@moda-ai/cli 1.22.1 → 1.22.2

package/dist/keys.js

@@ -1,136 +0,0 @@
-import { createHash } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { assertValidProfileName, getModaPaths, secretFilePathFromRef, writeSecretJsonFile, } from './profiles.js';
-export const KEY_LIFECYCLE_ENDPOINT_REQUIREMENTS = {
-    list: 'GET /api/cli/keys?profile=<profile>',
-    create: 'POST /api/cli/keys',
-    rotate: 'POST /api/cli/keys/<key_id>/rotate',
-    revoke: 'POST /api/cli/keys/<key_id>/revoke',
-};
-export function keySecretRef(profile, keyId) {
-    assertValidProfileName(profile);
-    assertSafeKeyId(keyId);
-    return `file:secrets/api-keys/${profile}/${keyId}.json`;
-}
-export function createLocalKeyDescriptor(input) {
-    assertValidProfileName(input.profile);
-    const now = input.now ?? new Date();
-    const id = stableKeyId(input.profile, input.name, now);
-    return {
-        id,
-        profile: input.profile,
-        name: input.name,
-        purpose: input.purpose ?? 'data_api',
-        environment: input.environment,
-        tenant_id: input.tenant_id,
-        workspace_id: input.workspace_id,
-        secret_ref: input.secret_ref ?? keySecretRef(input.profile, id),
-        status: 'active',
-        created_at: now.toISOString(),
-    };
-}
-export function validateKeyDescriptor(descriptor) {
-    assertValidProfileName(descriptor.profile);
-    assertSafeKeyId(descriptor.id);
-    if (!descriptor.name.trim()) {
-        throw new Error('Key name is required.');
-    }
-    if (descriptor.status !== 'active' &&
-        descriptor.status !== 'rotating' &&
-        descriptor.status !== 'revoked') {
-        throw new Error(`Invalid key status '${descriptor.status}'.`);
-    }
-    if (descriptor.purpose !== 'data_api' &&
-        descriptor.purpose !== 'ingest' &&
-        descriptor.purpose !== 'automation') {
-        throw new Error(`Invalid key purpose '${descriptor.purpose}'.`);
-    }
-    if (descriptor.environment !== 'local' &&
-        descriptor.environment !== 'dev' &&
-        descriptor.environment !== 'staging' &&
-        descriptor.environment !== 'prod') {
-        throw new Error(`Invalid key environment '${descriptor.environment}'.`);
-    }
-    if (!descriptor.secret_ref.startsWith('file:')) {
-        throw new Error('Local key descriptors must point to a file: secret ref.');
-    }
-}
-export function writeLocalApiKeySecret(descriptor, apiKey, options = {}) {
-    validateKeyDescriptor(descriptor);
-    if (!apiKey.trim()) {
-        throw new Error('API key value is required.');
-    }
-    const path = secretFilePathFromRef(descriptor.secret_ref, options);
-    if (!path) {
-        throw new Error(`Unsupported key secret reference: ${descriptor.secret_ref}`);
-    }
-    writeSecretJsonFile(path, {
-        value: apiKey,
-        key_id: descriptor.id,
-        profile: descriptor.profile,
-        purpose: descriptor.purpose,
-        created_at: descriptor.created_at,
-    });
-    return path;
-}
-export function keyDescriptorStorePath(options = {}) {
-    return join(getModaPaths(options).dir, 'keys.json');
-}
-export function loadLocalKeyDescriptors(options = {}) {
-    const path = keyDescriptorStorePath(options);
-    try {
-        if (!existsSync(path))
-            return [];
-        const parsed = JSON.parse(readFileSync(path, 'utf8'));
-        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-            return [];
-        }
-        const keys = parsed.keys;
-        if (!Array.isArray(keys))
-            return [];
-        return keys.filter((key) => {
-            try {
-                validateKeyDescriptor(key);
-                return true;
-            }
-            catch {
-                return false;
-            }
-        });
-    }
-    catch {
-        return [];
-    }
-}
-export function saveLocalKeyDescriptors(keys, options = {}) {
-    for (const key of keys)
-        validateKeyDescriptor(key);
-    writeSecretJsonFile(keyDescriptorStorePath(options), {
-        version: 1,
-        keys,
-    });
-}
-export function upsertLocalKeyDescriptor(descriptor, options = {}) {
-    validateKeyDescriptor(descriptor);
-    const keys = loadLocalKeyDescriptors(options);
-    const next = [
-        ...keys.filter((key) => key.id !== descriptor.id),
-        descriptor,
-    ].sort((a, b) => a.created_at.localeCompare(b.created_at));
-    saveLocalKeyDescriptors(next, options);
-    return next;
-}
-function stableKeyId(profile, name, now) {
-    const hash = createHash('sha256')
-        .update(`${profile}\0${name}\0${now.toISOString()}`)
-        .digest('hex')
-        .slice(0, 12);
-    return `key_${hash}`;
-}
-function assertSafeKeyId(keyId) {
-    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(keyId)) {
-        throw new Error(`Invalid key id '${keyId}'. Use letters, numbers, dots, dashes, or underscores.`);
-    }
-}
-//# sourceMappingURL=keys.js.map

