@moda-ai/cli 1.10.2 → 1.11.0

package/dist/init/index.js

@@ -14,7 +14,7 @@ import { SDK_GUIDE_PATH, writeSdkIntegrationGuide } from './sdk-guide.js';
 import { runSdkIntegration } from './sdk-integration.js';
 import { createCommandContext } from '../command-context.js';
 import { VERSION } from '../config.js';
-import { CliInputError } from '../errors.js';
+import { CliAuthError, CliInputError } from '../errors.js';
 import { runHarnessCommand } from '../harness.js';
 import { buildDoctorReport } from '../doctor.js';
 import { renderInitBanner, renderInitComplete, renderInitNote, renderInitSetupPlan, renderInitStep, } from '../tui.js';
@@ -48,7 +48,11 @@ export async function runInit(flags, options = {}) {
     let token = loadToken();
     if (!token) {
         if (json || agent) {
-            throw new CliInputError('Browser authentication is required before non-interactive init can continue.', 'Run `moda init` in a human terminal first, or provide an existing cached auth session.');
+            throw new CliAuthError('Browser authentication is required before non-interactive init can continue.', {
+                reason: 'no_stored_credentials',
+                login_command: ['moda', 'auth', 'login'],
+                resume_command: ['moda', 'init', ...resumeFlagsForInit(flags)],
+            }, 'Run `moda auth login`, then re-run `moda init`.');
         }
         let action = 'login';
         if (!yes) {
@@ -73,7 +77,12 @@ export async function runInit(flags, options = {}) {
     // Step 3: Tenant + API Key
     log(renderInitStep(3, 7, 'Workspace & Profile'));
     emit('workspace', 'Selecting workspace and creating API key.');
-    const { apiKey, tenantName } = await selectTenantAndCreateKey();
+    const { apiKey, tenantName } = await selectTenantAndCreateKey({
+        tenantId: stringFlag(flagValue(flags, 'tenant-id', 'tenant_id')),
+        nonInteractive: json || agent,
+        silent: !human,
+        resumeCommand: ['moda', 'init', ...resumeFlagsForInit(flags)],
+    });
     log(renderInitNote(`Active workspace: ${tenantName}`));
     emit('workspace', `Active workspace: ${tenantName}`, 'completed');
     phases.push({ id: 'workspace', title: 'Workspace & Profile', status: 'completed', details: tenantName });
@@ -86,7 +95,12 @@ export async function runInit(flags, options = {}) {
         positionals: ['analyze'],
         flags: commandFlags({
             summary: true,
-            yes,
+            // In machine mode the nested harness scan must not emit its own
+            // `needs_input` with a `moda harness analyze --yes` resume command — an
+            // orchestrator obeying it would resume the scan and silently skip the
+            // rest of init. The broad local read is part of the init flow the caller
+            // already opted into, so auto-approve it here; human init still confirms.
+            yes: yes || json || agent,
             json: json || agent,
             agent,
             analyst: stringFlag(flags.analyst) ?? 'auto',
@@ -139,6 +153,15 @@ export async function runInit(flags, options = {}) {
         configureCiCd: await shouldConfigureCiCd(flags, yes),
         configureAutosync: await shouldConfigureAutosync(flags, yes),
     });
+    if (json || agent) {
+        const skipped = setupPlan
+            .filter((action) => (action.category === 'sdk' || action.category === 'ci-cd' || action.category === 'autosync') &&
+            action.approved === false)
+            .map((action) => `${action.category}: ${action.command ?? 'explicit flag required'}`);
+        if (skipped.length > 0) {
+            emit('plan', `Non-interactive init skipped optional actions (${skipped.join('; ')}).`, 'warning');
+        }
+    }
     log(renderInitSetupPlan(setupPlan));
     emit('plan', 'Setup plan ready.', 'completed');
     phases.push({ id: 'plan', title: 'Setup Plan', status: 'completed' });
@@ -497,6 +520,36 @@ function commandFlags(flags) {
 function stringFlag(value) {
     return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
 }
+function resumeFlagsForInit(flags) {
+    const passthrough = [
+        'profile',
+        'tenant-id',
+        'offline',
+        'analyst',
+        'sdk-integrate',
+        'ci-cd',
+        'autosync',
+        'no-sdk-integrate',
+        'no-ci-cd',
+        'no-autosync',
+        'yes',
+        'agent',
+        'json',
+        'stream',
+    ];
+    const out = [];
+    for (const key of passthrough) {
+        const value = flagValue(flags, key, key.replace(/-/g, '_'));
+        if (value === undefined || value === false || value === 'false')
+            continue;
+        const flag = `--${key}`;
+        if (value === true || value === 'true')
+            out.push(flag);
+        else
+            out.push(flag, String(value));
+    }
+    return out;
+}
 // Coding-agent capture is temporarily disabled; restore this prompt with the hooks phase.
 // async function shouldIngestCodingAgentTraces(
 //   flags: Record<string, unknown>,

package/dist/init/tenant.d.ts

@@ -4,6 +4,11 @@ interface BootstrapResult {
     tenantName: string;
     tenantSlug: string;
 }
-export declare function selectTenantAndCreateKey(): Promise<BootstrapResult>;
+export declare function selectTenantAndCreateKey(options?: {
+    tenantId?: string;
+    nonInteractive?: boolean;
+    silent?: boolean;
+    resumeCommand?: string[];
+}): Promise<BootstrapResult>;
 export {};
 //# sourceMappingURL=tenant.d.ts.map

package/dist/init/tenant.js

@@ -2,7 +2,8 @@
 import { select } from '@inquirer/prompts';
 import { authFetch } from '../auth.js';
 import { resolveIngestUrl, saveCliConfig } from '../config.js';
-export async function selectTenantAndCreateKey() {
+import { CliInputError, CliInputRequiredError } from '../errors.js';
+export async function selectTenantAndCreateKey(options = {}) {
     // 1. Fetch CLI context
     const contextRes = await authFetch('/api/cli/context');
     if (!contextRes.ok) {
@@ -10,16 +11,39 @@ export async function selectTenantAndCreateKey() {
         throw new Error(`Failed to fetch context (${contextRes.status}): ${body}`);
     }
     const ctx = (await contextRes.json());
-    console.log(`  Authenticated as ${ctx.user.email}`);
+    if (!options.silent)
+        console.log(`  Authenticated as ${ctx.user.email}`);
     // 2. Select tenant
     if (ctx.tenants.length === 0) {
-        console.error('  No organizations found. Create one at https://moda.dev');
-        process.exit(1);
+        throw new CliInputError('No organizations found. Create one at https://moda.dev', 'Create an organization in Moda, then rerun `moda init`.');
     }
     let tenantId;
-    if (ctx.tenants.length === 1) {
+    if (options.tenantId) {
+        const selected = ctx.tenants.find((tenant) => tenant.id === options.tenantId);
+        if (!selected) {
+            throw new CliInputError(`Tenant '${options.tenantId}' is not available for the authenticated user.`, 'Run `moda init` without --tenant-id in a human terminal, or choose a tenant from the needs_input event.');
+        }
+        tenantId = selected.id;
+        if (!options.silent)
+            console.log(`  Organization: ${selected.name}`);
+    }
+    else if (ctx.tenants.length === 1) {
         tenantId = ctx.tenants[0].id;
-        console.log(`  Organization: ${ctx.tenants[0].name}`);
+        if (!options.silent)
+            console.log(`  Organization: ${ctx.tenants[0].name}`);
+    }
+    else if (options.nonInteractive) {
+        throw new CliInputRequiredError('Multiple Moda organizations are available; choose one and re-run with --tenant-id.', {
+            id: 'init_tenant_selection',
+            question: 'Select organization',
+            kind: 'select',
+            choices: ctx.tenants.map((tenant) => ({
+                value: tenant.id,
+                label: `${tenant.name} (${tenant.role})`,
+                resume_flags: ['--tenant-id', tenant.id],
+            })),
+            resume_command: options.resumeCommand,
+        }, 'Re-run `moda init --tenant-id <tenant_id>`.');
     }
     else {
         tenantId = await select({
@@ -37,9 +61,7 @@ export async function selectTenantAndCreateKey() {
         body: JSON.stringify({ tenantId }),
     });
     if (bootstrapRes.status === 403) {
-        console.error('  Error: You need admin or owner access to create API keys.');
-        console.error('  Ask your organization owner to upgrade your role.');
-        process.exit(1);
+        throw new CliInputError('You need admin or owner access to create API keys.', 'Ask your organization owner to upgrade your role.');
     }
     if (!bootstrapRes.ok) {
         const body = await bootstrapRes.text();
@@ -55,8 +77,10 @@ export async function selectTenantAndCreateKey() {
         tenant_id: result.tenantId,
         ingest_url: resolveIngestUrl(),
     });
-    console.log('  API key + tenant saved to ~/.moda/config.json\n');
-    console.log('  (Set MODA_API_KEY / MODA_TENANT_ID to override for scripts/CI.)\n');
+    if (!options.silent) {
+        console.log('  API key + tenant saved to ~/.moda/config.json\n');
+        console.log('  (Set MODA_API_KEY / MODA_TENANT_ID to override for scripts/CI.)\n');
+    }
     return result;
 }
 //# sourceMappingURL=tenant.js.map

package/dist/manifest.d.ts

@@ -0,0 +1,5 @@
+import type { CommandMetadata } from './command-registry.js';
+export declare const MANIFEST_SCHEMA_VERSION = "moda.manifest.v1";
+export declare function buildManifest(commands: CommandMetadata[]): Record<string, unknown>;
+export declare function renderManifestHuman(manifest: Record<string, unknown>): string;
+//# sourceMappingURL=manifest.d.ts.map

package/dist/manifest.js

@@ -0,0 +1,111 @@
+import { VERSION } from './config.js';
+export const MANIFEST_SCHEMA_VERSION = 'moda.manifest.v1';
+export function buildManifest(commands) {
+    return {
+        schema_version: MANIFEST_SCHEMA_VERSION,
+        cli_version: VERSION,
+        invocations: [
+            'bunx @moda-ai/cli',
+            'npx -y @moda-ai/cli',
+            'moda',
+        ],
+        global_flags: [
+            '--agent',
+            '--stream',
+            '--json',
+            '--human',
+            '--profile <name>',
+            '--quiet',
+            '--no-telemetry',
+            '--no-update-check',
+            '--json-schemas',
+        ],
+        env: [
+            'MODA_FORMAT',
+            'MODA_AGENT',
+            'MODA_API_KEY',
+            'MODA_TENANT_ID',
+            'MODA_PROFILE',
+            'MODA_BASE_URL',
+            'MODA_HEARTBEAT_MS',
+            'MODA_AGENT_MAX_OUTPUT_BYTES',
+            'MODA_CLI_TELEMETRY',
+            'MODA_CLI_UPDATE_CHECK',
+        ],
+        exit_codes: [
+            { code: 0, name: 'ok', meaning: 'Command completed successfully.' },
+            { code: 1, name: 'error', meaning: 'Command, input, API, network, or unexpected failure.' },
+            { code: 3, name: 'degraded', meaning: 'Reserved for `moda ask` local fallback.' },
+            { code: 4, name: 'auth_required', meaning: 'Run login_command, then resume.' },
+            { code: 5, name: 'input_required', meaning: 'Choose from input_request choices, then resume.' },
+            { code: 130, name: 'cancelled', meaning: 'Interrupted or output consumer closed.' },
+        ],
+        events: [
+            event('started', 'First event for every agent stream.', false),
+            event('progress', 'Progress update while work continues.', false),
+            event('warning', 'Non-fatal warning or skipped action.', false),
+            event('artifact', 'File or artifact produced by a command.', false),
+            event('heartbeat', 'Idle liveness event emitted after MODA_HEARTBEAT_MS without output.', false),
+            event('needs_input', 'Terminal event requesting exit-and-reinvoke input.', true),
+            event('auth_required', 'Terminal event requesting authentication before retry.', true),
+            event('completed', 'Terminal success event.', true),
+            event('error', 'Terminal failure event.', true),
+            event('cancelled', 'Terminal cancellation event.', true),
+            event('approval_required', 'Deprecated; use needs_input.', true, true),
+        ],
+        schemas: [
+            'moda.agent.v1',
+            'moda.agent_event.v1',
+            'moda.intelligence.v1',
+            'production_ask.v0.1',
+        ],
+        commands: commands.map((command) => ({
+            name: command.name,
+            aliases: command.aliases ?? [],
+            summary: command.description,
+            output_modes: command.outputModes,
+            streaming: command.outputModes.includes('agent-stream') || command.outputModes.includes('agent'),
+            examples: command.examples,
+            auth: command.auth,
+            mutability: command.mutability,
+            exit_codes: exitCodesForCommand(command.name),
+        })),
+        concepts: [
+            { term: 'tenant', meaning: 'A Moda organization/workspace that owns data, prompts, skills, and API keys.' },
+            { term: 'profile', meaning: 'A named local CLI configuration under ~/.moda that selects environment, tenant, and secret references.' },
+            { term: 'harness', meaning: 'Moda’s local graph of runtime agents, prompts, tools, identities, and deployments in a codebase.' },
+            { term: 'harness report', meaning: 'A cited analyst artifact under .moda/ that justifies the harness graph before sync.' },
+            { term: 'conversation', meaning: 'A user-agent interaction thread stored in Moda analytics.' },
+            { term: 'trace', meaning: 'Raw OTLP span evidence for one run or conversation, exposed by `moda audit`.' },
+            { term: 'ingest key', meaning: 'A `moda_sk_` API key for SDKs, CI, and Data API calls. Treat it as a secret.' },
+            { term: 'CLI session token', meaning: 'A local browser-auth session token used by CLI auth/bootstrap flows, not by application SDKs.' },
+            { term: 'prompt', meaning: 'A code-first prompt file tracked by `.moda/prompts.yml` and synced to Moda.' },
+            { term: 'skill', meaning: 'A SKILL.md agent instruction file generated by or synced to Moda.' },
+        ],
+    };
+}
+export function renderManifestHuman(manifest) {
+    const commands = Array.isArray(manifest.commands) ? manifest.commands : [];
+    return [
+        `Moda CLI manifest ${manifest.cli_version ?? ''}`,
+        '',
+        'Commands:',
+        ...commands.map((command) => {
+            const row = command;
+            return `  ${row.name ?? 'unknown'} - ${row.summary ?? ''}`;
+        }),
+        '',
+        'Run `moda manifest --json` for the full machine-readable contract.',
+    ].join('\n');
+}
+function event(name, when, terminal, deprecated = false) {
+    return { name, event_version: 1, when, terminal, ...(deprecated ? { deprecated: true } : {}) };
+}
+function exitCodesForCommand(command) {
+    if (command === 'ask')
+        return [0, 1, 3, 4, 5, 130];
+    if (command === 'init' || command === 'harness')
+        return [0, 1, 4, 5, 130];
+    return [0, 1, 4, 130];
+}
+//# sourceMappingURL=manifest.js.map

package/dist/output.d.ts

@@ -1,3 +1,4 @@
+import { type AgentAuthRequest, type AgentInputRequest } from './errors.js';
 export type CliOutputMode = 'human' | 'json' | 'agent' | 'agent-stream';
 export declare const AGENT_SCHEMA_VERSION = "moda.agent.v1";
 export declare const AGENT_EVENT_SCHEMA_VERSION = "moda.agent_event.v1";
@@ -6,12 +7,20 @@ export declare 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 declare const EXIT_OK = 0;
 export declare const EXIT_ERROR = 1;
 export declare const EXIT_DEGRADED = 3;
+export declare const EXIT_AUTH_REQUIRED = 4;
+export declare const EXIT_INPUT_REQUIRED = 5;
+export declare const EXIT_CANCELLED = 130;
+export declare const AGENT_ERROR_CODES: readonly ["input_error", "api_error", "network_error", "auth_required", "input_required", "cancelled", "command_error", "unknown_error", "cloud_unavailable"];
+export type AgentErrorCode = typeof AGENT_ERROR_CODES[number];
 export type AgentStatus = 'ok' | 'degraded' | 'error';
 export type AgentConfidence = 'high' | 'medium' | 'low' | 'unknown';
 export interface AgentSummary {
@@ -54,10 +63,12 @@ export interface AgentArtifact {
     description?: string;
 }
 export interface AgentError {
-    code: string;
+    code: AgentErrorCode | string;
     message: string;
     cause?: string;
     suggested_commands?: string[];
+    input_request?: AgentInputRequest;
+    auth?: AgentAuthRequest;
     blocking: boolean;
 }
 export interface AgentEnvelope {
@@ -80,9 +91,12 @@ export interface AgentEnvelope {
 }
 export interface AgentEvent {
     schema_version: typeof AGENT_EVENT_SCHEMA_VERSION;
-    event: 'started' | 'progress' | 'artifact' | 'approval_required' | 'completed' | 'error';
+    event: 'started' | 'progress' | 'artifact' | 'approval_required' | 'completed' | 'error' | 'heartbeat' | 'needs_input' | 'auth_required' | 'cancelled' | 'warning';
     command: string;
     generated_at: string;
+    run_id?: string;
+    seq?: number;
+    event_version?: number;
     status?: AgentStatus;
     phase?: string;
     message?: string;
@@ -90,6 +104,8 @@ export interface AgentEvent {
     artifact?: AgentArtifact;
     result?: AgentEnvelope;
     error?: AgentError;
+    input_request?: AgentInputRequest;
+    auth?: AgentAuthRequest;
 }
 export interface AgentWriteOptions {
     summary?: string | Partial<AgentSummary>;
@@ -109,7 +125,29 @@ export interface CliOutput {
         meta?: Record<string, unknown>;
     } & AgentWriteOptions): void;
     writeEvent(event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at'>): void;
+    writeError(error: unknown): void;
+    writeCancelled(reason?: string): void;
+    hasTerminalOutput(): boolean;
+    close(): void;
 }
+interface OutputRunState {
+    runId: string;
+    seq: number;
+    started: boolean;
+    terminal: boolean;
+    startedAt: number;
+    lastEventAt: number;
+    heartbeat?: NodeJS.Timeout;
+}
+/**
+ * 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 declare function wasOutputCancelled(): boolean;
+export declare function safeWriteStdout(text: string): boolean;
+export declare function safeWriteStderr(text: string): boolean;
 /** Flag-only resolution (default human). Kept for callers that only have flags. */
 export declare function outputModeFromFlags(flags: Record<string, string>): CliOutputMode;
 /**
@@ -127,6 +165,7 @@ export declare function createCliOutput(options: {
     command: string;
     mode: CliOutputMode;
     quiet?: boolean;
+    runId?: string;
 }): CliOutput;
 export declare function createAgentEnvelope(options: {
     command: string;
@@ -135,7 +174,8 @@ export declare function createAgentEnvelope(options: {
     profile?: string;
     meta?: Record<string, unknown>;
 } & AgentWriteOptions): AgentEnvelope;
-export declare function createAgentErrorEnvelope(command: string, error: AgentError): AgentEnvelope;
-export declare function createAgentEvent(command: string, event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at'>): AgentEvent;
+export declare function createAgentErrorEnvelope(command: string, error: AgentError, runId?: string): AgentEnvelope;
+export declare function createAgentEvent(command: string, event: Omit<AgentEvent, 'schema_version' | 'command' | 'generated_at' | 'run_id' | 'seq'>, state?: OutputRunState): AgentEvent;
 export declare function errorToAgentError(error: unknown): AgentError;
+export {};
 //# sourceMappingURL=output.d.ts.map