@orchagent/cli 0.2.2 → 0.2.4

package/dist/commands/run.js

@@ -266,6 +266,183 @@ async function executeCodeAgent(agentData, args) {
         process.exit(code);
     }
 }
+async function unzipBundle(zipPath, destDir) {
+    // Use spawn with array arguments to avoid shell injection
+    return new Promise((resolve, reject) => {
+        const proc = (0, child_process_1.spawn)('unzip', ['-q', zipPath, '-d', destDir], {
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        let stderr = '';
+        proc.stderr?.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            if (code !== 0) {
+                reject(new errors_1.CliError(`Failed to extract bundle: ${stderr || `exit code ${code}`}`));
+            }
+            else {
+                resolve();
+            }
+        });
+        proc.on('error', (err) => {
+            reject(new errors_1.CliError(`Failed to run unzip: ${err.message}. Make sure unzip is installed.`));
+        });
+    });
+}
+async function executeBundleAgent(config, org, agentName, version, agentData, args) {
+    // Create temp directory for the bundle
+    const tempDir = path_1.default.join(os_1.default.tmpdir(), `orchagent-${agentName}-${Date.now()}`);
+    await promises_1.default.mkdir(tempDir, { recursive: true });
+    const bundleZip = path_1.default.join(tempDir, 'bundle.zip');
+    const extractDir = path_1.default.join(tempDir, 'agent');
+    try {
+        // Download the bundle
+        process.stderr.write(`Downloading bundle...\n`);
+        const bundleBuffer = await (0, api_1.downloadCodeBundle)(config, org, agentName, version);
+        await promises_1.default.writeFile(bundleZip, bundleBuffer);
+        process.stderr.write(`Bundle downloaded (${bundleBuffer.length} bytes)\n`);
+        // Extract the bundle
+        await promises_1.default.mkdir(extractDir, { recursive: true });
+        process.stderr.write(`Extracting bundle...\n`);
+        await unzipBundle(bundleZip, extractDir);
+        // Check if requirements.txt exists and install dependencies
+        const requirementsPath = path_1.default.join(extractDir, 'requirements.txt');
+        try {
+            await promises_1.default.access(requirementsPath);
+            process.stderr.write(`Installing dependencies from requirements.txt...\n`);
+            const { code } = await runCommand('python3', ['-m', 'pip', 'install', '-q', '-r', requirementsPath]);
+            if (code !== 0) {
+                throw new errors_1.CliError('Failed to install dependencies from requirements.txt');
+            }
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            // requirements.txt doesn't exist, skip installation
+        }
+        // Determine entrypoint
+        const entrypoint = agentData.entrypoint || 'sandbox_main.py';
+        const entrypointPath = path_1.default.join(extractDir, entrypoint);
+        // Verify entrypoint exists
+        try {
+            await promises_1.default.access(entrypointPath);
+        }
+        catch {
+            throw new errors_1.CliError(`Entrypoint not found: ${entrypoint}`);
+        }
+        // Build input JSON from args
+        // The first arg should be the input (file path or JSON string)
+        let inputJson = '{}';
+        if (args.length > 0) {
+            const firstArg = args[0];
+            // Check if it's a file path
+            try {
+                const stat = await promises_1.default.stat(firstArg);
+                if (stat.isFile()) {
+                    // Read file content as input
+                    const fileContent = await promises_1.default.readFile(firstArg, 'utf-8');
+                    // Check if it's already JSON
+                    try {
+                        JSON.parse(fileContent);
+                        inputJson = fileContent;
+                    }
+                    catch {
+                        // Wrap as file_path in JSON
+                        inputJson = JSON.stringify({ file_path: firstArg });
+                    }
+                }
+                else if (stat.isDirectory()) {
+                    // Pass directory path
+                    inputJson = JSON.stringify({ directory: firstArg });
+                }
+            }
+            catch {
+                // Not a file, check if it's JSON
+                try {
+                    JSON.parse(firstArg);
+                    inputJson = firstArg;
+                }
+                catch {
+                    // Treat as a simple string input
+                    inputJson = JSON.stringify({ input: firstArg });
+                }
+            }
+        }
+        // Run the entrypoint with input via stdin
+        process.stderr.write(`\nRunning: python3 ${entrypoint}\n\n`);
+        const proc = (0, child_process_1.spawn)('python3', [entrypointPath], {
+            cwd: extractDir,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        // Send input JSON via stdin
+        proc.stdin.write(inputJson);
+        proc.stdin.end();
+        // Collect output
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+        });
+        proc.stderr?.on('data', (data) => {
+            const text = data.toString();
+            stderr += text;
+            process.stderr.write(text);
+        });
+        const exitCode = await new Promise((resolve) => {
+            proc.on('close', (code) => {
+                resolve(code ?? 1);
+            });
+            proc.on('error', (err) => {
+                process.stderr.write(`Error running agent: ${err.message}\n`);
+                resolve(1);
+            });
+        });
+        // Handle output - check for errors in stdout even on failure
+        if (stdout.trim()) {
+            try {
+                const result = JSON.parse(stdout.trim());
+                // Check if it's an error response
+                if (exitCode !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
+                    throw new errors_1.CliError(`Agent error: ${result.error}`);
+                }
+                if (exitCode !== 0) {
+                    // Non-zero exit but output isn't an error object - show it and fail
+                    (0, output_1.printJson)(result);
+                    throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
+                }
+                // Success - print result
+                (0, output_1.printJson)(result);
+            }
+            catch (err) {
+                if (err instanceof errors_1.CliError)
+                    throw err;
+                // Not JSON, print as-is
+                process.stdout.write(stdout);
+                if (exitCode !== 0) {
+                    throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
+                }
+            }
+        }
+        else if (exitCode !== 0) {
+            // No stdout, check stderr
+            if (stderr.trim()) {
+                throw new errors_1.CliError(`Agent error: ${stderr.trim()}`);
+            }
+            throw new errors_1.CliError(`Agent exited with code ${exitCode} (no output)`);
+        }
+    }
+    finally {
+        // Clean up temp directory
+        try {
+            await promises_1.default.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    }
+}
 async function saveAgentLocally(org, agent, agentData) {
     const agentDir = path_1.default.join(AGENTS_DIR, org, agent);
     await promises_1.default.mkdir(agentDir, { recursive: true });
@@ -351,7 +528,18 @@ function registerRunCommand(program) {
         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
+            // Check if this agent has a bundle available for local execution
+            if (agentData.has_bundle) {
+                if (options.downloadOnly) {
+                    process.stdout.write(`\nCode agent has bundle available for local execution.\n`);
+                    process.stdout.write(`Run with: orch run ${org}/${parsed.agent} [args...]\n`);
+                    return;
+                }
+                // Execute the bundle-based code agent locally
+                await executeBundleAgent(resolved, org, parsed.agent, parsed.version, agentData, args);
+                return;
+            }
+            // Check for pip/source-based local execution (legacy)
             if (agentData.run_command && (agentData.source_url || agentData.pip_package)) {
                 if (options.downloadOnly) {
                     process.stdout.write(`\nCode agent ready for local execution.\n`);

package/dist/lib/api.js

@@ -47,6 +47,7 @@ exports.unstarAgent = unstarAgent;
 exports.forkAgent = forkAgent;
 exports.searchAgents = searchAgents;
 exports.fetchLlmKeys = fetchLlmKeys;
+exports.downloadCodeBundle = downloadCodeBundle;
 exports.uploadCodeBundle = uploadCodeBundle;
 class ApiError extends Error {
     status;
@@ -151,6 +152,17 @@ async function fetchLlmKeys(config) {
     const result = await request(config, 'GET', '/llm-keys/export');
     return result.keys;
 }
+/**
+ * Download a code bundle for local execution.
+ */
+async function downloadCodeBundle(config, org, agent, version) {
+    const response = await fetch(`${config.apiUrl.replace(/\/$/, '')}/public/agents/${org}/${agent}/${version}/bundle`);
+    if (!response.ok) {
+        throw await parseError(response);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    return Buffer.from(arrayBuffer);
+}
 /**
  * Upload a code bundle for a hosted code agent.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orchagent/cli",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Command-line interface for the OrchAgent AI agent marketplace",
   "license": "MIT",
   "author": "OrchAgent <hello@orchagent.io>",