Power Platform on the CLI, Part 2: Add the Marketplace and See What Each Plugin Does

In Part 1 we covered what an agentic CLI is and how a plugin folder is put together. Now let's actually pull down Microsoft's power-platform-skills marketplace and — the part people skip — learn to read a plugin so you understand what it does before you turn it loose.

As before, Copilot CLI and Claude Code commands run side by side.

Step 1: Register the marketplace

A marketplace is just a git repo. You point your CLI at microsoft/power-platform-skills and it fetches the catalog.

The simplest path — and the one Microsoft's README recommends — is the /plugin slash command from inside a running session. This is identical in both Copilot CLI and Claude Code:

/plugin marketplace add microsoft/power-platform-skills

If you prefer your normal shell, Copilot CLI also exposes the same thing as a subcommand:

# GitHub Copilot CLI (from your shell)
copilot plugin marketplace add microsoft/power-platform-skills

In Claude Code, marketplace management lives behind the /plugin slash command shown above; Claude Code's shell subcommands cover installing (claude plugin install …, shown below) rather than adding marketplaces.

You can point at a local clone or a non-GitHub git URL the same way — /plugin marketplace add /path/to/folder or /plugin marketplace add https://gitlab.com/owner/repo.git.

Confirm it registered (slash form works in both tools; Copilot also has the shell form):

/plugin marketplace list                 # in-session, both tools

copilot plugin marketplace list          # Copilot CLI, from your shell

Step 2: Browse what's inside

Before installing anything, see the catalog. In Copilot CLI, browse lists a marketplace's plugins from your shell; in Claude Code, run /plugin and use the Discover tab:

copilot plugin marketplace browse power-platform-skills   # Copilot CLI (shell)

/plugin                                                   # Claude Code → Discover tab

The power-platform-skills marketplace ships seven plugins. Their manifest names — the names you install by — are:

(Note the two mild gotchas: the code-apps plugin installs as code-apps-preview, and the mobile plugin installs as mobile-app, singular — even though their folders are code-apps and mobile-apps.)

Step 3: Install the plugins

The install syntax is PLUGIN@MARKETPLACE. To grab all seven:

# --- GitHub Copilot CLI ---
copilot plugin install power-pages@power-platform-skills
copilot plugin install model-apps@power-platform-skills
copilot plugin install mcp-apps@power-platform-skills
copilot plugin install canvas-apps@power-platform-skills
copilot plugin install code-apps-preview@power-platform-skills
copilot plugin install mobile-app@power-platform-skills
copilot plugin install power-automate@power-platform-skills

# --- Claude Code (same, swap the binary) ---
claude plugin install power-pages@power-platform-skills
claude plugin install model-apps@power-platform-skills
# ...and so on for the rest

Inside a session the slash-command form works too: /plugin install power-pages@power-platform-skills.

The one-liner shortcut

If you don't want to type seven commands, Microsoft ships an installer script that detects which CLI you have, installs the pac CLI if it's missing, registers the marketplace, installs all the plugins, and turns on auto-update:

# macOS / Linux / Windows (cmd)
curl -fsSL https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js | node

# Windows (PowerShell)
iwr https://raw.githubusercontent.com/microsoft/power-platform-skills/main/scripts/install.js -OutFile install.js; node install.js; del install.js

Verify what you've got (slash form works in both; Copilot also has the shell form):

/plugin list             # in-session, both tools

copilot plugin list      # Copilot CLI, from your shell

Step 4: See what a plugin actually does

This is the skill worth building. Every plugin is plain files, so you can open it and understand it. After install, the plugin lives under your CLI home — ~/.copilot/installed-plugins/power-platform-skills/power-pages/ for Copilot CLI, ~/.claude/plugins/... for Claude Code — or you can just browse the repo on GitHub. Three files tell you almost everything.

4a. plugin.json — the identity card

Start at the manifest. Here's the real one for power-pages (trimmed):

