@pikku/cli 0.12.20 → 0.12.22

package/dist/src/fabric/sdk/pikku-rpc.gen.d.ts

@@ -0,0 +1,105 @@
+/**
+ * This file was generated by @pikku/cli@0.12.21
+ */
+import { PikkuFetch } from "./pikku-fetch.gen.js";
+import type { RPCInvoke, TypedAgentRun, TypedStartWorkflow, TypedRunWorkflow, TypedWorkflowStatus } from './rpc-map.gen.d.js';
+/**
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
+ * to your Pikku server. It wraps the underlying HTTP client and provides a
+ * simple interface for invoking server-side functions.
+ */
+export declare class PikkuRPC {
+    /** The underlying HTTP client used for making RPC calls */
+    pikkuFetch: PikkuFetch;
+    /**
+     * Sets a custom PikkuFetch instance to use for RPC calls.
+     * This allows you to configure custom settings or use a shared client instance.
+     *
+     * @param pikkuFetch - The PikkuFetch instance to use
+     */
+    setPikkuFetch(pikkuFetch: PikkuFetch): void;
+    /**
+     * Sets the base server URL for all RPC calls.
+     *
+     * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
+     */
+    setServerUrl(serverUrl: string): void;
+    /**
+     * Sets the JWT token for authorization on all RPC calls.
+     *
+     * @param jwt - The JWT token to use for authorization, or null to remove authorization
+     */
+    setAuthorizationJWT(jwt: string | null): void;
+    /**
+     * Sets the API key for authorization on all RPC calls.
+     *
+     * @param apiKey - The API key to use for authorization, or null to remove the API key
+     */
+    setAPIKey(apiKey: string | null): void;
+    /**
+     * Invokes a remote procedure call on the server.
+     * This is a generic method that routes to the appropriate server function
+     * based on the function name and passes the provided data.
+     *
+     * @param rpcName - The name of the server function to invoke
+     * @param data - The data to pass to the server function
+     * @returns A promise that resolves with the function's return value
+     */
+    invoke: RPCInvoke;
+    /**
+     * Starts a workflow by name with the given input.
+     * Posts to \`/workflow/:workflowName/start\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the new run ID
+     */
+    startWorkflow: TypedStartWorkflow;
+    /**
+     * Runs a workflow to completion and returns the output.
+     * Posts to \`/workflow/:workflowName/run\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the workflow output
+     */
+    runWorkflow: TypedRunWorkflow;
+    /**
+     * Gets the current status of a workflow run.
+     * GET \`/workflow/:workflowName/status/:runId\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param runId - The workflow run ID
+     * @returns A promise with the minimal run status
+     */
+    workflowStatus: TypedWorkflowStatus;
+    /**
+     * Agent namespace — methods for running, streaming, and approving AI agents.
+     * All methods post to \`/rpc/agent/:agentName/*\`.
+     */
+    agent: {
+        /**
+         * Runs an agent to completion and returns the result.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         * @returns A promise with runId, result, and token usage
+         */
+        run: TypedAgentRun;
+        /**
+         * Streams agent responses via SSE. Used for real-time chat interfaces.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         */
+        stream: (agentName: string, input: Record<string, unknown>) => Promise<any>;
+        /**
+         * Approves or denies pending tool calls for an agent run.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The approval payload (runId, approvals array)
+         */
+        approve: (agentName: string, input: Record<string, unknown>) => Promise<any>;
+    };
+}
+export declare const pikkuRPC: PikkuRPC;

package/dist/src/fabric/sdk/pikku-rpc.gen.js

