@orchagent/cli 0.1.0

package/dist/commands/keys.js

@@ -0,0 +1,172 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerKeysCommand = registerKeysCommand;
+const readline = __importStar(require("readline"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const VALID_PROVIDERS = ['openai', 'anthropic', 'gemini'];
+async function promptForKey(provider) {
+    // Use hidden input to avoid exposing keys in terminal history/logs
+    return new Promise((resolve, reject) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        // Mask input by not echoing characters
+        process.stdout.write(`Enter API key for ${provider}: `);
+        if (process.stdin.isTTY) {
+            // For TTY, read without echo
+            const stdin = process.stdin;
+            stdin.setRawMode(true);
+            stdin.resume();
+            stdin.setEncoding('utf8');
+            let key = '';
+            const onData = (char) => {
+                if (char === '\n' || char === '\r') {
+                    stdin.setRawMode(false);
+                    stdin.removeListener('data', onData);
+                    rl.close();
+                    process.stdout.write('\n');
+                    resolve(key.trim());
+                }
+                else if (char === '\u0003') {
+                    // Ctrl+C
+                    stdin.setRawMode(false);
+                    rl.close();
+                    reject(new errors_1.CliError('Cancelled'));
+                }
+                else if (char === '\u007F' || char === '\b') {
+                    // Backspace
+                    if (key.length > 0) {
+                        key = key.slice(0, -1);
+                    }
+                }
+                else {
+                    key += char;
+                }
+            };
+            stdin.on('data', onData);
+        }
+        else {
+            // Non-TTY (piped input), just read normally
+            rl.question('', (answer) => {
+                rl.close();
+                resolve(answer.trim());
+            });
+        }
+    });
+}
+async function addKey(config, provider, options) {
+    let apiKey = options.key;
+    if (!apiKey) {
+        apiKey = await promptForKey(provider);
+    }
+    if (!apiKey) {
+        throw new errors_1.CliError('API key is required');
+    }
+    await (0, api_1.request)(config, 'POST', '/llm-keys', {
+        body: JSON.stringify({
+            provider,
+            api_key: apiKey,
+            endpoint_url: options.endpoint,
+        }),
+        headers: { 'Content-Type': 'application/json' },
+    });
+    process.stdout.write(`Saved ${provider} API key.\n`);
+}
+async function listKeys(config) {
+    const keys = await (0, api_1.request)(config, 'GET', '/llm-keys');
+    if (keys.length === 0) {
+        process.stdout.write('No LLM keys configured.\n');
+        process.stdout.write('\nAdd a key with: orchagent keys add <provider>\n');
+        process.stdout.write('Providers: openai, anthropic, gemini\n');
+        return;
+    }
+    process.stdout.write('Configured LLM keys:\n\n');
+    for (const key of keys) {
+        const endpoint = key.has_custom_endpoint ? ' (custom endpoint)' : '';
+        process.stdout.write(`  ${key.provider}${endpoint}\n`);
+    }
+    process.stdout.write('\n');
+}
+async function removeKey(config, provider) {
+    await (0, api_1.request)(config, 'DELETE', `/llm-keys/${provider}`);
+    process.stdout.write(`Removed ${provider} API key.\n`);
+}
+function registerKeysCommand(program) {
+    const keys = program
+        .command('keys')
+        .description('Manage LLM API keys for calling agents');
+    keys
+        .command('add <provider>')
+        .description('Add or update an LLM API key')
+        .option('--key <key>', 'API key (will prompt if not provided)')
+        .option('--endpoint <url>', 'Custom endpoint URL (enterprise proxy or self-hosted model)')
+        .action(async (provider, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        if (!VALID_PROVIDERS.includes(provider)) {
+            throw new errors_1.CliError(`Invalid provider: ${provider}. Valid providers: ${VALID_PROVIDERS.join(', ')}`);
+        }
+        await addKey(config, provider, options);
+    });
+    keys
+        .command('list')
+        .description('List configured LLM API keys')
+        .action(async () => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        await listKeys(config);
+    });
+    keys
+        .command('remove <provider>')
+        .description('Remove an LLM API key')
+        .action(async (provider) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        if (!VALID_PROVIDERS.includes(provider)) {
+            throw new errors_1.CliError(`Invalid provider: ${provider}. Valid providers: ${VALID_PROVIDERS.join(', ')}`);
+        }
+        await removeKey(config, provider);
+    });
+}