{
  "name": "power-pages",
  "version": "2.6.2",
  "description": "Create and deploy Power Pages sites using modern development approaches. Supports code sites (SPAs) with React, Angular, Vue, or Astro. Includes ALM orchestration (plan-alm) with a solution-splitting decision tree, per-solution pipelines, Azure Blob asset advisory, manifest schema v2 for multi-solution deployments, and force-link remediation for cross-host pipeline migrations.",
  "author": { "name": "Microsoft", "url": "https://www.microsoft.com" },
  "license": "MIT",
  "keywords": [
    "power-pages", "code-sites", "spa", "react", "angular", "vue", "astro",
    "pac-cli", "dataverse", "web-api", "solution", "alm", "plan-alm",
    "ci-cd", "pipeline", "force-link", "diagnostics"
  ]
}

In ten seconds you know the version, the supported frameworks, the fact that it does ALM and CI/CD, and that it leans on the pac CLI and Dataverse. The keywords array is a surprisingly good table of contents for a plugin's capabilities.

4b. .mcp.json — what external servers it uses

Next, check which MCP servers the plugin brings along. This tells you what the agent can reach beyond your files. Power Pages ships two:

{
  "mcpServers": {
    "playwright":      { "command": "node", "args": ["...launch-playwright-mcp.js..."] },
    "microsoft-learn": { "type": "http", "url": "https://learn.microsoft.com/api/mcp" }
  }
}

So this plugin can drive a real browser (Playwright — to open your site and verify its own work) and query the official Microsoft Learn docs over HTTP (so it grounds answers in current documentation instead of guessing). Other plugins declare different servers — canvas-apps launches a .NET-based Canvas Authoring MCP, power-automate launches its self-contained FlowAgent server. An empty or absent .mcp.json (like mcp-apps and code-apps) means the plugin works purely with local files and the CLI's built-in tools.

4c. skills/<name>/SKILL.md — the capabilities

Finally, the skills. List the skills/ folder and you get the plugin's menu. For power-pages that includes create-site, setup-datamodel, add-ai-webapi, integrate-webapi, setup-auth, create-webroles, audit-permissions, plan-alm, deploy-site, deploy-pipeline, diagnose-deployment, and about twenty more.

Open any skill's SKILL.md and read its front matter — that's the contract. Here's the top of create-site:

---
name: create-site
description: >-
  Creates a new Power Pages code site (SPA) using React, Angular, Vue, or Astro.
  Guides through the full process from initial concept to deployed site:
  requirements discovery, scaffolding, component planning, design,
  implementation, validation, and deployment. Use when the user wants to
  create, build, or scaffold a new Power Pages website or portal.
user-invocable: true
argument-hint: Optional site description
allowed-tools: Read, Write, Edit, Grep, Glob, Bash, WebSearch, AskUserQuestion,
  Task, mcp__plugin_power-pages_playwright__browser_navigate, ...
model: opus
---

Everything you'd want to know is right there:

• description — what it does and, importantly, when the agent will reach for it. The CLI matches your natural-language request against these descriptions to decide which skill to load.
• user-invocable: true — you can trigger it directly, not just let the agent pick it.
• allowed-tools — the exact set of tools the skill may use. Notice it can edit files, run shell commands, and drive the Playwright browser MCP, but that's the whole list. This is your permission boundary, in writing.
• model — which model tier the skill asks for.

Below the front matter is the actual instruction body — the step-by-step playbook the agent follows. It's readable Markdown. If you ever wonder "how is this going to build my site?", scroll down and read it.

The habit worth forming

Before running an unfamiliar plugin, open three files: plugin.json (what and which version), .mcp.json (what it can reach), and the SKILL.md of whatever you're about to invoke (what it'll do and what it's allowed to touch). It takes a minute and it's the difference between running an agent blind and running one you actually understand.

In Part 3 we'll do exactly that across all seven plugins — a guided tour of what each one builds, its stack, its standout skills, and the MCP servers behind it.

Sources: Finding & installing Copilot CLI plugins · power-platform-skills README