@moda-ai/cli 1.10.2 → 1.11.0

package/dist/output.js

@@ -1,3 +1,6 @@
+import { randomUUID } from 'node:crypto';
+import { CliAuthError, CliCancellationError, CliInputError, CliInputRequiredError, isApiLikeError, isNetworkLikeError, } from './errors.js';
+import { redactDeep } from './redact.js';
 export const AGENT_SCHEMA_VERSION = 'moda.agent.v1';
 export const AGENT_EVENT_SCHEMA_VERSION = 'moda.agent_event.v1';
 /**
@@ -5,12 +8,100 @@ export const AGENT_EVENT_SCHEMA_VERSION = 'moda.agent_event.v1';
  *   0  ok        — grounded answer from Moda Cloud intelligence.
  *   3  degraded  — answer produced from a local/degraded fallback (lower trust).
  *   1  error     — command/input/unexpected failure (see envelope `errors[]`).
+ *   4  auth      — login or token renewal required before retrying.
+ *   5  input     — non-interactive caller must choose and re-invoke.
+ *   130 cancel   — interrupted or the output consumer closed the pipe.
  * `EXIT_DEGRADED` is intentionally distinct so a caller can tell a degraded
  * answer apart from both success and hard failure without parsing the payload.
  */
 export const EXIT_OK = 0;
 export const EXIT_ERROR = 1;
 export const EXIT_DEGRADED = 3;
