@orchagent/cli 0.3.6 → 0.3.8

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/env.js

@@ -0,0 +1,245 @@
+"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.registerEnvCommand = registerEnvCommand;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const chalk_1 = __importDefault(require("chalk"));
+const fs = __importStar(require("fs/promises"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+async function resolveWorkspaceId(config, slug) {
+    const configFile = await (0, config_1.loadConfig)();
+    const targetSlug = slug ?? configFile.workspace;
+    if (!targetSlug) {
+        // Use user's personal org
+        const org = await (0, api_1.getOrg)(config);
+        return org.id;
+    }
+    const response = await (0, api_1.request)(config, 'GET', '/workspaces');
+    const workspace = response.workspaces.find((w) => w.slug === targetSlug);
+    if (!workspace) {
+        throw new errors_1.CliError(`Workspace '${targetSlug}' not found`);
+    }
+    return workspace.id;
+}
+function statusColor(status) {
+    switch (status) {
+        case 'ready':
+            return chalk_1.default.green(status);
+        case 'building':
+            return chalk_1.default.yellow(status);
+        case 'failed':
+            return chalk_1.default.red(status);
+        case 'pending':
+            return chalk_1.default.gray(status);
+        default:
+            return chalk_1.default.gray(status ?? 'unknown');
+    }
+}
+async function listEnvs(config, options) {
+    const workspaceId = await resolveWorkspaceId(config, options.workspace);
+    const result = await (0, api_1.listEnvironments)(config, workspaceId);
+    if (result.environments.length === 0) {
+        console.log(chalk_1.default.gray('No environments found.'));
+        console.log(chalk_1.default.gray('Use `orch env create` to create one, or include a Dockerfile in your agent bundle.'));
+        return;
+    }
+    const table = new cli_table3_1.default({
+        head: [
+            chalk_1.default.cyan('Name'),
+            chalk_1.default.cyan('Status'),
+            chalk_1.default.cyan('Agents'),
+            chalk_1.default.cyan('Type'),
+            chalk_1.default.cyan('ID'),
+        ],
+        style: { head: [], border: [] },
+    });
+    for (const env of result.environments) {
+        const isDefault = env.environment.id === result.default_environment_id;
+        const name = isDefault
+            ? `${env.environment.name} ${chalk_1.default.yellow('(default)')}`
+            : env.environment.name;
+        table.push([
+            name,
+            statusColor(env.build?.status),
+            env.agent_count.toString(),
+            env.environment.is_predefined ? chalk_1.default.blue('predefined') : chalk_1.default.gray('custom'),
+            env.environment.id.slice(0, 8),
+        ]);
+    }
+    console.log();
+    console.log(chalk_1.default.bold('Environments:'));
+    console.log(table.toString());
+    console.log();
+    if (result.default_environment_id) {
+        const defaultEnv = result.environments.find((e) => e.environment.id === result.default_environment_id);
+        if (defaultEnv) {
+            console.log(chalk_1.default.gray(`Workspace default: ${chalk_1.default.white(defaultEnv.environment.name)}`));
+            console.log(chalk_1.default.gray('All new agents will use this environment unless they include their own Dockerfile.'));
+        }
+    }
+}
+async function getEnvStatus(config, environmentId) {
+    const result = await (0, api_1.getEnvironment)(config, environmentId);
+    console.log();
+    console.log(chalk_1.default.bold(`Environment: ${result.environment.name}`));
+    console.log();
+    console.log(`  ID:      ${result.environment.id}`);
+    console.log(`  Status:  ${statusColor(result.build?.status)}`);
+    console.log(`  Agents:  ${result.agent_count}`);
+    console.log(`  Type:    ${result.environment.is_predefined ? 'predefined' : 'custom'}`);
+    console.log(`  Created: ${new Date(result.environment.created_at).toLocaleString()}`);
+    if (result.build?.status === 'failed') {
+        console.log();
+        console.log(chalk_1.default.red('Build Error:'));
+        console.log(chalk_1.default.red(`  ${result.build.error_message || 'Unknown error'}`));
+    }
+    if (result.build?.build_logs) {
+        console.log();
+        console.log(chalk_1.default.gray('Build Logs:'));
+        console.log(chalk_1.default.gray(result.build.build_logs));
+    }
+    console.log();
+    console.log(chalk_1.default.gray('Dockerfile:'));
+    console.log(chalk_1.default.gray('---'));
+    console.log(result.environment.dockerfile_content);
+    console.log(chalk_1.default.gray('---'));
+}
+async function createEnv(config, options) {
+    let dockerfileContent;
+    try {
+        dockerfileContent = await fs.readFile(options.file, 'utf-8');
+    }
+    catch (err) {
+        throw new errors_1.CliError(`Failed to read Dockerfile: ${options.file}`);
+    }
+    console.log(chalk_1.default.gray(`Creating environment '${options.name}'...`));
+    const result = await (0, api_1.createEnvironment)(config, options.name, dockerfileContent);
+    if (result.reused) {
+        console.log(chalk_1.default.cyan('Existing environment with same Dockerfile found, reusing.'));
+        console.log(`Environment ID: ${result.environment.id}`);
+    }
+    else {
+        console.log(chalk_1.default.green('Environment created, build started.'));
+        console.log(`Environment ID: ${result.environment.id}`);
+        console.log();
+        console.log(chalk_1.default.gray(`Check build status: orch env status ${result.environment.id}`));
+    }
+    await (0, analytics_1.track)('env_create', {
+        environment_id: result.environment.id,
+        reused: result.reused,
+    });
+}
+async function deleteEnv(config, environmentId) {
+    console.log(chalk_1.default.gray(`Deleting environment ${environmentId}...`));
+    await (0, api_1.deleteEnvironment)(config, environmentId);
+    console.log(chalk_1.default.green('Environment deleted.'));
+    await (0, analytics_1.track)('env_delete', { environment_id: environmentId });
+}
+async function setDefault(config, environmentId, options) {
+    const workspaceId = await resolveWorkspaceId(config, options.workspace);
+    console.log(chalk_1.default.gray(`Setting default environment for workspace...`));
+    await (0, api_1.setWorkspaceDefaultEnvironment)(config, workspaceId, environmentId);
+    console.log(chalk_1.default.green('Default environment set for workspace.'));
+    console.log(chalk_1.default.gray('All new agents will use this environment unless they include their own Dockerfile.'));
+    await (0, analytics_1.track)('env_set_default', {
+        environment_id: environmentId,
+        workspace_id: workspaceId,
+    });
+}
+async function clearDefault(config, options) {
+    const workspaceId = await resolveWorkspaceId(config, options.workspace);
+    console.log(chalk_1.default.gray(`Clearing default environment for workspace...`));
+    await (0, api_1.setWorkspaceDefaultEnvironment)(config, workspaceId, null);
+    console.log(chalk_1.default.green('Default environment cleared. Agents will use base image.'));
+    await (0, analytics_1.track)('env_clear_default', { workspace_id: workspaceId });
+}
+function registerEnvCommand(program) {
+    const env = program
+        .command('env')
+        .description('Manage custom Docker environments for code agents');
+    env
+        .command('list')
+        .description('List environments in workspace')
+        .option('-w, --workspace <slug>', 'Workspace slug')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await listEnvs(config, options);
+    });
+    env
+        .command('status <environment-id>')
+        .description('Check environment build status')
+        .action(async (environmentId) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await getEnvStatus(config, environmentId);
+    });
+    env
+        .command('create')
+        .description('Create environment from Dockerfile')
+        .requiredOption('-f, --file <path>', 'Path to Dockerfile')
+        .requiredOption('-n, --name <name>', 'Environment name')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await createEnv(config, options);
+    });
+    env
+        .command('delete <environment-id>')
+        .description('Delete an environment')
+        .action(async (environmentId) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await deleteEnv(config, environmentId);
+    });
+    env
+        .command('set-default <environment-id>')
+        .description('Set workspace default environment (all agents use this)')
+        .option('-w, --workspace <slug>', 'Workspace slug (defaults to current)')
+        .action(async (environmentId, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await setDefault(config, environmentId, options);
+    });
+    env
+        .command('clear-default')
+        .description('Clear workspace default environment (agents use base image)')
+        .option('-w, --workspace <slug>', 'Workspace slug (defaults to current)')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        await clearDefault(config, options);
+    });
+}

