power-pages

Create and deploy Power Pages code sites using modern frontend frameworks. This plugin provides a complete workflow — from scaffolding a new site to deploying it, setting up data models, authentication, and Web API integrations — all through conversational AI skills.

Supported frameworks: React, Angular, Vue, Astro (static SPAs)

Installation

From the marketplace

/plugin marketplace add microsoft/power-platform-skills
/plugin install power-pages@power-platform-skills

From a local clone

claude --plugin-dir /path/to/power-platform-skills/plugins/power-pages

Hook behavior

The plugin centralizes Claude Code hook registration in hooks/hooks.json.

• PostToolUse hooks match the Skill tool so validation runs when a tracked Power Pages skill completes.
• Command validators and checklist verification are maintained centrally instead of in per-skill frontmatter.

This keeps hook behavior in one place and avoids relying on skill-frontmatter hook registration.

Prerequisites

Prerequisite	Required for	Install
Node.js (LTS)	All skills	winget install OpenJS.NodeJS.LTS
PAC CLI	Deploy, activate, data model	dotnet tool install -g Microsoft.PowerApps.CLI.Tool
Azure CLI	Data model, sample data, activation	winget install Microsoft.AzureCLI

Skills

The plugin provides 30 skills that cover the full lifecycle of a Power Pages code site — scaffolding, deployment, data modeling, backend integration, authentication, ALM and CI/CD, security review, testing, and auditing. Each skill is invoked conversationally — just describe what you want to do.

Site scaffolding and deployment

/create-site

"Create a Power Pages site with React for a job board"

Scaffolds a complete code site from a framework template, applies your design direction (fonts, colors, layout), builds out pages and components, and provides a live preview in the browser throughout development.

• Choose from React, Vue, Angular, or Astro
• Real images from Unsplash (no placeholders)
• Live browser preview during development
• Git commits at each milestone

/deploy-site

"Deploy my site to Power Pages"

Builds your project and uploads it to your Power Pages environment using pac pages upload-code-site. Handles common blockers like JavaScript attachment restrictions.

• Verifies PAC CLI installation and authentication
• Confirms target environment before deploying
• Creates .powerpages-site folder with deployment artifacts

/activate-site

"Activate my site"

Provisions a website record in your Power Platform environment so your site is accessible at a public URL.

• Generates a subdomain suggestion (you choose the final name)
• Polls provisioning status until the site is live
• Provides the final site URL

/test-site

"Test my deployed site at https://contoso.powerappsportals.com"

Runtime-tests a deployed, activated site using a real browser (via the bundled Playwright MCP). Crawls discoverable links, verifies pages render, captures network traffic for API calls, and produces a test report.

• Browser-based navigation and page crawling
• Network request verification for Web API / Server Logic / Cloud Flow endpoints
• Console and network error capture
• Screenshots on failure

Data modeling

/setup-datamodel

"Create Dataverse tables for my site"

Analyzes your site's requirements and creates Dataverse tables, columns, and relationships via OData API calls.

• Spawns a Data Model Architect agent that proposes tables based on your site's code
• Alternatively, you can upload an ER diagram
• Generates a .datamodel-manifest.json used by downstream skills
• Visualizes the data model as a Mermaid ER diagram

/add-sample-data

"Add sample data to my tables"

Populates your Dataverse tables with realistic, contextually appropriate records.

• Reads table definitions from .datamodel-manifest.json or queries OData metadata
• Generates values that match column types and names (emails, dates, currencies, etc.)
• Inserts records in dependency order (parent tables first)

Backend integration

/integrate-backend

"I need to send a confirmation email when someone submits the contact form"

Router skill that analyzes your business problem and recommends the right backend approach — Web API, Server Logic, Cloud Flow, or a combination — then hands off to the specialized skill(s). Use this as the entry point when you're not sure which integration path fits your scenario.

