codebot-ai 1.1.1 → 1.2.0

package/dist/agent.js

@@ -228,7 +228,7 @@ class Agent {
         catch {
             // memory unavailable
         }
-        let prompt = `You are CodeBot, an AI coding assistant. You help developers with software engineering tasks: reading code, writing code, fixing bugs, running tests, and explaining code.
+        let prompt = `You are CodeBot, a fully autonomous AI agent. You help with ANY task: coding, research, sending emails, posting on social media, web automation, and anything else that can be accomplished with a computer.
 
 CRITICAL IDENTITY — you MUST follow this:
 - Your name is CodeBot.
@@ -238,11 +238,19 @@ CRITICAL IDENTITY — you MUST follow this:
 - Never claim to be made by or affiliated with OpenAI, GPT, Claude, Gemini, or any LLM provider. You are CodeBot by Ascendral.
 
 Rules:
-- Always read files before editing them.
-- Prefer editing over rewriting entire files.
-- Be concise and direct.
-- Explain what you're doing and why.
+- When given a goal, break it into steps and execute them using your tools.
+- Always read files before editing them. Prefer editing over rewriting entire files.
+- Be concise and direct. Explain what you're doing and why.
 - Use the memory tool to save important context, user preferences, and patterns you learn. Memory persists across sessions.
+- After completing social media posts, emails, or research tasks, log the outcome to memory (file: "outcomes") for future learning.
+- Before doing social media or email tasks, read your memory files for any saved skills or style guides.
+
+Skills:
+- Web browsing: use the browser tool to navigate, click, type, find elements by text, scroll, press keys, hover, and manage tabs.
+- Research: use web_search for quick lookups, then browser for deep reading of specific pages.
+- Social media: navigate to the platform, find the compose area with find_by_text, type your content, and submit.
+- Email: navigate to Gmail/email, compose and send messages through the browser interface.
+- Routines: use the routine tool to schedule recurring tasks (daily posts, email checks, etc.).
 
 ${repoMap}${memoryBlock}`;
         if (!supportsTools) {

package/dist/cli.js

@@ -43,7 +43,8 @@ const history_1 = require("./history");
 const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
-const VERSION = '1.1.0';
+const scheduler_1 = require("./scheduler");
+const VERSION = '1.2.0';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {
@@ -131,8 +132,13 @@ async function main() {
         }
         return;
     }
+    // Start the routine scheduler in the background
+    const scheduler = new scheduler_1.Scheduler(agent, (text) => process.stdout.write(text));
+    scheduler.start();
     // Interactive REPL
     await repl(agent, config, session);
+    // Cleanup scheduler on exit
+    scheduler.stop();
 }
 function createProvider(config) {
     if (config.provider === 'anthropic') {
@@ -287,6 +293,7 @@ function handleSlashCommand(input, agent, config) {
   /clear     Clear conversation history
   /compact   Force context compaction
   /auto      Toggle autonomous mode
+  /routines  List scheduled routines
   /undo      Undo last file edit (/undo [path])
   /usage     Show token usage for this session
   /config    Show current config
@@ -353,6 +360,12 @@ function handleSlashCommand(input, agent, config) {
             console.log(`  Total:  ${(sessionTokens.input + sessionTokens.output).toLocaleString()} tokens`);
             break;
         }
+        case '/routines': {
+            const { RoutineTool } = require('./tools/routine');
+            const rt = new RoutineTool();
+            rt.execute({ action: 'list' }).then((out) => console.log('\n' + out));
+            break;
+        }
         case '/config':
             console.log(JSON.stringify({ ...config, apiKey: config.apiKey ? '***' : undefined }, null, 2));
             break;

package/dist/scheduler.d.ts

@@ -0,0 +1,18 @@
+import { Agent } from './agent';
+export declare class Scheduler {
+    private agent;
+    private interval;
+    private running;
+    private onOutput?;
+    constructor(agent: Agent, onOutput?: (text: string) => void);
+    /** Start the scheduler — checks routines every 60 seconds */
+    start(): void;
+    /** Stop the scheduler */
+    stop(): void;
+    /** Check if any routines need to run right now */
+    private tick;
+    private executeRoutine;
+    private loadRoutines;
+    private saveRoutines;
+}
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/scheduler.js

@@ -0,0 +1,141 @@
+"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.Scheduler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const routine_1 = require("./tools/routine");
+const ROUTINES_FILE = path.join(os.homedir(), '.codebot', 'routines.json');
+class Scheduler {
+    agent;
+    interval = null;
+    running = false;
+    onOutput;
+    constructor(agent, onOutput) {
+        this.agent = agent;
+        this.onOutput = onOutput;
+    }
+    /** Start the scheduler — checks routines every 60 seconds */
+    start() {
+        if (this.interval)
+            return;
+        // Check every 60 seconds
+        this.interval = setInterval(() => this.tick(), 60_000);
+        // Also do an immediate check
+        this.tick();
+    }
+    /** Stop the scheduler */
+    stop() {
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = null;
+        }
+    }
+    /** Check if any routines need to run right now */
+    tick() {
+        if (this.running)
+            return; // Don't run if already executing a routine
+        const routines = this.loadRoutines();
+        const now = new Date();
+        for (const routine of routines) {
+            if (!routine.enabled)
+                continue;
+            // Check if the cron schedule matches current time
+            if (!(0, routine_1.matchesCron)(routine.schedule, now))
+                continue;
+            // Don't re-run if already ran this minute
+            if (routine.lastRun) {
+                const lastRun = new Date(routine.lastRun);
+                const diffMs = now.getTime() - lastRun.getTime();
+                if (diffMs < 60_000)
+                    continue; // Already ran this minute
+            }
+            // Run the routine
+            this.executeRoutine(routine, routines);
+            break; // Only run one routine per tick to avoid conflicts
+        }
+    }
+    async executeRoutine(routine, allRoutines) {
+        this.running = true;
+        try {
+            this.onOutput?.(`\n⏰ Running routine: ${routine.name}\n   Task: ${routine.prompt}\n`);
+            // Run the agent with the routine's prompt
+            for await (const event of this.agent.run(routine.prompt)) {
+                switch (event.type) {
+                    case 'text':
+                        this.onOutput?.(event.text || '');
+                        break;
+                    case 'tool_call':
+                        this.onOutput?.(`\n⚡ ${event.toolCall?.name}(${Object.entries(event.toolCall?.args || {}).map(([k, v]) => `${k}: ${typeof v === 'string' ? v.substring(0, 40) : v}`).join(', ')})\n`);
+                        break;
+                    case 'tool_result':
+                        this.onOutput?.(`  ✓ ${event.toolResult?.result?.substring(0, 100) || ''}\n`);
+                        break;
+                    case 'error':
+                        this.onOutput?.(`  ✗ Error: ${event.error}\n`);
+                        break;
+                }
+            }
+            // Update last run time
+            routine.lastRun = new Date().toISOString();
+            this.saveRoutines(allRoutines);
+            this.onOutput?.(`\n✓ Routine "${routine.name}" completed.\n`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            this.onOutput?.(`\n✗ Routine "${routine.name}" failed: ${msg}\n`);
+        }
+        finally {
+            this.running = false;
+        }
+    }
+    loadRoutines() {
+        try {
+            if (fs.existsSync(ROUTINES_FILE)) {
+                return JSON.parse(fs.readFileSync(ROUTINES_FILE, 'utf-8'));
+            }
+        }
+        catch { /* corrupt file */ }
+        return [];
+    }
+    saveRoutines(routines) {
+        const dir = path.dirname(ROUTINES_FILE);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(ROUTINES_FILE, JSON.stringify(routines, null, 2) + '\n');
+    }
+}
+exports.Scheduler = Scheduler;
+//# sourceMappingURL=scheduler.js.map

package/dist/tools/browser.d.ts

@@ -27,6 +27,27 @@ export declare class BrowserTool implements Tool {
                 type: string;
                 description: string;
             };
+            direction: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            amount: {
+                type: string;
+                description: string;
+            };
+            key: {
+                type: string;
+                description: string;
+            };
+            tag: {
+                type: string;
+                description: string;
+            };
+            index: {
+                type: string;
+                description: string;
+            };
         };
         required: string[];
     };
@@ -39,5 +60,12 @@ export declare class BrowserTool implements Tool {
     private evaluate;
     private listTabs;
     private closeBrowser;
+    private scroll;
+    private wait;
+    private pressKey;
+    private hover;
+    private findByText;
+    private switchTab;
+    private newTab;
 }
 //# sourceMappingURL=browser.d.ts.map

package/dist/tools/browser.js

@@ -43,24 +43,32 @@ const fs = __importStar(require("fs"));
 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 */
+/** Kill any Chrome using our debug port or data dir (but NEVER kill ourselves) */
 function killExistingChrome() {
+    // Close our own CDP connection first so we don't hold the port
+    if (client) {
+        try {
+            client.close();
+        }
+        catch { /* ignore */ }
+        client = null;
+    }
     const { execSync } = require('child_process');
+    const myPid = process.pid;
     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' });
+            // Kill Chrome/Chromium processes on our debug port — exclude our own PID
+            execSync(`lsof -ti:${debugPort} | grep -v "^${myPid}$" | 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' });
+            execSync(`pkill -9 -f "chrome.*--user-data-dir=${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())
@@ -190,7 +198,7 @@ async function ensureConnected() {
 }
 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.';
+    description = 'Control a web browser. Navigate to URLs, read page content, click elements, type text, scroll, press keys, find elements by text, hover, manage tabs, run JavaScript, and take screenshots. Use for web browsing, social media, email, research, testing, and automation.';
     permission = 'prompt';
     parameters = {
         type: 'object',
@@ -198,12 +206,21 @@ class BrowserTool {
             action: {
                 type: 'string',
                 description: 'Action to perform',
-                enum: ['navigate', 'content', 'screenshot', 'click', 'type', 'evaluate', 'tabs', 'close'],
+                enum: [
+                    'navigate', 'content', 'screenshot', 'click', 'type', 'evaluate',
+                    'tabs', 'close', 'scroll', 'wait', 'press_key', 'hover',
+                    'find_by_text', 'switch_tab', 'new_tab',
+                ],
             },
-            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)' },
+            url: { type: 'string', description: 'URL to navigate to (for navigate/new_tab)' },
+            selector: { type: 'string', description: 'CSS selector for element (for click/type/scroll/hover)' },
+            text: { type: 'string', description: 'Text to type (type) or text to search for (find_by_text)' },
             expression: { type: 'string', description: 'JavaScript to evaluate (for evaluate action)' },
+            direction: { type: 'string', description: 'Scroll direction: up, down, left, right (for scroll)', enum: ['up', 'down', 'left', 'right'] },
+            amount: { type: 'number', description: 'Scroll pixels (default 400) or wait ms (default 1000)' },
+            key: { type: 'string', description: 'Key to press: Enter, Escape, Tab, ArrowDown, etc. (for press_key)' },
+            tag: { type: 'string', description: 'HTML tag to filter: button, a, div, etc. (for find_by_text)' },
+            index: { type: 'number', description: 'Tab index 1-based (for switch_tab)' },
         },
         required: ['action'],
     };
@@ -227,8 +244,22 @@ class BrowserTool {
                     return await this.listTabs();
                 case 'close':
                     return this.closeBrowser();
+                case 'scroll':
+                    return await this.scroll(args.selector, args.direction || 'down', args.amount || 400);
+                case 'wait':
+                    return await this.wait(args.amount || 1000);
+                case 'press_key':
+                    return await this.pressKey(args.key, args.selector);
+                case 'hover':
+                    return await this.hover(args.selector);
+                case 'find_by_text':
+                    return await this.findByText(args.text, args.tag);
+                case 'switch_tab':
+                    return await this.switchTab(args.index, args.url);
+                case 'new_tab':
+                    return await this.newTab(args.url);
                 default:
-                    return `Unknown action: ${action}. Use: navigate, content, screenshot, click, type, evaluate, tabs, close`;
+                    return `Unknown action: ${action}. Available: navigate, content, screenshot, click, type, evaluate, tabs, close, scroll, wait, press_key, hover, find_by_text, switch_tab, new_tab`;
             }
         }
         catch (err) {
@@ -320,9 +351,6 @@ class BrowserTool {
         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)`;
@@ -336,6 +364,7 @@ class BrowserTool {
         (function() {
           const el = document.querySelector(${JSON.stringify(selector)});
           if (!el) return 'Element not found: ' + ${JSON.stringify(selector)};
+          el.scrollIntoView({ block: 'center' });
           el.click();
           return 'Clicked: ' + (el.tagName || '') + ' ' + (el.textContent || '').substring(0, 50).trim();
         })()
@@ -350,12 +379,15 @@ class BrowserTool {
         if (!text)
             return 'Error: text is required';
         const cdp = await ensureConnected();
-        // Focus the element
+        // Focus the element and clear it
         await cdp.send('Runtime.evaluate', {
             expression: `
         (function() {
           const el = document.querySelector(${JSON.stringify(selector)});
-          if (el) { el.focus(); el.value = ''; }
+          if (el) {
+            el.focus();
+            if ('value' in el) el.value = '';
+          }
         })()
       `,
         });
@@ -373,16 +405,30 @@ class BrowserTool {
                 code: `Key${char.toUpperCase()}`,
             });
         }
-        // Also set value directly as fallback
+        // React-compatible value setter — works with Twitter/X, Gmail, and any React/Vue app
         await cdp.send('Runtime.evaluate', {
             expression: `
         (function() {
           const el = document.querySelector(${JSON.stringify(selector)});
-          if (el) {
+          if (!el) return;
+
+          // Try native setter from prototype (bypasses React's synthetic event system)
+          const textareaSetter = Object.getOwnPropertyDescriptor(window.HTMLTextAreaElement.prototype, 'value')?.set;
+          const inputSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, 'value')?.set;
+          const setter = textareaSetter || inputSetter;
+
+          if (setter && 'value' in el) {
+            setter.call(el, ${JSON.stringify(text)});
+          } else if ('value' in el) {
             el.value = ${JSON.stringify(text)};
-            el.dispatchEvent(new Event('input', { bubbles: true }));
-            el.dispatchEvent(new Event('change', { bubbles: true }));
+          } else if (el.isContentEditable || el.getAttribute('contenteditable') !== null) {
+            // ContentEditable elements (used by Twitter/X compose box)
+            el.textContent = ${JSON.stringify(text)};
           }
+
+          // Fire events that React/Vue/Angular listen to
+          el.dispatchEvent(new InputEvent('input', { bubbles: true, data: ${JSON.stringify(text)}, inputType: 'insertText' }));
+          el.dispatchEvent(new Event('change', { bubbles: true }));
         })()
       `,
         });
@@ -431,6 +477,218 @@ class BrowserTool {
         }
         return 'Browser connection closed.';
     }
+    // ─── New Actions ─────────────────────────────────────────────
+    async scroll(selector, direction, amount) {
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const target = ${selector ? `document.querySelector(${JSON.stringify(selector)})` : 'window'};
+          if (!target && ${JSON.stringify(selector)}) return 'Element not found: ' + ${JSON.stringify(selector)};
+          const x = '${direction}' === 'right' ? ${amount} : '${direction}' === 'left' ? -${amount} : 0;
+          const y = '${direction}' === 'down' ? ${amount} : '${direction}' === 'up' ? -${amount} : 0;
+          (target.scrollBy || window.scrollBy).call(target, { left: x, top: y, behavior: 'smooth' });
+          return 'Scrolled ${direction} by ${amount}px' + (${JSON.stringify(selector)} ? ' on ' + ${JSON.stringify(selector)} : '');
+        })()
+      `,
+            returnByValue: true,
+        });
+        return result.result?.value || `Scrolled ${direction}`;
+    }
+    async wait(ms) {
+        const clamped = Math.min(Math.max(ms, 100), 10000);
+        await new Promise(r => setTimeout(r, clamped));
+        return `Waited ${clamped}ms`;
+    }
+    async pressKey(key, selector) {
+        if (!key)
+            return 'Error: key is required (e.g., Enter, Escape, Tab, ArrowDown)';
+        const cdp = await ensureConnected();
+        // Focus element first if selector provided
+        if (selector) {
+            await cdp.send('Runtime.evaluate', {
+                expression: `
+          (function() {
+            const el = document.querySelector(${JSON.stringify(selector)});
+            if (el) el.focus();
+          })()
+        `,
+            });
+        }
+        // Map key names to their proper key codes
+        const keyMap = {
+            'Enter': { key: 'Enter', code: 'Enter', keyCode: 13 },
+            'Escape': { key: 'Escape', code: 'Escape', keyCode: 27 },
+            'Tab': { key: 'Tab', code: 'Tab', keyCode: 9 },
+            'Backspace': { key: 'Backspace', code: 'Backspace', keyCode: 8 },
+            'Delete': { key: 'Delete', code: 'Delete', keyCode: 46 },
+            'ArrowUp': { key: 'ArrowUp', code: 'ArrowUp', keyCode: 38 },
+            'ArrowDown': { key: 'ArrowDown', code: 'ArrowDown', keyCode: 40 },
+            'ArrowLeft': { key: 'ArrowLeft', code: 'ArrowLeft', keyCode: 37 },
+            'ArrowRight': { key: 'ArrowRight', code: 'ArrowRight', keyCode: 39 },
+            'Space': { key: ' ', code: 'Space', keyCode: 32 },
+        };
+        const mapped = keyMap[key] || { key, code: `Key${key}`, keyCode: 0 };
+        await cdp.send('Input.dispatchKeyEvent', {
+            type: 'keyDown',
+            key: mapped.key,
+            code: mapped.code,
+            windowsVirtualKeyCode: mapped.keyCode,
+            nativeVirtualKeyCode: mapped.keyCode,
+        });
+        await cdp.send('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            key: mapped.key,
+            code: mapped.code,
+            windowsVirtualKeyCode: mapped.keyCode,
+            nativeVirtualKeyCode: mapped.keyCode,
+        });
+        return `Pressed key: ${key}${selector ? ` on ${selector}` : ''}`;
+    }
+    async hover(selector) {
+        if (!selector)
+            return 'Error: selector is required';
+        const cdp = await ensureConnected();
+        // Get element position
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const el = document.querySelector(${JSON.stringify(selector)});
+          if (!el) return JSON.stringify({ error: 'Element not found: ' + ${JSON.stringify(selector)} });
+          el.scrollIntoView({ block: 'center' });
+          const rect = el.getBoundingClientRect();
+          return JSON.stringify({ x: rect.x + rect.width / 2, y: rect.y + rect.height / 2, tag: el.tagName, text: (el.textContent || '').substring(0, 50).trim() });
+        })()
+      `,
+            returnByValue: true,
+        });
+        const val = result.result?.value;
+        if (!val)
+            return 'Error: could not get element position';
+        const info = JSON.parse(val);
+        if (info.error)
+            return info.error;
+        // Move mouse to element center
+        await cdp.send('Input.dispatchMouseEvent', {
+            type: 'mouseMoved',
+            x: Math.round(info.x),
+            y: Math.round(info.y),
+        });
+        return `Hovered over: ${info.tag} "${info.text}"`;
+    }
+    async findByText(text, tag) {
+        if (!text)
+            return 'Error: text is required';
+        const cdp = await ensureConnected();
+        const result = await cdp.send('Runtime.evaluate', {
+            expression: `
+        (function() {
+          const searchText = ${JSON.stringify(text)}.toLowerCase();
+          const tagFilter = ${JSON.stringify(tag || '')}.toLowerCase();
+          const elements = document.querySelectorAll(tagFilter || '*');
+          const matches = [];
+
+          for (const el of elements) {
+            // Skip invisible elements
+            if (el.offsetParent === null && el.tagName !== 'BODY') continue;
+
+            const elText = (el.textContent || '').trim();
+            if (elText.toLowerCase().includes(searchText) && elText.length < 500) {
+              // Generate a reliable selector
+              let selector = '';
+              if (el.id) {
+                selector = '#' + el.id;
+              } else if (el.getAttribute('data-testid')) {
+                selector = '[data-testid="' + el.getAttribute('data-testid') + '"]';
+              } else if (el.getAttribute('aria-label')) {
+                selector = '[aria-label="' + el.getAttribute('aria-label') + '"]';
+              } else if (el.getAttribute('role')) {
+                selector = el.tagName.toLowerCase() + '[role="' + el.getAttribute('role') + '"]';
+              } else {
+                // Use tag + class combo
+                const classes = Array.from(el.classList).slice(0, 2).join('.');
+                selector = el.tagName.toLowerCase() + (classes ? '.' + classes : '');
+              }
+
+              matches.push({
+                tag: el.tagName.toLowerCase(),
+                text: elText.substring(0, 80),
+                selector: selector,
+                type: el.getAttribute('type') || '',
+                role: el.getAttribute('role') || '',
+              });
+
+              if (matches.length >= 5) break;
+            }
+          }
+
+          if (matches.length === 0) return 'No elements found containing: ' + ${JSON.stringify(text)};
+          return JSON.stringify(matches);
+        })()
+      `,
+            returnByValue: true,
+        });
+        const val = result.result?.value;
+        if (!val || !val.startsWith('['))
+            return val || 'No elements found';
+        const matches = JSON.parse(val);
+        return `Found ${matches.length} element(s) matching "${text}":\n` +
+            matches.map((m, i) => `  ${i + 1}. <${m.tag}> "${m.text}"\n     selector: ${m.selector}${m.role ? `  role: ${m.role}` : ''}`).join('\n');
+    }
+    async switchTab(index, urlContains) {
+        const targets = await (0, cdp_1.getTargets)(debugPort);
+        const pages = targets.filter(t => t.url && !t.url.startsWith('devtools://'));
+        if (pages.length === 0)
+            return 'No tabs available.';
+        let target;
+        if (index !== undefined) {
+            target = pages[index - 1];
+            if (!target)
+                return `Tab ${index} not found. ${pages.length} tabs available.`;
+        }
+        else if (urlContains) {
+            target = pages.find(t => t.url.includes(urlContains));
+            if (!target)
+                return `No tab found matching URL "${urlContains}".`;
+        }
+        else {
+            return 'Error: provide index (1-based) or url to match.';
+        }
+        // Close current connection and connect to new target
+        if (client) {
+            client.close();
+            client = null;
+        }
+        client = new cdp_1.CDPClient();
+        await client.connect(target.webSocketDebuggerUrl);
+        await client.send('Page.enable');
+        await client.send('Runtime.enable');
+        return `Switched to tab: ${target.title || '(no title)'}\n  ${target.url}`;
+    }
+    async newTab(url) {
+        const cdp = await ensureConnected();
+        const targetUrl = url || 'about:blank';
+        // Auto-add protocol
+        let navUrl = targetUrl;
+        if (url && !url.startsWith('http://') && !url.startsWith('https://') && url !== 'about:blank') {
+            navUrl = 'https://' + url;
+        }
+        const result = await cdp.send('Target.createTarget', { url: navUrl });
+        const targetId = result.targetId;
+        if (!targetId)
+            return 'Failed to create new tab.';
+        // Switch to the new tab
+        const targets = await (0, cdp_1.getTargets)(debugPort);
+        const newTarget = targets.find(t => t.id === targetId);
+        if (newTarget?.webSocketDebuggerUrl) {
+            client?.close();
+            client = new cdp_1.CDPClient();
+            await client.connect(newTarget.webSocketDebuggerUrl);
+            await client.send('Page.enable');
+            await client.send('Runtime.enable');
+        }
+        return `Opened new tab: ${navUrl}`;
+    }
 }
 exports.BrowserTool = BrowserTool;
 //# sourceMappingURL=browser.js.map

