swallowkit 1.0.2 → 1.1.0

package/src/__tests__/migration.test.ts

@@ -0,0 +1,116 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import {
+  checksumAtVersion,
+  collectLegacyBaselineFiles,
+  createMigrationManifest,
+  decodeMigrationState,
+  encodeMigrationState,
+  getMigrationTagKey,
+  findBaselineDrift,
+  loadMigrationManifest,
+  resolveMigrations,
+  saveMigrationManifest,
+  selectPendingMigrations,
+} from "../core/project/migrations";
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+describe("infrastructure migrations", () => {
+  let projectRoot: string;
+
+  beforeEach(() => {
+    projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-migrations-"));
+    writeFile(path.join(projectRoot, "infra", "main.bicep"), "targetScope = 'resourceGroup'\n");
+    writeFile(path.join(projectRoot, "infra", "main.parameters.json"), '{"parameters":{}}\n');
+    writeFile(path.join(projectRoot, "infra", "modules", "functions.bicep"), "// functions\n");
+  });
+
+  afterEach(() => fs.rmSync(projectRoot, { recursive: true, force: true }));
+
+  it("records a deterministic legacy baseline without including migrations", () => {
+    writeFile(path.join(projectRoot, "infra", "migrations", "ignored.bicep"), "// ignored\n");
+
+    const first = createMigrationManifest(projectRoot, { legacy: true, projectId: "project-one" });
+    const second = createMigrationManifest(projectRoot, { legacy: true, projectId: "project-one" });
+
+    expect(first.baseline.legacy).toBe(true);
+    expect(first.baseline.files.map((file) => file.path)).toEqual([
+      "infra/main.bicep",
+      "infra/main.parameters.json",
+      "infra/modules/functions.bicep",
+    ]);
+    expect(first.baseline.checksum).toBe(second.baseline.checksum);
+  });
+
+  it("saves and loads a manifest without overwriting it", () => {
+    const manifest = createMigrationManifest(projectRoot, { legacy: true, projectId: "project-one" });
+    saveMigrationManifest(manifest, projectRoot);
+
+    expect(loadMigrationManifest(projectRoot)).toEqual(manifest);
+    expect(() => saveMigrationManifest(manifest, projectRoot)).toThrow(/already exists/);
+  });
+
+  it("computes cumulative checksums and selects only pending migrations", () => {
+    const manifest = createMigrationManifest(projectRoot, { projectId: "project-one" });
+    writeFile(path.join(projectRoot, "infra", "migrations", "0001-products", "main.bicep"), "resource product 'Example/items@2020-01-01' = {}\n");
+    writeFile(path.join(projectRoot, "infra", "migrations", "0002-search", "main.bicep"), "resource search 'Example/search@2020-01-01' = {}\n");
+    manifest.migrations = [
+      { version: 1, slug: "products", template: "infra/migrations/0001-products/main.bicep", source: "model", sourceModel: "Product" },
+      { version: 2, slug: "search", template: "infra/migrations/0002-search/main.bicep", source: "custom" },
+    ];
+
+    const resolved = resolveMigrations(manifest, projectRoot);
+    const pending = selectPendingMigrations(manifest, {
+      schemaVersion: 1,
+      version: 1,
+      checksum: resolved[0].cumulativeChecksum,
+    }, projectRoot);
+
+    expect(resolved[0].checksum).toHaveLength(64);
+    expect(resolved[1].cumulativeChecksum).not.toBe(resolved[0].cumulativeChecksum);
+    expect(pending.map((migration) => migration.version)).toEqual([2]);
+    expect(checksumAtVersion(manifest, 0, projectRoot)).toBe(manifest.baseline.checksum);
+  });
+
+  it("rejects gaps, traversal, remote-ahead state, and checksum drift", () => {
+    const manifest = createMigrationManifest(projectRoot, { projectId: "project-one" });
+    manifest.migrations = [{ version: 2, slug: "bad", template: "../bad.bicep", source: "custom" }];
+    expect(() => resolveMigrations(manifest, projectRoot)).toThrow(/contiguous/);
+
+    manifest.migrations = [];
+    expect(() => selectPendingMigrations(manifest, {
+      schemaVersion: 1,
+      version: 1,
+      checksum: manifest.baseline.checksum,
+    }, projectRoot)).toThrow(/Azure is at migration 1/);
+    expect(() => selectPendingMigrations(manifest, {
+      schemaVersion: 1,
+      version: 0,
+      checksum: "0".repeat(64),
+    }, projectRoot)).toThrow(/does not match/);
+  });
+
+  it("round-trips project-specific Azure tag state", () => {
+    const state = { schemaVersion: 1 as const, version: 12, checksum: "a".repeat(64) };
+    expect(decodeMigrationState(encodeMigrationState(state))).toEqual(state);
+    expect(getMigrationTagKey("project-one")).toMatch(/^swallowkit-migration-[a-f0-9]{12}$/);
+    expect(getMigrationTagKey("project-one")).not.toBe(getMigrationTagKey("project-two"));
+    expect(() => decodeMigrationState("broken")).toThrow(/invalid/);
+  });
+
+  it("collects current baseline file hashes", () => {
+    expect(collectLegacyBaselineFiles(projectRoot)).toHaveLength(3);
+  });
+
+  it("detects edits to baseline files after initialization", () => {
+    const manifest = createMigrationManifest(projectRoot, { projectId: "project-one" });
+    writeFile(path.join(projectRoot, "infra", "main.bicep"), "// changed\n");
+
+    expect(findBaselineDrift(manifest, projectRoot)).toEqual(["infra/main.bicep"]);
+  });
+});

