@pikku/cli 0.12.15 → 0.12.16

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

@@ -0,0 +1,114 @@
+const ANSI = {
+    green: '\x1b[32m',
+    blue: '\x1b[34m',
+    red: '\x1b[31m',
+    yellow: '\x1b[33m',
+    dim: '\x1b[2m',
+    bold: '\x1b[1m',
+    reset: '\x1b[0m',
+};
+const ACTION_DISPLAY = {
+    create: { symbol: '+', color: ANSI.green, label: 'create' },
+    update: { symbol: '~', color: ANSI.blue, label: 'update' },
+    delete: { symbol: '-', color: ANSI.red, label: 'delete' },
+    drain: { symbol: '\u23F3', color: ANSI.yellow, label: 'drain' },
+};
+const ROLE_LABELS = {
+    http: 'HTTP',
+    rpc: 'RPC',
+    mcp: 'MCP',
+    'queue-consumer': 'Queue Consumer',
+    scheduled: 'Cron',
+    agent: 'Agent',
+    channel: 'Channel',
+    'workflow-orchestrator': 'Workflow',
+    'workflow-step': 'Workflow Step',
+};
+const RESOURCE_LABELS = {
+    queue: 'Queue',
+    'scheduled-task': 'Scheduled Task',
+    secret: 'Secret',
+    variable: 'Variable',
+};
+function padRight(str, len) {
+    return str + ' '.repeat(Math.max(0, len - str.length));
+}
+function getResourceLabel(change) {
+    if (change.resourceType === 'unit' && change.role) {
+        return ROLE_LABELS[change.role] ?? change.role;
+    }
+    return RESOURCE_LABELS[change.resourceType] ?? change.resourceType;
+}
+function formatChange(change) {
+    const display = ACTION_DISPLAY[change.action];
+    const typeLabel = padRight(getResourceLabel(change), 16);
+    const nameLabel = padRight(change.name, 28);
+    return `  ${display.color}${display.symbol} ${padRight(display.label, 8)}${ANSI.reset} ${typeLabel} ${ANSI.bold}${nameLabel}${ANSI.reset} ${ANSI.dim}${change.reason}${ANSI.reset}`;
+}
+export function formatPlan(plan) {
+    const lines = [];
+    lines.push(`${ANSI.bold}Deployment Plan${ANSI.reset}`);
+    lines.push('');
+    if (plan.changes.length === 0) {
+        lines.push(`  ${ANSI.dim}No changes. Everything is up to date.${ANSI.reset}`);
+        return lines.join('\n');
+    }
+    // Group by action for clean output
+    const order = ['create', 'update', 'delete', 'drain'];
+    for (const action of order) {
+        const group = plan.changes.filter((c) => c.action === action);
+        for (const change of group) {
+            lines.push(formatChange(change));
+        }
+    }
+    if (plan.summary.unchanged > 0) {
+        lines.push(`  ${ANSI.dim}= ${plan.summary.unchanged} resources unchanged${ANSI.reset}`);
+    }
+    lines.push('');
+    const parts = [];
+    if (plan.summary.create > 0)
+        parts.push(`${ANSI.green}${plan.summary.create} to create${ANSI.reset}`);
+    if (plan.summary.update > 0)
+        parts.push(`${ANSI.blue}${plan.summary.update} to update${ANSI.reset}`);
+    if (plan.summary.delete > 0)
+        parts.push(`${ANSI.red}${plan.summary.delete} to delete${ANSI.reset}`);
+    if (plan.summary.drain > 0)
+        parts.push(`${ANSI.yellow}${plan.summary.drain} to drain${ANSI.reset}`);
+    lines.push(`${ANSI.bold}Summary:${ANSI.reset} ${parts.join(', ')}`);
+    return lines.join('\n');
+}
+/** Plain text version without ANSI colors (for logs, storage) */
+export function formatPlanPlain(plan) {
+    const lines = [];
+    lines.push('Deployment Plan');
+    lines.push('');
+    if (plan.changes.length === 0) {
+        lines.push('  No changes. Everything is up to date.');
+        return lines.join('\n');
+    }
+    const order = ['create', 'update', 'delete', 'drain'];
+    for (const action of order) {
+        const group = plan.changes.filter((c) => c.action === action);
+        for (const change of group) {
+            const display = ACTION_DISPLAY[change.action];
+            const typeLabel = padRight(getResourceLabel(change), 16);
+            const nameLabel = padRight(change.name, 28);
+            lines.push(`  ${display.symbol} ${padRight(display.label, 8)} ${typeLabel} ${nameLabel} ${change.reason}`);
+        }
+    }
+    if (plan.summary.unchanged > 0) {
+        lines.push(`  = ${plan.summary.unchanged} resources unchanged`);
+    }
+    lines.push('');
+    const parts = [];
+    if (plan.summary.create > 0)
+        parts.push(`${plan.summary.create} to create`);
+    if (plan.summary.update > 0)
+        parts.push(`${plan.summary.update} to update`);
+    if (plan.summary.delete > 0)
+        parts.push(`${plan.summary.delete} to delete`);
+    if (plan.summary.drain > 0)
+        parts.push(`${plan.summary.drain} to drain`);
+    lines.push(`Summary: ${parts.join(', ')}`);
+    return lines.join('\n');
+}

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

