codebot-ai 1.0.2 → 1.1.1

package/dist/plugins.js

@@ -0,0 +1,101 @@
+"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.loadPlugins = loadPlugins;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Plugin system for CodeBot.
+ *
+ * Plugins are .js files in `.codebot/plugins/` (project) or `~/.codebot/plugins/` (global).
+ * Each plugin exports a default function or object that implements the Tool interface:
+ *
+ * module.exports = {
+ *   name: 'my_tool',
+ *   description: 'Does something useful',
+ *   permission: 'prompt',
+ *   parameters: { type: 'object', properties: { ... }, required: [...] },
+ *   execute: async (args) => { return 'result'; }
+ * };
+ */
+function loadPlugins(projectRoot) {
+    const plugins = [];
+    const os = require('os');
+    const dirs = [
+        path.join(os.homedir(), '.codebot', 'plugins'),
+    ];
+    if (projectRoot) {
+        dirs.push(path.join(projectRoot, '.codebot', 'plugins'));
+    }
+    for (const dir of dirs) {
+        if (!fs.existsSync(dir))
+            continue;
+        let entries;
+        try {
+            entries = fs.readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.js'))
+                continue;
+            try {
+                const pluginPath = path.join(dir, entry.name);
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const mod = require(pluginPath);
+                const plugin = mod.default || mod;
+                if (isValidTool(plugin)) {
+                    plugins.push(plugin);
+                }
+            }
+            catch (err) {
+                console.error(`Plugin load error (${entry.name}): ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    return plugins;
+}
+function isValidTool(obj) {
+    if (!obj || typeof obj !== 'object')
+        return false;
+    const t = obj;
+    return (typeof t.name === 'string' &&
+        typeof t.description === 'string' &&
+        typeof t.execute === 'function' &&
+        typeof t.parameters === 'object' &&
+        typeof t.permission === 'string');
+}
+//# sourceMappingURL=plugins.js.map

package/dist/providers/openai.js

@@ -20,6 +20,13 @@ class OpenAIProvider {
         if (tools?.length && this.supportsTools) {
             body.tools = tools;
         }
+        // Ollama/local provider optimizations: set context window and keep model loaded
+        const isLocal = this.config.baseUrl.includes('localhost') || this.config.baseUrl.includes('127.0.0.1');
+        if (isLocal) {
+            const modelInfo = (0, registry_1.getModelInfo)(this.config.model);
+            body.options = { num_ctx: modelInfo.contextWindow };
+            body.keep_alive = '30m';
+        }
         const headers = {
             'Content-Type': 'application/json',
         };

package/dist/setup.js

@@ -59,9 +59,9 @@ function loadConfig() {
 /** 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;
+    // Persist API key if user entered it during setup (convenience over env vars)
+    // The key is stored in the user's home directory with default permissions
     fs.writeFileSync(CONFIG_FILE, JSON.stringify(safe, null, 2) + '\n');
 }
 /** Check if this is the first run (no config, no env keys) */
@@ -113,6 +113,16 @@ function detectApiKeys() {
         set: !!process.env[defaults.envKey],
     }));
 }
+/** Cloud provider display info */
+const CLOUD_PROVIDERS = [
+    { provider: 'openai', name: 'OpenAI', defaultModel: 'gpt-4o', description: 'GPT-4o, GPT-4.1, o3/o4' },
+    { provider: 'anthropic', name: 'Anthropic', defaultModel: 'claude-sonnet-4-6', description: 'Claude Opus/Sonnet/Haiku' },
+    { provider: 'gemini', name: 'Google Gemini', defaultModel: 'gemini-2.5-flash', description: 'Gemini 2.5 Pro/Flash' },
+    { provider: 'deepseek', name: 'DeepSeek', defaultModel: 'deepseek-chat', description: 'DeepSeek Chat/Reasoner' },
+    { provider: 'groq', name: 'Groq', defaultModel: 'llama-3.3-70b-versatile', description: 'Fast Llama/Mixtral inference' },
+    { provider: 'mistral', name: 'Mistral', defaultModel: 'mistral-large-latest', description: 'Mistral Large, Codestral' },
+    { provider: 'xai', name: 'xAI', defaultModel: 'grok-3', description: 'Grok-3' },
+];
 const C = {
     reset: '\x1b[0m',
     bold: '\x1b[1m',
@@ -155,46 +165,58 @@ async function runSetup() {
             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
+    // Step 3: Choose provider — show ALL options (local + cloud)
     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 });
+        options.push({
+            label: `${server.name} (local, free)`,
+            provider: 'openai',
+            model: defaultModel,
+            baseUrl: server.url,
+            needsKey: false,
+        });
         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')}`);
+    // Cloud options — ALWAYS show all providers
+    for (const cloud of CLOUD_PROVIDERS) {
+        const keyInfo = apiKeys.find(k => k.provider === cloud.provider);
+        const hasKey = keyInfo?.set || false;
+        const defaults = registry_1.PROVIDER_DEFAULTS[cloud.provider];
+        const keyStatus = hasKey ? fmt('✓ key set', 'green') : fmt('enter key during setup', 'yellow');
+        options.push({
+            label: cloud.name,
+            provider: cloud.provider,
+            model: cloud.defaultModel,
+            baseUrl: defaults.baseUrl,
+            needsKey: !hasKey,
+            envVar: defaults.envKey,
+        });
+        console.log(`  ${fmt(`${idx}`, 'cyan')} ${cloud.name} — ${cloud.description} ${fmt(`(${keyStatus})`, '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
-    // For local servers, use the actual installed models instead of the hardcoded registry
+    // Step 4: If cloud provider needs API key, prompt for it
+    let apiKey = '';
+    if (selected.needsKey && selected.envVar) {
+        console.log(fmt(`\n  ${selected.label} requires an API key.`, 'yellow'));
+        console.log(fmt(`  Get one at: ${getKeyUrl(selected.provider)}`, 'dim'));
+        apiKey = await ask(rl, fmt(`\n  Enter your ${selected.label} API key: `, 'cyan'));
+        if (!apiKey) {
+            console.log(fmt(`\n  No key entered. You can set it later:`, 'yellow'));
+            console.log(fmt(`    export ${selected.envVar}="your-key-here"`, 'dim'));
+        }
+    }
+    else if (selected.envVar) {
+        // Use existing env var
+        apiKey = process.env[selected.envVar] || '';
+    }
+    // Step 5: Show available models for chosen provider
     const matchedServer = localServers.find(s => s.url === selected.baseUrl);
     const providerModels = matchedServer && matchedServer.models.length > 0
         ? matchedServer.models
@@ -219,7 +241,7 @@ async function runSetup() {
             }
         }
     }
-    // Step 5: Auto mode?
+    // Step 6: 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();
@@ -230,14 +252,34 @@ async function runSetup() {
         baseUrl: selected.baseUrl,
         autoApprove,
     };
+    // Save API key if user entered one
+    if (apiKey) {
+        config.apiKey = apiKey;
+    }
     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 (apiKey) {
+        console.log(fmt(`  API Key: ${'*'.repeat(Math.min(apiKey.length, 20))}`, '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;
 }
+/** Get the URL where users can get API keys for each provider */
+function getKeyUrl(provider) {
+    switch (provider) {
+        case 'openai': return 'https://platform.openai.com/api-keys';
+        case 'anthropic': return 'https://console.anthropic.com/settings/keys';
+        case 'gemini': return 'https://aistudio.google.com/app/apikey';
+        case 'deepseek': return 'https://platform.deepseek.com/api_keys';
+        case 'groq': return 'https://console.groq.com/keys';
+        case 'mistral': return 'https://console.mistral.ai/api-keys';
+        case 'xai': return 'https://console.x.ai/';
+        default: return 'Check provider documentation';
+    }
+}
 //# sourceMappingURL=setup.js.map

package/dist/tools/batch-edit.d.ts

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

package/dist/tools/batch-edit.js

@@ -0,0 +1,122 @@
+"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.BatchEditTool = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class BatchEditTool {
+    name = 'batch_edit';
+    description = 'Apply multiple find-and-replace edits across one or more files atomically. All edits are validated before any are applied. Useful for renaming, refactoring, and coordinated multi-file changes.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            edits: {
+                type: 'array',
+                description: 'Array of edit operations: [{path, old_string, new_string}, ...]',
+                items: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'File path' },
+                        old_string: { type: 'string', description: 'Exact string to find' },
+                        new_string: { type: 'string', description: 'Replacement string' },
+                    },
+                    required: ['path', 'old_string', 'new_string'],
+                },
+            },
+        },
+        required: ['edits'],
+    };
+    async execute(args) {
+        const edits = args.edits;
+        if (!edits || !Array.isArray(edits) || edits.length === 0) {
+            return 'Error: edits array is required and must not be empty';
+        }
+        // Phase 1: Validate all edits before applying any
+        const errors = [];
+        const validated = [];
+        // Group edits by file so we can chain them
+        const byFile = new Map();
+        for (const edit of edits) {
+            if (!edit.path || !edit.old_string === undefined) {
+                errors.push(`Invalid edit: missing path or old_string`);
+                continue;
+            }
+            const filePath = path.resolve(edit.path);
+            if (!byFile.has(filePath))
+                byFile.set(filePath, []);
+            byFile.get(filePath).push(edit);
+        }
+        for (const [filePath, fileEdits] of byFile) {
+            if (!fs.existsSync(filePath)) {
+                errors.push(`File not found: ${filePath}`);
+                continue;
+            }
+            let content = fs.readFileSync(filePath, 'utf-8');
+            const originalContent = content;
+            for (const edit of fileEdits) {
+                const oldStr = String(edit.old_string);
+                const newStr = String(edit.new_string);
+                const count = content.split(oldStr).length - 1;
+                if (count === 0) {
+                    errors.push(`String not found in ${filePath}: "${oldStr.substring(0, 60)}${oldStr.length > 60 ? '...' : ''}"`);
+                    continue;
+                }
+                if (count > 1) {
+                    errors.push(`String found ${count} times in ${filePath} (must be unique): "${oldStr.substring(0, 60)}${oldStr.length > 60 ? '...' : ''}"`);
+                    continue;
+                }
+                content = content.replace(oldStr, newStr);
+            }
+            if (content !== originalContent) {
+                validated.push({ filePath, content: originalContent, updated: content, edit: fileEdits[0] });
+            }
+        }
+        if (errors.length > 0) {
+            return `Validation failed (no changes made):\n${errors.map(e => `  - ${e}`).join('\n')}`;
+        }
+        // Phase 2: Apply all edits atomically
+        const results = [];
+        for (const { filePath, updated } of validated) {
+            fs.writeFileSync(filePath, updated, 'utf-8');
+            results.push(filePath);
+        }
+        const fileCount = validated.length;
+        const editCount = edits.length;
+        return `Applied ${editCount} edit${editCount > 1 ? 's' : ''} across ${fileCount} file${fileCount > 1 ? 's' : ''}:\n${results.map(f => `  ✓ ${f}`).join('\n')}`;
+    }
+}
+exports.BatchEditTool = BatchEditTool;
+//# sourceMappingURL=batch-edit.js.map

package/dist/tools/browser.js

@@ -1,15 +1,71 @@
 "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.BrowserTool = void 0;
 const cdp_1 = require("../browser/cdp");
 const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
 // Shared browser instance across tool calls
 let client = null;
 let debugPort = 9222;
+const CHROME_DATA_DIR = path.join(os.homedir(), '.codebot', 'chrome-profile');
+/** Kill any Chrome using our debug port or data dir */
+function killExistingChrome() {
+    const { execSync } = require('child_process');
+    try {
+        if (process.platform === 'win32') {
+            execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${debugPort}') do taskkill /F /PID %a`, { stdio: 'ignore' });
+        }
+        else {
+            // Kill any process listening on our debug port
+            execSync(`lsof -ti:${debugPort} | xargs kill -9 2>/dev/null || true`, { stdio: 'ignore' });
+            // Also kill any Chrome using our data dir
+            execSync(`pkill -f "${CHROME_DATA_DIR}" 2>/dev/null || true`, { stdio: 'ignore' });
+        }
+    }
+    catch {
+        // ignore — nothing to kill
+    }
+    // Give OS time to release the port
+}
 async function ensureConnected() {
     if (client?.isConnected())
         return client;
-    // Try connecting to existing Chrome
+    // Try connecting to existing Chrome with debug port
     try {
         const wsUrl = await (0, cdp_1.getDebuggerUrl)(debugPort);
         client = new cdp_1.CDPClient();
@@ -28,7 +84,9 @@ async function ensureConnected() {
         return client;
     }
     catch {
-        // Chrome not running with debugging — try to launch it
+        // Can't connect — kill stale processes and launch fresh
+        killExistingChrome();
+        await new Promise(r => setTimeout(r, 500));
     }
     // Launch Chrome with debugging
     const chromePaths = process.platform === 'win32'
@@ -55,14 +113,49 @@ async function ensureConnected() {
                 '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;
+    // Create isolated Chrome profile dir so it doesn't conflict with user's running Chrome
+    fs.mkdirSync(CHROME_DATA_DIR, { recursive: true });
+    const chromeArgs = [
+        `--remote-debugging-port=${debugPort}`,
+        `--user-data-dir=${CHROME_DATA_DIR}`,
+        '--no-first-run',
+        '--no-default-browser-check',
+        '--disable-background-timer-throttling',
+        '--disable-backgrounding-occluded-windows',
+        'about:blank',
+    ];
+    // On macOS, launch directly (not via 'open -a' which reuses existing instance)
+    if (process.platform === 'darwin') {
+        const macPaths = [
+            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+            '/Applications/Chromium.app/Contents/MacOS/Chromium',
+            '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+        ];
+        for (const chromePath of macPaths) {
+            try {
+                if (fs.existsSync(chromePath)) {
+                    const child = (0, child_process_1.spawn)(chromePath, chromeArgs, { stdio: 'ignore', detached: true });
+                    child.unref();
+                    launched = true;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
         }
-        catch {
-            continue;
+    }
+    if (!launched) {
+        for (const chromePath of chromePaths) {
+            try {
+                const child = (0, child_process_1.spawn)(chromePath, chromeArgs, { stdio: 'ignore', detached: true });
+                child.unref();
+                launched = true;
+                break;
+            }
+            catch {
+                continue;
+            }
         }
     }
     if (!launched) {
@@ -151,16 +244,30 @@ class BrowserTool {
         if (!url.startsWith('http://') && !url.startsWith('https://')) {
             url = 'https://' + url;
         }
+        // Set up load event listener BEFORE navigating
+        const loadPromise = cdp.waitForEvent('Page.loadEventFired', 15000);
         await cdp.send('Page.navigate', { url });
-        // Wait for page load
-        await new Promise(r => setTimeout(r, 2000));
-        // Get page title
+        // Wait for actual page load event (up to 15s)
+        await loadPromise;
+        // Extra delay for SPA hydration (React, Next.js, etc.)
+        await new Promise(r => setTimeout(r, 1500));
+        // Get final URL (after redirects) and page title
         const result = await cdp.send('Runtime.evaluate', {
-            expression: 'document.title',
+            expression: 'JSON.stringify({ title: document.title, url: window.location.href })',
             returnByValue: true,
         });
-        const title = result.result?.value || 'untitled';
-        return `Navigated to: ${url}\nTitle: ${title}`;
+        const val = result.result?.value;
+        let title = 'untitled';
+        let finalUrl = url;
+        try {
+            const parsed = JSON.parse(val);
+            title = parsed.title || 'untitled';
+            finalUrl = parsed.url || url;
+        }
+        catch {
+            // fallback
+        }
+        return `Navigated to: ${finalUrl}\nTitle: ${title}`;
     }
     async getContent() {
         const cdp = await ensureConnected();

package/dist/tools/edit.d.ts

@@ -22,5 +22,11 @@ export declare class EditFileTool implements Tool {
         required: string[];
     };
     execute(args: Record<string, unknown>): Promise<string>;
+    private generateDiff;
+    /** Save a snapshot for undo */
+    private saveSnapshot;
+    private loadManifest;
+    /** Undo the last edit to a file. Returns result message. */
+    static undo(filePath?: string): string;
 }
 //# sourceMappingURL=edit.d.ts.map