@orchagent/cli 0.1.0

package/README.md

@@ -0,0 +1,18 @@
+# OrchAgent CLI
+
+Minimal CLI for interacting with the OrchAgent platform.
+
+## Commands
+
+- `orchagent login` - store an API key locally
+- `orchagent call <agent> [file]` - call an agent endpoint
+- `orchagent agents` - list public agents
+
+## Development
+
+```bash
+cd cli
+bun install
+bun run build
+node dist/index.js --help
+```

package/dist/commands/agents.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerAgentsCommand = registerAgentsCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const output_1 = require("../lib/output");
+function registerAgentsCommand(program) {
+    program
+        .command('agents')
+        .description('List public agents')
+        .option('--filter <text>', 'Filter by name (case-insensitive)')
+        .option('--json', 'Output raw JSON')
+        .action(async (options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const agents = await (0, api_1.listPublicAgents)(config);
+        const filter = options.filter?.toLowerCase();
+        const filtered = filter
+            ? agents.filter((agent) => `${agent.org_slug}/${agent.name}`.toLowerCase().includes(filter))
+            : agents;
+        if (options.json) {
+            (0, output_1.printJson)(filtered);
+            return;
+        }
+        (0, output_1.printAgentsTable)(filtered);
+    });
+}

package/dist/commands/call.js

