codebot-ai 1.0.0

package/dist/setup.js

@@ -0,0 +1,243 @@
+"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.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.isFirstRun = isFirstRun;
+exports.runSetup = runSetup;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const readline = __importStar(require("readline"));
+const registry_1 = require("./providers/registry");
+const CONFIG_DIR = path.join(os.homedir(), '.codebot');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+/** Load saved config from ~/.codebot/config.json */
+function loadConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'));
+        }
+    }
+    catch {
+        // corrupt config, ignore
+    }
+    return {};
+}
+/** Save config to ~/.codebot/config.json */
+function saveConfig(config) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    // Never persist API keys to disk — use env vars
+    const safe = { ...config };
+    delete safe.apiKey;
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(safe, null, 2) + '\n');
+}
+/** Check if this is the first run (no config, no env keys) */
+function isFirstRun() {
+    if (fs.existsSync(CONFIG_FILE))
+        return false;
+    // Check if any provider API keys are set
+    const envKeys = [
+        'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY',
+        'DEEPSEEK_API_KEY', 'GROQ_API_KEY', 'MISTRAL_API_KEY',
+        'XAI_API_KEY', 'CODEBOT_API_KEY',
+    ];
+    for (const key of envKeys) {
+        if (process.env[key])
+            return false;
+    }
+    return true;
+}
+/** Detect what local LLM servers are running */
+async function detectLocalServers() {
+    const servers = [];
+    const candidates = [
+        { url: 'http://localhost:11434', name: 'Ollama' },
+        { url: 'http://localhost:1234', name: 'LM Studio' },
+        { url: 'http://localhost:8000', name: 'vLLM' },
+    ];
+    for (const { url, name } of candidates) {
+        try {
+            const res = await fetch(`${url}/v1/models`, {
+                signal: AbortSignal.timeout(2000),
+            });
+            if (res.ok) {
+                const data = await res.json();
+                const models = (data.data || []).map(m => m.id);
+                servers.push({ name, url, models });
+            }
+        }
+        catch {
+            // not running
+        }
+    }
+    return servers;
+}
+/** Detect which cloud API keys are available */
+function detectApiKeys() {
+    return Object.entries(registry_1.PROVIDER_DEFAULTS).map(([provider, defaults]) => ({
+        provider,
+        envVar: defaults.envKey,
+        set: !!process.env[defaults.envKey],
+    }));
+}
+const C = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+function fmt(text, style) {
+    return `${C[style]}${text}${C.reset}`;
+}
+function ask(rl, question) {
+    return new Promise(resolve => {
+        rl.question(question, answer => resolve(answer.trim()));
+    });
+}
+/** Interactive setup wizard */
+async function runSetup() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log(fmt('\n⚡ CodeBot AI — Setup', 'bold'));
+    console.log(fmt('   Let\'s get you configured.\n', 'dim'));
+    // Step 1: Detect local servers
+    console.log(fmt('Scanning for local LLM servers...', 'dim'));
+    const localServers = await detectLocalServers();
+    // Step 2: Detect API keys
+    const apiKeys = detectApiKeys();
+    const availableKeys = apiKeys.filter(k => k.set);
+    // Show what was found
+    if (localServers.length > 0) {
+        for (const server of localServers) {
+            console.log(fmt(`  ✓ ${server.name} detected (${server.models.length} models)`, 'green'));
+        }
+    }
+    else {
+        console.log(fmt('  No local LLM servers detected.', 'dim'));
+    }
+    if (availableKeys.length > 0) {
+        for (const key of availableKeys) {
+            console.log(fmt(`  ✓ ${key.provider} API key found (${key.envVar})`, 'green'));
+        }
+    }
+    const missingKeys = apiKeys.filter(k => !k.set);
+    if (missingKeys.length > 0 && localServers.length === 0) {
+        console.log(fmt('\n  No API keys found. Set one to use cloud models:', 'yellow'));
+        for (const key of missingKeys) {
+            console.log(fmt(`    export ${key.envVar}="your-key-here"`, 'dim'));
+        }
+    }
+    // Step 3: Choose provider
+    console.log(fmt('\nChoose your setup:', 'bold'));
+    const options = [];
+    let idx = 1;
+    // Local options first
+    for (const server of localServers) {
+        const defaultModel = server.models[0] || 'qwen2.5-coder:32b';
+        options.push({ label: `${server.name} (local, free)`, provider: 'openai', model: defaultModel, baseUrl: server.url });
+        console.log(`  ${fmt(`${idx}`, 'cyan')} ${server.name} — ${defaultModel} ${fmt('(local, free, private)', 'green')}`);
+        idx++;
+    }
+    // Cloud options
+    for (const key of availableKeys) {
+        const models = Object.entries(registry_1.MODEL_REGISTRY)
+            .filter(([, info]) => info.provider === key.provider)
+            .map(([name]) => name);
+        const defaultModel = models[0] || key.provider;
+        const defaults = registry_1.PROVIDER_DEFAULTS[key.provider];
+        options.push({ label: key.provider, provider: key.provider, model: defaultModel, baseUrl: defaults.baseUrl });
+        console.log(`  ${fmt(`${idx}`, 'cyan')} ${key.provider} — ${defaultModel} ${fmt('(cloud)', 'dim')}`);
+        idx++;
+    }
+    if (options.length === 0) {
+        console.log(fmt('\n  No providers available. Either:', 'yellow'));
+        console.log(fmt('    1. Install Ollama: https://ollama.ai', 'dim'));
+        console.log(fmt('    2. Set an API key: export ANTHROPIC_API_KEY="..."', 'dim'));
+        rl.close();
+        return {};
+    }
+    const choice = await ask(rl, fmt(`\nSelect [1-${options.length}]: `, 'cyan'));
+    const selected = options[parseInt(choice, 10) - 1] || options[0];
+    // Step 4: Show available models for chosen provider
+    const providerModels = Object.entries(registry_1.MODEL_REGISTRY)
+        .filter(([, info]) => {
+        if (selected.provider === 'openai' && !info.provider)
+            return true; // local models
+        return info.provider === selected.provider;
+    })
+        .map(([name]) => name);
+    if (providerModels.length > 1) {
+        console.log(fmt(`\nAvailable models for ${selected.label}:`, 'bold'));
+        providerModels.slice(0, 10).forEach((m, i) => {
+            const marker = m === selected.model ? fmt(' (default)', 'green') : '';
+            console.log(`  ${fmt(`${i + 1}`, 'cyan')} ${m}${marker}`);
+        });
+        const modelChoice = await ask(rl, fmt(`\nModel [Enter for ${selected.model}]: `, 'cyan'));
+        if (modelChoice) {
+            const modelIdx = parseInt(modelChoice, 10) - 1;
+            if (providerModels[modelIdx]) {
+                selected.model = providerModels[modelIdx];
+            }
+            else if (modelChoice.length > 2) {
+                // Treat as model name
+                selected.model = modelChoice;
+            }
+        }
+    }
+    // Step 5: Auto mode?
+    const autoChoice = await ask(rl, fmt('\nEnable autonomous mode? (skip permission prompts) [y/N]: ', 'cyan'));
+    const autoApprove = autoChoice.toLowerCase().startsWith('y');
+    rl.close();
+    // Save config
+    const config = {
+        model: selected.model,
+        provider: selected.provider,
+        baseUrl: selected.baseUrl,
+        autoApprove,
+    };
+    saveConfig(config);
+    console.log(fmt('\n✓ Config saved to ~/.codebot/config.json', 'green'));
+    console.log(fmt(`  Model: ${config.model}`, 'dim'));
+    console.log(fmt(`  Provider: ${config.provider}`, 'dim'));
+    if (autoApprove) {
+        console.log(fmt(`  Mode: AUTONOMOUS`, 'yellow'));
+    }
+    console.log(fmt(`\nRun ${fmt('codebot', 'bold')} to start. Run ${fmt('codebot --setup', 'bold')} to reconfigure.\n`, 'dim'));
+    return config;
+}
+//# sourceMappingURL=setup.js.map