package/src/__tests__/plan-apply.test.ts

@@ -4,6 +4,7 @@ import * as path from "path";
 import * as childProcess from "child_process";
 import { EventEmitter } from "events";
 import { runMachineCli } from "../machine";
+import { getCSharpSchemaModelPath } from "../core/scaffold/native-schema-generator";
 
 jest.mock("child_process", () => {
   const actual = jest.requireActual<typeof import("child_process")>("child_process");
@@ -329,8 +330,8 @@ describe("plan / apply / drift / verify machine commands", () => {
       `import { z } from 'zod/v4';
 export const LearningQuestion = z.object({
   id: z.string(),
-  kind: z.enum(['grammar', 'vocabulary']),
-  level: z.literal('5'),
+  kind: z.enum(['grammar', 'in_progress', '123', '5級', 'a-b', 'a_b', 'class']),
+  examLevel: z.literal('5'),
   createdAt: z.string().optional(),
   updatedAt: z.string().optional(),
 });
@@ -355,21 +356,50 @@ export type LearningQuestion = z.infer<typeof LearningQuestion>;
         fs.readFileSync(path.join(tempDir, "functions", "openapi", "learning-question.openapi.json"), "utf-8")
       );
       const properties = openApi.components.schemas.LearningQuestion.properties;
-      expect(properties.kind.enum).toEqual(["grammar", "vocabulary"]);
-      expect(properties.level.enum).toEqual(["5"]);
+      expect(properties.kind.enum).toEqual(["grammar", "in_progress", "123", "5級", "a-b", "a_b", "class"]);
+      expect(properties.examLevel.enum).toEqual(["5"]);
 
-      const csharp = fs.readFileSync(
-        path.join(tempDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "LearningQuestion.cs"),
-        "utf-8"
-      );
+      const csharpOutputDir = path.join(tempDir, "functions", "generated", "csharp-models");
+      const csharp = fs.readFileSync(getCSharpSchemaModelPath(csharpOutputDir, "LearningQuestion"), "utf-8");
       expect(csharp).toContain("public enum KindEnum");
-      expect(csharp).toContain("public enum LevelEnum");
+      expect(csharp).toContain("public enum ExamLevelEnum");
+      expect(csharp).toContain("Grammar = 1");
+      expect(csharp).toContain("InProgress = 2");
+      expect(csharp).toContain("Value123 = 3");
+      expect(csharp).toContain("Value5U7D1A = 4");
+      expect(csharp).toContain("AB_612D62 = 5");
+      expect(csharp).toContain("AB_615F62 = 6");
+      expect(csharp).toContain("Class = 7");
+      expect(csharp).toContain("Value5 = 1");
+      expect(csharp).toContain('value.Equals("5", StringComparison.Ordinal)');
+      expect(csharp).toContain("return ExamLevelEnum.Value5;");
+      expect(csharp).toContain('return "5";');
+      expect(csharp).toContain('value.Equals("a-b", StringComparison.Ordinal)');
+      expect(csharp).toContain("return KindEnum.AB_612D62;");
+      expect(csharp).toContain("if (value == KindEnum.AB_615F62)");
+      expect(csharp).toContain('return "a_b";');
       expect(csharp).not.toContain("Dictionary<string, object> Kind");
-      expect(csharp).not.toContain("Dictionary<string, object> Level");
+      expect(csharp).not.toContain("Dictionary<string, object> ExamLevel");
+
+      writeFile(
+        path.join(csharpOutputDir, "SwallowKitBackendModels.csproj"),
+        `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+</Project>
+`
+      );
+      expect(() => childProcess.execFileSync("dotnet", ["build", "--nologo", "--verbosity", "quiet"], {
+        cwd: csharpOutputDir,
+        stdio: "pipe",
+        timeout: 120_000,
+      })).not.toThrow();
     } finally {
       restoreCodegenMocks();
     }
-  });
+  }, 150_000);
 
   it("leaves the project untouched when the native toolchain validation fails on apply", async () => {
     createNativeBackendFixture(tempDir, "csharp");

package/src/__tests__/scaffold.test.ts

@@ -16,6 +16,7 @@ import {
   getPythonSchemaModelPath,
 } from "../core/scaffold/native-schema-generator";
 import { createBasicModelInfo } from "./fixtures";
+import { createMigrationManifest, saveMigrationManifest } from "../core/project/migrations";
 
 describe("authenticated UI scaffold layouts", () => {
   const originalCwd = process.cwd();
@@ -215,6 +216,7 @@ describe("generateCosmosContainer", () => {
     process.chdir(tempDir);
     fs.mkdirSync(path.join(tempDir, "infra", "containers"), { recursive: true });
     fs.writeFileSync(path.join(tempDir, "infra", "main.bicep"), "module cosmosDbServerless 'modules/cosmosdb-serverless.bicep' = if (cosmosDbMode == 'serverless') {\n  name: 'cosmosDb'\n}\n");
+    saveMigrationManifest(createMigrationManifest(tempDir, { projectId: "test-project" }), tempDir);
   });
 
   afterEach(() => {
@@ -222,18 +224,19 @@ describe("generateCosmosContainer", () => {
     fs.rmSync(tempDir, { recursive: true, force: true });
   });
 
-  it("generates container templates without container-level throughput settings", async () => {
+  it("generates a container migration without changing main.bicep", async () => {
+    const mainBefore = fs.readFileSync(path.join(tempDir, "infra", "main.bicep"), "utf-8");
     await generateCosmosContainer({ name: "SurveyResponse", partitionKey: "/id" });
 
-    const containerFilePath = path.join(tempDir, "infra", "containers", "survey-response-container.bicep");
+    const containerFilePath = path.join(tempDir, "infra", "migrations", "0001-create-survey-response-container", "main.bicep");
     const containerContent = fs.readFileSync(containerFilePath, "utf-8");
     const mainContent = fs.readFileSync(path.join(tempDir, "infra", "main.bicep"), "utf-8");
 
     expect(containerContent).toContain("resource container");
+    expect(containerContent).toContain("existing");
     expect(containerContent).not.toContain("throughput");
     expect(containerContent).not.toContain("options:");
-    expect(mainContent).toContain("module surveyResponseContainer 'containers/survey-response-container.bicep'");
-    expect(mainContent).not.toContain("dependsOn");
+    expect(mainContent).toBe(mainBefore);
   });
 });
   describe("non-destructive native schema generation", () => {

package/src/cli/commands/create-migration.ts

@@ -0,0 +1,13 @@
+import { Command } from "commander";
+import { ensureSwallowKitProject } from "../../core/config";
+import { createCustomMigration } from "../../core/operations/migration-generator";
+
+export const createMigrationCommand = new Command("create-migration")
+  .description("Create a versioned Bicep migration for additional Azure resources")
+  .argument("<slug>", "Kebab-case migration name")
+  .action((slug: string) => {
+    ensureSwallowKitProject("create-migration");
+    const migration = createCustomMigration(slug);
+    console.log(`Created migration ${migration.version}: ${migration.template}`);
+    console.log("Edit the Bicep file, then run provision to plan and apply it.");
+  });

package/src/cli/commands/index.ts

@@ -7,3 +7,5 @@ export { devCommand } from "./dev";
 export { devSeedsCommand } from "./dev-seeds";
 export { scaffoldCommand } from "./scaffold";
 export { createModelCommand } from "./create-model";
+export { createMigrationCommand } from "./create-migration";
+export { migrationsCommand } from "./migrations";

package/src/cli/commands/init.ts

@@ -19,6 +19,7 @@ import {
 import { syncProjectManifest } from "../../core/project/manifest";
 import { writeWorkflowDocs, writeAgentSkills } from "../../core/project/workflows";
 import { writeAgentInstructionFiles } from "../../core/project/agent-instructions";
+import { initializeNewProjectMigrations } from "../../core/operations/migration-generator";
 import {
   buildCSharpCodegenToolManifestSource,
   buildPythonCodegenRequirementsSource,
@@ -2759,6 +2760,7 @@ output privateDnsZoneId string = privateDnsZone.id
 
   console.log('✅ VNet module definitions created\n');
 
+  initializeNewProjectMigrations(projectDir);
   console.log('✅ Infrastructure files created\n');
 }
 

package/src/cli/commands/migrations.ts

@@ -0,0 +1,20 @@
+import { Command } from "commander";
+import { ensureSwallowKitProject } from "../../core/config";
+import { initializeLegacyMigrations } from "../../core/operations/migration-generator";
+
+export const migrationsCommand = new Command("migrations")
+  .description("Manage versioned Azure infrastructure migrations");
+
+migrationsCommand
+  .command("init")
+  .description("Initialize migration tracking for an existing SwallowKit project")
+  .option("--legacy-baseline", "Record the current infra directory as version 0")
+  .action((options: { legacyBaseline?: boolean }) => {
+    ensureSwallowKitProject("migrations init");
+    if (!options.legacyBaseline) {
+      throw new Error("Existing projects must be initialized with --legacy-baseline.");
+    }
+    const manifest = initializeLegacyMigrations();
+    console.log(`Migration baseline 0 created for project ${manifest.projectId}.`);
+    console.log("Commit infra/migrations/manifest.json, then run provision with --adopt-existing --baseline 0.");
+  });

package/src/cli/commands/provision.ts

@@ -1,193 +1,124 @@
-import { Command } from 'commander';
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-import prompts from 'prompts';
-import { ensureSwallowKitProject } from '../../core/config';
-
-export const provisionCommand = new Command('provision')
-  .description('Provision Azure resources using Bicep templates')
-  .requiredOption('-g, --resource-group <name>', 'Resource group name')
-  .option('--subscription <id>', 'Azure subscription ID (optional)')
-  .action(async (options) => {
-    // SwallowKit プロジェクトディレクトリかどうかを検証
+import { Command } from "commander";
+import prompts from "prompts";
+import { ensureSwallowKitProject } from "../../core/config";
+import { applyProvisionOperation, planProvisionOperation } from "../../core/operations/provision-operations";
+
+const PRIMARY_REGIONS = [
+  { title: "Japan East (japaneast)", value: "japaneast" },
+  { title: "Japan West (japanwest)", value: "japanwest" },
+  { title: "East Asia (eastasia)", value: "eastasia" },
+  { title: "Southeast Asia (southeastasia)", value: "southeastasia" },
+  { title: "East US (eastus)", value: "eastus" },
+  { title: "East US 2 (eastus2)", value: "eastus2" },
+  { title: "West US 2 (westus2)", value: "westus2" },
+  { title: "Central US (centralus)", value: "centralus" },
+  { title: "West Europe (westeurope)", value: "westeurope" },
+];
+
+const SWA_REGIONS = [
+  { title: "East Asia (eastasia) - Recommended for Japan", value: "eastasia" },
+  { title: "West US 2 (westus2)", value: "westus2" },
+  { title: "Central US (centralus)", value: "centralus" },
+  { title: "East US 2 (eastus2)", value: "eastus2" },
+  { title: "West Europe (westeurope)", value: "westeurope" },
+];
+
+interface ProvisionCliOptions {
+  resourceGroup: string;
+  subscription?: string;
+  location?: string;
+  swaLocation?: string;
+  whatIf?: boolean;
+  adoptExisting?: boolean;
+  baseline?: string;
+  reconcile?: boolean;
+  approve?: boolean;
+}
+
+async function resolveLocations(options: ProvisionCliOptions): Promise<{ location: string; swaLocation: string }> {
+  if (options.location && options.swaLocation) {
+    return { location: options.location, swaLocation: options.swaLocation };
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error("Non-interactive provision requires --location and --swa-location.");
+  }
+  const answer = await prompts([
+    {
+      type: options.location ? null : "select",
+      name: "location",
+      message: "Primary location for Functions and Cosmos DB",
+      choices: PRIMARY_REGIONS,
+      initial: 0,
+    },
+    {
+      type: options.swaLocation ? null : "select",
+      name: "swaLocation",
+      message: "Static Web App location",
+      choices: SWA_REGIONS,
+      initial: 0,
+    },
+  ]);
+  const location = options.location ?? answer.location;
+  const swaLocation = options.swaLocation ?? answer.swaLocation;
+  if (!location || !swaLocation) throw new Error("Region selection cancelled.");
+  return { location, swaLocation };
+}
+
+export const provisionCommand = new Command("provision")
+  .description("Bootstrap, adopt, migrate, or explicitly reconcile Azure resources")
+  .requiredOption("-g, --resource-group <name>", "Resource group name")
+  .option("--subscription <id>", "Azure subscription ID")
+  .option("--location <region>", "Primary location for Functions and Cosmos DB")
+  .option("--swa-location <region>", "Static Web App location")
+  .option("--what-if", "Include Azure what-if evidence", false)
+  .option("--adopt-existing", "Adopt an existing untagged resource group without deploying main.bicep", false)
+  .option("--baseline <version>", "Baseline version for adoption (currently 0)")
+  .option("--reconcile", "Explicitly redeploy infra/main.bicep", false)
+  .option("--approve", "Apply the displayed plan without an interactive confirmation", false)
+  .action(async (options: ProvisionCliOptions) => {
     ensureSwallowKitProject("provision");
-
-    console.log('🚀 Starting Azure resource provisioning...\n');
-
-    // Check if Azure CLI is installed
-    try {
-      execSync('az --version', { stdio: 'ignore' });
-    } catch {
-      console.error('❌ Azure CLI is not installed. Please install it first: https://aka.ms/azure-cli');
-      process.exit(1);
+    const locations = await resolveLocations(options);
+    const baseline = options.baseline === undefined ? undefined : Number(options.baseline);
+    const plan = await planProvisionOperation({
+      resourceGroup: options.resourceGroup,
+      subscription: options.subscription,
+      location: locations.location,
+      swaLocation: locations.swaLocation,
+      whatIf: options.whatIf,
+      adoptExisting: options.adoptExisting,
+      baseline,
+      reconcile: options.reconcile,
+    });
+
+    console.log(`Provision mode: ${plan.mode}`);
+    for (const warning of plan.warnings) console.warn(`Warning: ${warning}`);
+    if (plan.pendingMigrations.length > 0) {
+      console.log(`Pending migrations: ${plan.pendingMigrations.map((migration) => `${migration.version}-${migration.slug}`).join(", ")}`);
     }
+    for (const command of plan.commands) console.log(`  ${command}`);
 
-    // Check if Bicep files exist
-    const infraDir = path.join(process.cwd(), 'infra');
-    const mainBicepPath = path.join(infraDir, 'main.bicep');
-    const parametersPath = path.join(infraDir, 'main.parameters.json');
-
-    if (!fs.existsSync(mainBicepPath)) {
-      console.error('❌ Bicep files not found. Run "swallowkit init" first to generate infrastructure files.');
-      process.exit(1);
+    if (plan.mode === "adoption-required") {
+      throw new Error('Existing resource group requires: migrations init --legacy-baseline, then provision --adopt-existing --baseline 0 --what-if.');
     }
 
-    try {
-      // Prompt for region selection
-      console.log('📍 Select Azure regions for your resources:\n');
-      
-      const regionChoices = await prompts([
-        {
-          type: 'select',
-          name: 'primaryLocation',
-          message: 'Primary location for Functions and Cosmos DB',
-          choices: [
-            { title: 'Japan East (japaneast)', value: 'japaneast' },
-            { title: 'Japan West (japanwest)', value: 'japanwest' },
-            { title: 'East Asia (eastasia)', value: 'eastasia' },
-            { title: 'Southeast Asia (southeastasia)', value: 'southeastasia' },
-            { title: 'East US (eastus)', value: 'eastus' },
-            { title: 'East US 2 (eastus2)', value: 'eastus2' },
-            { title: 'West US 2 (westus2)', value: 'westus2' },
-            { title: 'Central US (centralus)', value: 'centralus' },
-            { title: 'West Europe (westeurope)', value: 'westeurope' },
-          ],
-          initial: 0, // Default to japaneast
-        },
-        {
-          type: 'select',
-          name: 'swaLocation',
-          message: 'Static Web App location (limited availability)',
-          choices: [
-            { title: 'East Asia (eastasia) - Recommended for Japan', value: 'eastasia' },
-            { title: 'West US 2 (westus2)', value: 'westus2' },
-            { title: 'Central US (centralus)', value: 'centralus' },
-            { title: 'East US 2 (eastus2)', value: 'eastus2' },
-            { title: 'West Europe (westeurope)', value: 'westeurope' },
-          ],
-          initial: 0, // Default to eastasia
-        },
-      ], {
-        onCancel: () => {
-          throw new Error('User cancelled');
-        }
-      });
-
-      if (!regionChoices.primaryLocation || !regionChoices.swaLocation) {
-        console.log('\n❌ Region selection cancelled.');
-        process.exit(1);
+    let approved = options.approve === true;
+    if (!approved) {
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("Non-interactive provision requires --approve after reviewing the plan.");
       }
-
-      const primaryLocation = regionChoices.primaryLocation;
-      const swaLocation = regionChoices.swaLocation;
-
-      console.log(`\n✓ Primary location: ${primaryLocation}`);
-      console.log(`✓ Static Web App location: ${swaLocation}`);
-      
-      // Confirmation prompt to prevent accidental wrong selection
-      const confirmation = await prompts({
-        type: 'confirm',
-        name: 'proceed',
-        message: `Proceed with deployment to ${primaryLocation} (primary) and ${swaLocation} (SWA)?`,
-        initial: true
-      }, {
-        onCancel: () => {
-          throw new Error('User cancelled');
-        }
+      const answer = await prompts({
+        type: "confirm",
+        name: "approved",
+        message: `Apply the ${plan.mode} plan?`,
+        initial: false,
       });
-
-      if (!confirmation.proceed) {
-        console.log('\n❌ Deployment cancelled by user.');
-        process.exit(0);
-      }
-
-      console.log('');
-      // Set subscription if provided
-      if (options.subscription) {
-        console.log(`🔧 Setting subscription: ${options.subscription}`);
-        execSync(`az account set --subscription ${options.subscription}`, { stdio: 'inherit' });
-      }
-
-      // Create resource group if it doesn't exist (use primary location)
-      console.log(`🔧 Ensuring resource group exists: ${options.resourceGroup}`);
-      execSync(
-        `az group create --name ${options.resourceGroup} --location ${primaryLocation}`,
-        { stdio: 'inherit' }
-      );
-
-      // Deploy Bicep template with both locations
-      console.log('\n📦 Deploying resources (this may take several minutes)...\n');
-      const deployCommand = `az deployment group create --resource-group ${options.resourceGroup} --template-file "${mainBicepPath}" --parameters "${parametersPath}" --parameters location=${primaryLocation} --parameters swaLocation=${swaLocation}`;
-      
-      const output = execSync(deployCommand, { encoding: 'utf-8', stdio: 'pipe' });
-      const deployment = JSON.parse(output);
-
-      // Display outputs
-      console.log('\n✅ Deployment completed successfully!\n');
-      console.log('📋 Resource Information:');
-      
-      let swaName = '<swa-name>';
-      let functionAppName = '<function-name>';
-      if (deployment.properties?.outputs) {
-        const outputs = deployment.properties.outputs;
-        if (outputs.staticWebAppName) {
-          swaName = outputs.staticWebAppName.value;
-          console.log(`  - Static Web App: ${swaName}`);
-          console.log(`  - URL: https://${outputs.staticWebAppUrl.value}`);
-        }
-        if (outputs.functionsAppName) {
-          functionAppName = outputs.functionsAppName.value;
-          console.log(`  - Function App: ${functionAppName}`);
-          console.log(`  - URL: https://${outputs.functionsAppUrl.value}`);
-        }
-        if (outputs.cosmosDbAccountName) {
-          console.log(`  - Cosmos DB: ${outputs.cosmosDbAccountName.value}`);
-          console.log(`  - Database: ${outputs.cosmosDatabaseName.value}`);
-        }
-      }
-
-      // Next steps guidance
-      console.log('\n📝 Next Steps:');
-      console.log('  1. Configure CI/CD secrets/variables:\n');
-
-      // Fetch SWA deployment token
-      console.log('     [AZURE_STATIC_WEB_APPS_API_TOKEN]');
-      try {
-        const swaToken = execSync(
-          `az staticwebapp secrets list --name ${swaName} --resource-group ${options.resourceGroup} --query "properties.apiKey" -o tsv`,
-          { encoding: 'utf-8', stdio: 'pipe' }
-        ).trim();
-        console.log(`       ${swaToken}\n`);
-      } catch {
-        console.log('       ⚠️  Failed to retrieve. Run manually:');
-        console.log(`       az staticwebapp secrets list --name ${swaName} --resource-group ${options.resourceGroup} --query "properties.apiKey" -o tsv\n`);
-      }
-
-      // Function App name (already known)
-      console.log('     [AZURE_FUNCTIONAPP_NAME]');
-      console.log(`       ${functionAppName}\n`);
-
-      // Fetch Function App publish profile
-      console.log('     [AZURE_FUNCTIONAPP_PUBLISH_PROFILE]');
-      try {
-        const publishProfile = execSync(
-          `az webapp deployment list-publishing-profiles --name ${functionAppName} --resource-group ${options.resourceGroup} --xml`,
-          { encoding: 'utf-8', stdio: 'pipe' }
-        ).trim();
-        console.log(`       ${publishProfile}\n`);
-      } catch {
-        console.log('       ⚠️  Failed to retrieve. Run manually:');
-        console.log(`       az webapp deployment list-publishing-profiles --name ${functionAppName} --resource-group ${options.resourceGroup} --xml\n`);
-      }
-
-      console.log('  2. Set up your CI/CD pipeline (GitHub Actions or Azure Pipelines)');
-      console.log('  3. Manually trigger the first deployment in your CI/CD pipeline');
-      console.log('     (Automatic deployments will run on subsequent pushes)\n');
-
-    } catch (error: any) {
-      console.error('❌ Deployment failed:');
-      console.error(error.message);
-      process.exit(1);
+      approved = answer.approved === true;
+    }
+    if (!approved) {
+      console.log("Provision cancelled.");
+      return;
     }
+
+    const result = await applyProvisionOperation({ planId: plan.planId, approve: true });
+    console.log(`Provision completed (${plan.mode}). ${result.executedCommands.length} command(s) executed.`);
   });