@ceo-ai/cli 1.0.2

package/README.md

@@ -0,0 +1,301 @@
+## CLI README  
+  
+### `ceo-cli/README.md`  
+  
+```
+`markdown  
+# @ceo-ai/cli  
+  
+Command-line interface for the CEO.AI API. Send prompts to your AI agents, poll for results, and manage your configuration — all from the terminal.  
+  
+## Installation  
+  
+
+```bash  
+npm install -g @ceo-ai/cli  
+```
+  
+  
+## Quick Start  
+  
+
+```bash  
+# 1. Configure your API key  
+ceo configure --key sk_live_your_api_key_here  
+  
+# 2. Send a prompt and wait for the result  
+ceo prompt "What was our Q4 revenue?" --poll  
+  
+# 3. That's it!  
+```
+  
+  
+## Configuration  
+  
+### Interactive Setup  
+  
+
+```bash  
+ceo configure  
+```
+  
+  
+You'll be prompted for:  
+- **API Key** — your `sk_live_...` key from the CEO.AI dashboard  
+- **Endpoint** — the API URL (defaults to `https://ingestion.api.ceo.ai`)  
+  
+### Inline Setup  
+  
+
+```bash  
+ceo configure --key sk_live_abc123 --endpoint https://ingestion.api.ceo.ai  
+```
+  
+  
+### View Current Config  
+  
+
+```bash  
+ceo config:show  
+```
+  
+  
+
+```  
+Current Configuration:  
+  
+  Endpoint:  https://ingestion.api.ceo.ai  
+  API Key:   sk_live_abc1••••••••def4  
+```
+  
+  
+Your configuration is stored in `~/.ceo-ai/config.json` with restricted file permissions (`0600`).  
+  
+## Commands  
+  
+### `ceo prompt <text>`  
+  
+Send a prompt to your AI agent.  
+  
+
+```bash  
+# Basic — returns the presigned URL immediately  
+ceo prompt "What was our Q4 revenue?"  
+  
+# Wait for the result  
+ceo prompt "What was our Q4 revenue?" --poll  
+  
+# Save result to a file  
+ceo prompt "What was our Q4 revenue?" --poll -o result.json  
+  
+# Disable RAG mode  
+ceo prompt "What is 2+2?" --no-rag --poll  
+  
+# Raw JSON output (useful for piping)  
+ceo prompt "What was our Q4 revenue?" --poll --json  
+  
+# Override API key for a single request  
+ceo prompt "Hello" --key sk_live_different_key --poll  
+  
+# Custom polling settings  
+ceo prompt "Complex query..." --poll --poll-interval 5000 --poll-timeout 300000  
+```
+  
+  
+**Options:**  
+  
+| Flag | Description | Default |  
+|------|-------------|---------|  
+| `--poll` | Wait for results instead of returning the presigned URL | `false` |  
+| `--poll-interval <ms>` | How often to check for results | `2000` |  
+| `--poll-timeout <ms>` | Maximum time to wait for results | `120000` |  
+| `--no-rag` | Disable RAG mode (RAG is enabled by default) | — |  
+| `-o, --output <file>` | Write results to a file (implies `--poll`) | — |  
+| `-k, --key <apiKey>` | Override the configured API key | — |  
+| `-e, --endpoint <url>` | Override the configured endpoint | — |  
+| `--json` | Output raw JSON | `false` |  
+  
+### `ceo poll <url>`  
+  
+Poll an existing presigned URL for results. Useful if you submitted a prompt earlier and want to check for results later.  
+  
+
+```bash  
+# Poll a presigned URL  
+ceo poll "https://ceo-ai-api-output-results.s3.amazonaws.com/api-data/..."  
+  
+# Save to file  
+ceo poll "https://..." -o result.json  
+  
+# Custom interval and timeout  
+ceo poll "https://..." --interval 5000 --timeout 300000  
+  
+# Raw JSON output  
+ceo poll "https://..." --json  
+```
+  
+  
+**Options:**  
+  
+| Flag | Description | Default |  
+|------|-------------|---------|  
+| `--interval <ms>` | Polling interval | `2000` |  
+| `--timeout <ms>` | Maximum wait time | `120000` |  
+| `-o, --output <file>` | Write results to a file | — |  
+| `--json` | Output raw JSON | `false` |  
+  
+### `ceo configure`  
+  
+Set your API key and endpoint.  
+  
+
+```bash  
+# Interactive  
+ceo configure  
+  
+# Inline  
+ceo configure --key sk_live_abc123  
+ceo configure --endpoint https://custom.endpoint.com  
+ceo configure --key sk_live_abc123 --endpoint https://custom.endpoint.com  
+```
+  
+  
+### `ceo config:show`  
+  
+Display the current configuration (API key is masked).  
+  
+## Examples  
+  
+### Basic Prompt and Poll  
+  
+
+```bash  
+$ ceo prompt "Summarize our sales performance this quarter" --poll  
+  
+✓ Request submitted  
+  Agent:     Sales Analyst  
+  Model:     gpt-4  
+  Credits:   1500  
+⠋ Waiting for results... (attempt 12)  
+✓ Results received  
+  
+--- Response ---  
+  
+Based on the available data, here are the key highlights...  
+```
+  
+  
+### Save Results to File  
+  
+
+```bash  
+$ ceo prompt "Generate a detailed financial report" --poll -o report.json  
+✓ Request submitted  
+✓ Results received  
+  
+✓ Results written to /Users/you/report.json  
+```
+  
+  
+### Pipe JSON Output  
+  
+
+```bash  
+# Pipe to jq for processing  
+ceo prompt "List all customers" --poll --json | jq '.response.customers'  
+  
+# Pipe to another command  
+ceo prompt "Get metrics" --poll --json > metrics.json  
+```
+  
+  
+### Two-Step Workflow  
+  
+
+```bash  
+# Step 1: Submit prompt, get presigned URL  
+$ ceo prompt "Long running analysis..."  
+  
+✓ Request submitted  
+  Agent:     Data Analyst  
+  Model:     claude-sonnet-4-5  
+  Credits:   3000  
+  
+  Presigned URL:  
+  https://ceo-ai-api-output-results.s3.amazonaws.com/api-data/abc/def/1234.json?X-Amz-...  
+  
+  Use --poll to wait for results, or fetch the URL when ready.  
+  
+# Step 2: Later, poll for results  
+$ ceo poll "https://ceo-ai-api-output-results.s3.amazonaws.com/api-data/abc/def/1234.json?X-Amz-..."  
+  
+✓ Results received  
+  
+--- Response ---  
+  
+Analysis complete...  
+```
+  
+  
+### Environment Variable Override  
+  
+You can also provide your API key via an environment variable:  
+  
+
+```bash  
+CEO_API_KEY=sk_live_abc123 ceo prompt "Hello" --poll  
+```
+  
+  
+## Error Handling  
+  
+The CLI provides clear error messages:  
+  
+
+```bash  
+# No API key configured  
+$ ceo prompt "Hello"  
+Error: No API key configured. Run: ceo configure  
+  
+# Invalid API key  
+$ ceo prompt "Hello" --key invalid_key  
+Error: Invalid API key format  
+  
+# Insufficient credits  
+$ ceo prompt "Hello" --poll  
+✗ Request failed  
+  Error: You need 1500 credits but only have 200 available.  
+  Details: {"requiredCredits":1500,"availableCredits":200,"deficit":1300}  
+  
+# Polling timeout  
+$ ceo prompt "Hello" --poll --poll-timeout 5000  
+✗ Polling failed  
+  Error: Polling timed out after 5000ms (3 attempts)  
+```
+  
+  
+## Getting Your API Key  
+  
+1. Log in to [CEO.AI Dashboard](https://app.ceo.ai)  
+2. Navigate to **API Keys**  
+3. Click **Create API Key**  (NB: you must have a paid subscription to create api keys)
+4. Select the agent you want to use  
+5. Copy the generated key (it will only be shown once)  
+  
+## Uninstall  
+  
+
+```bash  
+npm uninstall -g @ceo-ai/cli  
+  
+# Optionally remove config  
+rm -rf ~/.ceo-ai  
+```
+  
+  
+## Requirements  
+  
+- Node.js 16 or later  
+- A CEO.AI account with an active API key and sufficient credits  
+  
+  

package/bin/ceo.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node  
+  
+const { Command } = require('commander');  
+const chalk = require('chalk');  
+const { CeoClient } = require('../lib/client');  
+const { ConfigManager } = require('../lib/config');  
+const ora = require('ora');  
+const fs = require('fs');  
+const path = require('path');  
+const pkg = require('../package.json');  
+  
+const program = new Command();  
+const config = new ConfigManager();  
+  
+program  
+    .name('ceo')  
+    .description('CLI for CEO.AI API')  
+    .version(pkg.version);  
+  
+// ---- Configure API key ----  
+  
+program  
+    .command('configure')  
+    .description('Set your API key and endpoint')  
+    .option('-k, --key <apiKey>', 'API key (sk_live_...)')  
+    .option('-e, --endpoint <url>', 'API endpoint URL')  
+    .action(async (opts) => {    
+        if (opts.key) {    
+            config.set('apiKey', opts.key);    
+            console.log(chalk.green('✓ API key saved'));    
+        }    
+    
+        if (opts.endpoint) {    
+            config.set('endpoint', opts.endpoint);    
+            console.log(chalk.green('✓ Endpoint saved'));    
+        }    
+    
+        // Only go interactive if neither flag was provided    
+        if (!opts.key && !opts.endpoint) {    
+            const readline = require('readline');    
+            const rl = readline.createInterface({    
+                input: process.stdin,    
+                output: process.stdout    
+            });    
+    
+            const ask = (question) => new Promise((resolve) => {    
+                rl.question(question, resolve);    
+            });    
+    
+            const apiKey = await ask('Enter your API key (sk_live_...): ');    
+            if (apiKey.trim()) {    
+                config.set('apiKey', apiKey.trim());    
+                console.log(chalk.green('✓ API key saved'));    
+            }    
+    
+            const endpoint = await ask(`API endpoint [${config.get('endpoint') || 'https://injestion.api.ceo.ai'}]: `);    
+            if (endpoint.trim()) {    
+                config.set('endpoint', endpoint.trim());    
+                console.log(chalk.green('✓ Endpoint saved'));    
+            }    
+    
+            rl.close();    
+        }    
+    });    
+  
+// ---- Show current config ----  
+  
+program  
+    .command('config:show')  
+    .description('Show current configuration')  
+    .action(() => {  
+        const apiKey = config.get('apiKey');  
+        const endpoint = config.get('endpoint') || 'https://injestion.api.ceo.ai';  
+  
+        console.log(chalk.bold('\nCurrent Configuration:\n'));  
+        console.log(`  Endpoint:  ${chalk.cyan(endpoint)}`);  
+  
+        if (apiKey) {  
+            const masked = apiKey.substring(0, 12) + '••••••••' + apiKey.substring(apiKey.length - 4);  
+            console.log(`  API Key:   ${chalk.cyan(masked)}`);  
+        } else {  
+            console.log(`  API Key:   ${chalk.yellow('Not set')}`);  
+        }  
+        console.log();  
+    });  
+  
+// ---- Send a prompt ----  
+  
+program  
+    .command('prompt')  
+    .description('Send a prompt to your agent')  
+    .argument('<text>', 'The prompt text to send')  
+    .option('--no-rag', 'Disable RAG mode')  
+    .option('--poll', 'Poll for results and display them')  
+    .option('--poll-interval <ms>', 'Polling interval in milliseconds', '2000')  
+    .option('--poll-timeout <ms>', 'Max time to wait for results', '120000')  
+    .option('-o, --output <file>', 'Write result to file (implies --poll)')  
+    .option('-k, --key <apiKey>', 'Override configured API key')  
+    .option('-e, --endpoint <url>', 'Override configured endpoint')  
+    .option('--json', 'Output raw JSON response')  
+    .action(async (text, opts) => {  
+        const apiKey = opts.key || config.get('apiKey');  
+        const endpoint = opts.endpoint || config.get('endpoint') || 'https://injestion.api.ceo.ai';  
+  
+        if (!apiKey) {  
+            console.error(chalk.red('Error: No API key configured. Run: ceo configure'));  
+            process.exit(1);  
+        }  
+  
+        const client = new CeoClient({ apiKey, endpoint });  
+        const spinner = ora('Sending prompt...').start();  
+  
+        try {  
+            const result = await client.prompt(text, {  
+                ragMode: opts.rag !== false  
+            });  
+  
+            spinner.succeed('Request submitted');  
+  
+            if (!opts.json) {  
+                console.log(chalk.dim(`  Agent:     ${result.agentName || result.agentId}`));  
+                console.log(chalk.dim(`  Model:     ${result.model || 'N/A'}`));  
+                console.log(chalk.dim(`  Credits:   ${result.estimatedCredits || 'N/A'}`));  
+            }  
+  
+            // If --poll or --output, wait for results  
+            if (opts.poll || opts.output) {  
+                spinner.start('Waiting for results...');  
+  
+                const pollInterval = parseInt(opts.pollInterval);  
+                const pollTimeout = parseInt(opts.pollTimeout);  
+  
+                const response = await client.pollForResult(result.presignedUrl, {  
+                    interval: pollInterval,  
+                    timeout: pollTimeout,  
+                    onPoll: (attempt) => {  
+                        spinner.text = `Waiting for results... (attempt ${attempt})`;  
+                    }  
+                });  
+  
+                spinner.succeed('Results received');  
+  
+                if (opts.output) {  
+                    const outputPath = path.resolve(opts.output);  
+                    const content = typeof response === 'string' ? response : JSON.stringify(response, null, 2);  
+                    fs.writeFileSync(outputPath, content);  
+                    console.log(chalk.green(`\n✓ Results written to ${outputPath}`));  
+                } else if (opts.json) {  
+                    console.log(JSON.stringify(response, null, 2));  
+                } else {  
+                    console.log(chalk.bold('\n--- Response ---\n'));  
+                    const content = typeof response === 'string' ? response : JSON.stringify(response, null, 2);  
+                    console.log(content);  
+                    console.log();  
+                }  
+            } else {  
+                // Just show the presigned URL  
+                if (opts.json) {  
+                    console.log(JSON.stringify(result, null, 2));  
+                } else {  
+                    console.log(chalk.bold('\n  Presigned URL:'));  
+                    console.log(chalk.cyan(`  ${result.presignedUrl}`));  
+                    console.log(chalk.dim('\n  Use --poll to wait for results, or fetch the URL when ready.\n'));  
+                }  
+            }  
+  
+        } catch (error) {  
+            spinner.fail('Request failed');  
+            console.error(chalk.red(`\n  Error: ${error.message}`));  
+  
+            if (error.details) {  
+                console.error(chalk.yellow(`  Details: ${JSON.stringify(error.details)}`));  
+            }  
+  
+            process.exit(1);  
+        }  
+    });  
+  
+// ---- Poll an existing presigned URL ----  
+  
+program  
+    .command('poll')  
+    .description('Poll an existing presigned URL for results')  
+    .argument('<url>', 'Presigned URL to poll')  
+    .option('--interval <ms>', 'Polling interval in milliseconds', '2000')  
+    .option('--timeout <ms>', 'Max time to wait', '120000')  
+    .option('-o, --output <file>', 'Write result to file')  
+    .option('--json', 'Output raw JSON')  
+    .action(async (url, opts) => {  
+        const client = new CeoClient({ apiKey: 'unused', endpoint: 'unused' });  
+        const spinner = ora('Polling for results...').start();  
+  
+        try {  
+            const response = await client.pollForResult(url, {  
+                interval: parseInt(opts.interval),  
+                timeout: parseInt(opts.timeout),  
+                onPoll: (attempt) => {  
+                    spinner.text = `Polling for results... (attempt ${attempt})`;  
+                }  
+            });  
+  
+            spinner.succeed('Results received');  
+  
+            if (opts.output) {  
+                const outputPath = path.resolve(opts.output);  
+                const content = typeof response === 'string' ? response : JSON.stringify(response, null, 2);  
+                fs.writeFileSync(outputPath, content);  
+                console.log(chalk.green(`\n✓ Results written to ${outputPath}`));  
+            } else if (opts.json) {  
+                console.log(JSON.stringify(response, null, 2));  
+            } else {  
+                console.log(chalk.bold('\n--- Response ---\n'));  
+                const content = typeof response === 'string' ? response : JSON.stringify(response, null, 2);  
+                console.log(content);  
+                console.log();  
+            }  
+        } catch (error) {  
+            spinner.fail('Polling failed');  
+            console.error(chalk.red(`\n  Error: ${error.message}`));  
+            process.exit(1);  
+        }  
+    });  
+  
+program.parse();  

package/lib/client.js

@@ -0,0 +1,170 @@
+const https = require('https');  
+const http = require('http');  
+  
+class CeoClient {  
+    constructor({ apiKey, endpoint }) {  
+        this.apiKey = apiKey;  
+        this.endpoint = endpoint;  
+    }  
+  
+    /**  
+     * Send a prompt  
+     */  
+    async prompt(text, options = {}) {  
+        const body = {  
+            prompt: text,  
+            ...(options.ragMode !== undefined && { ragMode: options.ragMode }),  
+            ...(options.conversationHistory && { conversationHistory: options.conversationHistory })  
+        };  
+  
+        const response = await this._request('POST', this.endpoint, body);  
+  
+        if (response.error) {  
+            const error = new Error(response.error || response.message);  
+            error.details = response.details;  
+            error.statusCode = response.statusCode;  
+            throw error;  
+        }  
+  
+        return response.data || response;  
+    }  
+  
+    /**  
+     * Poll a presigned URL until content is available  
+     */  
+    async pollForResult(presignedUrl, options = {}) {  
+        const {  
+            interval = 2000,  
+            timeout = 120000,  
+            onPoll = null  
+        } = options;  
+  
+        const startTime = Date.now();  
+        let attempt = 0;  
+  
+        while (Date.now() - startTime < timeout) {  
+            attempt++;  
+  
+            if (onPoll) {  
+                onPoll(attempt);  
+            }  
+  
+            try {  
+                const result = await this._fetch(presignedUrl);  
+                // S3 returns the content when ready  
+                if (result !== null) {  
+                    // Try to parse as JSON  
+                    try {  
+                        return JSON.parse(result);  
+                    } catch {  
+                        return result;  
+                    }  
+                }  
+            } catch (error) {  
+                // 403/404 means the object doesn't exist yet - keep polling  
+                if (error.statusCode === 403 || error.statusCode === 404) {  
+                    // Expected - not ready yet  
+                } else {  
+                    throw error;  
+                }  
+            }  
+  
+            await this._sleep(interval);  
+        }  
+  
+        throw new Error(`Polling timed out after ${timeout}ms (${attempt} attempts)`);  
+    }  
+  
+    /**  
+     * Make an HTTP request to the API  
+     */  
+    _request(method, url, body = null) {  
+        return new Promise((resolve, reject) => {  
+            const parsedUrl = new URL(url);  
+            const isHttps = parsedUrl.protocol === 'https:';  
+            const lib = isHttps ? https : http;  
+  
+            const payload = body ? JSON.stringify(body) : null;  
+  
+            const options = {  
+                hostname: parsedUrl.hostname,  
+                port: parsedUrl.port || (isHttps ? 443 : 80),  
+                path: parsedUrl.pathname + parsedUrl.search,  
+                method,  
+                headers: {  
+                    'Authorization': `Bearer ${this.apiKey}`,  
+                    'Content-Type': 'application/json',  
+                    ...(payload && { 'Content-Length': Buffer.byteLength(payload) })  
+                }  
+            };  
+  
+            const req = lib.request(options, (res) => {  
+                let data = '';  
+                res.on('data', (chunk) => { data += chunk; });  
+                res.on('end', () => {  
+                    try {  
+                        const parsed = JSON.parse(data);  
+                        if (res.statusCode >= 400) {  
+                            parsed.statusCode = res.statusCode;  
+                        }  
+                        resolve(parsed);  
+                    } catch {  
+                        resolve({ data: data, statusCode: res.statusCode });  
+                    }  
+                });  
+            });  
+  
+            req.on('error', reject);  
+            req.setTimeout(30000, () => {  
+                req.destroy();  
+                reject(new Error('Request timed out'));  
+            });  
+  
+            if (payload) req.write(payload);  
+            req.end();  
+        });  
+    }  
+  
+    /**  
+     * Fetch a URL (for presigned URL polling)  
+     */  
+    _fetch(url) {  
+        return new Promise((resolve, reject) => {  
+            const parsedUrl = new URL(url);  
+            const isHttps = parsedUrl.protocol === 'https:';  
+            const lib = isHttps ? https : http;  
+  
+            const req = lib.get(url, (res) => {  
+                if (res.statusCode === 403 || res.statusCode === 404) {  
+                    const error = new Error('Not ready');  
+                    error.statusCode = res.statusCode;  
+                    res.resume(); // Drain response  
+                    reject(error);  
+                    return;  
+                }  
+  
+                let data = '';  
+                res.on('data', (chunk) => { data += chunk; });  
+                res.on('end', () => {  
+                    if (res.statusCode >= 200 && res.statusCode < 300 && data.length > 0) {  
+                        resolve(data);  
+                    } else {  
+                        resolve(null);  
+                    }  
+                });  
+            });  
+  
+            req.on('error', reject);  
+            req.setTimeout(10000, () => {  
+                req.destroy();  
+                reject(new Error('Fetch timed out'));  
+            });  
+        });  
+    }  
+  
+    _sleep(ms) {  
+        return new Promise((resolve) => setTimeout(resolve, ms));  
+    }  
+}  
+  
+module.exports = { CeoClient };  

package/lib/config.js

@@ -0,0 +1,58 @@
+const fs = require('fs');  
+const path = require('path');  
+const os = require('os');  
+  
+class ConfigManager {  
+    constructor() {  
+        this.configDir = path.join(os.homedir(), '.ceo-ai');  
+        this.configFile = path.join(this.configDir, 'config.json');  
+        this._ensureConfigDir();  
+    }  
+  
+    _ensureConfigDir() {  
+        if (!fs.existsSync(this.configDir)) {  
+            fs.mkdirSync(this.configDir, { recursive: true, mode: 0o700 });  
+        }  
+    }  
+  
+    _read() {  
+        try {  
+            if (fs.existsSync(this.configFile)) {  
+                const content = fs.readFileSync(this.configFile, 'utf8');  
+                return JSON.parse(content);  
+            }  
+        } catch {  
+            // Corrupted config, start fresh  
+        }  
+        return {};  
+    }  
+  
+    _write(data) {  
+        fs.writeFileSync(  
+            this.configFile,  
+            JSON.stringify(data, null, 2),  
+            { mode: 0o600 } // Owner read/write only  
+        );  
+    }  
+  
+    get(key) {  
+        const data = this._read();  
+        return data[key];  
+    }  
+  
+    set(key, value) {  
+        const data = this._read();  
+        data[key] = value;  
+        this._write(data);  
+    }  
+  
+    getAll() {  
+        return this._read();  
+    }  
+  
+    clear() {  
+        this._write({});  
+    }  
+}  
+  
+module.exports = { ConfigManager };  

package/package.json

@@ -0,0 +1 @@
+{"name":"@ceo-ai/cli","version":"1.0.2","description":"CLI tool for CEO.AI API","bin":{"ceo":"./bin/ceo.js"},"files":["bin/","lib/"],"scripts":{"test":"node test/index.test.js"},"keywords":["ceo-ai","cli","ai","api"],"license":"MIT","dependencies":{"commander":"^12.1.0","chalk":"^4.1.2","conf":"^10.2.0","ora":"^5.4.1"}}