@orchagent/cli 0.3.91 → 0.3.92

package/dist/commands/run.js

@@ -37,6 +37,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.localCommandForEntrypoint = localCommandForEntrypoint;
+exports.inferFileField = inferFileField;
 exports.validateInputSchema = validateInputSchema;
 exports.tryParseJsonObject = tryParseJsonObject;
 exports.isKeyedFileArg = isKeyedFileArg;
@@ -156,6 +157,13 @@ function warnIfLocalPathReference(jsonBody) {
         // If parsing fails, skip the warning
     }
 }
+/**
+ * Infer which schema field should receive file content.
+ *
+ * Returns the detected field name, or null when the schema has properties
+ * but none of the heuristics can determine the right field.
+ * Returns 'content' (default) only when there is no schema to check against.
+ */
 function inferFileField(inputSchema) {
     if (!inputSchema || typeof inputSchema !== 'object')
         return 'content';
@@ -163,6 +171,7 @@ function inferFileField(inputSchema) {
     if (!props || typeof props !== 'object')
         return 'content';
     const properties = props;
+    // 1. Check well-known content field names
     for (const field of CONTENT_FIELD_NAMES) {
         if (properties[field] && properties[field].type === 'string')
             return field;
@@ -171,12 +180,41 @@ function inferFileField(inputSchema) {
     const stringProps = Object.entries(properties)
         .filter(([, v]) => v.type === 'string')
         .map(([k]) => k);
+    // 2. Only one string property in the schema — use it
     if (stringProps.length === 1)
         return stringProps[0];
+    // 3. Only one required string property — use it
     const requiredStrings = stringProps.filter(k => required.includes(k));
     if (requiredStrings.length === 1)
         return requiredStrings[0];
-    return 'content';
+    // 4. Schema exists but detection is ambiguous — return null so callers
+    //    can surface a clear error instead of silently using the wrong field
+    return null;
+}
+/**
+ * Resolve the file field name, throwing a clear error when auto-detection fails.
+ * Used at call sites where a file is being injected into a JSON payload.
+ */
+function resolveFileField(fileFieldOption, inputSchema) {
+    if (fileFieldOption)
+        return fileFieldOption;
+    const detected = inferFileField(inputSchema);
+    if (detected !== null)
+        return detected;
+    // Detection failed — build a helpful error message
+    const props = inputSchema?.properties;
+    const stringFields = props
+        ? Object.entries(props).filter(([, v]) => v.type === 'string').map(([k]) => k)
+        : [];
+    const fieldList = stringFields.length > 0
+        ? `String fields in schema: ${stringFields.map(f => `"${f}"`).join(', ')}`
+        : 'No string fields found in schema';
+    throw new errors_1.CliError(`Could not determine which input field to use for file content.\n\n` +
+        `${fieldList}\n\n` +
+        `Specify the field explicitly:\n` +
+        `  orch run <agent> --file-field <field> input.json\n` +
+        `  orch run <agent> --data @input.json\n` +
+        `  orch run <agent> --file <field>=input.json`);
 }
 function applySchemaDefaults(body, schema) {
     if (!schema)
@@ -2037,7 +2075,7 @@ async function executeCloud(agentRef, file, options) {
             const resolvedBody = await resolveJsonBody(options.data);
             const bodyObj = JSON.parse(resolvedBody);
             if (cloudEngine !== 'code_runtime') {
-                const fieldName = options.fileField || inferFileField(agentMeta.input_schema);
+                const fieldName = resolveFileField(options.fileField, agentMeta.input_schema);
                 if (filePaths.length === 1) {
                     await validateFilePath(filePaths[0]);
                     bodyObj[fieldName] = await promises_1.default.readFile(filePaths[0], 'utf-8');
@@ -2093,7 +2131,7 @@ async function executeCloud(agentRef, file, options) {
             headers['Content-Type'] = 'application/json';
         }
         else if ((filePaths.length > 0 || options.metadata) && cloudEngine !== 'code_runtime') {
-            const fieldName = options.fileField || inferFileField(agentMeta.input_schema);
+            const fieldName = resolveFileField(options.fileField, agentMeta.input_schema);
             let bodyObj = {};
             if (options.metadata) {
                 try {
@@ -2204,8 +2242,11 @@ async function executeCloud(agentRef, file, options) {
         ? { spinner: null, dispose: () => { } }
         : (0, spinner_1.createElapsedSpinner)(`Running ${org}/${parsed.agent}@${parsed.version}...`);
     spinner?.start();
-    // Streamed sandbox runs can take longer; use 10 min timeout.
-    const timeoutMs = wantStream ? 600000 : undefined;
+    // Streamed sandbox runs can take longer; use 10 min timeout (or --wait-timeout).
+    const waitTimeoutSec = options.waitTimeout ? parseInt(options.waitTimeout, 10) : undefined;
+    const timeoutMs = wantStream
+        ? (waitTimeoutSec && waitTimeoutSec > 0 ? waitTimeoutSec * 1000 : 600000)
+        : undefined;
     let response;
     try {
         response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
@@ -2375,38 +2416,74 @@ async function executeCloud(agentRef, file, options) {
             process.stderr.write(chalk_1.default.gray(`\nStreaming ${org}/${parsed.agent}@${parsed.version}:\n`));
         }
         let progressErrorShown = false;
-        for await (const { event, data } of parseSSE(response.body)) {
-            if (event === 'progress') {
-                try {
-                    const parsed = JSON.parse(data);
-                    renderProgress(parsed, !!options.verbose);
-                    if (parsed.type === 'error') {
-                        progressErrorShown = true;
+        let streamTimedOut = false;
+        try {
+            for await (const { event, data } of parseSSE(response.body)) {
+                if (event === 'progress') {
+                    try {
+                        const parsed = JSON.parse(data);
+                        renderProgress(parsed, !!options.verbose);
+                        if (parsed.type === 'error') {
+                            progressErrorShown = true;
+                        }
+                    }
+                    catch {
+                        // ignore malformed progress events
                     }
                 }
-                catch {
-                    // ignore malformed progress events
-                }
-            }
-            else if (event === 'result') {
-                try {
-                    finalPayload = JSON.parse(data);
+                else if (event === 'result') {
+                    try {
+                        finalPayload = JSON.parse(data);
+                    }
+                    catch {
+                        finalPayload = data;
+                    }
                 }
-                catch {
-                    finalPayload = data;
+                else if (event === 'error') {
+                    hadError = true;
+                    try {
+                        finalPayload = JSON.parse(data);
+                    }
+                    catch {
+                        finalPayload = data;
+                    }
                 }
             }
-            else if (event === 'error') {
-                hadError = true;
-                try {
-                    finalPayload = JSON.parse(data);
-                }
-                catch {
-                    finalPayload = data;
-                }
+        }
+        catch (streamErr) {
+            // BUG-6: Detect timeout/abort errors — the server-side job may still be running.
+            const errName = streamErr instanceof DOMException ? streamErr.name
+                : streamErr instanceof Error ? streamErr.name
+                    : '';
+            if (errName === 'TimeoutError' || errName === 'AbortError') {
+                streamTimedOut = true;
+            }
+            else {
+                throw streamErr;
             }
         }
         process.stderr.write('\n');
+        // BUG-6: When the stream timed out, the run is likely still in progress on server.
+        if (streamTimedOut) {
+            const runId = response.headers?.get?.('x-run-id');
+            process.stderr.write(chalk_1.default.yellow('\nRun still in progress on server — the CLI stopped waiting.\n') +
+                (runId
+                    ? chalk_1.default.yellow(`Check status with: orch logs ${runId}\n`)
+                    : chalk_1.default.yellow('Check recent runs with: orch runs\n')) +
+                (options.waitTimeout
+                    ? ''
+                    : chalk_1.default.gray('Tip: Use --wait-timeout <seconds> to wait longer.\n')));
+            await (0, analytics_1.track)('cli_run', {
+                agent: `${org}/${parsed.agent}@${parsed.version}`,
+                input_type: hasInjection ? 'file_injection' : unkeyedFileArgs.length > 0 ? 'file' : options.data ? 'json' : 'empty',
+                mode: 'cloud',
+                streamed: true,
+                timed_out: true,
+            });
+            const err = new errors_1.CliError('CLI wait timeout — run still in progress on server', errors_1.ExitCodes.TIMEOUT);
+            err.displayed = true;
+            throw err;
+        }
         await (0, analytics_1.track)('cli_run', {
             agent: `${org}/${parsed.agent}@${parsed.version}`,
             input_type: hasInjection ? 'file_injection' : unkeyedFileArgs.length > 0 ? 'file' : options.data ? 'json' : 'empty',
@@ -2794,6 +2871,7 @@ function registerRunCommand(program) {
         .option('--skills-only <skills>', 'Use only these skills')
         .option('--no-skills', 'Ignore default skills')
         .option('--no-stream', 'Disable real-time streaming for stream-capable sandbox runs')
+        .option('--wait-timeout <seconds>', 'Max seconds to wait for streaming result (default: 600)')
         // Cloud-only options
         .option('--endpoint <endpoint>', 'Override agent endpoint (cloud only)')
         .option('--tenant <tenant>', 'Tenant identifier for multi-tenant callers (cloud only)')

package/dist/commands/scaffold.js

@@ -0,0 +1,213 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerScaffoldCommand = registerScaffoldCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+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 scaffold_orchestration_1 = require("../lib/scaffold-orchestration");
+async function fileExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function asCanonicalType(value) {
+    const normalized = String(value || 'agent').trim().toLowerCase();
+    if (normalized === 'agentic')
+        return 'agent';
+    if (normalized === 'code')
+        return 'tool';
+    return normalized;
+}
+function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    return value;
+}
+function formatDependencyNotFound(org, agent, version) {
+    return `Dependency agent not found: ${org}/${agent}@${version}`;
+}
+function throwDependencyResolutionError(err, org, agent, version) {
+    if (err instanceof api_1.ApiError) {
+        if (err.status === 404) {
+            throw new errors_1.CliError(formatDependencyNotFound(org, agent, version));
+        }
+        if (err.status === 401) {
+            throw new errors_1.CliError(`Authentication required to resolve ${org}/${agent}@${version}. Run \`orch login\` first.`);
+        }
+        throw new errors_1.CliError(`Failed to resolve ${org}/${agent}@${version}: ${err.message} (HTTP ${err.status})`);
+    }
+    throw err;
+}
+function assertDependencyIsCallable(agent, org, name, version) {
+    const canonicalType = asCanonicalType(agent.type);
+    if (canonicalType === 'skill') {
+        throw new errors_1.CliError(`Dependency ${org}/${name}@${version} is a skill. Skills are not callable agents.`);
+    }
+    if (agent.callable === false) {
+        throw new errors_1.CliError(`Dependency ${org}/${name}@${version} has callable: false and cannot be used for orchestration.`);
+    }
+}
+async function resolveDependencies(config, rawRefs) {
+    const workspaceByOrg = new Map();
+    const workspaceForOrg = async (org) => {
+        if (!workspaceByOrg.has(org)) {
+            workspaceByOrg.set(org, (0, api_1.resolveWorkspaceIdForOrg)(config, org).catch(() => undefined));
+        }
+        return workspaceByOrg.get(org);
+    };
+    const resolved = await Promise.all(rawRefs.map(async (rawRef) => {
+        const parsed = (0, agent_ref_1.parseAgentRef)(rawRef);
+        const org = parsed.org || config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError(`Missing org in '${rawRef}'. Use org/agent[@version] format or set default org with \`orch config set default_org <org>\`.`);
+        }
+        const workspaceId = await workspaceForOrg(org);
+        let depAgent;
+        try {
+            depAgent = await (0, api_1.getAgentWithFallback)(config, org, parsed.agent, parsed.version, workspaceId);
+        }
+        catch (err) {
+            throwDependencyResolutionError(err, org, parsed.agent, parsed.version);
+        }
+        const pinnedVersion = depAgent.version || parsed.version;
+        assertDependencyIsCallable(depAgent, org, parsed.agent, pinnedVersion);
+        return {
+            org,
+            name: parsed.agent,
+            version: pinnedVersion,
+            description: typeof depAgent.description === 'string' ? depAgent.description : undefined,
+            inputSchema: asObject(depAgent.input_schema),
+        };
+    }));
+    const deduped = (0, scaffold_orchestration_1.dedupeOrchestrationDependencies)(resolved);
+    if (deduped.conflicts.length > 0) {
+        const details = deduped.conflicts
+            .map((conflict) => `- ${conflict.id}: ${conflict.versions.join(', ')}`)
+            .join('\n');
+        throw new errors_1.CliError(`Conflicting dependency versions provided:\n${details}\nUse a single version per dependency.`);
+    }
+    return {
+        dependencies: deduped.dependencies,
+        duplicates: deduped.duplicates,
+    };
+}
+async function ensureOutputDirectory(outputDir) {
+    const exists = await fileExists(outputDir);
+    if (!exists) {
+        await promises_1.default.mkdir(outputDir, { recursive: true });
+        return;
+    }
+    const stat = await promises_1.default.stat(outputDir);
+    if (!stat.isDirectory()) {
+        throw new errors_1.CliError(`Output path exists but is not a directory: ${outputDir}`);
+    }
+}
+function registerScaffoldCommand(program) {
+    const scaffold = program
+        .command('scaffold')
+        .description('Scaffold projects from existing agents')
+        .action(() => { scaffold.help(); });
+    scaffold
+        .command('orchestration <agents...>')
+        .description('Generate a managed-loop orchestrator scaffold from published dependency agents')
+        .option('--profile <name>', 'Use API key from named profile')
+        .option('--name <name>', 'Orchestrator name (default: output directory name)')
+        .option('--output <dir>', 'Output directory (default: current directory)')
+        .option('--force', 'Overwrite existing scaffold files')
+        .option('--json', 'Print scaffold summary as JSON')
+        .action(async (agents, options) => {
+        const config = await (0, config_1.getResolvedConfig)({}, options.profile);
+        const outputDir = path_1.default.resolve(options.output || process.cwd());
+        await ensureOutputDirectory(outputDir);
+        const manifestName = (options.name || path_1.default.basename(outputDir)).trim();
+        const nameErrors = (0, scaffold_orchestration_1.validateScaffoldAgentName)(manifestName);
+        if (nameErrors.length > 0) {
+            throw new errors_1.CliError(nameErrors.join('\n'));
+        }
+        const manifestPath = path_1.default.join(outputDir, 'orchagent.json');
+        const promptPath = path_1.default.join(outputDir, 'prompt.md');
+        const schemaPath = path_1.default.join(outputDir, 'schema.json');
+        const targetFiles = [manifestPath, promptPath, schemaPath];
+        if (!options.force) {
+            const existing = (await Promise.all(targetFiles.map(async (filePath) => (await fileExists(filePath) ? filePath : null)))).filter((filePath) => Boolean(filePath));
+            if (existing.length > 0) {
+                const rel = existing.map((f) => path_1.default.relative(outputDir, f));
+                throw new errors_1.CliError(`Refusing to overwrite existing files in ${outputDir}: ${rel.join(', ')}. Re-run with --force to overwrite.`);
+            }
+        }
+        const { dependencies, duplicates } = await resolveDependencies(config, agents);
+        if (dependencies.length === 0) {
+            throw new errors_1.CliError('No dependency agents were resolved.');
+        }
+        const customTools = (0, scaffold_orchestration_1.buildOrchestrationCustomTools)(dependencies);
+        const manifest = (0, scaffold_orchestration_1.buildOrchestrationManifest)({
+            name: manifestName,
+            dependencies,
+            customTools,
+        });
+        const prompt = (0, scaffold_orchestration_1.buildOrchestrationPrompt)({
+            name: manifestName,
+            dependencies,
+            customTools,
+        });
+        const schema = (0, scaffold_orchestration_1.buildOrchestrationSchema)();
+        await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        await promises_1.default.writeFile(promptPath, prompt);
+        await promises_1.default.writeFile(schemaPath, JSON.stringify(schema, null, 2) + '\n');
+        await (0, analytics_1.track)('cli_scaffold_orchestration', {
+            dependency_count: dependencies.length,
+            duplicates_removed: duplicates.length,
+            output_custom: Boolean(options.output),
+            force: Boolean(options.force),
+            json: Boolean(options.json),
+        });
+        if (options.json) {
+            (0, output_1.printJson)({
+                name: manifestName,
+                output_dir: outputDir,
+                dependencies: dependencies.map((dep) => (0, scaffold_orchestration_1.dependencyRef)(dep)),
+                custom_tools: customTools.map((tool) => tool.name),
+                files: ['orchagent.json', 'prompt.md', 'schema.json'],
+                duplicates_removed: duplicates,
+            });
+            return;
+        }
+        process.stdout.write(`Scaffolded orchestrator "${manifestName}" in ${outputDir}\n`);
+        process.stdout.write('\nDependencies:\n');
+        for (const dep of dependencies) {
+            process.stdout.write(`  - ${(0, scaffold_orchestration_1.dependencyRef)(dep)}\n`);
+        }
+        if (duplicates.length > 0) {
+            process.stdout.write('\nRemoved duplicate dependency refs:\n');
+            for (const dup of duplicates) {
+                process.stdout.write(`  - ${dup}\n`);
+            }
+        }
+        process.stdout.write('\nFiles written:\n');
+        process.stdout.write('  - orchagent.json\n');
+        process.stdout.write('  - prompt.md\n');
+        process.stdout.write('  - schema.json\n');
+        process.stdout.write('\nNext steps:\n');
+        if (path_1.default.resolve(outputDir) !== path_1.default.resolve(process.cwd())) {
+            process.stdout.write(`  1. cd ${outputDir}\n`);
+            process.stdout.write('  2. Review prompt.md and schema.json\n');
+            process.stdout.write('  3. Publish: orch publish\n');
+        }
+        else {
+            process.stdout.write('  1. Review prompt.md and schema.json\n');
+            process.stdout.write('  2. Publish: orch publish\n');
+        }
+    });
+}

package/dist/commands/schedule.js

@@ -230,7 +230,7 @@ function registerScheduleCommand(program) {
         }
         else {
             if (s.webhook_url) {
-                process.stdout.write(`\n  ${chalk_1.default.bold('Webhook URL')} (save this — secret shown once):\n`);
+                process.stdout.write(`\n  ${chalk_1.default.bold('Webhook URL')} (save this — retrieve later with ${chalk_1.default.cyan('orch schedule info --reveal')}):\n`);
                 process.stdout.write(`  ${s.webhook_url}\n`);
             }
         }
@@ -444,8 +444,11 @@ function registerScheduleCommand(program) {
         if (s.webhook_url) {
             process.stdout.write(`  Webhook:    ${s.webhook_url}\n`);
         }
-        else if (s.schedule_type === 'webhook' && !options.reveal) {
-            process.stdout.write(`  Webhook:    ${chalk_1.default.gray('(redacted — use --reveal to show)')}\n`);
+        else if (s.schedule_type === 'webhook' && options.reveal) {
+            process.stdout.write(`  Webhook:    ${chalk_1.default.red('Failed to reveal — you may need owner permissions')}\n`);
+        }
+        else if (s.schedule_type === 'webhook') {
+            process.stdout.write(`  Webhook:    ${chalk_1.default.gray('(redacted — use --reveal to show, or regenerate-webhook if lost)')}\n`);
         }
         process.stdout.write(`  Enabled:    ${s.enabled ? chalk_1.default.green('yes') : chalk_1.default.red('no')}\n`);
         process.stdout.write(`  Auto-update: ${s.auto_update === false ? chalk_1.default.yellow('pinned') : chalk_1.default.green('yes')}\n`);
@@ -562,4 +565,38 @@ function registerScheduleCommand(program) {
             process.stdout.write(chalk_1.default.red('\u2717') + ' Test alert delivery failed\n');
         }
     });
+    // orch schedule regenerate-webhook <schedule-id>
+    schedule
+        .command('regenerate-webhook <schedule-id>')
+        .description('Regenerate the webhook secret (invalidates old URL)')
+        .option('--workspace <slug>', 'Workspace slug (default: current workspace)')
+        .option('-y, --yes', 'Skip confirmation prompt')
+        .action(async (partialScheduleId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orch login` first.');
+        }
+        const workspaceId = await resolveWorkspaceId(config, options.workspace);
+        const scheduleId = await resolveScheduleId(config, partialScheduleId, workspaceId);
+        if (!options.yes) {
+            const rl = promises_1.default.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const answer = await rl.question(chalk_1.default.yellow('Warning: This will invalidate the current webhook URL.\n') +
+                'Any integrations using the old URL will stop working.\n' +
+                'Regenerate webhook secret? (y/N): ');
+            rl.close();
+            if (answer.trim().toLowerCase() !== 'y' && answer.trim().toLowerCase() !== 'yes') {
+                process.stdout.write('Cancelled.\n');
+                return;
+            }
+        }
+        const result = await (0, api_1.request)(config, 'POST', `/workspaces/${workspaceId}/schedules/${scheduleId}/regenerate-webhook`);
+        process.stdout.write(chalk_1.default.green('\u2713') + ' Webhook secret regenerated\n\n');
+        process.stdout.write(`  ${chalk_1.default.bold('New Webhook URL')} (save this — retrieve later with ${chalk_1.default.cyan('orch schedule info --reveal')}):\n`);
+        process.stdout.write(`  ${result.webhook_url}\n\n`);
+        process.stdout.write(chalk_1.default.yellow('  The old webhook URL no longer works.\n'));
+        process.stdout.write('\n');
+    });
 }