@msn-control/liftoff 0.4.1 → 0.5.0

package/dist/commands.js

@@ -6,14 +6,15 @@ import os from 'node:os';
 import path from 'node:path';
 import { getCommandHelp, getGeneralHelp, readBooleanFlag, readListFlag, readStringFlag } from './args.js';
 import { getCodingAgent, getFrameworkDefinition, getSpecWorkflow, listRegions, patterns, providers, searchRegions } from './catalogs.js';
+import { probeCodeAppsPlugin } from './code-apps-plugin.js';
 import { initializeFramework } from './framework-adapters.js';
 import { validateFrameworkInstallation } from './framework-validation.js';
-import { artifactPath, assertNewOrEmptyDirectory, deleteProjectFile, findProjectRoot, loadManifest, manifestDisplayPath, resolveProjectPath, validateGeneratedProject, writeArtifacts, writeProjectFile } from './file-system.js';
-import { InteractivePrompter } from './interactive.js';
+import { artifactPath, applyProjectFileTransaction, assertNewOrEmptyDirectory, findProjectRoot, loadManifest, manifestDisplayPath, resolveProjectPath, validateGeneratedProject, writeArtifacts, writeProjectFile } from './file-system.js';
+import { InteractiveCancelledError, InteractivePrompter } from './interactive.js';
 import { applyMergePreflight, assertSafeInitTarget, authorizeMergePreflight, buildMergePreflight, captureTreeState, discoverGitRoot, resolveInitTargetFromDiscovery, validateStagedTree, withStagingArea, writeStagedArtifacts } from './init-filesystem.js';
 import { renderMigrationChecklist, renderMigrationProposal, renderMigrationTasks, seedMigrationGroups } from './migrate-plan.js';
 import { buildProjectPlan, loadConfigOptions, mergeOptions, PlanValidationError, projectPlanEntries } from './planner.js';
-import { buildDependencySetupPlan, runDependencySetup } from './project-dependencies.js';
+import { buildDependencySetupPlan, dependencyResumeCommand, runDependencySetup, verifyPowerAppsPackageMetadata } from './project-dependencies.js';
 import { formatCommand, NodeCommandRunner } from './process-runner.js';
 import { scanDefaults, scanLegacyProject } from './scan.js';
 import { hasDrift, reconcileProject } from './reconcile.js';
