0agent 1.0.50 → 1.0.55

package/bin/0agent.js

@@ -19,7 +19,7 @@
  *   0agent improve             # self-improvement analysis
  */
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, existsSync, mkdirSync, openSync } from 'node:fs';
 import { resolve, dirname } from 'node:path';
 import { homedir, platform } from 'node:os';
 import { spawn, execSync } from 'node:child_process';
@@ -431,10 +431,10 @@ async function startDaemon() {
 
   mkdirSync(resolve(AGENT_DIR, 'logs'), { recursive: true });
 
-  const logFile = writeFileSync(LOG_PATH, '', 'utf8');
+  const logFd = openSync(LOG_PATH, 'w');
   const child = spawn(process.execPath, [startScript], {
     detached: true,
-    stdio: ['ignore', 'ignore', 'ignore'],
+    stdio: ['ignore', logFd, logFd],
     env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH },
   });
   child.unref();

package/bin/chat.js

@@ -1192,7 +1192,14 @@ process.stdin.on('keypress', (_char, key) => {
     sessionId      = null;
     streaming      = false;
     streamLineCount = 0;
-    messageQueue.length = 0; // also clear queue — fresh start
+    messageQueue.length = 0;
+
+    // Kill any OS-level processes spawned by GUI/shell capabilities
+    // (python3 GUI scripts, bash subprocesses) so nothing keeps running
+    import('node:child_process').then(({ execSync: _exec }) => {
+      try { _exec('pkill -f "0agent_gui_" 2>/dev/null; pkill -f "0agent-bg-" 2>/dev/null; true', { stdio: 'ignore' }); } catch {}
+    }).catch(() => {});
+
     res();
     rl.prompt();
   }
@@ -1206,24 +1213,36 @@ connectWS();
 
 // ── Startup: ensure fresh daemon + verify LLM ────────────────────────────────
 async function _spawnDaemon() {
-  const pkgRoot = resolve(new URL(import.meta.url).pathname, '..', '..');
+  const pkgRoot  = resolve(new URL(import.meta.url).pathname, '..', '..');
   const bundled  = resolve(pkgRoot, 'dist', 'daemon.mjs');
-  if (!existsSync(bundled) || !existsSync(CONFIG_PATH)) return false;
+  const devPath  = resolve(pkgRoot, 'packages', 'daemon', 'dist', 'start.js');
+  const daemonScript = existsSync(bundled) ? bundled : existsSync(devPath) ? devPath : null;
+
+  if (!daemonScript) return 'no-bundle';
+  if (!existsSync(CONFIG_PATH)) return 'no-config';
+
   const { spawn } = await import('node:child_process');
-  const child = spawn(process.execPath, [bundled], {
-    detached: true, stdio: 'ignore',
+  const { openSync: fsOpen, mkdirSync: fsMkdir } = await import('node:fs');
+  const logDir = resolve(AGENT_DIR, 'logs');
+  fsMkdir(logDir, { recursive: true });
+  const logFd = fsOpen(resolve(logDir, 'daemon.log'), 'w');
+
+  const child = spawn(process.execPath, [daemonScript], {
+    detached: true,
+    stdio: ['ignore', logFd, logFd],
     env: { ...process.env, ZEROAGENT_CONFIG: CONFIG_PATH },
   });
   child.unref();
+
   // Wait up to 10s for daemon to be ready
   for (let i = 0; i < 20; i++) {
     await new Promise(r => setTimeout(r, 500));
     try {
       await fetch(`${BASE_URL}/api/health`, { signal: AbortSignal.timeout(500) });
-      return true;
+      return 'ok';
     } catch {}
   }
-  return false;
+  return 'timeout';
 }
 
 async function _safeJsonFetch(url, opts) {
@@ -1256,23 +1275,32 @@ async function _safeJsonFetch(url, opts) {
     // Daemon not running at all
   }
 
+  let spawnResult = 'ok';
   if (needsRestart) {
     startSpin.start('Restarting daemon (new version)');
-    // Kill old daemon
     try {
       const { execSync } = await import('node:child_process');
       execSync('pkill -f "daemon.mjs" 2>/dev/null; true', { stdio: 'ignore' });
     } catch {}
     await new Promise(r => setTimeout(r, 800));
-    daemonOk = await _spawnDaemon();
+    spawnResult = await _spawnDaemon();
+    daemonOk = spawnResult === 'ok';
   } else if (!daemonOk) {
     startSpin.start('Starting daemon');
-    daemonOk = await _spawnDaemon();
+    spawnResult = await _spawnDaemon();
+    daemonOk = spawnResult === 'ok';
   }
 
   startSpin.stop();
   if (!daemonOk) {
-    console.log(`  ${fmt(C.red, '✗')} Daemon failed to start. Run: 0agent start`);
+    if (spawnResult === 'no-config') {
+      console.log(`  ${fmt(C.yellow, '!')} Not configured yet. Run: ${fmt(C.bold, '0agent init')}`);
+    } else if (spawnResult === 'no-bundle') {
+      console.log(`  ${fmt(C.red, '✗')} Daemon bundle missing. Reinstall: ${fmt(C.bold, 'npm i -g 0agent@latest')}`);
+    } else {
+      const logPath = resolve(AGENT_DIR, 'logs', 'daemon.log');
+      console.log(`  ${fmt(C.red, '✗')} Daemon failed to start. Check logs: ${fmt(C.dim, logPath)}`);
+    }
     rl.prompt();
     return;
   }

package/bin/postinstall.js

@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+/**
+ * postinstall — runs automatically after `npm install -g 0agent`
+ *
+ * Ensures all runtime dependencies are installed in the package directory.
+ * This handles cases where native modules (better-sqlite3) failed to build,
+ * or where the package was installed in a non-standard way.
+ */
+
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { execSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const pkgRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
+
+// Runtime deps that must be present (matches bundle externals in scripts/bundle.mjs)
+const REQUIRED = [
+  'better-sqlite3',
+  'hono',
+  '@hono/node-server',
+  'ws',
+  'yaml',
+  'zod',
+];
+
+function depInstalled(name) {
+  // Handle scoped packages like @hono/node-server
+  const modPath = resolve(pkgRoot, 'node_modules', name);
+  return existsSync(modPath);
+}
+
+const missing = REQUIRED.filter(d => !depInstalled(d));
+
+if (missing.length === 0) {
+  // All present — check if better-sqlite3 native binary actually loads
+  try {
+    const { createRequire } = await import('node:module');
+    const req = createRequire(import.meta.url);
+    req('better-sqlite3');
+  } catch {
+    // Binary broken — try rebuild
+    try {
+      process.stdout.write('  Rebuilding better-sqlite3 for this platform…\n');
+      execSync('npm rebuild better-sqlite3', {
+        cwd: pkgRoot,
+        stdio: 'inherit',
+        timeout: 60_000,
+      });
+    } catch {
+      process.stdout.write(
+        '  ⚠  Could not rebuild better-sqlite3. Memory persistence will be disabled.\n' +
+        '     If you need it, install build tools:\n' +
+        '       macOS: xcode-select --install\n' +
+        '       Linux: sudo apt-get install build-essential python3\n'
+      );
+    }
+  }
+  process.exit(0);
+}
+
+process.stdout.write(`  Installing dependencies: ${missing.join(', ')}\n`);
+
+try {
+  execSync(
+    `npm install --omit=dev --prefix "${pkgRoot}" ${missing.join(' ')}`,
+    { stdio: 'inherit', timeout: 120_000 }
+  );
+  process.stdout.write('  ✓ Dependencies installed\n');
+} catch (err) {
+  process.stderr.write(
+    `  ✗ Failed to install some dependencies: ${err.message}\n` +
+    `  Try manually: npm install --prefix "${pkgRoot}" ${missing.join(' ')}\n`
+  );
+  // Don't exit non-zero — let the agent start anyway; daemon will log the actual error
+}

package/bin/preuninstall.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * preuninstall — runs automatically before `npm uninstall -g 0agent`
+ *
+ * Kills the daemon and ALL processes spawned by 0agent so nothing
+ * keeps running (e.g. opening Brave) after the package is removed.
+ */
+
+import { execSync } from 'node:child_process';
+import { existsSync, readFileSync, unlinkSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { homedir } from 'node:os';
+
+const AGENT_DIR = resolve(homedir(), '.0agent');
+const PID_PATH  = resolve(AGENT_DIR, 'daemon.pid');
+
+function run(cmd) {
+  try { execSync(cmd, { stdio: 'ignore', timeout: 5000 }); } catch {}
+}
+
+process.stdout.write('  Stopping 0agent daemon and background processes…\n');
+
+// 1. Kill daemon by PID file
+if (existsSync(PID_PATH)) {
+  try {
+    const pid = parseInt(readFileSync(PID_PATH, 'utf8').trim(), 10);
+    if (!isNaN(pid)) process.kill(pid, 'SIGTERM');
+  } catch {}
+  try { unlinkSync(PID_PATH); } catch {}
+}
+
+// 2. Kill by process name (catches daemons started by chat.js or other means)
+run('pkill -f "daemon.mjs" 2>/dev/null; true');
+
+// 3. Kill any GUI Python scripts still running
+run('pkill -f "0agent_gui_" 2>/dev/null; true');
+run('pkill -f "0agent-bg-" 2>/dev/null; true');
+
+// 4. Free port 4200 (last resort)
+run('lsof -ti:4200 | xargs kill -9 2>/dev/null; true');
+
+// 5. Remove any launchd plists that 0agent may have registered
+// (prevents apps from being re-launched on login)
+const launchAgentsDir = resolve(homedir(), 'Library', 'LaunchAgents');
+if (existsSync(launchAgentsDir)) {
+  try {
+    const { readdirSync } = await import('node:fs');
+    for (const f of readdirSync(launchAgentsDir)) {
+      if (f.includes('0agent') || f.includes('zeroagent')) {
+        const plistPath = resolve(launchAgentsDir, f);
+        run(`launchctl unload "${plistPath}" 2>/dev/null; true`);
+        try { unlinkSync(plistPath); } catch {}
+        process.stdout.write(`  Removed launchd plist: ${f}\n`);
+      }
+    }
+  } catch {}
+}
+
+// 6. Remove 0agent crontab entries (if any were ever added)
+run('crontab -l 2>/dev/null | grep -v "0agent" | crontab - 2>/dev/null; true');
+
+process.stdout.write('  ✓ 0agent stopped and cleaned up\n');

package/dist/daemon.mjs

@@ -2348,7 +2348,7 @@ var ShellCapability;
 var init_ShellCapability = __esm({
   "packages/daemon/src/capabilities/ShellCapability.ts"() {
     "use strict";
-    ShellCapability = class {
+    ShellCapability = class _ShellCapability {
       name = "shell_exec";
       description = "Execute shell commands in the working directory.";
       toolDefinition = {
@@ -2363,10 +2363,24 @@ var init_ShellCapability = __esm({
           required: ["command"]
         }
       };
-      async execute(input, cwd) {
+      // Commands that create persistent OS-level scheduled tasks.
+      // These must never run autonomously — they survive uninstall and can
+      // re-open apps (e.g. Brave) on every login or on a timer.
+      static PERSISTENT_TASK_PATTERN = /crontab\s+-[eilr]|launchctl\s+load|launchctl\s+bootstrap|systemctl\s+enable|at\s+\d|make\s+login\s+item|LaunchAgents|LaunchDaemons|loginitems/i;
+      async execute(input, cwd, signal) {
         let command = String(input.command ?? "");
         const timeout = Number(input.timeout_ms ?? 3e4);
         const start = Date.now();
+        if (_ShellCapability.PERSISTENT_TASK_PATTERN.test(command)) {
+          return {
+            success: false,
+            output: `Blocked: "${command.slice(0, 80)}" creates a persistent scheduled task (cron/launchd/login item). These survive uninstall and can keep launching apps autonomously. Ask the user explicitly before scheduling any persistent OS task.`,
+            duration_ms: 0
+          };
+        }
+        if (signal?.aborted) {
+          return { success: false, output: "Cancelled.", duration_ms: 0 };
+        }
         if (/&\s*$/.test(command) && !/[>|].*&\s*$/.test(command)) {
           const logFile = `/tmp/0agent-bg-${Date.now()}.log`;
           command = command.replace(/\s*&\s*$/, ` > ${logFile} 2>&1 &`);
@@ -2374,30 +2388,43 @@ var init_ShellCapability = __esm({
         return new Promise((resolve_) => {
           const chunks = [];
           let settled = false;
-          const done = (code, signal) => {
+          const done = (code, killedBySignal) => {
             if (settled) return;
             settled = true;
+            signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
             const output = chunks.join("").trim();
-            const success = code === 0 || code === null && !!signal;
+            const success = code === 0 || code === null && !!killedBySignal;
             resolve_({
               success,
-              output: output || (success ? "(no output)" : `exit ${code ?? signal}`),
+              output: output || (success ? "(no output)" : `exit ${code ?? killedBySignal}`),
               duration_ms: Date.now() - start,
-              ...!success && { error: `exit ${code ?? signal}` }
+              ...!success && { error: `exit ${code ?? killedBySignal}` }
             });
           };
           const proc = spawn2("bash", ["-c", command], {
             cwd,
             env: { ...process.env, TERM: "dumb" }
-            // DO NOT set `timeout` here — we manage it manually via timer
-            // so we can resolve on `exit` rather than waiting for `close`
           });
+          const onAbort = () => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+            if (!settled) {
+              settled = true;
+              signal?.removeEventListener("abort", onAbort);
+              clearTimeout(timer);
+              resolve_({ success: false, output: chunks.join("").trim() || "Cancelled.", duration_ms: Date.now() - start });
+            }
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
           proc.stdout.on("data", (d) => chunks.push(d.toString()));
           proc.stderr.on("data", (d) => chunks.push(d.toString()));
           proc.on("exit", (code) => done(code));
           proc.on("error", (err) => {
             settled = true;
+            signal?.removeEventListener("abort", onAbort);
             clearTimeout(timer);
             resolve_({ success: false, output: err.message, error: err.message, duration_ms: Date.now() - start });
           });
@@ -2408,6 +2435,7 @@ var init_ShellCapability = __esm({
             } catch {
             }
             settled = true;
+            signal?.removeEventListener("abort", onAbort);
             const output = chunks.join("").trim();
             resolve_({
               success: false,
@@ -2558,7 +2586,7 @@ var init_MemoryCapability = __esm({
 });
 
 // packages/daemon/src/capabilities/GUICapability.ts
-import { spawnSync as spawnSync4 } from "node:child_process";
+import { spawn as spawn3, spawnSync as spawnSync4 } from "node:child_process";
 import { writeFileSync as writeFileSync2, unlinkSync } from "node:fs";
 import { resolve as resolve3 } from "node:path";
 import { tmpdir, platform as platform2 } from "node:os";
@@ -2571,13 +2599,13 @@ var init_GUICapability = __esm({
       description = "Automate desktop GUI \u2014 click, type, screenshot, hotkeys, find text on screen.";
       toolDefinition = {
         name: "gui_automation",
-        description: 'Automate desktop GUI interactions. Take screenshots to see the current screen state, click on buttons/links/fields, type text, press keyboard shortcuts, scroll, open apps. Always start with action="screenshot" to see what is on screen before clicking.',
+        description: 'Automate desktop GUI interactions. Take screenshots to see the current screen state, click on buttons/links/fields, type text, press keyboard shortcuts, scroll, open apps. IMPORTANT: Limit screenshots to at most 3 per task \u2014 avoid re-screenshotting if you already know the layout. Prefer targeted actions (click, find_and_click, hotkey) over repeated screenshots. Use get_cursor_pos to check cursor position without a full screenshot. To open a website, ALWAYS use action="open_url" \u2014 never open_app + new tab, which creates duplicate windows.',
         input_schema: {
           type: "object",
           properties: {
             action: {
               type: "string",
-              description: '"screenshot" | "click" | "double_click" | "right_click" | "move" | "type" | "hotkey" | "scroll" | "drag" | "find_and_click" | "get_screen_size" | "open_app"'
+              description: '"screenshot" | "click" | "double_click" | "right_click" | "move" | "type" | "hotkey" | "scroll" | "drag" | "find_and_click" | "get_screen_size" | "get_cursor_pos" | "open_url" | "open_app"'
             },
             x: { type: "number", description: "X coordinate (pixels from left)" },
             y: { type: "number", description: "Y coordinate (pixels from top)" },
@@ -2588,28 +2616,67 @@ var init_GUICapability = __esm({
             direction: { type: "string", description: '"up" | "down" | "left" | "right" for scroll' },
             amount: { type: "number", description: "Scroll clicks (default 3)" },
             app: { type: "string", description: 'App name to open e.g. "Safari", "Terminal", "Chrome"' },
+            url: { type: "string", description: 'URL to open e.g. "https://example.com" (use with open_url)' },
             interval: { type: "number", description: "Seconds to wait between actions (default 0.05)" },
             duration: { type: "number", description: "Seconds for mouse movement animation (default 0.2)" }
           },
           required: ["action"]
         }
       };
-      async execute(input, _cwd) {
+      async execute(input, _cwd, signal) {
         const action = String(input.action ?? "").toLowerCase().trim();
         const start = Date.now();
         const script = this._buildScript(action, input);
         if (!script) {
-          return { success: false, output: `Unknown GUI action: "${action}". Valid: screenshot, click, double_click, right_click, move, type, hotkey, scroll, drag, find_and_click, get_screen_size, open_app`, duration_ms: 0 };
+          return { success: false, output: `Unknown GUI action: "${action}". Valid: screenshot, click, double_click, right_click, move, type, hotkey, scroll, drag, find_and_click, get_screen_size, get_cursor_pos, open_url, open_app`, duration_ms: 0 };
+        }
+        if (signal?.aborted) {
+          return { success: false, output: "Cancelled.", duration_ms: 0 };
         }
         const tmpFile = resolve3(tmpdir(), `0agent_gui_${Date.now()}.py`);
         writeFileSync2(tmpFile, script, "utf8");
-        const result = spawnSync4("python3", [tmpFile], { timeout: 3e4, encoding: "utf8" });
+        const runPy = (file) => new Promise((res) => {
+          const proc = spawn3("python3", [file], { env: process.env });
+          const out = [];
+          const err = [];
+          let settled = false;
+          const finish = (code) => {
+            if (settled) return;
+            settled = true;
+            signal?.removeEventListener("abort", onAbort);
+            clearTimeout(timer);
+            res({ stdout: out.join(""), stderr: err.join(""), code });
+          };
+          const onAbort = () => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+            finish(null);
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+          proc.stdout.on("data", (d) => out.push(d.toString()));
+          proc.stderr.on("data", (d) => err.push(d.toString()));
+          proc.on("exit", finish);
+          proc.on("error", () => finish(-1));
+          const timer = setTimeout(() => {
+            try {
+              proc.kill("SIGKILL");
+            } catch {
+            }
+            finish(null);
+          }, 3e4);
+        });
+        let result = await runPy(tmpFile);
         try {
           unlinkSync(tmpFile);
         } catch {
         }
-        if (result.status !== 0) {
-          const err = String(result.stderr ?? "").trim();
+        if (signal?.aborted) {
+          return { success: false, output: "Cancelled.", duration_ms: Date.now() - start };
+        }
+        if (result.code !== 0 && result.code !== null) {
+          const err = result.stderr.trim();
           if (err.includes("No module named") || err.includes("ModuleNotFoundError")) {
             const missing = err.includes("pyautogui") ? "pyautogui pillow pytesseract" : err.includes("PIL") ? "pillow" : err.includes("tesseract") ? "pytesseract" : "pyautogui pillow";
             const install = spawnSync4("pip3", ["install", ...missing.split(" "), "-q"], {
@@ -2619,17 +2686,15 @@ var init_GUICapability = __esm({
             if (install.status !== 0) {
               return { success: false, output: `Auto-install failed: ${install.stderr?.slice(0, 200)}. Run: pip3 install ${missing}`, duration_ms: Date.now() - start };
             }
-            const retry = spawnSync4("python3", [tmpFile], { timeout: 3e4, encoding: "utf8" });
             writeFileSync2(tmpFile, script, "utf8");
-            const retry2 = spawnSync4("python3", [tmpFile], { timeout: 3e4, encoding: "utf8" });
+            result = await runPy(tmpFile);
             try {
               unlinkSync(tmpFile);
             } catch {
             }
-            if (retry2.status === 0) {
-              return { success: true, output: retry2.stdout.trim() || "Done", duration_ms: Date.now() - start };
-            }
-            return { success: false, output: retry2.stderr?.trim() || "Unknown error after install", duration_ms: Date.now() - start };
+            if (signal?.aborted) return { success: false, output: "Cancelled.", duration_ms: Date.now() - start };
+            if (result.code === 0) return { success: true, output: result.stdout.trim() || "Done", duration_ms: Date.now() - start };
+            return { success: false, output: result.stderr.trim() || "Unknown error after install", duration_ms: Date.now() - start };
           }
           if (err.includes("accessibility") || err.includes("permission") || err.includes("AXIsProcessTrusted")) {
             return {
@@ -2652,6 +2717,7 @@ var init_GUICapability = __esm({
         const dir = input.direction != null ? String(input.direction) : "down";
         const amount = input.amount != null ? Number(input.amount) : 3;
         const app = input.app != null ? String(input.app) : "";
+        const url = input.url != null ? String(input.url) : "";
         const interval = input.interval != null ? Number(input.interval) : 0.05;
         const duration = input.duration != null ? Number(input.duration) : 0.2;
         const header = `
@@ -2666,6 +2732,11 @@ pyautogui.PAUSE = ${interval}
             return header + `
 w, h = pyautogui.size()
 print(f"Screen size: {w} x {h}")
+`;
+          case "get_cursor_pos":
+            return header + `
+x, y = pyautogui.position()
+print(f"Cursor position: ({x}, {y})")
 `;
           case "screenshot": {
             return header + `
@@ -2705,10 +2776,13 @@ try:
         print("\\n".join(hits[:40]))
 except ImportError:
     print("(pytesseract not installed \u2014 install it for OCR: pip3 install pytesseract)")
-    print(f"Screenshot saved: {shot_path}")
 except Exception as e:
     print(f"OCR failed: {e}")
-    print(f"Screenshot saved: {shot_path}")
+finally:
+    try:
+        os.remove(shot_path)
+    except Exception:
+        pass
 `;
           }
           case "click":
@@ -2790,13 +2864,107 @@ for i, word in enumerate(data['text']):
         cy = data['top'][i] + data['height'][i] // 2
         found.append((cx, cy, word))
 
-if found:
-    cx, cy, word = found[0]
-    pyautogui.click(cx, cy, duration=${duration})
-    print(f"Found '{word}' at ({cx},{cy}) \u2014 clicked")
+try:
+    if found:
+        cx, cy, word = found[0]
+        pyautogui.click(cx, cy, duration=${duration})
+        print(f"Found '{word}' at ({cx},{cy}) \u2014 clicked")
+    else:
+        print(f"Text '${safeText}' not found on screen. Take a screenshot to see current state.")
+        sys.exit(1)
+finally:
+    try:
+        os.remove(shot_path)
+    except Exception:
+        pass
+`;
+          }
+          case "open_url": {
+            if (!url) return null;
+            const safeUrl = url.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+            const osName = platform2();
+            if (osName === "darwin") {
+              return header + `
+import subprocess
+
+url = '${safeUrl}'
+
+# Check if Chrome is running
+chrome_running = subprocess.run(['pgrep', '-x', 'Google Chrome'], capture_output=True).returncode == 0
+firefox_running = subprocess.run(['pgrep', '-x', 'firefox'], capture_output=True).returncode == 0
+safari_running  = subprocess.run(['pgrep', '-x', 'Safari'], capture_output=True).returncode == 0
+
+import urllib.parse
+domain = urllib.parse.urlparse(url).netloc
+
+if chrome_running:
+    # Check if URL domain is already open in an existing tab \u2014 switch to it instead of opening new tab
+    check_script = f"""
+tell application "Google Chrome"
+  set foundTab to false
+  repeat with w in every window
+    set tabIdx to 1
+    repeat with t in every tab of w
+      if URL of t contains "{domain}" then
+        set active tab index of w to tabIdx
+        set index of w to 1
+        set foundTab to true
+        exit repeat
+      end if
+      set tabIdx to tabIdx + 1
+    end repeat
+    if foundTab then exit repeat
+  end repeat
+  if foundTab then
+    activate
+    return "switched"
+  else
+    tell front window to make new tab with properties {{URL:"{url}"}}
+    activate
+    return "new-tab"
+  end if
+end tell"""
+    r = subprocess.run(['osascript', '-e', check_script], capture_output=True, text=True)
+    if r.stdout.strip() == "switched":
+        print(f"Switched to existing Chrome tab: {url}")
+    else:
+        print(f"Opened new Chrome tab: {url}")
+elif firefox_running:
+    script = f'tell application "Firefox" to open location "{url}"'
+    subprocess.run(['osascript', '-e', script])
+    subprocess.run(['osascript', '-e', 'tell application "Firefox" to activate'])
+    print(f"Navigated Firefox to: {url}")
+elif safari_running:
+    script = f'tell application "Safari" to open location "{url}"'
+    subprocess.run(['osascript', '-e', script])
+    subprocess.run(['osascript', '-e', 'tell application "Safari" to activate'])
+    print(f"Navigated Safari to: {url}")
 else:
-    print(f"Text '${safeText}' not found on screen. Take a screenshot to see current state.")
-    sys.exit(1)
+    # No browser open \u2014 launch default browser with the URL
+    subprocess.run(['open', url])
+    print(f"Launched browser with: {url}")
+time.sleep(1.0)
+`;
+            }
+            return header + `
+import subprocess
+
+url = '${safeUrl}'
+
+# Try to reuse existing browser via wmctrl/xdotool, fall back to xdg-open
+chrome_pid = subprocess.run(['pgrep', '-x', 'chrome'], capture_output=True)
+firefox_pid = subprocess.run(['pgrep', '-x', 'firefox'], capture_output=True)
+
+if chrome_pid.returncode == 0:
+    subprocess.Popen(['google-chrome', '--new-tab', url])
+    print(f"Opened in Chrome tab: {url}")
+elif firefox_pid.returncode == 0:
+    subprocess.Popen(['firefox', '--new-tab', url])
+    print(f"Opened in Firefox tab: {url}")
+else:
+    subprocess.Popen(['xdg-open', url])
+    print(f"Opened with default browser: {url}")
+time.sleep(1.0)
 `;
           }
           case "open_app": {
@@ -2963,13 +3131,13 @@ var init_CapabilityRegistry = __esm({
       getToolDefinitions() {
         return [...this.capabilities.values()].map((c) => c.toolDefinition);
       }
-      async execute(toolName, input, cwd) {
+      async execute(toolName, input, cwd, signal) {
         const cap = this.capabilities.get(toolName);
         if (!cap) {
           return { success: false, output: `Unknown capability: ${toolName}`, duration_ms: 0 };
         }
         try {
-          return await cap.execute(input, cwd);
+          return await cap.execute(input, cwd, signal);
         } catch (err) {
           return {
             success: false,
@@ -2999,7 +3167,7 @@ var init_capabilities = __esm({
 });
 
 // packages/daemon/src/AgentExecutor.ts
-import { spawn as spawn3 } from "node:child_process";
+import { spawn as spawn4 } from "node:child_process";
 import { writeFileSync as writeFileSync3, readFileSync as readFileSync3, readdirSync as readdirSync2, mkdirSync as mkdirSync2, existsSync as existsSync3 } from "node:fs";
 import { resolve as resolve4, dirname as dirname2, relative } from "node:path";
 var SELF_MOD_PATTERN, AgentExecutor;
@@ -3009,8 +3177,8 @@ var init_AgentExecutor = __esm({
     init_capabilities();
     SELF_MOD_PATTERN = /\b(yourself|the agent|this agent|this cli|0agent|your code|your source|agent cli|improve.*agent|update.*agent|add.*to.*agent|fix.*agent|self.?improv)\b/i;
     AgentExecutor = class {
-      constructor(llm2, config, onStep, onToken) {
-        this.llm = llm2;
+      constructor(llm, config, onStep, onToken) {
+        this.llm = llm;
         this.config = config;
         this.onStep = onStep;
         this.onToken = onToken;
@@ -3025,7 +3193,7 @@ var init_AgentExecutor = __esm({
       maxCommandMs;
       registry;
       agentRoot;
-      async execute(task, systemContext) {
+      async execute(task, systemContext, signal) {
         const filesWritten = [];
         const commandsRun = [];
         let totalTokens = 0;
@@ -3041,6 +3209,10 @@ var init_AgentExecutor = __esm({
         }
         let finalOutput = "";
         for (let i = 0; i < this.maxIterations; i++) {
+          if (signal?.aborted) {
+            finalOutput = "Cancelled.";
+            break;
+          }
           this.onStep(i === 0 ? "Thinking\u2026" : "Continuing\u2026");
           let response;
           let llmFailed = false;
@@ -3056,7 +3228,8 @@ var init_AgentExecutor = __esm({
                   (token) => {
                     this.onToken(token);
                     finalOutput += token;
-                  }
+                  },
+                  signal
                 );
                 break;
               } catch (err) {
@@ -3092,7 +3265,7 @@ var init_AgentExecutor = __esm({
             this.onStep(`\u25B6 ${tc.name}(${this.summariseInput(tc.name, tc.input)})`);
             let result;
             try {
-              const capResult = await this.registry.execute(tc.name, tc.input, this.cwd);
+              const capResult = await this.registry.execute(tc.name, tc.input, this.cwd, signal);
               result = capResult.output;
               if (capResult.fallback_used) {
                 this.onStep(`  (used fallback: ${capResult.fallback_used})`);
@@ -3156,7 +3329,7 @@ var init_AgentExecutor = __esm({
       shellExec(command, timeoutMs) {
         return new Promise((resolve16) => {
           const chunks = [];
-          const proc = spawn3("bash", ["-c", command], {
+          const proc = spawn4("bash", ["-c", command], {
             cwd: this.cwd,
             env: { ...process.env, TERM: "dumb" },
             timeout: timeoutMs
@@ -3475,7 +3648,7 @@ var init_ExecutionVerifier = __esm({
 import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, existsSync as existsSync6 } from "node:fs";
 import { resolve as resolve6, dirname as dirname3 } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execSync as execSync4, spawn as spawn4 } from "node:child_process";
+import { execSync as execSync4, spawn as spawn5 } from "node:child_process";
 function isRuntimeBug(error) {
   if (TASK_FAILURE_PATTERNS.some((p) => p.test(error))) return false;
   return RUNTIME_BUG_PATTERNS.some((p) => p.test(error));
@@ -3541,8 +3714,8 @@ var init_RuntimeSelfHeal = __esm({
       // network issue
     ];
     RuntimeSelfHeal = class {
-      constructor(llm2, eventBus) {
-        this.llm = llm2;
+      constructor(llm, eventBus) {
+        this.llm = llm;
         this.eventBus = eventBus;
         let dir = dirname3(fileURLToPath(import.meta.url));
         while (dir !== "/" && !existsSync6(resolve6(dir, "package.json"))) {
@@ -3710,7 +3883,7 @@ Rules:
       restartDaemon() {
         const bundlePath = resolve6(this.projectRoot, "dist", "daemon.mjs");
         if (existsSync6(bundlePath)) {
-          const child = spawn4(process.execPath, [bundlePath], {
+          const child = spawn5(process.execPath, [bundlePath], {
             detached: true,
             stdio: "ignore",
             env: process.env
@@ -3736,8 +3909,8 @@ var init_SelfHealLoop = __esm({
     init_ExecutionVerifier();
     init_RuntimeSelfHeal();
     SelfHealLoop = class {
-      constructor(llm2, config, onStep, onToken, maxAttempts = 3, runtimeHealer) {
-        this.llm = llm2;
+      constructor(llm, config, onStep, onToken, maxAttempts = 3, runtimeHealer) {
+        this.llm = llm;
         this.config = config;
         this.onStep = onStep;
         this.onToken = onToken;
@@ -3746,17 +3919,18 @@ var init_SelfHealLoop = __esm({
         this.verifier = new ExecutionVerifier(config.cwd);
       }
       verifier;
-      async executeWithHealing(task, systemContext) {
+      async executeWithHealing(task, systemContext, signal) {
         const attempts = [];
         let currentContext = systemContext;
         let finalResult = null;
         let lastVerification = { success: true, method: "none", details: "", retryable: false, elapsed_ms: 0 };
         for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
+          if (signal?.aborted) break;
           if (attempt > 1) {
             this.onStep(`\u21BA Self-healing (attempt ${attempt}/${this.maxAttempts}): ${lastVerification.details}`);
           }
           const executor = new AgentExecutor(this.llm, this.config, this.onStep, this.onToken);
-          const result = await executor.execute(task, currentContext);
+          const result = await executor.execute(task, currentContext, signal);
           finalResult = result;
           lastVerification = await this.verifier.verify(result);
           attempts.push({ attempt_number: attempt, error_context: currentContext ?? "", result, verification: lastVerification });
@@ -4207,24 +4381,24 @@ var LLMExecutor = class {
     return { content: res.content, tokens_used: res.tokens_used, model: res.model };
   }
   // ─── Tool-calling completion with optional streaming ─────────────────────
-  async completeWithTools(messages, tools, system, onToken) {
+  async completeWithTools(messages, tools, system, onToken, signal) {
     switch (this.config.provider) {
       case "anthropic":
-        return this.anthropic(messages, tools, system, onToken);
+        return this.anthropic(messages, tools, system, onToken, signal);
       case "openai":
-        return this.openai(messages, tools, system, onToken);
+        return this.openai(messages, tools, system, onToken, void 0, signal);
       case "xai":
-        return this.openai(messages, tools, system, onToken, "https://api.x.ai/v1");
+        return this.openai(messages, tools, system, onToken, "https://api.x.ai/v1", signal);
       case "gemini":
-        return this.openai(messages, tools, system, onToken, "https://generativelanguage.googleapis.com/v1beta/openai");
+        return this.openai(messages, tools, system, onToken, "https://generativelanguage.googleapis.com/v1beta/openai", signal);
       case "ollama":
         return this.ollama(messages, system, onToken);
       default:
-        return this.openai(messages, tools, system, onToken);
+        return this.openai(messages, tools, system, onToken, void 0, signal);
     }
   }
   // ─── Anthropic ───────────────────────────────────────────────────────────
-  async anthropic(messages, tools, system, onToken) {
+  async anthropic(messages, tools, system, onToken, signal) {
     const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
     const filtered = messages.filter((m) => m.role !== "system");
     const anthropicMsgs = filtered.map((m) => {
@@ -4272,8 +4446,7 @@ var LLMExecutor = class {
         "anthropic-version": "2023-06-01"
       },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(12e4)
-      // 60s timeout
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(12e4)]) : AbortSignal.timeout(12e4)
     });
     if (!res.ok) {
       const err = await res.text();
@@ -4356,7 +4529,7 @@ var LLMExecutor = class {
     };
   }
   // ─── OpenAI (also xAI, Gemini) ───────────────────────────────────────────
-  async openai(messages, tools, system, onToken, baseUrl = "https://api.openai.com/v1") {
+  async openai(messages, tools, system, onToken, baseUrl = "https://api.openai.com/v1", signal) {
     const allMessages = [];
     const sysContent = system ?? messages.find((m) => m.role === "system")?.content;
     if (sysContent) allMessages.push({ role: "system", content: sysContent });
@@ -4397,7 +4570,7 @@ var LLMExecutor = class {
         "Authorization": `Bearer ${this.config.api_key}`
       },
       body: JSON.stringify(body),
-      signal: AbortSignal.timeout(12e4)
+      signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(12e4)]) : AbortSignal.timeout(12e4)
     });
     if (!res.ok) {
       const err = await res.text();
@@ -4816,6 +4989,7 @@ import { homedir as homedir2 } from "node:os";
 import YAML2 from "yaml";
 var SessionManager = class {
   sessions = /* @__PURE__ */ new Map();
+  abortControllers = /* @__PURE__ */ new Map();
   inferenceEngine;
   eventBus;
   graph;
@@ -4944,6 +5118,11 @@ var SessionManager = class {
     session.status = "cancelled";
     session.completed_at = Date.now();
     session.error = "cancelled";
+    const controller = this.abortControllers.get(id);
+    if (controller) {
+      controller.abort();
+      this.abortControllers.delete(id);
+    }
     this.emit({
       type: "session.failed",
       session_id: id,
@@ -5005,6 +5184,9 @@ var SessionManager = class {
    * All callers must have created the session first.
    */
   async _executeSession(sessionId, enrichedReq) {
+    const abortController = new AbortController();
+    this.abortControllers.set(sessionId, abortController);
+    const signal = abortController.signal;
     try {
       await this.startSession(sessionId);
       this.addStep(sessionId, `Extracting entities from: "${enrichedReq.task.slice(0, 60)}${enrichedReq.task.length > 60 ? "\u2026" : ""}"`);
@@ -5082,9 +5264,9 @@ Current task:`;
             (step) => this.addStep(sessionId, step),
             (token) => this.emit({ type: "session.token", session_id: sessionId, token })
           );
-          agentResult = await healLoop.executeWithHealing(enrichedReq.task, systemContext);
+          agentResult = await healLoop.executeWithHealing(enrichedReq.task, systemContext, signal);
         } catch {
-          agentResult = await executor.execute(enrichedReq.task, systemContext);
+          agentResult = await executor.execute(enrichedReq.task, systemContext, signal);
         }
         if (this.conversationStore && userEntityId) {
           const now = Date.now();
@@ -5183,6 +5365,8 @@ Current task:`;
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       this.failSession(sessionId, message);
+    } finally {
+      this.abortControllers.delete(sessionId);
     }
     return this.sessions.get(sessionId);
   }
@@ -5288,7 +5472,7 @@ Conversation:
 User: ${task.slice(0, 600)}
 Agent: ${output.slice(0, 500)}`;
     try {
-      const resp = await llm.complete(
+      const resp = await extractLLM.complete(
         [{ role: "user", content: prompt }],
         "You are a memory extraction system. Be concise. Extract only factual, durable information. Return valid JSON only."
       );
@@ -7202,7 +7386,7 @@ git checkout <commit> graph/         # restore graph files
 };
 
 // packages/daemon/src/CodespaceManager.ts
-import { execSync as execSync5, spawn as spawn5 } from "node:child_process";
+import { execSync as execSync5, spawn as spawn6 } from "node:child_process";
 var BROWSER_PORT_REMOTE = 3e3;
 var BROWSER_PORT_LOCAL = 3001;
 var DISPLAY_NAME = "0agent-browser";
@@ -7297,7 +7481,7 @@ var CodespaceManager = class {
   async openTunnel(name) {
     this.closeTunnel();
     console.log(`[Codespace] Opening tunnel port ${BROWSER_PORT_REMOTE} \u2192 localhost:${BROWSER_PORT_LOCAL}...`);
-    this.forwardProcess = spawn5(
+    this.forwardProcess = spawn6(
       "gh",
       ["codespace", "ports", "forward", `${BROWSER_PORT_REMOTE}:${BROWSER_PORT_LOCAL}`, "--codespace", name],
       { stdio: ["ignore", "ignore", "ignore"] }

package/package.json

@@ -1,26 +1,27 @@
 {
   "name": "0agent",
-  "version": "1.0.50",
+  "version": "1.0.55",
   "description": "A persistent, learning AI agent that runs on your machine. An agent that learns.",
   "private": false,
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
-    "0agent": "./bin/0agent.js",
-    "0agent-chat": "./bin/chat.js"
+    "0agent": "bin/0agent.js",
+    "0agent-chat": "bin/chat.js"
   },
   "files": [
     "bin/",
     "dist/",
     "skills/",
-    "seeds/",
-    "bin/chat.js"
+    "seeds/"
   ],
   "scripts": {
     "build": "turbo run build",
     "bundle": "node scripts/bundle.mjs",
     "test": "turbo run test",
     "lint": "turbo run lint",
+    "postinstall": "node bin/postinstall.js",
+    "preuninstall": "node bin/preuninstall.js",
     "prepublishOnly": "pnpm build --filter='!@0agent/dashboard' --filter='!@0agent/core-native' && node scripts/bundle.mjs"
   },
   "dependencies": {
@@ -53,7 +54,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/cadetmaze/0agentv1"
+    "url": "git+https://github.com/cadetmaze/0agentv1.git"
   },
   "homepage": "https://github.com/cadetmaze/0agentv1#readme",
   "packageManager": "pnpm@9.12.0"