• Generates a visual backend plan (HTML) with the recommended approach and trade-offs
• Routes to /integrate-webapi, /add-server-logic, or /add-cloud-flow
• Supports multi-approach plans (e.g., Web API for CRUD + Cloud Flow for notifications)

/integrate-webapi

"Connect my site to the Dataverse tables"

Orchestrates the full Web API integration lifecycle — from analyzing your site's code to identify where data is needed, through generating typed API code for each table, to configuring table permissions and site settings so the APIs work in production.

The skill first scans your codebase to find components using mock data, placeholder fetch calls, or hardcoded arrays, then maps them to your Dataverse tables. It processes each table sequentially, spawning a dedicated Web API Integration agent that creates the integration code. After all tables are wired up, a Table Permissions agent proposes CRUD permissions and scopes, and a Web API Settings agent proposes site settings with case-sensitive validated column names queried directly from Dataverse — or you can upload your own permissions diagram instead.

What gets created:

• Shared powerPagesApi.ts client with anti-forgery token management, OData URL builder, and exponential backoff retry logic
• TypeScript entity types and domain mappers per table
• CRUD service layer per table using /_api/ endpoints with dual token headers and @odata.bind for lookups
• Framework-specific patterns: React hooks, Vue composables, Angular injectable services
• Table permission YAML files and site setting YAML files (with explicit validated column lists by default; use * only for aggregate OData scenarios that otherwise 403)

What gets updated:

• Existing components are refactored to use real API calls (mock data and placeholder fetches are replaced)
• .powerpages-site/table-permissions/ and .powerpages-site/site-settings/ directories are populated for deployment

/add-ai-webapi

"Add AI summaries to my site"

Integrates Power Pages generative-AI summarization APIs into a Single Page Application (SPA) site: the Search Summary API (/_api/search/v1.0/summary) and the Data Summarization API (/_api/summarization/data/v1.0/...). Data Summarization can be configured for any record-detail or list page; Microsoft documents one ready-made recipe for a Copilot-style summary on a support-case detail page (incident table with $select=description,title and the portal-comments expand) — that recipe is available as a maker pick, not an automatic recommendation.