@@ -0,0 +1,126 @@
+/**
+ * This file was generated by @pikku/cli@0.12.21
+ */
+import { PikkuFetch } from "./pikku-fetch.gen.js";
+/**
+ * PikkuRPC provides a type-safe client for making Remote Procedure Calls (RPC)
+ * to your Pikku server. It wraps the underlying HTTP client and provides a
+ * simple interface for invoking server-side functions.
+ */
+export class PikkuRPC {
+    /** The underlying HTTP client used for making RPC calls */
+    pikkuFetch = new PikkuFetch();
+    /**
+     * Sets a custom PikkuFetch instance to use for RPC calls.
+     * This allows you to configure custom settings or use a shared client instance.
+     *
+     * @param pikkuFetch - The PikkuFetch instance to use
+     */
+    setPikkuFetch(pikkuFetch) {
+        this.pikkuFetch = pikkuFetch;
+    }
+    /**
+     * Sets the base server URL for all RPC calls.
+     *
+     * @param serverUrl - The base URL of your Pikku server (e.g., 'https://api.example.com')
+     */
+    setServerUrl(serverUrl) {
+        this.pikkuFetch.setServerUrl(serverUrl);
+    }
+    /**
+     * Sets the JWT token for authorization on all RPC calls.
+     *
+     * @param jwt - The JWT token to use for authorization, or null to remove authorization
+     */
+    setAuthorizationJWT(jwt) {
+        this.pikkuFetch.setAuthorizationJWT(jwt);
+    }
+    /**
+     * Sets the API key for authorization on all RPC calls.
+     *
+     * @param apiKey - The API key to use for authorization, or null to remove the API key
+     */
+    setAPIKey(apiKey) {
+        this.pikkuFetch.setAPIKey(apiKey);
+    }
+    /**
+     * Invokes a remote procedure call on the server.
+     * This is a generic method that routes to the appropriate server function
+     * based on the function name and passes the provided data.
+     *
+     * @param rpcName - The name of the server function to invoke
+     * @param data - The data to pass to the server function
+     * @returns A promise that resolves with the function's return value
+     */
+    invoke = ((rpcName, data) => {
+        return this.pikkuFetch.post(`/rpc/${String(rpcName)}`, { rpcName: String(rpcName), data });
+    });
+    /**
+     * Starts a workflow by name with the given input.
+     * Posts to \`/workflow/:workflowName/start\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the new run ID
+     */
+    startWorkflow = async (workflowName, input) => {
+        return await this.pikkuFetch.post(`/workflow/${String(workflowName)}/start`, { data: input });
+    };
+    /**
+     * Runs a workflow to completion and returns the output.
+     * Posts to \`/workflow/:workflowName/run\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param input - The workflow input data
+     * @returns A promise that resolves with the workflow output
+     */
+    runWorkflow = async (workflowName, input) => {
+        return await this.pikkuFetch.post(`/workflow/${String(workflowName)}/run`, { data: input });
+    };
+    /**
+     * Gets the current status of a workflow run.
+     * GET \`/workflow/:workflowName/status/:runId\`.
+     *
+     * @param workflowName - The registered workflow name
+     * @param runId - The workflow run ID
+     * @returns A promise with the minimal run status
+     */
+    workflowStatus = async (workflowName, runId) => {
+        return await this.pikkuFetch.get(`/workflow/${String(workflowName)}/status/${runId}`);
+    };
+    /**
+     * Agent namespace — methods for running, streaming, and approving AI agents.
+     * All methods post to \`/rpc/agent/:agentName/*\`.
+     */
+    agent = {
+        /**
+         * Runs an agent to completion and returns the result.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         * @returns A promise with runId, result, and token usage
+         */
+        run: (async (agentName, input) => {
+            return await this.pikkuFetch.post(`/rpc/agent/${String(agentName)}`, input);
+        }),
+        /**
+         * Streams agent responses via SSE. Used for real-time chat interfaces.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The agent input (message, threadId, resourceId)
+         */
+        stream: async (agentName, input) => {
+            return await this.pikkuFetch.post(`/rpc/agent/${String(agentName)}/stream`, input);
+        },
+        /**
+         * Approves or denies pending tool calls for an agent run.
+         *
+         * @param agentName - The registered agent name
+         * @param input - The approval payload (runId, approvals array)
+         */
+        approve: async (agentName, input) => {
+            return await this.pikkuFetch.post(`/rpc/agent/${String(agentName)}/approve`, input);
+        },
+    };
+}
+export const pikkuRPC = new PikkuRPC();

package/dist/src/functions/commands/all.d.ts

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

package/dist/src/functions/commands/binary.d.ts