@@ -0,0 +1,264 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCallCommand = registerCallCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const output_1 = require("../lib/output");
+const llm_1 = require("../lib/llm");
+const analytics_1 = require("../lib/analytics");
+const DEFAULT_VERSION = 'v1';
+function parseAgentRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 1) {
+        return { agent: segments[0], version };
+    }
+    if (segments.length === 2) {
+        return { org: segments[0], agent: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent or agent format.');
+}
+async function readStdin() {
+    if (process.stdin.isTTY)
+        return null;
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    if (!chunks.length)
+        return null;
+    return Buffer.concat(chunks);
+}
+async function buildMultipartBody(filePaths, metadata) {
+    if (!filePaths || filePaths.length === 0) {
+        const stdinData = await readStdin();
+        if (stdinData) {
+            const form = new FormData();
+            form.append('files[]', new Blob([new Uint8Array(stdinData)]), 'stdin');
+            if (metadata) {
+                form.append('metadata', metadata);
+            }
+            return { body: form, sourceLabel: 'stdin' };
+        }
+        if (metadata) {
+            const form = new FormData();
+            form.append('metadata', metadata);
+            return { body: form, sourceLabel: 'metadata' };
+        }
+        return {};
+    }
+    const form = new FormData();
+    for (const filePath of filePaths) {
+        const buffer = await promises_1.default.readFile(filePath);
+        const filename = path_1.default.basename(filePath);
+        form.append('files[]', new Blob([new Uint8Array(buffer)]), filename);
+    }
+    if (metadata) {
+        form.append('metadata', metadata);
+    }
+    return {
+        body: form,
+        sourceLabel: filePaths.length === 1 ? filePaths[0] : `${filePaths.length} files`,
+    };
+}
+async function resolveJsonBody(input) {
+    let raw = input;
+    if (input.startsWith('@')) {
+        const source = input.slice(1);
+        if (!source) {
+            throw new errors_1.CliError('Invalid JSON input. Use a JSON string or @file.');
+        }
+        if (source === '-') {
+            const stdinData = await readStdin();
+            if (!stdinData) {
+                throw new errors_1.CliError('No stdin provided for JSON input.');
+            }
+            raw = stdinData.toString('utf8');
+        }
+        else {
+            raw = await promises_1.default.readFile(source, 'utf8');
+        }
+    }
+    try {
+        return JSON.stringify(JSON.parse(raw));
+    }
+    catch {
+        throw new errors_1.CliError('Invalid JSON input. Provide a valid JSON string or @file.');
+    }
+}
+function registerCallCommand(program) {
+    program
+        .command('call <agent> [file]')
+        .description('Call an agent endpoint')
+        .option('--endpoint <endpoint>', 'Override agent endpoint')
+        .option('--tenant <tenant>', 'Tenant identifier for multi-tenant callers')
+        .option('--data <json>', 'JSON payload (string or @file, @- for stdin)')
+        .option('--key <key>', 'LLM API key (overrides env vars)')
+        .option('--provider <provider>', 'LLM provider (openai, anthropic, gemini)')
+        .option('--json', 'Output raw JSON')
+        .option('--output <file>', 'Save response body to a file')
+        .option('--skills <skills>', 'Add skills (comma-separated)')
+        .option('--skills-only <skills>', 'Use only these skills')
+        .option('--no-skills', 'Ignore default skills')
+        .option('--file <path...>', 'File(s) to upload (can specify multiple)')
+        .option('--metadata <json>', 'JSON metadata to send with files')
+        .action(async (agentRef, file, options) => {
+        const resolved = await (0, config_1.getResolvedConfig)();
+        if (!resolved.apiKey) {
+            throw new errors_1.CliError('Missing API key. Run `orchagent login` first.');
+        }
+        const parsed = parseAgentRef(agentRef);
+        const org = parsed.org ?? resolved.defaultOrg;
+        if (!org) {
+            throw new errors_1.CliError('Missing org. Use org/agent or set default org.');
+        }
+        const agentMeta = await (0, api_1.getPublicAgent)(resolved, org, parsed.agent, parsed.version);
+        const endpoint = options.endpoint?.trim() || agentMeta.default_endpoint || 'analyze';
+        const headers = {
+            Authorization: `Bearer ${resolved.apiKey}`,
+        };
+        if (options.tenant) {
+            headers['X-OrchAgent-Tenant'] = options.tenant;
+        }
+        const supportedProviders = agentMeta.supported_providers || ['any'];
+        let llmKey;
+        let llmProvider;
+        if (options.key) {
+            // Explicit key provided - require provider
+            if (!options.provider) {
+                throw new errors_1.CliError('When using --key, you must also specify --provider (openai, anthropic, or gemini)');
+            }
+            (0, llm_1.validateProvider)(options.provider);
+            llmKey = options.key;
+            llmProvider = options.provider;
+        }
+        else {
+            // Try to detect from environment or server
+            const detected = await (0, llm_1.detectLlmKey)(supportedProviders, resolved);
+            if (detected) {
+                llmKey = detected.key;
+                llmProvider = detected.provider;
+            }
+        }
+        // Add LLM key to headers
+        if (llmKey) {
+            headers['X-LLM-API-Key'] = llmKey;
+            if (llmProvider) {
+                headers['X-LLM-Provider'] = llmProvider;
+            }
+        }
+        else if (agentMeta.type === 'prompt') {
+            // Warn if no key found for prompt-based agent
+            const providerList = supportedProviders.join(', ');
+            process.stderr.write(`Warning: No LLM key found for providers: ${providerList}\n` +
+                `Set an env var (e.g., OPENAI_API_KEY), use --key, or configure in web dashboard\n\n`);
+        }
+        // Add skill headers
+        if (options.skills) {
+            headers['X-OrchAgent-Skills'] = options.skills;
+        }
+        if (options.skillsOnly) {
+            headers['X-OrchAgent-Skills-Only'] = options.skillsOnly;
+        }
+        if (options.noSkills) {
+            headers['X-OrchAgent-No-Skills'] = 'true';
+        }
+        let body;
+        let sourceLabel;
+        const filePaths = [
+            ...(options.file ?? []),
+            ...(file ? [file] : []),
+        ];
+        if (options.data) {
+            if (filePaths.length > 0 || options.metadata) {
+                throw new errors_1.CliError('Cannot use --data with file uploads or --metadata.');
+            }
+            body = await resolveJsonBody(options.data);
+            headers['Content-Type'] = 'application/json';
+        }
+        else {
+            const multipart = await buildMultipartBody(filePaths.length ? filePaths : undefined, options.metadata);
+            body = multipart.body;
+            sourceLabel = multipart.sourceLabel;
+        }
+        const url = `${resolved.apiUrl.replace(/\/$/, '')}/${org}/${parsed.agent}/${parsed.version}/${endpoint}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = text;
+            }
+            // Handle specific error codes with helpful messages
+            const errorCode = typeof payload === 'object' && payload
+                ? payload.error?.code
+                : undefined;
+            if (errorCode === 'LLM_KEY_REQUIRED') {
+                throw new errors_1.CliError('This public agent requires you to provide an LLM key.\n' +
+                    'Use --key <key> --provider <provider> or set OPENAI_API_KEY/ANTHROPIC_API_KEY env var.');
+            }
+            const message = typeof payload === 'object' && payload
+                ? payload.error
+                    ?.message ||
+                    payload.message ||
+                    response.statusText
+                : response.statusText;
+            throw new errors_1.CliError(message);
+        }
+        // Track successful call
+        const inputType = filePaths.length > 0
+            ? 'file'
+            : options.data
+                ? 'json'
+                : sourceLabel === 'stdin'
+                    ? 'stdin'
+                    : sourceLabel === 'metadata'
+                        ? 'metadata'
+                        : 'empty';
+        await (0, analytics_1.track)('cli_call', {
+            agent: `${org}/${parsed.agent}@${parsed.version}`,
+            input_type: inputType,
+        });
+        if (options.output) {
+            const buffer = Buffer.from(await response.arrayBuffer());
+            await promises_1.default.writeFile(options.output, buffer);
+            process.stdout.write(`Saved response to ${options.output}\n`);
+            return;
+        }
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = text;
+        }
+        if (options.json) {
+            if (typeof payload === 'string') {
+                process.stdout.write(`${payload}\n`);
+                return;
+            }
+            (0, output_1.printJson)(payload);
+            return;
+        }
+        if (typeof payload === 'string') {
+            process.stdout.write(`${payload}\n`);
+            return;
+        }
+        (0, output_1.printJson)(payload);
+    });
+}

package/dist/commands/fork.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerForkCommand = registerForkCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const analytics_1 = require("../lib/analytics");
+function parseAgentRef(ref) {
+    // Format: org/agent/version or org/agent (defaults to v1)
+    const parts = ref.split('/');
+    if (parts.length < 2 || parts.length > 3) {
+        throw new errors_1.CliError('Invalid agent reference. Use: org/agent or org/agent/version');
+    }
+    return {
+        org: parts[0],
+        name: parts[1],
+        version: parts[2] || 'v1',
+    };
+}
+function registerForkCommand(program) {
+    program
+        .command('fork')
+        .description('Fork an agent to your account')
+        .argument('<agent>', 'Agent reference (org/name or org/name/version)')
+        .action(async (agent) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const { org, name, version } = parseAgentRef(agent);
+        // Get the agent to get its ID
+        const agentInfo = await (0, api_1.getPublicAgent)(config, org, name, version);
+        // Fork it
+        const result = await (0, api_1.forkAgent)(config, agentInfo.id);
+        // Get our org info
+        const myOrg = await (0, api_1.getOrg)(config);
+        await (0, analytics_1.track)('cli_fork', { agent: `${org}/${name}/${version}` });
+        process.stdout.write(`Forked ${org}/${name}/${version} to your account\n`);
+        process.stdout.write(`\nYour forked agent: ${myOrg.slug}/${name}/v1\n`);
+        process.stdout.write(`\nNext steps:\n`);
+        process.stdout.write(`  1. Run: orchagent init ${name}\n`);
+        process.stdout.write(`  2. Edit the prompt and schemas locally\n`);
+        process.stdout.write(`  3. Run: orchagent publish\n`);
+    });
+}

package/dist/commands/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerCommands = registerCommands;
+const login_1 = require("./login");
+const call_1 = require("./call");
+const agents_1 = require("./agents");
+const init_1 = require("./init");
+const publish_1 = require("./publish");
+const whoami_1 = require("./whoami");
+const star_1 = require("./star");
+const fork_1 = require("./fork");
+const search_1 = require("./search");
+const llm_config_1 = require("./llm-config");
+const keys_1 = require("./keys");
+const run_1 = require("./run");
+const info_1 = require("./info");
+const skill_1 = require("./skill");
+function registerCommands(program) {
+    (0, login_1.registerLoginCommand)(program);
+    (0, whoami_1.registerWhoamiCommand)(program);
+    (0, init_1.registerInitCommand)(program);
+    (0, publish_1.registerPublishCommand)(program);
+    (0, call_1.registerCallCommand)(program);
+    (0, run_1.registerRunCommand)(program);
+    (0, info_1.registerInfoCommand)(program);
+    (0, agents_1.registerAgentsCommand)(program);
+    (0, search_1.registerSearchCommand)(program);
+    (0, star_1.registerStarCommand)(program);
+    (0, fork_1.registerForkCommand)(program);
+    (0, llm_config_1.registerLlmConfigCommand)(program);
+    (0, keys_1.registerKeysCommand)(program);
+    (0, skill_1.registerSkillCommand)(program);
+}

package/dist/commands/info.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInfoCommand = registerInfoCommand;
+const config_1 = require("../lib/config");
+const api_1 = require("../lib/api");
+const errors_1 = require("../lib/errors");
+const DEFAULT_VERSION = 'latest';
+function parseAgentRef(value) {
+    const [ref, versionPart] = value.split('@');
+    const version = versionPart?.trim() || DEFAULT_VERSION;
+    const segments = ref.split('/');
+    if (segments.length === 2) {
+        return { org: segments[0], agent: segments[1], version };
+    }
+    throw new errors_1.CliError('Invalid agent reference. Use org/agent format (e.g., joe/leak-finder)');
+}
+function deriveReadmeUrl(sourceUrl) {
+    // Parse GitHub URLs like:
+    // git+https://github.com/user/repo.git#subdirectory=path
+    // https://github.com/user/repo
+    const githubMatch = sourceUrl.match(/github\.com[/:]([^/]+)\/([^/.#]+)(?:\.git)?(?:#subdirectory=(.+))?/);
+    if (!githubMatch)
+        return null;
+    const [, user, repo, subdirectory] = githubMatch;
+    const path = subdirectory ? `${subdirectory}/README.md` : 'README.md';
+    return `https://raw.githubusercontent.com/${user}/${repo}/main/${path}`;
+}
+async function fetchReadme(url) {
+    try {
+        const response = await fetch(url);
+        if (!response.ok)
+            return null;
+        return await response.text();
+    }
+    catch {
+        return null;
+    }
+}
+function registerInfoCommand(program) {
+    program
+        .command('info <agent>')
+        .description('Show agent information and README')
+        .option('--json', 'Output as JSON')
+        .action(async (agentArg, options) => {
+        const config = await (0, config_1.getResolvedConfig)();
+        const { org, agent, version } = parseAgentRef(agentArg);
+        // Fetch agent metadata
+        const agentData = await (0, api_1.publicRequest)(config, `/public/agents/${org}/${agent}/${version}/download`);
+        if (options.json) {
+            process.stdout.write(JSON.stringify(agentData, null, 2) + '\n');
+            return;
+        }
+        // Display agent info
+        process.stdout.write('\n');
+        process.stdout.write(`${org}/${agent}@${version}\n`);
+        process.stdout.write('='.repeat(40) + '\n\n');
+        if (agentData.description) {
+            process.stdout.write(`${agentData.description}\n\n`);
+        }
+        process.stdout.write(`Type: ${agentData.type}\n`);
+        process.stdout.write(`Providers: ${agentData.supported_providers.join(', ')}\n`);
+        if (agentData.type === 'code') {
+            if (agentData.url) {
+                process.stdout.write(`Server: ${agentData.url}\n`);
+            }
+            if (agentData.source_url) {
+                process.stdout.write(`Source: ${agentData.source_url}\n`);
+            }
+            if (agentData.run_command) {
+                process.stdout.write(`Run: ${agentData.run_command}\n`);
+            }
+        }
+        // Fetch and display README if available
+        if (agentData.source_url) {
+            const readmeUrl = deriveReadmeUrl(agentData.source_url);
+            if (readmeUrl) {
+                const readme = await fetchReadme(readmeUrl);
+                if (readme) {
+                    process.stdout.write('\n' + '-'.repeat(40) + '\n');
+                    process.stdout.write('README\n');
+                    process.stdout.write('-'.repeat(40) + '\n\n');
+                    process.stdout.write(readme);
+                    process.stdout.write('\n');
+                }
+            }
+        }
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInitCommand = registerInitCommand;
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const errors_1 = require("../lib/errors");
+const MANIFEST_TEMPLATE = `{
+  "name": "my-agent",
+  "version": "v1",
+  "description": "A simple AI agent",
+  "type": "prompt",
+  "tags": []
+}
+`;
+const PROMPT_TEMPLATE = `You are a helpful AI assistant.
+
+Given the following input, provide a clear and concise response.
+
+Input: {{input}}
+
+Respond in a helpful and professional manner.
+`;
+const SCHEMA_TEMPLATE = `{
+  "input": {
+    "type": "object",
+    "properties": {
+      "input": {
+        "type": "string",
+        "description": "The user's input or question"
+      }
+    },
+    "required": ["input"]
+  },
+  "output": {
+    "type": "object",
+    "properties": {
+      "result": {
+        "type": "string",
+        "description": "The agent's response"
+      }
+    },
+    "required": ["result"]
+  }
+}
+`;
+function registerInitCommand(program) {
+    program
+        .command('init')
+        .description('Initialize a new agent project')
+        .argument('[name]', 'Agent name (default: current directory name)')
+        .option('--type <type>', 'Agent type: prompt or code (default: prompt)', 'prompt')
+        .action(async (name, options) => {
+        const cwd = process.cwd();
+        const agentName = name || path_1.default.basename(cwd);
+        const manifestPath = path_1.default.join(cwd, 'orchagent.json');
+        const promptPath = path_1.default.join(cwd, 'prompt.md');
+        const schemaPath = path_1.default.join(cwd, 'schema.json');
+        // Check if already initialized
+        try {
+            await promises_1.default.access(manifestPath);
+            throw new errors_1.CliError(`Already initialized (orchagent.json exists)`);
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+        // Create manifest
+        const manifest = JSON.parse(MANIFEST_TEMPLATE);
+        manifest.name = agentName;
+        manifest.type = options.type === 'code' ? 'code' : 'prompt';
+        await promises_1.default.writeFile(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+        // Create prompt template (for prompt-based agents)
+        if (options.type !== 'code') {
+            await promises_1.default.writeFile(promptPath, PROMPT_TEMPLATE);
+        }
+        // Create schema template
+        await promises_1.default.writeFile(schemaPath, SCHEMA_TEMPLATE);
+        process.stdout.write(`Initialized agent "${agentName}" in ${cwd}\n`);
+        process.stdout.write(`\nFiles created:\n`);
+        process.stdout.write(`  orchagent.json - Agent configuration\n`);
+        if (options.type !== 'code') {
+            process.stdout.write(`  prompt.md      - Prompt template\n`);
+        }
+        process.stdout.write(`  schema.json    - Input/output schemas\n`);
+        process.stdout.write(`\nNext steps:\n`);
+        if (options.type !== 'code') {
+            process.stdout.write(`  1. Edit prompt.md with your prompt template\n`);
+            process.stdout.write(`  2. Edit schema.json with your input/output schemas\n`);
+            process.stdout.write(`  3. Run: orchagent publish\n`);
+        }
+        else {
+            process.stdout.write(`  1. Edit schema.json with your input/output schemas\n`);
+            process.stdout.write(`  2. Deploy your code and get the URL\n`);
+            process.stdout.write(`  3. Run: orchagent publish --url <your-agent-url>\n`);
+        }
+    });
+}