package/dist/tools/browser.d.ts

@@ -0,0 +1,43 @@
+import { Tool } from '../types';
+export declare class BrowserTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            url: {
+                type: string;
+                description: string;
+            };
+            selector: {
+                type: string;
+                description: string;
+            };
+            text: {
+                type: string;
+                description: string;
+            };
+            expression: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private navigate;
+    private getContent;
+    private screenshot;
+    private click;
+    private typeText;
+    private evaluate;
+    private listTabs;
+    private closeBrowser;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/tools/browser.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserTool = void 0;
+const cdp_1 = require("../browser/cdp");
+const child_process_1 = require("child_process");
+// Shared browser instance across tool calls
+let client = null;
+let debugPort = 9222;
+async function ensureConnected() {
+    if (client?.isConnected())
+        return client;
+    // Try connecting to existing Chrome
+    try {
+        const wsUrl = await (0, cdp_1.getDebuggerUrl)(debugPort);
+        client = new cdp_1.CDPClient();
+        await client.connect(wsUrl);
+        // Get or create a page target
+        const targets = await (0, cdp_1.getTargets)(debugPort);
+        const page = targets.find(t => t.url !== 'about:blank' && !t.url.startsWith('devtools://'))
+            || targets[0];
+        if (page?.webSocketDebuggerUrl) {
+            client.close();
+            client = new cdp_1.CDPClient();
+            await client.connect(page.webSocketDebuggerUrl);
+        }
+        await client.send('Page.enable');
+        await client.send('Runtime.enable');
+        return client;
+    }
+    catch {
+        // Chrome not running with debugging — try to launch it
+    }
+    // Launch Chrome with debugging
+    const chromePaths = process.platform === 'win32'
+        ? [
+            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe',
+            'C:\\Program Files\\Microsoft\\Edge\\Application\\msedge.exe',
+        ]
+        : process.platform === 'linux'
+            ? [
+                'google-chrome',
+                'google-chrome-stable',
+                'chromium',
+                'chromium-browser',
+                '/usr/bin/google-chrome',
+                '/usr/bin/chromium',
+                '/snap/bin/chromium',
+            ]
+            : [
+                '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+                '/Applications/Chromium.app/Contents/MacOS/Chromium',
+                '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+                'google-chrome',
+                'chromium',
+            ];
+    let launched = false;
+    for (const chromePath of chromePaths) {
+        try {
+            (0, child_process_1.execSync)(`"${chromePath}" --remote-debugging-port=${debugPort} --no-first-run --no-default-browser-check about:blank &`, { stdio: 'ignore', timeout: 5000 });
+            launched = true;
+            break;
+        }
+        catch {
+            continue;
+        }
+    }
+    if (!launched) {
+        throw new Error('Could not launch Chrome. Start Chrome manually with:\n' +
+            `  chrome --remote-debugging-port=${debugPort}\n` +
+            'Or on macOS:\n' +
+            `  /Applications/Google\\ Chrome.app/Contents/MacOS/Google\\ Chrome --remote-debugging-port=${debugPort}`);
+    }
+    // Wait for Chrome to start
+    for (let i = 0; i < 10; i++) {
+        try {
+            await new Promise(r => setTimeout(r, 500));
+            const wsUrl = await (0, cdp_1.getDebuggerUrl)(debugPort);
+            client = new cdp_1.CDPClient();
+            await client.connect(wsUrl);
+            const targets = await (0, cdp_1.getTargets)(debugPort);
+            const page = targets[0];
+            if (page?.webSocketDebuggerUrl) {
+                client.close();
+                client = new cdp_1.CDPClient();
+                await client.connect(page.webSocketDebuggerUrl);
+            }
+            await client.send('Page.enable');
+            await client.send('Runtime.enable');
+            return client;
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error('Chrome launched but could not connect via CDP');
+}
+class BrowserTool {
+    name = 'browser';
+    description = 'Control a web browser. Navigate to URLs, read page content, click elements, type text, run JavaScript, take screenshots. Use for web browsing, social media, testing, and automation.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: 'Action to perform',
+                enum: ['navigate', 'content', 'screenshot', 'click', 'type', 'evaluate', 'tabs', 'close'],
+            },
+            url: { type: 'string', description: 'URL to navigate to (for navigate action)' },
+            selector: { type: 'string', description: 'CSS selector for element (for click/type)' },
+            text: { type: 'string', description: 'Text to type (for type action)' },
+            expression: { type: 'string', description: 'JavaScript to evaluate (for evaluate action)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        try {
+            switch (action) {
+                case 'navigate':
+                    return await this.navigate(args.url);
+                case 'content':
+                    return await this.getContent();
+                case 'screenshot':
+                    return await this.screenshot();
+                case 'click':
+                    return await this.click(args.selector);
+                case 'type':
+                    return await this.typeText(args.selector, args.text);
+                case 'evaluate':
+                    return await this.evaluate(args.expression);
+                case 'tabs':
+                    return await this.listTabs();
+                case 'close':
+                    return this.closeBrowser();
+                default:
+                    return `Unknown action: ${action}. Use: navigate, content, screenshot, click, type, evaluate, tabs, close`;
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Browser error: ${msg}`;
+        }
+    }
+    async navigate(url) {
+        if (!url)
+            return 'Error: url is required';
+        const cdp = await ensureConnected();
+        // Auto-add protocol
+        if (!url.startsWith('http://') && !url.startsWith('https://')) {
+            url = 'https://' + url;
+        }
+        await cdp.send('Page.navigate', { url });
+        // Wait for page load
+        await new Promise(r => setTimeout(r, 2000));
+        // Get page title
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: 'document.title',
+            returnByValue: true,
+        });
+        const title = result.result?.value || 'untitled';
+        return `Navigated to: ${url}\nTitle: ${title}`;
+    }
+    async getContent() {
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          // Remove scripts and styles
+          const clone = document.body.cloneNode(true);
+          clone.querySelectorAll('script, style, noscript, svg, iframe').forEach(el => el.remove());
+
+          // Get text content, preserving structure
+          function getText(node, depth) {
+            if (depth > 10) return '';
+            let text = '';
+            for (const child of node.childNodes) {
+              if (child.nodeType === 3) {
+                text += child.textContent.trim() + ' ';
+              } else if (child.nodeType === 1) {
+                const tag = child.tagName.toLowerCase();
+                if (['div', 'p', 'br', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'tr', 'section', 'article'].includes(tag)) {
+                  text += '\\n';
+                }
+                // Include link hrefs
+                if (tag === 'a' && child.href) {
+                  text += getText(child, depth + 1) + ' [' + child.href + '] ';
+                } else if (tag === 'img' && child.alt) {
+                  text += '[image: ' + child.alt + '] ';
+                } else {
+                  text += getText(child, depth + 1);
+                }
+              }
+            }
+            return text;
+          }
+
+          let content = 'URL: ' + window.location.href + '\\n';
+          content += 'Title: ' + document.title + '\\n\\n';
+          content += getText(clone, 0);
+          return content.replace(/\\n\\s*\\n\\s*\\n/g, '\\n\\n').substring(0, 30000);
+        })()
+      `,
+            returnByValue: true,
+        });
+        return result.result?.value || 'No content';
+    }
+    async screenshot() {
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Page.captureScreenshot', { format: 'png' });
+        const data = result.data;
+        if (!data)
+            return 'Failed to capture screenshot';
+        // Save to temp file
+        const fs = require('fs');
+        const path = require('path');
+        const os = require('os');
+        const filePath = path.join(os.tmpdir(), `codebot-screenshot-${Date.now()}.png`);
+        fs.writeFileSync(filePath, Buffer.from(data, 'base64'));
+        return `Screenshot saved: ${filePath} (${Math.round(data.length * 0.75 / 1024)}KB)`;
+    }
+    async click(selector) {
+        if (!selector)
+            return 'Error: selector is required';
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (!el) return 'Element not found: ${selector}';
+          el.click();
+          return 'Clicked: ' + (el.tagName || '') + ' ' + (el.textContent || '').substring(0, 50).trim();
+        })()
+      `,
+            returnByValue: true,
+        });
+        return result.result?.value || 'Click executed';
+    }
+    async typeText(selector, text) {
+        if (!selector)
+            return 'Error: selector is required';
+        if (!text)
+            return 'Error: text is required';
+        const cdp = await ensureConnected();
+        // Focus the element
+        await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (el) { el.focus(); el.value = ''; }
+        })()
+      `,
+        });
+        // Type character by character using Input.dispatchKeyEvent
+        for (const char of text) {
+            await cdp.send('Input.dispatchKeyEvent', {
+                type: 'keyDown',
+                text: char,
+                key: char,
+                code: `Key${char.toUpperCase()}`,
+            });
+            await cdp.send('Input.dispatchKeyEvent', {
+                type: 'keyUp',
+                key: char,
+                code: `Key${char.toUpperCase()}`,
+            });
+        }
+        // Also set value directly as fallback
+        await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (el) {
+            el.value = ${JSON.stringify(text)};
+            el.dispatchEvent(new Event('input', { bubbles: true }));
+            el.dispatchEvent(new Event('change', { bubbles: true }));
+          }
+        })()
+      `,
+        });
+        return `Typed "${text.length > 50 ? text.substring(0, 50) + '...' : text}" into ${selector}`;
+    }
+    async evaluate(expression) {
+        if (!expression)
+            return 'Error: expression is required';
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Runtime.evaluate', {
+            expression,
+            returnByValue: true,
+            awaitPromise: true,
+        });
+        const val = result.result;
+        if (val?.type === 'undefined')
+            return 'undefined';
+        if (val?.value !== undefined) {
+            return typeof val.value === 'string' ? val.value : JSON.stringify(val.value, null, 2);
+        }
+        const exception = result.exceptionDetails;
+        if (exception) {
+            const ex = exception.exception;
+            return `Error: ${ex?.description || ex?.value || 'Unknown error'}`;
+        }
+        return JSON.stringify(val, null, 2);
+    }
+    async listTabs() {
+        try {
+            const targets = await (0, cdp_1.getTargets)(debugPort);
+            if (targets.length === 0)
+                return 'No tabs open.';
+            return targets
+                .filter(t => t.url && !t.url.startsWith('devtools://'))
+                .map((t, i) => `${i + 1}. ${t.title || '(no title)'}\n   ${t.url}`)
+                .join('\n');
+        }
+        catch {
+            return 'Browser not connected. Use navigate first.';
+        }
+    }
+    closeBrowser() {
+        if (client) {
+            client.close();
+            client = null;
+        }
+        return 'Browser connection closed.';
+    }
+}
+exports.BrowserTool = BrowserTool;
+//# sourceMappingURL=browser.js.map

package/dist/tools/edit.d.ts

@@ -0,0 +1,26 @@
+import { Tool } from '../types';
+export declare class EditFileTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            path: {
+                type: string;
+                description: string;
+            };
+            old_string: {
+                type: string;
+                description: string;
+            };
+            new_string: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+}
+//# sourceMappingURL=edit.d.ts.map