@pikku/cli 0.12.20 → 0.12.21

package/dist/src/functions/wirings/functions/serialize-function-types.js

@@ -12,7 +12,7 @@ export const serializeFunctionTypes = (userSessionTypeImport, userSessionTypeNam
  * Core function, middleware, and permission types for all wirings
  */
 
-import type { CorePikkuMiddleware, CorePermissionGroup, PikkuWire, PickRequired } from '@pikku/core'
+import type { CorePikkuMiddleware, CorePermissionGroup, ListInput, ListOutput, PikkuWire, PickRequired } from '@pikku/core'
 import type { CorePikkuFunctionConfig, CorePikkuAuth, CorePikkuAuthConfig, CorePikkuPermission } from '@pikku/core/function'
 import { pikkuAuth as pikkuAuthCore } from '@pikku/core/function'
 import { addMiddleware as addMiddlewareCore, addPermission as addPermissionCore } from '@pikku/core/middleware'
@@ -338,10 +338,13 @@ export type PikkuFunctionConfigWithSchema<
   RequiredWires extends keyof PikkuWire = never
 > = {
   name?: string
+  description?: string
   tags?: string[]
   expose?: boolean
   mcp?: boolean
   internal?: boolean
+  remote?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
   func: PikkuFunction<
@@ -415,6 +418,32 @@ export function pikkuFunc(func: any) {
   return typeof func === 'function' ? { func } : func
 }
 
+export type PikkuListFunction<
+  F extends Record<string, unknown> = {},
+  Row = unknown,
+  S extends string = never
+> =
+  | PikkuFunction<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'>
+  | PikkuFunctionSessionless<
+      ListInput<F, S>,
+      ListOutput<Row>,
+      'session' | 'rpc'
+    >
+
+export const pikkuListFunc = <
+  F extends Record<string, unknown> = {},
+  Row = unknown,
+  S extends string = never
+>(
+  config: PikkuFunctionConfig<
+    ListInput<F, S>,
+    ListOutput<Row>,
+    'session' | 'rpc'
+  >
+): PikkuFunctionConfig<ListInput<F, S>, ListOutput<Row>, 'session' | 'rpc'> => {
+  return pikkuFunc(config)
+}
+
 /**
  * Configuration object for sessionless Pikku functions with Zod schema validation.
  */
@@ -430,6 +459,7 @@ export type PikkuFunctionSessionlessConfigWithSchema<
   mcp?: boolean
   internal?: boolean
   remote?: boolean
+  deploy?: 'serverless' | 'server' | 'auto'
   approvalRequired?: boolean
   approvalDescription?: InputSchema extends StandardSchemaV1 ? PikkuApprovalDescription<InferSchemaOutput<InputSchema>> : never
   func: PikkuFunctionSessionless<

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

@@ -1 +1 @@
-export declare const pikkuHTTP: 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 pikkuCommandHTTP: 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/http/pikku-command-http-routes.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 pikkuHTTP = pikkuSessionlessFunc({
+export const pikkuCommandHTTP = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { httpWiringsFile, httpWiringMetaFile, httpWiringMetaJsonFile, packageMappings, schema, } = config;

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

@@ -1 +1 @@
-export declare const pikkuQueueMap: 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 pikkuCommandQueueMap: 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>;

package/dist/src/functions/wirings/queue/pikku-command-queue-map.js

@@ -2,7 +2,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeQueueMap } from './serialize-queue-map.js';
-export const pikkuQueueMap = pikkuSessionlessFunc({
+export const pikkuCommandQueueMap = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const { queueWorkers, functions, resolvedIOTypes } = await getInspectorState();
         const { queueMapDeclarationFile, packageMappings } = config;

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

@@ -1 +1 @@
-export declare const pikkuQueue: 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 pikkuCommandQueue: 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/queue/pikku-command-queue.js

@@ -5,7 +5,7 @@ import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-
 import { serializeQueueMeta, serializeQueueMetaTS, } from './serialize-queue-meta.js';
 import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { stripVerboseFields, hasVerboseFields, } from '../../../utils/strip-verbose-meta.js';
-export const pikkuQueue = pikkuSessionlessFunc({
+export const pikkuCommandQueue = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
         const visitState = await getInspectorState();
         const { queueWorkersWiringFile, queueWorkersWiringMetaFile, queueWorkersWiringMetaJsonFile, packageMappings, schema, } = config;

package/dist/src/functions/wirings/rpc/pikku-command-public-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializePublicRPC } from './serialize-public-rpc.js';
 export const pikkuPublicRPC = 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?.rpc) {
             const pathToPikkuTypes = getFileImportRelativePath(config.publicRpcFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.publicRpcFile, serializePublicRPC(pathToPikkuTypes, config.scaffold.rpc === 'auth', config.globalHTTPPrefix || ''));

package/dist/src/functions/wirings/rpc/pikku-command-remote-rpc.js

@@ -4,7 +4,11 @@ import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeRemoteRPC } from './serialize-remote-rpc.js';
 export const pikkuRemoteRPC = 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.remoteRpcWorkersFile) {
             const pathToPikkuTypes = getFileImportRelativePath(config.remoteRpcWorkersFile, config.typesDeclarationFile, config.packageMappings);
             await writeFileInDir(logger, config.remoteRpcWorkersFile, serializeRemoteRPC(pathToPikkuTypes));

package/dist/src/functions/wirings/rpc/serialize-typed-rpc-map.js

@@ -41,13 +41,13 @@ ${addonImports}
 ${mergedRPCMap}
 
 export type RPCInvoke = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
 
 export type RPCRemote = <Name extends keyof FlattenedRPCMap>(
-  ...args: FlattenedRPCMap[Name]['input'] extends void | null
+  ...args: IsVoidishInput<FlattenedRPCMap[Name]['input']> extends true
     ? [name: Name]
     : [name: Name, data: FlattenedRPCMap[Name]['input']]
 ) => Promise<FlattenedRPCMap[Name]['output']>
@@ -117,6 +117,13 @@ function generateMergedRPCMap(wireAddonDeclarations) {
         return `
 // No addon packages, use RPCMap directly
 export type FlattenedRPCMap = RPCMap
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     }
     // TypeScript utility to flatten namespaced RPC maps
@@ -131,6 +138,13 @@ export type FlattenedRPCMap =
   RPCMap${Array.from(wireAddonDeclarations.keys())
         .map((namespace) => ` & PrefixKeys<${toPascalCase(namespace)}RPCMap, '${namespace}'>`)
         .join('')}
+
+type IsAny<T> = 0 extends (1 & T) ? true : false
+type IsVoidishInput<T> = IsAny<T> extends true
+  ? false
+  : [T] extends [void | null | undefined]
+    ? true
+    : false
 `;
     return utilityTypes;
 }

package/dist/src/functions/wirings/workflow/serialize-workflow-routes.js

@@ -68,6 +68,7 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -78,6 +79,26 @@ export const workflowStatusStream = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         steps: steps.map((s: { stepName: string; status: string }) => [s.stepName, s.status]),
@@ -133,6 +154,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
     const terminalStatuses = new Set(['completed', 'failed', 'cancelled'])
     let lastHash = ''
+    let initSent = false
 
     const poll = async () => {
       const run = await workflowRunService.getRun(runId)
@@ -143,6 +165,26 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc<
 
       const steps = await workflowRunService.getRunSteps(runId)
 
+      if (!initSent && run.deterministic) {
+        const statusByStep = new Map(
+          steps.map((s: { stepName: string; status: string }) => [
+            s.stepName,
+            s.status,
+          ])
+        )
+        channel.send({
+          type: 'init',
+          deterministic: true,
+          steps: (run.plannedSteps ?? []).map(
+            (s: { stepName: string }) => ({
+              stepName: s.stepName,
+              status: statusByStep.get(s.stepName) ?? 'pending',
+            })
+          ),
+        })
+        initSent = true
+      }
+
       const hash = JSON.stringify({
         s: run.status,
         o: run.output,

package/dist/src/functions/workflows/all.workflow.js

@@ -128,7 +128,7 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [http, scheduler, triggers] = await Promise.all([
-                workflow.do('HTTP', 'pikkuHTTP', null),
+                workflow.do('HTTP', 'pikkuCommandHTTP', null),
                 workflow.do('Scheduler', 'pikkuScheduler', null),
                 workflow.do('Trigger', 'pikkuTrigger', null),
             ]);
@@ -158,15 +158,15 @@ export const allWorkflow = pikkuWorkflowComplexFunc({
         }
         if (!config.addon) {
             const [queues, channels, gateways, mcp, cli] = await Promise.all([
-                workflow.do('Queue', 'pikkuQueue', null),
-                workflow.do('Channels', 'pikkuChannels', null),
+                workflow.do('Queue', 'pikkuCommandQueue', null),
+                workflow.do('Channels', 'pikkuCommandChannels', null),
                 workflow.do('Gateway', 'pikkuGateway', null),
                 workflow.do('MCP', 'pikkuMCP', null),
                 workflow.do('CLI', 'pikkuCLI', null),
             ]);
             if (queues) {
                 await Promise.all([
-                    workflow.do('Queue map', 'pikkuQueueMap', null),
+                    workflow.do('Queue map', 'pikkuCommandQueueMap', null),
                     workflow.do('Queue service', 'pikkuQueueService', null),
                 ]);
                 allImports.push(config.queueWorkersWiringMetaFile, config.queueWorkersWiringFile);

package/dist/src/scaffold/rpc-remote.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.20
+ * This file was generated by @pikku/cli@0.12.21
  */
 /**
  * Auto-generated remote internal RPC queue worker and HTTP endpoint

package/dist/src/scaffold/workflow-routes.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.20
+ * This file was generated by @pikku/cli@0.12.21
  */
 /**
  * Workflow HTTP catch-all routes
@@ -50,6 +50,7 @@ export const workflowStatusStream = pikkuSessionlessFunc({
             return;
         const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
         let lastHash = '';
+        let initSent = false;
         const poll = async () => {
             const run = await workflowRunService.getRun(runId);
             if (!run) {
@@ -57,6 +58,21 @@ export const workflowStatusStream = pikkuSessionlessFunc({
                 return false;
             }
             const steps = await workflowRunService.getRunSteps(runId);
+            if (!initSent && run.deterministic) {
+                const statusByStep = new Map(steps.map((s) => [
+                    s.stepName,
+                    s.status,
+                ]));
+                channel.send({
+                    type: 'init',
+                    deterministic: true,
+                    steps: (run.plannedSteps ?? []).map((s) => ({
+                        stepName: s.stepName,
+                        status: statusByStep.get(s.stepName) ?? 'pending',
+                    })),
+                });
+                initSent = true;
+            }
             const hash = JSON.stringify({
                 s: run.status,
                 steps: steps.map((s) => [s.stepName, s.status]),
@@ -105,6 +121,7 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc({
             return;
         const terminalStatuses = new Set(['completed', 'failed', 'cancelled']);
         let lastHash = '';
+        let initSent = false;
         const poll = async () => {
             const run = await workflowRunService.getRun(runId);
             if (!run) {
@@ -112,6 +129,21 @@ export const workflowStatusStreamFull = pikkuSessionlessFunc({
                 return false;
             }
             const steps = await workflowRunService.getRunSteps(runId);
+            if (!initSent && run.deterministic) {
+                const statusByStep = new Map(steps.map((s) => [
+                    s.stepName,
+                    s.status,
+                ]));
+                channel.send({
+                    type: 'init',
+                    deterministic: true,
+                    steps: (run.plannedSteps ?? []).map((s) => ({
+                        stepName: s.stepName,
+                        status: statusByStep.get(s.stepName) ?? 'pending',
+                    })),
+                });
+                initSent = true;
+            }
             const hash = JSON.stringify({
                 s: run.status,
                 o: run.output,

package/dist/src/services/cli-logger.service.d.ts

@@ -1,26 +1,46 @@
 import type { Logger } from '@pikku/core/services';
 import { LogLevel } from '@pikku/core/services';
 import type { ErrorCode } from '@pikku/inspector';
+export type CLIOutputMode = 'text' | 'json';
 export declare class CLILogger implements Logger {
     private silent;
     private level;
     private criticalErrors;
+    private outputMode;
+    private jsonFlushHookRegistered;
     constructor({ logLogo, silent, }: {
         logLogo: boolean;
         silent?: boolean;
     });
     setLevel(level: LogLevel): void;
     setSilent(silent: boolean): void;
+    setOutputMode(mode: CLIOutputMode): void;
+    getOutputMode(): CLIOutputMode;
     isSilent(): boolean;
+    private normalizeMessage;
+    private writeJSONLine;
+    private ensureJSONFlushHook;
+    flushJSONBuffer(): void;
+    private emit;
     info(message: string | {
         message: string;
         type?: string;
+        data?: Record<string, unknown>;
+    }): void;
+    error(message: string | Error | {
+        message: string;
+        type?: string;
+        data?: Record<string, unknown>;
+    }): void;
+    warn(message: string | {
+        message: string;
+        type?: string;
+        data?: Record<string, unknown>;
     }): void;
-    error(message: string): void;
-    warn(message: string): void;
     debug(message: string | {
         message: string;
         type?: string;
+        data?: Record<string, unknown>;
     }): void;
     critical(code: ErrorCode, message: string): void;
     hasCriticalErrors(): boolean;

package/dist/src/services/cli-logger.service.js

@@ -9,10 +9,13 @@ const logo = `
 |_|    |_|_| _)_| _)____/
 `;
 const BASE_ERROR_URL = 'https://pikku.dev/docs/pikku-cli/errors';
+const ANSI_ESCAPE_REGEX = /\x1B\[[0-?]*[ -/]*[@-~]/g;
 export class CLILogger {
     silent;
     level = LogLevel.warn; // default to warn level
     criticalErrors = [];
+    outputMode = 'text';
+    jsonFlushHookRegistered = false;
     constructor({ logLogo, silent = false, }) {
         this.silent = silent;
         if (logLogo && !silent) {
@@ -25,49 +28,122 @@ export class CLILogger {
     setSilent(silent) {
         this.silent = silent;
     }
+    setOutputMode(mode) {
+        this.outputMode = mode;
+        if (mode === 'json') {
+            this.ensureJSONFlushHook();
+        }
+    }
+    getOutputMode() {
+        return this.outputMode;
+    }
     isSilent() {
         return this.silent;
     }
+    normalizeMessage(message) {
+        const str = typeof message === 'string'
+            ? message
+            : message instanceof Error
+                ? (message.stack ?? message.message)
+                : typeof message === 'object' && message !== null
+                    ? JSON.stringify(message)
+                    : String(message);
+        if (this.outputMode === 'json') {
+            return str.replace(ANSI_ESCAPE_REGEX, '');
+        }
+        return str;
+    }
+    writeJSONLine(payload) {
+        process.stdout.write(`${JSON.stringify(payload)}\n`);
+    }
+    ensureJSONFlushHook() {
+        if (this.jsonFlushHookRegistered)
+            return;
+        this.jsonFlushHookRegistered = true;
+        process.once('beforeExit', () => this.flushJSONBuffer());
+        process.once('exit', () => this.flushJSONBuffer());
+    }
+    // NDJSON records are written synchronously in `emit` so consumers can
+    // stream output; nothing is buffered. Kept as a no-op because the
+    // beforeExit/exit hooks installed by `ensureJSONFlushHook` still
+    // reference it, and external callers may rely on the signature.
+    flushJSONBuffer() { }
+    emit(level, message, type, code, data) {
+        const normalizedMessage = this.normalizeMessage(message);
+        if (this.outputMode === 'json') {
+            this.writeJSONLine({
+                level,
+                message: normalizedMessage,
+                ...(type ? { type } : {}),
+                ...(code ? { code } : {}),
+                ...(code ? { url: `${BASE_ERROR_URL}/${code.toLowerCase()}` } : {}),
+                ...(data ? { data } : {}),
+                timestamp: new Date().toISOString(),
+            });
+            return;
+        }
+        if (level === 'error') {
+            console.error(chalk.red(normalizedMessage));
+            return;
+        }
+        if (level === 'warn') {
+            console.error(chalk.yellow(normalizedMessage));
+            return;
+        }
+        if (level === 'critical') {
+            console.error(chalk.red.bold(normalizedMessage));
+            return;
+        }
+        let c = level === 'info' ? chalk.blue : chalk.gray;
+        if (type === 'success') {
+            c = chalk.green;
+        }
+        else if (type === 'timing' && level === 'info') {
+            c = chalk.gray;
+        }
+        console.log(c(normalizedMessage));
+    }
     info(message) {
         if (this.level > LogLevel.info || this.silent)
             return;
-        let c = chalk.blue;
-        if (typeof message === 'object') {
-            if (message.type === 'success') {
-                c = chalk.green;
-            }
-            else if (message.type === 'timing') {
-                c = chalk.gray;
-            }
-        }
-        console.log(c(typeof message === 'string' ? message : message.message));
+        const msg = typeof message === 'string' ? message : message.message;
+        const type = typeof message === 'string' ? undefined : message.type;
+        const data = typeof message === 'string' ? undefined : message.data;
+        this.emit('info', msg, type, undefined, data);
     }
     error(message) {
         if (this.level > LogLevel.error)
             return;
-        console.error(chalk.red(message));
+        if (message instanceof Error) {
+            this.emit('error', message.stack ?? message.message);
+            return;
+        }
+        const msg = typeof message === 'string' ? message : message.message;
+        const type = typeof message === 'string' ? undefined : message.type;
+        const data = typeof message === 'string' ? undefined : message.data;
+        this.emit('error', msg, type, undefined, data);
     }
     warn(message) {
         if (this.level > LogLevel.warn)
             return;
-        console.error(chalk.yellow(message));
+        const msg = typeof message === 'string' ? message : message.message;
+        const type = typeof message === 'string' ? undefined : message.type;
+        const data = typeof message === 'string' ? undefined : message.data;
+        this.emit('warn', msg, type, undefined, data);
     }
     debug(message) {
         if (this.level > LogLevel.debug || this.silent)
             return;
-        let c = chalk.gray;
-        if (typeof message === 'object') {
-            if (message.type === 'success') {
-                c = chalk.green;
-            }
-        }
-        console.log(c(typeof message === 'string' ? message : message.message));
+        const msg = typeof message === 'string' ? message : message.message;
+        const type = typeof message === 'string' ? undefined : message.type;
+        const data = typeof message === 'string' ? undefined : message.data;
+        this.emit('debug', msg, type, undefined, data);
     }
     critical(code, message) {
         const url = `${BASE_ERROR_URL}/${code.toLowerCase()}`;
         const formattedMessage = `[${code}] ${message}\n  → ${url}`;
         this.criticalErrors.push(formattedMessage);
-        console.error(chalk.red.bold(formattedMessage));
+        this.emit('critical', formattedMessage, undefined, code);
     }
     hasCriticalErrors() {
         return this.criticalErrors.length > 0;
@@ -83,7 +159,7 @@ export class CLILogger {
     }
     primary(message) {
         if (!this.silent) {
-            console.log(chalk.green(message));
+            this.emit('info', message);
         }
     }
 }

package/dist/src/services.js

@@ -103,6 +103,13 @@ export const createConfig = async (_variablesService, data) => {
     // --silent > --loglevel > --verbose > --info > default (warn)
     let logLevel = LogLevel.warn; // default
     let isSilent = false;
+    // --output is constrained to 'text' | 'json' by the CLI parser
+    // (choices + default in cli.wiring.ts), so no runtime validation
+    // is needed here. --json is kept as an alias that forces 'json'.
+    const outputMode = data.json
+        ? 'json'
+        : data.output;
+    logger.setOutputMode(outputMode);
     if (data.silent) {
         logLevel = LogLevel.critical;
         isSilent = true;
@@ -125,7 +132,7 @@ export const createConfig = async (_variablesService, data) => {
     logger.setLevel(logLevel);
     logger.setSilent(isSilent);
     // Display logo unless in silent mode
-    if (!isSilent) {
+    if (!isSilent && outputMode !== 'json') {
         logger.logLogo();
     }
     const cliConfig = await getPikkuCLIConfig(logger, data.configFile, [], true, data.outDir);