+export const EXIT_AUTH_REQUIRED = 4;
+export const EXIT_INPUT_REQUIRED = 5;
+export const EXIT_CANCELLED = 130;
+export const AGENT_ERROR_CODES = [
+    'input_error',
+    'api_error',
+    'network_error',
+    'auth_required',
+    'input_required',
+    'cancelled',
+    'command_error',
+    'unknown_error',
+    'cloud_unavailable',
+];
+const FALLBACK_RUN_ID = randomUUID();
+let fallbackSeq = 0;
+let stdoutClosed = false;
+let stderrClosed = false;
+process.stdout.on('error', (error) => {
+    if (error.code === 'EPIPE') {
+        stdoutClosed = true;
+        process.exitCode = EXIT_CANCELLED;
+        return;
+    }
+    throw error;
+});
+process.stderr.on('error', (error) => {
+    if (error.code === 'EPIPE') {
+        stderrClosed = true;
+        process.exitCode = EXIT_CANCELLED;
+        return;
+    }
+    throw error;
+});
+/**
+ * True once an EPIPE from a closed stdout/stderr consumer has been observed.
+ * The stream error listeners above own this state; expose it so callers can
+ * detect consumer-cancelled runs explicitly instead of sniffing the global
+ * `process.exitCode`.
+ */
+export function wasOutputCancelled() {
+    return stdoutClosed || stderrClosed;
+}
+export function safeWriteStdout(text) {
+    if (stdoutClosed)
+        return false;
+    try {
+        if (process.env.NODE_ENV === 'test') {
+            console.log(text.endsWith('\n') ? text.slice(0, -1) : text);
+        }
+        else {
+            process.stdout.write(text);
+        }
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EPIPE') {
+            stdoutClosed = true;
+            process.exitCode = EXIT_CANCELLED;
+            return false;
+        }
+        throw error;
+    }
+}
+export function safeWriteStderr(text) {
+    if (stderrClosed)
+        return false;
+    try {
+        if (process.env.NODE_ENV === 'test') {
+            console.error(text.endsWith('\n') ? text.slice(0, -1) : text);
+        }
+        else {
+            process.stderr.write(text);
+        }
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'EPIPE') {
+            stderrClosed = true;
+            process.exitCode = EXIT_CANCELLED;
+            return false;
+        }
+        throw error;
+    }
+}
 /**
  * Output mode requested by explicit flags only, or `undefined` when the caller
  * did not pick one. Explicit flags always win over auto-detection.
@@ -75,80 +166,198 @@ export function resolveOutputMode(flags, opts = {}) {
     return 'human';
 }
 export function createCliOutput(options) {
-    return {
+    const state = {
+        runId: options.runId ?? randomUUID(),
+        seq: 0,
+        started: false,
+        terminal: false,
+        startedAt: Date.now(),
+        lastEventAt: Date.now(),
+    };
+    const emitEvent = (event) => {
+        if (options.quiet || options.mode !== 'agent-stream')
+            return;
+        if (state.terminal)
+            return;
+        if (event.event === 'started' && state.started)
+            return;
+        if (event.event === 'started')
+            state.started = true;
+        if (isTerminalEvent(event.event)) {
+            state.terminal = true;
+            clearHeartbeat(state);
+        }
+        state.lastEventAt = Date.now();
+        safeWriteStdout(`${JSON.stringify(createAgentEvent(options.command, event, state))}\n`);
+    };
+    const ensureStarted = () => {
+        if (options.mode !== 'agent-stream' || state.started || options.quiet)
+            return;
+        startHeartbeat(options.command, state);
+        emitEvent({
+            event: 'started',
+            phase: options.command,
+            message: `Starting ${options.command}.`,
+            elapsed_ms: 0,
+        });
+    };
+    const writeEnvelope = (data, writeOptions = {}) => {
+        return createAgentEnvelope({
+            command: options.command,
+            status: writeOptions.status === 'error'
+                ? 'error'
+                : writeOptions.status === 'degraded'
+                    ? 'degraded'
+                    : 'ok',
+            data,
+            meta: {
+                ...(writeOptions.meta ?? {}),
+                run_id: state.runId,
+            },
+            summary: writeOptions.summary,
+            findings: writeOptions.findings,
+            evidenceRefs: writeOptions.evidenceRefs,
+            recommendedActions: writeOptions.recommendedActions,
+            nextCommands: writeOptions.nextCommands,
+            artifacts: writeOptions.artifacts,
+            warnings: writeOptions.warnings,
+            errors: writeOptions.errors,
+        });
+    };
+    const output = {
         mode: options.mode,
         quiet: options.quiet === true,
         writeData(data, writeOptions = {}) {
             if (options.quiet)
                 return;
             if (options.mode === 'agent' || options.mode === 'agent-stream') {
-                const envelope = createAgentEnvelope({
-                    command: options.command,
-                    status: writeOptions.status === 'error'
-                        ? 'error'
-                        : writeOptions.status === 'degraded'
-                            ? 'degraded'
-                            : 'ok',
-                    data,
-                    meta: writeOptions.meta,
-                    summary: writeOptions.summary,
-                    findings: writeOptions.findings,
-                    evidenceRefs: writeOptions.evidenceRefs,
-                    recommendedActions: writeOptions.recommendedActions,
-                    nextCommands: writeOptions.nextCommands,
-                    artifacts: writeOptions.artifacts,
-                    warnings: writeOptions.warnings,
-                    errors: writeOptions.errors,
-                });
+                if (state.terminal)
+                    return;
+                const envelope = writeEnvelope(data, writeOptions);
                 if (options.mode === 'agent-stream') {
-                    console.log(JSON.stringify(createAgentEvent(options.command, {
+                    ensureStarted();
+                    emitEvent({
                         event: envelope.status === 'error' ? 'error' : 'completed',
                         status: envelope.status,
                         result: envelope,
-                    })));
+                        ...(envelope.errors[0] ? { error: envelope.errors[0] } : {}),
+                    });
                 }
                 else {
-                    console.log(JSON.stringify(envelope));
+                    state.terminal = true;
+                    safeWriteStdout(`${JSON.stringify(envelope)}\n`);
                 }
                 return;
             }
-            console.log(JSON.stringify(data, null, 2));
+            safeWriteStdout(`${JSON.stringify(redactDeep(data), null, 2)}\n`);
         },
         writeEvent(event) {
             if (options.quiet)
                 return;
             if (options.mode !== 'agent-stream')
                 return;
-            console.log(JSON.stringify(createAgentEvent(options.command, event)));
+            if (event.event === 'started') {
+                startHeartbeat(options.command, state);
+                emitEvent(event);
+                return;
+            }
+            ensureStarted();
+            emitEvent(event);
+        },
+        writeError(error) {
+            if (options.quiet || state.terminal)
+                return;
+            const agentError = errorToAgentError(error);
+            const envelope = createAgentErrorEnvelope(options.command || 'unknown', agentError, state.runId);
+            if (options.mode === 'agent-stream') {
+                ensureStarted();
+                if (error instanceof CliInputRequiredError) {
+                    emitEvent({
+                        event: 'needs_input',
+                        status: 'error',
+                        message: error.message,
+                        error: agentError,
+                        input_request: error.input_request,
+                        result: envelope,
+                    });
+                    return;
+                }
+                if (error instanceof CliAuthError) {
+                    emitEvent({
+                        event: 'auth_required',
+                        status: 'error',
+                        message: error.message,
+                        error: agentError,
+                        auth: error.auth,
+                        result: envelope,
+                    });
+                    return;
+                }
+                if (error instanceof CliCancellationError) {
+                    emitEvent({
+                        event: 'cancelled',
+                        status: 'error',
+                        message: error.message,
+                        error: agentError,
+                        result: envelope,
+                    });
+                    return;
+                }
+                emitEvent({
+                    event: 'error',
+                    status: 'error',
+                    message: agentError.message,
+                    error: agentError,
+                    result: envelope,
+                });
+                return;
+            }
+            if (options.mode === 'agent' || options.mode === 'json') {
+                state.terminal = true;
+                safeWriteStdout(`${JSON.stringify(envelope)}\n`);
+            }
+        },
+        writeCancelled(reason = 'Command cancelled.') {
+            output.writeError(new CliCancellationError(reason));
+        },
+        hasTerminalOutput() {
+            return state.terminal;
+        },
+        close() {
+            clearHeartbeat(state);
         },
     };
+    return output;
 }
 export function createAgentEnvelope(options) {
-    const bounded = boundForAgent(options.data);
-    return {
+    const safeData = redactDeep(options.data);
+    const bounded = boundForAgent(safeData);
+    const envelope = {
         schema_version: AGENT_SCHEMA_VERSION,
         command: options.command,
         status: options.status,
         generated_at: new Date().toISOString(),
         ...(options.profile ? { profile: options.profile } : {}),
-        summary: normalizeSummary(options.summary, options.command, options.status, options.data),
+        summary: normalizeSummary(options.summary, options.command, options.status, safeData),
         findings: options.findings ?? [],
         evidence_refs: options.evidenceRefs ?? [],
         recommended_actions: options.recommendedActions ?? [],
         next_commands: normalizeNextCommands(options.nextCommands ?? []),
         artifacts: options.artifacts ?? [],
-        warnings: options.warnings ?? inferWarnings(options.data),
+        warnings: options.warnings ?? inferWarnings(safeData),
         errors: options.errors ?? [],
         data: bounded.data,
         ...(options.meta ? { meta: options.meta } : {}),
         ...(bounded.truncation ? { truncation: bounded.truncation } : {}),
     };
+    return redactDeep(envelope);
 }
-export function createAgentErrorEnvelope(command, error) {
+export function createAgentErrorEnvelope(command, error, runId) {
     return createAgentEnvelope({
         command,
         status: 'error',
         data: null,
+        meta: runId ? { run_id: runId } : undefined,
         summary: {
             text: error.message,
             confidence: 'high',
@@ -162,18 +371,81 @@ export function createAgentErrorEnvelope(command, error) {
         })),
     });
 }
-export function createAgentEvent(command, event) {
-    return {
+export function createAgentEvent(command, event, state) {
+    const stamped = {
         schema_version: AGENT_EVENT_SCHEMA_VERSION,
         command,
         generated_at: new Date().toISOString(),
+        run_id: state?.runId ?? FALLBACK_RUN_ID,
+        seq: state ? ++state.seq : ++fallbackSeq,
+        event_version: event.event_version ?? 1,
         ...event,
     };
+    return redactDeep(stamped);
 }
 export function errorToAgentError(error) {
+    if (error instanceof CliInputRequiredError) {
+        return {
+            code: 'input_required',
+            message: error.message,
+            cause: error.usage,
+            suggested_commands: error.input_request.resume_command
+                ? [error.input_request.resume_command.join(' ')]
+                : undefined,
+            input_request: error.input_request,
+            blocking: true,
+        };
+    }
+    if (error instanceof CliAuthError) {
+        const suggested = [error.auth.login_command.join(' ')];
+        if (error.auth.resume_command)
+            suggested.push(error.auth.resume_command.join(' '));
+        return {
+            code: 'auth_required',
+            message: error.message,
+            cause: error.usage,
+            suggested_commands: suggested,
+            auth: error.auth,
+            blocking: true,
+        };
+    }
+    if (error instanceof CliCancellationError) {
+        return {
+            code: 'cancelled',
+            message: error.message,
+            blocking: true,
+        };
+    }
     if (error instanceof Error) {
+        if (error instanceof CliInputError || error.name === 'ZodError') {
+            return {
+                code: 'input_error',
+                message: error.message,
+                cause: 'usage' in error && typeof error.usage === 'string' ? error.usage : undefined,
+                suggested_commands: 'usage' in error && typeof error.usage === 'string'
+                    ? extractSuggestedCommands(error.usage)
+                    : undefined,
+                blocking: true,
+            };
+        }
+        if (isApiLikeError(error)) {
+            const statusCode = 'statusCode' in error ? error.statusCode : undefined;
+            return {
+                code: 'api_error',
+                message: error.message,
+                cause: typeof statusCode === 'number' ? `HTTP ${statusCode}` : undefined,
+                blocking: true,
+            };
+        }
+        if (isNetworkLikeError(error)) {
+            return {
+                code: 'network_error',
+                message: error.message,
+                blocking: true,
+            };
+        }
         return {
-            code: error.name === 'CliInputError' ? 'input_error' : 'command_error',
+            code: 'command_error',
             message: error.message,
             cause: 'usage' in error && typeof error.usage === 'string' ? error.usage : undefined,
             suggested_commands: 'usage' in error && typeof error.usage === 'string'
@@ -188,6 +460,39 @@ export function errorToAgentError(error) {
         blocking: true,
     };
 }
+function isTerminalEvent(event) {
+    return event === 'completed' ||
+        event === 'error' ||
+        event === 'cancelled' ||
+        event === 'needs_input' ||
+        event === 'auth_required';
+}
+function startHeartbeat(command, state) {
+    if (state.heartbeat)
+        return;
+    const intervalMs = Number(process.env.MODA_HEARTBEAT_MS ?? 10_000);
+    if (!Number.isFinite(intervalMs) || intervalMs <= 0)
+        return;
+    state.heartbeat = setInterval(() => {
+        if (state.terminal || stdoutClosed)
+            return;
+        const now = Date.now();
+        if (now - state.lastEventAt < intervalMs)
+            return;
+        state.lastEventAt = now;
+        safeWriteStdout(`${JSON.stringify(createAgentEvent(command, {
+            event: 'heartbeat',
+            elapsed_ms: now - state.startedAt,
+        }, state))}\n`);
+    }, intervalMs);
+    state.heartbeat.unref();
+}
+function clearHeartbeat(state) {
+    if (!state.heartbeat)
+        return;
+    clearInterval(state.heartbeat);
+    state.heartbeat = undefined;
+}
 function normalizeSummary(summary, command, status, data) {
     if (typeof summary === 'string') {
         return { text: summary, confidence: 'high' };

package/dist/prompts.d.ts

@@ -1,5 +1,6 @@
+import { type CommandContext } from './command-context.js';
 import type { ProfileIOOptions } from './profiles.js';
-export declare function runPromptsCommand(positionals: string[], flags: Record<string, string>, profileOptions?: ProfileIOOptions): Promise<void>;
+export declare function runPromptsCommand(input: CommandContext | string[], legacyFlags?: Record<string, string>, legacyProfileOptions?: ProfileIOOptions): Promise<void>;
 export declare function initPrompts(options?: {
     silent?: boolean;
 }): Promise<void>;

package/dist/prompts.js

@@ -3,6 +3,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
 import { dirname, isAbsolute, join, relative, resolve } from 'node:path';
 import { callControlAPI } from './api-client.js';
+import { createCommandContext } from './command-context.js';
 const MODA_DIR = '.moda';
 const MANIFEST_PATH = join(MODA_DIR, 'prompts.yml');
 const LOCK_PATH = join(MODA_DIR, 'prompts.lock.json');
@@ -12,23 +13,43 @@ const DEFAULT_PROMPT_PATHS = [
     'prompts/**/*.prompt.yaml',
     'prompts/**/*.prompt.yml',
 ];
