@orchagent/cli 0.3.86 → 0.3.88

package/dist/commands/diff.js

@@ -0,0 +1,418 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeDiffs = computeDiffs;
+exports.registerDiffCommand = registerDiffCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const agent_ref_1 = require("../lib/agent-ref");
+const spinner_1 = require("../lib/spinner");
+// ── Helpers ────────────────────────────────────────────────────
+function extractDependencies(manifest) {
+    if (!manifest)
+        return [];
+    const deps = manifest.dependencies;
+    if (!Array.isArray(deps))
+        return [];
+    return deps
+        .filter(d => d && typeof d.id === 'string' && typeof d.version === 'string')
+        .map(d => ({ id: d.id, version: d.version }));
+}
+function extractCustomTools(manifest) {
+    if (!manifest)
+        return [];
+    const tools = manifest.custom_tools;
+    if (!Array.isArray(tools))
+        return [];
+    return tools
+        .filter(t => t && typeof t.name === 'string')
+        .map(t => ({ name: t.name, description: t.description, command: t.command }));
+}
+/** Fetch a normalised snapshot for one agent version. */
+async function fetchSnapshot(config, org, agent, version, workspaceId) {
+    // Try public endpoint first
+    try {
+        const pub = await (0, api_1.getPublicAgent)(config, org, agent, version);
+        const raw = pub;
+        const manifest = raw.manifest;
+        return {
+            org,
+            name: pub.name,
+            version: pub.version,
+            type: (pub.type || 'tool'),
+            description: (pub.description ?? undefined),
+            callable: pub.callable ?? false,
+            run_mode: pub.run_mode ?? null,
+            execution_engine: pub.execution_engine ?? null,
+            supported_providers: pub.supported_providers || ['any'],
+            tags: pub.tags || [],
+            input_schema: pub.input_schema,
+            output_schema: pub.output_schema,
+            dependencies: extractDependencies(manifest),
+            default_skills: raw.default_skills || [],
+            custom_tools: extractCustomTools(manifest),
+            required_secrets: raw.required_secrets || [],
+            source_url: raw.source_url,
+            run_command: raw.run_command,
+            default_models: raw.default_models,
+            timeout_seconds: manifest?.timeout_seconds,
+            max_turns: manifest?.max_turns,
+        };
+    }
+    catch (err) {
+        if (!(err instanceof api_1.ApiError) || err.status !== 404)
+            throw err;
+    }
+    // Fallback to authenticated endpoint
+    if (!config.apiKey) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    const userOrg = await (0, api_1.getOrg)(config, workspaceId);
+    if (userOrg.slug !== org) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    const agents = await (0, api_1.listMyAgents)(config, workspaceId);
+    const matching = agents.filter(a => a.name === agent);
+    if (matching.length === 0) {
+        throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+    }
+    let target = matching[0];
+    if (version !== 'latest') {
+        const found = matching.find(a => a.version === version);
+        if (!found)
+            throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
+        target = found;
+    }
+    else {
+        target = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
+    }
+    const manifest = target.manifest;
+    return {
+        org,
+        name: target.name,
+        version: target.version,
+        type: target.type,
+        description: target.description,
+        callable: target.callable ?? false,
+        run_mode: target.run_mode ?? null,
+        execution_engine: target.execution_engine ?? null,
+        supported_providers: target.supported_providers || ['any'],
+        tags: target.tags || [],
+        input_schema: target.input_schema,
+        output_schema: target.output_schema,
+        prompt: target.prompt,
+        dependencies: extractDependencies(manifest),
+        default_skills: target.default_skills || [],
+        custom_tools: extractCustomTools(manifest),
+        required_secrets: target.required_secrets || [],
+        source_url: target.source_url,
+        run_command: target.run_command,
+        default_models: target.default_models,
+        timeout_seconds: manifest?.timeout_seconds,
+        max_turns: manifest?.max_turns,
+    };
+}
+// ── Diffing ────────────────────────────────────────────────────
+function isEqual(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+function isEmpty(val) {
+    if (val === undefined || val === null)
+        return true;
+    if (Array.isArray(val))
+        return val.length === 0;
+    if (typeof val === 'object')
+        return Object.keys(val).length === 0;
+    return false;
+}
+/** Compare two snapshots field-by-field and return a list of diffs. */
+function computeDiffs(a, b) {
+    const diffs = [];
+    // Simple scalar fields
+    const scalars = [
+        { field: 'type', key: 'type' },
+        { field: 'description', key: 'description' },
+        { field: 'callable', key: 'callable' },
+        { field: 'run_mode', key: 'run_mode' },
+        { field: 'execution_engine', key: 'execution_engine' },
+        { field: 'source_url', key: 'source_url' },
+        { field: 'run_command', key: 'run_command' },
+        { field: 'timeout_seconds', key: 'timeout_seconds' },
+        { field: 'max_turns', key: 'max_turns' },
+    ];
+    for (const { field, key } of scalars) {
+        const oldVal = a[key];
+        const newVal = b[key];
+        if (!isEqual(oldVal, newVal)) {
+            if (isEmpty(oldVal) && !isEmpty(newVal)) {
+                diffs.push({ field, kind: 'added', new: newVal });
+            }
+            else if (!isEmpty(oldVal) && isEmpty(newVal)) {
+                diffs.push({ field, kind: 'removed', old: oldVal });
+            }
+            else {
+                diffs.push({ field, kind: 'changed', old: oldVal, new: newVal });
+            }
+        }
+    }
+    // Array fields — show as changed with old/new
+    const arrays = [
+        { field: 'supported_providers', key: 'supported_providers' },
+        { field: 'tags', key: 'tags' },
+        { field: 'default_skills', key: 'default_skills' },
+        { field: 'required_secrets', key: 'required_secrets' },
+    ];
+    for (const { field, key } of arrays) {
+        const oldArr = (a[key] || []);
+        const newArr = (b[key] || []);
+        if (!isEqual(oldArr, newArr)) {
+            if (oldArr.length === 0 && newArr.length > 0) {
+                diffs.push({ field, kind: 'added', new: newArr });
+            }
+            else if (oldArr.length > 0 && newArr.length === 0) {
+                diffs.push({ field, kind: 'removed', old: oldArr });
+            }
+            else {
+                diffs.push({ field, kind: 'changed', old: oldArr, new: newArr });
+            }
+        }
+    }
+    // Object fields — schemas, default_models
+    const objects = [
+        { field: 'input_schema', key: 'input_schema' },
+        { field: 'output_schema', key: 'output_schema' },
+        { field: 'default_models', key: 'default_models' },
+    ];
+    for (const { field, key } of objects) {
+        const oldObj = a[key];
+        const newObj = b[key];
+        if (!isEqual(oldObj, newObj)) {
+            if (isEmpty(oldObj) && !isEmpty(newObj)) {
+                diffs.push({ field, kind: 'added', new: newObj });
+            }
+            else if (!isEmpty(oldObj) && isEmpty(newObj)) {
+                diffs.push({ field, kind: 'removed', old: oldObj });
+            }
+            else {
+                diffs.push({ field, kind: 'changed', old: oldObj, new: newObj });
+            }
+        }
+    }
+    // Structured arrays — dependencies, custom_tools
+    if (!isEqual(a.dependencies, b.dependencies)) {
+        if (a.dependencies.length === 0 && b.dependencies.length > 0) {
+            diffs.push({ field: 'dependencies', kind: 'added', new: b.dependencies });
+        }
+        else if (a.dependencies.length > 0 && b.dependencies.length === 0) {
+            diffs.push({ field: 'dependencies', kind: 'removed', old: a.dependencies });
+        }
+        else {
+            diffs.push({ field: 'dependencies', kind: 'changed', old: a.dependencies, new: b.dependencies });
+        }
+    }
+    if (!isEqual(a.custom_tools, b.custom_tools)) {
+        if (a.custom_tools.length === 0 && b.custom_tools.length > 0) {
+            diffs.push({ field: 'custom_tools', kind: 'added', new: b.custom_tools });
+        }
+        else if (a.custom_tools.length > 0 && b.custom_tools.length === 0) {
+            diffs.push({ field: 'custom_tools', kind: 'removed', old: a.custom_tools });
+        }
+        else {
+            diffs.push({ field: 'custom_tools', kind: 'changed', old: a.custom_tools, new: b.custom_tools });
+        }
+    }
+    // Prompt (may only be available for owned agents)
+    if (a.prompt !== undefined && b.prompt !== undefined && a.prompt !== b.prompt) {
+        diffs.push({ field: 'prompt', kind: 'changed', old: a.prompt, new: b.prompt });
+    }
+    else if (a.prompt === undefined && b.prompt !== undefined) {
+        diffs.push({ field: 'prompt', kind: 'added', new: b.prompt });
+    }
+    else if (a.prompt !== undefined && b.prompt === undefined) {
+        diffs.push({ field: 'prompt', kind: 'removed', old: a.prompt });
+    }
+    return diffs;
+}
+// ── Formatting ─────────────────────────────────────────────────
+function formatValue(val) {
+    if (val === undefined || val === null)
+        return chalk_1.default.gray('(none)');
+    if (typeof val === 'boolean')
+        return val ? chalk_1.default.green('true') : chalk_1.default.red('false');
+    if (typeof val === 'string') {
+        if (val.length > 120)
+            return val.slice(0, 117) + '...';
+        return val;
+    }
+    if (Array.isArray(val)) {
+        if (val.length === 0)
+            return chalk_1.default.gray('[]');
+        // Array of strings
+        if (typeof val[0] === 'string')
+            return val.join(', ');
+        // Array of objects — compact JSON
+        return JSON.stringify(val, null, 2);
+    }
+    if (typeof val === 'object')
+        return JSON.stringify(val, null, 2);
+    return String(val);
+}
+function formatPromptDiff(oldPrompt, newPrompt) {
+    const oldLines = (oldPrompt || '').split('\n');
+    const newLines = (newPrompt || '').split('\n');
+    const lines = [];
+    // Simple line-by-line diff (not LCS — good enough for prompt comparison)
+    const maxLines = Math.max(oldLines.length, newLines.length);
+    const oldSet = new Set(oldLines);
+    const newSet = new Set(newLines);
+    for (const line of oldLines) {
+        if (!newSet.has(line)) {
+            lines.push(chalk_1.default.red(`  - ${line}`));
+        }
+    }
+    for (const line of newLines) {
+        if (!oldSet.has(line)) {
+            lines.push(chalk_1.default.green(`  + ${line}`));
+        }
+    }
+    if (lines.length === 0) {
+        // Lines are the same but order changed
+        lines.push(chalk_1.default.yellow('  (line order changed)'));
+    }
+    // Truncate if very large
+    if (lines.length > 40) {
+        const shown = lines.slice(0, 40);
+        shown.push(chalk_1.default.gray(`  ... and ${lines.length - 40} more lines`));
+        return shown.join('\n');
+    }
+    return lines.join('\n');
+}
+function formatSchemaDiff(field, oldSchema, newSchema) {
+    const lines = [];
+    const oldProps = oldSchema?.properties || {};
+    const newProps = newSchema?.properties || {};
+    const oldRequired = new Set(oldSchema?.required || []);
+    const newRequired = new Set(newSchema?.required || []);
+    const allKeys = new Set([...Object.keys(oldProps), ...Object.keys(newProps)]);
+    for (const key of allKeys) {
+        const inOld = key in oldProps;
+        const inNew = key in newProps;
+        if (!inOld && inNew) {
+            const reqMark = newRequired.has(key) ? '' : '?';
+            lines.push(chalk_1.default.green(`  + ${key}${reqMark}: ${newProps[key].type || 'any'}`));
+        }
+        else if (inOld && !inNew) {
+            const reqMark = oldRequired.has(key) ? '' : '?';
+            lines.push(chalk_1.default.red(`  - ${key}${reqMark}: ${oldProps[key].type || 'any'}`));
+        }
+        else if (inOld && inNew) {
+            const oldType = oldProps[key].type || 'any';
+            const newType = newProps[key].type || 'any';
+            const wasReq = oldRequired.has(key);
+            const isReq = newRequired.has(key);
+            if (oldType !== newType || wasReq !== isReq) {
+                const oldMark = wasReq ? '' : '?';
+                const newMark = isReq ? '' : '?';
+                lines.push(chalk_1.default.red(`  - ${key}${oldMark}: ${oldType}`));
+                lines.push(chalk_1.default.green(`  + ${key}${newMark}: ${newType}`));
+            }
+        }
+    }
+    return lines.join('\n');
+}
+function printDiffs(refA, refB, diffs) {
+    process.stdout.write('\n');
+    process.stdout.write(chalk_1.default.bold(`${refA}  ${chalk_1.default.yellow('→')}  ${refB}`) + '\n');
+    process.stdout.write('='.repeat(50) + '\n\n');
+    if (diffs.length === 0) {
+        process.stdout.write(chalk_1.default.green('No differences found.') + '\n');
+        return;
+    }
+    process.stdout.write(`${chalk_1.default.bold(String(diffs.length))} ${diffs.length === 1 ? 'change' : 'changes'}:\n\n`);
+    for (const diff of diffs) {
+        // Schema fields get special formatting
+        if ((diff.field === 'input_schema' || diff.field === 'output_schema') && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ ${diff.field}:`) + '\n');
+            process.stdout.write(formatSchemaDiff(diff.field, diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // Prompt gets special formatting
+        if (diff.field === 'prompt' && diff.kind === 'changed') {
+            process.stdout.write(chalk_1.default.cyan(`~ prompt:`) + '\n');
+            process.stdout.write(formatPromptDiff(diff.old, diff.new) + '\n\n');
+            continue;
+        }
+        // Standard fields
+        const prefix = diff.kind === 'added' ? chalk_1.default.green('+')
+            : diff.kind === 'removed' ? chalk_1.default.red('-')
+                : chalk_1.default.cyan('~');
+        if (diff.kind === 'added') {
+            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.new)}\n`);
+        }
+        else if (diff.kind === 'removed') {
+            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.old)}\n`);
+        }
+        else {
+            process.stdout.write(`${prefix} ${chalk_1.default.bold(diff.field)}: ${formatValue(diff.old)} ${chalk_1.default.yellow('→')} ${formatValue(diff.new)}\n`);
+        }
+    }
+}
+// ── Ref parsing ────────────────────────────────────────────────
+/**
+ * Parse second ref which can be:
+ * - Full ref: "org/agent@version"
+ * - Version-only shorthand: "v2" (inherits org/agent from first ref)
+ */
+function parseSecondRef(value, firstOrg, firstName) {
+    // If it contains '/', treat as full ref
+    if (value.includes('/')) {
+        return (0, agent_ref_1.parseAgentRef)(value);
+    }
+    // Otherwise treat as a version shorthand for the same agent
+    return { org: firstOrg, agent: firstName, version: value };
+}
+// ── Command ────────────────────────────────────────────────────
+function registerDiffCommand(program) {
+    program
+        .command('diff <ref1> [ref2]')
+        .description('Compare two versions of an agent')
+        .option('--json', 'Output as JSON')
+        .action(async (ref1Arg, ref2Arg, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const ref1 = (0, agent_ref_1.parseAgentRef)(ref1Arg);
+        let ref2;
+        if (ref2Arg) {
+            ref2 = parseSecondRef(ref2Arg, ref1.org, ref1.agent);
+        }
+        else {
+            // No second ref — compare ref1 against latest
+            if (ref1.version === 'latest') {
+                throw new api_1.ApiError('Two versions are required. Use: orch diff org/agent@v1 v2', 400);
+            }
+            ref2 = { org: ref1.org, agent: ref1.agent, version: 'latest' };
+        }
+        // Resolve workspace
+        const workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, ref1.org);
+        // Fetch both versions in parallel
+        const [snapA, snapB] = await (0, spinner_1.withSpinner)('Fetching agent versions', () => Promise.all([
+            fetchSnapshot(config, ref1.org, ref1.agent, ref1.version, workspaceId),
+            fetchSnapshot(config, ref2.org, ref2.agent, ref2.version, ref2.org === ref1.org ? workspaceId : undefined),
+        ]), { successText: 'Fetched both versions' });
+        const refALabel = `${snapA.org}/${snapA.name}@${snapA.version}`;
+        const refBLabel = `${snapB.org}/${snapB.name}@${snapB.version}`;
+        const diffs = computeDiffs(snapA, snapB);
+        if (options.json) {
+            process.stdout.write(JSON.stringify({
+                from: refALabel,
+                to: refBLabel,
+                identical: diffs.length === 0,
+                changes: diffs,
+            }, null, 2) + '\n');
+            return;
+        }
+        printDiffs(refALabel, refBLabel, diffs);
+    });
+}

package/dist/commands/estimate.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerEstimateCommand = registerEstimateCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const agent_ref_1 = require("../lib/agent-ref");
+const output_1 = require("../lib/output");
+function formatUsd(amount) {
+    if (amount < 0.001)
+        return '<$0.001';
+    if (amount < 0.01)
+        return `$${amount.toFixed(4)}`;
+    if (amount < 1)
+        return `$${amount.toFixed(3)}`;
+    return `$${amount.toFixed(2)}`;
+}
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${Math.round(ms)}ms`;
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+function formatTokens(count) {
+    if (count < 1000)
+        return `${Math.round(count)}`;
+    return `${(count / 1000).toFixed(1)}k`;
+}
+function registerEstimateCommand(program) {
+    program
+        .command('estimate <agent>')
+        .description('Show estimated cost for running an agent')
+        .option('--json', 'Output as JSON')
+        .action(async (agentArg, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentArg);
+        if (!org) {
+            process.stderr.write(chalk_1.default.red('Error: org/agent format required (e.g. myorg/my-agent)\n'));
+            process.exit(1);
+        }
+        let data;
+        try {
+            data = await (0, api_1.getAgentCostEstimate)(config, org, agent, version);
+        }
+        catch (err) {
+            if (err instanceof api_1.ApiError && err.status === 404) {
+                process.stderr.write(chalk_1.default.red(`Agent '${org}/${agent}@${version}' not found\n`));
+                process.exit(1);
+            }
+            throw err;
+        }
+        if (options.json) {
+            (0, output_1.printJson)(data);
+            return;
+        }
+        const est = data.estimate;
+        process.stdout.write('\n');
+        process.stdout.write(`${chalk_1.default.bold(data.agent)}\n`);
+        process.stdout.write('='.repeat(40) + '\n\n');
+        process.stdout.write(`Type: ${data.type}\n`);
+        if (data.execution_engine) {
+            process.stdout.write(`Engine: ${data.execution_engine}\n`);
+        }
+        process.stdout.write(`Providers: ${data.supported_providers.join(', ')}\n`);
+        if (est.sample_size === 0) {
+            process.stdout.write('\n' + chalk_1.default.yellow('No run history available for cost estimation.\n'));
+            process.stdout.write(chalk_1.default.gray('Run the agent once and re-check for estimates.\n'));
+            return;
+        }
+        process.stdout.write(`\n${chalk_1.default.bold('Cost Estimate')} ${chalk_1.default.gray(`(${est.sample_size} runs, last ${est.period_days}d)`)}\n`);
+        process.stdout.write('-'.repeat(40) + '\n');
+        // Main cost stats
+        process.stdout.write(`  Average:   ${chalk_1.default.green(formatUsd(est.avg_cost_usd))}\n`);
+        process.stdout.write(`  Median:    ${chalk_1.default.green(formatUsd(est.p50_cost_usd))}\n`);
+        process.stdout.write(`  95th pct:  ${chalk_1.default.yellow(formatUsd(est.p95_cost_usd))}\n`);
+        // Token averages
+        if (est.avg_input_tokens || est.avg_output_tokens) {
+            process.stdout.write(`\n${chalk_1.default.bold('Tokens (avg per run)')}\n`);
+            process.stdout.write(`  Input:  ${formatTokens(est.avg_input_tokens)}\n`);
+            process.stdout.write(`  Output: ${formatTokens(est.avg_output_tokens)}\n`);
+        }
+        // Duration
+        if (est.avg_duration_ms) {
+            process.stdout.write(`\n${chalk_1.default.bold('Duration')}\n`);
+            process.stdout.write(`  Average: ${formatDuration(est.avg_duration_ms)}\n`);
+        }
+        // Success rate
+        if (est.success_rate !== undefined) {
+            const rateColor = est.success_rate >= 95 ? chalk_1.default.green : est.success_rate >= 80 ? chalk_1.default.yellow : chalk_1.default.red;
+            process.stdout.write(`  Success: ${rateColor(est.success_rate + '%')}\n`);
+        }
+        // Provider breakdown
+        if (est.provider_breakdown && est.provider_breakdown.length > 0) {
+            process.stdout.write(`\n${chalk_1.default.bold('By Provider')}\n`);
+            for (const p of est.provider_breakdown) {
+                const model = p.model !== 'unknown' ? ` (${p.model})` : '';
+                process.stdout.write(`  ${chalk_1.default.cyan(p.provider)}${chalk_1.default.gray(model)}: ` +
+                    `${formatUsd(p.avg_cost_usd)} avg · ${p.runs} runs\n`);
+            }
+        }
+        process.stdout.write('\n');
+    });
+}