package/dist/manifest.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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_AUTH_TIMEOUT_MS',
-            'MODA_HEARTBEAT_MS',
-            'MODA_AGENT_MAX_OUTPUT_BYTES',
-            'MODA_CLI_TELEMETRY',
-            'MODA_CLI_UPDATE_CHECK',
-            'MODA_CLI_TIPS',
-        ],
-        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: 'remote analyze run', meaning: 'A Moda-hosted harness analysis tracked in .moda/harness-remote-run.json; fetch its status or result with `moda harness pull`.' },
-            { 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/markdown-terminal.d.ts

@@ -1,49 +0,0 @@
-export interface MarkdownTerminalOptions {
-    /** When false, all structural fixes still apply but zero ANSI codes are emitted. */
-    color: boolean;
-}
-/** Minimal ANSI styling helpers shared by the renderer and ask chrome. */
-export interface TerminalStyles {
-    bold(text: string): string;
-    italic(text: string): string;
-    dim(text: string): string;
-    code(text: string): string;
-    /** Section heading: bold + underline. */
-    heading(text: string): string;
-}
-/**
- * The CLI's color convention (mirrors `src/tui.ts` / `src/analyst-tui.ts`):
- * color only for a human at a TTY, honoring `NO_COLOR` (present with ANY value,
- * including the empty string, disables — per the no-color.org spec) and
- * `TERM=dumb`.
- */
-export declare function shouldColorTerminalOutput(opts?: {
-    isTTY?: boolean;
-    env?: NodeJS.ProcessEnv;
-}): boolean;
-/**
- * ANSI style constructors. Closers restore the specific attribute (22/23/39)
- * rather than a full reset so nested styles (code inside bold, bold inside a
- * heading) survive. When `color` is false every helper is the identity.
- */
-export declare function terminalStyles(color: boolean): TerminalStyles;
-/** Remove ANSI/OSC control sequences from untrusted content. */
-export declare function stripAnsi(text: string): string;
-/**
- * Render an agent markdown answer for direct terminal display.
- *
- * - Headers lose their `#` sigils; h1/h2 render bold+underlined, h3+ bold,
- *   with a blank line before.
- * - `**bold**`, `*italic*`/`_italic_`, and backtick `code` spans lose their
- *   sigils and gain ANSI styling (bold / italic / cyan) when `color` is on.
- * - List items are re-indented to consistent 2-space-per-level steps based on
- *   their original RELATIVE nesting (odd indents round to the nearest level; a
- *   top-level-looking item after deeper items stays top-level). Bullets render
- *   `•` at level 0 and `-` deeper; ordered items keep their numbers.
- * - `|` table rows and fenced code blocks pass through untouched (only ANSI
- *   control sequences are stripped, since that content is backend-controlled).
- * - Runs of 3+ blank lines collapse to a single blank line.
- * - Prose is never reflowed or wrapped.
- */
-export declare function renderMarkdownForTerminal(markdown: string, opts: MarkdownTerminalOptions): string;
-//# sourceMappingURL=markdown-terminal.d.ts.map

package/dist/markdown-terminal.js

@@ -1,212 +0,0 @@
-// src/markdown-terminal.ts
-//
-// Pure markdown -> terminal renderer for human-mode output (`moda ask`).
-// The cloud agent answers in markdown; printing it raw leaves literal `##`
-// header sigils, `**bold**` asterisks, and the model's erratic list
-// indentation on screen. This module strips the sigils, applies ANSI styling
-// when the terminal supports it, and normalizes list nesting to consistent
-// 2-space steps — WITHOUT reflowing prose (terminals wrap themselves) and
-// WITHOUT touching `|` tables or fenced code blocks.
-//
-// No dependencies: raw ANSI escape constants only (the CLI has no color lib).
-/**
- * The CLI's color convention (mirrors `src/tui.ts` / `src/analyst-tui.ts`):
- * color only for a human at a TTY, honoring `NO_COLOR` (present with ANY value,
- * including the empty string, disables — per the no-color.org spec) and
- * `TERM=dumb`.
- */
-export function shouldColorTerminalOutput(opts = {}) {
-    const env = opts.env ?? process.env;
-    const isTTY = opts.isTTY ?? process.stdout.isTTY === true;
-    if (!isTTY)
-        return false;
-    if (env.NO_COLOR !== undefined)
-        return false;
-    if (env.TERM === 'dumb')
-        return false;
-    return true;
-}
-/**
- * ANSI style constructors. Closers restore the specific attribute (22/23/39)
- * rather than a full reset so nested styles (code inside bold, bold inside a
- * heading) survive. When `color` is false every helper is the identity.
- */
-export function terminalStyles(color) {
-    const paint = (open, close) => (text) => color ? `\u001b[${open}m${text}\u001b[${close}m` : text;
-    return {
-        bold: paint('1', '22'),
-        italic: paint('3', '23'),
-        dim: paint('2', '22'),
-        code: paint('36', '39'),
-        heading: paint('1;4', '22;24'),
-    };
-}
-const FENCE_RE = /^\s*(`{3,}|~{3,})/;
-const FENCE_CLOSE_RE = /^\s*(`{3,}|~{3,})\s*$/;
-const TABLE_ROW_RE = /^\s*\|.*\S/;
-// Matches ANSI/OSC control sequences: CSI (ESC [ … final byte), OSC (ESC ] …
-// BEL or ST), and other two-byte escapes. Backend-controlled content (table
-// cells, code-fence bodies, streamed tool names/titles) is passed through
-// verbatim, so any escape sequences an LLM or a compromised backend emits must
-// be stripped before they reach the terminal — otherwise they could clear the
-// screen, spoof UI, or trigger OSC side-effects in some emulators.
-const ANSI_RE = /\u001b(?:\[[0-9;?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)|[@-Z\\-_])/g;
-/** Remove ANSI/OSC control sequences from untrusted content. */
-export function stripAnsi(text) {
-    return text.replace(ANSI_RE, '');
-}
-/**
- * A fenced code block's opening marker: the fence character (`` ` `` or `~`)
- * and its length. CommonMark closes a fence only with the same character and at
- * least as many markers, so tracking these prevents a `~~~` line from closing a
- * ` ``` ` block (and a 3-backtick line from closing a 4-backtick opener).
- */
-function parseFenceOpen(line) {
-    const match = FENCE_RE.exec(line);
-    if (!match)
-        return null;
-    return { char: match[1][0], len: match[1].length };
-}
-/** Whether `line` closes an open fence per the CommonMark same-char/length rule. */
-function isFenceClose(line, fence) {
-    const match = FENCE_CLOSE_RE.exec(line);
-    return match !== null && match[1][0] === fence.char && match[1].length >= fence.len;
-}
-const HEADER_RE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
-const BULLET_RE = /^(\s*)([-*+])\s+(.*)$/;
-const ORDERED_RE = /^(\s*)(\d+)[.)]\s+(.*)$/;
-/**
- * Render an agent markdown answer for direct terminal display.
- *
- * - Headers lose their `#` sigils; h1/h2 render bold+underlined, h3+ bold,
- *   with a blank line before.
- * - `**bold**`, `*italic*`/`_italic_`, and backtick `code` spans lose their
- *   sigils and gain ANSI styling (bold / italic / cyan) when `color` is on.
- * - List items are re-indented to consistent 2-space-per-level steps based on
- *   their original RELATIVE nesting (odd indents round to the nearest level; a
- *   top-level-looking item after deeper items stays top-level). Bullets render
- *   `•` at level 0 and `-` deeper; ordered items keep their numbers.
- * - `|` table rows and fenced code blocks pass through untouched (only ANSI
- *   control sequences are stripped, since that content is backend-controlled).
- * - Runs of 3+ blank lines collapse to a single blank line.
- * - Prose is never reflowed or wrapped.
- */
-export function renderMarkdownForTerminal(markdown, opts) {
-    const style = terminalStyles(opts.color);
-    const out = [];
-    // Original indent width backing each active list level; index == level.
-    const listStack = [];
-    // The open fence's char + length, or null outside a fenced code block.
-    let fence = null;
-    for (const raw of markdown.replace(/\r\n/g, '\n').split('\n')) {
-        if (fence) {
-            out.push(stripAnsi(raw));
-            if (isFenceClose(raw, fence))
-                fence = null;
-            continue;
-        }
-        const opened = parseFenceOpen(raw);
-        if (opened) {
-            fence = opened;
-            listStack.length = 0;
-            out.push(stripAnsi(raw));
-            continue;
-        }
-        if (TABLE_ROW_RE.test(raw)) {
-            // Tables depend on exact column spacing — pass through monospaced.
-            out.push(stripAnsi(raw));
-            continue;
-        }
-        const line = raw.replace(/\s+$/, '');
-        if (line === '') {
-            out.push('');
-            continue;
-        }
-        const header = HEADER_RE.exec(line);
-        if (header) {
-            listStack.length = 0;
-            // Strip inline sigils inside the header text (plain), then style the
-            // whole line so nested `**bold**` can't fight the heading attributes.
-            const text = renderInline(header[2], terminalStyles(false));
-            if (out.length > 0 && out[out.length - 1] !== '')
-                out.push('');
-            out.push(header[1].length <= 2 ? style.heading(text) : style.bold(text));
-            continue;
-        }
-        const bullet = BULLET_RE.exec(line);
-        const ordered = bullet ? null : ORDERED_RE.exec(line);
-        if (bullet || ordered) {
-            const match = (bullet ?? ordered);
-            const level = resolveListLevel(match[1].length, listStack);
-            const indent = '  '.repeat(level);
-            const text = renderInline(match[3], style);
-            if (bullet) {
-                out.push(`${indent}${level === 0 ? '•' : '-'} ${text}`);
-            }
-            else {
-                out.push(`${indent}${match[2]}. ${text}`);
-            }
-            continue;
-        }
-        // Unindented prose ends any open list; indented non-list lines are treated
-        // as continuations and keep the current nesting context.
-        if (!/^\s{2,}/.test(line))
-            listStack.length = 0;
-        out.push(renderInline(line, style));
-    }
-    return collapseBlankRuns(out).join('\n');
-}
-/**
- * Map an item's original indent width onto a consistent nesting level.
- * `stack[level]` remembers the original indent that opened that level:
- * meaningfully shallower indents pop back out, meaningfully deeper indents
- * open a new level, and anything within +/-1 space sticks to the current
- * level (rounding the model's odd 3/5/7-space indents to the nearest level).
- */
-function resolveListLevel(indent, stack) {
-    while (stack.length > 0 && indent < stack[stack.length - 1] - 1)
-        stack.pop();
-    if (stack.length === 0 || indent > stack[stack.length - 1] + 1)
-        stack.push(indent);
-    return stack.length - 1;
-}
-/**
- * Strip/style inline markdown sigils: `code` spans first (protected via
- * placeholders so asterisks/underscores inside them are never re-parsed),
- * then `**bold**`/`__bold__`, then word-boundary `*italic*`/`_italic_`
- * (mid-word underscores as in `silent_empty_result` never match).
- */
-function renderInline(text, style) {
-    const codeSpans = [];
-    // Strip any ANSI escapes already in the (backend-controlled) text BEFORE we
-    // add our own styling, so this only removes injected sequences — never the
-    // codes the style helpers emit below.
-    let result = stripAnsi(text).replace(/`([^`]+)`/g, (_, code) => {
-        codeSpans.push(code);
-        return `\u0000${codeSpans.length - 1}\u0000`;
-    });
-    result = result.replace(/\*\*([^\s*](?:[^*]*[^\s*])?)\*\*/g, (_, inner) => style.bold(inner));
-    result = result.replace(/__([^\s_](?:[^_]*[^\s_])?)__/g, (_, inner) => style.bold(inner));
-    result = result.replace(/(?<![\w*])\*([^\s*](?:[^*\n]*[^\s*])?)\*(?![\w*])/g, (_, inner) => style.italic(inner));
-    result = result.replace(/(?<![\w_])_([^\s_](?:[^_\n]*[^\s_])?)_(?![\w_])/g, (_, inner) => style.italic(inner));
-    return result.replace(/\u0000(\d+)\u0000/g, (_, index) => style.code(codeSpans[Number(index)]));
-}
-/** Collapse runs of 3+ blank lines down to a single blank line. */
-function collapseBlankRuns(lines) {
-    const collapsed = [];
-    let blanks = 0;
-    for (const line of lines) {
-        if (line === '') {
-            blanks += 1;
-            continue;
-        }
-        if (blanks > 0)
-            collapsed.push('', ...(blanks === 2 ? [''] : []));
-        blanks = 0;
-        collapsed.push(line);
-    }
-    if (blanks > 0)
-        collapsed.push('', ...(blanks === 2 ? [''] : []));
-    return collapsed;
-}
-//# sourceMappingURL=markdown-terminal.js.map