@@ -0,0 +1,7 @@
+export declare const binary: import("#pikku").PikkuFunctionConfig<{
+    compileTarget?: string;
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+    compileTarget?: string;
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+    compileTarget?: string;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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

@@ -0,0 +1,40 @@
+import { resolve, dirname } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { pikkuSessionlessFunc } from '#pikku';
+function targetSuffix(target) {
+    return target.replace(/^bun-/, '').replace(/[^a-z0-9_-]/g, '-');
+}
+export const binary = pikkuSessionlessFunc({
+    func: async ({ logger, config }, data) => {
+        const binConfig = config.binary;
+        if (!binConfig) {
+            throw new Error('No "binary" config found in pikku.config.json. Add a "binary" section with "entrypoint" and "output".');
+        }
+        const entrypoint = resolve(config.rootDir, binConfig.entrypoint);
+        if (!existsSync(entrypoint)) {
+            throw new Error(`Binary entrypoint not found: ${entrypoint}`);
+        }
+        const outputBase = resolve(config.rootDir, binConfig.output);
+        const outputDir = dirname(outputBase);
+        if (!existsSync(outputDir)) {
+            mkdirSync(outputDir, { recursive: true });
+        }
+        const targets = data?.compileTarget
+            ? [data.compileTarget]
+            : binConfig.targets?.length
+                ? binConfig.targets
+                : [undefined];
+        for (const target of targets) {
+            const outputPath = target
+                ? `${outputBase}-${targetSuffix(target)}`
+                : outputBase;
+            const args = ['build', '--compile', `--outfile=${outputPath}`, entrypoint];
+            if (target)
+                args.splice(2, 0, `--target=${target}`);
+            logger.info(`Compiling${target ? ` for ${target}` : ''}...`);
+            execFileSync('bun', args, { stdio: 'inherit' });
+            logger.info(`Output: ${outputPath}`);
+        }
+    },
+});

package/dist/src/functions/commands/bootstrap.d.ts

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

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

@@ -2,17 +2,20 @@ import { pikkuVoidFunc } from '#pikku';
 export const bootstrap = pikkuVoidFunc({
     remote: true,
     func: async ({ logger, getInspectorState }, _data, { rpc }) => {
-        await getInspectorState(false, false, true);
-        await rpc.invoke('pikkuFunctionTypes');
+        await getInspectorState(false, true, true);
         await rpc.invoke('pikkuFunctionTypesSplit');
+        await rpc.invoke('pikkuFunctionTypes');
         await rpc.invoke('pikkuHTTPTypes');
         await rpc.invoke('pikkuChannelTypes');
         await rpc.invoke('pikkuSchedulerTypes');
         await rpc.invoke('pikkuQueueTypes');
-        await rpc.invoke('pikkuWorkflow');
+        await rpc.invoke('pikkuWorkflow', { bootstrap: true });
+        await rpc.invoke('pikkuTriggerTypes');
         await rpc.invoke('pikkuMCPTypes');
         await rpc.invoke('pikkuAIAgentTypes');
-        await rpc.invoke('pikkuCLITypes');
+        await rpc.invoke('pikkuNodeTypes');
+        await rpc.invoke('pikkuSecretDefinitionTypes');
+        await rpc.invoke('pikkuCLITypes', { bootstrap: true });
         if (logger.hasCriticalErrors()) {
             process.exit(1);
         }

package/dist/src/functions/commands/console.d.ts

@@ -2,12 +2,12 @@ export declare const consoleCommand: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     open?: string;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     open?: string;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
     open?: string;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/commands/db-migrate.d.ts

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

package/dist/src/functions/commands/db-migrate.js

@@ -0,0 +1,35 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { resolveLocalDb, migrateAndCodegen } from '../db/local-db.js';
+import { loadUserConfigForDb } from './db-shared.js';
+export const dbMigrate = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState }) => {
+        const userConfig = await loadUserConfigForDb({
+            config,
+            getInspectorState,
+            logger,
+        });
+        if (!userConfig)
+            return;
+        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        if (!resolved) {
+            logger.error('pikku db migrate: dev.db is not configured in your pikku config.');
+            throw new Error('dev.db not configured');
+        }
+        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        if (migrate.applied.length === 0) {
+            logger.info(`db migrate: no pending migrations (${migrate.skipped.length} already applied)`);
+        }
+        else {
+            for (const name of migrate.applied) {
+                logger.info(`db migrate: applied ${name}`);
+            }
+        }
+        logger.info(codegen.written
+            ? `db migrate: regenerated ${codegen.outFile} (${codegen.tables.length} tables)`
+            : `db migrate: ${codegen.outFile} unchanged`);
+        logger.info(zod.written
+            ? `db migrate: regenerated ${zod.outFile} (${zod.tables.length} tables)`
+            : `db migrate: ${zod.outFile} unchanged`);
+    },
+});

package/dist/src/functions/commands/db-reset.d.ts

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

package/dist/src/functions/commands/db-reset.js

@@ -0,0 +1,36 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { resolveLocalDb, reset, migrateAndCodegen, seed, } from '../db/local-db.js';
+import { loadUserConfigForDb } from './db-shared.js';
+export const dbReset = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState }) => {
+        const userConfig = await loadUserConfigForDb({
+            config,
+            getInspectorState,
+            logger,
+        });
+        if (!userConfig)
+            return;
+        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        if (!resolved) {
+            logger.error('pikku db reset: dev.db is not configured in your pikku config.');
+            throw new Error('dev.db not configured');
+        }
+        reset(resolved, config.rootDir);
+        logger.info(`db reset: removed ${resolved.dbFile}`);
+        const { migrate, codegen, zod } = migrateAndCodegen(resolved);
+        for (const name of migrate.applied) {
+            logger.info(`db reset: applied ${name}`);
+        }
+        logger.info(codegen.written
+            ? `db reset: regenerated ${codegen.outFile} (${codegen.tables.length} tables)`
+            : `db reset: ${codegen.outFile} unchanged`);
+        logger.info(zod.written
+            ? `db reset: regenerated ${zod.outFile} (${zod.tables.length} tables)`
+            : `db reset: ${zod.outFile} unchanged`);
+        const seedResult = seed(resolved);
+        if (seedResult.applied) {
+            logger.info(`db reset: seeded ${resolved.seedFile} (${seedResult.bytes} bytes)`);
+        }
+    },
+});

