0agent 1.0.54 → 1.0.56

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();
   }

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,7 +2599,7 @@ 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. 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.',
+        description: "Desktop GUI automation \u2014 ONLY use for tasks that explicitly require controlling the screen. DO NOT use for coding, research, file edits, or any task that does not need the desktop UI. Actions: click, type, hotkey, scroll, find_and_click, open_url, open_app. screenshot: use sparingly \u2014 only when you cannot proceed without seeing the current screen. Max 2 per task. To open a website use open_url (reuses existing browser tab, never opens duplicate windows).",
         input_schema: {
           type: "object",
           properties: {
@@ -2595,22 +2623,60 @@ var init_GUICapability = __esm({
           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, 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"], {
@@ -2620,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 {
@@ -2830,12 +2894,41 @@ chrome_running = subprocess.run(['pgrep', '-x', 'Google Chrome'], capture_output
 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:
-    # Open in existing Chrome window \u2014 no new window created
-    script = f'tell application "Google Chrome" to open location "{url}"'
-    subprocess.run(['osascript', '-e', script])
-    subprocess.run(['osascript', '-e', 'tell application "Google Chrome" to activate'])
-    print(f"Navigated Chrome to: {url}")
+    # 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])
@@ -3038,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,
@@ -3074,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;
@@ -3172,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})`);
@@ -3236,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
@@ -3404,12 +3497,14 @@ content = element.text if element else page.get_all_text()` : `content = page.ge
           `- Use relative paths from the working directory`,
           `- Be concise in your final response: state what was done and where to find it`,
           ``,
-          `GUI Automation (gui_automation tool):`,
-          `- ALWAYS call gui_automation({action:"screenshot"}) first to see what is on screen`,
-          `- Use the OCR output to find element coordinates before clicking`,
-          `- After clicking or typing, take another screenshot to confirm the result`,
+          `GUI Automation (gui_automation tool) \u2014 ONLY use when the task explicitly requires controlling the desktop UI:`,
+          `- DO NOT take screenshots for general tasks, coding, research, or anything that doesn't need the screen`,
+          `- Only screenshot when you genuinely cannot proceed without seeing the current screen state`,
+          `- Prefer find_and_click, hotkey, open_url, and type over repeated screenshots`,
+          `- Max 2 screenshots per task \u2014 if you've already seen the screen, act on that knowledge`,
           `- Use find_and_click to click on text by name rather than guessing coordinates`,
           `- Use hotkey for keyboard shortcuts: "cmd+c", "ctrl+v", "alt+tab", "cmd+space"`,
+          `- To open a website: use open_url \u2014 it reuses the existing browser tab`,
           ...hasMemory ? [
             ``,
             `Memory (CRITICAL \u2014 write EVERYTHING you learn):`,
@@ -3555,7 +3650,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));
@@ -3790,7 +3885,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
@@ -7293,7 +7388,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";
@@ -7388,7 +7483,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,13 +1,13 @@
 {
   "name": "0agent",
-  "version": "1.0.54",
+  "version": "1.0.56",
   "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/",
@@ -21,6 +21,7 @@
     "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"