package/dist/commands/index.js

@@ -25,6 +25,7 @@ const config_1 = require("./config");
 const install_1 = require("./install");
 const formats_1 = require("./formats");
 const update_1 = require("./update");
+const env_1 = require("./env");
 function registerCommands(program) {
     (0, login_1.registerLoginCommand)(program);
     (0, whoami_1.registerWhoamiCommand)(program);
@@ -50,4 +51,5 @@ function registerCommands(program) {
     (0, install_1.registerInstallCommand)(program);
     (0, formats_1.registerFormatsCommand)(program);
     (0, update_1.registerUpdateCommand)(program);
+    (0, env_1.registerEnvCommand)(program);
 }

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/publish.js

@@ -8,6 +8,7 @@ const promises_1 = __importDefault(require("fs/promises"));
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const yaml_1 = __importDefault(require("yaml"));
+const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const errors_1 = require("../lib/errors");
@@ -463,6 +464,20 @@ function registerPublishCommand(program) {
                 process.stdout.write(`  Uploading bundle...\n`);
                 const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath, manifest.entrypoint);
                 process.stdout.write(`  Uploaded: ${uploadResult.code_hash.substring(0, 12)}...\n`);
+                // Show environment info if applicable
+                if (uploadResult.environment_id) {
+                    if (uploadResult.environment_source === 'dockerfile_new') {
+                        process.stdout.write(`  ${chalk_1.default.cyan('Custom environment detected (Dockerfile)')}\n`);
+                        process.stdout.write(`  ${chalk_1.default.yellow('Environment building...')} Agent will be ready when build completes.\n`);
+                        process.stdout.write(`  ${chalk_1.default.gray(`Check status: orch env status ${uploadResult.environment_id}`)}\n`);
+                    }
+                    else if (uploadResult.environment_source === 'dockerfile_reused') {
+                        process.stdout.write(`  ${chalk_1.default.green('Custom environment (reusing existing build)')}\n`);
+                    }
+                    else if (uploadResult.environment_source === 'workspace_default') {
+                        process.stdout.write(`  ${chalk_1.default.cyan('Using workspace default environment')}\n`);
+                    }
+                }
             }
             finally {
                 // Clean up temp files

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;
@@ -58,15 +59,23 @@ exports.deleteAgent = deleteAgent;
 exports.previewAgentVersion = previewAgentVersion;
 exports.reportInstall = reportInstall;
 exports.fetchUserProfile = fetchUserProfile;
+exports.listEnvironments = listEnvironments;
+exports.getEnvironment = getEnvironment;
+exports.createEnvironment = createEnvironment;
+exports.deleteEnvironment = deleteEnvironment;
+exports.setWorkspaceDefaultEnvironment = setWorkspaceDefaultEnvironment;
 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 +86,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++) {
@@ -357,3 +404,40 @@ async function fetchUserProfile(config) {
     const result = await request(config, 'GET', '/users/me');
     return result.user;
 }
+/**
+ * List environments in a workspace (plus predefined).
+ */
+async function listEnvironments(config, workspaceId) {
+    const params = workspaceId ? `?workspace_id=${encodeURIComponent(workspaceId)}` : '';
+    return request(config, 'GET', `/environments${params}`);
+}
+/**
+ * Get environment details including build status.
+ */
+async function getEnvironment(config, environmentId) {
+    return request(config, 'GET', `/environments/${environmentId}`);
+}
+/**
+ * Create a new environment from Dockerfile.
+ */
+async function createEnvironment(config, name, dockerfileContent) {
+    return request(config, 'POST', '/environments', {
+        body: JSON.stringify({ name, dockerfile_content: dockerfileContent }),
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+/**
+ * Delete an environment (must have no agents using it).
+ */
+async function deleteEnvironment(config, environmentId) {
+    return request(config, 'DELETE', `/environments/${environmentId}`);
+}
+/**
+ * Set workspace default environment.
+ */
+async function setWorkspaceDefaultEnvironment(config, workspaceId, environmentId) {
+    return request(config, 'POST', `/environments/workspaces/${workspaceId}/default-environment`, {
+        body: JSON.stringify({ environment_id: environmentId }),
+        headers: { 'Content-Type': 'application/json' },
+    });
+}

package/package.json

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