package/dist/src/functions/commands/db-seed.d.ts

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

package/dist/src/functions/commands/db-seed.js

@@ -0,0 +1,27 @@
+import { pikkuSessionlessFunc } from '#pikku';
+import { resolveLocalDb, seed } from '../db/local-db.js';
+import { loadUserConfigForDb } from './db-shared.js';
+export const dbSeed = pikkuSessionlessFunc({
+    remote: true,
+    func: async ({ logger, config, getInspectorState }) => {
+        const userConfig = await loadUserConfigForDb({
+            config,
+            getInspectorState,
+            logger,
+        });
+        if (!userConfig)
+            return;
+        const resolved = resolveLocalDb(userConfig.dev?.db, config.rootDir, config.outDir, config.runtimeDir);
+        if (!resolved) {
+            logger.error('pikku db seed: dev.db is not configured in your pikku config.');
+            throw new Error('dev.db not configured');
+        }
+        const result = seed(resolved);
+        if (!result.applied) {
+            logger.info(`db seed: no ${resolved.seedFile} found, nothing to do`);
+        }
+        else {
+            logger.info(`db seed: applied ${resolved.seedFile} (${result.bytes} bytes)`);
+        }
+    },
+});

package/dist/src/functions/commands/db-shared.d.ts

@@ -0,0 +1,32 @@
+import type { DevDbConfig } from '../db/local-db.js';
+export interface UserConfigShape {
+    dev?: {
+        db?: DevDbConfig;
+    };
+    [key: string]: unknown;
+}
+interface LoadOptions {
+    config: {
+        rootDir: string;
+        outDir: string;
+    };
+    getInspectorState: (refresh: boolean) => Promise<{
+        filesAndMethods: {
+            pikkuConfigFactory?: {
+                file: string;
+                variable: string;
+            };
+        };
+    }>;
+    logger: {
+        error: (msg: string) => void;
+    };
+}
+/**
+ * Load the user's pikkuConfig the same way `dev.ts` does — through the
+ * inspector state, then by importing the user's config factory file.
+ * Returns `null` (and logs the error) if the project hasn't defined a
+ * pikkuConfigFactory, so the caller can early-exit.
+ */
+export declare function loadUserConfigForDb(options: LoadOptions): Promise<UserConfigShape | null>;
+export {};

package/dist/src/functions/commands/db-shared.js

@@ -0,0 +1,26 @@
+import { resolve } from 'path';
+import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
+/**
+ * Load the user's pikkuConfig the same way `dev.ts` does — through the
+ * inspector state, then by importing the user's config factory file.
+ * Returns `null` (and logs the error) if the project hasn't defined a
+ * pikkuConfigFactory, so the caller can early-exit.
+ */
+export async function loadUserConfigForDb(options) {
+    const { config, getInspectorState, logger } = options;
+    const inspectorState = await getInspectorState(true);
+    const { pikkuConfigFactory } = inspectorState.filesAndMethods;
+    if (!pikkuConfigFactory) {
+        logger.error('createConfig must be defined in your project');
+        return null;
+    }
+    const pikkuDir = resolve(config.rootDir, config.outDir);
+    await loadUserBootstrap(pikkuDir);
+    const configModule = await loadUserModule(pikkuConfigFactory.file);
+    const userCreateConfig = configModule[pikkuConfigFactory.variable];
+    if (typeof userCreateConfig !== 'function') {
+        logger.error(`Expected '${pikkuConfigFactory.variable}' in '${pikkuConfigFactory.file}' to be a function`);
+        return null;
+    }
+    return (await userCreateConfig());
+}

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

@@ -11,12 +11,12 @@ export declare const deployApply: import("#pikku").PikkuFunctionConfig<{
     fromPlan?: boolean;
     provider?: string;
     resultFile?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     fromPlan?: boolean;
     provider?: string;
     resultFile?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     fromPlan?: boolean;
     provider?: string;
     resultFile?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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-info.d.ts

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

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

@@ -1,10 +1,10 @@
 export declare const deployPlan: import("#pikku").PikkuFunctionConfig<{
     resultFile?: string;
     provider?: string;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     resultFile?: string;
     provider?: string;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     resultFile?: string;
     provider?: string;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

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/dev.d.ts

@@ -2,12 +2,12 @@ export declare const dev: import("#pikku").PikkuFunctionConfig<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;
-}, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;