@pikku/cli 0.12.20 → 0.12.21

package/dist/src/deploy/build-pipeline.js

@@ -10,6 +10,24 @@ import { mkdir, writeFile, copyFile } from 'node:fs/promises';
 import { analyzeDeployment } from './analyzer/index.js';
 import { generatePerUnitCodegen } from './codegen/per-unit-codegen.js';
 import { bundleUnits } from './bundler/index.js';
+const MERGED_SERVER_UNIT_NAME = 'pikku-server-container';
+const UNITS_DIR_NAME = 'units';
+const CONTAINER_DIR_NAME = 'container';
+function attachBundleMetadata(manifest, bundled) {
+    if (bundled.length === 0)
+        return;
+    const byUnitName = new Map(bundled.map((b) => [b.unitName, b]));
+    for (const unit of manifest.units) {
+        const bundle = byUnitName.get(unit.name);
+        if (!bundle)
+            continue;
+        unit.bundleHash = bundle.bundleHash;
+        unit.bundleSizeBytes = bundle.bundleSizeBytes;
+        unit.exactDependenciesHash = bundle.exactDependenciesHash;
+        unit.exactDependencies = bundle.exactDependencies;
+        unit.exactOptionalDependencies = bundle.exactOptionalDependencies;
+    }
+}
 function findLockfile(projectDir) {
     for (const name of ['yarn.lock', 'package-lock.json', 'pnpm-lock.yaml']) {
         const p = join(projectDir, name);
@@ -30,6 +48,10 @@ export async function runBuildPipeline(options) {
     let bundled = [];
     let bundleErrors = [];
     let codegenErrors = [];
+    let infraPath = null;
+    const deploymentManifestPath = join(providerDir, 'deployment-manifest.json');
+    const unitsDir = join(providerDir, UNITS_DIR_NAME);
+    const containerDir = join(providerDir, CONTAINER_DIR_NAME);
     if (provider.singleUnit) {
         // Single-unit mode: bundle everything into one unit, use project's .pikku/ directly
         logger.info('Building standalone bundle...');
@@ -63,6 +85,7 @@ export async function runBuildPipeline(options) {
         });
         bundled = bundleResult.results;
         bundleErrors = bundleResult.errors;
+        attachBundleMetadata(manifest, bundled);
         logger.info(`Bundled standalone${bundleErrors.length > 0 ? ` (${bundleErrors.length} errors)` : ''}`);
     }
     else {
@@ -74,6 +97,8 @@ export async function runBuildPipeline(options) {
             return {
                 manifest,
                 providerDir,
+                deploymentManifestPath,
+                infraPath,
                 projectId,
                 bundled: [],
                 bundleErrors: [],
@@ -88,7 +113,7 @@ export async function runBuildPipeline(options) {
             projectDir,
             manifest: serverlessManifest,
             inspectorState,
-            deployDir: providerDir,
+            deployDir: unitsDir,
             onProgress: (unitName, status, error) => {
                 if (status === 'start') {
                     logger.info(`  Codegen: ${unitName}...`);
@@ -104,7 +129,7 @@ export async function runBuildPipeline(options) {
         codegenErrors = serverlessCodegenErrors;
         // Step 2b: Server units — single codegen pass with all server function IDs
         if (serverUnits.length > 0) {
-            const serverUnitName = 'server';
+            const serverUnitName = MERGED_SERVER_UNIT_NAME;
             // Create a merged server unit with all server function IDs
             const mergedServerUnit = {
                 name: serverUnitName,
@@ -122,7 +147,8 @@ export async function runBuildPipeline(options) {
                 projectDir,
                 manifest: serverManifest,
                 inspectorState,
-                deployDir: providerDir,
+                deployDir: containerDir,
+                resolveUnitDir: () => containerDir,
                 onProgress: (unitName, status, error) => {
                     if (status === 'start')
                         logger.info(`  Codegen: ${unitName}...`);
@@ -147,7 +173,7 @@ export async function runBuildPipeline(options) {
             const pikkuDir = unitPikkuDirs.get(unit.name);
             if (!pikkuDir)
                 continue;
-            const unitDir = join(providerDir, unit.name);
+            const unitDir = unit.target === 'server' ? containerDir : join(unitsDir, unit.name);
             const entryPath = join(unitDir, 'entry.ts');
             await mkdir(unitDir, { recursive: true });
             const ctx = getEntryContext(unitDir, pikkuDir, unit, inspectorState);
@@ -161,9 +187,11 @@ export async function runBuildPipeline(options) {
             define: provider.getDefine?.(),
             platform: provider.getPlatform?.(),
             format: provider.getFormat?.(),
+            resolveOutputDir: (unit) => unit.target === 'server' ? containerDir : join(unitsDir, unit.name),
         });
         bundled = bundleResult.results;
         bundleErrors = bundleResult.errors;
+        attachBundleMetadata(manifest, bundled);
         logger.info(`Bundled ${bundled.length} units${bundleErrors.length > 0 ? ` (${bundleErrors.length} failed)` : ''}`);
     }
     if (bundleErrors.length > 0) {
@@ -172,9 +200,13 @@ export async function runBuildPipeline(options) {
         }
     }
     // Step 4: Generate configs + infra manifest
+    await mkdir(providerDir, { recursive: true });
+    await writeFile(deploymentManifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+    logger.info('Generated deployment manifest');
     const infraContent = provider.generateInfraManifest(manifest);
     if (infraContent) {
-        await writeFile(join(providerDir, 'infra.json'), infraContent, 'utf-8');
+        infraPath = join(providerDir, 'infra.json');
+        await writeFile(infraPath, infraContent, 'utf-8');
         logger.info('Generated infrastructure manifest');
     }
     if (provider.generateProviderConfigs) {
@@ -187,7 +219,11 @@ export async function runBuildPipeline(options) {
     }
     const lockfileSrc = findLockfile(projectDir);
     for (const unit of manifest.units) {
-        const unitDir = join(providerDir, unit.name);
+        const unitDir = provider.singleUnit
+            ? join(providerDir, unit.name)
+            : unit.target === 'server'
+                ? containerDir
+                : join(unitsDir, unit.name);
         await mkdir(unitDir, { recursive: true });
         const configs = provider.generateUnitConfigs(unit, manifest, projectId);
         for (const [filename, content] of configs) {
@@ -201,6 +237,8 @@ export async function runBuildPipeline(options) {
     return {
         manifest,
         providerDir,
+        deploymentManifestPath,
+        infraPath,
         projectId,
         bundled,
         bundleErrors,

package/dist/src/deploy/bundler/bundler.d.ts

@@ -9,7 +9,7 @@
  * 5. Generates a minimal package.json with exact versions
  * 6. Writes all artifacts to `<outputDir>/<unit-name>/`
  */
-import type { DeploymentManifest, BundleOutput } from './types.js';
+import type { DeploymentManifest, DeploymentUnit, BundleOutput } from './types.js';
 /**
  * Bundles all deployment units defined in a DeploymentManifest.
  *
@@ -27,4 +27,5 @@ export declare function bundleUnits(projectDir: string, manifest: DeploymentMani
     define?: Record<string, string>;
     platform?: 'node' | 'neutral' | 'browser';
     format?: 'esm' | 'cjs';
+    resolveOutputDir?: (unit: DeploymentUnit, baseOutputDir: string) => string;
 }): Promise<BundleOutput>;

package/dist/src/deploy/bundler/bundler.js

@@ -12,6 +12,7 @@
 import { build } from 'esbuild';
 import { writeFile, mkdir, stat, readFile } from 'node:fs/promises';
 import { join } from 'node:path';
+import { createHash } from 'node:crypto';
 import { extractDependencies, generateMinimalPackageJson, } from './dep-extractor.js';
 /**
  * Mapping of service name -> gen file pattern that should be stubbed
@@ -70,6 +71,7 @@ function createDeadModuleStubPlugin(patterns) {
 const BUNDLE_FILENAME = 'bundle.js';
 const METAFILE_FILENAME = 'metafile.json';
 const PACKAGE_JSON_FILENAME = 'package.json';
+const EXACT_DEPENDENCIES_FILENAME = 'exact-dependencies.json';
 /**
  * Bundles a single deployment unit using esbuild.
  *
@@ -84,6 +86,7 @@ async function bundleUnit(options) {
     const bundlePath = join(unitOutputDir, BUNDLE_FILENAME);
     const metafilePath = join(unitOutputDir, METAFILE_FILENAME);
     const packageJsonPath = join(unitOutputDir, PACKAGE_JSON_FILENAME);
+    const exactDependenciesPath = join(unitOutputDir, EXACT_DEPENDENCIES_FILENAME);
     // Determine which gen files to stub based on per-unit service requirements
     const deadPatterns = await getDeadGenFilePatterns(unitOutputDir);
     // Run esbuild — inline everything into a self-contained bundle.
@@ -106,7 +109,9 @@ async function bundleUnit(options) {
     // The banner shims require via createRequire so CJS builtins resolve.
     const resolvedFormat = format ?? 'esm';
     const banner = resolvedFormat === 'esm' && (platform ?? 'node') === 'node'
-        ? { js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);` }
+        ? {
+            js: `import { createRequire } from 'module'; const require = createRequire(import.meta.url);`,
+        }
         : undefined;
     const result = await build({
         entryPoints: [entryPath],
@@ -132,18 +137,34 @@ async function bundleUnit(options) {
     const metafileJson = JSON.stringify(result.metafile, null, 2);
     await writeFile(metafilePath, metafileJson, 'utf-8');
     // Extract dependencies and generate minimal package.json
-    const dependencies = await extractDependencies(result.metafile, projectDir);
-    const packageJson = generateMinimalPackageJson(unit.name, dependencies);
+    const { exactDependencies, exactOptionalDependencies } = await extractDependencies(result.metafile, projectDir);
+    const packageJson = generateMinimalPackageJson(unit.name, exactDependencies, exactOptionalDependencies);
     await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2), 'utf-8');
+    await writeFile(exactDependenciesPath, JSON.stringify({
+        dependencies: Object.fromEntries(Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b))),
+        optionalDependencies: Object.fromEntries(Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b))),
+    }, null, 2), 'utf-8');
     // Get bundle size
     const bundleStat = await stat(bundlePath);
+    const bundleContents = await readFile(bundlePath);
+    const bundleHash = createHash('sha256').update(bundleContents).digest('hex');
+    const exactDependenciesHash = createHash('sha256')
+        .update(JSON.stringify({
+        dependencies: Object.entries(exactDependencies).sort(([a], [b]) => a.localeCompare(b)),
+        optionalDependencies: Object.entries(exactOptionalDependencies).sort(([a], [b]) => a.localeCompare(b)),
+    }))
+        .digest('hex');
     return {
         unitName: unit.name,
         bundlePath,
         packageJsonPath,
+        exactDependenciesPath,
         metafilePath,
         bundleSizeBytes: bundleStat.size,
-        externalPackages: dependencies,
+        bundleHash,
+        exactDependenciesHash,
+        exactDependencies,
+        exactOptionalDependencies,
     };
 }
 /**
@@ -173,7 +194,9 @@ export async function bundleUnits(projectDir, manifest, entryFiles, outputDir, o
             });
             continue;
         }
-        const unitOutputDir = join(buildDir, unit.name);
+        const unitOutputDir = options?.resolveOutputDir
+            ? options.resolveOutputDir(unit, buildDir)
+            : join(buildDir, unit.name);
         try {
             const result = await bundleUnit({
                 unit,

package/dist/src/deploy/bundler/dep-extractor.d.ts

@@ -28,8 +28,11 @@ export declare function parsePackageName(specifier: string): string | null;
  * Returns a record of package name to exact version, suitable for
  * writing into a minimal package.json.
  */
-export declare function extractDependencies(metafile: Metafile, projectDir: string): Promise<Record<string, string>>;
+export declare function extractDependencies(metafile: Metafile, projectDir: string): Promise<{
+    exactDependencies: Record<string, string>;
+    exactOptionalDependencies: Record<string, string>;
+}>;
 /**
  * Generates a minimal package.json content object for a unit bundle.
  */
-export declare function generateMinimalPackageJson(unitName: string, dependencies: Record<string, string>): Record<string, unknown>;
+export declare function generateMinimalPackageJson(unitName: string, dependencies: Record<string, string>, optionalDependencies: Record<string, string>): Record<string, unknown>;

package/dist/src/deploy/bundler/dep-extractor.js

@@ -43,12 +43,57 @@ export function parsePackageName(specifier) {
         return null;
     }
     const builtins = new Set([
-        'assert', 'buffer', 'child_process', 'cluster', 'console', 'constants',
-        'crypto', 'dgram', 'dns', 'domain', 'events', 'fs', 'http', 'http2',
-        'https', 'inspector', 'module', 'net', 'os', 'path', 'perf_hooks',
-        'process', 'punycode', 'querystring', 'readline', 'repl', 'stream',
-        'string_decoder', 'sys', 'timers', 'tls', 'tty', 'url', 'util',
-        'v8', 'vm', 'wasi', 'worker_threads', 'zlib',
+        'assert',
+        'buffer',
+        'child_process',
+        'cluster',
+        'console',
+        'constants',
+        'crypto',
+        'dgram',
+        'dns',
+        'domain',
+        'events',
+        'fs',
+        'http',
+        'http2',
+        'https',
+        'inspector',
+        'module',
+        'net',
+        'os',
+        'path',
+        'perf_hooks',
+        'process',
+        'punycode',
+        'querystring',
+        'readline',
+        'repl',
+        'stream',
+        'string_decoder',
+        'sys',
+        'timers',
+        'tls',
+        'tty',
+        'url',
+        'util',
+        'v8',
+        'vm',
+        'wasi',
+        'worker_threads',
+        'zlib',
+        'async_hooks',
+        'child_process',
+        'cluster',
+        'diagnostics_channel',
+        'dns/promises',
+        'fs/promises',
+        'readline/promises',
+        'stream/consumers',
+        'stream/promises',
+        'stream/web',
+        'timers/promises',
+        'util/types',
     ]);
     if (builtins.has(specifier.split('/')[0])) {
         return null;
@@ -68,7 +113,7 @@ export function parsePackageName(specifier) {
  */
 async function readProjectDependencies(projectDir) {
     const dependencies = {};
-    const devDependencies = {};
+    const optionalDependencies = {};
     // Walk up the directory tree to find all package.json files
     // (handles monorepo setups where deps are in the root package.json)
     let dir = projectDir;
@@ -82,9 +127,9 @@ async function readProjectDependencies(projectDir) {
                 if (!(k in dependencies))
                     dependencies[k] = v;
             }
-            for (const [k, v] of Object.entries(pkg.devDependencies ?? {})) {
-                if (!(k in devDependencies))
-                    devDependencies[k] = v;
+            for (const [k, v] of Object.entries(pkg.optionalDependencies ?? {})) {
+                if (!(k in optionalDependencies))
+                    optionalDependencies[k] = v;
             }
         }
         catch {
@@ -95,7 +140,7 @@ async function readProjectDependencies(projectDir) {
             break;
         dir = parent;
     }
-    return { dependencies, devDependencies };
+    return { dependencies, optionalDependencies };
 }
 /**
  * Attempts to read a version from yarn.lock for a given package.
@@ -161,7 +206,27 @@ function parseYarnLockKeyLine(line) {
  * Resolves the exact version for a package, trying yarn.lock first,
  * then falling back to the version range from package.json.
  */
-function resolveVersion(packageName, projectDeps, yarnLockVersions) {
+async function resolveInstalledPackageVersion(packageName, projectDir) {
+    let dir = projectDir;
+    while (true) {
+        const pkgPath = join(dir, 'node_modules', packageName, 'package.json');
+        try {
+            const content = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            if (pkg.version)
+                return pkg.version;
+        }
+        catch {
+            // Keep walking up to workspace root
+        }
+        const parent = join(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+async function resolveVersion(packageName, projectDeps, yarnLockVersions, projectDir) {
     // Prefer exact version from yarn.lock
     const locked = yarnLockVersions.get(packageName);
     if (locked)
@@ -170,12 +235,13 @@ function resolveVersion(packageName, projectDeps, yarnLockVersions) {
     const fromDeps = projectDeps.dependencies[packageName];
     if (fromDeps)
         return fromDeps;
-    const fromDevDeps = projectDeps.devDependencies[packageName];
-    if (fromDevDeps)
-        return fromDevDeps;
-    // Last resort: use wildcard (will get latest on install)
-    console.warn(`Could not resolve version for package '${packageName}', defaulting to '*'`);
-    return '*';
+    const fromOptionalDeps = projectDeps.optionalDependencies[packageName];
+    if (fromOptionalDeps)
+        return fromOptionalDeps;
+    const installedVersion = await resolveInstalledPackageVersion(packageName, projectDir);
+    if (installedVersion)
+        return installedVersion;
+    return null;
 }
 /**
  * Given an esbuild metafile, extracts all external packages and resolves
@@ -187,27 +253,41 @@ function resolveVersion(packageName, projectDeps, yarnLockVersions) {
 export async function extractDependencies(metafile, projectDir) {
     const externalPackages = extractExternalPackages(metafile);
     if (externalPackages.size === 0) {
-        return {};
+        return { exactDependencies: {}, exactOptionalDependencies: {} };
     }
     const [projectDeps, yarnLockVersions] = await Promise.all([
         readProjectDependencies(projectDir),
         readYarnLockVersions(projectDir),
     ]);
-    const dependencies = {};
+    const exactDependencies = {};
+    const exactOptionalDependencies = {};
     for (const pkg of [...externalPackages].sort()) {
-        dependencies[pkg] = resolveVersion(pkg, projectDeps, yarnLockVersions);
+        const version = await resolveVersion(pkg, projectDeps, yarnLockVersions, projectDir);
+        if (!version) {
+            // Some packages are optional-at-runtime (e.g. ws acceleration addons).
+            // Keep deploy planning deterministic without forcing a hard failure.
+            exactOptionalDependencies[pkg] = '*';
+            continue;
+        }
+        if (pkg in projectDeps.optionalDependencies) {
+            exactOptionalDependencies[pkg] = version;
+        }
+        else {
+            exactDependencies[pkg] = version;
+        }
     }
-    return dependencies;
+    return { exactDependencies, exactOptionalDependencies };
 }
 /**
  * Generates a minimal package.json content object for a unit bundle.
  */
-export function generateMinimalPackageJson(unitName, dependencies) {
+export function generateMinimalPackageJson(unitName, dependencies, optionalDependencies) {
     return {
         name: unitName,
         private: true,
         type: 'module',
         main: 'bundle.js',
         dependencies,
+        optionalDependencies,
     };
 }

package/dist/src/deploy/bundler/types.d.ts

@@ -7,9 +7,13 @@ export interface BundleResult {
     unitName: string;
     bundlePath: string;
     packageJsonPath: string;
+    exactDependenciesPath: string;
     metafilePath: string;
     bundleSizeBytes: number;
-    externalPackages: Record<string, string>;
+    bundleHash: string;
+    exactDependenciesHash: string;
+    exactDependencies: Record<string, string>;
+    exactOptionalDependencies: Record<string, string>;
 }
 export interface BundleError {
     unitName: string;

package/dist/src/deploy/codegen/per-unit-codegen.d.ts

@@ -8,7 +8,7 @@
  * Uses --stateInput to avoid re-inspecting the codebase for each unit.
  */
 import type { InspectorState } from '@pikku/inspector';
-import type { DeploymentManifest } from '../analyzer/manifest.js';
+import type { DeploymentManifest, DeploymentUnit } from '../analyzer/manifest.js';
 export interface PerUnitCodegenOptions {
     /** Root directory of the project (where pikku.config.json lives) */
     projectDir: string;
@@ -22,6 +22,8 @@ export interface PerUnitCodegenOptions {
     pikkuBin?: string;
     /** Called for each unit as it starts/completes */
     onProgress?: (unitName: string, status: 'start' | 'done' | 'error', error?: string) => void;
+    /** Resolve unit output directory (defaults to <deployDir>/<unit-name>) */
+    resolveUnitDir?: (unit: DeploymentUnit, baseDeployDir: string) => string;
 }
 export interface PerUnitCodegenResult {
     /** Map of unit name -> path to the unit's .pikku directory */

package/dist/src/deploy/codegen/per-unit-codegen.js

@@ -171,7 +171,9 @@ export async function generatePerUnitCodegen(options) {
                 continue;
             }
             onProgress?.(unit.name, 'start');
-            const unitDir = join(baseDir, unit.name);
+            const unitDir = options.resolveUnitDir
+                ? options.resolveUnitDir(unit, baseDir)
+                : join(baseDir, unit.name);
             const unitPikkuDir = join(unitDir, '.pikku');
             await mkdir(unitDir, { recursive: true });
             const namesArg = filterNames.join(',');

package/dist/src/deploy/plan/planner.js

@@ -23,14 +23,36 @@ function diffUnits(manifest, current, drainInfo) {
             });
         }
         else if (!arraysEqual(existing.functionIds, desired.functionIds) ||
-            existing.role !== desired.role) {
+            existing.role !== desired.role ||
+            (typeof desired.bundleHash === 'string' &&
+                typeof existing.bundleHash === 'string' &&
+                desired.bundleHash !== existing.bundleHash) ||
+            (typeof desired.exactDependenciesHash === 'string' &&
+                typeof existing.exactDependenciesHash === 'string' &&
+                desired.exactDependenciesHash !== existing.exactDependenciesHash)) {
+            const bundleChanged = typeof desired.bundleHash === 'string' &&
+                typeof existing.bundleHash === 'string' &&
+                desired.bundleHash !== existing.bundleHash;
+            const depsChanged = typeof desired.exactDependenciesHash === 'string' &&
+                typeof existing.exactDependenciesHash === 'string' &&
+                desired.exactDependenciesHash !== existing.exactDependenciesHash;
             changes.push({
                 action: 'update',
                 resourceType: 'unit',
                 name: desired.name,
                 role: desired.role,
-                reason: 'code changed',
-                details: { functionIds: desired.functionIds },
+                reason: bundleChanged
+                    ? depsChanged
+                        ? 'bundle + dependencies changed'
+                        : 'bundle changed'
+                    : depsChanged
+                        ? 'dependencies changed'
+                        : 'code changed',
+                details: {
+                    functionIds: desired.functionIds,
+                    bundleHash: desired.bundleHash,
+                    exactDependenciesHash: desired.exactDependenciesHash,
+                },
             });
         }
     }

package/dist/src/deploy/plan/provider.d.ts

@@ -5,6 +5,8 @@ export interface CurrentState {
         name: string;
         functionIds: string[];
         role: string;
+        bundleHash?: string;
+        exactDependenciesHash?: string;
     }>;
     queues: Array<{
         name: string;

package/dist/src/functions/commands/deploy-apply.js

@@ -94,7 +94,6 @@ export async function resolveProvider(config, providerName) {
 }
 const ANSI = {
     green: '\x1b[32m',
-    red: '\x1b[31m',
     bold: '\x1b[1m',
     reset: '\x1b[0m',
 };
@@ -119,8 +118,12 @@ async function runDeploy(provider, providerDir, logger, resultFile) {
         deployResult = await provider.deploy({
             buildDir: providerDir,
             logger,
-            onProgress: (_step, _detail) => {
-                process.stdout.write(` ${ANSI.green}done${ANSI.reset}\n`);
+            onProgress: (step, detail) => {
+                logger.info({
+                    message: `[${step}] ${detail}`,
+                    type: 'progress',
+                    data: { progress: { step, detail } },
+                });
             },
         });
     }
@@ -132,7 +135,6 @@ async function runDeploy(provider, providerDir, logger, resultFile) {
         };
     }
     await writeResultFile(resultFile, deployResult);
-    console.log('');
     if (deployResult.success) {
         logger.info(`${ANSI.green}${ANSI.bold}Deployment complete.${ANSI.reset}`);
         logger.info(`  ${deployResult.workersDeployed?.length ?? 0} units deployed, ${deployResult.resourcesCreated?.length ?? 0} resources created`);

package/dist/src/functions/commands/deploy-plan.js

@@ -89,7 +89,13 @@ export const deployPlan = pikkuSessionlessFunc({
                 unitCount: result.bundled.length,
                 totalSizeBytes: totalSize,
                 errors: result.bundleErrors,
-                manifest: result.manifest,
+                codegenErrors: result.codegenErrors,
+                summary: plan.summary,
+                changeCount: plan.changes.length,
+                artifacts: {
+                    deploymentManifestPath: result.deploymentManifestPath,
+                    infraPath: result.infraPath,
+                },
             }, null, 2), 'utf-8');
         }
     },

package/dist/src/functions/commands/pikku-command-summary.js

@@ -49,7 +49,10 @@ export const pikkuSummary = pikkuSessionlessFunc({
                 summary.set('workflowGraphs', workflowGraphsCount);
         }
         if (!logger.isSilent()) {
-            console.log(summary.format());
+            // Route through the logger so JSON mode emits a single NDJSON
+            // record instead of raw chalk-coloured text written directly to
+            // stdout (which would break NDJSON consumers).
+            logger.info({ message: summary.format(), type: 'summary' });
         }
     },
 });

package/dist/src/functions/commands/versions-update.js

@@ -13,9 +13,11 @@ export const pikkuVersionsUpdate = pikkuSessionlessFunc({
         const immutabilityErrors = visitState.manifest.errors.filter((e) => e.code === ErrorCode.FUNCTION_VERSION_MODIFIED);
         if (immutabilityErrors.length > 0) {
             for (const e of immutabilityErrors) {
-                logger.warn(`[${e.code}] ${e.message}`);
+                logger.critical(ErrorCode.FUNCTION_VERSION_MODIFIED, e.message);
+            }
+            if (logger.hasCriticalErrors()) {
+                process.exit(1);
             }
-            logger.warn(`Contract drift detected — version manifest not updated. Run 'pikku versions check' to inspect, or bump versions via code and re-run.`);
             return;
         }
         await saveManifest(manifestPath, visitState.manifest.current);

package/dist/src/functions/wirings/channels/pikku-command-channels.d.ts

@@ -1 +1 @@
-export declare const pikkuChannels: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuCommandChannels: import("#pikku").PikkuFunctionConfig<void, boolean | undefined, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, boolean | undefined, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, boolean | undefined, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/wirings/channels/pikku-command-channels.js

@@ -4,7 +4,7 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-export const pikkuChannels = pikkuSessionlessFunc({
+export const pikkuCommandChannels = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { channelsWiringFile, channelsWiringMetaFile, channelsWiringMetaJsonFile, packageMappings, schema, } = config;

package/dist/src/functions/wirings/console/pikku-command-console-functions.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeConsoleFunctions } from './serialize-console-functions.js';
 export const pikkuConsoleFunctions = pikkuSessionlessFunc({
-    func: async ({ logger, config }) => {
+    func: async ({ logger, config, variables }) => {
+        const deployCodegenFlag = await variables.get('PIKKU_DEPLOY_CODEGEN');
+        if (deployCodegenFlag === '1') {
+            return false;
+        }
         if (config.scaffold?.console) {
             const pathToPikkuTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.typesDeclarationFile, config.packageMappings);
             const pathToAgentTypes = getFileImportRelativePath(config.consoleFunctionsFile, config.agentTypesFile, config.packageMappings);