@orchagent/cli 0.3.44 → 0.3.46

package/dist/commands/info.js

@@ -49,49 +49,27 @@ async function fetchReadme(url) {
         return null;
     }
 }
-async function downloadAgentWithFallback(config, org, agent, version) {
-    // First fetch public metadata to get pricing fields
-    let publicMeta = null;
+async function getAgentInfo(config, org, agent, version) {
+    // Use public metadata endpoint as primary source — never blocked by download restrictions
     try {
-        publicMeta = await (0, api_1.getPublicAgent)(config, org, agent, version);
+        const publicMeta = await (0, api_1.getPublicAgent)(config, org, agent, version);
+        const meta = publicMeta;
+        return {
+            type: (publicMeta.type || 'tool'),
+            name: publicMeta.name,
+            version: publicMeta.version,
+            description: (publicMeta.description ?? undefined),
+            supported_providers: publicMeta.supported_providers || ['any'],
+            input_schema: publicMeta.input_schema,
+            output_schema: publicMeta.output_schema,
+            source_url: meta.source_url,
+            run_command: meta.run_command,
+            url: meta.url,
+            pricing_mode: publicMeta.pricing_mode,
+            price_per_call_cents: publicMeta.price_per_call_cents,
+        };
     }
     catch (err) {
-        // If public metadata not found, continue to try download
-        if (!(err instanceof api_1.ApiError) || err.status !== 404) {
-            // Some other error, rethrow
-            throw err;
-        }
-    }
-    // Try public download endpoint
-    try {
-        const downloadData = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
-        // Merge pricing fields from publicMeta if not present
-        if (publicMeta && !downloadData.pricing_mode) {
-            downloadData.pricing_mode = publicMeta.pricing_mode;
-            downloadData.price_per_call_cents = publicMeta.price_per_call_cents;
-        }
-        return downloadData;
-    }
-    catch (err) {
-        // Handle 403 PAID_AGENT_SERVER_ONLY error
-        if (err instanceof api_1.ApiError && err.status === 403) {
-            const payload = err.payload;
-            if (payload?.error?.code === 'PAID_AGENT_SERVER_ONLY') {
-                // For non-owners, use public metadata
-                if (publicMeta) {
-                    return {
-                        type: publicMeta.type,
-                        name: publicMeta.name,
-                        version: publicMeta.version,
-                        description: publicMeta.description,
-                        supported_providers: publicMeta.supported_providers || ['any'],
-                        source_url: publicMeta.source_url,
-                        pricing_mode: publicMeta.pricing_mode,
-                        price_per_call_cents: publicMeta.price_per_call_cents,
-                    };
-                }
-            }
-        }
         if (!(err instanceof api_1.ApiError) || err.status !== 404)
             throw err;
     }
@@ -103,7 +81,6 @@ async function downloadAgentWithFallback(config, org, agent, version) {
     if (userOrg.slug !== org) {
         throw new api_1.ApiError(`Agent '${org}/${agent}@${version}' not found`, 404);
     }
-    // Find agent in user's list and construct download data
     const agents = await (0, api_1.listMyAgents)(config);
     const matching = agents.filter(a => a.name === agent);
     if (matching.length === 0) {
@@ -118,10 +95,8 @@ async function downloadAgentWithFallback(config, org, agent, version) {
         targetAgent = found;
     }
     else {
-        // Get most recent
         targetAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
     }
-    // Convert Agent to AgentDownload format
     return {
         type: targetAgent.type,
         name: targetAgent.name,
@@ -134,7 +109,6 @@ async function downloadAgentWithFallback(config, org, agent, version) {
         source_url: targetAgent.source_url,
         run_command: targetAgent.run_command,
         url: targetAgent.url,
-        sdk_compatible: false,
         pricing_mode: targetAgent.pricing_mode,
         price_per_call_cents: targetAgent.price_per_call_cents,
     };
@@ -148,7 +122,7 @@ function registerInfoCommand(program) {
         const config = await (0, config_1.getResolvedConfig)();
         const { org, agent, version } = (0, agent_ref_1.parseAgentRef)(agentArg);
         // Fetch agent metadata
-        const agentData = await downloadAgentWithFallback(config, org, agent, version);
+        const agentData = await getAgentInfo(config, org, agent, version);
         if (options.json) {
             // Don't expose internal routing URLs in JSON output
             const output = { ...agentData };

package/dist/commands/init.js

@@ -124,27 +124,13 @@ const AGENT_MANIFEST_TEMPLATE = `{
   "description": "An AI agent with tool use",
   "type": "agent",
   "supported_providers": ["anthropic"],
-  "max_turns": 25,
-  "custom_tools": [
-    {
-      "name": "run_tests",
-      "description": "Run the test suite",
-      "command": "pytest"
-    }
-  ]
+  "max_turns": 25
 }
 `;
-const AGENT_PROMPT_TEMPLATE = `You are a helpful AI agent with access to a sandboxed environment.
+const AGENT_PROMPT_TEMPLATE = `You are a helpful AI agent.
 
-Given the input, complete the task using the available tools:
-- Use bash to run commands
-- Use read_file and write_file to work with files
-- Use custom tools defined by the agent author
-- Call submit_result when you're done
-
-Input: The caller's input will be provided as JSON.
-
-Work step by step, verify your results, and submit the final output.
+Given the input, complete the task step by step.
+Verify your results before submitting.
 `;
 const AGENT_SCHEMA_TEMPLATE = `{
   "input": {
@@ -287,9 +273,8 @@ function registerInitCommand(program) {
                 process.stdout.write(`  1. cd ${name}\n`);
             }
             process.stdout.write(`  ${stepNum}. Edit prompt.md with your agent instructions\n`);
-            process.stdout.write(`  ${stepNum + 1}. Edit custom_tools in orchagent.json for your environment\n`);
-            process.stdout.write(`  ${stepNum + 2}. Edit schema.json with your input/output schemas\n`);
-            process.stdout.write(`  ${stepNum + 3}. Run: orchagent publish\n`);
+            process.stdout.write(`  ${stepNum + 1}. Edit schema.json with your input/output schemas\n`);
+            process.stdout.write(`  ${stepNum + 2}. Run: orchagent publish\n`);
         }
         else if (options.type !== 'tool') {
             const stepNum = name ? 2 : 1;

package/dist/commands/publish.js

@@ -309,6 +309,16 @@ function registerPublishCommand(program) {
         if (!manifest.name) {
             throw new errors_1.CliError('orchagent.json must have name');
         }
+        // Warn about deprecated fields that are ignored
+        if (manifest.prompt) {
+            process.stderr.write(chalk_1.default.yellow('Warning: "prompt" field in orchagent.json is ignored. Use prompt.md file instead.\n'));
+        }
+        if (manifest.input_schema) {
+            process.stderr.write(chalk_1.default.yellow('Warning: "input_schema" field in orchagent.json is ignored. Use schema.json file instead.\n'));
+        }
+        if (manifest.output_schema) {
+            process.stderr.write(chalk_1.default.yellow('Warning: "output_schema" field in orchagent.json is ignored. Use schema.json file instead.\n'));
+        }
         // Check for misplaced manifest fields at top level (common user error)
         const manifestFields = ['manifest_version', 'dependencies', 'max_hops', 'timeout_ms', 'per_call_downstream_cap'];
         const misplacedFields = manifestFields.filter(f => f in manifest && !manifest.manifest);

package/dist/commands/run.js

@@ -74,6 +74,18 @@ function parseAgentRef(value) {
     }
     throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
 }
+// ─── Validation helpers ─────────────────────────────────────────────────────
+async function validateFilePath(filePath) {
+    const stat = await promises_1.default.stat(filePath);
+    if (stat.isDirectory()) {
+        throw new errors_1.CliError(`Cannot upload a directory for cloud execution: ${filePath}\n\n` +
+            `Options:\n` +
+            `  Use --local to run locally with filesystem access:\n` +
+            `    orch run <agent> --local --path ${filePath}\n` +
+            `  Or specify individual files:\n` +
+            `    orch run <agent> --file ${filePath}/specific-file.ts`);
+    }
+}
 // ─── Cloud execution helpers (from call.ts) ─────────────────────────────────
 function findLocalPathKey(obj) {
     if (typeof obj !== 'object' || obj === null) {
@@ -124,6 +136,19 @@ function inferFileField(inputSchema) {
         return requiredStrings[0];
     return 'content';
 }
+function applySchemaDefaults(body, schema) {
+    if (!schema)
+        return body;
+    const props = schema.properties;
+    if (!props || typeof props !== 'object')
+        return body;
+    for (const [key, def] of Object.entries(props)) {
+        if (body[key] === undefined && def.default !== undefined) {
+            body[key] = def.default;
+        }
+    }
+    return body;
+}
 async function readStdin() {
     if (process.stdin.isTTY)
         return null;
@@ -155,6 +180,7 @@ async function buildMultipartBody(filePaths, metadata) {
     }
     const form = new FormData();
     for (const filePath of filePaths) {
+        await validateFilePath(filePath);
         const buffer = await promises_1.default.readFile(filePath);
         const filename = path_1.default.basename(filePath);
         form.append('files[]', new Blob([new Uint8Array(buffer)]), filename);
@@ -182,6 +208,7 @@ async function resolveJsonBody(input) {
             raw = stdinData.toString('utf8');
         }
         else {
+            await validateFilePath(source);
             raw = await promises_1.default.readFile(source, 'utf8');
         }
     }
@@ -857,6 +884,224 @@ async function saveBundleLocally(config, org, agent, version, agentId) {
     }
     return bundleDir;
 }
+// ─── Local directory execution ───────────────────────────────────────────────
+function isLocalPath(ref) {
+    return ref.startsWith('.') || ref.startsWith('/') || ref.startsWith('~');
+}
+async function executeLocalFromDir(dirPath, args, options) {
+    // Merge --data alias into --input
+    if (options.data && !options.input) {
+        options.input = options.data;
+    }
+    if (options.here) {
+        options.input = JSON.stringify({ path: process.cwd() });
+    }
+    else if (options.path) {
+        options.input = JSON.stringify({ path: options.path });
+    }
+    const resolved = path_1.default.resolve(dirPath);
+    // Verify directory exists
+    let stat;
+    try {
+        stat = await promises_1.default.stat(resolved);
+    }
+    catch {
+        throw new errors_1.CliError(`Directory not found: ${resolved}`);
+    }
+    if (!stat.isDirectory()) {
+        throw new errors_1.CliError(`Not a directory: ${resolved}`);
+    }
+    // Read orchagent.json manifest
+    const manifestPath = path_1.default.join(resolved, 'orchagent.json');
+    let manifest;
+    try {
+        const raw = await promises_1.default.readFile(manifestPath, 'utf-8');
+        manifest = JSON.parse(raw);
+    }
+    catch {
+        throw new errors_1.CliError(`No orchagent.json found in ${resolved}\n\n` +
+            `To run a local agent, the directory must contain orchagent.json.\n` +
+            `Create one with: orch init`);
+    }
+    const agentType = manifest.type || 'tool';
+    if (agentType === 'skill') {
+        throw new errors_1.CliError('Skills cannot be run directly.\n\n' +
+            'Skills are instructions meant to be injected into AI agent contexts.\n' +
+            `Install with: orchagent skill install <org>/<skill>`);
+    }
+    if (agentType === 'agent') {
+        throw new errors_1.CliError('Agent type cannot be run locally.\n\n' +
+            'Agent type requires a sandbox environment with tool use capabilities.\n' +
+            'Publish first, then run in the cloud:\n' +
+            '  orch publish && orch run <org>/<agent> --data \'{"task": "..."}\'');
+    }
+    if (agentType === 'prompt') {
+        // Read prompt.md
+        const promptPath = path_1.default.join(resolved, 'prompt.md');
+        let prompt;
+        try {
+            prompt = await promises_1.default.readFile(promptPath, 'utf-8');
+        }
+        catch {
+            throw new errors_1.CliError(`No prompt.md found in ${resolved}`);
+        }
+        // Read schema.json for schemas
+        let inputSchema;
+        let outputSchema;
+        try {
+            const schemaRaw = await promises_1.default.readFile(path_1.default.join(resolved, 'schema.json'), 'utf-8');
+            const schemas = JSON.parse(schemaRaw);
+            inputSchema = schemas.input;
+            outputSchema = schemas.output;
+        }
+        catch {
+            // Schema is optional
+        }
+        // Build AgentDownload from local files
+        const agentData = {
+            type: 'prompt',
+            name: manifest.name || path_1.default.basename(resolved),
+            version: manifest.version || 'local',
+            description: manifest.description,
+            prompt,
+            input_schema: inputSchema,
+            output_schema: outputSchema,
+            supported_providers: manifest.supported_providers || ['any'],
+            default_models: manifest.default_models,
+        };
+        if (!options.input) {
+            process.stderr.write(`Loaded local agent: ${agentData.name}\n\n`);
+            process.stderr.write(`Run with input:\n`);
+            process.stderr.write(`  orch run ${dirPath} --local --data '{...}'\n`);
+            return;
+        }
+        let inputData;
+        try {
+            inputData = JSON.parse(options.input);
+        }
+        catch {
+            throw new errors_1.CliError('Invalid JSON input');
+        }
+        const config = await (0, config_1.getResolvedConfig)();
+        const result = await executePromptLocally(agentData, inputData, [], config, options.provider, options.model);
+        (0, output_1.printJson)(result);
+        return;
+    }
+    // Tool agents with bundle
+    const entrypoint = manifest.entrypoint || 'sandbox_main.py';
+    const entrypointPath = path_1.default.join(resolved, entrypoint);
+    try {
+        await promises_1.default.access(entrypointPath);
+    }
+    catch {
+        // No local entrypoint — try run_command
+        if (manifest.run_command) {
+            const agentData = {
+                type: 'tool',
+                name: manifest.name || path_1.default.basename(resolved),
+                version: manifest.version || 'local',
+                supported_providers: manifest.supported_providers || ['any'],
+                run_command: manifest.run_command,
+                source_url: manifest.source_url,
+                pip_package: manifest.pip_package,
+            };
+            await executeTool(agentData, args);
+            return;
+        }
+        throw new errors_1.CliError(`No entrypoint found in ${resolved}\n\n` +
+            `Expected: ${entrypoint}\n` +
+            `For tool agents, ensure the directory contains the entrypoint file\n` +
+            `or has run_command set in orchagent.json.`);
+    }
+    // Execute bundle-style from local directory
+    const config = await (0, config_1.getResolvedConfig)();
+    const agentData = {
+        type: 'tool',
+        name: manifest.name || path_1.default.basename(resolved),
+        version: manifest.version || 'local',
+        supported_providers: manifest.supported_providers || ['any'],
+        entrypoint,
+    };
+    // Install requirements if present
+    const requirementsPath = path_1.default.join(resolved, 'requirements.txt');
+    try {
+        await promises_1.default.access(requirementsPath);
+        const { code } = await runCommand('python3', ['-m', 'pip', 'install', '-q', '--disable-pip-version-check', '-r', requirementsPath]);
+        if (code !== 0) {
+            process.stderr.write('Warning: Failed to install requirements.txt\n');
+        }
+    }
+    catch {
+        // No requirements.txt
+    }
+    let inputJson = '{}';
+    if (options.input) {
+        try {
+            JSON.parse(options.input);
+            inputJson = options.input;
+        }
+        catch {
+            throw new errors_1.CliError('Invalid JSON input');
+        }
+    }
+    else if (args.length > 0) {
+        inputJson = JSON.stringify({ input: args[0] });
+    }
+    process.stderr.write(`\nRunning: python3 ${entrypoint}\n\n`);
+    const subprocessEnv = { ...process.env };
+    if (config.apiKey) {
+        subprocessEnv.ORCHAGENT_SERVICE_KEY = config.apiKey;
+        subprocessEnv.ORCHAGENT_API_URL = config.apiUrl;
+    }
+    const proc = (0, child_process_1.spawn)('python3', [entrypointPath], {
+        cwd: resolved,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: subprocessEnv,
+    });
+    proc.stdin.write(inputJson);
+    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;
+        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);
+        });
+    });
+    if (stdout.trim()) {
+        try {
+            const result = JSON.parse(stdout.trim());
+            if (exitCode !== 0 && typeof result === 'object' && result !== null && 'error' in result) {
+                throw new errors_1.CliError(`Agent error: ${result.error}`);
+            }
+            if (exitCode !== 0) {
+                (0, output_1.printJson)(result);
+                throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
+            }
+            (0, output_1.printJson)(result);
+        }
+        catch (err) {
+            if (err instanceof errors_1.CliError)
+                throw err;
+            process.stdout.write(stdout);
+            if (exitCode !== 0) {
+                throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
+            }
+        }
+    }
+    else if (exitCode !== 0) {
+        throw new errors_1.CliError(`Agent exited with code ${exitCode}`);
+    }
+}
 // ─── Cloud execution path ───────────────────────────────────────────────────
 async function executeCloud(agentRef, file, options) {
     // Merge --input alias into --data
@@ -1012,10 +1257,58 @@ async function executeCloud(agentRef, file, options) {
         ...(options.file ?? []),
         ...(file ? [file] : []),
     ];
-    if (options.data) {
-        if (filePaths.length > 0 || options.metadata) {
-            throw new errors_1.CliError('Cannot use --data with file uploads or --metadata.');
+    if (options.data && options.metadata) {
+        throw new errors_1.CliError('Cannot use --data with --metadata. Use one or the other.');
+    }
+    if (options.data && filePaths.length > 0) {
+        // Merge file content into --data
+        const resolvedBody = await resolveJsonBody(options.data);
+        const bodyObj = JSON.parse(resolvedBody);
+        if (agentMeta.type === 'prompt') {
+            const fieldName = options.fileField || inferFileField(agentMeta.input_schema);
+            if (filePaths.length === 1) {
+                await validateFilePath(filePaths[0]);
+                bodyObj[fieldName] = await promises_1.default.readFile(filePaths[0], 'utf-8');
+                sourceLabel = filePaths[0];
+            }
+            else {
+                const allContents = {};
+                for (const fp of filePaths) {
+                    await validateFilePath(fp);
+                    allContents[path_1.default.basename(fp)] = await promises_1.default.readFile(fp, 'utf-8');
+                }
+                bodyObj[fieldName] = await promises_1.default.readFile(filePaths[0], 'utf-8');
+                bodyObj.files = allContents;
+                sourceLabel = `${filePaths.length} files`;
+            }
+            // Auto-populate filename if schema has it and user didn't provide it
+            if (filePaths.length >= 1 && bodyObj.filename === undefined) {
+                const schema = agentMeta.input_schema;
+                const schemaProps = schema?.properties;
+                if (schemaProps?.filename) {
+                    bodyObj.filename = path_1.default.basename(filePaths[0]);
+                }
+            }
+            applySchemaDefaults(bodyObj, agentMeta.input_schema);
+            if (llmCredentials)
+                bodyObj.llm_credentials = llmCredentials;
+            body = JSON.stringify(bodyObj);
+            headers['Content-Type'] = 'application/json';
+        }
+        else {
+            // Tool agents: send files as multipart, --data as metadata
+            let metadata = resolvedBody;
+            if (llmCredentials) {
+                const metaObj = JSON.parse(metadata);
+                metaObj.llm_credentials = llmCredentials;
+                metadata = JSON.stringify(metaObj);
+            }
+            const multipart = await buildMultipartBody(filePaths, metadata);
+            body = multipart.body;
+            sourceLabel = multipart.sourceLabel;
         }
+    }
+    else if (options.data) {
         const resolvedBody = await resolveJsonBody(options.data);
         warnIfLocalPathReference(resolvedBody);
         if (llmCredentials) {
@@ -1040,6 +1333,7 @@ async function executeCloud(agentRef, file, options) {
             }
         }
         if (filePaths.length === 1) {
+            await validateFilePath(filePaths[0]);
             const fileContent = await promises_1.default.readFile(filePaths[0], 'utf-8');
             bodyObj[fieldName] = fileContent;
             sourceLabel = filePaths[0];
@@ -1047,6 +1341,7 @@ async function executeCloud(agentRef, file, options) {
         else if (filePaths.length > 1) {
             const allContents = {};
             for (const fp of filePaths) {
+                await validateFilePath(fp);
                 allContents[path_1.default.basename(fp)] = await promises_1.default.readFile(fp, 'utf-8');
             }
             const firstContent = await promises_1.default.readFile(filePaths[0], 'utf-8');
@@ -1054,6 +1349,15 @@ async function executeCloud(agentRef, file, options) {
             bodyObj.files = allContents;
             sourceLabel = `${filePaths.length} files`;
         }
+        // Auto-populate filename if schema has it and user didn't provide it
+        if (filePaths.length >= 1 && bodyObj.filename === undefined) {
+            const schema = agentMeta.input_schema;
+            const schemaProps = schema?.properties;
+            if (schemaProps?.filename) {
+                bodyObj.filename = path_1.default.basename(filePaths[0]);
+            }
+        }
+        applySchemaDefaults(bodyObj, agentMeta.input_schema);
         if (llmCredentials) {
             bodyObj.llm_credentials = llmCredentials;
         }
@@ -1139,6 +1443,12 @@ async function executeCloud(agentRef, file, options) {
                 payload.message ||
                 response.statusText
             : response.statusText;
+        if (response.status >= 500) {
+            spinner?.fail(`Server error (${response.status})`);
+            throw new errors_1.CliError(`${message}\n\n` +
+                `This is a server-side error. Try again in a moment.\n` +
+                `If it persists, check the dashboard for run logs or try a different provider.`);
+        }
         spinner?.fail(`Run failed: ${message}`);
         throw new errors_1.CliError(message);
     }
@@ -1413,7 +1723,12 @@ contains keys like 'path', 'directory', 'file', etc., those values will be inter
 by the server, not your local machine. To use local files, use --local or --file.
 `)
         .action(async (agentRef, file, options) => {
-        if (options.local) {
+        if (options.local && isLocalPath(agentRef)) {
+            // Local directory execution (e.g., orch run . --local)
+            const args = file ? [file] : [];
+            await executeLocalFromDir(agentRef, args, options);
+        }
+        else if (options.local) {
             // Local execution: file arg becomes first positional arg
             const args = file ? [file] : [];
             await executeLocal(agentRef, args, options);

package/dist/commands/skill.js

@@ -48,6 +48,10 @@ const installed_1 = require("../lib/installed");
 const pricing_1 = require("../lib/pricing");
 const package_json_1 = __importDefault(require("../../package.json"));
 const DEFAULT_VERSION = 'latest';
+function stripFrontmatter(content) {
+    const match = content.match(/^---\s*\n[\s\S]*?\n---\s*\n([\s\S]*)$/);
+    return match ? match[1].trimStart() : content;
+}
 /**
  * AI tool skill directories.
  *
@@ -443,6 +447,8 @@ Instructions and guidance for AI agents...
         // Determine scope (--global is legacy alias for --scope user; then config default; then 'project')
         const scope = options.global ? 'user' : (options.scope || await (0, config_1.getDefaultScope)() || 'project');
         result.scope = scope;
+        // Strip existing YAML frontmatter from the prompt to avoid duplication
+        const cleanPrompt = stripFrontmatter(skillData.prompt);
         // Build skill content with header
         const skillContent = `# ${skillData.name}
 
@@ -450,7 +456,7 @@ ${skillData.description || ''}
 
 ---
 
-${skillData.prompt}
+${cleanPrompt}
 `;
         // Dry run - show what would be installed
         if (options.dryRun) {

package/package.json

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