package/dist/commands/llm-config.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLlmConfigCommand = registerLlmConfigCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+function registerLlmConfigCommand(program) {
+    program
+        .command('llm-config')
+        .description('Set default LLM configuration for prompt-based agents')
+        .option('--endpoint <url>', 'LLM API base URL (e.g., https://api.openai.com/v1)')
+        .option('--model <model>', 'Default model name (e.g., gpt-4.1-mini)')
+        .option('--api-key <key>', 'LLM API key')
+        .option('--clear', 'Clear the stored default LLM config')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        if (!config.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        if (options.clear) {
+            await (0, api_1.updateOrg)(config, { default_llm_config: null });
+            process.stdout.write('Cleared default LLM config.\n');
+            return;
+        }
+        const endpoint = options.endpoint?.trim();
+        const model = options.model?.trim();
+        const apiKey = options.apiKey?.trim();
+        if (!endpoint || !model || !apiKey) {
+            throw new errors_1.CliError('Missing required flags. Use --endpoint, --model, and --api-key (or --clear).');
+        }
+        await (0, api_1.updateOrg)(config, {
+            default_llm_config: {
+                endpoint,
+                model,
+                api_key: apiKey,
+            },
+        });
+        process.stdout.write('Saved default LLM config.\n');
+    });
+}

