0agent 1.0.54 → 1.0.55

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";
@@ -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
@@ -3555,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));
@@ -3790,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
@@ -7293,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";
@@ -7388,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,13 +1,13 @@
 {
   "name": "0agent",
-  "version": "1.0.54",
+  "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/",
@@ -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"