@@ -0,0 +1,5 @@
+export { generatePlan } from './planner.js';
+export { applyPlan } from './executor.js';
+export { formatPlan, formatPlanPlain } from './formatter.js';
+export type { DeploymentPlan, PlanChange, ApplyResult, ChangeAction, ResourceType, } from './types.js';
+export type { DeployProvider, CurrentState } from './provider.js';

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

@@ -0,0 +1,3 @@
+export { generatePlan } from './planner.js';
+export { applyPlan } from './executor.js';
+export { formatPlan, formatPlanPlain } from './formatter.js';

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

@@ -0,0 +1,4 @@
+import type { DeploymentManifest } from '../analyzer/manifest.js';
+import type { CurrentState, DeployProvider } from './provider.js';
+import type { DeploymentPlan } from './types.js';
+export declare function generatePlan(manifest: DeploymentManifest, currentState: CurrentState, provider: DeployProvider): Promise<DeploymentPlan>;

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

@@ -0,0 +1,220 @@
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    const sorted1 = [...a].sort();
+    const sorted2 = [...b].sort();
+    return sorted1.every((v, i) => v === sorted2[i]);
+}
+function diffUnits(manifest, current, drainInfo) {
+    const changes = [];
+    const currentByName = new Map(current.units.map((u) => [u.name, u]));
+    const desiredByName = new Map(manifest.units.map((u) => [u.name, u]));
+    // Create or update
+    for (const desired of manifest.units) {
+        const existing = currentByName.get(desired.name);
+        if (!existing) {
+            changes.push({
+                action: 'create',
+                resourceType: 'unit',
+                name: desired.name,
+                role: desired.role,
+                reason: 'new function',
+                details: { functionIds: desired.functionIds },
+            });
+        }
+        else if (!arraysEqual(existing.functionIds, desired.functionIds) ||
+            existing.role !== desired.role) {
+            changes.push({
+                action: 'update',
+                resourceType: 'unit',
+                name: desired.name,
+                role: desired.role,
+                reason: 'code changed',
+                details: { functionIds: desired.functionIds },
+            });
+        }
+    }
+    // Delete or drain
+    for (const existing of current.units) {
+        if (!desiredByName.has(existing.name)) {
+            const pending = drainInfo.get(existing.name) ?? 0;
+            if (pending > 0) {
+                changes.push({
+                    action: 'drain',
+                    resourceType: 'unit',
+                    name: existing.name,
+                    reason: `removed, ${pending} pending workflows`,
+                    details: { pendingCount: pending },
+                });
+            }
+            else {
+                changes.push({
+                    action: 'delete',
+                    resourceType: 'unit',
+                    name: existing.name,
+                    reason: 'removed, no active workflows',
+                });
+            }
+        }
+    }
+    return changes;
+}
+function diffSimpleResources(resourceType, desired, current) {
+    const changes = [];
+    const currentNames = new Set(current.map((r) => r.name));
+    const desiredNames = new Set(desired.map((r) => r.name));
+    for (const r of desired) {
+        if (!currentNames.has(r.name)) {
+            changes.push({
+                action: 'create',
+                resourceType,
+                name: r.name,
+                reason: 'new',
+            });
+        }
+    }
+    for (const r of current) {
+        if (!desiredNames.has(r.name)) {
+            changes.push({
+                action: 'delete',
+                resourceType,
+                name: r.name,
+                reason: 'removed',
+            });
+        }
+    }
+    return changes;
+}
+function diffScheduledTasks(desired, current) {
+    const changes = [];
+    const currentByUnit = new Map(current.map((t) => [t.unitName, t.schedule]));
+    const desiredByUnit = new Map(desired.map((t) => [t.unitName, t.schedule]));
+    for (const d of desired) {
+        const existingSchedule = currentByUnit.get(d.unitName);
+        if (existingSchedule === undefined) {
+            changes.push({
+                action: 'create',
+                resourceType: 'scheduled-task',
+                name: d.name,
+                reason: 'new scheduled task',
+                details: { schedule: d.schedule, unitName: d.unitName },
+            });
+        }
+        else if (existingSchedule !== d.schedule) {
+            changes.push({
+                action: 'update',
+                resourceType: 'scheduled-task',
+                name: d.name,
+                reason: 'schedule changed',
+                details: { oldSchedule: existingSchedule, newSchedule: d.schedule },
+            });
+        }
+    }
+    for (const c of current) {
+        if (!desiredByUnit.has(c.unitName)) {
+            changes.push({
+                action: 'delete',
+                resourceType: 'scheduled-task',
+                name: c.name ?? c.unitName,
+                reason: 'removed',
+            });
+        }
+    }
+    return changes;
+}
+function diffSecrets(desired, current) {
+    const changes = [];
+    const currentSet = new Set(current);
+    const desiredSet = new Set(desired);
+    for (const s of desired) {
+        if (!currentSet.has(s)) {
+            changes.push({
+                action: 'create',
+                resourceType: 'secret',
+                name: s,
+                reason: 'new secret',
+            });
+        }
+    }
+    for (const s of current) {
+        if (!desiredSet.has(s)) {
+            changes.push({
+                action: 'delete',
+                resourceType: 'secret',
+                name: s,
+                reason: 'removed',
+            });
+        }
+    }
+    return changes;
+}
+function diffVariables(desired, current) {
+    const changes = [];
+    for (const [key, value] of Object.entries(desired)) {
+        if (!(key in current)) {
+            changes.push({
+                action: 'create',
+                resourceType: 'variable',
+                name: key,
+                reason: 'new variable',
+            });
+        }
+        else if (current[key] !== value) {
+            changes.push({
+                action: 'update',
+                resourceType: 'variable',
+                name: key,
+                reason: 'value changed',
+            });
+        }
+    }
+    for (const key of Object.keys(current)) {
+        if (!(key in desired)) {
+            changes.push({
+                action: 'delete',
+                resourceType: 'variable',
+                name: key,
+                reason: 'removed',
+            });
+        }
+    }
+    return changes;
+}
+function countUnchanged(manifest, changes) {
+    const totalDesired = manifest.units.length +
+        manifest.queues.length +
+        manifest.scheduledTasks.length +
+        manifest.secrets.length +
+        manifest.variables.length;
+    // Rough count: total desired minus those that appear in changes
+    const createOrUpdate = changes.filter((c) => c.action === 'create' || c.action === 'update').length;
+    return Math.max(0, totalDesired - createOrUpdate);
+}
+export async function generatePlan(manifest, currentState, provider) {
+    // Check drain status for units being removed
+    const removedUnitNames = currentState.units
+        .filter((u) => !manifest.units.some((mu) => mu.name === u.name))
+        .map((u) => u.name);
+    const drainInfo = new Map();
+    for (const name of removedUnitNames) {
+        const { active, pendingCount } = await provider.hasActiveWork(name);
+        if (active) {
+            drainInfo.set(name, pendingCount);
+        }
+    }
+    const changes = [
+        ...diffUnits(manifest, currentState, drainInfo),
+        ...diffSimpleResources('queue', manifest.queues, currentState.queues),
+        ...diffScheduledTasks(manifest.scheduledTasks, currentState.scheduledTasks),
+        ...diffSecrets(manifest.secrets.map((s) => s.secretId), currentState.secrets),
+        ...diffVariables(Object.fromEntries(manifest.variables.map((v) => [v.variableId, v.displayName])), currentState.variables),
+    ];
+    const summary = {
+        create: changes.filter((c) => c.action === 'create').length,
+        update: changes.filter((c) => c.action === 'update').length,
+        delete: changes.filter((c) => c.action === 'delete').length,
+        drain: changes.filter((c) => c.action === 'drain').length,
+        unchanged: countUnchanged(manifest, changes),
+    };
+    return { changes, summary };
+}

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