package/dist/commands/login.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerLoginCommand = registerLoginCommand;
+const promises_1 = __importDefault(require("readline/promises"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const browser_auth_1 = require("../lib/browser-auth");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const DEFAULT_AUTH_PORT = 8374;
+async function promptForKey() {
+    const rl = promises_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const answer = await rl.question('API key: ');
+    rl.close();
+    return answer.trim();
+}
+function registerLoginCommand(program) {
+    program
+        .command('login')
+        .description('Authenticate with OrchAgent via browser or API key')
+        .option('--key <key>', 'API key (for CI/CD, non-interactive)')
+        .option('--port <port>', `Localhost port for browser callback (default: ${DEFAULT_AUTH_PORT})`, String(DEFAULT_AUTH_PORT))
+        .action(async (options) => {
+        const providedKey = options.key || process.env.ORCHAGENT_API_KEY;
+        // If key provided via flag or env var, use existing key-based flow
+        if (providedKey) {
+            await keyBasedLogin(providedKey);
+            return;
+        }
+        // Check if running in non-interactive mode (no TTY)
+        if (!process.stdin.isTTY) {
+            throw new errors_1.CliError('Non-interactive mode requires --key flag or ORCHAGENT_API_KEY environment variable.\n' +
+                'For CI/CD, set ORCHAGENT_API_KEY or use: orchagent login --key <your-api-key>');
+        }
+        // Interactive mode: use browser auth
+        const port = parseInt(options.port || String(DEFAULT_AUTH_PORT), 10);
+        if (isNaN(port) || port < 1024 || port > 65535) {
+            throw new errors_1.CliError('Port must be a number between 1024 and 65535');
+        }
+        await browserBasedLogin(port);
+    });
+}
+/**
+ * Login using an API key (for CI/CD and non-interactive environments).
+ */
+async function keyBasedLogin(apiKey) {
+    if (!apiKey) {
+        throw new errors_1.CliError('API key is required.');
+    }
+    const resolved = await (0, config_1.getResolvedConfig)({ api_key: apiKey });
+    const org = await (0, api_1.getOrg)(resolved);
+    const existing = await (0, config_1.loadConfig)();
+    const nextConfig = {
+        ...existing,
+        api_key: apiKey,
+        api_url: resolved.apiUrl,
+        default_org: existing.default_org ?? org.slug,
+    };
+    await (0, config_1.saveConfig)(nextConfig);
+    await (0, analytics_1.track)('cli_login', { method: 'key' });
+    process.stdout.write(`✓ Logged in to ${org.slug}\n`);
+}
+/**
+ * Login via browser OAuth flow.
+ */
+async function browserBasedLogin(port) {
+    const existing = await (0, config_1.loadConfig)();
+    const resolved = await (0, config_1.getResolvedConfig)();
+    process.stdout.write('Opening browser for authentication...\n');
+    try {
+        const result = await (0, browser_auth_1.startBrowserAuth)(resolved.apiUrl, port);
+        const nextConfig = {
+            ...existing,
+            api_key: result.apiKey,
+            api_url: resolved.apiUrl,
+            default_org: existing.default_org ?? result.orgSlug,
+        };
+        await (0, config_1.saveConfig)(nextConfig);
+        await (0, analytics_1.track)('cli_login', { method: 'browser' });
+        process.stdout.write(`\n✓ Logged in to ${result.orgSlug}\n`);
+    }
+    catch (err) {
+        if (err instanceof errors_1.CliError) {
+            throw err;
+        }
+        throw new errors_1.CliError(err instanceof Error ? err.message : 'Authentication failed');
+    }
+}

package/dist/commands/publish.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPublishCommand = registerPublishCommand;
+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 config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+const bundle_1 = require("../lib/bundle");
+async function parseSkillMd(filePath) {
+    try {
+        const content = await promises_1.default.readFile(filePath, 'utf-8');
+        const match = content.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+        if (!match)
+            return null;
+        const frontmatter = yaml_1.default.parse(match[1]);
+        const body = match[2].trim();
+        if (!frontmatter.name || !frontmatter.description)
+            return null;
+        return { frontmatter, body };
+    }
+    catch {
+        return null;
+    }
+}
+function registerPublishCommand(program) {
+    program
+        .command('publish')
+        .description('Publish agent from local files')
+        .option('--url <url>', 'Agent URL (for code-based agents)')
+        .option('--public', 'Make agent public (default: true)', true)
+        .option('--private', 'Make agent private')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const cwd = process.cwd();
+        // Check for SKILL.md first (skills take precedence)
+        const skillMdPath = path_1.default.join(cwd, 'SKILL.md');
+        const skillData = await parseSkillMd(skillMdPath);
+        if (skillData) {
+            // Publish as a skill (server auto-assigns version)
+            const org = await (0, api_1.getOrg)(config);
+            const skillResult = await (0, api_1.createAgent)(config, {
+                name: skillData.frontmatter.name,
+                type: 'skill',
+                description: skillData.frontmatter.description,
+                prompt: skillData.body,
+                is_public: options.private ? false : true,
+                supported_providers: ['any'],
+            });
+            const skillVersion = skillResult.agent?.version || 'v1';
+            await (0, analytics_1.track)('cli_publish', { agent_type: 'skill' });
+            process.stdout.write(`\nPublished skill: ${org.slug}/${skillData.frontmatter.name}@${skillVersion}\n`);
+            process.stdout.write(`Public: ${options.private ? 'no' : 'yes'}\n`);
+            return;
+        }
+        // Read manifest
+        const manifestPath = path_1.default.join(cwd, 'orchagent.json');
+        let manifest;
+        try {
+            const raw = await promises_1.default.readFile(manifestPath, 'utf-8');
+            manifest = JSON.parse(raw);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                throw new errors_1.CliError('No orchagent.json found. Run `orchagent init` first.');
+            }
+            throw new errors_1.CliError(`Failed to read orchagent.json: ${err}`);
+        }
+        // Validate manifest
+        if (!manifest.name) {
+            throw new errors_1.CliError('orchagent.json must have name');
+        }
+        // Read prompt (for prompt-based agents)
+        let prompt;
+        if (manifest.type === 'prompt') {
+            const promptPath = path_1.default.join(cwd, 'prompt.md');
+            try {
+                prompt = await promises_1.default.readFile(promptPath, 'utf-8');
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    throw new errors_1.CliError('No prompt.md found for prompt-based agent');
+                }
+                throw err;
+            }
+        }
+        // Read schemas
+        let inputSchema;
+        let outputSchema;
+        const schemaPath = path_1.default.join(cwd, 'schema.json');
+        try {
+            const raw = await promises_1.default.readFile(schemaPath, 'utf-8');
+            const schemas = JSON.parse(raw);
+            inputSchema = schemas.input;
+            outputSchema = schemas.output;
+        }
+        catch (err) {
+            // Schema is optional
+            if (err.code !== 'ENOENT') {
+                throw new errors_1.CliError(`Failed to read schema.json: ${err}`);
+            }
+        }
+        // For code-based agents, either --url is required OR we bundle the code
+        let agentUrl = options.url;
+        let shouldUploadBundle = false;
+        if (manifest.type === 'code' && !options.url) {
+            // Check if this looks like a Python or JS project that can be bundled
+            const entrypoint = manifest.entrypoint || await (0, bundle_1.detectEntrypoint)(cwd);
+            if (entrypoint) {
+                // This is a hosted code agent - we'll bundle and upload
+                shouldUploadBundle = true;
+                // Set a placeholder URL that tells the gateway to use sandbox execution
+                agentUrl = 'https://code-agent.internal';
+                process.stdout.write(`Detected code project with entrypoint: ${entrypoint}\n`);
+            }
+            else {
+                throw new errors_1.CliError('Code agent requires either --url <url> or an entry point file (main.py, app.py, index.js, etc.)');
+            }
+        }
+        // Get org info
+        const org = await (0, api_1.getOrg)(config);
+        // Default to 'any' provider if not specified
+        const supportedProviders = manifest.supported_providers || ['any'];
+        // Create the agent (server auto-assigns version)
+        const result = await (0, api_1.createAgent)(config, {
+            name: manifest.name,
+            type: manifest.type,
+            description: manifest.description,
+            prompt,
+            url: agentUrl,
+            input_schema: inputSchema,
+            output_schema: outputSchema,
+            tags: manifest.tags,
+            is_public: options.private ? false : true,
+            supported_providers: supportedProviders,
+            default_models: manifest.default_models,
+            // Local run fields for code agents
+            source_url: manifest.source_url,
+            pip_package: manifest.pip_package,
+            run_command: manifest.run_command,
+        });
+        const assignedVersion = result.agent?.version || 'v1';
+        const agentId = result.agent?.id;
+        // Upload code bundle if this is a hosted code agent
+        if (shouldUploadBundle && agentId) {
+            process.stdout.write(`\nBundling code...\n`);
+            const tempDir = await promises_1.default.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'orchagent-bundle-'));
+            const bundlePath = path_1.default.join(tempDir, 'bundle.zip');
+            try {
+                const bundleResult = await (0, bundle_1.createCodeBundle)(cwd, bundlePath, {
+                    entrypoint: manifest.entrypoint,
+                    exclude: manifest.bundle?.exclude,
+                    include: manifest.bundle?.include,
+                });
+                process.stdout.write(`  Created bundle: ${bundleResult.fileCount} files, ${(bundleResult.sizeBytes / 1024).toFixed(1)}KB\n`);
+                // Validate bundle size
+                const validation = await (0, bundle_1.validateBundle)(bundlePath);
+                if (!validation.valid) {
+                    throw new errors_1.CliError(`Bundle validation failed: ${validation.error}`);
+                }
+                // Upload the bundle
+                process.stdout.write(`  Uploading bundle...\n`);
+                const uploadResult = await (0, api_1.uploadCodeBundle)(config, agentId, bundlePath);
+                process.stdout.write(`  Uploaded: ${uploadResult.code_hash.substring(0, 12)}...\n`);
+            }
+            finally {
+                // Clean up temp files
+                await promises_1.default.rm(tempDir, { recursive: true, force: true });
+            }
+        }
+        await (0, analytics_1.track)('cli_publish', { agent_type: manifest.type, hosted: shouldUploadBundle });
+        process.stdout.write(`\nPublished agent: ${org.slug}/${manifest.name}@${assignedVersion}\n`);
+        process.stdout.write(`Type: ${manifest.type}${shouldUploadBundle ? ' (hosted)' : ''}\n`);
+        process.stdout.write(`Providers: ${supportedProviders.join(', ')}\n`);
+        process.stdout.write(`Public: ${options.private ? 'no' : 'yes'}\n`);
+        if (result.service_key) {
+            process.stdout.write(`\nService key (save this - shown only once):\n`);
+            process.stdout.write(`  ${result.service_key}\n`);
+        }
+        process.stdout.write(`\nAPI endpoint:\n`);
+        process.stdout.write(`  POST ${config.apiUrl}/${org.slug}/${manifest.name}/${assignedVersion}/run\n`);
+        if (shouldUploadBundle) {
+            process.stdout.write(`\nNote: Hosted code execution is in beta. Contact support for full deployment.\n`);
+        }
+    });
+}