@orchagent/cli 0.3.6 → 0.3.7

package/dist/commands/call.js

@@ -229,7 +229,7 @@ Note: Use 'call' for server-side execution (requires login), 'run' for local exe
             sourceLabel = multipart.sourceLabel;
         }
         const url = `${resolved.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}`;
-        const response = await (0, api_1.safeFetch)(url, {
+        const response = await (0, api_1.safeFetchWithRetryForCalls)(url, {
             method: 'POST',
             headers,
             body,

package/dist/commands/install.js

@@ -70,20 +70,50 @@ function registerInstallCommand(program) {
         .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
         .option('--scope <scope>', 'Install scope: user (home dir) or project (current dir)', 'user')
         .option('--dry-run', 'Show what would be installed without making changes')
+        .option('--json', 'Output result as JSON (for automation/tooling)')
         .action(async (agentArg, options) => {
+        const jsonMode = options.json === true;
+        const log = (msg) => { if (!jsonMode)
+            process.stdout.write(msg); };
+        const logErr = (msg) => { if (!jsonMode)
+            process.stderr.write(msg); };
+        // Result tracking for JSON output
+        const result = {
+            success: false,
+            agent: '',
+            version: '',
+            scope: '',
+            formats: [],
+            files: [],
+            warnings: [],
+            errors: [],
+        };
         const resolved = await (0, config_1.getResolvedConfig)();
         const parsed = parseAgentRef(agentArg);
         const org = parsed.org ?? resolved.defaultOrg;
         if (!org) {
+            if (jsonMode) {
+                result.errors.push('Missing org. Use org/agent format or set default org.');
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
             throw new errors_1.CliError('Missing org. Use org/agent format or set default org.');
         }
+        result.agent = `${org}/${parsed.name}`;
+        result.version = parsed.version;
         // Determine target formats
         let targetFormats = [];
         if (options.format) {
             targetFormats = options.format.split(',').map(f => f.trim());
             const invalid = targetFormats.filter(f => !adapters_1.adapterRegistry.has(f));
             if (invalid.length > 0) {
-                throw new errors_1.CliError(`Unknown format(s): ${invalid.join(', ')}. Available: ${adapters_1.adapterRegistry.getIds().join(', ')}`);
+                const errMsg = `Unknown format(s): ${invalid.join(', ')}. Available: ${adapters_1.adapterRegistry.getIds().join(', ')}`;
+                if (jsonMode) {
+                    result.errors.push(errMsg);
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                    process.exit(1);
+                }
+                throw new errors_1.CliError(errMsg);
             }
         }
         else {
@@ -96,41 +126,65 @@ function registerInstallCommand(program) {
                 targetFormats = ['claude-code'];
             }
         }
+        result.formats = targetFormats;
         // Validate scope
         let scope = options.scope;
         if (scope !== 'user' && scope !== 'project') {
-            throw new errors_1.CliError('Scope must be "user" or "project"');
+            const errMsg = 'Scope must be "user" or "project"';
+            if (jsonMode) {
+                result.errors.push(errMsg);
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
+            throw new errors_1.CliError(errMsg);
         }
+        result.scope = scope;
         // Download agent
-        process.stdout.write(`Fetching ${org}/${parsed.name}@${parsed.version}...\n`);
-        const agent = await downloadAgentWithFallback(resolved, org, parsed.name, parsed.version);
+        log(`Fetching ${org}/${parsed.name}@${parsed.version}...\n`);
+        let agent;
+        try {
+            agent = await downloadAgentWithFallback(resolved, org, parsed.name, parsed.version);
+        }
+        catch (err) {
+            if (jsonMode) {
+                result.errors.push(err instanceof Error ? err.message : String(err));
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
+            throw err;
+        }
         // Install for each format
         let filesWritten = 0;
         for (const formatId of targetFormats) {
             const adapter = adapters_1.adapterRegistry.get(formatId);
             if (!adapter) {
-                process.stderr.write(`Warning: Unknown format '${formatId}', skipping\n`);
+                const warn = `Unknown format '${formatId}', skipping`;
+                result.warnings.push(warn);
+                logErr(`Warning: ${warn}\n`);
                 continue;
             }
             // Check if can convert
             const checkResult = adapter.canConvert(agent);
             if (!checkResult.canConvert) {
-                process.stderr.write(`Cannot convert to ${adapter.name}:\n`);
+                logErr(`Cannot convert to ${adapter.name}:\n`);
                 for (const err of checkResult.errors) {
-                    process.stderr.write(`  - ${err}\n`);
+                    result.errors.push(`${adapter.name}: ${err}`);
+                    logErr(`  - ${err}\n`);
                 }
                 continue;
             }
             // Show warnings
             for (const warn of checkResult.warnings) {
-                process.stdout.write(`Warning (${formatId}): ${warn}\n`);
+                result.warnings.push(`${formatId}: ${warn}`);
+                log(`Warning (${formatId}): ${warn}\n`);
             }
             // Determine scope for this adapter (use local variable to not affect other formats)
             let effectiveScope = scope;
             const supportedScopes = adapter.installPaths.map(p => p.scope);
             if (!supportedScopes.includes(effectiveScope)) {
-                process.stderr.write(`Warning: ${adapter.name} doesn't support '${scope}' scope. ` +
-                    `Supported: ${supportedScopes.join(', ')}. Using '${supportedScopes[0]}' instead.\n`);
+                const warn = `${adapter.name} doesn't support '${scope}' scope. Using '${supportedScopes[0]}' instead.`;
+                result.warnings.push(warn);
+                logErr(`Warning: ${warn}\n`);
                 effectiveScope = supportedScopes[0];
             }
             // Convert
@@ -142,8 +196,9 @@ function registerInstallCommand(program) {
                 const fullDir = path_1.default.join(baseDir, file.installPath);
                 const fullPath = path_1.default.join(fullDir, file.filename);
                 if (options.dryRun) {
-                    process.stdout.write(`Would install: ${fullPath}\n`);
-                    process.stdout.write(`Content preview:\n${file.content.slice(0, 500)}...\n\n`);
+                    log(`Would install: ${fullPath}\n`);
+                    log(`Content preview:\n${file.content.slice(0, 500)}...\n\n`);
+                    result.files.push({ path: fullPath, format: formatId });
                     continue;
                 }
                 // Create directory and write file
@@ -174,7 +229,8 @@ function registerInstallCommand(program) {
                     contentHash: (0, installed_1.computeHash)(file.content),
                 };
                 await (0, installed_1.trackInstall)(installedAgent);
-                process.stdout.write(`Installed: ${fullPath}\n`);
+                result.files.push({ path: fullPath, format: formatId });
+                log(`Installed: ${fullPath}\n`);
             }
         }
         if (!options.dryRun) {
@@ -184,18 +240,33 @@ function registerInstallCommand(program) {
                     formats: targetFormats,
                     scope,
                 });
-                process.stdout.write(`\nAgent installed successfully!\n`);
+                result.success = true;
+                log(`\nAgent installed successfully!\n`);
                 if (scope === 'user') {
-                    process.stdout.write(`Available in all your projects.\n`);
+                    log(`Available in all your projects.\n`);
                 }
                 else {
-                    process.stdout.write(`Available in this project only.\n`);
+                    log(`Available in this project only.\n`);
                 }
             }
             else {
-                process.stderr.write(`\nNo files were installed. Check warnings above.\n`);
+                result.errors.push('No files were installed. Check warnings.');
+                logErr(`\nNo files were installed. Check warnings above.\n`);
+            }
+        }
+        else {
+            // Dry run is considered success if we got file list
+            result.success = result.files.length > 0;
+        }
+        // Output JSON result
+        if (jsonMode) {
+            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            if (!result.success) {
                 process.exit(1);
             }
         }
+        else if (!result.success && !options.dryRun) {
+            process.exit(1);
+        }
     });
 }

package/dist/commands/skill.js

@@ -164,7 +164,24 @@ Instructions and guidance for AI agents...
         .option('--scope <scope>', 'Install scope: user or project', 'project')
         .option('--dry-run', 'Show what would be installed without making changes')
         .option('--format <formats>', 'Comma-separated format IDs (e.g., claude-code,cursor)')
+        .option('--json', 'Output result as JSON (for automation/tooling)')
         .action(async (skillRef, options) => {
+        const jsonMode = options.json === true;
+        const log = (msg) => { if (!jsonMode)
+            process.stdout.write(msg); };
+        const logErr = (msg) => { if (!jsonMode)
+            process.stderr.write(msg); };
+        // Result tracking for JSON output
+        const result = {
+            success: false,
+            skill: '',
+            version: '',
+            scope: '',
+            tools: [],
+            files: [],
+            warnings: [],
+            errors: [],
+        };
         const resolved = await (0, config_1.getResolvedConfig)();
         // Determine target formats
         let targetFormats = [];
@@ -173,7 +190,13 @@ Instructions and guidance for AI agents...
             // Validate format IDs
             const invalid = targetFormats.filter(f => !config_1.VALID_FORMAT_IDS.includes(f));
             if (invalid.length > 0) {
-                throw new errors_1.CliError(`Invalid format ID(s): ${invalid.join(', ')}. Valid: ${config_1.VALID_FORMAT_IDS.join(', ')}`);
+                const errMsg = `Invalid format ID(s): ${invalid.join(', ')}. Valid: ${config_1.VALID_FORMAT_IDS.join(', ')}`;
+                if (jsonMode) {
+                    result.errors.push(errMsg);
+                    process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                    process.exit(1);
+                }
+                throw new errors_1.CliError(errMsg);
             }
         }
         else {
@@ -183,7 +206,9 @@ Instructions and guidance for AI agents...
                 targetFormats = defaults.filter(f => config_1.VALID_FORMAT_IDS.includes(f));
                 const skipped = defaults.filter(f => !config_1.VALID_FORMAT_IDS.includes(f));
                 if (skipped.length > 0) {
-                    process.stderr.write(`Note: Skipping ${skipped.join(', ')} (no skill directory)\n`);
+                    const warn = `Skipping ${skipped.join(', ')} (no skill directory)`;
+                    result.warnings.push(warn);
+                    logErr(`Note: ${warn}\n`);
                 }
             }
         }
@@ -194,17 +219,43 @@ Instructions and guidance for AI agents...
         const parsed = parseSkillRef(skillRef);
         const org = parsed.org ?? resolved.defaultOrg;
         if (!org) {
-            throw new errors_1.CliError('Missing org. Use org/skill or set default org.');
+            const errMsg = 'Missing org. Use org/skill or set default org.';
+            if (jsonMode) {
+                result.errors.push(errMsg);
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
+            throw new errors_1.CliError(errMsg);
         }
+        result.skill = `${org}/${parsed.skill}`;
+        result.version = parsed.version;
         // Download skill (tries public first, falls back to authenticated for private)
-        const skillData = await downloadSkillWithFallback(resolved, org, parsed.skill, parsed.version);
+        let skillData;
+        try {
+            skillData = await downloadSkillWithFallback(resolved, org, parsed.skill, parsed.version);
+        }
+        catch (err) {
+            if (jsonMode) {
+                result.errors.push(err instanceof Error ? err.message : String(err));
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
+            throw err;
+        }
         if (!skillData.prompt) {
+            const errMsg = 'Skill has no content. The skill exists but has an empty prompt.';
+            if (jsonMode) {
+                result.errors.push(errMsg);
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
             throw new errors_1.CliError('Skill has no content.\n\n' +
                 'The skill exists but has an empty prompt. This may be a publishing issue.\n' +
                 'Try re-publishing the skill or contact the skill author.');
         }
         // Determine scope (--global is legacy alias for --scope user)
         const scope = options.global ? 'user' : (options.scope || 'project');
+        result.scope = scope;
         // Build skill content with header
         const skillContent = `# ${skillData.name}
 
@@ -216,16 +267,21 @@ ${skillData.prompt}
 `;
         // Dry run - show what would be installed
         if (options.dryRun) {
-            process.stdout.write(`Would install ${org}/${parsed.skill}@${parsed.version}\n\n`);
-            process.stdout.write(`Target directories (scope: ${scope}):\n`);
+            log(`Would install ${org}/${parsed.skill}@${parsed.version}\n\n`);
+            log(`Target directories (scope: ${scope}):\n`);
             for (const tool of toolDirs) {
                 const baseDir = scope === 'user' ? os_1.default.homedir() : process.cwd();
                 const toolPath = scope === 'user' ? tool.userPath : tool.projectPath;
                 const skillDir = path_1.default.join(baseDir, toolPath);
                 const skillFile = path_1.default.join(skillDir, `${parsed.skill}.md`);
-                process.stdout.write(`  - ${tool.name}: ${skillFile}\n`);
+                result.files.push({ path: skillFile, tool: tool.name });
+                log(`  - ${tool.name}: ${skillFile}\n`);
+            }
+            log(`\nNo changes made (dry run)\n`);
+            result.success = true;
+            if (jsonMode) {
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
             }
-            process.stdout.write(`\nNo changes made (dry run)\n`);
             return;
         }
         // Install to target AI tool directories
@@ -239,15 +295,26 @@ ${skillData.prompt}
                 await promises_1.default.mkdir(skillDir, { recursive: true });
                 await promises_1.default.writeFile(skillFile, skillContent);
                 installed.push(tool.name);
+                result.files.push({ path: skillFile, tool: tool.name });
             }
             catch (err) {
                 // Skip if we can't write (e.g., permission issues)
-                process.stderr.write(`Warning: Could not install to ${toolPath}: ${err.message}\n`);
+                const warn = `Could not install to ${toolPath}: ${err.message}`;
+                result.warnings.push(warn);
+                logErr(`Warning: ${warn}\n`);
             }
         }
         if (installed.length === 0) {
-            throw new errors_1.CliError('Failed to install skill to any directory');
+            const errMsg = 'Failed to install skill to any directory';
+            if (jsonMode) {
+                result.errors.push(errMsg);
+                process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                process.exit(1);
+            }
+            throw new errors_1.CliError(errMsg);
         }
+        result.tools = installed;
+        result.success = true;
         await (0, analytics_1.track)('cli_skill_install', {
             skill: `${org}/${parsed.skill}`,
             scope,
@@ -257,11 +324,16 @@ ${skillData.prompt}
         if (resolved.apiKey) {
             (0, api_1.reportInstall)(resolved, org, parsed.skill, parsed.version, package_json_1.default.version).catch(() => { });
         }
-        process.stdout.write(`Installed ${org}/${parsed.skill}@${parsed.version}\n`);
-        process.stdout.write(`\nAvailable for:\n`);
-        for (const tool of installed) {
-            process.stdout.write(`  - ${tool}\n`);
+        if (jsonMode) {
+            process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+        }
+        else {
+            log(`Installed ${org}/${parsed.skill}@${parsed.version}\n`);
+            log(`\nAvailable for:\n`);
+            for (const tool of installed) {
+                log(`  - ${tool}\n`);
+            }
+            log(`\nLocation: ${scope === 'user' ? '~/' : './'}\n`);
         }
-        process.stdout.write(`\nLocation: ${scope === 'user' ? '~/' : './'}\n`);
     });
 }

package/dist/lib/api.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiError = void 0;
 exports.safeFetch = safeFetch;
+exports.safeFetchWithRetryForCalls = safeFetchWithRetryForCalls;
 exports.request = request;
 exports.publicRequest = publicRequest;
 exports.getOrg = getOrg;
@@ -60,13 +61,16 @@ exports.reportInstall = reportInstall;
 exports.fetchUserProfile = fetchUserProfile;
 const errors_1 = require("./errors");
 const DEFAULT_TIMEOUT_MS = 15000;
+const CALL_TIMEOUT_MS = 120000; // 2 minutes for agent calls (can take time)
 const MAX_RETRIES = 3;
 const BASE_DELAY_MS = 1000;
 async function safeFetch(url, options) {
+    const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const { timeoutMs: _, ...fetchOptions } = options ?? {};
     try {
         return await fetch(url, {
-            ...options,
-            signal: AbortSignal.timeout(DEFAULT_TIMEOUT_MS),
+            ...fetchOptions,
+            signal: AbortSignal.timeout(timeoutMs),
         });
     }
     catch (err) {
@@ -77,6 +81,44 @@ async function safeFetch(url, options) {
         throw new errors_1.NetworkError(url, err instanceof Error ? err : undefined);
     }
 }
+/**
+ * safeFetch with retry logic for connection failures.
+ * Use for important operations that should retry on transient errors.
+ */
+async function safeFetchWithRetryForCalls(url, options) {
+    let lastError;
+    const timeoutMs = options?.timeoutMs ?? CALL_TIMEOUT_MS;
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+        try {
+            const response = await safeFetch(url, { ...options, timeoutMs });
+            // Don't retry client errors (except 429)
+            if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                return response;
+            }
+            // Retry on 5xx or 429
+            if (response.status >= 500 || response.status === 429) {
+                if (attempt < MAX_RETRIES) {
+                    const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                    const jitter = Math.random() * 500;
+                    process.stderr.write(`Request failed (${response.status}), retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                    await new Promise(r => setTimeout(r, delay + jitter));
+                    continue;
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < MAX_RETRIES) {
+                const delay = BASE_DELAY_MS * Math.pow(2, attempt - 1);
+                const jitter = Math.random() * 500;
+                process.stderr.write(`Connection error, retrying in ${Math.round((delay + jitter) / 1000)}s...\n`);
+                await new Promise(r => setTimeout(r, delay + jitter));
+            }
+        }
+    }
+    throw lastError ?? new errors_1.NetworkError(url);
+}
 async function safeFetchWithRetry(url, options) {
     let lastError;
     for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {

package/package.json

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