The skill scans your code for search pages and record-detail / list pages and proposes which APIs to wire where. For any Data Summarization target that is missing its Web API prerequisites (Layer 1 Webapi/<table>/* settings, Layer 2 table permissions, or the shared powerPagesApi.ts client), the skill delegates to /integrate-webapi in an AI-only read mode — read-only permissions, minimal fields list (no primary key, only _<col>_value for lookups) — and to /create-webroles if no web role exists yet. Once Layer 1/2 is in place, the skill spawns the AI Web API Integration agent sequentially per target to create a single summarization service (fetchSearchSummary, fetchDataSummary) with correct CSRF handling, a framework-idiomatic wrapper, and real UI call sites. Finally, the AI Web API Settings Architect is invoked for Layer 3 to propose the Summarization/Data/Enable toggle and per-prompt Summarization/prompt/<identifier> settings.

What gets created:

• src/services/aiSummaryService.ts (or extended if it already exists) with raw fetch + both required CSRF headers
• Framework-specific wrapper (React hook / Vue composable / Angular service)
• Real call sites in the target page(s) with loading, error, and recommendation-button handling
• Summarization/Data/Enable site setting and one Summarization/prompt/<identifier> per prompt
• Webapi/<table>/enabled / Webapi/<table>/fields, read-only table permissions, and the shared powerPagesApi.ts client for the summarised tables and every $expand target (delegated to /integrate-webapi)

/add-server-logic

"Move my pricing calculation out of the browser and onto the server"

Creates and manages Power Pages Server Logic — server-side JavaScript that runs securely on the Power Pages runtime. Covers the full lifecycle: gathering requirements, fetching Microsoft Learn docs for reference, implementing the handler, configuring site settings, and deploying.

• Grounded in live Microsoft Learn docs (via the bundled MCP)
• Generates the server-side handler and its deployment metadata
• Wires up the client-side call site in your frontend code
• Handles site-setting flags required to enable Server Logic

/add-cloud-flow

"When a user submits an application, kick off my existing approval flow"

Integrates Power Automate cloud flows into a Power Pages site. Discovers flows available in the environment, suggests relevant ones for your intent, identifies scenarios and web roles, creates flow metadata, and generates the client-side code to invoke the flow.

• Lists available cloud flows in the environment
• Handles both new flow registration and adding already-registered flows to additional pages
• Generates metadata files and client-side call-site code
• Configures web role access for the flow

Security and access

/create-webroles

"Create web roles for my site"

Generates web role YAML files in your .powerpages-site directory for managing user access.

• Discovers existing roles before creating new ones
• Generates proper UUIDs for each role
• Enforces uniqueness constraints (one anonymous role, one authenticated role)

/setup-auth

"Set up authentication for my site"

Adds login/logout functionality and role-based authorization to your site.

• Auth service with anti-forgery token handling
• Login/logout UI component
• Role-based UI patterns (show/hide elements by role)
• Framework-specific implementation (hooks, composables, services)

/audit-permissions

"Check my table permissions for security issues"

Audits existing table permissions on a deployed or in-progress site by analyzing them against the site code and live Dataverse metadata. Produces a visual HTML audit report grouped by severity with suggested fixes.

• Findings grouped as critical / warning / info / pass
• Cross-references code usage, web roles, and Dataverse schema
• Suggests concrete fixes for each issue

/scan-site

"Scan my production site for vulnerabilities"

Runs a security scan on a deployed Power Pages site, fetches the latest scan report, and produces a plain-language summary of vulnerabilities by severity.

• Scans the live site's public surface for vulnerabilities
• Fetches and explains the latest scan report
• Surfaces issues grouped by severity

/manage-firewall

"Block traffic from a specific country and add a rate limit to /login"

Inspects and configures the web application firewall (WAF) in front of a Power Pages production site. Walks you through enabling protection and managing custom rules.

• Lists current WAF state and recommends enabling protection when off
• Adds, updates, or removes custom rules — IP blocks, country blocks, path blocks, rate limits
• Protects pages from brute-force attempts and bot traffic

/manage-headers

"Fix my CSP errors and harden cookie settings"

Inspects and configures the security headers a Power Pages site sends to browsers — Content Security Policy, frame and clickjacking protection, cross-origin sharing, cookie behavior, and related site settings.

• Identifies gaps in browser security headers
• Walks through fixes for CSP, CORS, cookies, and embedding policy
• Updates the corresponding site settings

/security-review

"Do a full security review before we ship"

Runs a guided, end-to-end security review of a Power Pages site and consolidates every finding into one HTML report covering the live site, browser headers, firewall, authentication, and role-based permissions.

• Orchestrates /scan-site, /manage-headers, /manage-firewall, /audit-permissions, and auth checks
• Consolidates findings into a single HTML report
• Suitable for release-readiness or live-site monitoring

ALM and CI/CD

/plan-alm

"Plan how to promote this site to staging and production"

Planner skill that creates an ALM (Application Lifecycle Management) plan for deploying a Power Pages site across environments. Gathers your promotion strategy, target environments, and approval requirements, then generates a visual HTML plan for your review and approval. It does not deploy anything itself — after you approve the plan, you run the individual ALM skills, which detect the plan and execute the right step in order.

• Detects project state (config, manifests, current environment)
• Branched flow for Power Platform Pipelines or manual export/import
• Generates docs/alm-plan.html for review and approval (the recommended execution sequence is the plan of record)
• Recommends the skill sequence to run next — setup-solution, setup-pipeline/export-solution, deploy-pipeline/import-solution — each of which detects this plan, proceeds, and keeps it updated as it runs

[!TIP] /plan-alm is the front door for any ALM intent — run it first to produce the plan. It plans only; you then run the execution skills it recommends. Use it instead of jumping straight to individual ALM skills when you want to deploy to staging, ship to production, or set up CI/CD.

/setup-solution

"Package my site into a solution for ALM"

Creates a Dataverse publisher and solution, then adds Power Pages site components to the solution for ALM and deployment management.

• Creates publisher and solution via OData API (with duplicate detection)
• Adds website and web role components via AddSolutionComponent
• Writes .solution-manifest.json for downstream skills
• Publisher prefix is irreversible — requires explicit confirmation

/export-solution

"Export the solution as a zip for deployment"

Exports a Dataverse solution containing Power Pages site components as a zip file, ready for deployment to another environment.

• Choose managed (locked for downstream environments) or unmanaged (editable)
• Triggers ExportSolutionAsync and polls until complete
• Bumps the solution version on every export so each zip is strictly increasing
• Verifies the zip contains a valid Solution.xml

/import-solution

"Import this solution zip into the staging environment"

Imports a Dataverse solution zip into a target environment, with optional staged import for dependency checking before committing.

• Optional StageSolution pre-flight to detect missing dependencies
• ImportSolutionAsync with polling until complete
• Writes docs/alm/last-import.json marker
• Surfaces per-component import results

/setup-pipeline

"Set up a Power Platform Pipeline for automated deployments"

Sets up a Power Platform Pipeline for automated Power Pages deployments. Power Platform Pipelines is Microsoft's native CI/CD tool built into the platform — no external infrastructure required.

• Auto-discovers host environment via RetrieveSetting('DefaultCustomPipelinesHostEnvForTenant')
• Creates deploymentenvironments, deploymentpipelines, and deploymentstages records
• GitHub Actions and Azure DevOps platforms show coming-soon guidance
• Writes docs/alm/last-pipeline.json and docs/pipeline-setup.md

/deploy-pipeline

"Deploy the site to staging via my pipeline"

Triggers a Power Platform Pipeline deployment run for a Power Pages solution. Validates the package, optionally configures deployment settings, then deploys and polls for completion.

• Pre-flight check on blockedattachments to proactively unblock .js/.css (saves a wasted ~60-min import)
• ValidatePackageAsync before deploying surfaces validation issues early
• Optional environment variable / connection reference overrides per stage
• Final consent gate before the deploy actually fires

/ensure-pipelines-host

"Make sure my tenant has a Power Platform Pipelines host"

Ensures the tenant has a usable Power Platform Pipelines host environment before any pipeline operation runs. Detects host state via the same resolution order as the Power Apps UI; if no host is bound, provisions a new Platform Host (recommended, idempotent) or guides through a Custom Host install.

• Detects host state from org-db setting, BAP env metadata, or default-custom-host setting
• Idempotent Platform Host fast-path (~3–5 min)
• Custom Host fast-path or manual PPAC install fallback
• Writes a host-check artifact other ALM skills consume

/force-link-environment

"This environment is already linked to another pipelines host — force-link it"

Force-links a development or target environment to a Power Platform Pipelines host, overriding any existing association with a previous host. Calls the documented ManageEnvironmentStamp Dataverse action (the API behind the "Force Link" button in the Deployment Pipeline Configuration app).

• Use when you hit "environment is already associated with another pipelines host"
• Required explicit consent gate — destructive to the previous host (makers lose pipeline access)
• Reversible by re-running from the previous host
• Writes docs/alm/last-force-link.json

/configure-env-variables

"Make these site settings environment-specific so they differ between dev and prod"

Configures environment variables for Power Pages site settings to support ALM across environments. Creates environment variable definitions in Dataverse, guides you through linking site settings via the Power Pages Management app, adds the variables to the solution, and generates a deployment-settings.json file with per-stage override values.

• Creates environmentvariabledefinition records (String or Secret type)
• Generates deployment-settings.json ready for deploy-pipeline to consume
• Routes credentials (ClientSecret, ConsumerKey, etc.) to Key Vault-backed secret env vars

/diagnose-deployment

"My last deploy failed — figure out why"

Surfaces PAC CLI upload errors and Dataverse async operation errors, pattern-matches against a known failure catalog, and optionally auto-fixes identified issues.

• Re-runs pac pages upload-code-site in capture mode to surface upload errors
• Queries recent Dataverse async operation failures
• Pattern matches against references/deployment-error-catalog.md
• Offers auto-fixes with explicit per-fix user confirmation

Polish

/add-seo

"Add SEO to my site"

Adds search engine optimization artifacts: robots.txt, sitemap.xml, and meta tags (Open Graph, Twitter Cards).

• Auto-discovers routes from your framework's router
• Generates sitemap with production URLs
• Adds viewport, charset, description, and social sharing meta tags

Support

/report-issue

"Report a bug with the create-site skill"

Collects context about the current session and opens a pre-filled GitHub issue against microsoft/power-platform-skills.

• Captures the skill(s) involved and recent error messages
• Attaches relevant file paths and environment info
• Opens the issue in your browser for final review

/telemetry

"Turn off telemetry" · "Disable telemetry" · "Telemetry status"

Enables, disables, or checks the status of anonymous usage telemetry. Per-user and per-plugin; the choice is stored in ~/.power-platform-skills/config.json. See Telemetry & privacy below.

• /power-pages:telemetry status — show the current setting
• /power-pages:telemetry off — stop sending telemetry (nothing leaves your machine)
• /power-pages:telemetry on — resume sending telemetry
• No personal data is ever collected (anonymous: skill name, plugin version, OS, Node version)
• Automation/CI: set POWER_PLATFORM_SKILLS_TELEMETRY_POWER_PAGES_OPTOUT=1 to disable (highest precedence — overrides any saved choice)

Agents

The plugin includes 6 specialized agents that are spawned automatically by skills when needed:

Agent	Purpose	Triggered by
Data Model Architect	Analyzes your site and proposes a Dataverse data model with an ER diagram	/setup-datamodel
Web API Integration	Creates typed API client, services, and hooks for a Dataverse table	/integrate-webapi (directly); /add-ai-webapi (transitively, when it delegates)
Table Permissions	Proposes table permissions (web roles, CRUD flags, scopes) with a visual Mermaid diagram	/integrate-webapi (directly); /add-ai-webapi (transitively, in AI-only read mode); /audit-permissions
Web API Settings	Proposes Web API site settings with case-sensitive validated column names from Dataverse	/integrate-webapi (directly); /add-ai-webapi (transitively, in AI-only read mode)
AI Web API Integration	Creates raw-fetch summarization service with CSRF, framework wrapper, and UI wiring	/add-ai-webapi
AI Web API Settings Architect	Proposes Summarization/Data/Enable and maker-defined Summarization/prompt/<identifier> site settings	/add-ai-webapi

The Data Model Architect, Table Permissions, and Web API Settings agents are read-only — they analyze and propose but never create or modify resources directly. You review and approve their proposals before any changes are made.

Bundled MCP servers

The plugin ships with two MCP servers configured in .mcp.json — they start automatically when the plugin loads:

Server	Purpose
playwright	Headless browser automation for live previews and runtime tests
microsoft-learn	Grounded search/fetch over official Microsoft Learn docs

Typical Workflow

A common end-to-end workflow looks like this:

1.  /create-site            →  Scaffold + design + build pages
2.  /deploy-site            →  Upload to Power Pages environment
3.  /activate-site          →  Provision a public URL
4.  /setup-datamodel        →  Create Dataverse tables
5.  /add-sample-data        →  Populate tables with test records
6.  /integrate-backend      →  Pick the right backend approach (Web API / Server Logic / Cloud Flow)
7.  /add-ai-webapi          →  Wire Copilot / search / data summarization APIs into pages
8.  /create-webroles        →  Define access roles
9.  /setup-auth             →  Add login/logout + role-based UI
10. /audit-permissions      →  Verify table permissions are safe
11. /add-seo                →  Search engine optimization
12. /deploy-site            →  Push final changes live
13. /test-site              →  Runtime smoke test on the live URL
14. /security-review        →  Full security review (headers, firewall, scan, permissions)
15. /plan-alm               →  Plan multi-environment promotion (planning only — produces the plan)
16. /setup-solution         →  Package the site into a Dataverse solution
17. /setup-pipeline         →  Set up the Power Platform pipeline
18. /deploy-pipeline        →  Promote through staging → production (run per stage)

Steps 16–18 are the execution sequence /plan-alm recommends — you run them yourself; each detects the approved plan and keeps it updated. /plan-alm never runs them for you.

Steps can be run independently — you don't need to follow this exact order. Each skill checks its own prerequisites and will tell you if something is missing. If something goes wrong, /diagnose-deployment pattern-matches deployment errors and /report-issue opens a pre-filled GitHub issue.

Running Without Interruption

The plugin invokes multiple tools during a session. To reduce approval prompts:

Option 1 — Permission mode (recommended)

// .claude/settings.json
{
  "defaultMode": "acceptEdits",
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git *)",
      "Bash(pac *)",
      "Bash(az *)",
      "Bash(node *)"
    ]
  }
}

Option 2 — Auto-accept all

claude --dangerously-skip-permissions

ALM prompts you may see

Several skills now ask about solution identity, orphan components, and pre-export completeness. These prompts catch a real class of bugs where Dataverse records silently stay behind in the Default solution. See references/alm-prompts.md for a user-facing walkthrough of each prompt and how to respond.

Documentation

• Power Pages AI Plugin Documentation
• Power Pages Code Sites
• PAC CLI Reference
• Power Pages REST API
• Dataverse Web API
• ALM prompts — user guide

Testing validator scripts

Run the validator unit tests with Node's built-in test runner:

node --test plugins/power-pages/scripts/tests/

To validate table-permission relationship names against live Dataverse metadata during local testing, run:

node plugins/power-pages/scripts/validate-permissions-schema.js --projectRoot /path/to/site --validate-dataverse-relationships --envUrl https://your-org.crm.dynamics.com

This Dataverse relationship check is intended for local validation only and should not be used in CI.

Telemetry & privacy

This plugin sends anonymous usage telemetry by default to help Microsoft improve it. No personal data is ever collected — only things like skill name, plugin version, OS, and Node version. It never includes file paths, prompts, tool inputs, site names, URLs, credentials, usernames, or hostnames.

Turn it on or off (per-user, applies to every project):

/power-pages:telemetry status   # show the current setting
/power-pages:telemetry off      # stop sending telemetry
/power-pages:telemetry on       # resume sending telemetry

When off, nothing leaves your machine. A local diagnostic copy of each event is still written under ~/.power-platform-skills/telemetry/power-pages/sessions/<sessionId>/events.jsonl so you can see exactly what would have been sent; delete it anytime. Run /power-pages:telemetry status to see the logs directory and the most recent session file. The setting is stored at ~/.power-platform-skills/config.json ({ "telemetry": { "power-pages": "off" } }).

For automation / CI, set the per-plugin opt-out environment variable instead of editing that file:

POWER_PLATFORM_SKILLS_TELEMETRY_POWER_PAGES_OPTOUT=1   # stop sending telemetry

Set it to 1 or true (dotnet *_TELEMETRY_OPTOUT convention). This opt-out has the highest precedence — it overrides a saved /power-pages:telemetry choice and even /power-pages:telemetry on. Like off from the command, it suppresses transmission only — the local per-session events.jsonl mirror is still written.

License

MIT