@duffcloudservices/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2139 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import chalk7 from "chalk";
+
+// package.json
+var version = "0.1.0";
+
+// src/commands/auth.ts
+import chalk2 from "chalk";
+
+// src/auth/device-flow.ts
+import open from "open";
+import ora from "ora";
+import chalk from "chalk";
+
+// src/auth/credentials.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "dcs-cli",
+  schema: {
+    auth: {
+      type: "object",
+      properties: {
+        accessToken: { type: "string" },
+        refreshToken: { type: "string" },
+        expiresAt: { type: "number" },
+        email: { type: "string" },
+        userId: { type: "string" }
+      }
+    }
+  }
+});
+function storeCredentials(credentials) {
+  config.set("auth", credentials);
+}
+function getCredentials() {
+  return config.get("auth");
+}
+function clearCredentials() {
+  config.delete("auth");
+}
+function isAuthenticated() {
+  const creds = getCredentials();
+  if (!creds) return false;
+  const bufferMs = 5 * 60 * 1e3;
+  return creds.expiresAt > Date.now() + bufferMs;
+}
+function getCurrentUserEmail() {
+  return getCredentials()?.email;
+}
+function getAccessToken() {
+  const creds = getCredentials();
+  if (!creds) return void 0;
+  return creds.accessToken;
+}
+function getRefreshToken() {
+  return getCredentials()?.refreshToken;
+}
+function updateAccessToken(accessToken, expiresIn) {
+  const creds = getCredentials();
+  if (!creds) return;
+  config.set("auth", {
+    ...creds,
+    accessToken,
+    expiresAt: Date.now() + expiresIn * 1e3
+  });
+}
+function getConfigPath() {
+  return config.path;
+}
+
+// src/auth/device-flow.ts
+var DEFAULT_API_URL = "https://portal.duffcloudservices.com";
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function startDeviceAuth(options = {}) {
+  const apiUrl = options.apiUrl || DEFAULT_API_URL;
+  const clientId = options.clientId || "dcs-cli";
+  const response = await fetch(`${apiUrl}/api/v1/cli/auth/device`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ client_id: clientId })
+  });
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`Failed to start device authorization: ${error}`);
+  }
+  const data = await response.json();
+  return {
+    deviceCode: data.device_code,
+    userCode: data.user_code,
+    verificationUri: data.verification_uri,
+    verificationUriComplete: data.verification_uri_complete,
+    expiresIn: data.expires_in,
+    interval: data.interval
+  };
+}
+async function pollForToken(deviceCode, apiUrl) {
+  const response = await fetch(`${apiUrl}/api/v1/cli/auth/token`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      device_code: deviceCode,
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+    })
+  });
+  if (!response.ok) {
+    const data2 = await response.json();
+    return { error: data2.error };
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    tokenType: data.token_type,
+    expiresIn: data.expires_in,
+    email: data.email,
+    userId: data.user_id
+  };
+}
+async function login(options = {}) {
+  const apiUrl = options.apiUrl || DEFAULT_API_URL;
+  const spinner = ora("Starting authentication...").start();
+  let deviceAuth;
+  try {
+    deviceAuth = await startDeviceAuth(options);
+  } catch (error) {
+    spinner.fail("Failed to start authentication");
+    throw error;
+  }
+  spinner.stop();
+  console.log();
+  console.log(chalk.bold("Please visit:"), chalk.cyan(deviceAuth.verificationUri));
+  console.log(chalk.bold("And enter code:"), chalk.yellow.bold(deviceAuth.userCode));
+  console.log();
+  try {
+    await open(deviceAuth.verificationUriComplete);
+    console.log(chalk.dim("(Browser opened automatically)"));
+  } catch {
+    console.log(chalk.dim("(Please open the link manually)"));
+  }
+  console.log();
+  const pollSpinner = ora("Waiting for authentication...").start();
+  let interval = deviceAuth.interval;
+  const deadline = Date.now() + deviceAuth.expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    try {
+      const result = await pollForToken(deviceAuth.deviceCode, apiUrl);
+      if ("error" in result) {
+        if (result.error === "authorization_pending") {
+          continue;
+        }
+        if (result.error === "slow_down") {
+          interval += 5;
+          continue;
+        }
+        if (result.error === "expired_token") {
+          pollSpinner.fail("Authentication timed out");
+          throw new Error("Authentication timed out. Please try again.");
+        }
+        if (result.error === "access_denied") {
+          pollSpinner.fail("Authentication denied");
+          throw new Error("Authentication was denied.");
+        }
+      } else {
+        const credentials = {
+          accessToken: result.accessToken,
+          refreshToken: result.refreshToken,
+          expiresAt: Date.now() + result.expiresIn * 1e3,
+          email: result.email,
+          userId: result.userId
+        };
+        storeCredentials(credentials);
+        pollSpinner.succeed(`Authenticated as ${chalk.green(result.email)}`);
+        return credentials;
+      }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("fetch")) {
+        continue;
+      }
+      throw error;
+    }
+  }
+  pollSpinner.fail("Authentication timed out");
+  throw new Error("Authentication timed out. Please try again.");
+}
+async function refreshAccessToken(refreshToken, options = {}) {
+  const apiUrl = options.apiUrl || DEFAULT_API_URL;
+  const response = await fetch(`${apiUrl}/api/v1/cli/auth/refresh`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({ refresh_token: refreshToken })
+  });
+  if (!response.ok) {
+    throw new Error("Failed to refresh access token. Please login again.");
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    expiresIn: data.expires_in
+  };
+}
+
+// src/commands/auth.ts
+async function loginCommand(options = {}) {
+  try {
+    await login(options);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk2.red("Login failed:"), error.message);
+    }
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  clearCredentials();
+  console.log(chalk2.green("\u2713"), "Logged out successfully");
+}
+async function whoamiCommand() {
+  const email = getCurrentUserEmail();
+  if (!email) {
+    console.log(chalk2.yellow("Not logged in."));
+    console.log("Run", chalk2.cyan("dcs login"), "to authenticate.");
+    return;
+  }
+  console.log("Logged in as:", chalk2.green(email));
+  console.log(chalk2.dim("Config file:"), chalk2.dim(getConfigPath()));
+}
+
+// src/commands/sites.ts
+import chalk3 from "chalk";
+import Table from "cli-table3";
+
+// src/api/portal-client.ts
+var DEFAULT_API_URL2 = "https://portal.duffcloudservices.com";
+var PortalClient = class {
+  apiUrl;
+  constructor(options = {}) {
+    this.apiUrl = options.apiUrl || process.env.DCS_API_URL || DEFAULT_API_URL2;
+  }
+  /**
+   * Make an authenticated API request.
+   */
+  async request(path4, options = {}) {
+    let accessToken = getAccessToken();
+    if (!isAuthenticated() && getRefreshToken()) {
+      const refreshToken = getRefreshToken();
+      try {
+        const { accessToken: newToken, expiresIn } = await refreshAccessToken(refreshToken, {
+          apiUrl: this.apiUrl
+        });
+        updateAccessToken(newToken, expiresIn);
+        accessToken = newToken;
+      } catch {
+        throw new Error("Session expired. Please login again with `dcs login`.");
+      }
+    }
+    if (!accessToken) {
+      throw new Error("Not authenticated. Please login with `dcs login`.");
+    }
+    const response = await fetch(`${this.apiUrl}${path4}`, {
+      ...options,
+      headers: {
+        ...options.headers,
+        Authorization: `Bearer ${accessToken}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (response.status === 401) {
+      throw new Error("Session expired. Please login again with `dcs login`.");
+    }
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`API error (${response.status}): ${error}`);
+    }
+    return response.json();
+  }
+  /**
+   * List sites accessible to the authenticated user.
+   */
+  async listSites() {
+    return this.request("/api/v1/cli/sites");
+  }
+  /**
+   * Get details for a specific site.
+   */
+  async getSite(slug) {
+    return this.request(`/api/v1/cli/sites/${slug}`);
+  }
+  /**
+   * Validate that the user can create/modify a site.
+   */
+  async validateSiteAccess(slug, operation) {
+    try {
+      const { sites } = await this.listSites();
+      const site = sites.find((s) => s.slug === slug);
+      if (!site) {
+        if (operation === "create") {
+          const canCreate = sites.some((s) => ["owner", "admin"].includes(s.role));
+          return canCreate ? { valid: true, message: "New site will be created" } : { valid: false, message: "You need admin access in a company to create new sites" };
+        }
+        return { valid: false, message: `Site '${slug}' not found or you don't have access` };
+      }
+      if (operation === "read") {
+        return { valid: true, role: site.role };
+      }
+      if (operation === "edit") {
+        const canEdit = ["owner", "admin", "editor"].includes(site.role);
+        return canEdit ? { valid: true, role: site.role } : { valid: false, role: site.role, message: "You need editor access to modify this site" };
+      }
+      if (operation === "create") {
+        return { valid: false, message: "Site already exists" };
+      }
+      return { valid: false };
+    } catch (error) {
+      if (error instanceof Error) {
+        return { valid: false, message: error.message };
+      }
+      return { valid: false, message: "Unknown error" };
+    }
+  }
+};
+var clientInstance = null;
+function getPortalClient(options) {
+  if (!clientInstance) {
+    clientInstance = new PortalClient(options);
+  }
+  return clientInstance;
+}
+
+// src/commands/sites.ts
+async function listSitesCommand() {
+  if (!isAuthenticated()) {
+    console.log(chalk3.yellow("Not logged in."));
+    console.log("Run", chalk3.cyan("dcs login"), "to authenticate.");
+    process.exit(1);
+  }
+  const client = getPortalClient();
+  try {
+    const { sites } = await client.listSites();
+    if (sites.length === 0) {
+      console.log(chalk3.yellow("No sites found."));
+      console.log("Ask your company admin to grant you access to sites.");
+      return;
+    }
+    console.log(chalk3.bold("\nYour Sites:\n"));
+    const table = new Table({
+      head: [
+        chalk3.cyan("Slug"),
+        chalk3.cyan("Name"),
+        chalk3.cyan("Role"),
+        chalk3.cyan("Company"),
+        chalk3.cyan("URL")
+      ],
+      style: {
+        head: [],
+        border: []
+      }
+    });
+    for (const site of sites) {
+      table.push([
+        site.slug,
+        site.name,
+        formatRole(site.role),
+        site.companyName,
+        site.productionUrl || chalk3.dim("(not deployed)")
+      ]);
+    }
+    console.log(table.toString());
+    console.log();
+    console.log(chalk3.dim(`Total: ${sites.length} site(s)`));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk3.red("Error:"), error.message);
+    }
+    process.exit(1);
+  }
+}
+async function showSiteCommand(slug) {
+  if (!isAuthenticated()) {
+    console.log(chalk3.yellow("Not logged in."));
+    console.log("Run", chalk3.cyan("dcs login"), "to authenticate.");
+    process.exit(1);
+  }
+  const client = getPortalClient();
+  try {
+    const site = await client.getSite(slug);
+    displaySiteDetails(site);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk3.red("Error:"), error.message);
+    }
+    process.exit(1);
+  }
+}
+function formatRole(role) {
+  switch (role) {
+    case "owner":
+      return chalk3.magenta(role);
+    case "admin":
+      return chalk3.red(role);
+    case "editor":
+      return chalk3.yellow(role);
+    case "viewer":
+      return chalk3.blue(role);
+    default:
+      return role;
+  }
+}
+function displaySiteDetails(site) {
+  console.log();
+  console.log(chalk3.bold("Site Details"));
+  console.log();
+  console.log("  Slug:        ", chalk3.cyan(site.slug));
+  console.log("  Name:        ", site.name);
+  console.log("  Role:        ", formatRole(site.role));
+  console.log("  Company:     ", site.companyName);
+  console.log("  Company ID:  ", chalk3.dim(site.companyId));
+  if (site.productionUrl) {
+    console.log("  URL:         ", chalk3.green(site.productionUrl));
+  } else {
+    console.log("  URL:         ", chalk3.dim("(not deployed)"));
+  }
+  console.log();
+}
+
+// src/commands/init.ts
+import fs from "fs/promises";
+import path from "path";
+import chalk4 from "chalk";
+import ora2 from "ora";
+
+// src/templates/site-deploy.yml
+var site_deploy_default = `# Site Deployment Workflow\r
+# Generated by @duffcloudservices/cli\r
+# This workflow deploys the site to Azure Static Web Apps using OIDC authentication.\r
+\r
+name: Site Deployment\r
+\r
+on:\r
+  push:\r
+    branches:\r
+      - 'release/**'\r
+      - 'master'\r
+  workflow_dispatch:\r
+    inputs:\r
+      trigger_reason:\r
+        description: 'Reason for manual deployment'\r
+        required: false\r
+        type: string\r
+        default: 'Manual deployment'\r
+\r
+# Prevent concurrent deployments for the same branch\r
+concurrency:\r
+  group: site-deploy-\${{ github.ref }}\r
+  cancel-in-progress: false\r
+\r
+permissions:\r
+  contents: read\r
+  issues: write\r
+  pull-requests: read\r
+  id-token: write  # Required for Azure OIDC authentication\r
+\r
+jobs:\r
+  deploy:\r
+    name: Deploy to Azure Static Web App\r
+    runs-on: ubuntu-latest\r
+    # Skip deployment on branch creation events\r
+    if: github.event.before != '0000000000000000000000000000000000000000'\r
+\r
+    steps:\r
+      - name: Determine deployment environment\r
+        id: environment\r
+        run: |\r
+          BRANCH="\${{ github.ref_name }}"\r
+          echo "Branch: $BRANCH"\r
+          \r
+          if [ "$BRANCH" == "master" ]; then\r
+            echo "environment=Production" >> $GITHUB_OUTPUT\r
+            echo "environment_name=Production" >> $GITHUB_OUTPUT\r
+            echo "swa_environment=" >> $GITHUB_OUTPUT\r
+          else\r
+            echo "environment=preview" >> $GITHUB_OUTPUT\r
+            echo "environment_name=Preview" >> $GITHUB_OUTPUT\r
+            echo "swa_environment=preview" >> $GITHUB_OUTPUT\r
+          fi\r
+\r
+      - name: Checkout repository\r
+        uses: actions/checkout@v4\r
+\r
+      - name: Read site configuration\r
+        id: config\r
+        run: |\r
+          CONFIG_FILE=".dcs/site.yaml"\r
+          \r
+          if [ ! -f "$CONFIG_FILE" ]; then\r
+            echo "::error::Missing DCS site configuration file: $CONFIG_FILE"\r
+            exit 1\r
+          fi\r
+          \r
+          SITE_NAME=$(grep -E '^site_name:' "$CONFIG_FILE" | sed 's/site_name:\\s*//' | tr -d '"' | tr -d "'")\r
+          SITE_SLUG=$(grep -E '^site_slug:' "$CONFIG_FILE" | sed 's/site_slug:\\s*//' | tr -d '"' | tr -d "'")\r
+          SWA_RESOURCE_ID=$(grep -E '^swa_resource_id:' "$CONFIG_FILE" | sed 's/swa_resource_id:\\s*//' | tr -d '"' | tr -d "'")\r
+          PORTAL_API_URL=$(grep -E '^portal_api_url:' "$CONFIG_FILE" | sed 's/portal_api_url:\\s*//' | tr -d '"' | tr -d "'")\r
+          PORTAL_API_URL="\${PORTAL_API_URL:-https://portal.duffcloudservices.com}"\r
+          GOOGLE_ANALYTICS_ID=$(grep -E '^google_analytics_id:' "$CONFIG_FILE" | sed 's/google_analytics_id:\\s*//' | tr -d '"' | tr -d "'")\r
+          \r
+          # Azure Authentication\r
+          AZURE_CLIENT_ID=$(grep -E '^\\s*client_id:' "$CONFIG_FILE" | sed 's/.*client_id:\\s*//' | tr -d '"' | tr -d "'")\r
+          AZURE_TENANT_ID=$(grep -E '^\\s*tenant_id:' "$CONFIG_FILE" | sed 's/.*tenant_id:\\s*//' | tr -d '"' | tr -d "'")\r
+          AZURE_SUBSCRIPTION_ID=$(grep -E '^\\s*subscription_id:' "$CONFIG_FILE" | sed 's/.*subscription_id:\\s*//' | tr -d '"' | tr -d "'")\r
+          \r
+          # Build Configuration\r
+          APP_LOCATION=$(grep -E '^\\s*app_location:' "$CONFIG_FILE" | sed 's/.*app_location:\\s*//' | tr -d '"' | tr -d "'")\r
+          OUTPUT_LOCATION=$(grep -E '^\\s*output_location:' "$CONFIG_FILE" | sed 's/.*output_location:\\s*//' | tr -d '"' | tr -d "'")\r
+          \r
+          APP_LOCATION="\${APP_LOCATION:-dist}"\r
+          OUTPUT_LOCATION="\${OUTPUT_LOCATION:-.}"\r
+\r
+          if [ -z "$SWA_RESOURCE_ID" ]; then\r
+            echo "::error::Missing swa_resource_id in $CONFIG_FILE"\r
+            exit 1\r
+          fi\r
+          \r
+          echo "site_name=$SITE_NAME" >> $GITHUB_OUTPUT\r
+          echo "site_slug=$SITE_SLUG" >> $GITHUB_OUTPUT\r
+          echo "swa_resource_id=$SWA_RESOURCE_ID" >> $GITHUB_OUTPUT\r
+          echo "app_location=$APP_LOCATION" >> $GITHUB_OUTPUT\r
+          echo "output_location=$OUTPUT_LOCATION" >> $GITHUB_OUTPUT\r
+          echo "azure_client_id=$AZURE_CLIENT_ID" >> $GITHUB_OUTPUT\r
+          echo "azure_tenant_id=$AZURE_TENANT_ID" >> $GITHUB_OUTPUT\r
+          echo "azure_subscription_id=$AZURE_SUBSCRIPTION_ID" >> $GITHUB_OUTPUT\r
+          echo "portal_api_url=$PORTAL_API_URL" >> $GITHUB_OUTPUT\r
+          echo "google_analytics_id=$GOOGLE_ANALYTICS_ID" >> $GITHUB_OUTPUT\r
+\r
+      - name: Azure login via OIDC\r
+        uses: azure/login@v2\r
+        with:\r
+          client-id: \${{ steps.config.outputs.azure_client_id || vars.AZURE_CLIENT_ID }}\r
+          tenant-id: \${{ steps.config.outputs.azure_tenant_id || vars.AZURE_TENANT_ID }}\r
+          subscription-id: \${{ steps.config.outputs.azure_subscription_id || vars.AZURE_SUBSCRIPTION_ID }}\r
+\r
+      - name: Get deployment tokens\r
+        id: tokens\r
+        run: |\r
+          # Get access token for DCS API\r
+          ACCESS_TOKEN=$(az account get-access-token --resource "api://304711b9-8532-4659-beb7-c85726de9ae5" --query accessToken -o tsv)\r
+          \r
+          SITE_NAME="\${{ steps.config.outputs.site_name }}"\r
+          SITE_SLUG="\${{ steps.config.outputs.site_slug }}"\r
+          PORTAL_API_URL="\${{ steps.config.outputs.portal_api_url }}"\r
+          \r
+          RESPONSE=$(curl -s -X POST "\${PORTAL_API_URL}/api/v1/sites/deployment-tokens" \\\r
+            -H "Authorization: Bearer $ACCESS_TOKEN" \\\r
+            -H "Content-Type: application/json" \\\r
+            -d "{\\"siteName\\": \\"$SITE_NAME\\", \\"siteSlug\\": \\"$SITE_SLUG\\"}")\r
+          \r
+          SWA_TOKEN=$(echo $RESPONSE | jq -r .swaToken)\r
+          \r
+          if [ -z "$SWA_TOKEN" ] || [ "$SWA_TOKEN" == "null" ]; then\r
+            echo "::error::Failed to retrieve SWA token from DCS API"\r
+            echo "Response: $RESPONSE"\r
+            exit 1\r
+          fi\r
+          \r
+          echo "::add-mask::$SWA_TOKEN"\r
+          echo "swa_token=$SWA_TOKEN" >> $GITHUB_OUTPUT\r
+\r
+      - name: Setup Node.js\r
+        uses: actions/setup-node@v4\r
+        with:\r
+          node-version: "22"\r
+\r
+      - name: Install pnpm\r
+        uses: pnpm/action-setup@v4\r
+\r
+      - name: Setup pnpm cache\r
+        uses: actions/cache@v4\r
+        with:\r
+          path: ~/.pnpm-store\r
+          key: \${{ runner.os }}-pnpm-\${{ hashFiles('**/pnpm-lock.yaml') }}\r
+          restore-keys: |\r
+            \${{ runner.os }}-pnpm-\r
+\r
+      - name: Install dependencies\r
+        run: pnpm install --frozen-lockfile\r
+\r
+      - name: Create environment file\r
+        run: |\r
+          cat > .env << EOF\r
+          VITE_BACKEND_URI="\${{ steps.config.outputs.portal_api_url }}"\r
+          VITE_SITE_SLUG="\${{ steps.config.outputs.site_slug }}"\r
+          VITE_GOOGLE_ANALYTICS_ID="\${{ steps.config.outputs.google_analytics_id }}"\r
+          EOF\r
+\r
+      - name: Build site\r
+        run: pnpm run build\r
+\r
+      - name: Deploy to Azure Static Web Apps\r
+        uses: Azure/static-web-apps-deploy@v1\r
+        with:\r
+          azure_static_web_apps_api_token: \${{ steps.tokens.outputs.swa_token }}\r
+          repo_token: \${{ secrets.GITHUB_TOKEN }}\r
+          action: "upload"\r
+          app_location: \${{ steps.config.outputs.app_location }}\r
+          output_location: \${{ steps.config.outputs.output_location }}\r
+          skip_app_build: true\r
+          deployment_environment: \${{ steps.environment.outputs.swa_environment != '' && steps.environment.outputs.swa_environment || '' }}\r
+`;
+
+// src/commands/init.ts
+async function initCommand(options) {
+  const { siteSlug, siteName, framework = "vue", target = ".", dryRun = false, force = false } = options;
+  if (!isAuthenticated()) {
+    console.log(chalk4.yellow("Not logged in."));
+    console.log("Run", chalk4.cyan("dcs login"), "to authenticate.");
+    process.exit(1);
+  }
+  const spinner = ora2("Validating site access...").start();
+  const client = getPortalClient();
+  try {
+    const { sites } = await client.listSites();
+    const existingSite = sites.find((s) => s.slug === siteSlug);
+    if (existingSite) {
+      if (!["owner", "admin", "editor"].includes(existingSite.role)) {
+        spinner.fail(`You don't have edit access to site '${siteSlug}'`);
+        process.exit(1);
+      }
+      spinner.succeed(`Site '${siteSlug}' found (role: ${existingSite.role})`);
+    } else {
+      const canCreate = sites.some((s) => ["owner", "admin"].includes(s.role));
+      if (!canCreate) {
+        spinner.fail("You need admin access in a company to create new sites");
+        process.exit(1);
+      }
+      spinner.info(`Creating new site: ${siteSlug}`);
+    }
+  } catch (error) {
+    spinner.fail("Failed to validate site access");
+    if (error instanceof Error) {
+      console.error(chalk4.red("Error:"), error.message);
+    }
+    process.exit(1);
+  }
+  const targetDir = path.resolve(target);
+  console.log(chalk4.dim(`Target directory: ${targetDir}`));
+  const generatedFiles = [];
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  try {
+    const siteYaml = generateSiteYaml({ siteSlug, siteName, timestamp, framework });
+    generatedFiles.push(await writeFile(targetDir, ".dcs/site.yaml", siteYaml, { dryRun, force }));
+    const pagesYaml = generatePagesYaml({ siteSlug, timestamp });
+    generatedFiles.push(await writeFile(targetDir, ".dcs/pages.yaml", pagesYaml, { dryRun, force }));
+    const contentYaml = generateContentYaml({ timestamp });
+    generatedFiles.push(await writeFile(targetDir, ".dcs/content.yaml", contentYaml, { dryRun, force }));
+    const seoYaml = generateSeoYaml({ siteName, timestamp });
+    generatedFiles.push(await writeFile(targetDir, ".dcs/seo.yaml", seoYaml, { dryRun, force }));
+    const sectionConventions = generateSectionConventions();
+    generatedFiles.push(
+      await writeFile(targetDir, ".dcs/SECTION-CONVENTIONS.md", sectionConventions, { dryRun, force })
+    );
+    const copilotInstructions = generateCopilotInstructions({ siteName });
+    generatedFiles.push(
+      await writeFile(targetDir, ".github/copilot-instructions.md", copilotInstructions, { dryRun, force })
+    );
+    const deployWorkflow = generateDeployWorkflow();
+    generatedFiles.push(
+      await writeFile(targetDir, ".github/workflows/site-deploy.yml", deployWorkflow, { dryRun, force })
+    );
+    const plansReadme = generatePlansReadme({ siteName, framework });
+    generatedFiles.push(await writeFile(targetDir, ".plans/README.md", plansReadme, { dryRun, force }));
+    const plan00 = generatePlan00AuditSite({ framework });
+    generatedFiles.push(await writeFile(targetDir, ".plans/00-audit-site.md", plan00, { dryRun, force }));
+    const plan01 = generatePlan01IntegrateContent();
+    generatedFiles.push(await writeFile(targetDir, ".plans/01-integrate-content.md", plan01, { dryRun, force }));
+    const plan02 = generatePlan02ConfigureSeo();
+    generatedFiles.push(await writeFile(targetDir, ".plans/02-configure-seo.md", plan02, { dryRun, force }));
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(chalk4.red("Error:"), error.message);
+    }
+    process.exit(1);
+  }
+  console.log();
+  console.log(chalk4.bold("Generated files:"));
+  for (const file of generatedFiles) {
+    console.log(`  ${chalk4.green("\u2713")} ${file}`);
+  }
+  console.log();
+  console.log(chalk4.bold("Next steps:"));
+  console.log("  1. Install CMS package:", chalk4.cyan("pnpm add @duffcloudservices/cms"));
+  console.log("  2. Configure Vite plugins in your build config");
+  console.log("  3. Follow the plans in", chalk4.cyan(".plans/"), "directory");
+  console.log();
+}
+async function writeFile(targetDir, relativePath, content, options) {
+  const fullPath = path.join(targetDir, relativePath);
+  if (options.dryRun) {
+    console.log(chalk4.dim(`Would create: ${relativePath}`));
+    return relativePath;
+  }
+  try {
+    await fs.access(fullPath);
+    if (!options.force) {
+      console.log(chalk4.yellow(`Skipped (exists): ${relativePath}`));
+      return relativePath;
+    }
+  } catch {
+  }
+  await fs.mkdir(path.dirname(fullPath), { recursive: true });
+  await fs.writeFile(fullPath, content, "utf8");
+  return relativePath;
+}
+function generateSiteYaml(data) {
+  return `# DCS Site Configuration
+# This file defines the site identity and Azure resource bindings.
+# Generated by: @duffcloudservices/cli
+
+site_name: ${data.siteName}
+site_slug: ${data.siteSlug}
+
+# Azure Static Web App resource ID
+# Set this after provisioning the SWA resource in Azure
+swa_resource_id: ""
+
+# URLs are populated after first deployment
+production_url: ""
+preview_url: ""
+
+# Google Analytics Configuration
+google_analytics_id: ""
+
+# Azure Authentication (Managed Identity)
+# These values are used by GitHub Actions for OIDC authentication
+azure:
+  client_id: ""
+  tenant_id: ""
+  subscription_id: ""
+
+# Portal API Configuration
+portal_api_url: "https://portal.duffcloudservices.com"
+
+# Site metadata for portal
+metadata:
+  framework: ${data.framework}
+  managed_by: dcs
+  created_at: "${data.timestamp}"
+`;
+}
+function generatePagesYaml(data) {
+  return `# .dcs/pages.yaml
+# Page registry for DCS CMS integration and snapshot capture.
+# Generated by: @duffcloudservices/cli
+#
+# This file defines page metadata only. Text content is stored in content.yaml
+# and text keys are auto-discovered during snapshot capture.
+
+version: 3
+siteSlug: ${data.siteSlug}
+lastUpdated: "${data.timestamp}"
+generatedBy: dcs-cli
+
+pages:
+  # Home page - always protected
+  - slug: home
+    path: /
+    type: static
+    title: Home
+    deletable: false
+
+# Excluded paths - never captured
+excluded:
+  - /404
+  - /dev-*
+  - /_*
+
+# Snapshot configuration
+snapshot:
+  viewport:
+    width: 1280
+    height: 720
+  waitAfterLoad: 3000
+  captureFullPage: true
+`;
+}
+function generateContentYaml(data) {
+  return `# .dcs/content.yaml
+# Managed by DCS Portal - Do not edit manually
+# This file contains all text content for the site.
+#
+# Content is organized by page slug, with each page containing
+# key-value pairs for editable text. The \`global\` section contains
+# text shared across all pages (navigation, footer, etc.).
+
+version: 1
+lastUpdated: "${data.timestamp}"
+updatedBy: "dcs-cli"
+
+# Global text content (shared across all pages)
+global: {}
+
+# Page-specific text content
+pages: {}
+`;
+}
+function generateSeoYaml(data) {
+  return `# .dcs/seo.yaml
+# Managed by DCS Portal - Do not edit manually
+# SEO configuration for all pages and global defaults.
+
+version: 1
+lastUpdated: "${data.timestamp}"
+updatedBy: "dcs-cli"
+
+# Global/site-wide SEO defaults
+global:
+  siteName: "${data.siteName}"
+  siteUrl: ""  # Set your production URL
+  locale: en_US
+  defaultTitle: "${data.siteName}"
+  defaultDescription: ""
+  titleTemplate: "%s | ${data.siteName}"
+
+  # Social media handles
+  social:
+    twitter: ""
+    linkedin: ""
+
+  # Default images for social sharing
+  images:
+    logo: ""
+    ogDefault: ""
+    twitterDefault: ""
+
+  # Default robots directive
+  robots: "index, follow"
+
+# Page-specific SEO configurations
+pages:
+  home:
+    title: Home
+    description: ""
+    noTitleTemplate: true
+    openGraph:
+      type: website
+    twitter:
+      card: summary_large_image
+`;
+}
+function generateSectionConventions() {
+  return `# Section Conventions for DCS CMS Integration
+
+This document describes the HTML attributes used by the DCS visual page editor
+for section identification and snapshot capture.
+
+## Required Attributes
+
+### \`data-dcs-section\`
+
+Marks an element as an editable section. The value should match the section's
+identifier in content.yaml.
+
+\`\`\`html
+<section data-dcs-section="hero">
+  <!-- Section content -->
+</section>
+\`\`\`
+
+### \`data-dcs-text\`
+
+Marks an element's text as editable via the portal. The value should be the
+text key from content.yaml.
+
+\`\`\`html
+<h1 data-dcs-text="hero.title">{{ t('hero.title') }}</h1>
+\`\`\`
+
+## Best Practices
+
+1. Use semantic section names that describe the content
+2. Keep text keys hierarchical (section.element)
+3. Ensure all user-editable text has a data-dcs-text attribute
+4. Don't nest sections unnecessarily
+`;
+}
+function generateCopilotInstructions(data) {
+  return `# GitHub Copilot Instructions for ${data.siteName}
+
+## Project Overview
+
+This is a **DCS-managed customer site**. Content and feature changes are managed
+through the DCS Portal at https://portal.duffcloudservices.com.
+
+## Technology Stack
+
+- Vue 3 + Composition API
+- VitePress (or Vite)
+- @duffcloudservices/cms for content management
+- Azure Static Web Apps for hosting
+
+## Content Management
+
+### Text Content
+
+Use the \`useTextContent\` composable for all editable text:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useTextContent } from '@duffcloudservices/cms'
+
+const { t } = useTextContent({
+  pageSlug: 'home',
+  defaults: {
+    'hero.title': 'Default Title',
+    'hero.subtitle': 'Default subtitle'
+  }
+})
+</script>
+
+<template>
+  <h1 data-dcs-text="hero.title">{{ t('hero.title') }}</h1>
+  <p data-dcs-text="hero.subtitle">{{ t('hero.subtitle') }}</p>
+</template>
+\`\`\`
+
+### SEO
+
+Use the \`useSEO\` composable for page SEO:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useSEO } from '@duffcloudservices/cms'
+
+const { applyHead } = useSEO('home')
+applyHead()
+</script>
+\`\`\`
+
+## Key Conventions
+
+1. All user-editable text must use \`useTextContent\`
+2. All pages must have SEO configured via \`useSEO\`
+3. Section elements need \`data-dcs-section\` attributes
+4. Text elements need \`data-dcs-text\` attributes
+5. See \`.dcs/SECTION-CONVENTIONS.md\` for details
+`;
+}
+function generatePlansReadme(data) {
+  return `# DCS Integration Plans for ${data.siteName}
+
+This directory contains step-by-step plans for integrating this site with the
+DCS content management system.
+
+## Overview
+
+These plans guide AI assistants (like GitHub Copilot) through the integration
+process. Follow them in order for best results.
+
+## Plans
+
+1. **00-audit-site.md** - Analyze current site structure
+2. **01-create-use-text-content.md** - Set up the text content composable
+3. **02-integrate-home-page.md** - Add CMS integration to home page
+4. **03-integrate-remaining-pages.md** - Complete other pages
+5. **04-capture-snapshots.md** - Configure visual editor snapshots
+6. **05-verify-deployment.md** - Test and verify deployment
+
+## Framework
+
+This site uses: **${data.framework}**
+
+## Getting Started
+
+1. Open plan 00 and ask Copilot to execute it
+2. Review the output and make any needed adjustments
+3. Continue with subsequent plans
+
+## Configuration Files
+
+- \`.dcs/site.yaml\` - Site identity and Azure config
+- \`.dcs/pages.yaml\` - Page registry for CMS
+- \`.dcs/content.yaml\` - Text content (managed by Portal)
+- \`.dcs/seo.yaml\` - SEO configuration (managed by Portal)
+`;
+}
+function generateDeployWorkflow() {
+  return site_deploy_default;
+}
+function generatePlan00AuditSite(data) {
+  return `# Plan 00: Audit Site Structure
+
+## Objective
+
+Analyze the current site structure to understand what pages exist, their routes,
+and identify all text content that should be managed via DCS.
+
+## Framework
+
+This site uses: **${data.framework}**
+
+## Tasks
+
+### 1. List All Pages
+
+Identify all page components/routes in the project:
+
+- For Vue/VitePress: Look in \`src/views/\`, \`src/pages/\`, or \`.vitepress/\`
+- For Astro: Look in \`src/pages/\`
+
+Create a list of:
+- Route path (e.g., \`/\`, \`/about\`, \`/services\`)
+- Component file path
+- Page title (from existing meta or content)
+
+### 2. Identify Text Content
+
+For each page, list all user-facing text that should be editable:
+
+- Headings (h1, h2, etc.)
+- Paragraphs and body text
+- Button labels
+- Navigation links
+- Footer content
+
+Use this naming convention for text keys:
+\`\`\`
+{pageSlug}.{section}.{element}
+
+Examples:
+- home.hero.title
+- home.hero.subtitle
+- home.cta.buttonText
+- about.intro.heading
+\`\`\`
+
+### 3. Update pages.yaml
+
+Add all discovered pages to \`.dcs/pages.yaml\`:
+
+\`\`\`yaml
+pages:
+  - slug: home
+    path: /
+    type: static
+    title: Home
+    deletable: false
+    
+  - slug: about
+    path: /about
+    type: static
+    title: About Us
+    deletable: true
+\`\`\`
+
+### 4. Document Findings
+
+Create a brief summary of:
+- Total number of pages
+- Estimated number of text keys per page
+- Any complex sections (carousels, tabs, etc.)
+- Shared components that contain text (header, footer)
+
+## Output
+
+After completing this plan, you should have:
+1. Updated \`.dcs/pages.yaml\` with all pages
+2. A mental map of text content to migrate
+3. Understanding of component structure
+`;
+}
+function generatePlan01IntegrateContent() {
+  return `# Plan 01: Integrate Text Content
+
+## Objective
+
+Set up the \`useTextContent\` composable and migrate all static text to the
+DCS content management system.
+
+## Prerequisites
+
+- Completed Plan 00 (site audit)
+- \`@duffcloudservices/cms\` package installed
+
+## Tasks
+
+### 1. Install DCS CMS Package
+
+\`\`\`bash
+pnpm add @duffcloudservices/cms
+\`\`\`
+
+### 2. Configure Vite Plugin
+
+Add the DCS content plugin to your Vite config:
+
+\`\`\`typescript
+// vite.config.ts
+import { dcsContentPlugin } from '@duffcloudservices/cms/vite'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    dcsContentPlugin({
+      contentPath: '.dcs/content.yaml',
+    }),
+  ],
+})
+\`\`\`
+
+### 3. Integrate Home Page
+
+Start with the home page as a template:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useTextContent } from '@duffcloudservices/cms'
+
+const { t } = useTextContent({
+  pageSlug: 'home',
+  defaults: {
+    'hero.title': 'Your Default Title',
+    'hero.subtitle': 'Your default subtitle text',
+    'hero.cta': 'Get Started',
+  }
+})
+</script>
+
+<template>
+  <section data-dcs-section="hero">
+    <h1 data-dcs-text="hero.title">{{ t('hero.title') }}</h1>
+    <p data-dcs-text="hero.subtitle">{{ t('hero.subtitle') }}</p>
+    <button data-dcs-text="hero.cta">{{ t('hero.cta') }}</button>
+  </section>
+</template>
+\`\`\`
+
+### 4. Key Patterns
+
+**Text Keys**: Use hierarchical naming
+- \`{section}.{element}\` for page-specific content
+- Prefix with \`global.\` for shared content
+
+**Default Values**: Always provide defaults that match current content
+- This ensures the site works before CMS content is loaded
+- Defaults serve as fallback if content fetch fails
+
+**Data Attributes**: Required for visual editor
+- \`data-dcs-section\` on section containers
+- \`data-dcs-text\` on text elements (value = text key)
+
+### 5. Migrate Remaining Pages
+
+Apply the same pattern to all pages identified in Plan 00.
+
+For each page:
+1. Import \`useTextContent\`
+2. Define defaults for all text content
+3. Replace static text with \`{{ t('key') }}\`
+4. Add \`data-dcs-text\` attributes
+
+### 6. Handle Global Content
+
+Create a shared composable for navigation/footer:
+
+\`\`\`typescript
+// composables/useGlobalContent.ts
+import { useTextContent } from '@duffcloudservices/cms'
+
+export function useGlobalContent() {
+  return useTextContent({
+    pageSlug: 'global',
+    defaults: {
+      'nav.home': 'Home',
+      'nav.about': 'About',
+      'footer.copyright': '\xA9 2025 Company Name',
+    }
+  })
+}
+\`\`\`
+
+## Verification
+
+After completing this plan:
+1. Run \`pnpm dev\` - site should display normally with defaults
+2. Check browser console for any missing text key warnings
+3. Verify all text elements have \`data-dcs-text\` attributes
+`;
+}
+function generatePlan02ConfigureSeo() {
+  return `# Plan 02: Configure SEO
+
+## Objective
+
+Set up the \`useSEO\` composable to manage page metadata through DCS Portal.
+
+## Prerequisites
+
+- Completed Plan 01 (content integration)
+- \`@duffcloudservices/cms\` package installed
+
+## Tasks
+
+### 1. Configure Vite Plugin
+
+Add the DCS SEO plugin to your Vite config:
+
+\`\`\`typescript
+// vite.config.ts
+import { dcsContentPlugin, dcsSeoPlugin } from '@duffcloudservices/cms/vite'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    dcsContentPlugin({ contentPath: '.dcs/content.yaml' }),
+    dcsSeoPlugin({ seoPath: '.dcs/seo.yaml' }),
+  ],
+})
+\`\`\`
+
+### 2. Add SEO to Pages
+
+For each page, add the \`useSEO\` composable:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useTextContent, useSEO } from '@duffcloudservices/cms'
+
+// Content setup
+const { t } = useTextContent({ pageSlug: 'home', defaults: { ... } })
+
+// SEO setup - applies head tags automatically
+const { applyHead } = useSEO('home')
+applyHead()
+</script>
+\`\`\`
+
+### 3. Configure Default SEO
+
+Update \`.dcs/seo.yaml\` with site-wide defaults:
+
+\`\`\`yaml
+global:
+  siteName: "Your Site Name"
+  siteUrl: "https://yoursite.com"
+  locale: en_US
+  defaultTitle: "Your Site Name"
+  defaultDescription: "Your site description for search engines"
+  titleTemplate: "%s | Your Site Name"
+  
+  social:
+    twitter: "@yourhandle"
+    linkedin: "company/yourcompany"
+  
+  images:
+    logo: "/images/logo.png"
+    ogDefault: "/images/og-default.png"
+
+pages:
+  home:
+    title: Home
+    description: "Welcome to our site"
+    noTitleTemplate: true  # Home page often skips " | Site Name"
+    openGraph:
+      type: website
+    twitter:
+      card: summary_large_image
+      
+  about:
+    title: About Us
+    description: "Learn more about our company"
+\`\`\`
+
+### 4. Page-Specific Overrides
+
+Each page can have custom SEO settings that override globals:
+
+\`\`\`yaml
+pages:
+  services:
+    title: Our Services
+    description: "Explore our professional services"
+    canonical: "https://yoursite.com/services"
+    openGraph:
+      title: "Services - Custom OG Title"
+      description: "Custom description for social sharing"
+      image: "/images/services-og.png"
+\`\`\`
+
+### 5. Dynamic Pages (Blogs, etc.)
+
+For dynamic pages like blog posts, you'll pass SEO data dynamically:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useSEO } from '@duffcloudservices/cms'
+
+const props = defineProps<{ post: BlogPost }>()
+
+const { applyHead } = useSEO('blog-post', {
+  title: props.post.title,
+  description: props.post.excerpt,
+  openGraph: {
+    type: 'article',
+    image: props.post.featuredImage,
+  }
+})
+applyHead()
+</script>
+\`\`\`
+
+## Verification
+
+After completing this plan:
+1. View page source - check for meta tags
+2. Use browser dev tools to inspect \`<head>\`
+3. Test with social sharing debuggers (Facebook, Twitter, LinkedIn)
+4. Validate with Google's Rich Results Test
+`;
+}
+
+// src/commands/validate.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import chalk5 from "chalk";
+import yaml from "js-yaml";
+async function validateCommand(options) {
+  const { target = ".", fix = false, verbose = false } = options;
+  const targetDir = path2.resolve(target);
+  const dcsDir = path2.join(targetDir, ".dcs");
+  console.log(chalk5.bold("Validating DCS configuration..."));
+  console.log(chalk5.dim(`Directory: ${targetDir}`));
+  console.log();
+  try {
+    await fs2.access(dcsDir);
+  } catch {
+    console.log(chalk5.red("No .dcs directory found."));
+    console.log("Run", chalk5.cyan("dcs init"), "to create DCS configuration.");
+    process.exit(1);
+  }
+  const results = [];
+  results.push(await validateSiteYaml(dcsDir, verbose));
+  results.push(await validatePagesYaml(dcsDir, verbose));
+  results.push(await validateContentYaml(dcsDir, verbose));
+  results.push(await validateSeoYaml(dcsDir, verbose));
+  console.log(chalk5.bold("Validation Results:"));
+  console.log();
+  let hasErrors = false;
+  let hasWarnings = false;
+  for (const result of results) {
+    if (!result.valid || result.errors.length > 0) {
+      hasErrors = true;
+      console.log(`${chalk5.red("\u2717")} ${result.file}`);
+      for (const error of result.errors) {
+        console.log(`    ${chalk5.red("error:")} ${error}`);
+      }
+    } else if (result.warnings.length > 0) {
+      hasWarnings = true;
+      console.log(`${chalk5.yellow("!")} ${result.file}`);
+    } else {
+      console.log(`${chalk5.green("\u2713")} ${result.file}`);
+    }
+    for (const warning of result.warnings) {
+      console.log(`    ${chalk5.yellow("warning:")} ${warning}`);
+    }
+  }
+  console.log();
+  if (hasErrors) {
+    console.log(chalk5.red("Validation failed with errors."));
+    if (fix) {
+      console.log(chalk5.yellow("Some errors can be fixed automatically. Run with --fix flag."));
+    }
+    process.exit(1);
+  } else if (hasWarnings) {
+    console.log(chalk5.yellow("Validation passed with warnings."));
+  } else {
+    console.log(chalk5.green("All configuration files are valid."));
+  }
+}
+async function validateSiteYaml(dcsDir, verbose) {
+  const filePath = path2.join(dcsDir, "site.yaml");
+  const result = {
+    file: ".dcs/site.yaml",
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  try {
+    const content = await fs2.readFile(filePath, "utf8");
+    const config2 = yaml.load(content);
+    if (!config2.site_name) {
+      result.errors.push("Missing required field: site_name");
+      result.valid = false;
+    }
+    if (!config2.site_slug) {
+      result.errors.push("Missing required field: site_slug");
+      result.valid = false;
+    } else if (!/^[a-z0-9-]+$/.test(config2.site_slug)) {
+      result.errors.push("site_slug must be lowercase alphanumeric with hyphens only");
+      result.valid = false;
+    }
+    if (!config2.swa_resource_id) {
+      result.warnings.push("swa_resource_id is not set (required for deployment)");
+    }
+    if (!config2.production_url) {
+      result.warnings.push("production_url is not set");
+    }
+    if (verbose) {
+      console.log(chalk5.dim(`  site_name: ${config2.site_name}`));
+      console.log(chalk5.dim(`  site_slug: ${config2.site_slug}`));
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      result.errors.push("File not found");
+    } else {
+      result.errors.push(`Parse error: ${error.message}`);
+    }
+    result.valid = false;
+  }
+  return result;
+}
+async function validatePagesYaml(dcsDir, verbose) {
+  const filePath = path2.join(dcsDir, "pages.yaml");
+  const result = {
+    file: ".dcs/pages.yaml",
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  try {
+    const content = await fs2.readFile(filePath, "utf8");
+    const config2 = yaml.load(content);
+    if (config2.version === void 0) {
+      result.errors.push("Missing required field: version");
+      result.valid = false;
+    }
+    if (!config2.siteSlug) {
+      result.errors.push("Missing required field: siteSlug");
+      result.valid = false;
+    }
+    const pages = config2.pages;
+    if (!pages || !Array.isArray(pages)) {
+      result.errors.push("Missing or invalid pages array");
+      result.valid = false;
+    } else {
+      const hasHome = pages.some((p) => p.slug === "home");
+      if (!hasHome) {
+        result.warnings.push("No home page defined (slug: home)");
+      }
+      for (let i = 0; i < pages.length; i++) {
+        const page = pages[i];
+        if (!page.slug) {
+          result.errors.push(`Page ${i}: missing slug`);
+          result.valid = false;
+        }
+        if (!page.path) {
+          result.errors.push(`Page ${i}: missing path`);
+          result.valid = false;
+        }
+        if (!page.type) {
+          result.warnings.push(`Page '${page.slug}': missing type (defaulting to static)`);
+        }
+      }
+      if (verbose) {
+        console.log(chalk5.dim(`  ${pages.length} pages defined`));
+      }
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      result.errors.push("File not found");
+    } else {
+      result.errors.push(`Parse error: ${error.message}`);
+    }
+    result.valid = false;
+  }
+  return result;
+}
+async function validateContentYaml(dcsDir, verbose) {
+  const filePath = path2.join(dcsDir, "content.yaml");
+  const result = {
+    file: ".dcs/content.yaml",
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  try {
+    const content = await fs2.readFile(filePath, "utf8");
+    const config2 = yaml.load(content);
+    if (config2.version === void 0) {
+      result.errors.push("Missing required field: version");
+      result.valid = false;
+    }
+    if (config2.global !== void 0 && typeof config2.global !== "object") {
+      result.errors.push("global must be an object");
+      result.valid = false;
+    }
+    if (config2.pages !== void 0 && typeof config2.pages !== "object") {
+      result.errors.push("pages must be an object");
+      result.valid = false;
+    }
+    if (verbose) {
+      const globalKeys = config2.global ? Object.keys(config2.global).length : 0;
+      const pageCount = config2.pages ? Object.keys(config2.pages).length : 0;
+      console.log(chalk5.dim(`  ${globalKeys} global keys, ${pageCount} page sections`));
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      result.errors.push("File not found");
+    } else {
+      result.errors.push(`Parse error: ${error.message}`);
+    }
+    result.valid = false;
+  }
+  return result;
+}
+async function validateSeoYaml(dcsDir, verbose) {
+  const filePath = path2.join(dcsDir, "seo.yaml");
+  const result = {
+    file: ".dcs/seo.yaml",
+    valid: true,
+    errors: [],
+    warnings: []
+  };
+  try {
+    const content = await fs2.readFile(filePath, "utf8");
+    const config2 = yaml.load(content);
+    if (config2.version === void 0) {
+      result.errors.push("Missing required field: version");
+      result.valid = false;
+    }
+    const global = config2.global;
+    if (!global) {
+      result.errors.push("Missing required section: global");
+      result.valid = false;
+    } else {
+      if (!global.siteName) {
+        result.warnings.push("global.siteName is not set");
+      }
+      if (!global.siteUrl) {
+        result.warnings.push("global.siteUrl is not set (required for SEO)");
+      }
+      if (!global.defaultDescription) {
+        result.warnings.push("global.defaultDescription is not set");
+      }
+    }
+    const pages = config2.pages;
+    if (pages && typeof pages === "object") {
+      const pageKeys = Object.keys(pages);
+      if (!pageKeys.includes("home")) {
+        result.warnings.push("No SEO configuration for home page");
+      }
+      if (verbose) {
+        console.log(chalk5.dim(`  ${pageKeys.length} page SEO configs`));
+      }
+    }
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      result.errors.push("File not found");
+    } else {
+      result.errors.push(`Parse error: ${error.message}`);
+    }
+    result.valid = false;
+  }
+  return result;
+}
+
+// src/commands/plans.ts
+import fs3 from "fs/promises";
+import path3 from "path";
+import chalk6 from "chalk";
+import yaml2 from "js-yaml";
+async function plansCommand(options) {
+  const { target = ".", force = false } = options;
+  const targetDir = path3.resolve(target);
+  const dcsDir = path3.join(targetDir, ".dcs");
+  const plansDir = path3.join(targetDir, ".plans");
+  console.log(chalk6.bold("Generating DCS integration plans..."));
+  console.log(chalk6.dim(`Directory: ${targetDir}`));
+  console.log();
+  try {
+    await fs3.access(dcsDir);
+  } catch {
+    console.log(chalk6.red("No .dcs directory found."));
+    console.log("Run", chalk6.cyan("dcs init"), "first to create DCS configuration.");
+    process.exit(1);
+  }
+  let siteName = "Customer Site";
+  let framework = "vue";
+  try {
+    const siteYaml = await fs3.readFile(path3.join(dcsDir, "site.yaml"), "utf8");
+    const siteConfig = yaml2.load(siteYaml);
+    siteName = siteConfig.site_name || siteName;
+    const metadata = siteConfig.metadata;
+    framework = metadata?.framework || framework;
+  } catch {
+    console.log(chalk6.yellow("Warning: Could not read site.yaml"));
+  }
+  const plans = [
+    { name: "00-audit-site.md", content: generateAuditPlan(siteName) },
+    { name: "01-create-use-text-content.md", content: generateTextContentPlan(siteName, framework) },
+    { name: "02-integrate-home-page.md", content: generateHomePagePlan(siteName) },
+    { name: "03-integrate-remaining-pages.md", content: generateRemainingPagesPlan(siteName) },
+    { name: "04-capture-snapshots.md", content: generateSnapshotsPlan(siteName) },
+    { name: "05-verify-deployment.md", content: generateVerifyPlan(siteName) }
+  ];
+  await fs3.mkdir(plansDir, { recursive: true });
+  const generatedFiles = [];
+  for (const plan of plans) {
+    const filePath = path3.join(plansDir, plan.name);
+    try {
+      await fs3.access(filePath);
+      if (!force) {
+        console.log(chalk6.yellow(`Skipped (exists): .plans/${plan.name}`));
+        continue;
+      }
+    } catch {
+    }
+    await fs3.writeFile(filePath, plan.content, "utf8");
+    generatedFiles.push(plan.name);
+    console.log(`${chalk6.green("\u2713")} .plans/${plan.name}`);
+  }
+  console.log();
+  if (generatedFiles.length > 0) {
+    console.log(chalk6.green(`Generated ${generatedFiles.length} plan files.`));
+  } else {
+    console.log(chalk6.yellow("No new files generated. Use --force to overwrite existing files."));
+  }
+}
+function generateAuditPlan(siteName) {
+  return `# Plan 00: Audit ${siteName} Site Structure
+
+## Objective
+
+Analyze the current site structure to understand:
+- What pages exist and their routing structure
+- Current component organization
+- Existing content patterns
+- Build/deploy configuration
+
+## Steps
+
+### Step 1: List All Pages
+
+Scan the project for page components:
+
+\`\`\`
+# For VitePress
+ls docs/**/*.md
+
+# For Vue/Vite
+ls src/pages/**/*.vue
+ls src/views/**/*.vue
+\`\`\`
+
+### Step 2: Identify Content Patterns
+
+Look for:
+- Hardcoded text strings in templates
+- Existing i18n or content management
+- Props-based content passing
+- API-driven content
+
+### Step 3: Document Current Structure
+
+Create a list of:
+1. All page routes
+2. Reusable components with text content
+3. Layout components (header, footer)
+4. Any existing SEO implementation
+
+### Step 4: Update pages.yaml
+
+Update \`.dcs/pages.yaml\` with all discovered pages:
+
+\`\`\`yaml
+pages:
+  - slug: home
+    path: /
+    type: static
+    title: Home
+    deletable: false
+  # Add discovered pages here...
+\`\`\`
+
+## Output
+
+- Updated \`.dcs/pages.yaml\` with all pages
+- List of components requiring content integration
+- Notes on any existing content management to migrate
+`;
+}
+function generateTextContentPlan(siteName, framework) {
+  return `# Plan 01: Create useTextContent Composable for ${siteName}
+
+## Objective
+
+Set up the text content composable for runtime/build-time content management.
+
+## Prerequisites
+
+- \`@duffcloudservices/cms\` package installed
+- Vite/VitePress project configured
+
+## Steps
+
+### Step 1: Install CMS Package
+
+\`\`\`bash
+pnpm add @duffcloudservices/cms
+\`\`\`
+
+### Step 2: Configure Vite Plugin
+
+${framework === "vue" ? `
+In \`vite.config.ts\`:
+
+\`\`\`typescript
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { dcsContentPlugin } from '@duffcloudservices/cms/plugins'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    dcsContentPlugin({ path: '.dcs/content.yaml' }),
+  ],
+})
+\`\`\`
+` : `
+In \`.vitepress/config.ts\`:
+
+\`\`\`typescript
+import { defineConfig } from 'vitepress'
+import { dcsContentPlugin } from '@duffcloudservices/cms/plugins'
+
+export default defineConfig({
+  vite: {
+    plugins: [
+      dcsContentPlugin({ path: '.dcs/content.yaml' }),
+    ],
+  },
+})
+\`\`\`
+`}
+
+### Step 3: Create Site Composable Wrapper (Optional)
+
+Create a site-specific wrapper for consistent defaults:
+
+\`\`\`typescript
+// src/composables/useContent.ts
+import { useTextContent as baseuseTextContent } from '@duffcloudservices/cms'
+
+export function useContent(pageSlug: string, defaults: Record<string, string> = {}) {
+  return baseuseTextContent({ pageSlug, defaults })
+}
+\`\`\`
+
+## Verification
+
+1. Run \`pnpm dev\` - should start without errors
+2. Import and use composable in a test component
+3. Verify content.yaml values are accessible via \`t()\` function
+`;
+}
+function generateHomePagePlan(siteName) {
+  return `# Plan 02: Integrate Home Page for ${siteName}
+
+## Objective
+
+Add DCS CMS integration to the home page, including:
+- Text content management
+- SEO configuration
+- Data attributes for visual editor
+
+## Steps
+
+### Step 1: Identify Home Page Component
+
+Find the main home page component:
+- VitePress: \`docs/index.md\` or \`docs/.vitepress/theme/components/Home.vue\`
+- Vue: \`src/pages/index.vue\` or \`src/views/Home.vue\`
+
+### Step 2: Add Text Content Integration
+
+Replace hardcoded text with \`t()\` function calls:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useTextContent, useSEO } from '@duffcloudservices/cms'
+
+const { t } = useTextContent({
+  pageSlug: 'home',
+  defaults: {
+    'hero.title': 'Welcome to ${siteName}',
+    'hero.subtitle': 'Your subtitle here',
+    'hero.cta': 'Get Started',
+    // Add all text content...
+  }
+})
+
+// Apply SEO
+const { applyHead } = useSEO('home')
+applyHead()
+</script>
+
+<template>
+  <section data-dcs-section="hero">
+    <h1 data-dcs-text="hero.title">{{ t('hero.title') }}</h1>
+    <p data-dcs-text="hero.subtitle">{{ t('hero.subtitle') }}</p>
+    <button data-dcs-text="hero.cta">{{ t('hero.cta') }}</button>
+  </section>
+</template>
+\`\`\`
+
+### Step 3: Update content.yaml
+
+Add all discovered text keys to \`.dcs/content.yaml\`:
+
+\`\`\`yaml
+pages:
+  home:
+    hero.title: "Welcome to ${siteName}"
+    hero.subtitle: "Your subtitle here"
+    hero.cta: "Get Started"
+\`\`\`
+
+### Step 4: Update seo.yaml
+
+Configure SEO for the home page in \`.dcs/seo.yaml\`:
+
+\`\`\`yaml
+pages:
+  home:
+    title: Home
+    description: "Description for ${siteName}"
+    noTitleTemplate: true
+    openGraph:
+      type: website
+\`\`\`
+
+## Verification
+
+1. Run \`pnpm dev\` and verify home page renders correctly
+2. Check browser console for any errors
+3. Verify SEO meta tags in page source
+4. Test that data-dcs-* attributes are present
+`;
+}
+function generateRemainingPagesPlan(siteName) {
+  return `# Plan 03: Integrate Remaining Pages for ${siteName}
+
+## Objective
+
+Apply the same integration pattern to all remaining pages identified in the audit.
+
+## Steps
+
+### For Each Page
+
+1. **Open the page component**
+
+2. **Add imports and composable setup**:
+
+\`\`\`vue
+<script setup lang="ts">
+import { useTextContent, useSEO } from '@duffcloudservices/cms'
+
+const { t } = useTextContent({
+  pageSlug: 'PAGE_SLUG', // Match pages.yaml slug
+  defaults: {
+    // Add all text content with sensible defaults
+  }
+})
+
+const { applyHead } = useSEO('PAGE_SLUG')
+applyHead()
+</script>
+\`\`\`
+
+3. **Replace all hardcoded text** with \`t()\` calls
+
+4. **Add data-dcs-* attributes** to sections and text elements
+
+5. **Update content.yaml** with the page's text content
+
+6. **Update seo.yaml** with SEO configuration
+
+### Global Components
+
+Don't forget shared components like:
+- Header/Navigation
+- Footer
+- Sidebar
+
+These should use \`pageSlug: 'global'\` for shared content.
+
+## Checklist
+
+- [ ] About page
+- [ ] Contact page
+- [ ] Services/Products pages
+- [ ] Blog index (if applicable)
+- [ ] Header component
+- [ ] Footer component
+- [ ] Any other pages...
+
+## Verification
+
+For each page:
+1. Page renders correctly
+2. No console errors
+3. SEO meta tags present
+4. Data attributes present
+`;
+}
+function generateSnapshotsPlan(siteName) {
+  return `# Plan 04: Configure Snapshot Capture for ${siteName}
+
+## Objective
+
+Ensure the visual page editor can capture accurate snapshots of all pages.
+
+## Prerequisites
+
+- All pages integrated with \`useTextContent\`
+- All pages have \`data-dcs-section\` attributes
+- All editable text has \`data-dcs-text\` attributes
+
+## Steps
+
+### Step 1: Verify pages.yaml
+
+Ensure all pages are listed in \`.dcs/pages.yaml\`:
+
+\`\`\`yaml
+pages:
+  - slug: home
+    path: /
+    type: static
+    title: Home
+    deletable: false
+  # All other pages...
+
+excluded:
+  - /404
+  - /dev-*
+  - /_*
+\`\`\`
+
+### Step 2: Configure Snapshot Settings
+
+Review snapshot configuration:
+
+\`\`\`yaml
+snapshot:
+  viewport:
+    width: 1280
+    height: 720
+  waitAfterLoad: 3000  # Adjust if page has animations
+  captureFullPage: true
+\`\`\`
+
+### Step 3: Test Local Snapshots
+
+Build and preview the site:
+
+\`\`\`bash
+pnpm build
+pnpm preview
+\`\`\`
+
+Manually verify each page:
+1. Opens correctly
+2. All content is visible
+3. No loading spinners or placeholders
+
+### Step 4: Verify Data Attributes
+
+Use browser DevTools to check:
+- Each section has \`data-dcs-section\`
+- Each editable text element has \`data-dcs-text\`
+- Attribute values match content.yaml keys
+
+## Verification
+
+1. Site builds without errors
+2. All pages accessible at documented paths
+3. Data attributes present in rendered HTML
+4. No dynamic content that would prevent snapshot capture
+`;
+}
+function generateVerifyPlan(siteName) {
+  return `# Plan 05: Verify Deployment for ${siteName}
+
+## Objective
+
+Test the complete integration before handing off to the DCS Portal.
+
+## Steps
+
+### Step 1: Run Validation
+
+\`\`\`bash
+npx @duffcloudservices/cli validate
+\`\`\`
+
+Fix any reported errors or warnings.
+
+### Step 2: Build Test
+
+\`\`\`bash
+pnpm build
+\`\`\`
+
+Ensure no build errors related to:
+- Missing content keys
+- SEO configuration
+- Vite plugin issues
+
+### Step 3: Local Preview
+
+\`\`\`bash
+pnpm preview
+\`\`\`
+
+Verify:
+- [ ] Home page loads correctly
+- [ ] All pages accessible
+- [ ] SEO meta tags correct
+- [ ] No console errors
+- [ ] Content displays correctly
+
+### Step 4: Deploy to Staging
+
+Deploy to Azure Static Web Apps staging environment:
+
+\`\`\`bash
+# If using GitHub Actions, push to a PR branch
+git push origin feature/dcs-integration
+\`\`\`
+
+### Step 5: Portal Registration
+
+1. Log in to DCS Portal
+2. Navigate to Sites > Add Site
+3. Enter site slug and GitHub repo
+4. Trigger initial snapshot capture
+
+### Step 6: Visual Editor Test
+
+1. Open the site in DCS Portal
+2. Navigate to Pages
+3. Select a page
+4. Verify visual editor loads correctly
+5. Test editing a text field
+6. Save and verify changes deploy
+
+## Success Criteria
+
+- [ ] All validation passes
+- [ ] Site builds and deploys
+- [ ] Portal can capture snapshots
+- [ ] Visual editor works
+- [ ] Content changes deploy correctly
+
+## Handoff
+
+Once verified:
+1. Merge the integration PR
+2. Notify the site owner
+3. Provide portal access credentials
+`;
+}
+
+// src/index.ts
+var program = new Command();
+program.name("dcs").description("DCS (Duff Cloud Services) CLI for customer site management").version(version);
+program.command("login").description("Authenticate with DCS Portal using Google OAuth").action(async () => {
+  await loginCommand();
+});
+program.command("logout").description("Clear stored credentials").action(async () => {
+  await logoutCommand();
+});
+program.command("whoami").description("Display current authenticated user").action(async () => {
+  await whoamiCommand();
+});
+var sitesCmd = program.command("sites").description("Manage customer sites");
+sitesCmd.command("list").description("List sites you have access to").action(async () => {
+  await listSitesCommand();
+});
+sitesCmd.command("show <slug>").description("Show details for a specific site").action(async (slug) => {
+  await showSiteCommand(slug);
+});
+program.command("init").description("Initialize DCS integration for a customer site").requiredOption("-s, --site-slug <slug>", "Site slug (lowercase, hyphens)").requiredOption("-n, --site-name <name>", "Human-readable site name").option("-f, --framework <framework>", "Site framework (vue, astro)", "vue").option("-t, --target <dir>", "Target directory", ".").option("--dry-run", "Show what would be created without writing files").option("--force", "Overwrite existing files").action(async (options) => {
+  await initCommand({
+    siteSlug: options.siteSlug,
+    siteName: options.siteName,
+    framework: options.framework,
+    target: options.target,
+    dryRun: options.dryRun,
+    force: options.force
+  });
+});
+program.command("validate").description("Validate .dcs configuration files").option("-t, --target <dir>", "Target directory", ".").option("--fix", "Attempt to fix common issues").option("-v, --verbose", "Show detailed output").action(async (options) => {
+  await validateCommand({
+    target: options.target,
+    fix: options.fix,
+    verbose: options.verbose
+  });
+});
+program.command("plans").description("Generate DCS integration plan files for AI-assisted onboarding").option("-t, --target <dir>", "Target directory", ".").option("--force", "Overwrite existing plan files").action(async (options) => {
+  await plansCommand({
+    target: options.target,
+    force: options.force
+  });
+});
+program.exitOverride();
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  if (error instanceof Error) {
+    if (error.code === "commander.helpDisplayed" || error.code === "commander.version") {
+      process.exit(0);
+    }
+    console.error(chalk7.red("Error:"), error.message);
+    process.exit(1);
+  }
+}
+//# sourceMappingURL=index.js.map