Packager-MCP Server

Packager-MCP is an MCP server that empowers your AI assistant to transform packaging tasks into complete Windows application deployment packages for Intune. By exposing specialized tools, resources, and prompts, you can ask your AI to search Winget, generate PSADT v4.1.7 deployment scripts, create detection rules, and validate your package, all in one guided workflow.

How to use

Connect an MCP-compatible AI client to the Packager-MCP server to start packaging workflows. You will access a set of tools that automate searching for installers, generating deployment scripts, and validating the final package. Use the three guided workflows to package apps, troubleshoot issues, or convert older scripts to the current format. When you ask the agent to package an app, it will fetch metadata, determine silent install arguments, generate a PSADT v4 script, craft Intune detection rules, and validate the result.

Typical end-to-end workflow: you request to package an app, the agent searches Winget for metadata, retrieves silent install arguments, generates a PSADT script, creates detection rules, and runs validation to ensure best practices are met. You can also troubleshoot failures by error code and log analysis, perform bulk lookups for multiple apps, or convert legacy PSADT v3 scripts to v4 format.

How to install

Prerequisites you need before installing the Packager-MCP server:

• Node.js 20 or higher
• A MCP-compatible AI client (Claude CLI recommended)
• GitHub Token (recommended) to increase Winget API rate limits

Install and set up the server locally by following these steps. Each command is a separate line so you can copy-paste easily.

# Install prerequisites (if not already installed)
winget install git.git
winget install OpenJS.NodeJS.LTS

# Clone the repository
git clone https://github.com/kkaminsk/Packager-MCP.git
cd Packager-MCP

# Install dependencies
npm install

# Build the project
npm run build

Configure MCP client connection (stdio)

The server is intended to run as a local, stdio-based MCP server. Use the following command configuration in your MCP client to start the server and pass the GitHub token when needed.

{
  "mcpServers": {
    "packager-mcp": {
      "command": "node",
      "args": ["C:/path/to/Packager-MCP/dist/server.js"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    }
  }
}

Verify It’s Working

After adding the server to your MCP client, you should see packager-mcp listed among available servers. The server provides six tools, eleven resources, and four prompts. You can ask the agent to perform a packaging task to confirm everything is wired correctly.

Notes on usage

The server relies on Winget metadata and PSADT v4.1.7 toolkit files to build deployment packages. The PSADT toolkit files are bundled under dist/knowledge/v4github/ and should be copied into your package directory when you prepare a deployment package.

Configuration and knowledge

Key knowledge sources embedded in the server include PSADT documentation, installer guides, packaging patterns for detection and prerequisites, and a reference of silent install arguments and exit codes. You will access these through the built-in resources and prompts to guide you through each packaging step.

Troubleshooting

If you encounter rate limit issues with Winget, ensure you provide a GitHub token to increase API access. If a package can’t be found, broaden your Winget search or check partial names. If the MCP connection drops, re-add the server to your client with the stdio configuration. If building fails, reinstall dependencies and rebuild.

Development

To run in development mode, use the project’s development commands to start a watcher and test changes. Use the unit and knowledge validation workflows to ensure accuracy of the knowledge base and tooling.

How it works under the hood

Claude CLI or another MCP client communicates with Packager-MCP to perform packaging tasks. The server queries Winget for installer metadata, generates PSADT v4 scripts from templates and knowledge, and returns a finished package plan that includes deployment scripts and Intune detection rules.