@orchagent/cli 0.3.85 → 0.3.87

package/dist/commands/health.js

@@ -0,0 +1,226 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerHealthCommand = registerHealthCommand;
+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 errors_1 = require("../lib/errors");
+const spinner_1 = require("../lib/spinner");
+const output_1 = require("../lib/output");
+const package_json_1 = __importDefault(require("../../package.json"));
+/**
+ * Generate a minimal sample input from an agent's input schema.
+ * Produces just enough to satisfy required fields.
+ */
+function generateSampleInput(schema) {
+    if (!schema?.properties)
+        return undefined;
+    const required = new Set(schema.required || []);
+    const result = {};
+    for (const [key, prop] of Object.entries(schema.properties)) {
+        if (!required.has(key))
+            continue;
+        result[key] = sampleValue(prop);
+    }
+    // If no required fields, fill one optional field so the request isn't empty
+    if (Object.keys(result).length === 0) {
+        const firstKey = Object.keys(schema.properties)[0];
+        if (firstKey) {
+            result[firstKey] = sampleValue(schema.properties[firstKey]);
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+function sampleValue(prop) {
+    if (prop.default !== undefined)
+        return prop.default;
+    if (prop.enum?.length)
+        return prop.enum[0];
+    switch (prop.type) {
+        case 'string': return 'test';
+        case 'number':
+        case 'integer': return 1;
+        case 'boolean': return true;
+        case 'array': return [];
+        case 'object': return {};
+        default: return 'test';
+    }
+}
+function registerHealthCommand(program) {
+    program
+        .command('health <agent>')
+        .description('Smoke test an agent with a minimal cloud execution')
+        .option('--json', 'Output result as JSON')
+        .option('--data <json>', 'Custom input data (JSON string)')
+        .option('--timeout <ms>', 'Execution timeout in milliseconds', '30000')
+        .action(async (agentArg, options) => {
+        const startTime = Date.now();
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        const parsed = (0, agent_ref_1.parseAgentRef)(agentArg);
+        const configFile = await (0, config_1.loadConfig)();
+        const org = parsed.org ?? configFile.workspace ?? config.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent[@version] format or set default org.');
+        }
+        const timeoutMs = parseInt(options.timeout || '30000', 10);
+        if (isNaN(timeoutMs) || timeoutMs < 1000) {
+            throw new errors_1.CliError('Timeout must be at least 1000ms.');
+        }
+        const result = {
+            agent: `${org}/${parsed.agent}`,
+            version: parsed.version,
+            status: 'fail',
+            latency_ms: 0,
+            checks: { resolve: 'fail', execute: 'skip' },
+        };
+        const { spinner, dispose } = options.json
+            ? { spinner: null, dispose: () => { } }
+            : (0, spinner_1.createElapsedSpinner)(`Health check: ${org}/${parsed.agent}@${parsed.version}`);
+        spinner?.start();
+        // --- Step 1: Resolve agent metadata ---
+        let agentMeta;
+        let workspaceId;
+        try {
+            workspaceId = await (0, api_1.resolveWorkspaceIdForOrg)(config, org);
+            agentMeta = await (0, api_1.getAgentWithFallback)(config, org, parsed.agent, parsed.version, workspaceId);
+            result.checks.resolve = 'pass';
+        }
+        catch (err) {
+            result.latency_ms = Date.now() - startTime;
+            result.error = err instanceof Error ? err.message : String(err);
+            dispose();
+            return reportResult(result, options.json, spinner);
+        }
+        // Skills are not runnable
+        const agentType = agentMeta.type || 'prompt';
+        if (agentType === 'skill') {
+            result.latency_ms = Date.now() - startTime;
+            result.error = 'Skills are not runnable — nothing to health check.';
+            result.checks.execute = 'skip';
+            dispose();
+            return reportResult(result, options.json, spinner);
+        }
+        // --- Step 2: Execute agent ---
+        const inputSchema = agentMeta.input_schema;
+        let body;
+        if (options.data) {
+            try {
+                JSON.parse(options.data);
+                body = options.data;
+            }
+            catch {
+                throw new errors_1.CliError('Invalid JSON in --data option.');
+            }
+        }
+        else {
+            const sample = generateSampleInput(inputSchema);
+            body = JSON.stringify(sample || {});
+        }
+        const endpoint = agentMeta.default_endpoint || 'analyze';
+        const url = `${config.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}`;
+        const headers = {
+            Authorization: `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+            'X-CLI-Version': package_json_1.default.version,
+            'X-OrchAgent-Client': 'cli',
+        };
+        if (workspaceId) {
+            headers['X-Workspace-Id'] = workspaceId;
+        }
+        try {
+            const response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
+                method: 'POST',
+                headers,
+                body,
+                timeoutMs: timeoutMs,
+            });
+            result.latency_ms = Date.now() - startTime;
+            // Extract run ID from response headers or body
+            const runId = response.headers.get('x-orchagent-run-id');
+            if (runId)
+                result.run_id = runId;
+            if (response.ok) {
+                // Try to extract run_id from body if not in headers
+                const text = await response.text();
+                if (!result.run_id) {
+                    try {
+                        const parsed = JSON.parse(text);
+                        if (parsed?.run_id)
+                            result.run_id = parsed.run_id;
+                    }
+                    catch { /* not JSON, that's fine */ }
+                }
+                result.checks.execute = 'pass';
+                result.status = 'pass';
+            }
+            else {
+                result.checks.execute = 'fail';
+                const text = await response.text();
+                let detail;
+                try {
+                    const parsed = JSON.parse(text);
+                    detail = parsed?.error?.message || parsed?.message || parsed?.detail || `HTTP ${response.status}`;
+                    if (parsed?.run_id)
+                        result.run_id = parsed.run_id;
+                }
+                catch {
+                    detail = `HTTP ${response.status}: ${text.slice(0, 200)}`;
+                }
+                result.error = detail;
+            }
+        }
+        catch (err) {
+            result.latency_ms = Date.now() - startTime;
+            result.checks.execute = 'fail';
+            result.error = err instanceof Error ? err.message : String(err);
+        }
+        dispose();
+        reportResult(result, options.json, spinner);
+    });
+}
+function reportResult(result, json, spinner) {
+    if (json) {
+        (0, output_1.printJson)(result);
+        if (result.status === 'fail') {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const passed = result.status === 'pass';
+    const latency = `${result.latency_ms}ms`;
+    if (passed) {
+        spinner?.succeed(`${chalk_1.default.green('PASS')} ${result.agent}@${result.version} — ${latency}`);
+    }
+    else {
+        spinner?.fail(`${chalk_1.default.red('FAIL')} ${result.agent}@${result.version} — ${latency}`);
+    }
+    // Detail lines
+    process.stderr.write('\n');
+    process.stderr.write(`  Resolve:  ${checkMark(result.checks.resolve)}\n`);
+    process.stderr.write(`  Execute:  ${checkMark(result.checks.execute)}\n`);
+    if (result.run_id) {
+        process.stderr.write(`  Run ID:   ${chalk_1.default.gray(result.run_id)}\n`);
+        process.stderr.write(`  Logs:     ${chalk_1.default.gray(`orch logs ${result.run_id}`)}\n`);
+    }
+    if (result.error) {
+        process.stderr.write(`\n  ${chalk_1.default.red('Error:')} ${result.error}\n`);
+    }
+    process.stderr.write('\n');
+    if (!passed) {
+        process.exitCode = 1;
+    }
+}
+function checkMark(status) {
+    switch (status) {
+        case 'pass': return chalk_1.default.green('pass');
+        case 'fail': return chalk_1.default.red('fail');
+        case 'skip': return chalk_1.default.gray('skip');
+    }
+}

package/dist/commands/index.js

@@ -36,6 +36,10 @@ const transfer_1 = require("./transfer");
 const pull_1 = require("./pull");
 const logs_1 = require("./logs");
 const secrets_1 = require("./secrets");
+const diff_1 = require("./diff");
+const health_1 = require("./health");
+const dev_1 = require("./dev");
+const estimate_1 = require("./estimate");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, logout_1.registerLogoutCommand)(program);
@@ -72,4 +76,8 @@ function registerCommands(program) {
     (0, pull_1.registerPullCommand)(program);
     (0, logs_1.registerLogsCommand)(program);
     (0, secrets_1.registerSecretsCommand)(program);
+    (0, diff_1.registerDiffCommand)(program);
+    (0, health_1.registerHealthCommand)(program);
+    (0, dev_1.registerDevCommand)(program);
+    (0, estimate_1.registerEstimateCommand)(program);
 }

package/dist/commands/info.js

@@ -48,11 +48,32 @@ async function fetchReadme(url) {
         return null;
     }
 }
+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 }));
+}
 async function getAgentInfo(config, org, agent, version, workspaceId) {
     // Use public metadata endpoint as primary source — never blocked by download restrictions
     try {
         const publicMeta = await (0, api_1.getPublicAgent)(config, org, agent, version);
         const meta = publicMeta;
+        const manifest = meta.manifest;
         return {
             type: (publicMeta.type || 'tool'),
             name: publicMeta.name,
@@ -65,6 +86,10 @@ async function getAgentInfo(config, org, agent, version, workspaceId) {
             source_url: meta.source_url,
             run_command: meta.run_command,
             url: meta.url,
+            dependencies: extractDependencies(manifest),
+            default_skills: meta.default_skills || [],
+            custom_tools: extractCustomTools(manifest),
+            environment: manifest?.environment,
         };
     }
     catch (err) {
@@ -95,6 +120,7 @@ async function getAgentInfo(config, org, agent, version, workspaceId) {
     else {
         targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
     }
+    const agentManifest = targetAgent.manifest;
     return {
         type: targetAgent.type,
         name: targetAgent.name,
@@ -108,6 +134,10 @@ async function getAgentInfo(config, org, agent, version, workspaceId) {
         source_url: targetAgent.source_url,
         run_command: targetAgent.run_command,
         url: targetAgent.url,
+        dependencies: extractDependencies(agentManifest),
+        default_skills: targetAgent.default_skills || [],
+        custom_tools: extractCustomTools(agentManifest),
+        environment: agentManifest?.environment,
     };
 }
 function registerInfoCommand(program) {
@@ -169,6 +199,51 @@ function registerInfoCommand(program) {
             process.stdout.write('\nOutput Schema:\n');
             process.stdout.write(formatSchema(agentData.output_schema) + '\n');
         }
+        // Display dependencies
+        const hasDeps = agentData.dependencies && agentData.dependencies.length > 0;
+        const hasSkills = agentData.default_skills && agentData.default_skills.length > 0;
+        const hasTools = agentData.custom_tools && agentData.custom_tools.length > 0;
+        if (hasDeps) {
+            process.stdout.write('\nDependencies:\n');
+            for (const dep of agentData.dependencies) {
+                process.stdout.write(`  ${chalk_1.default.cyan(dep.id)}@${dep.version}\n`);
+            }
+        }
+        if (hasSkills) {
+            process.stdout.write('\nSkills:\n');
+            for (const skill of agentData.default_skills) {
+                process.stdout.write(`  ${chalk_1.default.yellow(skill)}\n`);
+            }
+        }
+        if (hasTools) {
+            process.stdout.write('\nCustom Tools:\n');
+            for (const tool of agentData.custom_tools) {
+                let line = `  ${chalk_1.default.magenta(tool.name)}`;
+                if (tool.description) {
+                    line += ` — ${tool.description}`;
+                }
+                process.stdout.write(line + '\n');
+            }
+        }
+        // Display environment pinning
+        if (agentData.environment) {
+            const env = agentData.environment;
+            const parts = [];
+            if (env.python_version)
+                parts.push(`Python ${env.python_version}`);
+            if (env.node_version)
+                parts.push(`Node ${env.node_version}`);
+            if (env.pip_flags)
+                parts.push(`pip flags: ${env.pip_flags}`);
+            if (env.npm_flags)
+                parts.push(`npm flags: ${env.npm_flags}`);
+            if (parts.length) {
+                process.stdout.write('\nEnvironment:\n');
+                for (const part of parts) {
+                    process.stdout.write(`  ${part}\n`);
+                }
+            }
+        }
         // Fetch and display README if available
         if (agentData.source_url) {
             const readmeUrl = deriveReadmeUrl(agentData.source_url);