@@ -24,7 +25,9 @@ import { liftoffVersion } from './version.js';
 import { blockingReadinessFailures, detectHostEnvironment, installRequirement, probeWorkstation, selectLiftoffRuntimeRequirements, selectWorkstationRequirements } from './workstation.js';
 export async function runCommand(parsed, context) {
     const helpRequested = parsed.command !== undefined && readBooleanFlag(parsed.flags, 'help') === true;
-    const jsonMode = !helpRequested && (parsed.command === 'doctor' || parsed.command === 'update') &&
+    const jsonMode = !helpRequested && (parsed.command === 'doctor' ||
+        parsed.command === 'update' ||
+        parsed.command === 'validate') &&
         readBooleanFlag(parsed.flags, 'json') === true;
     const presentation = new PresentationSession({
         stdout: context.stdout,
@@ -80,6 +83,10 @@ export async function runCommand(parsed, context) {
         }
     }
     catch (error) {
+        if (error instanceof InteractiveCancelledError) {
+            presentation.cancellation('Interactive operation stopped.');
+            return 0;
+        }
         if (error instanceof PlanValidationError) {
             presentation.error(error.issues.join('\n'), parsed.command ? `Run \`liftoff ${parsed.command} --help\` to review accepted values.` : undefined);
             return 1;
@@ -103,7 +110,10 @@ async function initCommand(parsed, context) {
         ? new InteractivePrompter({
             input: context.stdin,
             output: context.stdout,
-            presentation
+            presentation,
+            cwd: context.cwd,
+            configuredRoot: git.exact ? git.root : undefined,
+            runner
         })
         : undefined;
     try {
@@ -111,12 +121,24 @@ async function initCommand(parsed, context) {
         if (needsPrompts) {
             presentation.stage('Configure project');
         }
-        const options = needsPrompts ? await prompter.promptForInitOptions(initial) : initial;
-        const plan = buildProjectPlan(options, { requireProjectName: true });
-        presentation.stage('Review resolved plan');
-        const confirmed = options.yes === true
-            ? (presentation.definitions('Resolved project plan', projectPlanEntries(plan)), true)
-            : await prompter.confirmPlan(plan);
+        let options;
+        let plan;
+        let confirmed;
+        try {
+            options = needsPrompts ? await prompter.promptForInitOptions(initial) : initial;
+            plan = buildProjectPlan(options, { requireProjectName: true });
+            presentation.stage('Review resolved plan');
+            confirmed = options.yes === true
+                ? (presentation.definitions('Resolved project plan', projectPlanEntries(plan)), true)
+                : await prompter.confirmPlan(plan);
+        }
+        catch (error) {
+            if (error instanceof InteractiveCancelledError) {
+                presentation.cancellation('Initialization stopped; no destination files were changed.');
+                return 0;
+            }
+            throw error;
+        }
         if (!confirmed) {
             presentation.cancellation('Initialization stopped; no destination files were changed.');
             return 0;
@@ -175,7 +197,8 @@ async function initCommand(parsed, context) {
         }
         presentation.bullets('Configured integrations', [
             `${plan.specWorkflow.label} ${plan.framework.version}`,
-            ...plan.agents.map((agent) => `${agent.label}${plan.defaultAgent?.id === agent.id ? ' (default)' : ''}`)
+            ...plan.agents.map((agent) => `${agent.label}${plan.defaultAgent?.id === agent.id ? ' (default)' : ''}`),
+            ...readiness.pluginProbes.map((probe) => `Code Apps plugin for ${probe.agent.label}: ${probe.state}`)
         ]);
         if (readiness.deferred.length > 0) {
             presentation.bullets('Deferred advisory checks', readiness.deferred);
@@ -221,13 +244,22 @@ async function planCommand(parsed, context) {
 }
 async function ensureWorkstationReady(plan, options, context, runner, presentation, prompter, resumeInvocation = 'liftoff init', commandCwd) {
     const requirements = selectWorkstationRequirements(plan);
-    let probes = await probeWorkstation(requirements, runner, { cwd: commandCwd });
+    const [initialProbes, pluginProbes] = await Promise.all([
+        probeWorkstation(requirements, runner, { cwd: commandCwd }),
+        plan.workload === 'power-apps-code-app' && plan.codeAppsPlugin
+            ? probeCodeAppsPlugin(plan.agents, runner, commandCwd)
+            : Promise.resolve([])
+    ]);
+    let probes = initialProbes;
     presentation.table('Workstation readiness', ['Requirement', 'Level', 'State', 'Detail'], probes.map((probe) => [
         probe.requirement.definition.label,
         probe.requirement.severity,
         probe.state,
         probe.detail
     ]));
+    if (pluginProbes.length > 0) {
+        presentation.table('Optional Code Apps plugin', ['Agent', 'State', 'Detail'], pluginProbes.map((probe) => [probe.agent.label, probe.state, probe.detail]));
+    }
     const actionable = probes.filter((probe) => probe.state !== 'ready');
     const host = await detectHostEnvironment();
     const installInstruction = (probe) => {
@@ -311,7 +343,7 @@ async function ensureWorkstationReady(plan, options, context, runner, presentati
         presentation.error('Workstation readiness is incomplete.', options.installTools
             ? `Open a new terminal if PATH changed, then rerun \`${resumeInvocation}\` with the same project options.`
             : `Resume with \`${resumeInvocation} --install-tools\` plus the same project options after reviewing the commands.`);
-        return { ready: false, deferred: [], probes };
+        return { ready: false, deferred: [], probes, pluginProbes };
     }
     const deferred = [
         ...probes
@@ -319,9 +351,12 @@ async function ensureWorkstationReady(plan, options, context, runner, presentati
             .map((probe) => `${probe.requirement.definition.label}: ${probe.detail} Remedy: ${installInstruction(probe)}`),
         ...probes.flatMap((probe) => probe.notices
             .filter((notice) => notice.state !== 'ready')
-            .map((notice) => `${notice.label}: ${notice.detail}${notice.remedy ? ` Remedy: ${notice.remedy}` : ''}`))
+            .map((notice) => `${notice.label}: ${notice.detail}${notice.remedy ? ` Remedy: ${notice.remedy}` : ''}`)),
+        ...pluginProbes
+            .filter((probe) => probe.state !== 'ready')
+            .map((probe) => `${probe.agent.label} Code Apps plugin: ${probe.detail}${probe.remedy ? ` Remedy: ${probe.remedy}` : ''}`)
     ];
-    return { ready: true, deferred, probes };
+    return { ready: true, deferred, probes, pluginProbes };
 }
 async function handleProjectDependencies(plan, projectRoot, options, probes, context, runner, presentation, prompter) {
     const dependencyPlan = buildDependencySetupPlan(plan, projectRoot, probes);
@@ -334,9 +369,16 @@ async function handleProjectDependencies(plan, projectRoot, options, probes, con
     if (!installDependencies) {
         return {
             success: true,
-            deferred: dependencyPlan.commands.map((command) => `${command.label}: ${command.cwd} -> ${formatCommand(command.command)}`)
+            deferred: dependencyPlan.commands.map((command) => `${command.label}: ${dependencyResumeCommand(command)}`)
         };
     }
+    if (plan.workload === 'power-apps-code-app') {
+        const issues = await verifyPowerAppsPackageMetadata(projectRoot);
+        if (issues.length > 0) {
+            presentation.error('Power Apps dependency installation blocked', `${issues.join(' ')} Restore package.json and package-lock.json or run \`liftoff update --apply\`.`);
+            return { success: false, deferred: [] };
+        }
+    }
     presentation.stage('Install project dependencies');
     const result = await runDependencySetup(dependencyPlan, projectRoot, runner, {
         ...presentation.childStreams(),
@@ -387,11 +429,21 @@ function regionsCommand(parsed, context) {
 }
 async function validateCommand(parsed, context) {
     context.presentation.commandIdentity('validate', 'Validate a generated Liftoff project');
+    const jsonMode = readBooleanFlag(parsed.flags, 'json') ?? false;
     const explicit = parsed.positional[0] ?? readStringFlag(parsed.flags, 'project');
     const projectRoot = explicit
         ? path.resolve(context.cwd, explicit)
         : (await findProjectRoot(context.cwd)) ?? context.cwd;
     const issues = await validateGeneratedProject(projectRoot);
+    if (jsonMode) {
+        context.presentation.rawStdout(`${JSON.stringify({
+            schemaVersion: 1,
+            projectRoot,
+            valid: issues.length === 0,
+            issues
+        }, null, 2)}\n`);
+        return issues.length === 0 ? 0 : 1;
+    }
     if (issues.length > 0) {
         context.presentation.error(issues.join('\n'), 'Restore invalid generated files or the manifest from version control, then rerun validation.');
         return 1;
@@ -534,12 +586,15 @@ async function executeMigration(parsed, context, sourceRoot) {
     if (flagOptions.projectType === 'genai' && flagOptions.apiStack === undefined) {
         initial.apiStack = undefined;
     }
+    const runner = context.runner ?? new NodeCommandRunner();
     const interactive = initial.yes !== true;
     const prompter = interactive
         ? new InteractivePrompter({
             input: context.stdin,
             output: context.stdout,
-            presentation
+            presentation,
+            cwd: context.cwd,
+            runner
         })
         : undefined;
     try {
@@ -549,6 +604,10 @@ async function executeMigration(parsed, context, sourceRoot) {
         }
         const options = needsPrompts ? await prompter.promptForInitOptions(initial) : initial;
         const plan = buildProjectPlan(options, { requireProjectName: true });
+        if (plan.workload === 'power-apps-code-app') {
+            presentation.error('Power Apps code app migration is not supported.', 'Initialize a fresh Power Apps code app, then move application changes intentionally.');
+            return 1;
+        }
         presentation.stage('Review migration plan');
         const confirmed = options.yes === true
             ? (presentation.definitions('Resolved migration plan', projectPlanEntries(plan)), true)
@@ -566,7 +625,6 @@ async function executeMigration(parsed, context, sourceRoot) {
         const target = { root: targetRoot, mode: 'named-child' };
         await assertSafeInitTarget(target, parentDir);
         await assertNewOrEmptyDirectory(targetRoot);
-        const runner = context.runner ?? new NodeCommandRunner();
         presentation.stage('Check workstation readiness');
         const readinessRoot = await mkdtemp(path.join(os.tmpdir(), 'liftoff-migrate-readiness-'));
         const readiness = await (async () => {
@@ -655,6 +713,11 @@ async function migrateCommand(parsed, context) {
         context.presentation.error('Usage: liftoff migrate <path-to-existing-project>', 'Run `liftoff migrate --help` for accepted migration options.');
         return 1;
     }
+    const migrationOptions = await optionsFromParsedArgs(parsed, context.cwd, false);
+    if (migrationOptions.projectType === 'power-apps-code-app') {
+        context.presentation.error('Power Apps code app migration is not supported.', 'Initialize a fresh Power Apps code app with `liftoff init --type power-apps-code-app`, then move application changes intentionally.');
+        return 1;
+    }
     const sourceRoot = path.resolve(context.cwd, sourceArg);
     let sourceDetails;
     try {
@@ -765,17 +828,35 @@ async function updateCommand(parsed, context) {
     }
     const config = await loadConfigOptions('liftoff.config.json', projectRoot);
     const plan = buildProjectPlan(config, { requireProjectName: true });
-    if (plan.projectType.id !== manifest.project.projectType) {
-        presentation.error(`Project type changes (${manifest.project.projectType} -> ${plan.projectType.id}) are a migration, not an update.`, 'Run `liftoff migrate` instead.');
+    const recordedWorkload = manifest.project.workload;
+    if (plan.workload !== recordedWorkload.kind) {
+        const involvesPowerApps = plan.workload === 'power-apps-code-app' ||
+            recordedWorkload.kind === 'power-apps-code-app';
+        presentation.error(`Project type changes (${recordedWorkload.kind} -> ${plan.workload}) are not supported by update.`, involvesPowerApps
+            ? 'Initialize a fresh project for the new workload.'
+            : 'Run `liftoff migrate` instead.');
         return 1;
     }
-    if (plan.apiStack.id !== manifest.project.apiStack) {
-        presentation.error(`API stack changes (${manifest.project.apiStack} -> ${plan.apiStack.id}) are a migration, not an update.`, 'Run `liftoff migrate` instead.');
-        return 1;
+    if (plan.workload === 'power-apps-code-app' && recordedWorkload.kind === 'power-apps-code-app') {
+        const recordedStarter = recordedWorkload.starter;
+        if (plan.starter.repository !== recordedStarter.repository ||
+            plan.starter.path !== recordedStarter.path ||
+            plan.starter.commit !== recordedStarter.commit) {
+            presentation.error('The Power Apps starter repository, path, or commit differs from the recorded immutable source.', 'Restore the recorded source identity or initialize a fresh project.');
+            return 1;
+        }
     }
-    if (plan.pattern?.id !== manifest.project.pattern) {
-        presentation.error(`Pattern changes (${manifest.project.pattern ?? 'none'} -> ${plan.pattern?.id ?? 'none'}) are a migration, not an update.`, 'Run `liftoff migrate` instead.');
-        return 1;
+    else if (plan.workload !== 'power-apps-code-app' && recordedWorkload.kind !== 'power-apps-code-app') {
+        if (plan.apiStack.id !== recordedWorkload.apiStack) {
+            presentation.error(`API stack changes (${recordedWorkload.apiStack} -> ${plan.apiStack.id}) are a migration, not an update.`, 'Run `liftoff migrate` instead.');
+            return 1;
+        }
+        const recordedPattern = recordedWorkload.kind === 'genai' ? recordedWorkload.pattern : undefined;
+        const desiredPattern = plan.workload === 'genai' ? plan.pattern.id : undefined;
+        if (desiredPattern !== recordedPattern) {
+            presentation.error(`Pattern changes (${recordedPattern ?? 'none'} -> ${desiredPattern ?? 'none'}) are a migration, not an update.`, 'Run `liftoff migrate` instead.');
+            return 1;
+        }
     }
     if (plan.specWorkflow.id !== manifest.project.specWorkflow) {
         presentation.error(`Spec workflow changes (${manifest.project.specWorkflow} -> ${plan.specWorkflow.id}) require official framework initialization and are not supported by liftoff update.`, 'Restore the workflow recorded in liftoff.manifest.json or migrate into a fresh project.');
@@ -837,20 +918,29 @@ async function updateCommand(parsed, context) {
     await preflightUpdate(projectRoot, entries, force);
     const written = [];
     const skipped = [];
+    const mutations = [];
     for (const entry of entries) {
         switch (entry.status) {
             case 'new':
             case 'missing':
             case 'upgrade':
-                await writeProjectFile(projectRoot, entry.pathParts, entry.rendered.content);
+                mutations.push({
+                    type: 'write',
+                    pathParts: entry.pathParts,
+                    content: entry.rendered.content
+                });
                 written.push(entry);
                 break;
             case 'moved':
                 if (entry.cleanMove || force) {
                     if (!entry.destinationMatches) {
-                        await writeProjectFile(projectRoot, entry.pathParts, entry.rendered.content);
+                        mutations.push({
+                            type: 'write',
+                            pathParts: entry.pathParts,
+                            content: entry.rendered.content
+                        });
                     }
-                    await deleteProjectFile(projectRoot, entry.previousPathParts);
+                    mutations.push({ type: 'delete', pathParts: entry.previousPathParts });
                     written.push(entry);
                 }
                 else {
@@ -859,9 +949,13 @@ async function updateCommand(parsed, context) {
                 break;
             case 'conflict':
                 if (force) {
-                    await writeProjectFile(projectRoot, entry.pathParts, entry.rendered.content);
+                    mutations.push({
+                        type: 'write',
+                        pathParts: entry.pathParts,
+                        content: entry.rendered.content
+                    });
                     if (entry.previousPathParts) {
-                        await deleteProjectFile(projectRoot, entry.previousPathParts);
+                        mutations.push({ type: 'delete', pathParts: entry.previousPathParts });
                     }
                     written.push(entry);
                 }
@@ -904,7 +998,12 @@ async function updateCommand(parsed, context) {
             nextManifest.artifacts.push(oldByName.get(entry.logicalName));
         }
     }
-    await writeProjectFile(projectRoot, ['liftoff.manifest.json'], `${JSON.stringify(nextManifest, null, 2)}\n`);
+    mutations.push({
+        type: 'write',
+        pathParts: ['liftoff.manifest.json'],
+        content: `${JSON.stringify(nextManifest, null, 2)}\n`
+    });
+    await applyProjectFileTransaction(projectRoot, mutations);
     if (jsonMode) {
         presentation.rawStdout(`${JSON.stringify({
             schemaVersion: 1,
@@ -996,11 +1095,17 @@ function workstationLayer(probes) {
 }
 function workstationSelectionFromManifest(manifest) {
     const framework = getFrameworkDefinition(manifest.project.specWorkflow);
+    const workload = manifest.project.workload;
     return {
-        apiStack: { id: manifest.project.apiStack },
+        workload: workload.kind === 'power-apps-code-app'
+            ? { kind: 'power-apps-code-app' }
+            : {
+                kind: workload.kind,
+                apiStack: { id: workload.apiStack },
+                provider: { id: workload.cloud }
+            },
         specWorkflow: { id: manifest.project.specWorkflow },
         framework: { version: framework.version },
-        provider: { id: manifest.project.cloud },
         agents: manifest.framework.state === 'initialized'
             ? manifest.project.agents.map((id) => {
                 const agent = getCodingAgent(id);
@@ -1106,6 +1211,26 @@ function stackProjectCheck(projectRoot, apiStack) {
         remedy: `repair the generated ${apiStack} backend configuration`
     };
 }
+async function powerAppsProjectCheck(projectRoot) {
+    const issues = await verifyPowerAppsPackageMetadata(projectRoot);
+    if (issues.length === 0) {
+        return {
+            id: 'power-apps-project',
+            label: 'Power Apps project',
+            severity: 'ok',
+            state: 'ready',
+            detail: 'SDK, Vite plugin, and deterministic lockfile metadata are valid'
+        };
+    }
+    return {
+        id: 'power-apps-project',
+        label: 'Power Apps project',
+        severity: 'fail',
+        state: 'unhealthy',
+        detail: issues[0],
+        remedy: 'restore package.json and package-lock.json or run liftoff update --apply'
+    };
+}
 function runReadOnly(command, args, cwd) {
     const result = spawnSync(command, args, { cwd, encoding: 'utf8' });
     return { status: result.status, stdout: result.stdout, stderr: result.stderr };
@@ -1204,7 +1329,20 @@ async function projectLayer(projectRoot, manifest) {
         checks.push({ label: 'version', severity: 'ok', detail: `generated by ${manifest.liftoffVersion}, CLI ${liftoffVersion}` });
     }
     checks.push(...await frameworkDoctorChecks(projectRoot, manifest));
-    checks.push(stackProjectCheck(projectRoot, manifest.project.apiStack));
+    if (manifest.project.workload.kind === 'power-apps-code-app') {
+        const starter = manifest.project.workload.starter;
+        checks.push({
+            id: 'power-apps-starter',
+            label: 'Power Apps starter',
+            severity: 'ok',
+            state: 'ready',
+            detail: `${starter.repository}/${starter.path} @ ${starter.commit}`
+        });
+        checks.push(await powerAppsProjectCheck(projectRoot));
+    }
+    else {
+        checks.push(stackProjectCheck(projectRoot, manifest.project.workload.apiStack));
+    }
     try {
         const config = await loadConfigOptions('liftoff.config.json', projectRoot);
         const plan = buildProjectPlan(config, { requireProjectName: true });
@@ -1233,8 +1371,40 @@ async function projectLayer(projectRoot, manifest) {
     }
     return { title: 'Project', checks };
 }
-async function runtimeLayer(projectRoot, dockerAvailable, runner) {
+async function runtimeLayer(projectRoot, dockerAvailable, runner, manifest) {
     const checks = [];
+    if (manifest.project.workload.kind === 'power-apps-code-app') {
+        if (!existsSync(path.join(projectRoot, 'node_modules'))) {
+            checks.push({
+                id: 'power-apps-cli',
+                label: 'Power Apps CLI',
+                severity: 'skipped',
+                state: 'not-observable',
+                detail: 'project dependencies are not installed',
+                remedy: 'run npm ci, then rerun liftoff doctor'
+            });
+            return { title: 'Runtime', checks };
+        }
+        const executable = process.platform === 'win32' ? 'npx.cmd' : 'npx';
+        const result = await runner.run({ executable, args: ['--no-install', 'power-apps', '--version'] }, { cwd: projectRoot, timeoutMs: 15_000 });
+        checks.push(result.status === 0
+            ? {
+                id: 'power-apps-cli',
+                label: 'Power Apps CLI',
+                severity: 'ok',
+                state: 'ready',
+                detail: result.stdout.trim() || 'local CLI is available'
+            }
+            : {
+                id: 'power-apps-cli',
+                label: 'Power Apps CLI',
+                severity: 'fail',
+                state: 'unhealthy',
+                detail: (result.stderr || 'local CLI probe failed').trim().split('\n')[0],
+                remedy: 'run npm ci and verify @microsoft/power-apps before binding the environment'
+            });
+        return { title: 'Runtime', checks };
+    }
     if (existsSync(path.join(projectRoot, '.env.example'))) {
         if (existsSync(path.join(projectRoot, '.env'))) {
             checks.push({ label: '.env', severity: 'ok', detail: 'present' });
@@ -1268,6 +1438,28 @@ async function runtimeLayer(projectRoot, dockerAvailable, runner) {
     }
     return { title: 'Runtime', checks };
 }
+async function codeAppsPluginLayer(projectRoot, manifest, runner) {
+    const agents = manifest.project.agents.map((id) => {
+        const agent = getCodingAgent(id);
+        if (!agent) {
+            throw new Error(`Manifest references unknown coding agent ${id}.`);
+        }
+        return agent;
+    });
+    const probes = await probeCodeAppsPlugin(agents, runner, projectRoot);
+    return {
+        title: 'Optional Code Apps plugin',
+        checks: probes.map((probe) => ({
+            id: probe.id,
+            label: probe.agent.label,
+            severity: probe.state === 'ready' ? 'ok' : 'warn',
+            state: probe.state,
+            requirementSeverity: 'advisory',
+            detail: probe.detail,
+            ...(probe.remedy ? { remedy: probe.remedy } : {})
+        }))
+    };
+}
 function renderDoctorLayers(layers, presentation) {
     const statusKind = {
         ok: 'success',
@@ -1322,16 +1514,26 @@ async function doctorCommand(parsed, context) {
         }
         if (manifest) {
             layers.push(await projectLayer(projectRoot, manifest));
-            layers.push(await runtimeLayer(projectRoot, dockerAvailable, runner));
-            const cloud = cloudOverride ?? manifest.project.cloud;
-            const cloudChecks = await cloudLayer(cloud, runner);
-            const pattern = patterns.find((candidate) => candidate.id === manifest.project.pattern);
-            if (pattern?.worker && cloud === 'azure') {
-                cloudChecks.checks.push(binaryPresent('func')
-                    ? { label: 'functions tooling', severity: 'ok', detail: 'Azure Functions Core Tools installed' }
-                    : { label: 'functions tooling', severity: 'warn', detail: 'Azure Functions Core Tools not found', remedy: 'npm install -g azure-functions-core-tools@4' });
+            layers.push(await runtimeLayer(projectRoot, dockerAvailable, runner, manifest));
+            if (manifest.project.workload.kind === 'power-apps-code-app') {
+                if (manifest.project.workload.codeAppsPlugin) {
+                    layers.push(await codeAppsPluginLayer(projectRoot, manifest, runner));
+                }
+            }
+            else {
+                const workload = manifest.project.workload;
+                const cloud = cloudOverride ?? workload.cloud;
+                const cloudChecks = await cloudLayer(cloud, runner);
+                const pattern = workload.kind === 'genai'
+                    ? patterns.find((candidate) => candidate.id === workload.pattern)
+                    : undefined;
+                if (pattern?.worker && cloud === 'azure') {
+                    cloudChecks.checks.push(binaryPresent('func')
+                        ? { label: 'functions tooling', severity: 'ok', detail: 'Azure Functions Core Tools installed' }
+                        : { label: 'functions tooling', severity: 'warn', detail: 'Azure Functions Core Tools not found', remedy: 'npm install -g azure-functions-core-tools@4' });
+                }
+                layers.push(cloudChecks);
             }
-            layers.push(cloudChecks);
         }
     }
     else if (cloudOverride) {
@@ -1348,7 +1550,24 @@ async function doctorCommand(parsed, context) {
     }
     return doctorExitCode(layers);
 }
-function helperCommand(parsed, context, tool) {
+async function helperCommand(parsed, context, tool) {
+    const projectRoot = await findProjectRoot(context.cwd);
+    if (projectRoot) {
+        const manifest = await loadManifest(projectRoot);
+        if (manifest.project.workload.kind === 'power-apps-code-app') {
+            if (parsed.command === 'dev') {
+                context.presentation.commandIdentity('dev', 'Power Apps local development');
+                context.presentation.section('Dependency prerequisite', ['Install the root lockfile before starting or after dependency changes.']);
+                context.presentation.command('npm ci');
+                context.presentation.section('Development server', []);
+                context.presentation.command('npm run dev');
+                return 0;
+            }
+            context.presentation.commandIdentity('infra', 'Power Apps hosting responsibility');
+            context.presentation.status('info', 'Not applicable', 'Power Apps code apps are hosted by Power Platform; Liftoff-managed OpenTofu infrastructure is not generated.');
+            return 0;
+        }
+    }
     const command = parsed.command === 'dev' ? buildDevCommand(parsed) : buildInfraCommand(parsed);
     context.presentation.commandIdentity(parsed.command ?? tool, `${tool} helper command`);
     context.presentation.section(`${tool} helper command`, []);
@@ -1389,9 +1608,8 @@ async function optionsFromParsedArgs(parsed, cwd, includeProjectName) {
     const configOptions = configPath ? await loadConfigOptions(configPath, cwd) : {};
     const flagOptions = {
         projectName: includeProjectName ? parsed.positional[0] ?? readStringFlag(parsed.flags, 'project') : readStringFlag(parsed.flags, 'project'),
-        projectType: readBooleanFlag(parsed.flags, 'genai') === undefined
-            ? undefined
-            : readBooleanFlag(parsed.flags, 'genai') ? 'genai' : 'standard',
+        projectType: readStringFlag(parsed.flags, 'type'),
+        genai: readBooleanFlag(parsed.flags, 'genai'),
         apiStack: readStringFlag(parsed.flags, 'api'),
         pattern: readStringFlag(parsed.flags, 'pattern'),
         cloud: readStringFlag(parsed.flags, 'cloud'),
@@ -1401,6 +1619,7 @@ async function optionsFromParsedArgs(parsed, cwd, includeProjectName) {
         specWorkflow: readStringFlag(parsed.flags, 'spec'),
         agents: readListFlag(parsed.flags, 'agents'),
         defaultAgent: readStringFlag(parsed.flags, 'default-agent'),
+        codeAppsPlugin: readBooleanFlag(parsed.flags, 'code-apps-plugin'),
         configPath,
         yes: readBooleanFlag(parsed.flags, 'yes') ?? false,
         force: readBooleanFlag(parsed.flags, 'force'),
@@ -1410,19 +1629,27 @@ async function optionsFromParsedArgs(parsed, cwd, includeProjectName) {
     return mergeOptions(configOptions, flagOptions);
 }
 function hasMissingInitInputs(options) {
-    const projectType = options.projectType ?? (options.pattern ? 'genai' : options.apiStack ? 'standard' : undefined);
-    const missingTypeSpecific = projectType === 'genai' ? !options.pattern : projectType === 'standard' ? !options.apiStack : true;
+    const projectType = options.projectType ??
+        (options.genai === undefined ? undefined : options.genai ? 'genai' : 'standard') ??
+        (options.pattern ? 'genai' : options.apiStack ? 'standard' : undefined);
+    const missingTypeSpecific = projectType === 'genai'
+        ? !options.pattern
+        : projectType === 'standard'
+            ? !options.apiStack
+            : projectType === 'power-apps-code-app'
+                ? options.codeAppsPlugin === undefined
+                : true;
     const missingDefaultAgent = options.specWorkflow === 'spec-kit' &&
         (options.agents?.length ?? 0) > 1 &&
         !options.defaultAgent;
     return !options.projectName ||
         missingTypeSpecific ||
-        !options.cloud ||
-        options.includeFrontend === undefined ||
+        projectType !== 'power-apps-code-app' && !options.cloud ||
+        projectType !== 'power-apps-code-app' && options.includeFrontend === undefined ||
         !options.specWorkflow ||
         !options.agents ||
         missingDefaultAgent ||
-        !options.environments;
+        projectType !== 'power-apps-code-app' && !options.environments;
 }
 function renderGeneralHelp(presentation) {
     const help = getGeneralHelp(liftoffVersion);