@@ -0,0 +1,30 @@
+import type { DeploymentManifest } from '../analyzer/manifest.js';
+import type { PlanChange } from './types.js';
+export interface CurrentState {
+    units: Array<{
+        name: string;
+        functionIds: string[];
+        role: string;
+    }>;
+    queues: Array<{
+        name: string;
+    }>;
+    scheduledTasks: Array<{
+        unitName: string;
+        schedule: string;
+        name?: string;
+    }>;
+    secrets: string[];
+    variables: Record<string, string>;
+}
+export interface DeployProvider {
+    /** Get current deployed state for a project */
+    getCurrentState(projectId: string): Promise<CurrentState>;
+    /** Execute a single change from the plan */
+    applyChange(change: PlanChange, manifest: DeploymentManifest): Promise<void>;
+    /** Check if a resource has active work (for drain vs delete decisions) */
+    hasActiveWork(resourceName: string): Promise<{
+        active: boolean;
+        pendingCount: number;
+    }>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,29 @@
+export type ChangeAction = 'create' | 'update' | 'delete' | 'drain';
+export type ResourceType = 'unit' | 'queue' | 'scheduled-task' | 'secret' | 'variable';
+export interface PlanChange {
+    action: ChangeAction;
+    resourceType: ResourceType;
+    name: string;
+    reason: string;
+    /** For units, the deployment role (http, agent, mcp, etc.) */
+    role?: string;
+    details?: Record<string, unknown>;
+}
+export interface DeploymentPlan {
+    changes: PlanChange[];
+    summary: {
+        create: number;
+        update: number;
+        delete: number;
+        drain: number;
+        unchanged: number;
+    };
+}
+export interface ApplyResult {
+    applied: Array<{
+        change: PlanChange;
+        status: 'done' | 'error';
+        error?: string;
+    }>;
+    success: boolean;
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/src/deploy/provider-adapter.d.ts

@@ -0,0 +1,111 @@
+/**
+ * Provider adapter interface for the deploy pipeline.
+ *
+ * Each provider (Cloudflare, AWS, etc.) implements this to handle
+ * the provider-specific parts of deployment: entry generation,
+ * infrastructure manifests, and config files.
+ *
+ * The generic pipeline handles: analysis, codegen, bundling, plan/apply.
+ */
+import type { DeploymentManifest, DeploymentUnit } from './analyzer/manifest.js';
+export interface EntryGenerationContext {
+    /** The unit being generated */
+    unit: DeploymentUnit;
+    /** Absolute path to the unit's output directory */
+    unitDir: string;
+    /** Relative path to the unit's pikku-bootstrap.gen.js */
+    bootstrapPath: string;
+    /** Import statement for createConfig */
+    configImport: string;
+    /** Variable name for createConfig */
+    configVar: string;
+    /** Import statement for createSingletonServices */
+    servicesImport: string;
+    /** Variable name for createSingletonServices */
+    servicesVar: string;
+    /** Import statement for SingletonServices type (or empty string) */
+    singletonServicesImport: string;
+    /** Type expression for Partial<SingletonServices> (or fallback) */
+    servicesType: string;
+}
+export interface ProviderAdapter {
+    /** Provider name (e.g. 'cloudflare', 'aws') */
+    readonly name: string;
+    /** Subdirectory name under .deploy/ (e.g. 'cloudflare') */
+    readonly deployDirName: string;
+    /**
+     * When true, skips per-unit decomposition and bundles everything
+     * into a single unit using the project's full .pikku/ directory.
+     * Used by standalone adapter.
+     */
+    readonly singleUnit?: boolean;
+    /**
+     * Generate the entry file source for a deployment unit.
+     * Called once per unit.
+     */
+    generateEntrySource(ctx: EntryGenerationContext): string;
+    /**
+     * Generate provider-specific config files per unit (e.g. wrangler.toml).
+     * Returns a map of filename → content to write into the unit directory.
+     */
+    generateUnitConfigs(unit: DeploymentUnit, manifest: DeploymentManifest, projectId: string): Map<string, string>;
+    /**
+     * Generate provider-level infrastructure manifest (e.g. infra.json).
+     * Returns file content, or null if not applicable.
+     */
+    generateInfraManifest(manifest: DeploymentManifest): string | null;
+    /**
+     * External modules for esbuild bundling.
+     * Defaults to ['node:*'] if not provided.
+     */
+    getExternals?(): string[];
+    /**
+     * Module aliases for esbuild bundling (e.g. { crypto: 'node:crypto' }).
+     * Used to remap bare imports to platform-compatible paths.
+     */
+    getAliases?(): Record<string, string>;
+    /**
+     * esbuild define map for compile-time constants (e.g. { 'process.env.NODE_ENV': '"production"' }).
+     */
+    getDefine?(): Record<string, string>;
+    /**
+     * esbuild platform target. Defaults to 'node'.
+     * Cloudflare Workers should use 'neutral'.
+     */
+    getPlatform?(): 'node' | 'neutral' | 'browser';
+    /**
+     * esbuild output format. Defaults to 'esm'.
+     * pkg requires 'cjs' for standalone binaries.
+     */
+    getFormat?(): 'esm' | 'cjs';
+    /**
+     * Generate additional provider-level config files (e.g. serverless.yml).
+     * Returns a map of filename → content to write into the deploy directory.
+     */
+    generateProviderConfigs?(manifest: DeploymentManifest): Map<string, string>;
+    /**
+     * Deploy the built artifacts to the provider.
+     * Optional — if not implemented, the CLI just outputs the build directory.
+     */
+    deploy?(options: {
+        buildDir: string;
+        logger: {
+            info(msg: string): void;
+            error(msg: string): void;
+        };
+        onProgress?: (step: string, detail: string) => void;
+    }): Promise<{
+        success: boolean;
+        workersDeployed?: Array<{
+            name: string;
+        }>;
+        resourcesCreated?: Array<{
+            type: string;
+            name: string;
+        }>;
+        errors: Array<{
+            step: string;
+            error: string;
+        }>;
+    }>;
+}

package/dist/src/deploy/provider-adapter.js

@@ -0,0 +1,10 @@
+/**
+ * Provider adapter interface for the deploy pipeline.
+ *
+ * Each provider (Cloudflare, AWS, etc.) implements this to handle
+ * the provider-specific parts of deployment: entry generation,
+ * infrastructure manifests, and config files.
+ *
+ * The generic pipeline handles: analysis, codegen, bundling, plan/apply.
+ */
+export {};

package/dist/src/functions/commands/all.js

@@ -83,7 +83,6 @@ export const all = pikkuVoidFunc({
             }
         }
         await rpc.invoke('pikkuPublicRPC', null);
-        await rpc.invoke('pikkuRPCClient', null);
         await rpc.invoke('pikkuConsoleFunctions', null);
         await rpc.invoke('pikkuNodeTypes', null);
         await rpc.invoke('pikkuSecretDefinitionTypes', null);
@@ -106,10 +105,14 @@ export const all = pikkuVoidFunc({
         await rpc.invoke('pikkuRPCExposedMap', null);
         const workflows = await rpc.invoke('pikkuWorkflow', null);
         let remoteRPC = false;
+        let workflowRoutes = false;
         if (!config.addon) {
             remoteRPC = await rpc.invoke('pikkuRemoteRPC', null);
+            if (workflows) {
+                workflowRoutes = await rpc.invoke('pikkuWorkflowRoutes', null);
+            }
         }
-        if (workflows || remoteRPC) {
+        if (workflows || remoteRPC || workflowRoutes) {
             await getInspectorState(true);
             await rpc.invoke('pikkuSchemas', null);
         }
@@ -118,6 +121,7 @@ export const all = pikkuVoidFunc({
             if (http) {
                 await rpc.invoke('pikkuHTTPMap', null);
                 await rpc.invoke('pikkuFetch', null);
+                await rpc.invoke('pikkuRPCClient', null);
                 allImports.push(config.httpWiringMetaFile, config.httpWiringsFile);
             }
             const scheduler = await rpc.invoke('pikkuScheduler', null);

package/dist/src/functions/commands/deploy-apply.d.ts

@@ -0,0 +1,22 @@
+import type { ProviderAdapter, EntryGenerationContext } from '../../deploy/provider-adapter.js';
+import type { InspectorState } from '@pikku/inspector';
+export declare function getEntryContext(unitDir: string, pikkuDir: string, unit: EntryGenerationContext['unit'], inspectorState: InspectorState): EntryGenerationContext;
+export declare function resolveProvider(config?: {
+    deploy?: {
+        providers: Record<string, string>;
+        defaultProvider?: string;
+    };
+}, providerName?: string): Promise<ProviderAdapter>;
+export declare const deployApply: import("#pikku").PikkuFunctionConfig<{
+    fromPlan?: boolean;
+    provider?: string;
+    resultFile?: string;
+}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+    fromPlan?: boolean;
+    provider?: string;
+    resultFile?: string;
+}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    fromPlan?: boolean;
+    provider?: string;
+    resultFile?: string;
+}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;