@stevederico/dotbot 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+0.29
+
+  Extract shared streamEvents
+  Remove dead databaseManager logging
+  Remove dead CDP methods
+  Remove dead compat aliases
+  Remove dead observer module
+  Consolidate cron row mapping
+  Update README sandbox docs
+
 0.28
 
   Add --sandbox mode

package/README.md

@@ -13,7 +13,7 @@
       <img src="https://img.shields.io/github/stars/stevederico/dotbot?style=social" alt="GitHub stars">
     </a>
     <a href="https://github.com/stevederico/dotbot">
-      <img src="https://img.shields.io/badge/version-0.25-green" alt="version">
+      <img src="https://img.shields.io/badge/version-0.28-green" alt="version">
     </a>
     <img src="https://img.shields.io/badge/LOC-11k-orange" alt="Lines of Code">
   </p>
@@ -27,9 +27,10 @@
 
 | | dotbot | nanobot | OpenClaw |
 |---|:---:|:---:|:---:|
-| **Lines of Code** | **11k** | 22k | 1M+ |
+| **Lines of Code** | **~11k** | 22k | 1M+ |
 | **Tools** | **53** | ~10 | ~50 |
-| **Dependencies** | Minimal | Heavy | Heavy |
+| **Dependencies** | **0** | Heavy | Heavy |
+| **Sandbox Mode** | **Built-in** | No | Requires NemoClaw |
 
 Everything you need for AI agents. Nothing you don't. No bloated abstractions. No dependency hell. Just a clean, focused agent that works.
 
@@ -43,7 +44,9 @@ A **streaming AI agent** with tool execution, autonomous tasks, and scheduled jo
 ```bash
 dotbot "What's the weather in San Francisco?"
 dotbot                  # Interactive mode
+dotbot --sandbox        # Sandbox mode (restricted tools)
 dotbot serve --port 3000
+dotbot models           # List available models
 dotbot tools            # List all 53 tools
 ```
 
@@ -80,6 +83,49 @@ dotbot stats
 dotbot memory
 ```
 
+### Sandbox Mode
+
+Run dotbot with restricted tool access — deny-by-default.
+
+```bash
+# Full lockdown — safe tools only (memory, search, weather, tasks)
+dotbot --sandbox "What is 2+2?"
+
+# Allow specific domains for web_fetch and browser_navigate
+dotbot --sandbox --allow github
+dotbot --sandbox --allow github --allow slack
+
+# Allow specific tool groups
+dotbot --sandbox --allow messages
+dotbot --sandbox --allow images
+
+# Mix domains and tool groups
+dotbot --sandbox --allow github --allow messages --allow npm
+
+# Custom domain
+dotbot --sandbox --allow api.mycompany.com
+
+# Persistent config in ~/.dotbotrc
+# { "sandbox": true, "sandboxAllow": ["github", "slack", "messages"] }
+```
+
+**What's blocked by default:**
+
+| Category | Tools | How to unlock |
+|----------|-------|---------------|
+| Filesystem writes | `file_write`, `file_delete`, `file_move`, `folder_create` | Cannot unlock |
+| Arbitrary HTTP | `web_fetch` | `--allow <domain>` |
+| Browser | `browser_navigate` | `--allow <domain>` |
+| Code execution | `run_code` | Always allowed (Node.js permission model) |
+| Messaging | `message_*` | `--allow messages` |
+| Images | `image_*` | `--allow images` |
+| Notifications | `notify_user` | `--allow notifications` |
+| App generation | `app_generate`, `app_validate` | Cannot unlock |
+
+**What's always allowed:** `memory_*`, `web_search`, `grokipedia_search`, `file_read`, `file_list`, `weather_get`, `event_*`, `task_*`, `trigger_*`, `schedule_job`, `list_jobs`, `toggle_job`, `cancel_job`
+
+**Domain presets:** `github`, `slack`, `discord`, `npm`, `pypi`, `jira`, `huggingface`, `docker`, `telegram`
+
 ### Library Usage
 
 ```bash