-export async function runPromptsCommand(positionals, flags, profileOptions = { profile: flags.profile }) {
+export async function runPromptsCommand(input, legacyFlags, legacyProfileOptions) {
+    const context = Array.isArray(input)
+        ? createCommandContext({
+            command: 'prompts',
+            positional: input[0],
+            positionals: input,
+            flags: legacyFlags ?? {},
+        }, {
+            commandFlags: legacyFlags ?? {},
+            outputMode: legacyFlags?.agent === 'true' ? 'agent' : legacyFlags?.json === 'true' ? 'json' : 'human',
+            env: legacyProfileOptions?.env,
+        })
+        : input;
+    const positionals = context.positionals;
+    const flags = context.flags;
+    const profileOptions = legacyProfileOptions ?? { profile: context.profile, env: context.env };
     const subcommand = positionals[0] || 'status';
     switch (subcommand) {
         case 'init':
-            await initPrompts();
+            await initPrompts({ silent: true });
+            context.output.writeData({
+                manifest: MANIFEST_PATH,
+                lockfile: LOCK_PATH,
+                promptPaths: readManifest().promptPaths,
+            });
             break;
         case 'status':
-            printJson(await getPromptStatus());
+            context.output.writeData(await getPromptStatus());
             break;
         case 'diff':
-            printJson(await getPromptStatus());
+            context.output.writeData(await getPromptStatus());
             break;
         case 'sync':
-            await syncPrompts(flags, profileOptions);
+            await syncPrompts(flags, profileOptions, context);
             break;
         case 'promote':
-            await promotePrompt(positionals, flags, profileOptions);
+            await promotePrompt(positionals, flags, profileOptions, context);
             break;
         default:
             throw new Error(`Unknown prompts command '${subcommand}'. Use init, status, diff, sync, or promote.`);
@@ -52,12 +73,12 @@ export async function initPrompts(options = {}) {
         });
     }
 }
