codebot-ai 1.2.3 → 1.3.0

package/README.md

@@ -1,50 +1,60 @@
 # CodeBot AI
 
-Local-first AI coding assistant. Zero runtime dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, and Grok.
+[![npm version](https://img.shields.io/npm/v/codebot-ai.svg)](https://www.npmjs.com/package/codebot-ai)
+[![license](https://img.shields.io/npm/l/codebot-ai.svg)](https://github.com/zanderone1980/codebot-ai/blob/main/LICENSE)
+[![node](https://img.shields.io/node/v/codebot-ai.svg)](https://nodejs.org)
+
+**Zero-dependency autonomous AI agent.** Works with any LLM — local or cloud. Code, browse the web, run commands, search, automate routines, and more.
+
+Built by [Ascendral Software Development & Innovation](https://github.com/AscendralSoftware).
 
 ## Quick Start
 
 ```bash
-# Install globally
 npm install -g codebot-ai
-
-# Run — setup wizard launches automatically on first use
 codebot
 ```
 
-Or run without installing:
+That's it. The setup wizard launches on first run — pick your model, paste an API key (or use a local LLM), and you're coding.
 
 ```bash
+# Or run without installing
 npx codebot-ai
 ```
 
-Or from source:
-
-```bash
-git clone https://github.com/AscendralSoftware/codebot-ai.git
-cd codebot-ai
-npm install && npm run build
-./bin/codebot
-```
+## What Can It Do?
 
-## Setup
+- **Write & edit code** — reads your codebase, makes targeted edits, runs tests
+- **Run shell commands** — system checks, builds, deploys, git operations
+- **Browse the web** — navigates Chrome, clicks, types, reads pages, takes screenshots
+- **Search the internet** — real-time web search for docs, APIs, current info
+- **Automate routines** — schedule recurring tasks with cron (daily posts, email checks, monitoring)
+- **Call APIs** — HTTP requests to any REST endpoint
+- **Persistent memory** — remembers preferences and context across sessions
+- **Self-recovering** — retries on network errors, recovers from API failures, never drops out
 
-On first run, CodeBot detects your environment and walks you through configuration:
+## Supported Models
 
-- Scans for local LLM servers (Ollama, LM Studio, vLLM)
-- Detects API keys from environment variables
-- Lets you pick a provider and model
-- Saves config to `~/.codebot/config.json`
+Pick any model during setup. CodeBot works with all of them:
 
-To reconfigure anytime: `codebot --setup`
+| Provider | Models |
+|----------|--------|
+| **Local (Ollama/LM Studio/vLLM)** | qwen2.5-coder, qwen3, deepseek-coder, llama3.x, mistral, phi-4, codellama, starcoder2, and any model your server runs |
+| **Anthropic** | claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5 |
+| **OpenAI** | gpt-4o, gpt-4.1, o1, o3, o4-mini |
+| **Google** | gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash |
+| **DeepSeek** | deepseek-chat, deepseek-reasoner |
+| **Groq** | llama-3.3-70b, mixtral-8x7b |
+| **Mistral** | mistral-large, codestral |
+| **xAI** | grok-3, grok-3-mini |
 
-### Environment Variables
+For local models, just have Ollama/LM Studio/vLLM running — CodeBot auto-detects them.
 
-Set an API key for your preferred cloud provider:
+For cloud models, set an environment variable:
 
 ```bash
-export ANTHROPIC_API_KEY="sk-ant-..."    # Claude
 export OPENAI_API_KEY="sk-..."           # GPT
+export ANTHROPIC_API_KEY="sk-ant-..."    # Claude
 export GEMINI_API_KEY="..."              # Gemini
 export DEEPSEEK_API_KEY="sk-..."         # DeepSeek
 export GROQ_API_KEY="gsk_..."            # Groq
@@ -52,52 +62,23 @@ export MISTRAL_API_KEY="..."             # Mistral
 export XAI_API_KEY="xai-..."             # Grok
 ```
 
-For local models, just have Ollama/LM Studio/vLLM running — CodeBot auto-detects them.
+Or paste your key during setup — either way works.
 
 ## Usage
 
-### Interactive Mode
-
-```bash
-codebot
-```
-
-### Single Message
-
 ```bash
-codebot "fix the bug in app.ts"
-codebot --model claude-sonnet-4-6 "explain this codebase"
+codebot                                        # Interactive REPL
+codebot "fix the bug in app.ts"                # Single task
+codebot --autonomous "refactor auth and test"  # Full auto — no permission prompts
+codebot --continue                             # Resume last session
+echo "explain this error" | codebot            # Pipe mode
 ```
 
-### Pipe Mode
-
-```bash
-echo "write a function that sorts by date" | codebot
-cat error.log | codebot "what's causing this?"
-```
-
-### Autonomous Mode
-
-Skip all permission prompts — full auto:
-
-```bash
-codebot --autonomous "refactor the auth module and run tests"
-```
-
-### Session Resume
-
-CodeBot auto-saves every conversation. Resume anytime:
-
-```bash
-codebot --continue              # Resume last session
-codebot --resume <session-id>   # Resume specific session
-```
-
-## CLI Options
+### CLI Options
 
 ```
 --setup              Run the setup wizard
---model <name>       Model to use (default: qwen2.5-coder:32b)
+--model <name>       Model to use
 --provider <name>    Provider: openai, anthropic, gemini, deepseek, groq, mistral, xai
 --base-url <url>     LLM API base URL
 --api-key <key>      API key (or use env vars)
@@ -107,25 +88,26 @@ codebot --resume <session-id>   # Resume specific session
 --max-iterations <n> Max agent loop iterations (default: 50)
 ```
 
-## Interactive Commands
+### Interactive Commands
 
 ```
-/help      Show commands
-/model     Show or change model
-/models    List all supported models
-/sessions  List saved sessions
-/auto      Toggle autonomous mode
-/undo      Undo last file edit (/undo [path])
-/usage     Show token usage for this session
-/clear     Clear conversation
-/compact   Force context compaction
-/config    Show configuration
-/quit      Exit
+/help       Show commands
+/model      Show or change model
+/models     List all supported models
+/sessions   List saved sessions
+/routines   List scheduled routines
+/auto       Toggle autonomous mode
+/undo       Undo last file edit (/undo [path])
+/usage      Show token usage for this session
+/clear      Clear conversation
+/compact    Force context compaction
+/config     Show configuration
+/quit       Exit
 ```
 
 ## Tools
 
-CodeBot has 11 built-in tools:
+CodeBot has 13 built-in tools:
 
 | Tool | Description | Permission |
 |------|-------------|-----------|
@@ -139,7 +121,9 @@ CodeBot has 11 built-in tools:
 | `think` | Internal reasoning scratchpad | auto |
 | `memory` | Persistent memory across sessions | auto |
 | `web_fetch` | HTTP requests and API calls | prompt |
+| `web_search` | Internet search with result summaries | prompt |
 | `browser` | Chrome automation via CDP | prompt |
+| `routine` | Schedule recurring tasks with cron | prompt |
 
 ### Permission Levels
 
@@ -147,7 +131,7 @@ CodeBot has 11 built-in tools:
 - **prompt** — Asks for approval (skipped in `--autonomous` mode)
 - **always-ask** — Always asks, even in autonomous mode
 
-### Browser Tool
+### Browser Automation
 
 Controls Chrome via the Chrome DevTools Protocol. Actions:
 
@@ -155,21 +139,34 @@ Controls Chrome via the Chrome DevTools Protocol. Actions:
 - `content` — Read page text
 - `screenshot` — Capture the page
 - `click` — Click an element by CSS selector
+- `find_by_text` — Find and interact with elements by visible text
 - `type` — Type into an input field
+- `scroll`, `press_key`, `hover` — Page interaction
 - `evaluate` — Run JavaScript on the page
 - `tabs` — List open tabs
 - `close` — Close browser connection
 
 Chrome is auto-launched with `--remote-debugging-port` if not already running.
 
+### Routines & Scheduling
+
+Schedule recurring tasks with cron expressions:
+
+```
+> Set up a routine to check my server health every hour
+> Create a daily routine at 9am to summarize my GitHub notifications
+```
+
+CodeBot creates the cron schedule, and the built-in scheduler runs tasks automatically while the agent is active. Manage with `/routines`.
+
 ### Memory
 
-CodeBot has persistent memory that survives across sessions:
+Persistent memory that survives across sessions:
 
 - **Global memory** (`~/.codebot/memory/`) — preferences, patterns
 - **Project memory** (`.codebot/memory/`) — project-specific context
-- Memory is automatically injected into the system prompt
-- The agent can read/write its own memory using the `memory` tool
+- Automatically injected into the system prompt
+- The agent reads/writes its own memory to learn your style
 
 ### Plugins
 
@@ -205,33 +202,54 @@ Connect external tool servers via [Model Context Protocol](https://modelcontextp
 
 MCP tools appear automatically with the `mcp_<server>_<tool>` prefix.
 
-## Supported Models
+## Stability
+
+CodeBot v1.3.0 is hardened for continuous operation:
+
+- **Automatic retry** — network errors, rate limits (429), and server errors (5xx) retry with exponential backoff
+- **Stream recovery** — if the LLM connection drops mid-response, the agent loop retries on the next iteration
+- **Context compaction** — when the conversation exceeds the model's context window, messages are intelligently summarized
+- **Process resilience** — unhandled exceptions and rejections are caught, logged, and the REPL keeps running
+- **Routine timeouts** — scheduled tasks are capped at 5 minutes to prevent the scheduler from hanging
+- **99 tests** — comprehensive suite covering error recovery, retry logic, tool execution, and edge cases
+
+## Programmatic API
+
+CodeBot can be used as a library:
 
-### Local (Ollama / LM Studio / vLLM)
+```typescript
+import { Agent, OpenAIProvider, AnthropicProvider } from 'codebot-ai';
 
-qwen2.5-coder (3b/7b/14b/32b), qwen3, deepseek-coder, codellama, llama3.x, mistral, mixtral, phi-3/4, starcoder2, granite-code, gemma2, command-r
+const provider = new AnthropicProvider({
+  baseUrl: 'https://api.anthropic.com',
+  apiKey: process.env.ANTHROPIC_API_KEY,
+  model: 'claude-sonnet-4-6',
+});
 
-### Cloud
+const agent = new Agent({
+  provider,
+  model: 'claude-sonnet-4-6',
+  autoApprove: true,
+});
 
-- **Anthropic**: claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5
-- **OpenAI**: gpt-4o, gpt-4.1, o1, o3, o4-mini
-- **Google**: gemini-2.5-pro, gemini-2.5-flash, gemini-2.0-flash
-- **DeepSeek**: deepseek-chat, deepseek-reasoner
-- **Groq**: llama-3.3-70b, mixtral-8x7b (fast inference)
-- **Mistral**: mistral-large, codestral
-- **xAI**: grok-3, grok-3-mini
+for await (const event of agent.run('list all TypeScript files')) {
+  if (event.type === 'text') process.stdout.write(event.text || '');
+}
+```
 
 ## Architecture
 
 ```
 src/
-  agent.ts              Agent loop with streaming, tool execution, permissions
+  agent.ts              Agent loop — streaming, tool execution, error recovery
   cli.ts                CLI interface, REPL, slash commands
   types.ts              TypeScript interfaces
   parser.ts             XML/JSON tool call parser (for models without native tool support)
   history.ts            Session persistence (JSONL)
   memory.ts             Persistent memory system
-  setup.ts              Interactive setup wizard
+  setup.ts              Interactive setup wizard (model-first UX)
+  scheduler.ts          Cron-based routine scheduler
+  retry.ts              Exponential backoff with jitter
   context/
     manager.ts          Context window management, LLM-powered compaction
     repo-map.ts         Project structure scanner
@@ -247,31 +265,8 @@ src/
     read.ts, write.ts, edit.ts, execute.ts
     batch-edit.ts       Multi-file atomic editing
     glob.ts, grep.ts, think.ts
-    memory.ts, web-fetch.ts, browser.ts
-```
-
-## Programmatic API
-
-CodeBot can be used as a library:
-
-```typescript
-import { Agent, OpenAIProvider, AnthropicProvider } from 'codebot-ai';
-
-const provider = new AnthropicProvider({
-  baseUrl: 'https://api.anthropic.com',
-  apiKey: process.env.ANTHROPIC_API_KEY,
-  model: 'claude-sonnet-4-6',
-});
-
-const agent = new Agent({
-  provider,
-  model: 'claude-sonnet-4-6',
-  autoApprove: true,
-});
-
-for await (const event of agent.run('list all TypeScript files')) {
-  if (event.type === 'text') process.stdout.write(event.text || '');
-}
+    memory.ts, web-fetch.ts, web-search.ts
+    browser.ts, routine.ts
 ```
 
 ## Configuration
@@ -282,6 +277,15 @@ Config is loaded in this order (later values win):
 2. Environment variables (`CODEBOT_MODEL`, `CODEBOT_PROVIDER`, etc.)
 3. CLI flags (`--model`, `--provider`, etc.)
 
+## From Source
+
+```bash
+git clone https://github.com/zanderone1980/codebot-ai.git
+cd codebot-ai
+npm install && npm run build
+./bin/codebot
+```
+
 ## License
 
-MIT - Ascendral Software Development & Innovation
+MIT - [Ascendral Software Development & Innovation](https://github.com/AscendralSoftware)

package/dist/agent.js

@@ -88,9 +88,15 @@ class Agent {
         this.messages.push(userMsg);
         this.onMessage?.(userMsg);
         if (!this.context.fitsInBudget(this.messages)) {
-            const result = await this.context.compactWithSummary(this.messages);
-            this.messages = result.messages;
-            yield { type: 'compaction', text: result.summary || 'Context compacted to fit budget.' };
+            try {
+                const result = await this.context.compactWithSummary(this.messages);
+                this.messages = result.messages;
+                yield { type: 'compaction', text: result.summary || 'Context compacted to fit budget.' };
+            }
+            catch {
+                this.messages = this.context.compact(this.messages, true);
+                yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
+            }
         }
         for (let i = 0; i < this.maxIterations; i++) {
             // Validate message integrity: ensure every tool_call has a matching tool response
@@ -100,29 +106,41 @@ class Agent {
             const toolSchemas = supportsTools ? this.tools.getSchemas() : undefined;
             let fullText = '';
             let toolCalls = [];
-            // Stream LLM response
-            for await (const event of this.provider.chat(this.messages, toolSchemas)) {
-                switch (event.type) {
-                    case 'text':
-                        fullText += event.text || '';
-                        yield { type: 'text', text: event.text };
-                        break;
-                    case 'thinking':
-                        yield { type: 'thinking', text: event.text };
-                        break;
-                    case 'tool_call_end':
-                        if (event.toolCall) {
-                            toolCalls.push(event.toolCall);
-                        }
-                        break;
-                    case 'usage':
-                        yield { type: 'usage', usage: event.usage };
-                        break;
-                    case 'error':
-                        yield { type: 'error', error: event.error };
-                        return;
+            let streamError = null;
+            // Stream LLM response — wrapped in try-catch for resilience
+            try {
+                for await (const event of this.provider.chat(this.messages, toolSchemas)) {
+                    switch (event.type) {
+                        case 'text':
+                            fullText += event.text || '';
+                            yield { type: 'text', text: event.text };
+                            break;
+                        case 'thinking':
+                            yield { type: 'thinking', text: event.text };
+                            break;
+                        case 'tool_call_end':
+                            if (event.toolCall) {
+                                toolCalls.push(event.toolCall);
+                            }
+                            break;
+                        case 'usage':
+                            yield { type: 'usage', usage: event.usage };
+                            break;
+                        case 'error':
+                            streamError = event.error || 'Unknown provider error';
+                            break;
+                    }
                 }
             }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                streamError = `Stream error: ${msg}`;
+            }
+            // On error: yield it to the UI but DON'T return — continue to next iteration
+            if (streamError) {
+                yield { type: 'error', error: streamError };
+                continue;
+            }
             // If no native tool calls, try parsing from text
             if (toolCalls.length === 0 && fullText) {
                 toolCalls = (0, parser_1.parseToolCalls)(fullText);
@@ -195,9 +213,15 @@ class Agent {
             }
             // Compact after tool results if needed
             if (!this.context.fitsInBudget(this.messages)) {
-                const result = await this.context.compactWithSummary(this.messages);
-                this.messages = result.messages;
-                yield { type: 'compaction', text: result.summary || 'Context compacted.' };
+                try {
+                    const result = await this.context.compactWithSummary(this.messages);
+                    this.messages = result.messages;
+                    yield { type: 'compaction', text: result.summary || 'Context compacted.' };
+                }
+                catch {
+                    this.messages = this.context.compact(this.messages, true);
+                    yield { type: 'compaction', text: 'Context compacted (summary unavailable).' };
+                }
             }
         }
         yield { type: 'error', error: `Max iterations (${this.maxIterations}) reached.` };

package/dist/cli.js

@@ -44,7 +44,7 @@ const setup_1 = require("./setup");
 const banner_1 = require("./banner");
 const tools_1 = require("./tools");
 const scheduler_1 = require("./scheduler");
-const VERSION = '1.2.3';
+const VERSION = '1.3.0';
 // Session-wide token tracking
 let sessionTokens = { input: 0, output: 0, total: 0 };
 const C = {
@@ -61,6 +61,17 @@ function c(text, style) {
     return `${C[style]}${text}${C.reset}`;
 }
 async function main() {
+    // Process-level safety nets: prevent silent crashes
+    process.on('unhandledRejection', (reason) => {
+        const msg = reason instanceof Error ? reason.message : String(reason);
+        console.error(`\x1b[31m\nUnhandled error: ${msg}\x1b[0m`);
+    });
+    process.on('uncaughtException', (err) => {
+        console.error(`\x1b[31m\nUncaught exception: ${err.message}\x1b[0m`);
+        if (err.message.includes('out of memory') || err.message.includes('ENOMEM')) {
+            process.exit(1);
+        }
+    });
     const args = parseArgs(process.argv.slice(2));
     if (args.help) {
         showHelp();
@@ -363,7 +374,12 @@ function handleSlashCommand(input, agent, config) {
         case '/routines': {
             const { RoutineTool } = require('./tools/routine');
             const rt = new RoutineTool();
-            rt.execute({ action: 'list' }).then((out) => console.log('\n' + out));
+            rt.execute({ action: 'list' })
+                .then((out) => console.log('\n' + out))
+                .catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error(c(`Error listing routines: ${msg}`, 'red'));
+            });
             break;
         }
         case '/config':

package/dist/providers/anthropic.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AnthropicProvider = void 0;
+const retry_1 = require("../retry");
 class AnthropicProvider {
     name;
     config;
@@ -27,26 +28,45 @@ class AnthropicProvider {
             }));
         }
         const baseUrl = this.config.baseUrl.replace(/\/+$/, '');
+        const MAX_RETRIES = 3;
         let response;
-        try {
-            response = await fetch(`${baseUrl}/v1/messages`, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'x-api-key': this.config.apiKey || '',
-                    'anthropic-version': '2023-06-01',
-                },
-                body: JSON.stringify(body),
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            yield { type: 'error', error: `Connection failed: ${msg}` };
-            return;
+        let lastError = '';
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                response = await fetch(`${baseUrl}/v1/messages`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-api-key': this.config.apiKey || '',
+                        'anthropic-version': '2023-06-01',
+                    },
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(60_000),
+                });
+                if (response.ok || !(0, retry_1.isRetryable)(null, response.status)) {
+                    break;
+                }
+                lastError = `Anthropic error ${response.status}`;
+                if (attempt < MAX_RETRIES) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt, response.headers.get('retry-after'));
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                if (attempt < MAX_RETRIES && (0, retry_1.isRetryable)(err)) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt);
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+                yield { type: 'error', error: `Connection failed after ${attempt + 1} attempts: ${lastError}` };
+                return;
+            }
         }
-        if (!response.ok) {
-            const text = await response.text();
-            yield { type: 'error', error: `Anthropic error ${response.status}: ${text}` };
+        if (!response || !response.ok) {
+            const text = response ? await response.text().catch(() => '') : '';
+            yield { type: 'error', error: `Anthropic error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
             return;
         }
         if (!response.body) {

package/dist/providers/openai.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIProvider = void 0;
 const registry_1 = require("./registry");
+const retry_1 = require("../retry");
 class OpenAIProvider {
     name;
     config;
@@ -33,22 +34,42 @@ class OpenAIProvider {
         if (this.config.apiKey) {
             headers['Authorization'] = `Bearer ${this.config.apiKey}`;
         }
+        const MAX_RETRIES = 3;
         let response;
-        try {
-            response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify(body),
-            });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            yield { type: 'error', error: `Connection failed: ${msg}. Is your LLM server running?` };
-            return;
+        let lastError = '';
+        for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+            try {
+                response = await fetch(`${this.config.baseUrl}/v1/chat/completions`, {
+                    method: 'POST',
+                    headers,
+                    body: JSON.stringify(body),
+                    signal: AbortSignal.timeout(60_000),
+                });
+                if (response.ok || !(0, retry_1.isRetryable)(null, response.status)) {
+                    break;
+                }
+                // Retryable HTTP status (429, 5xx)
+                lastError = `LLM error ${response.status}`;
+                if (attempt < MAX_RETRIES) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt, response.headers.get('retry-after'));
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+            }
+            catch (err) {
+                lastError = err instanceof Error ? err.message : String(err);
+                if (attempt < MAX_RETRIES && (0, retry_1.isRetryable)(err)) {
+                    const delay = (0, retry_1.getRetryDelay)(attempt);
+                    await (0, retry_1.sleep)(delay);
+                    continue;
+                }
+                yield { type: 'error', error: `Connection failed after ${attempt + 1} attempts: ${lastError}. Is your LLM server running?` };
+                return;
+            }
         }
-        if (!response.ok) {
-            const text = await response.text();
-            yield { type: 'error', error: `LLM error ${response.status}: ${text}` };
+        if (!response || !response.ok) {
+            const text = response ? await response.text().catch(() => '') : '';
+            yield { type: 'error', error: `LLM error after retries: ${lastError}${text ? ` — ${text}` : ''}` };
             return;
         }
         if (!response.body) {

package/dist/retry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Retry utilities for resilient network operations.
+ * Exponential backoff with jitter, Retry-After header support.
+ * Zero dependencies.
+ */
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    maxDelayMs?: number;
+    retryableStatuses?: number[];
+}
+declare const DEFAULTS: Required<RetryOptions>;
+/** Returns true if the error/status is retryable (network error or retryable HTTP status). */
+export declare function isRetryable(error: unknown, status?: number, opts?: RetryOptions): boolean;
+/**
+ * Calculate delay with exponential backoff + jitter.
+ * For 429 responses, respects Retry-After header.
+ */
+export declare function getRetryDelay(attempt: number, retryAfterHeader?: string | null, opts?: RetryOptions): number;
+export declare function sleep(ms: number): Promise<void>;
+export { DEFAULTS as RETRY_DEFAULTS };
+//# sourceMappingURL=retry.d.ts.map

package/dist/retry.js

@@ -0,0 +1,59 @@
+"use strict";
+/**
+ * Retry utilities for resilient network operations.
+ * Exponential backoff with jitter, Retry-After header support.
+ * Zero dependencies.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RETRY_DEFAULTS = void 0;
+exports.isRetryable = isRetryable;
+exports.getRetryDelay = getRetryDelay;
+exports.sleep = sleep;
+const DEFAULTS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    retryableStatuses: [429, 500, 502, 503, 504],
+};
+exports.RETRY_DEFAULTS = DEFAULTS;
+/** Returns true if the error/status is retryable (network error or retryable HTTP status). */
+function isRetryable(error, status, opts) {
+    const statuses = opts?.retryableStatuses ?? DEFAULTS.retryableStatuses;
+    if (status && statuses.includes(status))
+        return true;
+    if (error instanceof TypeError)
+        return true; // fetch network errors
+    if (error instanceof Error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes('fetch failed') || msg.includes('econnreset') ||
+            msg.includes('econnrefused') || msg.includes('etimedout') ||
+            msg.includes('socket hang up') || msg.includes('network') ||
+            msg.includes('abort')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Calculate delay with exponential backoff + jitter.
+ * For 429 responses, respects Retry-After header.
+ */
+function getRetryDelay(attempt, retryAfterHeader, opts) {
+    const base = opts?.baseDelayMs ?? DEFAULTS.baseDelayMs;
+    const max = opts?.maxDelayMs ?? DEFAULTS.maxDelayMs;
+    // Respect Retry-After header (in seconds)
+    if (retryAfterHeader) {
+        const seconds = parseInt(retryAfterHeader, 10);
+        if (!isNaN(seconds) && seconds > 0) {
+            return Math.min(seconds * 1000, max);
+        }
+    }
+    // Exponential backoff with jitter: base * 2^attempt * (0.5..1.5)
+    const exponential = base * Math.pow(2, attempt);
+    const jitter = 0.5 + Math.random();
+    return Math.min(exponential * jitter, max);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=retry.js.map

package/dist/scheduler.d.ts

@@ -12,6 +12,8 @@ export declare class Scheduler {
     /** Check if any routines need to run right now */
     private tick;
     private executeRoutine;
+    /** Run the agent loop for a routine — separated so it can be wrapped in Promise.race */
+    private runRoutineAgent;
     private loadRoutines;
     private saveRoutines;
 }

package/dist/scheduler.js

@@ -90,25 +90,14 @@ class Scheduler {
     }
     async executeRoutine(routine, allRoutines) {
         this.running = true;
+        const ROUTINE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes max per routine
         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;
-                }
-            }
+            // Race against a timeout so a hanging routine doesn't block the scheduler forever
+            await Promise.race([
+                this.runRoutineAgent(routine),
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Routine timed out after ${ROUTINE_TIMEOUT_MS / 1000}s`)), ROUTINE_TIMEOUT_MS)),
+            ]);
             // Update last run time
             routine.lastRun = new Date().toISOString();
             this.saveRoutines(allRoutines);
@@ -122,6 +111,25 @@ class Scheduler {
             this.running = false;
         }
     }
+    /** Run the agent loop for a routine — separated so it can be wrapped in Promise.race */
+    async runRoutineAgent(routine) {
+        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;
+            }
+        }
+    }
     loadRoutines() {
         try {
             if (fs.existsSync(ROUTINES_FILE)) {

package/dist/tools/web-fetch.js

@@ -73,14 +73,23 @@ class WebFetchTool {
             body = args.body;
         }
         try {
+            // AbortController covers both connection AND body reading (res.text())
+            const controller = new AbortController();
+            const bodyTimeout = setTimeout(() => controller.abort(), 30_000);
             const res = await fetch(url, {
                 method,
                 headers,
                 body,
-                signal: AbortSignal.timeout(30000),
+                signal: controller.signal,
             });
             const contentType = res.headers.get('content-type') || '';
-            const responseText = await res.text();
+            let responseText;
+            try {
+                responseText = await res.text();
+            }
+            finally {
+                clearTimeout(bodyTimeout);
+            }
             // Truncate very large responses
             const maxLen = 50000;
             const truncated = responseText.length > maxLen

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "codebot-ai",
-  "version": "1.2.3",
-  "description": "Local-first AI coding assistant. Zero dependencies. Works with Ollama, LM Studio, vLLM, Claude, GPT, Gemini, and more.",
+  "version": "1.3.0",
+  "description": "Zero-dependency autonomous AI agent. Code, browse, search, automate. Works with any LLM — Ollama, Claude, GPT, Gemini, DeepSeek, Groq, Mistral, Grok.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "bin": {
@@ -17,17 +17,25 @@
   },
   "keywords": [
     "ai",
-    "coding-assistant",
-    "ollama",
-    "local-llm",
+    "ai-agent",
     "agent",
-    "cli",
+    "autonomous",
+    "agentic",
+    "coding-assistant",
     "code-generation",
+    "llm",
+    "openai",
     "claude",
     "gpt",
     "gemini",
-    "autonomous",
-    "agentic"
+    "ollama",
+    "deepseek",
+    "groq",
+    "mistral",
+    "local-llm",
+    "browser-automation",
+    "cli",
+    "web-search"
   ],
   "author": "Ascendral Software Development & Innovation",
   "license": "MIT",