PackagingTools.Core 12.0.0

PackagingTools

Cross-platform .NET 10 packaging stack for building, signing, validating, and publishing Windows, macOS, and Linux application installers from a shared project model. PackagingTools combines an Avalonia desktop app, a .NET global tool, reusable SDK packages, and platform-specific engines so the same workflow can run locally or inside CI/CD.

NuGet Packages

Primary packages

Package	NuGet	Description
PackagingTools.Core		Shared orchestration engine, project model, policy services, security primitives, audit, and telemetry
PackagingTools.Core.Windows		Windows packaging providers for MSIX/MSI/App Installer flows, signing, and host integration
PackagingTools.Core.Mac		macOS packaging providers for .app, .pkg, .dmg, notarization, and entitlement workflows
PackagingTools.Core.Linux		Linux packaging providers for DEB/RPM/AppImage/Flatpak/Snap, repositories, SBOM, and vulnerability evidence
PackagingTools.Plugins		Extensibility contracts and helpers for runtime-loaded format, signing, policy, and telemetry plugins
PackagingTools.Sdk		High-level .NET client API for embedding PackagingTools orchestration into custom services and release systems
PackagingTools.Cli		.NET global tool for packaging runs, host integration automation, policy validation, and scripted release flows

src/PackagingTools.App is the desktop host and is intentionally not published as a NuGet package.

Solution Components

Supported Packaging Workflows

Features

• Shared project schema with JSON configuration consumed consistently by the app, CLI, SDK, and plugins. The schema lives at docs/configuration/schema.json.
• Policy-driven packaging through IPolicyEvaluator, allowing approval checks, signing requirements, SBOM rules, vulnerability thresholds, and retention constraints to block unsafe releases.
• Identity-aware operations via pluggable identity services and secure stores for certificates, tokens, provisioning materials, and signing secrets.
• Extensible packaging pipeline with plugin hooks for new formats, signing providers, telemetry sinks, vulnerability scanners, and organization-specific automation.
• Operational telemetry and audit trails through the dashboard aggregation model, diagnostics bundles, packaging evidence, and verification results.
• Local and CI parity so the same project definition, property model, and policy behavior apply on developer machines and in build pipelines.

Getting Started

1. Install the .NET 10 SDK and platform tooling described in Developer Onboarding.
2. Clone the repository and build the solution:

git clone https://github.com/wieslawsoltes/PackingingTools.git
cd PackingingTools
dotnet build PackagingTools.sln -c Release

3. Run the integration suite:

dotnet test tests/PackagingTools.IntegrationTests/PackagingTools.IntegrationTests.csproj -c Release

4. Produce NuGet artifacts locally:

dotnet pack PackagingTools.sln -c Release

Local packages are written to artifacts/nuget.

CLI Usage

During development you can run the CLI directly:

dotnet run --project src/PackagingTools.Cli -- pack \
  --project ./samples/sample-project.json \
  --platform windows \
  --format msix --format msi \
  --output ./artifacts/windows \
  --property windows.msix.payloadDirectory=./payload/win \
  --property windows.signing.certificatePath=certs/code-sign.pfx

After publishing, install the tool from NuGet:

dotnet tool install --global PackagingTools.Cli

Common commands:

• pack executes packaging pipelines for the selected platform and formats.
• host previews and applies Windows host integration metadata with diff-oriented output.
• identity login acquires and stores credentials for identity-aware packaging flows.

SDK Usage

PackagingTools.Sdk exposes the same orchestration model to custom services and automation hosts:

using PackagingTools.Core.Models;
using PackagingTools.Sdk;

var client = PackagingClient.CreateDefault();

var run = new PackagingRunOptions("./projects/sample.json", PackagingPlatform.Windows)
{
    Configuration = "Release",
    OutputDirectory = "./artifacts/windows"
};

run.Formats.Add("msi");
run.Properties["windows.signing.azureKeyVaultCertificate"] = "contoso-signing-cert";

var result = await client.PackAsync(run);

See docs/sdk/embedding-packagingtools.md for advanced composition and host customization.

CI/CD and Release Flow

• CI builds and tests the solution on Linux, macOS, and Windows, then packs all NuGet packages on Ubuntu and uploads both .nupkg and .snupkg artifacts.
• Release runs the same validation on tag pushes matching v*, packs all publishable projects with the tag version, pushes packages to NuGet.org when NUGET_API_KEY is configured, and creates a GitHub release with generated release notes.
• Reusable starter workflows for packaging jobs live under build/templates/github-actions/ and are documented in docs/ci/starter-templates.md.

Documentation

• Published documentation site
• Solution architecture
• Windows packaging suite
• Configuration guide
• Plugin configuration
• Identity architecture
• Security and SBOM architecture
• Packaging roadmap

Repository Layout

PackingingTools/
├── src/                # App, CLI, SDK, core libraries, platform engines, plugin contracts
├── build/              # Bootstrap scripts, tool checks, CI templates
├── docs/               # Architecture, onboarding, CI, security, identity, platform guidance
├── samples/            # Sample project definitions and payload references
├── tests/              # Integration coverage and scenario validation
└── tools/              # Auxiliary utilities and diagnostics

Contributing

Use the onboarding guide to set up the toolchain, then run dotnet build, dotnet test, and dotnet pack before opening a pull request. When changing packaging behavior, update the relevant docs and add integration coverage under tests/PackagingTools.IntegrationTests.