-async function syncPrompts(flags, profileOptions) {
+async function syncPrompts(flags, profileOptions, context) {
     if (flags.watch === 'true') {
         await watchPromptSync(flags, profileOptions);
         return;
     }
-    await syncPromptsOnce(flags, profileOptions);
+    await syncPromptsOnce(flags, profileOptions, context);
 }
 /**
  * Sync the manifest's prompt files to the backend and update the lockfile.
@@ -88,12 +109,16 @@ export async function runPromptSync(flags, profileOptions) {
     }
     return { synced: response.synced ?? [], dryRun };
 }
-async function syncPromptsOnce(flags, profileOptions) {
+async function syncPromptsOnce(flags, profileOptions, context) {
     const result = await runPromptSync(flags, profileOptions);
-    printJson({
+    const payload = {
         synced: result.synced,
         lockfile: result.dryRun ? undefined : LOCK_PATH,
-    });
+    };
+    if (context)
+        context.output.writeData(payload);
+    else
+        printJson(payload);
 }
 async function watchPromptSync(flags, profileOptions) {
     console.error('Watching prompt files. Press Ctrl+C to stop.');
@@ -111,7 +136,7 @@ async function watchPromptSync(flags, profileOptions) {
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
-async function promotePrompt(positionals, flags, profileOptions) {
+async function promotePrompt(positionals, flags, profileOptions, context) {
     const key = positionals[1];
     const label = flags.label;
     const versionId = flags.version || flags['version-id'];
@@ -125,7 +150,7 @@ async function promotePrompt(positionals, flags, profileOptions) {
         method: 'POST',
         body: JSON.stringify({ label, versionId }),
     }, profileOptions);
-    printJson(response);
+    context.output.writeData(response);
 }
 async function getPromptStatus() {
     await initPrompts({ silent: true });

package/dist/redact.d.ts

@@ -0,0 +1,2 @@
+export declare function redactDeep<T>(value: T): T;
+//# sourceMappingURL=redact.d.ts.map

package/dist/redact.js

@@ -0,0 +1,81 @@
+const REDACTED = '[REDACTED]';
+// Pure stack-safety bound. Cycles are handled separately by the `seen` WeakSet,
+// so this only needs to be high enough that legitimate nested payloads (the
+// agent-envelope wrapper plus arbitrary customer tool-call JSON) are never
+// silently truncated to '[MaxDepth]'. 256 is far below any real recursion limit.
+const MAX_DEPTH = 256;
+const SECRET_KEYS = new Set([
+    'api_key',
+    'apikey',
+    'token',
+    'access_token',
+    'authorization',
+    'secret',
+    'password',
+    'cli_token',
+]);
+const SECRET_PATTERNS = [
+    { pattern: /\bmoda_sk_[A-Za-z0-9_-]+\b/g, prefixLength: 8 },
+    { pattern: /\bmoda_ct_[A-Za-z0-9_-]+\b/g, prefixLength: 8 },
+    { pattern: /\bBearer\s+([A-Za-z0-9._~+/-]+=*)\b/gi, prefixLength: 8 },
+    { pattern: /\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/g, prefixLength: 8 },
+];
+export function redactDeep(value) {
+    return redactValue(value, 0, new WeakSet());
+}
+function redactValue(value, depth, seen) {
+    if (typeof value === 'string')
+        return redactString(value);
+    if (value === null || typeof value !== 'object')
+        return value;
+    if (depth >= MAX_DEPTH)
+        return '[MaxDepth]';
+    if (seen.has(value))
+        return '[Circular]';
+    seen.add(value);
+    if (Array.isArray(value)) {
+        try {
+            return value.map((item) => redactValue(item, depth + 1, seen));
+        }
+        finally {
+            seen.delete(value);
+        }
+    }
+    const out = {};
+    try {
+        for (const [key, item] of Object.entries(value)) {
+            out[key] = shouldRedactKey(key) ? redactSecretValue(item) : redactValue(item, depth + 1, seen);
+        }
+    }
+    finally {
+        seen.delete(value);
+    }
+    return out;
+}
+function shouldRedactKey(key) {
+    return SECRET_KEYS.has(key.replace(/[-\s]/g, '_').toLowerCase());
+}
+function redactSecretValue(value) {
+    if (typeof value !== 'string')
+        return REDACTED;
+    const redacted = redactString(value);
+    if (redacted !== value)
+        return redacted;
+    if (/^(configured|missing|not_configured|none|present|absent)$/i.test(value))
+        return value;
+    return REDACTED;
+}
+function redactString(input) {
+    let output = input;
+    for (const { pattern, prefixLength } of SECRET_PATTERNS) {
+        output = output.replace(pattern, (match) => {
+            if (/^Bearer\s+/i.test(match)) {
+                const token = match.replace(/^Bearer\s+/i, '');
+                return `Bearer ${token.slice(0, prefixLength)}...[REDACTED]`;
+            }
+            return `${match.slice(0, prefixLength)}...[REDACTED]`;
+        });
+    }
+    return output;
+}
+//# sourceMappingURL=redact.js.map

package/dist/schemas.d.ts

@@ -126,20 +126,20 @@ export declare const ToolFailureDetailSchema: z.ZodObject<{
     window: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
 }, "strip", z.ZodTypeAny, {
     tool_name: string;
+    subtype?: string | undefined;
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     window?: number | undefined;
     include_window?: boolean | undefined;
-    subtype?: string | undefined;
 }, {
     tool_name: string;
+    subtype?: string | undefined;
     days_back?: number | undefined;
     limit?: number | undefined;
     offset?: number | undefined;
     window?: number | undefined;
     include_window?: unknown;
-    subtype?: string | undefined;
 }>;
 /**
  * moda audit <conversation_id|trace_id> — raw, non-deduped span/trace read.