EDM (enhanced/standard data-model) Power Pages site support in ALM discovery

Enhanced data-model sites are downloaded with `pac pages download` (not
download-code-site): they have NO `powerpages.config.json` and no SPA build output —
just `.powerpages-site/` with a config tree + `website.yml`. The shared discovery
helpers hard-required `powerpages.config.json`, so every ALM skill broke on EDM sites.

- `findProjectRoot` (validation-helpers.js): treats a `.powerpages-site/` directory as
  a project-root marker, not just `powerpages.config.json`.
- `detect-project-context.js`: falls back to `.powerpages-site/website.yml`
  (`id`→websiteRecordId, `name`→siteName) when no `powerpages.config.json`; returns a
  new `siteType` ("code" | "data-model"); exits 1 only when neither marker exists.
- `check-activation-status.js`: same fallback (verified live against an EDM site →
  resolves identity + activation status instead of erroring).

Backward-compatible: `powerpages.config.json` stays the primary signal for code sites.

PR 2 of 4 (stacked, on plan-alm-plan-only).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: tyaginidhi

plugins/power-pages/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "power-pages",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "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",

plugins/power-pages/AGENTS.md

@@ -196,7 +196,7 @@ Shared lib modules live at `scripts/lib/` and are imported by other scripts via
 #### ALM Prerequisites & Context
 
 - `scripts/lib/verify-alm-prerequisites.js`: Verifies all prerequisites for ALM skills — PAC CLI installed + authenticated (`pac env who`), Azure CLI installed + logged in, Dataverse API reachable (`WhoAmI`). Args: `--envUrl` (opt, overrides env from PAC CLI), `--require-manifest` (fails if `.solution-manifest.json` not found). Output: `{ envUrl, token, userId, organizationId, tenantId }`. Exit 0 on success, exit 1 on any failure. Used by `setup-solution`, `export-solution`, `import-solution`, `setup-pipeline`, `deploy-pipeline`, `plan-alm`.
-- `scripts/lib/detect-project-context.js`: Reads Power Pages project context files from the project root — `powerpages.config.json`, `.solution-manifest.json`, and `.datamodel-manifest.json`. Args: `--projectRoot` (opt, auto-discovered from cwd if omitted). Output: `{ projectRoot, siteName, websiteRecordId, environmentUrl, solutionManifest, datamodelManifest }`. Exit 0 on success, exit 1 if `powerpages.config.json` not found.
+- `scripts/lib/detect-project-context.js`: Reads Power Pages project context from the project root. Resolves site identity in order: (1) `powerpages.config.json` → `siteType: "code"` (SPA sites); (2) `.powerpages-site/website.yml` → `siteType: "data-model"` (standard/enhanced data-model "EDM" sites, which have **no** `powerpages.config.json` — `id`→`websiteRecordId`, `name`→`siteName`, `environmentUrl: null` since the local files carry no env URL). Also reads `.solution-manifest.json` and `.datamodel-manifest.json`. Args: `--projectRoot` (opt, auto-discovered from cwd if omitted). Output: `{ projectRoot, siteType, siteName, websiteRecordId, environmentUrl, solutionManifest, datamodelManifest }`. Exit 0 on success, exit 1 only if **neither** `powerpages.config.json` nor `.powerpages-site/website.yml` is found. Note: `findProjectRoot` (in `validation-helpers.js`) likewise treats a `.powerpages-site/` directory as a project-root marker, not just `powerpages.config.json`, so data-model sites are discoverable.
 - `scripts/lib/alm-paths.js`: Single source of truth for ALM artifact paths. Exports `ALM_DIR` (always `docs/alm`), `FILE_NAMES` (frozen object mapping logical key → filename for all 14 ALM artifacts), `almDir(projectRoot) → path`, `almPath(projectRoot, key) → path`, `ensureAlmDir(projectRoot) → path` (mkdir -p idempotent). Every ALM-only state file (5 plan/decision JSONs + 9 `last-*.json` skill-run markers including `last-export.json`) writes under `<projectRoot>/docs/alm/`. **Always resolve through this helper** — never inline a raw `docs/alm/...` path in a script. Files intentionally NOT moved here (and not in `FILE_NAMES`): `.solution-manifest.json`, `.datamodel-manifest.json`, `.alm-config.json`, `.alm-deferred`, `deployment-settings.json`. Adding a new ALM marker means adding its key + filename to `FILE_NAMES` first; `almPath` throws on unknown keys to catch typos at call-site.
 - `scripts/lib/check-alm-plan.js`: Phase 0 gate helper used by every ALM skill to detect (a) whether an ALM plan exists for this project, (b) whether the user has explicitly deferred ALM via the `.alm-deferred` marker, and (c) whether an existing plan is stale (the source solution was modified after the plan was generated). Args: `--projectRoot`, `--envUrl` (opt — required for staleness check), `--token` (opt), `--solutionId` (opt — required for staleness check). Output: `{ exists, deferred, deferral, planPath, htmlPath, stale, staleness: { reason, detail }, generatedAt, planStatus, solution: {...} }`. Without env/solution context the helper does an existence-only check; with them it queries Dataverse for `solutions(solutionId)?$select=modifiedon` and compares against `planData.generatedAt`. Used by `setup-solution`, `setup-pipeline`, `deploy-pipeline`, `export-solution`, `import-solution`, `configure-env-variables`, `ensure-pipelines-host`, `force-link-environment` Phase 0 gates — the "fail closed when no plan" pattern.
 - `scripts/lib/resolve-target-solution.js`: Resolves "which solution should this new Dataverse record land in?" Implements the strict 3-step order from the ALM-aware-by-default principle: (1) explicit `--solutionUniqueName` (or equivalent caller arg) wins; (2) `.solution-manifest.json` in the project root; (3) neither → throw `NoSolutionConfiguredError`. **The module NEVER auto-picks from Dataverse** — interactive prompt UX is the caller's responsibility (catch the error, present an `AskUserQuestion` list, re-invoke with `explicit` populated). Callers that need to confirm the solution still exists in Dataverse can pass `verifyExists: true`; the module then enriches the result with `{ solutionId, version, ismanaged }`. Component-creation scripts must require this helper and pass through `--solutionUniqueName` so records land in the user's solution instead of `Default`.

