@orchagent/cli 0.3.86 → 0.3.88

package/dist/commands/agent-keys.js

@@ -8,6 +8,7 @@ const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const errors_1 = require("../lib/errors");
+const key_store_1 = require("../lib/key-store");
 /**
  * Resolve an agent reference ("org/agent" or just "agent") to an agent ID.
  * Uses the authenticated list-agents endpoint and finds the latest version.
@@ -27,7 +28,7 @@ async function resolveAgentId(config, ref) {
     }
     // Use the latest version
     const latest = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
-    return { agent: latest, agentId: latest.id };
+    return { agent: latest, agentId: latest.id, orgSlug: latest.org_slug ?? resolvedOrg ?? '' };
 }
 function registerAgentKeysCommand(program) {
     const agentKeys = program
@@ -41,22 +42,29 @@ function registerAgentKeysCommand(program) {
         if (!config.apiKey) {
             throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
         }
-        const { agent, agentId } = await resolveAgentId(config, ref);
+        const { agent, agentId, orgSlug } = await resolveAgentId(config, ref);
         const result = await (0, api_1.listAgentKeys)(config, agentId);
+        // Load locally-saved keys for this agent
+        const localKeys = await (0, key_store_1.loadServiceKeys)(orgSlug, agent.name);
+        const localPrefixes = new Set(localKeys.map(k => k.prefix));
         if (result.keys.length === 0) {
             process.stdout.write(`No service keys for ${agent.name}.\n`);
             process.stdout.write(`\nCreate one with: orchagent agent-keys create ${ref}\n`);
             return;
         }
         process.stdout.write(`Service keys for ${agent.name}:\n\n`);
-        process.stdout.write(`  ${'ID'.padEnd(38)} ${'PREFIX'.padEnd(14)} ${'CREATED'.padEnd(22)} LAST USED\n`);
-        process.stdout.write(`  ${'─'.repeat(38)} ${'─'.repeat(14)} ${'─'.repeat(22)} ${'─'.repeat(22)}\n`);
+        process.stdout.write(`  ${'ID'.padEnd(38)} ${'PREFIX'.padEnd(14)} ${'CREATED'.padEnd(22)} ${'LAST USED'.padEnd(22)} SAVED\n`);
+        process.stdout.write(`  ${'─'.repeat(38)} ${'─'.repeat(14)} ${'─'.repeat(22)} ${'─'.repeat(22)} ${'─'.repeat(5)}\n`);
         for (const key of result.keys) {
             const created = new Date(key.created_at).toLocaleDateString();
             const lastUsed = key.last_used_at
                 ? new Date(key.last_used_at).toLocaleDateString()
                 : chalk_1.default.gray('never');
-            process.stdout.write(`  ${key.id.padEnd(38)} ${key.prefix.padEnd(14)} ${created.padEnd(22)} ${lastUsed}\n`);
+            const saved = localPrefixes.has(key.prefix) ? chalk_1.default.green('yes') : chalk_1.default.gray('no');
+            process.stdout.write(`  ${key.id.padEnd(38)} ${key.prefix.padEnd(14)} ${created.padEnd(22)} ${String(lastUsed).padEnd(22)} ${saved}\n`);
+        }
+        if (localKeys.length > 0) {
+            process.stdout.write(`\n  ${chalk_1.default.gray('Keys marked "yes" can be retrieved from ~/.orchagent/keys/')}\n`);
         }
         process.stdout.write('\n');
     });
@@ -68,11 +76,17 @@ function registerAgentKeysCommand(program) {
         if (!config.apiKey) {
             throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
         }
-        const { agent } = await resolveAgentId(config, ref);
+        const { agent, orgSlug } = await resolveAgentId(config, ref);
         const result = await (0, api_1.createAgentKey)(config, agent.id);
         process.stdout.write(`\nNew service key for ${agent.name}:\n\n`);
         process.stdout.write(`  ${result.key}\n\n`);
-        process.stderr.write(chalk_1.default.yellow('Save this key now — it cannot be retrieved again.\n'));
+        try {
+            const savedPath = await (0, key_store_1.saveServiceKey)(orgSlug, agent.name, agent.version, result.key, result.prefix);
+            process.stdout.write(`  ${chalk_1.default.gray(`Saved to ${savedPath}`)}\n`);
+        }
+        catch {
+            process.stderr.write(chalk_1.default.yellow('Could not save key locally. Copy it now — it cannot be retrieved from the server.\n'));
+        }
     });
     agentKeys
         .command('delete <agent> <key-id>')

package/dist/commands/agents.js

@@ -36,16 +36,42 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.latestOnly = latestOnly;
 exports.registerAgentsCommand = registerAgentsCommand;
 const chalk_1 = __importDefault(require("chalk"));
 const config_1 = require("../lib/config");
 const api_1 = require("../lib/api");
 const output_1 = require("../lib/output");
+/**
+ * Given a list of agents, return only the latest version of each agent name.
+ * "Latest" = highest created_at timestamp (most recently published).
+ * Also returns the total version count per agent name for display.
+ */
+function latestOnly(agents) {
+    const byName = new Map();
+    for (const agent of agents) {
+        const existing = byName.get(agent.name) ?? [];
+        existing.push(agent);
+        byName.set(agent.name, existing);
+    }
+    const result = [];
+    const versionCounts = new Map();
+    for (const [name, versions] of byName) {
+        versionCounts.set(name, versions.length);
+        // Sort by created_at descending, take the first (latest)
+        versions.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime());
+        result.push(versions[0]);
+    }
+    // Sort final list alphabetically by name for stable output
+    result.sort((a, b) => a.name.localeCompare(b.name));
+    return { agents: result, versionCounts };
+}
 function registerAgentsCommand(program) {
     program
         .command('agents')
         .description('List your published agents')
         .option('--filter <text>', 'Filter by name')
+        .option('--all-versions', 'Show all versions (default: latest only)')
         .option('--json', 'Output raw JSON')
         .action(async (options) => {
         const config = await (0, config_1.getResolvedConfig)();
@@ -58,11 +84,22 @@ function registerAgentsCommand(program) {
         const filteredAgents = options.filter
             ? agents.filter(a => a.name.toLowerCase().includes(options.filter.toLowerCase()))
             : agents;
+        // Determine display set: latest-only (default) or all versions
+        let displayAgents;
+        let versionCounts;
+        if (options.allVersions) {
+            displayAgents = filteredAgents;
+        }
+        else {
+            const grouped = latestOnly(filteredAgents);
+            displayAgents = grouped.agents;
+            versionCounts = grouped.versionCounts;
+        }
         if (options.json) {
-            (0, output_1.printJson)(filteredAgents);
+            (0, output_1.printJson)(displayAgents);
             return;
         }
-        if (filteredAgents.length === 0) {
+        if (displayAgents.length === 0) {
             process.stdout.write(options.filter
                 ? `No agents found matching "${options.filter}"\n`
                 : 'No agents published yet.\n\nPublish an agent: orch publish\n');
@@ -77,18 +114,36 @@ function registerAgentsCommand(program) {
                 chalk_1.default.bold('Description'),
             ],
         });
-        filteredAgents.forEach((agent) => {
+        displayAgents.forEach((agent) => {
             const name = agent.name;
-            const version = agent.version;
             const type = agent.type || 'tool';
             const desc = agent.description
                 ? agent.description.length > 60
                     ? agent.description.slice(0, 57) + '...'
                     : agent.description
                 : '-';
+            // In latest-only mode, show version count if > 1
+            let version = agent.version;
+            if (!options.allVersions && versionCounts) {
+                const count = versionCounts.get(agent.name) ?? 1;
+                if (count > 1) {
+                    version = `${agent.version} (${count} total)`;
+                }
+            }
             table.push([name, version, type, desc]);
         });
         process.stdout.write(`${table.toString()}\n`);
-        process.stdout.write(`\nTotal: ${filteredAgents.length} agent${filteredAgents.length === 1 ? '' : 's'}\n`);
+        if (options.allVersions) {
+            process.stdout.write(`\nTotal: ${displayAgents.length} version${displayAgents.length === 1 ? '' : 's'}\n`);
+        }
+        else {
+            const totalVersions = filteredAgents.length;
+            const agentCount = displayAgents.length;
+            process.stdout.write(`\n${agentCount} agent${agentCount === 1 ? '' : 's'}`);
+            if (totalVersions > agentCount) {
+                process.stdout.write(` (${totalVersions} versions total, use --all-versions to show all)`);
+            }
+            process.stdout.write('\n');
+        }
     });
 }

package/dist/commands/config.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.setConfigValue = setConfigValue;
 exports.registerConfigCommand = registerConfigCommand;
 const config_1 = require("../lib/config");
 const errors_1 = require("../lib/errors");
@@ -18,6 +19,9 @@ async function setConfigValue(key, value) {
     if (!isValidKey(key)) {
         throw new errors_1.CliError(`Unknown config key: ${key}. Supported keys: ${SUPPORTED_KEYS.join(', ')}`);
     }
+    if (!value || !value.trim()) {
+        throw new errors_1.CliError(`Cannot set ${key} to an empty value. To clear this setting, use: orch config unset ${key}`);
+    }
     if (key === 'default-format') {
         const formats = value.split(',').map((f) => f.trim()).filter(Boolean);
         // Validate format IDs against union of skill formats and agent adapters

package/dist/commands/delete.js

@@ -64,7 +64,7 @@ Examples:
             selectedAgent = matching.sort((a, b) => new Date(b.created_at).getTime() - new Date(a.created_at).getTime())[0];
         }
         // Check if confirmation is required
-        const deleteCheck = await (0, api_1.checkAgentDelete)(config, selectedAgent.id);
+        const deleteCheck = await (0, api_1.checkAgentDelete)(config, selectedAgent.id, workspaceId);
         // Show agent info
         process.stdout.write(`\n${chalk_1.default.bold('Agent:')} ${selectedAgent.name}@${selectedAgent.version}\n`);
         process.stdout.write('\n');
@@ -97,7 +97,7 @@ Examples:
         // Perform deletion
         process.stdout.write('Deleting agent...\n');
         const confirmationName = deleteCheck.requires_confirmation ? selectedAgent.name : undefined;
-        await (0, api_1.deleteAgent)(config, selectedAgent.id, confirmationName);
+        await (0, api_1.deleteAgent)(config, selectedAgent.id, confirmationName, workspaceId);
         await (0, analytics_1.track)('cli_delete', { agent_name: selectedAgent.name, version: selectedAgent.version });
         process.stdout.write(`✓ Deleted ${selectedAgent.name}@${selectedAgent.version}\n`);
         process.stdout.write(chalk_1.default.gray('\nData will be retained for 30 days before permanent deletion.\n'));

package/dist/commands/dev.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * `orch dev` — local development server with hot-reload.
+ *
+ * Starts an HTTP server that accepts JSON input and runs the agent locally.
+ * Watches for file changes and reloads agent configuration automatically.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerDevCommand = registerDevCommand;
+const path_1 = __importDefault(require("path"));
+const promises_1 = __importDefault(require("fs/promises"));
+const chalk_1 = __importDefault(require("chalk"));
+const chokidar_1 = __importDefault(require("chokidar"));
+const errors_1 = require("../lib/errors");
+const dotenv_1 = require("../lib/dotenv");
+const dev_server_1 = require("../lib/dev-server");
+// ─── Console UI ─────────────────────────────────────────────────────────────
+function printBanner(config, port) {
+    const name = config.manifest.name || 'unknown';
+    const version = config.manifest.version || 'local';
+    const engine = (0, dev_server_1.engineLabel)(config.engine);
+    process.stderr.write('\n');
+    process.stderr.write(chalk_1.default.cyan.bold(`  orch dev`) + chalk_1.default.gray(` — local development server\n`));
+    process.stderr.write('\n');
+    process.stderr.write(`  ${chalk_1.default.bold('Agent:')}   ${name}@${version}\n`);
+    process.stderr.write(`  ${chalk_1.default.bold('Engine:')}  ${engine}`);
+    if (config.entrypoint) {
+        process.stderr.write(chalk_1.default.gray(` (${config.entrypoint})`));
+    }
+    process.stderr.write('\n');
+    process.stderr.write(`  ${chalk_1.default.bold('Server:')}  ${chalk_1.default.green(`http://localhost:${port}`)}\n`);
+    process.stderr.write('\n');
+    process.stderr.write(chalk_1.default.gray(`  POST http://localhost:${port}/run   Execute agent\n`));
+    process.stderr.write(chalk_1.default.gray(`  GET  http://localhost:${port}/health Agent info\n`));
+    process.stderr.write('\n');
+    process.stderr.write(chalk_1.default.gray('  Watching for file changes... (Ctrl+C to stop)\n'));
+    process.stderr.write(chalk_1.default.gray('  ─'.repeat(32)) + '\n');
+}
+function printRequestLog(log) {
+    const status = log.statusCode < 400
+        ? chalk_1.default.green(`${log.statusCode}`)
+        : chalk_1.default.red(`${log.statusCode}`);
+    const duration = chalk_1.default.gray(`${log.durationMs}ms`);
+    const id = chalk_1.default.gray(`#${log.id}`);
+    if (log.error) {
+        process.stderr.write(`  ${id} ${log.method} ${log.path} ${status} ${duration}\n` +
+            chalk_1.default.red(`     ${log.error.split('\n')[0].slice(0, 120)}\n`));
+    }
+    else {
+        process.stderr.write(`  ${id} ${log.method} ${log.path} ${status} ${duration}\n`);
+    }
+}
+function printReload(reason) {
+    const time = new Date().toLocaleTimeString();
+    process.stderr.write(chalk_1.default.cyan(`\n  [${time}] ${reason}\n`));
+}
+function printReloadError(error) {
+    process.stderr.write(chalk_1.default.red(`  Reload failed: ${error}\n`));
+    process.stderr.write(chalk_1.default.yellow(`  Server still running with previous configuration.\n`));
+}
+function setupWatcher(agentDir, state, verbose) {
+    const watcher = chokidar_1.default.watch(agentDir, {
+        ignored: /(node_modules|__pycache__|\.git|dist|build|\.venv|venv|\.next|target)/,
+        persistent: true,
+        ignoreInitial: true,
+    });
+    const reloadConfig = async (filePath) => {
+        const relPath = path_1.default.relative(agentDir, filePath);
+        printReload(`Changed: ${relPath}`);
+        try {
+            const newConfig = await (0, dev_server_1.loadAgentConfig)(agentDir);
+            state.config = newConfig;
+            const engine = (0, dev_server_1.engineLabel)(newConfig.engine);
+            const ep = newConfig.entrypoint ? `, ${newConfig.entrypoint}` : '';
+            process.stderr.write(chalk_1.default.green(`  Reloaded`) + chalk_1.default.gray(` (${engine}${ep})\n`));
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            printReloadError(message);
+        }
+    };
+    const onChange = (filePath) => {
+        if (state.debounceTimer)
+            clearTimeout(state.debounceTimer);
+        state.debounceTimer = setTimeout(() => reloadConfig(filePath), 300);
+    };
+    watcher
+        .on('change', onChange)
+        .on('add', onChange)
+        .on('unlink', onChange)
+        .on('error', (error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(chalk_1.default.red(`  Watcher error: ${message}\n`));
+    });
+    return watcher;
+}
+// ─── Command registration ───────────────────────────────────────────────────
+function registerDevCommand(program) {
+    program
+        .command('dev [path]')
+        .description('Start a local development server with hot-reload')
+        .option('-p, --port <port>', 'Server port', '4900')
+        .option('-v, --verbose', 'Show detailed execution output')
+        .option('--no-watch', 'Disable file watching')
+        .addHelpText('after', `
+Examples:
+  orch dev                     Start dev server in current directory
+  orch dev ./my-agent          Start dev server for agent in specified directory
+  orch dev --port 3001         Use custom port
+  orch dev --verbose           Show detailed execution output
+  orch dev --no-watch          Disable file watching (no hot-reload)
+
+Then send requests:
+  curl -X POST http://localhost:4900/run \\
+    -H "Content-Type: application/json" \\
+    -d '{"task": "hello world"}'
+`)
+        .action(async (dirPath, options) => {
+        const agentDir = path_1.default.resolve(dirPath || '.');
+        const port = parseInt(options.port, 10);
+        const verbose = options.verbose ?? false;
+        const watchEnabled = options.watch !== false;
+        if (isNaN(port) || port < 1 || port > 65535) {
+            throw new errors_1.CliError('Port must be a number between 1 and 65535');
+        }
+        // Verify directory exists
+        try {
+            const stat = await promises_1.default.stat(agentDir);
+            if (!stat.isDirectory()) {
+                throw new errors_1.CliError(`Not a directory: ${agentDir}`);
+            }
+        }
+        catch (err) {
+            if (err instanceof errors_1.CliError)
+                throw err;
+            throw new errors_1.CliError(`Directory not found: ${agentDir}`);
+        }
+        // Verify orchagent.json exists
+        try {
+            await promises_1.default.access(path_1.default.join(agentDir, 'orchagent.json'));
+        }
+        catch {
+            throw new errors_1.CliError(`No orchagent.json found in ${agentDir}\n\n` +
+                `To start a dev server, the directory must contain orchagent.json.\n` +
+                `Create one with: orch init`);
+        }
+        // Load .env
+        const dotEnvVars = await (0, dotenv_1.loadDotEnv)(agentDir);
+        const dotEnvCount = Object.keys(dotEnvVars).length;
+        if (dotEnvCount > 0) {
+            for (const [key, value] of Object.entries(dotEnvVars)) {
+                if (!(key in process.env) || process.env[key] === undefined) {
+                    process.env[key] = value;
+                }
+            }
+        }
+        // Initial config load
+        let initialConfig;
+        try {
+            initialConfig = await (0, dev_server_1.loadAgentConfig)(agentDir);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            throw new errors_1.CliError(`Failed to load agent configuration: ${message}`);
+        }
+        const type = (initialConfig.manifest.type || 'agent').toLowerCase();
+        if (type === 'skill') {
+            throw new errors_1.CliError('Skills cannot be served as a dev server.\n' +
+                'Skills are instructions meant to be injected into AI agent contexts.');
+        }
+        // Set up state
+        const state = {
+            config: initialConfig,
+            debounceTimer: null,
+        };
+        // Create server
+        const { server, close } = (0, dev_server_1.createDevServer)(port, verbose, () => state.config, {
+            onRequest: printRequestLog,
+            onError: verbose ? (err) => {
+                process.stderr.write(chalk_1.default.red(`     Detail: ${err.message}\n`));
+            } : undefined,
+        });
+        // Start server
+        await new Promise((resolve, reject) => {
+            server.on('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    reject(new errors_1.CliError(`Port ${port} is already in use.\n\n` +
+                        `Try a different port: orch dev --port ${port + 1}`));
+                }
+                else {
+                    reject(new errors_1.CliError(`Server error: ${err.message}`));
+                }
+            });
+            server.listen(port, () => resolve());
+        });
+        // Print banner
+        printBanner(initialConfig, port);
+        if (dotEnvCount > 0) {
+            process.stderr.write(chalk_1.default.gray(`  Loaded ${dotEnvCount} variable${dotEnvCount === 1 ? '' : 's'} from .env\n`));
+        }
+        // Set up file watcher
+        let watcher = null;
+        if (watchEnabled) {
+            watcher = setupWatcher(agentDir, state, verbose);
+        }
+        else {
+            process.stderr.write(chalk_1.default.gray(`  File watching disabled\n`));
+        }
+        // Handle shutdown
+        const shutdown = async () => {
+            process.stderr.write(chalk_1.default.gray('\n  Shutting down...\n'));
+            if (watcher) {
+                await watcher.close();
+            }
+            await close();
+            process.exit(0);
+        };
+        process.on('SIGINT', shutdown);
+        process.on('SIGTERM', shutdown);
+        // Keep process alive
+        await new Promise(() => { });
+    });
+}