@orchagent/cli 0.1.0

package/dist/commands/run.js

@@ -0,0 +1,421 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunCommand = registerRunCommand;
+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 config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const output_1 = require("../lib/output");
+const llm_1 = require("../lib/llm");
+const DEFAULT_VERSION = 'latest';
+const AGENTS_DIR = path_1.default.join(os_1.default.homedir(), '.orchagent', 'agents');
+function parseAgentRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { agent: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], agent: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
+}
+async function downloadAgent(config, org, agent, version) {
+    // Public endpoint - no auth required
+    return (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+}
+async function checkDependencies(config, dependencies) {
+    const results = [];
+    for (const dep of dependencies) {
+        const [org, agent] = dep.id.split('/');
+        try {
+            const agentData = await downloadAgent(config, org, agent, dep.version);
+            const downloadable = !!(agentData.source_url || agentData.pip_package || agentData.type === 'prompt');
+            results.push({ dep, downloadable, agentData });
+        }
+        catch {
+            // Agent not found or not downloadable
+            results.push({ dep, downloadable: false });
+        }
+    }
+    return results;
+}
+async function promptUserForDeps(depStatuses) {
+    const readline = await Promise.resolve().then(() => __importStar(require('readline')));
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stderr,
+    });
+    const downloadableCount = depStatuses.filter(d => d.downloadable).length;
+    const cloudOnlyCount = depStatuses.length - downloadableCount;
+    process.stderr.write('\n⚠️  This agent has dependencies:\n');
+    for (const status of depStatuses) {
+        const icon = status.downloadable ? '✓' : '☁️';
+        const note = status.downloadable ? '(downloadable)' : '(cloud-only)';
+        process.stderr.write(`  ${icon} ${status.dep.id}@${status.dep.version} ${note}\n`);
+    }
+    process.stderr.write('\n');
+    if (cloudOnlyCount > 0) {
+        process.stderr.write(`Note: ${cloudOnlyCount} dependency(s) are cloud-only and cannot run locally.\n\n`);
+    }
+    process.stderr.write('Options:\n');
+    process.stderr.write('  [1] Run on server (orch call) - recommended\n');
+    if (downloadableCount > 0) {
+        process.stderr.write(`  [2] Download ${downloadableCount} available deps, run locally\n`);
+    }
+    process.stderr.write('  [3] Cancel\n\n');
+    return new Promise((resolve) => {
+        rl.question('Choose [1/2/3]: ', (answer) => {
+            rl.close();
+            const choice = answer.trim();
+            if (choice === '1')
+                resolve('server');
+            else if (choice === '2' && downloadableCount > 0)
+                resolve('local');
+            else
+                resolve('cancel');
+        });
+    });
+}
+async function downloadDependenciesRecursively(config, depStatuses, visited = new Set()) {
+    for (const status of depStatuses) {
+        if (!status.downloadable || !status.agentData)
+            continue;
+        const depRef = `${status.dep.id}@${status.dep.version}`;
+        if (visited.has(depRef))
+            continue;
+        visited.add(depRef);
+        const [org, agent] = status.dep.id.split('/');
+        process.stderr.write(`\nDownloading dependency: ${depRef}...\n`);
+        // Save the dependency locally
+        await saveAgentLocally(org, agent, status.agentData);
+        // Install if it's a code agent
+        if (status.agentData.type === 'code' && (status.agentData.source_url || status.agentData.pip_package)) {
+            await installCodeAgent(status.agentData);
+        }
+        // Recursively download its dependencies
+        if (status.agentData.dependencies && status.agentData.dependencies.length > 0) {
+            const nestedStatuses = await checkDependencies(config, status.agentData.dependencies);
+            await downloadDependenciesRecursively(config, nestedStatuses, visited);
+        }
+    }
+}
+async function executePromptLocally(agentData, inputData, skillPrompts = [], config) {
+    const detected = await (0, llm_1.detectLlmKey)(agentData.supported_providers, config);
+    if (!detected) {
+        const providers = agentData.supported_providers.join(', ');
+        throw new errors_1.CliError(`No LLM key found. This agent requires: ${providers}\n` +
+            `Set an environment variable (e.g., OPENAI_API_KEY) or configure in web dashboard`);
+    }
+    const { provider, key, model: serverModel } = detected;
+    // Priority: server config model > agent default model > hardcoded default
+    const model = serverModel || agentData.default_models?.[provider] || (0, llm_1.getDefaultModel)(provider);
+    // Combine skill prompts with agent prompt (skills first, then agent)
+    let basePrompt = agentData.prompt || '';
+    if (skillPrompts.length > 0) {
+        basePrompt = [...skillPrompts, basePrompt].join('\n\n---\n\n');
+    }
+    // Build the prompt with input data (matches server behavior)
+    const prompt = (0, llm_1.buildPrompt)(basePrompt, inputData);
+    // Call the LLM directly
+    const response = await (0, llm_1.callLlm)(provider, key, model, prompt, agentData.output_schema);
+    return response;
+}
+function parseSkillRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || 'v1';
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { skill: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], skill: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid skill reference. Use org/skill or skill format.');
+}
+async function loadSkillPrompts(config, skillRefs, defaultOrg) {
+    const prompts = [];
+    for (const ref of skillRefs) {
+        const parsed = parseSkillRef(ref.trim());
+        const org = parsed.org ?? defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError(`Missing org for skill: ${ref}. Use org/skill format.`);
+        }
+        // Fetch skill metadata
+        const skillMeta = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${parsed.skill}/${parsed.version}`);
+        // Verify it's a skill
+        const skillType = skillMeta.type;
+        if (skillType !== 'skill') {
+            throw new errors_1.CliError(`${org}/${parsed.skill} is not a skill (type: ${skillType || 'prompt'})`);
+        }
+        // Get the skill prompt (need to download for full content)
+        const skillData = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${parsed.skill}/${parsed.version}/download`);
+        if (!skillData.prompt) {
+            throw new errors_1.CliError(`Skill has no content: ${ref}`);
+        }
+        prompts.push(skillData.prompt);
+    }
+    return prompts;
+}
+function runCommand(command, args) {
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.spawn)(command, args, {
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: true,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            process.stdout.write(text);
+        });
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            process.stderr.write(text);
+        });
+        proc.on('close', (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+async function checkPackageInstalled(packageName) {
+    try {
+        const { code } = await runCommand('pip', ['show', packageName, '--quiet']);
+        return code === 0;
+    }
+    catch {
+        return false;
+    }
+}
+async function installCodeAgent(agentData) {
+    const installSource = agentData.pip_package || agentData.source_url;
+    if (!installSource) {
+        throw new errors_1.CliError('This code agent does not support local execution.\n' +
+            'Use `orch call` to run it on the server instead.');
+    }
+    // Check if already installed (for pip packages)
+    if (agentData.pip_package) {
+        const installed = await checkPackageInstalled(agentData.pip_package);
+        if (installed) {
+            process.stderr.write(`Package ${agentData.pip_package} already installed.\n`);
+            return;
+        }
+    }
+    process.stderr.write(`Installing ${installSource}...\n`);
+    const { code } = await runCommand('python3', ['-m', 'pip', 'install', '--quiet', installSource]);
+    if (code !== 0) {
+        throw new errors_1.CliError(`Failed to install agent. Exit code: ${code}`);
+    }
+    process.stderr.write(`Installation complete.\n`);
+}
+async function executeCodeAgent(agentData, args) {
+    if (!agentData.run_command) {
+        throw new errors_1.CliError('This code agent does not have a run command defined.\n' +
+            'Use `orch call` to run it on the server instead.');
+    }
+    // Install the agent if needed
+    await installCodeAgent(agentData);
+    // Parse the run command and append user args
+    const [cmd, ...cmdArgs] = agentData.run_command.split(' ');
+    const fullArgs = [...cmdArgs, ...args];
+    process.stderr.write(`\nRunning: ${cmd} ${fullArgs.join(' ')}\n\n`);
+    const { code } = await runCommand(cmd, fullArgs);
+    if (code !== 0) {
+        process.exit(code);
+    }
+}
+async function saveAgentLocally(org, agent, agentData) {
+    const agentDir = path_1.default.join(AGENTS_DIR, org, agent);
+    await promises_1.default.mkdir(agentDir, { recursive: true });
+    // Save metadata
+    await promises_1.default.writeFile(path_1.default.join(agentDir, 'agent.json'), JSON.stringify(agentData, null, 2));
+    // For prompt agents, save the prompt
+    if (agentData.type === 'prompt' && agentData.prompt) {
+        await promises_1.default.writeFile(path_1.default.join(agentDir, 'prompt.md'), agentData.prompt);
+    }
+    // For code agents, save files if provided
+    if (agentData.files) {
+        for (const file of agentData.files) {
+            const filePath = path_1.default.join(agentDir, file.path);
+            await promises_1.default.mkdir(path_1.default.dirname(filePath), { recursive: true });
+            await promises_1.default.writeFile(filePath, file.content);
+        }
+    }
+    return agentDir;
+}
+function registerRunCommand(program) {
+    program
+        .command('run <agent> [args...]')
+        .description('Download and run an agent locally')
+        .option('--local', 'Run locally using local LLM keys (default for run command)')
+        .option('--input <json>', 'JSON input data')
+        .option('--download-only', 'Just download the agent, do not execute')
+        .option('--with-deps', 'Automatically download all dependencies (skip prompt)')
+        .option('--json', 'Output raw JSON')
+        .option('--skills <skills>', 'Add skills (comma-separated)')
+        .option('--skills-only <skills>', 'Use only these skills')
+        .option('--no-skills', 'Ignore default skills')
+        .action(async (agentRef, args, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        const parsed = parseAgentRef(agentRef);
+        const org = parsed.org ?? resolved.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent format.');
+        }
+        // Download agent definition
+        process.stderr.write(`Downloading ${org}/${parsed.agent}@${parsed.version}...\n`);
+        let agentData;
+        try {
+            agentData = await downloadAgent(resolved, org, parsed.agent, parsed.version);
+        }
+        catch (err) {
+            // Fall back to getting public agent info if download endpoint not available
+            const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
+            agentData = {
+                type: agentMeta.type || 'code',
+                name: agentMeta.name,
+                version: agentMeta.version,
+                description: agentMeta.description || undefined,
+                supported_providers: agentMeta.supported_providers || ['any'],
+            };
+        }
+        // Check for dependencies (orchestrator agents)
+        if (agentData.dependencies && agentData.dependencies.length > 0) {
+            process.stderr.write(`\nChecking dependencies...\n`);
+            const depStatuses = await checkDependencies(resolved, agentData.dependencies);
+            let choice;
+            if (options.withDeps) {
+                // Auto-download deps without prompting
+                choice = 'local';
+            }
+            else {
+                choice = await promptUserForDeps(depStatuses);
+            }
+            if (choice === 'cancel') {
+                process.stderr.write('\nCancelled.\n');
+                process.exit(0);
+            }
+            if (choice === 'server') {
+                process.stderr.write(`\nUse server execution instead:\n`);
+                process.stderr.write(`  orch call ${org}/${parsed.agent}@${parsed.version} --input '{...}'\n\n`);
+                process.exit(0);
+            }
+            // choice === 'local' - download dependencies
+            process.stderr.write(`\nDownloading dependencies...\n`);
+            await downloadDependenciesRecursively(resolved, depStatuses);
+            process.stderr.write(`\nAll dependencies downloaded.\n`);
+        }
+        // Save locally
+        const agentDir = await saveAgentLocally(org, parsed.agent, agentData);
+        process.stderr.write(`\nAgent saved to: ${agentDir}\n`);
+        if (agentData.type === 'code') {
+            // Check if this agent supports local execution
+            if (agentData.run_command && (agentData.source_url || agentData.pip_package)) {
+                if (options.downloadOnly) {
+                    process.stdout.write(`\nCode agent ready for local execution.\n`);
+                    process.stdout.write(`Run with: orch run ${org}/${parsed.agent} [args...]\n`);
+                    return;
+                }
+                // Execute the code agent locally
+                await executeCodeAgent(agentData, args);
+                return;
+            }
+            // Fallback: agent doesn't support local execution
+            process.stdout.write(`\nThis is a code-based agent that runs on the server.\n`);
+            process.stdout.write(`\nUse: orch call ${org}/${parsed.agent}@${parsed.version} --input '{...}'\n`);
+            return;
+        }
+        if (options.downloadOnly) {
+            process.stdout.write(`\nAgent downloaded. Run with:\n`);
+            process.stdout.write(`  orchagent run ${org}/${parsed.agent}@${parsed.version} --input '{...}'\n`);
+            return;
+        }
+        // For prompt-based agents, execute locally
+        if (!options.input) {
+            process.stdout.write(`\nPrompt-based agent ready.\n`);
+            process.stdout.write(`Run with: orchagent run ${org}/${parsed.agent}@${parsed.version} --input '{...}'\n`);
+            return;
+        }
+        // Parse input
+        let inputData;
+        try {
+            inputData = JSON.parse(options.input);
+        }
+        catch {
+            throw new errors_1.CliError('Invalid JSON input');
+        }
+        // Handle skill composition
+        let skillPrompts = [];
+        if (!options.noSkills) {
+            const skillRefs = [];
+            if (options.skillsOnly) {
+                // Use only the specified skills (ignore defaults)
+                skillRefs.push(...options.skillsOnly.split(',').map((s) => s.trim()));
+            }
+            else {
+                // Start with agent's default skills (if any)
+                const defaultSkills = agentData.default_skills || [];
+                skillRefs.push(...defaultSkills);
+                // Add any additional skills specified via --skills
+                if (options.skills) {
+                    skillRefs.push(...options.skills.split(',').map((s) => s.trim()));
+                }
+            }
+            if (skillRefs.length > 0) {
+                process.stderr.write(`Loading ${skillRefs.length} skill(s)...\n`);
+                skillPrompts = await loadSkillPrompts(resolved, skillRefs, org);
+            }
+        }
+        // Execute locally
+        process.stderr.write(`Executing locally...\n\n`);
+        const result = await executePromptLocally(agentData, inputData, skillPrompts, resolved);
+        if (options.json) {
+            (0, output_1.printJson)(result);
+        }
+        else {
+            (0, output_1.printJson)(result);
+        }
+    });
+}