@orchagent/cli 0.3.86 → 0.3.88

package/dist/lib/dev-server.js

@@ -0,0 +1,425 @@
+"use strict";
+/**
+ * Local HTTP dev server for agent development.
+ *
+ * Provides agent config loading, execution dispatch (code_runtime, direct_llm,
+ * managed_loop), and an HTTP server that accepts JSON input and returns results.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferEngine = inferEngine;
+exports.engineLabel = engineLabel;
+exports.loadAgentConfig = loadAgentConfig;
+exports.executeAgent = executeAgent;
+exports.createDevServer = createDevServer;
+const http_1 = __importDefault(require("http"));
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const llm_1 = require("./llm");
+const bundle_1 = require("./bundle");
+const config_1 = require("./config");
+// ─── Engine inference ───────────────────────────────────────────────────────
+function inferEngine(manifest) {
+    const hasRuntimeCommand = Boolean(manifest.runtime?.command?.trim());
+    const hasLoop = Boolean(manifest.loop && Object.keys(manifest.loop).length > 0);
+    if (hasRuntimeCommand)
+        return 'code_runtime';
+    if (hasLoop)
+        return 'managed_loop';
+    const rawType = (manifest.type || 'agent').trim().toLowerCase();
+    if (rawType === 'tool' || rawType === 'code')
+        return 'code_runtime';
+    if (rawType === 'agentic')
+        return 'managed_loop';
+    if (rawType === 'agent')
+        return 'managed_loop';
+    return 'direct_llm';
+}
+function engineLabel(engine) {
+    switch (engine) {
+        case 'direct_llm': return 'prompt';
+        case 'managed_loop': return 'agent loop';
+        case 'code_runtime': return 'code runtime';
+    }
+}
+// ─── Agent config loading ───────────────────────────────────────────────────
+async function loadAgentConfig(agentDir) {
+    const manifestPath = path_1.default.join(agentDir, 'orchagent.json');
+    const raw = await promises_1.default.readFile(manifestPath, 'utf-8');
+    const manifest = JSON.parse(raw);
+    const engine = inferEngine(manifest);
+    // Read prompt.md if needed
+    let prompt;
+    if (engine === 'direct_llm' || engine === 'managed_loop') {
+        try {
+            prompt = await promises_1.default.readFile(path_1.default.join(agentDir, 'prompt.md'), 'utf-8');
+        }
+        catch {
+            // Will error at execution time
+        }
+    }
+    // Read schema.json
+    let inputSchema;
+    let outputSchema;
+    try {
+        const schemaRaw = await promises_1.default.readFile(path_1.default.join(agentDir, 'schema.json'), 'utf-8');
+        const schemas = JSON.parse(schemaRaw);
+        inputSchema = schemas.input;
+        outputSchema = schemas.output;
+    }
+    catch {
+        // Optional
+    }
+    // Custom tools
+    const customTools = manifest.custom_tools || undefined;
+    // Detect entrypoint for code_runtime
+    let entrypoint;
+    if (engine === 'code_runtime') {
+        entrypoint = manifest.entrypoint || (await (0, bundle_1.detectEntrypoint)(agentDir)) || undefined;
+    }
+    return { manifest, engine, entrypoint, prompt, outputSchema, inputSchema, customTools, agentDir };
+}
+// ─── Agent execution ────────────────────────────────────────────────────────
+/**
+ * Execute a code_runtime agent: spawn entrypoint with stdin JSON, return stdout.
+ */
+async function executeCodeRuntime(config, input, verbose) {
+    if (!config.entrypoint) {
+        throw new Error('No entrypoint found. Set "entrypoint" in orchagent.json or create main.py/main.js.');
+    }
+    const entrypoint = config.entrypoint;
+    const isJs = entrypoint.endsWith('.js') || entrypoint.endsWith('.ts') ||
+        entrypoint.endsWith('.mjs') || entrypoint.endsWith('.cjs');
+    const cmd = isJs ? 'node' : 'python3';
+    const inputJson = JSON.stringify(input);
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)(cmd, [entrypoint], {
+            cwd: config.agentDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: { ...process.env, ORCHAGENT_LOCAL_EXECUTION: 'true' },
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            if (verbose) {
+                process.stderr.write(text);
+            }
+        });
+        proc.stdin?.write(inputJson);
+        proc.stdin?.end();
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                const detail = stderr.trim() ? `\n${stderr.trim()}` : '';
+                reject(new Error(`Entrypoint exited with code ${code}${detail}`));
+                return;
+            }
+            const trimmed = stdout.trim();
+            if (!trimmed) {
+                resolve({});
+                return;
+            }
+            try {
+                resolve(JSON.parse(trimmed));
+            }
+            catch {
+                // Return raw output wrapped
+                resolve({ raw_output: trimmed });
+            }
+        });
+        proc.on('error', (err) => {
+            reject(new Error(`Failed to spawn ${cmd}: ${err.message}`));
+        });
+    });
+}
+/**
+ * Execute a direct_llm agent: call LLM with prompt + input.
+ */
+async function executeDirectLlm(config, input, verbose, resolvedConfig) {
+    if (!config.prompt) {
+        throw new Error('No prompt.md found. Create prompt.md in the agent directory.');
+    }
+    const supportedProviders = config.manifest.supported_providers || ['any'];
+    const detected = await (0, llm_1.detectLlmKey)(supportedProviders, resolvedConfig);
+    if (!detected) {
+        throw new Error(`No LLM key found. Set an environment variable (e.g., OPENAI_API_KEY) or add one to .env`);
+    }
+    const { provider, key, model: serverModel } = detected;
+    const model = serverModel
+        || config.manifest.default_models?.[provider]
+        || (0, llm_1.getDefaultModel)(provider);
+    if (verbose) {
+        process.stderr.write(`  LLM: ${provider} (${model})\n`);
+    }
+    const prompt = (0, llm_1.buildPrompt)(config.prompt, input);
+    return await (0, llm_1.callLlm)(provider, key, model, prompt, config.outputSchema);
+}
+/**
+ * Execute a managed_loop agent: spawn agent_runner.py with temp files.
+ */
+async function executeManagedLoop(config, input, verbose, resolvedConfig) {
+    if (!config.prompt) {
+        throw new Error('No prompt.md found. Create prompt.md in the agent directory.');
+    }
+    const supportedProviders = config.manifest.supported_providers || ['any'];
+    const detected = await (0, llm_1.detectLlmKey)(supportedProviders, resolvedConfig);
+    if (!detected) {
+        throw new Error(`No LLM key found. Set an environment variable (e.g., OPENAI_API_KEY) or add one to .env`);
+    }
+    const { provider, key: apiKey, model: serverModel } = detected;
+    const model = serverModel
+        || config.manifest.default_models?.[provider]
+        || (0, llm_1.getDefaultModel)(provider);
+    const apiKeyEnvVar = llm_1.PROVIDER_ENV_VARS[provider];
+    if (verbose) {
+        process.stderr.write(`  LLM: ${provider} (${model})\n`);
+    }
+    // Create temp directory with agent files
+    const tempDir = path_1.default.join(os_1.default.tmpdir(), `orchagent-dev-${Date.now()}`);
+    await promises_1.default.mkdir(tempDir, { recursive: true });
+    try {
+        // Copy agent_runner.py from resources
+        const runnerSource = path_1.default.join(__dirname, '..', 'resources', 'agent_runner.py');
+        let runnerContent;
+        try {
+            runnerContent = await promises_1.default.readFile(runnerSource, 'utf-8');
+        }
+        catch {
+            const altSource = path_1.default.join(__dirname, '..', '..', 'src', 'resources', 'agent_runner.py');
+            runnerContent = await promises_1.default.readFile(altSource, 'utf-8');
+        }
+        await promises_1.default.writeFile(path_1.default.join(tempDir, 'agent_runner.py'), runnerContent);
+        await promises_1.default.writeFile(path_1.default.join(tempDir, 'prompt.md'), config.prompt);
+        await promises_1.default.writeFile(path_1.default.join(tempDir, 'input.json'), JSON.stringify(input, null, 2));
+        if (config.outputSchema) {
+            await promises_1.default.writeFile(path_1.default.join(tempDir, 'output_schema.json'), JSON.stringify(config.outputSchema));
+        }
+        if (config.customTools && config.customTools.length > 0) {
+            await promises_1.default.writeFile(path_1.default.join(tempDir, 'custom_tools.json'), JSON.stringify(config.customTools));
+        }
+        const subprocessEnv = { ...process.env };
+        subprocessEnv.LOCAL_MODE = '1';
+        subprocessEnv.LLM_PROVIDER = provider;
+        subprocessEnv.LLM_MODEL = model;
+        if (apiKeyEnvVar && apiKey) {
+            subprocessEnv[apiKeyEnvVar] = apiKey;
+        }
+        const maxTurns = config.manifest.max_turns || 25;
+        return await new Promise((resolve, reject) => {
+            const proc = (0, child_process_1.spawn)('python3', ['agent_runner.py', '--max-turns', String(maxTurns), '--verbose'], {
+                cwd: tempDir,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: subprocessEnv,
+            });
+            proc.stdin.end();
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                if (verbose) {
+                    for (const line of text.split('\n')) {
+                        if (line.startsWith('@@ORCHAGENT_EVENT:'))
+                            continue;
+                        if (line.trim() === '.' || line.trim() === '')
+                            continue;
+                        process.stderr.write(`  ${line}\n`);
+                    }
+                }
+            });
+            proc.on('close', (code) => {
+                if (stdout.trim()) {
+                    try {
+                        const result = JSON.parse(stdout.trim());
+                        if (code !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
+                            reject(new Error(String(result.error)));
+                            return;
+                        }
+                        resolve(result);
+                    }
+                    catch {
+                        if (code !== 0) {
+                            reject(new Error(`Agent exited with code ${code}`));
+                        }
+                        else {
+                            resolve({ raw_output: stdout.trim() });
+                        }
+                    }
+                }
+                else if (code !== 0) {
+                    reject(new Error(`Agent exited with code ${code}${stderr.trim() ? `: ${stderr.trim().slice(0, 200)}` : ''}`));
+                }
+                else {
+                    resolve({});
+                }
+            });
+            proc.on('error', (err) => {
+                reject(new Error(`Failed to spawn python3: ${err.message}`));
+            });
+        });
+    }
+    finally {
+        try {
+            await promises_1.default.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
+/**
+ * Execute an agent with the given input, dispatching by engine type.
+ */
+async function executeAgent(config, input, verbose, resolvedConfig) {
+    switch (config.engine) {
+        case 'code_runtime':
+            return executeCodeRuntime(config, input, verbose);
+        case 'direct_llm':
+            return executeDirectLlm(config, input, verbose, resolvedConfig);
+        case 'managed_loop':
+            return executeManagedLoop(config, input, verbose, resolvedConfig);
+    }
+}
+// ─── HTTP server ────────────────────────────────────────────────────────────
+function readBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf-8')));
+        req.on('error', reject);
+    });
+}
+function sendJson(res, statusCode, body) {
+    const json = JSON.stringify(body, null, 2);
+    res.writeHead(statusCode, {
+        'Content-Type': 'application/json',
+        'Access-Control-Allow-Origin': '*',
+        'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+        'Access-Control-Allow-Headers': 'Content-Type',
+    });
+    res.end(json);
+}
+function createDevServer(port, verbose, getConfig, callbacks = {}) {
+    let requestCounter = 0;
+    const server = http_1.default.createServer(async (req, res) => {
+        const startTime = Date.now();
+        const reqId = ++requestCounter;
+        const method = req.method || 'GET';
+        const urlPath = req.url || '/';
+        // CORS preflight
+        if (method === 'OPTIONS') {
+            sendJson(res, 204, null);
+            return;
+        }
+        // GET /health — agent info
+        if (method === 'GET' && (urlPath === '/health' || urlPath === '/info')) {
+            const config = getConfig();
+            if (!config) {
+                sendJson(res, 503, { status: 'error', error: 'Agent configuration invalid' });
+                return;
+            }
+            sendJson(res, 200, {
+                status: 'ok',
+                agent: config.manifest.name,
+                version: config.manifest.version,
+                type: config.manifest.type,
+                engine: config.engine,
+                entrypoint: config.entrypoint,
+                has_prompt: Boolean(config.prompt),
+                has_schema: Boolean(config.inputSchema || config.outputSchema),
+            });
+            return;
+        }
+        // GET / — usage page
+        if (method === 'GET' && urlPath === '/') {
+            const config = getConfig();
+            const name = config?.manifest.name || 'unknown';
+            res.writeHead(200, { 'Content-Type': 'text/plain' });
+            res.end(`orchagent dev server — ${name}\n\n` +
+                `Endpoints:\n` +
+                `  POST /       Run agent with JSON body\n` +
+                `  POST /run    Run agent with JSON body\n` +
+                `  GET  /health Agent configuration info\n\n` +
+                `Example:\n` +
+                `  curl -X POST http://localhost:${port}/run \\\n` +
+                `    -H "Content-Type: application/json" \\\n` +
+                `    -d '{"task": "hello world"}'\n`);
+            return;
+        }
+        // POST / or POST /run — execute agent
+        if (method === 'POST' && (urlPath === '/' || urlPath === '/run')) {
+            const config = getConfig();
+            if (!config) {
+                const log = {
+                    id: reqId, method, path: urlPath, statusCode: 503,
+                    durationMs: Date.now() - startTime, error: 'Agent configuration invalid',
+                };
+                callbacks.onRequest?.(log);
+                sendJson(res, 503, { error: 'Agent configuration invalid. Check console for validation errors.' });
+                return;
+            }
+            let input;
+            try {
+                const body = await readBody(req);
+                input = body.trim() ? JSON.parse(body) : {};
+            }
+            catch {
+                const log = {
+                    id: reqId, method, path: urlPath, statusCode: 400,
+                    durationMs: Date.now() - startTime, error: 'Invalid JSON body',
+                };
+                callbacks.onRequest?.(log);
+                sendJson(res, 400, { error: 'Invalid JSON body' });
+                return;
+            }
+            const inputPreview = JSON.stringify(input).slice(0, 80);
+            try {
+                const resolvedCfg = await (0, config_1.getResolvedConfig)();
+                const result = await executeAgent(config, input, verbose, resolvedCfg);
+                const durationMs = Date.now() - startTime;
+                const log = {
+                    id: reqId, method, path: urlPath, statusCode: 200,
+                    durationMs, inputPreview,
+                };
+                callbacks.onRequest?.(log);
+                sendJson(res, 200, result);
+            }
+            catch (err) {
+                const durationMs = Date.now() - startTime;
+                const message = err instanceof Error ? err.message : String(err);
+                const log = {
+                    id: reqId, method, path: urlPath, statusCode: 500,
+                    durationMs, inputPreview, error: message,
+                };
+                callbacks.onRequest?.(log);
+                callbacks.onError?.(err instanceof Error ? err : new Error(message));
+                sendJson(res, 500, { error: message });
+            }
+            return;
+        }
+        // 404 for everything else
+        sendJson(res, 404, { error: `Not found: ${method} ${urlPath}` });
+    });
+    const close = () => {
+        return new Promise((resolve, reject) => {
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+    };
+    return { server, close };
+}

package/dist/lib/doctor/checks/environment.js

@@ -87,7 +87,7 @@ async function checkCliVersion() {
                 name: 'cli_version',
                 status: 'warning',
                 message: `CLI v${installedVersion} (v${latestVersion} available)`,
-                fix: 'Run `npm update -g @orchagent/cli` to update',
+                fix: 'Run `npm install -g @orchagent/cli@latest` to update',
                 details: { installed: installedVersion, latest: latestVersion },
             };
         }

package/dist/lib/key-store.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveServiceKey = saveServiceKey;
+exports.loadServiceKeys = loadServiceKeys;
+exports.listAllLocalKeys = listAllLocalKeys;
+exports.deleteLocalKey = deleteLocalKey;
+exports.getKeysDir = getKeysDir;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const KEYS_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent', 'keys');
+/**
+ * Build the path to the key file for an agent: ~/.orchagent/keys/{org}/{agent}.json
+ */
+function keyFilePath(org, agentName) {
+    return path_1.default.join(KEYS_DIR, org, `${agentName}.json`);
+}
+/**
+ * Save a service key locally after creation (publish, fork, or agent-keys create).
+ * Keys are stored per-agent in ~/.orchagent/keys/{org}/{agent}.json with 0600 permissions.
+ */
+async function saveServiceKey(org, agentName, agentVersion, key, prefix) {
+    const filePath = keyFilePath(org, agentName);
+    const dir = path_1.default.dirname(filePath);
+    await promises_1.default.mkdir(dir, { recursive: true, mode: 0o700 });
+    // Load existing keys for this agent
+    const existing = await loadServiceKeys(org, agentName);
+    const entry = {
+        key,
+        prefix,
+        agent_version: agentVersion,
+        created_at: new Date().toISOString(),
+    };
+    existing.push(entry);
+    await promises_1.default.writeFile(filePath, JSON.stringify(existing, null, 2) + '\n', { mode: 0o600 });
+    await promises_1.default.chmod(filePath, 0o600);
+    return filePath;
+}
+/**
+ * Load locally-saved service keys for a specific agent.
+ */
+async function loadServiceKeys(org, agentName) {
+    try {
+        const raw = await promises_1.default.readFile(keyFilePath(org, agentName), 'utf-8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+}
+/**
+ * List all locally-saved service keys across all orgs/agents.
+ * Returns entries grouped by org/agent.
+ */
+async function listAllLocalKeys() {
+    const results = [];
+    let orgDirs;
+    try {
+        orgDirs = await promises_1.default.readdir(KEYS_DIR);
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return [];
+        }
+        throw err;
+    }
+    for (const orgDir of orgDirs) {
+        const orgPath = path_1.default.join(KEYS_DIR, orgDir);
+        const stat = await promises_1.default.stat(orgPath);
+        if (!stat.isDirectory())
+            continue;
+        const files = await promises_1.default.readdir(orgPath);
+        for (const file of files) {
+            if (!file.endsWith('.json'))
+                continue;
+            const agentName = file.replace('.json', '');
+            try {
+                const raw = await promises_1.default.readFile(path_1.default.join(orgPath, file), 'utf-8');
+                const keys = JSON.parse(raw);
+                if (keys.length > 0) {
+                    results.push({ org: orgDir, agent: agentName, keys });
+                }
+            }
+            catch {
+                // Skip corrupted files
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Delete a locally-saved key by prefix match. Returns true if found and removed.
+ */
+async function deleteLocalKey(org, agentName, prefix) {
+    const keys = await loadServiceKeys(org, agentName);
+    const filtered = keys.filter(k => k.prefix !== prefix);
+    if (filtered.length === keys.length) {
+        return false; // nothing removed
+    }
+    const filePath = keyFilePath(org, agentName);
+    if (filtered.length === 0) {
+        await promises_1.default.unlink(filePath);
+    }
+    else {
+        await promises_1.default.writeFile(filePath, JSON.stringify(filtered, null, 2) + '\n', { mode: 0o600 });
+        await promises_1.default.chmod(filePath, 0o600);
+    }
+    return true;
+}
+/**
+ * Get the keys directory path (for display purposes).
+ */
+function getKeysDir() {
+    return KEYS_DIR;
+}

package/dist/lib/spinner.js

@@ -8,6 +8,8 @@ exports.isProgressEnabled = isProgressEnabled;
 exports.createSpinner = createSpinner;
 exports.withSpinner = withSpinner;
 exports.createProgressSpinner = createProgressSpinner;
+exports.formatElapsed = formatElapsed;
+exports.createElapsedSpinner = createElapsedSpinner;
 const ora_1 = __importDefault(require("ora"));
 // Global flag to control spinner visibility (set via --no-progress)
 let progressEnabled = true;
@@ -118,3 +120,51 @@ function createProgressSpinner(initialText) {
     };
     return { spinner, updateProgress };
 }
+/**
+ * Format elapsed seconds as a human-readable string.
+ * Under 60s: "5.0s", 60s+: "1m 23s"
+ */
+function formatElapsed(seconds) {
+    if (seconds < 60) {
+        return `${seconds.toFixed(1)}s`;
+    }
+    const mins = Math.floor(seconds / 60);
+    const secs = Math.floor(seconds % 60);
+    return `${mins}m ${secs.toString().padStart(2, '0')}s`;
+}
+/**
+ * Create a spinner that auto-updates with elapsed time.
+ * Shows "Running agent... (5.0s)" and ticks every second.
+ * Call dispose() to stop the timer when done (before spinner.stop/succeed/fail).
+ */
+function createElapsedSpinner(text) {
+    const spinner = createSpinner(text);
+    const startTime = Date.now();
+    let timer = null;
+    const originalStart = spinner.start.bind(spinner);
+    spinner.start = function (newText) {
+        originalStart(newText);
+        timer = setInterval(() => {
+            const elapsed = (Date.now() - startTime) / 1000;
+            spinner.text = `${text} (${formatElapsed(elapsed)})`;
+        }, 1000);
+        return this;
+    };
+    const dispose = () => {
+        if (timer) {
+            clearInterval(timer);
+            timer = null;
+        }
+    };
+    // Auto-dispose on stop/succeed/fail so callers can't leak timers
+    const wrap = (fn) => {
+        return ((...args) => {
+            dispose();
+            return fn(...args);
+        });
+    };
+    spinner.stop = wrap(spinner.stop.bind(spinner));
+    spinner.succeed = wrap(spinner.succeed.bind(spinner));
+    spinner.fail = wrap(spinner.fail.bind(spinner));
+    return { spinner, dispose };
+}