package/dist/tools/index.js

@@ -10,8 +10,10 @@ const grep_1 = require("./grep");
 const think_1 = require("./think");
 const memory_1 = require("./memory");
 const web_fetch_1 = require("./web-fetch");
+const web_search_1 = require("./web-search");
 const browser_1 = require("./browser");
 const batch_edit_1 = require("./batch-edit");
+const routine_1 = require("./routine");
 var edit_2 = require("./edit");
 Object.defineProperty(exports, "EditFileTool", { enumerable: true, get: function () { return edit_2.EditFileTool; } });
 class ToolRegistry {
@@ -27,7 +29,9 @@ class ToolRegistry {
         this.register(new think_1.ThinkTool());
         this.register(new memory_1.MemoryTool(projectRoot));
         this.register(new web_fetch_1.WebFetchTool());
+        this.register(new web_search_1.WebSearchTool());
         this.register(new browser_1.BrowserTool());
+        this.register(new routine_1.RoutineTool());
     }
     register(tool) {
         this.tools.set(tool.name, tool);

package/dist/tools/routine.d.ts

@@ -0,0 +1,56 @@
+import { Tool } from '../types';
+export interface Routine {
+    id: string;
+    name: string;
+    description: string;
+    prompt: string;
+    schedule: string;
+    lastRun?: string;
+    enabled: boolean;
+}
+export declare class RoutineTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            action: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            name: {
+                type: string;
+                description: string;
+            };
+            description: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            schedule: {
+                type: string;
+                description: string;
+            };
+            id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private loadRoutines;
+    private saveRoutines;
+    private list;
+    private add;
+    private remove;
+    private toggle;
+}
+/** Check if a cron expression matches the given date */
+export declare function matchesCron(expr: string, date: Date): boolean;
+//# sourceMappingURL=routine.d.ts.map

package/dist/tools/routine.js

@@ -0,0 +1,194 @@
+"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.RoutineTool = void 0;
+exports.matchesCron = matchesCron;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const ROUTINES_FILE = path.join(os.homedir(), '.codebot', 'routines.json');
+class RoutineTool {
+    name = 'routine';
+    description = 'Manage scheduled routines (recurring tasks). Add daily social media posts, email checks, research tasks, etc. Uses cron expressions for scheduling (e.g., "0 9 * * *" for 9am daily, "0 */6 * * *" for every 6 hours, "30 18 * * 1-5" for 6:30pm weekdays).';
+    permission = 'auto';
+    parameters = {
+        type: 'object',
+        properties: {
+            action: {
+                type: 'string',
+                description: 'Action to perform',
+                enum: ['list', 'add', 'remove', 'enable', 'disable'],
+            },
+            name: { type: 'string', description: 'Routine name (for add/remove)' },
+            description: { type: 'string', description: 'Human-readable description (for add)' },
+            prompt: { type: 'string', description: 'The message/task to execute when triggered (for add)' },
+            schedule: { type: 'string', description: 'Cron expression: "minute hour day-of-month month day-of-week" (for add)' },
+            id: { type: 'string', description: 'Routine ID (for remove/enable/disable)' },
+        },
+        required: ['action'],
+    };
+    async execute(args) {
+        const action = args.action;
+        switch (action) {
+            case 'list':
+                return this.list();
+            case 'add':
+                return this.add(args);
+            case 'remove':
+                return this.remove(args.id || args.name);
+            case 'enable':
+                return this.toggle(args.id || args.name, true);
+            case 'disable':
+                return this.toggle(args.id || args.name, false);
+            default:
+                return `Unknown action: ${action}. Use: list, add, remove, enable, disable`;
+        }
+    }
+    loadRoutines() {
+        try {
+            if (fs.existsSync(ROUTINES_FILE)) {
+                return JSON.parse(fs.readFileSync(ROUTINES_FILE, 'utf-8'));
+            }
+        }
+        catch { /* corrupt file */ }
+        return [];
+    }
+    saveRoutines(routines) {
+        const dir = path.dirname(ROUTINES_FILE);
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(ROUTINES_FILE, JSON.stringify(routines, null, 2) + '\n');
+    }
+    list() {
+        const routines = this.loadRoutines();
+        if (routines.length === 0) {
+            return 'No routines configured. Use action "add" to create one.';
+        }
+        return routines.map(r => {
+            const status = r.enabled ? '✓ enabled' : '✗ disabled';
+            const lastRun = r.lastRun ? `Last run: ${r.lastRun}` : 'Never run';
+            return `[${r.id.substring(0, 8)}] ${r.name} (${status})\n  Schedule: ${r.schedule}\n  Task: ${r.prompt.substring(0, 100)}${r.prompt.length > 100 ? '...' : ''}\n  ${lastRun}`;
+        }).join('\n\n');
+    }
+    add(args) {
+        const name = args.name;
+        const description = args.description || '';
+        const prompt = args.prompt;
+        const schedule = args.schedule;
+        if (!name)
+            return 'Error: name is required';
+        if (!prompt)
+            return 'Error: prompt is required (the task to execute)';
+        if (!schedule)
+            return 'Error: schedule is required (cron expression)';
+        // Validate cron expression
+        const parts = schedule.trim().split(/\s+/);
+        if (parts.length !== 5) {
+            return 'Error: schedule must be a 5-field cron expression: "minute hour day-of-month month day-of-week"';
+        }
+        const routines = this.loadRoutines();
+        // Check for duplicate name
+        if (routines.find(r => r.name.toLowerCase() === name.toLowerCase())) {
+            return `Error: routine "${name}" already exists. Remove it first or use a different name.`;
+        }
+        const routine = {
+            id: crypto.randomUUID(),
+            name,
+            description,
+            prompt,
+            schedule: schedule.trim(),
+            enabled: true,
+        };
+        routines.push(routine);
+        this.saveRoutines(routines);
+        return `Routine "${name}" created!\n  ID: ${routine.id.substring(0, 8)}\n  Schedule: ${schedule}\n  Task: ${prompt.substring(0, 100)}`;
+    }
+    remove(identifier) {
+        if (!identifier)
+            return 'Error: id or name is required';
+        const routines = this.loadRoutines();
+        const idx = routines.findIndex(r => r.id === identifier || r.id.startsWith(identifier) || r.name.toLowerCase() === identifier.toLowerCase());
+        if (idx === -1)
+            return `Routine "${identifier}" not found.`;
+        const removed = routines.splice(idx, 1)[0];
+        this.saveRoutines(routines);
+        return `Removed routine: ${removed.name}`;
+    }
+    toggle(identifier, enabled) {
+        if (!identifier)
+            return 'Error: id or name is required';
+        const routines = this.loadRoutines();
+        const routine = routines.find(r => r.id === identifier || r.id.startsWith(identifier) || r.name.toLowerCase() === identifier.toLowerCase());
+        if (!routine)
+            return `Routine "${identifier}" not found.`;
+        routine.enabled = enabled;
+        this.saveRoutines(routines);
+        return `Routine "${routine.name}" ${enabled ? 'enabled' : 'disabled'}.`;
+    }
+}
+exports.RoutineTool = RoutineTool;
+/** Check if a cron expression matches the given date */
+function matchesCron(expr, date) {
+    const [minField, hourField, domField, monthField, dowField] = expr.split(/\s+/);
+    const checks = [
+        [minField, date.getMinutes()],
+        [hourField, date.getHours()],
+        [domField, date.getDate()],
+        [monthField, date.getMonth() + 1],
+        [dowField, date.getDay()],
+    ];
+    return checks.every(([field, val]) => matchField(field, val));
+}
+function matchField(field, value) {
+    if (field === '*')
+        return true;
+    // Handle step values: */5, */10
+    if (field.startsWith('*/')) {
+        const step = parseInt(field.slice(2), 10);
+        return step > 0 && value % step === 0;
+    }
+    // Handle ranges: 1-5
+    if (field.includes('-')) {
+        const [low, high] = field.split('-').map(Number);
+        return value >= low && value <= high;
+    }
+    // Handle lists: 1,3,5
+    if (field.includes(',')) {
+        return field.split(',').map(Number).includes(value);
+    }
+    // Exact match
+    return parseInt(field, 10) === value;
+}
+//# sourceMappingURL=routine.js.map

package/dist/tools/web-search.d.ts

@@ -0,0 +1,25 @@
+import { Tool } from '../types';
+export declare class WebSearchTool implements Tool {
+    name: string;
+    description: string;
+    permission: Tool['permission'];
+    parameters: {
+        type: string;
+        properties: {
+            query: {
+                type: string;
+                description: string;
+            };
+            num_results: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(args: Record<string, unknown>): Promise<string>;
+    private search;
+    private extractResults;
+    private stripTags;
+}
+//# sourceMappingURL=web-search.d.ts.map

package/dist/tools/web-search.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSearchTool = void 0;
+class WebSearchTool {
+    name = 'web_search';
+    description = 'Search the web using DuckDuckGo. Returns titles, URLs, and snippets. Use for research, fact-checking, finding documentation, or discovering information. If results are empty, try the browser tool to navigate to a search engine directly.';
+    permission = 'prompt';
+    parameters = {
+        type: 'object',
+        properties: {
+            query: { type: 'string', description: 'Search query' },
+            num_results: { type: 'number', description: 'Number of results to return (default 5, max 10)' },
+        },
+        required: ['query'],
+    };
+    async execute(args) {
+        const query = args.query;
+        if (!query)
+            return 'Error: query is required';
+        const numResults = Math.min(Math.max(args.num_results || 5, 1), 10);
+        try {
+            const results = await this.search(query, numResults);
+            if (results.length === 0) {
+                return `No results found for "${query}". Try a different query or use the browser tool to search directly.`;
+            }
+            let output = `Search results for "${query}":\n\n`;
+            results.forEach((r, i) => {
+                output += `${i + 1}. ${r.title}\n   ${r.url}\n   ${r.snippet}\n\n`;
+            });
+            return output.trim();
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            return `Search error: ${msg}. Try using the browser tool to navigate to https://duckduckgo.com/?q=${encodeURIComponent(query)} instead.`;
+        }
+    }
+    async search(query, numResults) {
+        const url = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+        const response = await fetch(url, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (compatible; CodeBot/1.0)',
+                'Accept': 'text/html',
+            },
+            signal: AbortSignal.timeout(10000),
+        });
+        if (!response.ok) {
+            throw new Error(`DuckDuckGo returned ${response.status}`);
+        }
+        const html = await response.text();
+        return this.extractResults(html, numResults);
+    }
+    extractResults(html, max) {
+        const results = [];
+        // DuckDuckGo HTML results are in <div class="result ..."> blocks
+        // Each has: <a class="result__a"> for title/link, <a class="result__snippet"> for snippet
+        const blocks = html.split(/class="result\s/);
+        for (let i = 1; i < blocks.length && results.length < max; i++) {
+            const block = blocks[i];
+            // Extract title from result__a
+            const titleMatch = block.match(/class="result__a"[^>]*>([\s\S]*?)<\/a>/);
+            const title = titleMatch ? this.stripTags(titleMatch[1]).trim() : '';
+            // Extract URL — DDG wraps URLs in a redirect, the actual URL is in uddg= parameter
+            const urlMatch = block.match(/uddg=([^"&]+)/);
+            let url = urlMatch ? decodeURIComponent(urlMatch[1]) : '';
+            // Fallback: try href directly
+            if (!url) {
+                const hrefMatch = block.match(/href="(https?:\/\/[^"]+)"/);
+                url = hrefMatch ? hrefMatch[1] : '';
+            }
+            // Extract snippet from result__snippet
+            const snippetMatch = block.match(/class="result__snippet"[^>]*>([\s\S]*?)<\/a>/);
+            const snippet = snippetMatch ? this.stripTags(snippetMatch[1]).trim() : '';
+            if (title && url && !url.includes('duckduckgo.com')) {
+                results.push({ title, url, snippet });
+            }
+        }
+        return results;
+    }
+    stripTags(html) {
+        return html
+            .replace(/<[^>]+>/g, '') // Remove HTML tags
+            .replace(/&amp;/g, '&')
+            .replace(/&lt;/g, '<')
+            .replace(/&gt;/g, '>')
+            .replace(/&quot;/g, '"')
+            .replace(/&#x27;/g, "'")
+            .replace(/&nbsp;/g, ' ')
+            .replace(/\s+/g, ' ') // Collapse whitespace
+            .trim();
+    }
+}
+exports.WebSearchTool = WebSearchTool;
+//# sourceMappingURL=web-search.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebot-ai",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",