package/dist/commands/fork.js

@@ -11,6 +11,7 @@ const agent_ref_1 = require("../lib/agent-ref");
 const errors_1 = require("../lib/errors");
 const analytics_1 = require("../lib/analytics");
 const output_1 = require("../lib/output");
+const key_store_1 = require("../lib/key-store");
 function getWorkspaceAuthError(err) {
     if (!(err instanceof api_1.ApiError) || (err.status !== 401 && err.status !== 403)) {
         return null;
@@ -101,8 +102,17 @@ Examples:
             write(`  Workspace: ${targetWorkspace.name} (${targetWorkspace.slug})\n`);
         }
         if (result.service_key) {
-            write(`\nService key (save this - shown only once):\n`);
+            write(`\nService key:\n`);
             write(`  ${result.service_key}\n`);
+            try {
+                const keyPrefix = result.service_key.substring(0, 12);
+                const savedPath = await (0, key_store_1.saveServiceKey)(targetOrgSlug, forked.name, forked.version, result.service_key, keyPrefix);
+                write(`  ${chalk_1.default.gray(`Saved to ${savedPath}`)}\n`);
+            }
+            catch {
+                write(`  ${chalk_1.default.yellow('Could not save key locally. Copy it now — it cannot be retrieved from the server.')}\n`);
+            }
+            write(`  Retrieve later: ${chalk_1.default.cyan(`orch agent-keys list ${targetOrgSlug}/${forked.name}`)}\n`);
         }
     });
 }