plugins/power-pages/scripts/check-activation-status.js

@@ -16,6 +16,7 @@ const fs = require('fs');
 const path = require('path');
 const { execSync } = require('child_process');
 const { findPath, getPacAuthInfo, getAuthToken, makeRequest, CLOUD_TO_API } = require('./lib/validation-helpers');
+const { readWebsiteYml } = require('./lib/detect-project-context');
 
 function output(obj) {
   process.stdout.write(JSON.stringify(obj));
@@ -27,26 +28,36 @@ const args = process.argv.slice(2);
 const rootIdx = args.indexOf('--projectRoot');
 const projectRoot = rootIdx !== -1 ? args[rootIdx + 1] : process.cwd();
 
-// --- Read siteName from powerpages.config.json ---
-const configPath = findPath(projectRoot, 'powerpages.config.json');
-if (!configPath) {
-  output({ error: 'powerpages.config.json not found' });
-}
-
+// --- Read site identity from powerpages.config.json (code/SPA sites) OR
+//     .powerpages-site/website.yml (data-model / enhanced data model "EDM" sites,
+//     which have no powerpages.config.json). website.yml carries both the site
+//     name and the website GUID, so EDM sites skip the pac-pages-list lookup below. ---
 let siteName;
-try {
-  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-  siteName = config.siteName;
-} catch {
-  output({ error: 'Failed to parse powerpages.config.json' });
+let websiteRecordId = null;
+const configPath = findPath(projectRoot, 'powerpages.config.json');
+if (configPath) {
+  try {
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    siteName = config.siteName;
+    websiteRecordId = config.websiteRecordId || null;
+  } catch {
+    output({ error: 'Failed to parse powerpages.config.json' });
+  }
+} else {
+  const websiteYmlPath = findPath(projectRoot, path.join('.powerpages-site', 'website.yml'));
+  const site = websiteYmlPath ? readWebsiteYml(websiteYmlPath) : null;
+  if (site) {
+    siteName = site.name;
+    websiteRecordId = site.id || null;
+  }
 }
 if (!siteName) {
-  output({ error: 'siteName not found in powerpages.config.json' });
+  output({ error: 'Site name not found — looked in powerpages.config.json and .powerpages-site/website.yml' });
 }
 
-// --- Get websiteRecordId from pac pages list ---
-let websiteRecordId = null;
-try {
+// --- Get websiteRecordId from pac pages list (only when not already known,
+//     e.g. a code site whose config omitted it). EDM sites already have it from website.yml. ---
+if (!websiteRecordId) try {
   const pacOutput = execSync('pac pages list', { encoding: 'utf8', timeout: 15000 });
   // pac pages list outputs a table with columns. Find the row matching siteName.
   // Column headers vary but Website Record ID is always a GUID column.

plugins/power-pages/scripts/lib/detect-project-context.js

@@ -1,7 +1,17 @@
 #!/usr/bin/env node
 
 // Reads Power Pages project context files from the project root.
-// Locates powerpages.config.json, .solution-manifest.json, and .datamodel-manifest.json.
+// Locates powerpages.config.json (code/SPA sites) OR .powerpages-site/website.yml
+// (data-model config sites, standard and enhanced data model), plus
+// .solution-manifest.json and .datamodel-manifest.json.
+//
+// Site identity resolution order (first match wins):
+//   1. powerpages.config.json  -> siteType "code"  (SPA sites; has siteName,
+//                                  websiteRecordId, environmentUrl)
+//   2. .powerpages-site/website.yml -> siteType "data-model"  (enhanced/standard
+//                                  data-model sites from `pac pages download`; the
+//                                  YAML carries `id` and `name`, but no environment URL —
+//                                  callers re-confirm the env via `pac env who`)
 //
 // Usage: node detect-project-context.js [--projectRoot <path>]
 //
@@ -11,14 +21,16 @@
 // Output (JSON to stdout):
 //   {
 //     "projectRoot": "...",
+//     "siteType": "code" | "data-model",
 //     "siteName": "...",
 //     "websiteRecordId": "...",
-//     "environmentUrl": "...",
+//     "environmentUrl": "..." | null,
 //     "solutionManifest": { ... } | null,
 //     "datamodelManifest": { ... } | null
 //   }
 //
-// Exit 0 on success, exit 1 if powerpages.config.json not found.
+// Exit 0 on success, exit 1 if neither powerpages.config.json nor
+// .powerpages-site/website.yml is found (not a Power Pages project).
 
 'use strict';
 
@@ -45,6 +57,32 @@ function readJsonFile(filePath) {
   }
 }
 
+// Minimal reader for the flat `.powerpages-site/website.yml` (a simple `key: value`
+// per line — no nesting). Returns { id, name } or null. Zero-dependency by design
+// (the plugin ships no YAML library); only the two identity keys are needed here.
+function readWebsiteYml(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf8');
+  } catch {
+    return null;
+  }
+  const out = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const m = /^([A-Za-z0-9_]+):\s*(.*)$/.exec(line);
+    if (!m) continue;
+    const key = m[1];
+    let value = m[2].trim();
+    // Strip surrounding quotes a YAML writer may add.
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+      value = value.slice(1, -1);
+    }
+    if (key === 'id' || key === 'name') out[key] = value;
+  }
+  return (out.id || out.name) ? out : null;
+}
+
 function detectProjectContext(options = {}) {
   const startDir = options.projectRoot || process.cwd();
   const projectRoot = options.projectRoot
@@ -53,31 +91,57 @@ function detectProjectContext(options = {}) {
 
   if (!projectRoot) {
     throw new Error(
-      'powerpages.config.json not found. Run this command from a Power Pages project directory.'
+      'No Power Pages project found. Run this command from a site project directory ' +
+      '(one containing powerpages.config.json for a code site, or .powerpages-site/ ' +
+      'for a data-model site).'
     );
   }
 
+  const solutionManifest = readJsonFile(path.join(projectRoot, '.solution-manifest.json'));
+  const datamodelManifest = readJsonFile(path.join(projectRoot, '.datamodel-manifest.json'));
+
+  // 1. Code/SPA site — powerpages.config.json is the source of truth.
   const configPath = path.join(projectRoot, 'powerpages.config.json');
-  if (!fs.existsSync(configPath)) {
-    throw new Error(`powerpages.config.json not found at: ${configPath}`);
+  if (fs.existsSync(configPath)) {
+    const config = readJsonFile(configPath);
+    if (!config) {
+      throw new Error(`Failed to parse powerpages.config.json at: ${configPath}`);
+    }
+    return {
+      projectRoot,
+      siteType: 'code',
+      siteName: config.siteName || null,
+      websiteRecordId: config.websiteRecordId || null,
+      environmentUrl: config.environmentUrl || null,
+      solutionManifest,
+      datamodelManifest,
+    };
   }
 
-  const config = readJsonFile(configPath);
-  if (!config) {
-    throw new Error(`Failed to parse powerpages.config.json at: ${configPath}`);
+  // 2. Data-model (standard/enhanced) site — identity comes from
+  //    .powerpages-site/website.yml (`id` -> websiteRecordId, `name` -> siteName).
+  //    There is no environment URL in the local files; callers re-confirm via `pac env who`.
+  const websiteYmlPath = path.join(projectRoot, '.powerpages-site', 'website.yml');
+  if (fs.existsSync(websiteYmlPath)) {
+    const site = readWebsiteYml(websiteYmlPath);
+    if (!site) {
+      throw new Error(`Could not read site id/name from: ${websiteYmlPath}`);
+    }
+    return {
+      projectRoot,
+      siteType: 'data-model',
+      siteName: site.name || null,
+      websiteRecordId: site.id || null,
+      environmentUrl: null,
+      solutionManifest,
+      datamodelManifest,
+    };
   }
 
-  const solutionManifest = readJsonFile(path.join(projectRoot, '.solution-manifest.json'));
-  const datamodelManifest = readJsonFile(path.join(projectRoot, '.datamodel-manifest.json'));
-
-  return {
-    projectRoot,
-    siteName: config.siteName || null,
-    websiteRecordId: config.websiteRecordId || null,
-    environmentUrl: config.environmentUrl || null,
-    solutionManifest,
-    datamodelManifest,
-  };
+  throw new Error(
+    `No site identity found at ${projectRoot}: neither powerpages.config.json nor ` +
+    '.powerpages-site/website.yml is present.'
+  );
 }
 
 // CLI entry point
@@ -94,4 +158,4 @@ if (require.main === module) {
   }
 }
 
-module.exports = { detectProjectContext };
+module.exports = { detectProjectContext, readWebsiteYml };

plugins/power-pages/scripts/lib/validation-helpers.js

@@ -89,14 +89,23 @@ function findPath(dir, target) {
 }
 
 /**
- * Finds the project root directory (containing powerpages.config.json).
+ * Finds the project root directory of a Power Pages site.
+ *
+ * A project root is marked by EITHER:
+ *   - `powerpages.config.json` — code/SPA sites (`pac pages download-code-site`), OR
+ *   - a `.powerpages-site/` directory — data-model config sites (`pac pages download`,
+ *     standard or enhanced data model). These have NO `powerpages.config.json`.
+ *
+ * Code sites have both markers; data-model (e.g. enhanced data model) sites have only
+ * `.powerpages-site/`. Checking for either makes root discovery work for both site types.
+ *
  * @returns {string|null} Project root path, or null
  */
 function findProjectRoot(dir) {
   let current = path.resolve(dir);
   while (true) {
-    const configPath = path.join(current, 'powerpages.config.json');
-    if (fs.existsSync(configPath)) {
+    if (fs.existsSync(path.join(current, 'powerpages.config.json')) ||
+        fs.existsSync(path.join(current, '.powerpages-site'))) {
       return current;
     }
 
@@ -107,8 +116,11 @@ function findProjectRoot(dir) {
     current = parent;
   }
 
+  // Fallback: search subdirectories for either marker (config first, then .powerpages-site/).
   const fallbackConfigPath = findPath(dir, 'powerpages.config.json');
-  return fallbackConfigPath ? path.dirname(fallbackConfigPath) : null;
+  if (fallbackConfigPath) return path.dirname(fallbackConfigPath);
+  const fallbackSiteDir = findPath(dir, '.powerpages-site');
+  return fallbackSiteDir ? path.dirname(fallbackSiteDir) : null;
 }
 
 /**

plugins/power-pages/scripts/tests/detect-project-context.test.js

@@ -4,19 +4,82 @@ const fs = require('fs');
 const os = require('os');
 const path = require('path');
 
-const { detectProjectContext } = require('../lib/detect-project-context');
+const { detectProjectContext, readWebsiteYml } = require('../lib/detect-project-context');
 const { createTempProject, writeProjectFile } = require('./test-utils');
 
-test('detectProjectContext throws when powerpages.config.json is missing', (t) => {
+test('detectProjectContext throws when neither config nor .powerpages-site/website.yml exists', (t) => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ctx-test-'));
   t.after(() => fs.rmSync(dir, { recursive: true, force: true }));
 
   assert.throws(
     () => detectProjectContext({ projectRoot: dir }),
-    /powerpages.config.json not found/
+    /neither powerpages\.config\.json nor/
   );
 });
 
+test('detectProjectContext: code site (powerpages.config.json) reports siteType "code"', (t) => {
+  const projectRoot = createTempProject(t);
+  writeProjectFile(projectRoot, 'powerpages.config.json', JSON.stringify({
+    siteName: 'Code Site',
+    websiteRecordId: 'aabbccdd-1234-5678-abcd-00000000000c',
+    environmentUrl: 'https://org.crm.dynamics.com',
+  }));
+
+  const result = detectProjectContext({ projectRoot });
+  assert.equal(result.siteType, 'code');
+  assert.equal(result.siteName, 'Code Site');
+});
+
+test('detectProjectContext: enhanced data-model site resolves identity from .powerpages-site/website.yml', (t) => {
+  const projectRoot = createTempProject(t);
+  // No powerpages.config.json — this is an EDM / data-model config site.
+  writeProjectFile(
+    projectRoot,
+    '.powerpages-site/website.yml',
+    [
+      'defaultlanguage: 32cc32f6-8665-f111-a826-000d3a5a7777',
+      'id: 2ecc32f6-8665-f111-a826-000d3a5a7777',
+      'name: Application processing EDM site - permitapplication-elyyn',
+      'statecode: 0',
+      '',
+    ].join('\n')
+  );
+
+  const result = detectProjectContext({ projectRoot });
+  assert.equal(result.siteType, 'data-model');
+  assert.equal(result.websiteRecordId, '2ecc32f6-8665-f111-a826-000d3a5a7777');
+  assert.equal(result.siteName, 'Application processing EDM site - permitapplication-elyyn');
+  // Data-model sites carry no environment URL locally — callers re-confirm via `pac env who`.
+  assert.equal(result.environmentUrl, null);
+});
+
+test('detectProjectContext: config site wins over website.yml when both exist (code-site precedence)', (t) => {
+  const projectRoot = createTempProject(t);
+  writeProjectFile(projectRoot, 'powerpages.config.json', JSON.stringify({
+    siteName: 'Code Wins',
+    websiteRecordId: 'config-guid',
+    environmentUrl: 'https://org.crm.dynamics.com',
+  }));
+  writeProjectFile(projectRoot, '.powerpages-site/website.yml', 'id: yml-guid\nname: YAML Name\n');
+
+  const result = detectProjectContext({ projectRoot });
+  assert.equal(result.siteType, 'code');
+  assert.equal(result.websiteRecordId, 'config-guid');
+});
+
+test('readWebsiteYml: extracts id + name, strips quotes, ignores other keys', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'yml-test-'));
+  const p = path.join(dir, 'website.yml');
+  fs.writeFileSync(p, 'id: "abc-123"\nname: \'Quoted Site\'\nstatecode: 0\n');
+  try {
+    const site = readWebsiteYml(p);
+    assert.deepEqual(site, { id: 'abc-123', name: 'Quoted Site' });
+    assert.equal(readWebsiteYml(path.join(dir, 'missing.yml')), null);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
 test('detectProjectContext returns siteName and websiteRecordId from config', (t) => {
   const projectRoot = createTempProject(t);
   writeProjectFile(projectRoot, 'powerpages.config.json', JSON.stringify({