@@ -139,9 +185,13 @@ for await (const event of agent.chat({
 - **Cerebras** — ultra-fast inference
 - **Ollama** — local models, no API cost
 
+### 🔒 **Sandbox Mode**
+- **Deny-by-default** tool access — no files, code, browser, or messaging
+- **Domain allowlists** — `--allow github`, `--allow slack`
+- **Preset-based** tool unlocking — `--allow messages`, `--allow images`
+
 ### 💾 **Pluggable Storage**
 - **SQLite** — zero dependencies with Node.js 22.5+
-- **MongoDB** — scalable with full-text search
 - **Memory** — in-memory for testing
 
 ### 📊 **Full Audit Trail**
@@ -154,7 +204,7 @@ for await (const event of agent.chat({
 ## CLI Reference
 
 ```
-dotbot v0.25 — AI agent CLI
+dotbot v0.28 — AI agent CLI
 
 Usage:
   dotbot "message"            One-shot query
@@ -164,6 +214,7 @@ Usage:
   echo "msg" | dotbot         Pipe input from stdin
 
 Commands:
+  models                      List available models from provider
   doctor                      Check environment and configuration
   tools                       List all available tools
   stats                       Show database statistics
@@ -182,6 +233,8 @@ Options:
   --model, -m      Model name (default: grok-4-1-fast-reasoning)
   --system, -s     Custom system prompt (prepended to default)
   --session        Resume a specific session by ID
+  --sandbox        Restrict tools to safe subset (deny-by-default)
+  --allow          Allow domain/preset in sandbox (github, slack, messages, etc.)
   --db             SQLite database path (default: ./dotbot.db)
   --port           Server port for 'serve' command
   --openai         Enable OpenAI-compatible API endpoints
@@ -197,7 +250,7 @@ Environment Variables:
   OLLAMA_BASE_URL      Base URL for Ollama (default: http://localhost:11434)
 
 Config File:
-  ~/.dotbotrc          JSON config for defaults (provider, model, db)
+  ~/.dotbotrc          JSON config for defaults (provider, model, db, sandbox)
 ```
 
 <br />
@@ -323,9 +376,8 @@ await agent.chat({
 | Technology | Purpose |
 |------------|---------|
 | **Node.js 22.5+** | Runtime with built-in SQLite |
-| **Playwright** | Browser automation |
+| **Chrome DevTools Protocol** | Browser automation (zero deps) |
 | **SQLite** | Default storage (zero deps) |
-| **MongoDB** | Scalable storage option |
 
 <br />
 
@@ -334,12 +386,13 @@ await agent.chat({
 ```
 dotbot/
 ├── bin/
-│   └── dotbot.js           # CLI entry point
+│   └── dotbot.js           # CLI entry point (REPL, server, sandbox mode)
 ├── core/
 │   ├── agent.js            # Streaming agent loop
 │   ├── events.js           # SSE event schemas
 │   ├── compaction.js       # Context window management
 │   ├── normalize.js        # Message format conversion
+│   ├── failover.js         # Cross-provider failover
 │   ├── cron_handler.js     # Scheduled job execution
 │   └── trigger_handler.js  # Event-driven triggers
 ├── storage/
@@ -347,9 +400,8 @@ dotbot/
 │   ├── TaskStore.js        # Task interface
 │   ├── CronStore.js        # Job scheduling interface
 │   ├── TriggerStore.js     # Trigger interface
-│   ├── SQLite*.js          # SQLite adapters
-│   └── Mongo*.js           # MongoDB adapters
-├── tools/                  # 47 built-in tools
+│   └── SQLite*.js          # SQLite adapters
+├── tools/                  # 53 built-in tools
 │   ├── memory.js
 │   ├── web.js
 │   ├── browser.js

package/bin/dotbot.js

@@ -604,50 +604,21 @@ async function initStores(dbPath, verbose = false, customSystemPrompt = '') {
 }
 
 /**
- * Run a single chat message and stream output.
+ * Stream events from an agentLoop iterable to stdout.
+ * Handles thinking markers, text deltas, tool status, and errors.
  *
- * @param {string} message - User message
- * @param {Object} options - CLI options
+ * @param {AsyncIterable<Object>} events - Async iterable of agentLoop events
+ * @returns {Promise<string>} Accumulated assistant text content
  */
-async function runChat(message, options) {
-  const storesObj = await initStores(options.db, options.verbose, options.system);
-  const provider = await getProviderConfig(options.provider);
-
-  let session;
-  let messages;
-
-  if (options.session) {
-    session = await storesObj.sessionStore.getSession(options.session, 'cli-user');
-    if (!session) {
-      console.error(`Error: Session not found: ${options.session}`);
-      process.exit(1);
-    }
-    messages = [...(session.messages || []), { role: 'user', content: message }];
-  } else {
-    session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
-    messages = [{ role: 'user', content: message }];
-  }
-
-  const context = {
-    userID: 'cli-user',
-    sessionId: session.id,
-    providers: { [options.provider]: { apiKey: process.env[AI_PROVIDERS[options.provider]?.envKey] } },
-    ...storesObj,
-  };
-
+async function streamEvents(events) {
   let hasThinkingText = false;
   let thinkingDone = false;
+  let assistantContent = '';
 
   process.stdout.write('Thinking');
   startSpinner();
 
-  for await (const event of agentLoop({
-    model: options.model,
-    messages,
-    tools: getActiveTools(options.sandbox, options.sandboxAllow),
-    provider,
-    context,
-  })) {
+  for await (const event of events) {
     switch (event.type) {
       case 'thinking':
         if (event.text) {
@@ -669,6 +640,7 @@ async function runChat(message, options) {
           thinkingDone = true;
         }
         process.stdout.write(event.text);
+        assistantContent += event.text;
         break;
       case 'tool_start':
         if (!thinkingDone) {
@@ -689,11 +661,55 @@ async function runChat(message, options) {
         stopSpinner('error');
         break;
       case 'error':
+        stopSpinner();
         console.error(`\nError: ${event.error}`);
         break;
     }
   }
 
+  return assistantContent;
+}
+
+/**
+ * Run a single chat message and stream output.
+ *
+ * @param {string} message - User message
+ * @param {Object} options - CLI options
+ */
+async function runChat(message, options) {
+  const storesObj = await initStores(options.db, options.verbose, options.system);
+  const provider = await getProviderConfig(options.provider);
+
+  let session;
+  let messages;
+
+  if (options.session) {
+    session = await storesObj.sessionStore.getSession(options.session, 'cli-user');
+    if (!session) {
+      console.error(`Error: Session not found: ${options.session}`);
+      process.exit(1);
+    }
+    messages = [...(session.messages || []), { role: 'user', content: message }];
+  } else {
+    session = await storesObj.sessionStore.createSession('cli-user', options.model, options.provider);
+    messages = [{ role: 'user', content: message }];
+  }
+
+  const context = {
+    userID: 'cli-user',
+    sessionId: session.id,
+    providers: { [options.provider]: { apiKey: process.env[AI_PROVIDERS[options.provider]?.envKey] } },
+    ...storesObj,
+  };
+
+  await streamEvents(agentLoop({
+    model: options.model,
+    messages,
+    tools: getActiveTools(options.sandbox, options.sandboxAllow),
+    provider,
+    context,
+  }));
+
   process.stdout.write('\n\n');
   process.exit(0);
 }
@@ -864,68 +880,14 @@ async function runRepl(options) {
   const handleMessage = async (text) => {
     messages.push({ role: 'user', content: text });
 
-    let hasThinkingText = false;
-    let thinkingDone = false;
-    let assistantContent = '';
-
-    process.stdout.write('Thinking');
-    startSpinner();
-
     try {
-      for await (const event of agentLoop({
+      const assistantContent = await streamEvents(agentLoop({
         model: options.model,
         messages: [...messages],
         tools: getActiveTools(options.sandbox, options.sandboxAllow),
         provider,
         context,
-      })) {
-        switch (event.type) {
-          case 'thinking':
-            if (event.text) {
-              if (!hasThinkingText) {
-                stopSpinner('');
-                process.stdout.write('\n');
-                hasThinkingText = true;
-              }
-              process.stdout.write(event.text);
-            }
-            break;
-          case 'text_delta':
-            if (!thinkingDone) {
-              if (hasThinkingText) {
-                process.stdout.write('\n...done thinking.\n\n');
-              } else {
-                stopSpinner('');
-              }
-              thinkingDone = true;
-            }
-            process.stdout.write(event.text);
-            assistantContent += event.text;
-            break;
-          case 'tool_start':
-            if (!thinkingDone) {
-              if (hasThinkingText) {
-                process.stdout.write('\n...done thinking.\n\n');
-              } else {
-                stopSpinner('');
-              }
-              thinkingDone = true;
-            }
-            process.stdout.write(`[${event.name}] `);
-            startSpinner();
-            break;
-          case 'tool_result':
-            stopSpinner('done');
-            break;
-          case 'tool_error':
-            stopSpinner('error');
-            break;
-          case 'error':
-            stopSpinner();
-            console.error(`\nError: ${event.error}`);
-            break;
-        }
-      }
+      }));
 
       if (assistantContent) {
         messages.push({ role: 'assistant', content: assistantContent });

package/core/agent.js

@@ -31,7 +31,7 @@ const OLLAMA_BASE = "http://localhost:11434";
  * @param {Array} options.tools - Tool definitions from tools.js
  * @param {AbortSignal} [options.signal] - Optional abort signal
  * @param {Object} [options.provider] - Provider config from AI_PROVIDERS. Defaults to Ollama.
- * @param {Object} [options.context] - Execution context passed to tool execute functions (e.g. databaseManager, dbConfig, userID).
+ * @param {Object} [options.context] - Execution context passed to tool execute functions (e.g. providers, userID).
  * @yields {Object} Stream events for the frontend
  */
 export async function* agentLoop({ model, messages, tools, signal, provider, context, maxTurns }) {

package/core/cdp.js

@@ -184,35 +184,22 @@ export class CDPClient {
     return result.result?.value;
   }
 
-  /**
-   * Get the page title.
-   * @returns {Promise<string>}
-   */
+  /** Get the page title. */
   async getTitle() {
     return this.evaluate('document.title');
   }
 
-  /**
-   * Get the current URL.
-   * @returns {Promise<string>}
-   */
+  /** Get the current URL. */
   async getUrl() {
     return this.evaluate('window.location.href');
   }
 
-  /**
-   * Get text content of the page body.
-   * @returns {Promise<string>}
-   */
+  /** Get text content of the page body. */
   async getBodyText() {
     return this.evaluate('document.body?.innerText || ""');
   }
 
-  /**
-   * Get text content of an element by CSS selector.
-   * @param {string} selector - CSS selector
-   * @returns {Promise<string>}
-   */
+  /** Get text content of an element by CSS selector. */
   async getText(selector) {
     const escaped = selector.replace(/"/g, '\\"');
     return this.evaluate(`document.querySelector("${escaped}")?.innerText || ""`);
@@ -308,26 +295,6 @@ export class CDPClient {
     });
   }
 
-  /**
-   * Click an element by CSS selector.
-   * @param {string} selector - CSS selector
-   */
-  async clickSelector(selector) {
-    const el = await this.querySelector(selector);
-    if (!el) throw new Error(`Element not found: ${selector}`);
-    await this.click(el.x, el.y);
-  }
-
-  /**
-   * Click an element by visible text.
-   * @param {string} text - Text content to find
-   */
-  async clickText(text) {
-    const el = await this.getByText(text);
-    if (!el) throw new Error(`Element with text "${text}" not found`);
-    await this.click(el.x, el.y);
-  }
-
   /**
    * Type text character by character.
    * @param {string} text - Text to type
@@ -453,9 +420,7 @@ export class CDPClient {
     });
   }
 
-  /**
-   * Close the connection.
-   */
+  /** Close the CDP connection. */
   close() {
     if (this.ws) {
       this.ws.close();
@@ -490,24 +455,6 @@ export class CDPClient {
     throw lastError;
   }
 
-  /**
-   * Wait for an element to appear in the DOM.
-   * @param {string} selector - CSS selector
-   * @param {Object} options - Wait options
-   * @param {number} options.timeout - Timeout in ms (default: 5000)
-   * @param {number} options.interval - Poll interval in ms (default: 100)
-   * @returns {Promise<{x: number, y: number, nodeId: number}>} Element info
-   */
-  async waitForSelector(selector, { timeout = 5000, interval = 100 } = {}) {
-    const start = Date.now();
-    while (Date.now() - start < timeout) {
-      const el = await this.querySelector(selector);
-      if (el) return el;
-      await new Promise(r => setTimeout(r, interval));
-    }
-    throw new Error(`Timeout waiting for selector: ${selector}`);
-  }
-
   /**
    * Wait for network to be idle (no requests for a period).
    * @param {Object} options - Wait options

package/index.js

@@ -18,10 +18,8 @@ import {
   notifyTools,
   createBrowserTools,
   taskTools,
-  goalTools,
   triggerTools,
   jobTools,
-  cronTools,
   eventTools,
   appgenTools,
 } from './tools/index.js';
@@ -40,9 +38,6 @@ export {
   runWithConcurrency,
   TaskStore,
   SQLiteTaskStore,
-  // Backwards compatibility aliases
-  GoalStore,
-  SQLiteGoalStore,
   TriggerStore,
   SQLiteTriggerStore,
   SQLiteMemoryStore,
@@ -65,10 +60,8 @@ export {
   browserTools,
   createBrowserTools,
   taskTools,
-  goalTools,   // backwards compatibility alias
   triggerTools,
   jobTools,
-  cronTools,   // backwards compatibility alias
   eventTools,
   appgenTools,
 } from './tools/index.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stevederico/dotbot",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "AI agent CLI and library for Node.js — streaming, multi-provider, tool execution, autonomous tasks",
   "type": "module",
   "main": "index.js",

package/storage/SQLiteCronAdapter.js

@@ -220,16 +220,7 @@ export class SQLiteCronStore extends CronStore {
       "SELECT * FROM cron_tasks WHERE session_id = ? AND name != 'heartbeat' ORDER BY next_run_at ASC"
     ).all(sessionId || 'default');
 
-    return rows.map(r => ({
-      id: r.id,
-      name: r.name,
-      prompt: r.prompt,
-      nextRunAt: new Date(r.next_run_at),
-      recurring: !!r.recurring,
-      intervalMs: r.interval_ms,
-      enabled: !!r.enabled,
-      lastRunAt: r.last_run_at ? new Date(r.last_run_at) : null,
-    }));
+    return rows.map(r => this._rowToTask(r));
   }
 
   /**
@@ -257,18 +248,7 @@ export class SQLiteCronStore extends CronStore {
 
     const rows = this.db.prepare(query).all(...params);
 
-    return rows.map(r => ({
-      id: r.id,
-      name: r.name,
-      prompt: r.prompt,
-      sessionId: r.session_id,
-      nextRunAt: new Date(r.next_run_at),
-      recurring: !!r.recurring,
-      intervalMs: r.interval_ms,
-      enabled: !!r.enabled,
-      lastRunAt: r.last_run_at ? new Date(r.last_run_at) : null,
-      createdAt: new Date(r.created_at),
-    }));
+    return rows.map(r => this._rowToTask(r));
   }
 
   /**
@@ -374,53 +354,6 @@ export class SQLiteCronStore extends CronStore {
     return null;
   }
 
-  /**
-   * Ensure a Morning Brief job exists for the user (disabled by default).
-   * Creates a daily recurring job at 8:00 AM if not present.
-   *
-   * @param {string} userId - User ID
-   * @returns {Promise<Object|null>} Created task or null if already exists
-   */
-  async ensureMorningBrief(userId) {
-    if (!this.db || !userId) return null;
-
-    // Check if Morning Brief already exists for this user
-    const existing = this.db.prepare(
-      `SELECT id FROM cron_tasks WHERE user_id = ? AND name = 'Morning Brief' LIMIT 1`
-    ).get(userId);
-    if (existing) return null;
-
-    const DAY_MS = 24 * 60 * 60 * 1000;
-    const MORNING_BRIEF_PROMPT = `Good morning! Give me a brief summary to start my day:
-1. What's on my calendar today?
-2. Any important reminders or tasks due?
-3. A quick weather update for my location.
-Keep it concise and actionable.`;
-
-    // Calculate next 8:00 AM
-    const now = new Date();
-    const today8AM = new Date(now.getFullYear(), now.getMonth(), now.getDate(), 8, 0, 0, 0);
-    const nextRun = now.getTime() < today8AM.getTime()
-      ? today8AM.getTime()
-      : today8AM.getTime() + DAY_MS;
-
-    const id = crypto.randomUUID();
-    const nowMs = Date.now();
-
-    const result = this.db.prepare(`
-      INSERT OR IGNORE INTO cron_tasks (id, name, prompt, session_id, user_id, next_run_at, interval_ms, recurring, enabled, created_at, last_run_at)
-      VALUES (?, 'Morning Brief', ?, 'default', ?, ?, ?, 1, 0, ?, NULL)
-    `).run(id, MORNING_BRIEF_PROMPT, userId, nextRun, DAY_MS, nowMs);
-
-    if (result.changes > 0) {
-      const runTime = new Date(nextRun);
-      console.log(`[cron] created Morning Brief for user ${userId}, next run at ${runTime.toLocaleTimeString()} (disabled by default)`);
-      return { id };
-    }
-
-    return null;
-  }
-
   /**
    * Get heartbeat status for a user
    *
@@ -455,35 +388,18 @@ Keep it concise and actionable.`;
   async resetHeartbeat(userId) {
     if (!this.db || !userId) return null;
 
-    const deleted = this.db.prepare(
+    this.db.prepare(
       "DELETE FROM cron_tasks WHERE user_id = ? AND name = 'heartbeat'"
     ).run(userId);
     console.log(`[cron] deleted existing heartbeat(s) for user ${userId}`);
 
-    const jitter = Math.floor(Math.random() * HEARTBEAT_INTERVAL_MS);
-    const now = Date.now();
-    const id = crypto.randomUUID();
+    const result = await this.ensureHeartbeat(userId);
 
-    this.db.prepare(`
-      INSERT INTO cron_tasks (id, name, prompt, session_id, user_id, next_run_at, interval_ms, recurring, enabled, created_at, last_run_at)
-      VALUES (?, 'heartbeat', ?, 'default', ?, ?, ?, 1, 1, ?, NULL)
-    `).run(id, HEARTBEAT_PROMPT, userId, now + jitter, HEARTBEAT_INTERVAL_MS, now);
-
-    console.log(`[cron] created new heartbeat for user ${userId}, first run in ${Math.round(jitter / 60000)}m`);
+    if (!result) return null;
 
-    return {
-      id,
-      name: 'heartbeat',
-      prompt: HEARTBEAT_PROMPT,
-      userId,
-      sessionId: 'default',
-      nextRunAt: new Date(now + jitter),
-      intervalMs: HEARTBEAT_INTERVAL_MS,
-      recurring: true,
-      enabled: true,
-      createdAt: new Date(now),
-      lastRunAt: null,
-    };
+    // Return the full task object for the newly created heartbeat
+    const row = this.db.prepare('SELECT * FROM cron_tasks WHERE id = ?').get(result.id);
+    return row ? this._rowToTask(row) : null;
   }
 
   /**

package/storage/index.js

@@ -5,9 +5,6 @@ export { CronStore } from './CronStore.js';
 export { SQLiteCronStore, parseInterval, HEARTBEAT_INTERVAL_MS, HEARTBEAT_PROMPT } from './SQLiteCronAdapter.js';
 export { TaskStore } from './TaskStore.js';
 export { SQLiteTaskStore } from './SQLiteTaskAdapter.js';
-// Backwards compatibility aliases
-export { TaskStore as GoalStore } from './TaskStore.js';
-export { SQLiteTaskStore as SQLiteGoalStore } from './SQLiteTaskAdapter.js';
 export { TriggerStore } from './TriggerStore.js';
 export { SQLiteTriggerStore } from './SQLiteTriggerAdapter.js';
 export { SQLiteMemoryStore } from './SQLiteMemoryAdapter.js';

package/tools/appgen.js

@@ -57,14 +57,7 @@ export function cleanGeneratedCode(code) {
   if (!code) return { code: '', windowSize: { width: 800, height: 650 } };
 
   let cleanCode = code
-    // Remove markdown code blocks
-    .replace(/```javascript/gi, '')
-    .replace(/```jsx/gi, '')
-    .replace(/```js/gi, '')
-    .replace(/```react/gi, '')
-    .replace(/```typescript/gi, '')
-    .replace(/```tsx/gi, '')
-    .replace(/```/g, '')
+    .replace(/```(?:javascript|jsx|js|react|typescript|tsx)?/gi, '')
     // Remove HTML document wrappers
     .replace(/<html[^>]*>[\s\S]*<\/html>/gi, '')
     .replace(/<head[^>]*>[\s\S]*<\/head>/gi, '')
@@ -307,5 +300,3 @@ export const appgenTools = [
     }
   }
 ];
-
-export default appgenTools;

package/tools/browser.js

@@ -616,21 +616,6 @@ export function createBrowserTools(screenshotUrlPattern = (filename) => `/api/ag
             pageSummary += `\n\nPage structure:\n${trimmed}`;
           }
 
-          // Log to activity so Photos app can list the screenshot
-          if (context?.databaseManager) {
-            try {
-              await context.databaseManager.logAgentActivity(
-                context.dbConfig.dbType,
-                context.dbConfig.db,
-                context.dbConfig.connectionString,
-                context.userID,
-                { type: 'image_generation', prompt: `Screenshot: ${title}`, url: screenshotUrl, source: 'browser' }
-              );
-            } catch {
-              /* best effort */
-            }
-          }
-
           // Return image JSON so frontend renders the screenshot inline
           return JSON.stringify({ type: 'image', url: screenshotUrl, prompt: pageSummary });
         } catch (err) {

package/tools/code.js

@@ -52,20 +52,6 @@ export const codeTools = [
 
         await unlink(tmpFile).catch(() => {});
 
-        if (context?.databaseManager) {
-          try {
-            await context.databaseManager.logAgentActivity(
-              context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-              context.userID, {
-                type: 'code_execution',
-                code: input.code.slice(0, 500),
-                output: (stdout || stderr || '').slice(0, 500),
-                success: !stderr
-              }
-            );
-          } catch (e) { /* best effort */ }
-        }
-
         if (stderr) {
           return `Stderr:\n${stderr}\n\nStdout:\n${stdout}`;
         }
@@ -74,20 +60,6 @@ export const codeTools = [
       } catch (err) {
         await unlink(tmpFile).catch(() => {});
 
-        if (context?.databaseManager) {
-          try {
-            await context.databaseManager.logAgentActivity(
-              context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-              context.userID, {
-                type: 'code_execution',
-                code: input.code.slice(0, 500),
-                output: (err.stderr || err.message || '').slice(0, 500),
-                success: false
-              }
-            );
-          } catch (e) { /* best effort */ }
-        }
-
         if (err.killed) {
           return "Error: code execution timed out (10s limit)";
         }

package/tools/images.js

@@ -176,16 +176,6 @@ export const imageTools = [
         return result.error;
       }
 
-      // Log to activity for persistence
-      if (context?.databaseManager) {
-        try {
-          await context.databaseManager.logAgentActivity(
-            context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-            context.userID, { type: 'image_generation', prompt: input.prompt, url: result.url, source: 'agent' }
-          );
-        } catch (e) { /* best effort */ }
-      }
-
       return JSON.stringify({ type: 'image', url: result.url, prompt: input.prompt });
     },
   },

package/tools/index.js

@@ -13,9 +13,9 @@ import { imageTools } from './images.js';
 import { weatherTools } from './weather.js';
 import { notifyTools } from './notify.js';
 import { browserTools, createBrowserTools } from './browser.js';
-import { taskTools, goalTools } from './tasks.js';
+import { taskTools } from './tasks.js';
 import { triggerTools } from './triggers.js';
-import { jobTools, cronTools } from './jobs.js';
+import { jobTools } from './jobs.js';
 import { eventTools } from './events.js';
 import { appgenTools } from './appgen.js';
 
@@ -88,10 +88,8 @@ export {
   browserTools,
   createBrowserTools,
   taskTools,
-  goalTools,   // backwards compatibility alias
   triggerTools,
   jobTools,
-  cronTools,   // backwards compatibility alias
   eventTools,
   appgenTools,
 };

package/tools/jobs.js

@@ -155,5 +155,3 @@ export const jobTools = [
   },
 ];
 
-// Backwards compatibility alias
-export const cronTools = jobTools;

package/tools/tasks.js

@@ -400,5 +400,3 @@ export const taskTools = [
   },
 ];
 
-// Backwards compatibility: export goalTools as alias
-export const goalTools = taskTools;

package/tools/web.js

@@ -70,15 +70,6 @@ export const webTools = [
               result += "\n\nSources:\n" + [...citations].slice(0, 5).map((url, i) => `${i + 1}. ${url}`).join("\n");
             }
 
-            if (context?.databaseManager) {
-              try {
-                await context.databaseManager.logAgentActivity(
-                  context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-                  context.userID, { type: 'web_search', query: input.query, provider: 'grok', resultPreview: result.slice(0, 300) }
-                );
-              } catch (e) { /* best effort */ }
-            }
-
             return result || "No results found.";
           } else {
             const errText = await res.text();
@@ -120,15 +111,6 @@ export const webTools = [
 
       const result = parts.join("\n\n");
 
-      if (context?.databaseManager) {
-        try {
-          await context.databaseManager.logAgentActivity(
-            context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-            context.userID, { type: 'web_search', query: input.query, provider: 'duckduckgo', resultPreview: parts.slice(0, 2).join('\n').slice(0, 300) }
-          );
-        } catch (e) { /* best effort */ }
-      }
-
       return result;
     },
   },
@@ -176,15 +158,6 @@ export const webTools = [
           text = text.slice(0, maxChars) + `\n\n... [truncated, ${text.length} chars total]`;
         }
 
-        if (context?.databaseManager) {
-          try {
-            await context.databaseManager.logAgentActivity(
-              context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-              context.userID, { type: 'grokipedia_search', query: input.query, url }
-            );
-          } catch (e) { /* best effort */ }
-        }
-
         return text;
       } catch (err) {
         return `Error looking up Grokipedia: ${err.message}`;
@@ -260,15 +233,6 @@ export const webTools = [
             .trim();
         }
 
-        if (context?.databaseManager) {
-          try {
-            await context.databaseManager.logAgentActivity(
-              context.dbConfig.dbType, context.dbConfig.db, context.dbConfig.connectionString,
-              context.userID, { type: 'web_fetch', url: input.url, status: res.status }
-            );
-          } catch (e) { /* best effort */ }
-        }
-
         const maxChars = 8000;
         if (text.length > maxChars) {
           return text.slice(0, maxChars) + `\n\n... [truncated, ${text.length} chars total]`;

package/examples/sqlite-session-example.js

@@ -1,69 +0,0 @@
-/**
- * SQLiteSessionStore Usage Example
- *
- * Demonstrates how to use SQLite as a session storage backend
- * for the @dottie/agent library. Requires Node.js 22.5+.
- */
-
-import { createAgent, SQLiteSessionStore, coreTools } from '@dottie/agent';
-
-// Initialize SQLite session store
-const sessionStore = new SQLiteSessionStore();
-await sessionStore.init('./sessions.db', {
-  // Optional: Fetch user preferences from your database
-  prefsFetcher: async (userId) => {
-    // Example: fetch from a user database
-    return {
-      agentName: 'Dottie',
-      agentPersonality: 'helpful and concise',
-    };
-  },
-  // Optional: Ensure user heartbeat for cron tasks
-  heartbeatEnsurer: async (userId) => {
-    // Example: update last_seen timestamp in user database
-    console.log(`User ${userId} active`);
-    return null;
-  },
-});
-
-// Create agent with SQLite session storage
-const agent = createAgent({
-  sessionStore,
-  providers: {
-    anthropic: { apiKey: process.env.ANTHROPIC_API_KEY },
-  },
-  tools: coreTools,
-});
-
-// Example 1: Create a new session
-const session = await agent.createSession('user-123', 'claude-sonnet-4-5', 'anthropic');
-console.log('Created session:', session.id);
-
-// Example 2: Chat with the agent
-for await (const event of agent.chat({
-  sessionId: session.id,
-  message: 'What can you help me with?',
-  provider: 'anthropic',
-  model: 'claude-sonnet-4-5',
-})) {
-  if (event.type === 'content_block_delta' && event.delta?.type === 'text_delta') {
-    process.stdout.write(event.delta.text);
-  }
-}
-console.log('\n');
-
-// Example 3: List all sessions for a user
-const sessions = await sessionStore.listSessions('user-123');
-console.log('User sessions:', sessions);
-
-// Example 4: Get or create default session
-const defaultSession = await sessionStore.getOrCreateDefaultSession('user-123');
-console.log('Default session:', defaultSession.id);
-
-// Example 5: Clear session history
-await sessionStore.clearSession(session.id);
-console.log('Session cleared');
-
-// Example 6: Delete a session
-await sessionStore.deleteSession(session.id, 'user-123');
-console.log('Session deleted');

package/observer/index.js

@@ -1,164 +0,0 @@
-/**
- * Browser Observer — in-memory snapshot store and agent tool.
- *
- * The frontend pushes structured browser-state snapshots via POST /api/agent/observer.
- * The agent reads the latest snapshot via the `browser_observe` tool to understand
- * what the user is currently doing in the browser.
- */
-
-const SNAPSHOT_TTL_MS = 5 * 60 * 1000; // 5 minutes
-
-/** @type {Map<string, Object>} userID → { ...snapshot, receivedAt } */
-const snapshots = new Map();
-
-/**
- * Store the latest browser snapshot for a user.
- *
- * @param {string} userID - Authenticated user ID
- * @param {Object} snapshot - Structured browser state from the frontend
- */
-export function storeSnapshot(userID, snapshot) {
-  snapshots.set(userID, { ...snapshot, receivedAt: Date.now() });
-}
-
-/**
- * Retrieve the latest snapshot for a user, or null if stale/missing.
- *
- * @param {string} userID - Authenticated user ID
- * @returns {Object|null} Snapshot with receivedAt, or null
- */
-export function getSnapshot(userID) {
-  const entry = snapshots.get(userID);
-  if (!entry) return null;
-  if (Date.now() - entry.receivedAt > SNAPSHOT_TTL_MS) {
-    snapshots.delete(userID);
-    return null;
-  }
-  return entry;
-}
-
-/**
- * Remove a user's snapshot (cleanup on logout, etc.).
- *
- * @param {string} userID - Authenticated user ID
- */
-export function clearSnapshot(userID) {
-  snapshots.delete(userID);
-}
-
-/**
- * Format a snapshot into plain-text for LLM consumption.
- *
- * @param {Object} snap - Snapshot object from the store
- * @param {boolean} includeActions - Whether to include recent actions
- * @returns {string} Human-readable state description
- */
-function formatSnapshot(snap, includeActions = true) {
-  const ageSec = Math.round((Date.now() - snap.timestamp) / 1000);
-  const lines = [];
-
-  lines.push(`Browser state (${ageSec}s ago):`);
-  lines.push('');
-
-  // Windows
-  if (snap.windows && snap.windows.length > 0) {
-    lines.push(`Open apps (${snap.windowCount || snap.windows.length}):`);
-    for (const w of snap.windows) {
-      const focus = w.isFocused ? ' [focused]' : '';
-      lines.push(`  - ${w.app}${w.title ? ': ' + w.title : ''}${focus}`);
-    }
-  } else {
-    lines.push('No apps open.');
-  }
-
-  if (snap.focusedApp) {
-    lines.push(`Focused: ${snap.focusedApp}`);
-  }
-
-  // Docked panel
-  if (snap.isDottieDocked) {
-    lines.push('DotBot panel: docked (sidebar)');
-  }
-
-  // Input bar
-  if (snap.isInputElevated) {
-    lines.push(`Input bar: elevated${snap.inputValue ? ' — "' + snap.inputValue + '"' : ''}`);
-  }
-
-  // Voice
-  if (snap.voiceState && snap.voiceState !== 'idle') {
-    lines.push(`Voice: ${snap.voiceState}`);
-  }
-
-  // Streaming
-  if (snap.isStreaming) {
-    lines.push('Agent: streaming response');
-  }
-
-  // Last tool call
-  if (snap.lastToolCall) {
-    const tc = snap.lastToolCall;
-    const tcAge = Math.round((Date.now() - tc.timestamp) / 1000);
-    lines.push(`Last tool: ${tc.name} (${tc.status}, ${tcAge}s ago)`);
-  }
-
-  // Messages
-  if (snap.messageCount > 0) {
-    lines.push(`Messages in session: ${snap.messageCount}`);
-  }
-
-  // Provider/model
-  if (snap.currentProvider || snap.currentModel) {
-    lines.push(`Model: ${snap.currentProvider || '?'}/${snap.currentModel || '?'}`);
-  }
-
-  // Layout + dock
-  lines.push(`Layout: ${snap.layoutMode || 'desktop'}`);
-  if (snap.dockApps && snap.dockApps.length > 0) {
-    lines.push(`Dock: ${snap.dockApps.join(', ')}`);
-  }
-
-  // Viewport
-  if (snap.viewport) {
-    lines.push(`Viewport: ${snap.viewport.width}x${snap.viewport.height}`);
-  }
-
-  // Recent actions
-  if (includeActions && snap.recentActions && snap.recentActions.length > 0) {
-    lines.push('');
-    lines.push('Recent actions:');
-    for (const a of snap.recentActions) {
-      const aAge = Math.round((Date.now() - a.timestamp) / 1000);
-      const detail = a.app ? ` (${a.app})` : a.tool ? ` (${a.tool})` : '';
-      lines.push(`  - ${a.action}${detail} — ${aAge}s ago`);
-    }
-  }
-
-  return lines.join('\n');
-}
-
-/** Agent tool definitions for the browser observer. */
-export const observerTools = [
-  {
-    name: 'browser_observe',
-    description:
-      "See what the user is currently doing in Dottie OS — open apps, focused window, voice state, recent actions. " +
-      "Call this when you need context about the user's current activity, or when they reference 'this', 'what I'm looking at', or 'current'.",
-    parameters: {
-      type: 'object',
-      properties: {
-        include_actions: {
-          type: 'boolean',
-          description: 'Include recent user actions (default true)',
-        },
-      },
-    },
-    execute: async (input, signal, context) => {
-      if (!context?.userID) return 'Error: user context not available';
-      const snap = getSnapshot(context.userID);
-      if (!snap) return 'No browser state available. The user may have the tab in the background or just opened the page.';
-      const includeActions = input.include_actions !== false;
-      return formatSnapshot(snap, includeActions);
-    },
-  },
-];