openfox 1.5.2 → 1.6.0

package/dist/agent-defaults/builder.agent.md

@@ -16,6 +16,7 @@ allowedTools:
   - call_sub_agent
   - load_skill
   - dev_server
+  - background_process
   - step_done
 ---
 

package/dist/agent-defaults/planner.agent.md

@@ -11,6 +11,7 @@ allowedTools:
   - criterion:add,get,update,remove
   - call_sub_agent
   - load_skill
+  - background_process
 ---
 
 # Plan Mode

package/dist/{auto-compaction-MNK2FZ6E.js → auto-compaction-BRT6SDEP.js}

@@ -2,16 +2,18 @@ import {
   maybeAutoCompactContext,
   performManualContextCompaction,
   resolveCompactionStatsIdentity
-} from "./chunk-GXVA5W7Q.js";
+} from "./chunk-GBBTJ6ND.js";
+import "./chunk-NBU6KIOD.js";
+import "./chunk-574HZVLE.js";
 import "./chunk-XFXOSPYH.js";
-import "./chunk-NW7PIZH3.js";
+import "./chunk-CIXMZ73F.js";
 import "./chunk-WQ4W5H6A.js";
-import "./chunk-S4QKTRGJ.js";
+import "./chunk-EBOKO2PW.js";
 import "./chunk-22CTURMH.js";
 import "./chunk-7IOZFJBW.js";
 import "./chunk-XKFPU2FA.js";
 import "./chunk-3EHGGBWE.js";
-import "./chunk-TPT6HP4H.js";
+import "./chunk-XQQ2BRJA.js";
 import "./chunk-R4HADRYO.js";
 import "./chunk-TVQOONDR.js";
 import "./chunk-PNBH3RAX.js";
@@ -20,4 +22,4 @@ export {
   performManualContextCompaction,
   resolveCompactionStatsIdentity
 };
-//# sourceMappingURL=auto-compaction-MNK2FZ6E.js.map
+//# sourceMappingURL=auto-compaction-BRT6SDEP.js.map

package/dist/{chat-handler-Y7KR2RLL.js → chat-handler-55LA4LI2.js}

@@ -1,16 +1,18 @@
-import {
-  runChatTurn
-} from "./chunk-F7PUG5WA.js";
-import "./chunk-GXVA5W7Q.js";
 import {
   generateSessionName,
   needsNameGeneration
 } from "./chunk-QDEKU5RL.js";
+import {
+  runChatTurn
+} from "./chunk-S73ATBSR.js";
+import "./chunk-GBBTJ6ND.js";
+import "./chunk-NBU6KIOD.js";
+import "./chunk-574HZVLE.js";
 import "./chunk-XFXOSPYH.js";
 import {
   getEventStore,
   updateSessionMetadata
-} from "./chunk-NW7PIZH3.js";
+} from "./chunk-CIXMZ73F.js";
 import {
   buildMessagesFromStoredEvents,
   foldPendingConfirmations
@@ -21,12 +23,12 @@ import {
   createPhaseChangedMessage,
   createSessionRunningMessage,
   createSessionStateMessage
-} from "./chunk-S4QKTRGJ.js";
+} from "./chunk-EBOKO2PW.js";
 import "./chunk-22CTURMH.js";
 import "./chunk-7IOZFJBW.js";
 import "./chunk-XKFPU2FA.js";
 import "./chunk-3EHGGBWE.js";
-import "./chunk-TPT6HP4H.js";
+import "./chunk-XQQ2BRJA.js";
 import "./chunk-R4HADRYO.js";
 import "./chunk-TVQOONDR.js";
 import {
@@ -59,7 +61,7 @@ async function startChatSession(sessionId, content, deps, options) {
   sessionManager.setRunning(sessionId, true);
   broadcastForSession(sessionId, createSessionRunningMessage(true));
   try {
-    const { maybeAutoCompactContext } = await import("./auto-compaction-MNK2FZ6E.js");
+    const { maybeAutoCompactContext } = await import("./auto-compaction-BRT6SDEP.js");
     await maybeAutoCompactContext({
       sessionManager,
       sessionId,
@@ -198,4 +200,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-Y7KR2RLL.js.map
+//# sourceMappingURL=chat-handler-55LA4LI2.js.map

package/dist/chunk-574HZVLE.js

@@ -0,0 +1,149 @@
+// src/server/tools/background-process/store.ts
+var MAX_PER_SESSION = 5;
+var processesBySession = /* @__PURE__ */ new Map();
+var logsByProcess = /* @__PURE__ */ new Map();
+function getMaxPerSession() {
+  return MAX_PER_SESSION;
+}
+function getProcess(processId, sessionId) {
+  return processesBySession.get(sessionId)?.get(processId);
+}
+function getSessionProcesses(sessionId) {
+  const sessionProcesses = processesBySession.get(sessionId);
+  if (!sessionProcesses) return [];
+  return Array.from(sessionProcesses.values());
+}
+function getSessionProcessCount(sessionId) {
+  return getSessionProcesses(sessionId).filter((p) => p.status !== "exited").length;
+}
+function createProcess(sessionId, name, command, cwd) {
+  const count = getSessionProcessCount(sessionId);
+  if (count >= MAX_PER_SESSION) {
+    return null;
+  }
+  const process2 = {
+    id: crypto.randomUUID(),
+    sessionId,
+    name,
+    command,
+    cwd,
+    pid: null,
+    status: "pending",
+    exitCode: null,
+    createdAt: Date.now(),
+    startedAt: null,
+    endedAt: null
+  };
+  if (!processesBySession.has(sessionId)) {
+    processesBySession.set(sessionId, /* @__PURE__ */ new Map());
+  }
+  processesBySession.get(sessionId).set(process2.id, process2);
+  logsByProcess.set(process2.id, []);
+  return process2;
+}
+function startProcess(processId, sessionId, pid) {
+  const process2 = getProcess(processId, sessionId);
+  if (!process2) return void 0;
+  process2.pid = pid;
+  process2.status = "running";
+  process2.startedAt = Date.now();
+  return process2;
+}
+function updateStatus(processId, sessionId, status, exitCode) {
+  const process2 = getProcess(processId, sessionId);
+  if (!process2) return void 0;
+  process2.status = status;
+  if (exitCode !== void 0) {
+    process2.exitCode = exitCode;
+  }
+  if (status === "exited" || status === "stopping") {
+    process2.endedAt = Date.now();
+  }
+  return process2;
+}
+function removeProcess(processId, sessionId) {
+  const sessionProcesses = processesBySession.get(sessionId);
+  if (!sessionProcesses) return false;
+  const deleted = sessionProcesses.delete(processId);
+  logsByProcess.delete(processId);
+  return deleted;
+}
+function appendLog(processId, content, stream = "stdout") {
+  const logs = logsByProcess.get(processId);
+  if (!logs) return;
+  const offset = logs.length;
+  logs.push({
+    offset,
+    content,
+    timestamp: Date.now(),
+    stream
+  });
+}
+function getLogs(processId, offset = 0, limit) {
+  const logs = logsByProcess.get(processId) ?? [];
+  const start = Math.min(offset, logs.length);
+  const end = limit !== void 0 ? Math.min(start + limit, logs.length) : logs.length;
+  return logs.slice(start, end);
+}
+function getLogsPaginated(processId, since = 0, maxLines = 500) {
+  const logs = logsByProcess.get(processId) ?? [];
+  const totalLines = logs.length;
+  const filteredLogs = logs.filter((_, index) => index >= since);
+  const slicedLogs = filteredLogs.slice(0, maxLines);
+  const lastLine = slicedLogs[slicedLogs.length - 1];
+  const nextOffset = lastLine ? lastLine.offset + 1 : totalLines;
+  const hasMore = slicedLogs.length < filteredLogs.length;
+  return {
+    lines: slicedLogs,
+    totalLines,
+    nextOffset,
+    hasMore
+  };
+}
+function clearLogs(processId) {
+  logsByProcess.delete(processId);
+  logsByProcess.set(processId, []);
+}
+function getProcessById(processId) {
+  for (const sessionProcesses of processesBySession.values()) {
+    const proc = sessionProcesses.get(processId);
+    if (proc) return proc;
+  }
+  return void 0;
+}
+function cleanupAllProcesses() {
+  for (const sessionProcesses of processesBySession.values()) {
+    for (const proc of sessionProcesses.values()) {
+      if (proc.status === "running" && proc.pid) {
+        try {
+          process.kill(-proc.pid, "SIGTERM");
+        } catch {
+          try {
+            process.kill(proc.pid, "SIGTERM");
+          } catch (_) {
+          }
+        }
+      }
+    }
+  }
+  processesBySession.clear();
+  logsByProcess.clear();
+}
+
+export {
+  getMaxPerSession,
+  getProcess,
+  getSessionProcesses,
+  getSessionProcessCount,
+  createProcess,
+  startProcess,
+  updateStatus,
+  removeProcess,
+  appendLog,
+  getLogs,
+  getLogsPaginated,
+  clearLogs,
+  getProcessById,
+  cleanupAllProcesses
+};
+//# sourceMappingURL=chunk-574HZVLE.js.map

package/dist/{chunk-NW7PIZH3.js → chunk-CIXMZ73F.js}

@@ -18,6 +18,8 @@ import {
 var EventStore = class {
   db;
   subscribers = /* @__PURE__ */ new Map();
+  globalSubscribers = /* @__PURE__ */ new Map();
+  globalSubscriberIdCounter = 0;
   constructor(db) {
     this.db = db;
     this.initSchema();
@@ -239,13 +241,82 @@ var EventStore = class {
   }
   notifySubscribers(sessionId, event) {
     const sessionSubs = this.subscribers.get(sessionId);
-    if (!sessionSubs) return;
-    for (const subscriber of sessionSubs) {
+    if (sessionSubs) {
+      for (const subscriber of sessionSubs) {
+        if (!subscriber.closed) {
+          subscriber.callback(event);
+        }
+      }
+    }
+    for (const subscriber of this.globalSubscribers.values()) {
       if (!subscriber.closed) {
         subscriber.callback(event);
       }
     }
   }
+  /**
+   * Subscribe to ALL events across ALL sessions.
+   * Unlike subscribe() which is session-specific, this receives every event.
+   * Used by WebSocket clients to receive real-time updates for all sessions.
+   *
+   * Returns an async iterator that yields events and an unsubscribe function
+   */
+  subscribeAll() {
+    const queue = [];
+    let resolveNext = null;
+    let closed = false;
+    const closeIterator = () => {
+      closed = true;
+      if (resolveNext) {
+        resolveNext({ value: void 0, done: true });
+        resolveNext = null;
+      }
+    };
+    const wsId = ++this.globalSubscriberIdCounter;
+    const subscriber = {
+      wsId,
+      callback: (event) => {
+        if (closed) return;
+        if (resolveNext) {
+          resolveNext({ value: event, done: false });
+          resolveNext = null;
+        } else {
+          queue.push(event);
+        }
+      },
+      close: closeIterator,
+      closed: false
+    };
+    this.globalSubscribers.set(wsId, subscriber);
+    const iterator = {
+      [Symbol.asyncIterator]() {
+        return this;
+      },
+      async next() {
+        if (closed) {
+          return { value: void 0, done: true };
+        }
+        const queued = queue.shift();
+        if (queued) {
+          return { value: queued, done: false };
+        }
+        return new Promise((resolve) => {
+          resolveNext = resolve;
+        });
+      },
+      async return() {
+        closed = true;
+        subscriber.closed = true;
+        return { value: void 0, done: true };
+      }
+    };
+    const unsubscribe = () => {
+      subscriber.closed = true;
+      closeIterator();
+      this.globalSubscribers.delete(wsId);
+    };
+    return { iterator, unsubscribe };
+  }
   // --------------------------------------------------------------------------
   // Cleanup
   // --------------------------------------------------------------------------
@@ -506,6 +577,13 @@ function updateSessionDangerLevel(id, dangerLevel) {
     UPDATE sessions SET danger_level = ?, updated_at = ? WHERE id = ?
   `).run(dangerLevel, now, id);
 }
+function updateSessionRunning(id, isRunning) {
+  const db = getDatabase();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  db.prepare(`
+    UPDATE sessions SET is_running = ?, updated_at = ? WHERE id = ?
+  `).run(isRunning ? 1 : 0, now, id);
+}
 function updateSessionSummary(id, summary) {
   const db = getDatabase();
   const now = (/* @__PURE__ */ new Date()).toISOString();
@@ -1027,6 +1105,7 @@ export {
   getSession,
   updateSessionProvider,
   updateSessionDangerLevel,
+  updateSessionRunning,
   updateSessionSummary,
   updateSessionMetadata,
   listSessions,
@@ -1064,4 +1143,4 @@ export {
   compactContext,
   getRecentUserPromptsForSession
 };
-//# sourceMappingURL=chunk-NW7PIZH3.js.map
+//# sourceMappingURL=chunk-CIXMZ73F.js.map

package/dist/{chunk-S4QKTRGJ.js → chunk-EBOKO2PW.js}

@@ -1,7 +1,7 @@
 import {
   createServerMessage,
   isClientMessage
-} from "./chunk-TPT6HP4H.js";
+} from "./chunk-XQQ2BRJA.js";
 
 // src/server/ws/protocol.ts
 function enrichMessagesWithToolResults(messages) {
@@ -340,4 +340,4 @@ export {
   isQueueCancelPayload,
   storedEventToServerMessage
 };
-//# sourceMappingURL=chunk-S4QKTRGJ.js.map
+//# sourceMappingURL=chunk-EBOKO2PW.js.map

package/dist/{chunk-GXVA5W7Q.js → chunk-GBBTJ6ND.js}

@@ -1,3 +1,16 @@
+import {
+  createProcess,
+  getPlatformShell,
+  getProcessLogs,
+  getProcessStatus,
+  getSessionProcesses,
+  startProcessCommand,
+  stopProcess
+} from "./chunk-NBU6KIOD.js";
+import {
+  getMaxPerSession,
+  getSessionProcessCount
+} from "./chunk-574HZVLE.js";
 import {
   streamWithSegments
 } from "./chunk-XFXOSPYH.js";
@@ -5,14 +18,14 @@ import {
   getContextMessages,
   getCurrentContextWindowId,
   getEventStore
-} from "./chunk-NW7PIZH3.js";
+} from "./chunk-CIXMZ73F.js";
 import {
   createChatMessageMessage,
   createChatPathConfirmationMessage,
   createChatToolOutputMessage,
   createChatVisionFallbackMessage,
   createQueueStateMessage
-} from "./chunk-S4QKTRGJ.js";
+} from "./chunk-EBOKO2PW.js";
 import {
   AskUserInterrupt,
   askUserTool
@@ -1121,8 +1134,8 @@ import { resolve as resolve2, isAbsolute } from "path";
 
 // src/server/tools/path-security.ts
 import { realpath } from "fs/promises";
-import { resolve, normalize, join as join3 } from "path";
-import { homedir } from "os";
+import { resolve, normalize, join as join3, basename, sep } from "path";
+import { homedir, tmpdir } from "os";
 var SAFE_PATHS = /* @__PURE__ */ new Set([
   "/dev/null",
   "/dev/zero",
@@ -1135,7 +1148,11 @@ var SAFE_PATHS = /* @__PURE__ */ new Set([
   "/dev/fd/1",
   "/dev/fd/2"
 ]);
-var ALLOWED_ROOTS = ["/tmp", "/var/tmp"];
+var ALLOWED_ROOTS = [
+  "/tmp",
+  "/var/tmp",
+  tmpdir()
+];
 var SENSITIVE_FILE_PATTERNS = [
   // Dotenv files (but not .envrc, .env-example, .env.example)
   /^\.env$/,
@@ -1156,9 +1173,9 @@ var SENSITIVE_FILE_PATTERNS = [
   /^\.netrc$/
 ];
 function isSensitivePath(path) {
-  const basename = path.split("/").pop() ?? "";
-  if (!basename) return false;
-  return SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(basename));
+  const fileName = basename(path);
+  if (!fileName) return false;
+  return SENSITIVE_FILE_PATTERNS.some((pattern) => pattern.test(fileName));
 }
 var sessionAllowedPaths = /* @__PURE__ */ new Map();
 function addAllowedPath(sessionId, path) {
@@ -1200,12 +1217,12 @@ async function isPathWithinSandbox(path, workdir, sessionId) {
     }
   }
   resolvedPath = resolvedPath.replace(/\/+$/, "");
-  if (resolvedPath === normalizedWorkdir || resolvedPath.startsWith(normalizedWorkdir + "/")) {
+  if (resolvedPath === normalizedWorkdir || resolvedPath.startsWith(normalizedWorkdir + sep)) {
     return { allowed: true, resolvedPath };
   }
   for (const root of ALLOWED_ROOTS) {
     const normalizedRoot = normalize(root);
-    if (resolvedPath === normalizedRoot || resolvedPath.startsWith(normalizedRoot + "/")) {
+    if (resolvedPath === normalizedRoot || resolvedPath.startsWith(normalizedRoot + sep)) {
       return { allowed: true, resolvedPath };
     }
   }
@@ -2111,7 +2128,8 @@ function executeCommand(command, cwd, timeout, signal, onProgress) {
       reject(new Error("Command aborted before execution"));
       return;
     }
-    const proc = spawn2("sh", ["-c", command], {
+    const shell = getPlatformShell();
+    const proc = spawn2(shell.command, [...shell.args, command], {
       cwd,
       env: { ...process.env, FORCE_COLOR: "0" },
       stdio: ["ignore", "pipe", "pipe"],
@@ -3607,7 +3625,7 @@ var callSubAgentTool = {
       };
     }
     try {
-      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-MY4TPRP4.js");
+      const { getToolRegistryForAgent: getToolRegistryForAgent2 } = await import("./tools-GQ3PJL6N.js");
       const toolRegistry = getToolRegistryForAgent2(agentDef);
       const turnMetrics = new TurnMetrics();
       const result = await executeSubAgent({
@@ -3954,7 +3972,8 @@ var DevServerManager = class {
     instance.errorMessage = void 0;
     instance.exited = false;
     const resolved = this.resolveWorkdir(workdir);
-    const proc = spawn3("sh", ["-c", config.command], {
+    const shell = getPlatformShell();
+    const proc = spawn3(shell.command, [...shell.args, config.command], {
       cwd: resolved,
       env: { ...process.env, FORCE_COLOR: "1" },
       stdio: ["ignore", "pipe", "pipe"],
@@ -4181,6 +4200,154 @@ var stepDoneTool = {
   }
 };
 
+// src/server/tools/background-process/index.ts
+var backgroundProcessTool = createTool(
+  "background_process",
+  {
+    type: "function",
+    function: {
+      name: "background_process",
+      description: `Start, stop, and monitor long-running background processes.
+
+These processes run independently of agent turns and persist across session compaction. Processes are displayed in the right sidebar where you can view their logs and status.
+
+**Actions:**
+- start: Launch a new background process (provide: name, command, cwd, timeout)
+- stop: Stop a running process and remove it from the sidebar
+- list: Show all processes for this session
+- status: Get detailed status of a specific process
+- logs: Retrieve process output with optional pagination`,
+      parameters: {
+        type: "object",
+        properties: {
+          action: {
+            type: "string",
+            enum: ["start", "stop", "list", "status", "logs"],
+            description: "The action to perform on background processes"
+          },
+          name: {
+            type: "string",
+            description: "Display name for the process. Auto-generated from command if not provided."
+          },
+          command: {
+            type: "string",
+            description: 'Shell command to execute. Required for "start" action.'
+          },
+          cwd: {
+            type: "string",
+            description: "Working directory. Defaults to session workdir."
+          },
+          timeout: {
+            type: "number",
+            description: "Maximum runtime in milliseconds. Process will be terminated after this duration."
+          },
+          processId: {
+            type: "string",
+            description: "Process ID. Required for stop, status, and logs actions."
+          },
+          since: {
+            type: "number",
+            description: "Return logs after this offset. Default: 0"
+          },
+          maxLines: {
+            type: "number",
+            description: "Maximum lines to return. Default: 500, max: 2000"
+          }
+        },
+        required: ["action"],
+        dependentRequired: {
+          start: ["command"],
+          stop: ["processId"],
+          status: ["processId"],
+          logs: ["processId"]
+        }
+      }
+    }
+  },
+  async (args, context, helpers) => {
+    const sessionId = context.sessionId;
+    const cwd = args.cwd ?? context.workdir;
+    switch (args.action) {
+      case "start": {
+        const count = getSessionProcessCount(sessionId);
+        const maxPerSession = getMaxPerSession();
+        if (count >= maxPerSession) {
+          return helpers.error(`Maximum number of background processes (${maxPerSession}) reached. Stop existing processes before starting new ones.`);
+        }
+        const name = args.name ?? args.command?.split(" ")[0] ?? "process";
+        const process2 = createProcess(sessionId, name, args.command, cwd, args.timeout);
+        if (!process2) {
+          return helpers.error(`Failed to create process. Maximum limit may have been reached.`);
+        }
+        const pid = startProcessCommand(process2.id, sessionId, args.command, cwd);
+        if (!pid) {
+          return helpers.error(`Failed to start process.`);
+        }
+        return helpers.success(JSON.stringify({
+          processId: process2.id,
+          name: process2.name,
+          pid,
+          status: "running",
+          maxReached: count + 1 >= maxPerSession
+        }, null, 2));
+      }
+      case "stop": {
+        const proc = getProcessStatus(args.processId, sessionId);
+        if (!proc) {
+          return helpers.error(`Process not found: ${args.processId}`);
+        }
+        if (proc.status !== "running") {
+          return helpers.error(`Process is not running (status: ${proc.status}). Cannot stop.`);
+        }
+        await stopProcess(args.processId, sessionId);
+        return helpers.success(JSON.stringify({
+          processId: args.processId,
+          status: "removed"
+        }, null, 2));
+      }
+      case "list": {
+        const processes = getSessionProcesses(sessionId);
+        const maxPerSession = getMaxPerSession();
+        return helpers.success(JSON.stringify({
+          processes,
+          maxPerSession,
+          currentCount: processes.filter((p) => p.status !== "exited").length
+        }, null, 2));
+      }
+      case "status": {
+        const proc = getProcessStatus(args.processId, sessionId);
+        if (!proc) {
+          return helpers.error(`Process not found: ${args.processId}`);
+        }
+        const uptime = proc.startedAt ? Date.now() - proc.startedAt : null;
+        return helpers.success(JSON.stringify({
+          process: proc,
+          uptime
+        }, null, 2));
+      }
+      case "logs": {
+        const proc = getProcessStatus(args.processId, sessionId);
+        if (!proc) {
+          return helpers.error(`Process not found: ${args.processId}`);
+        }
+        const since = args.since ?? 0;
+        const maxLines = Math.min(args.maxLines ?? 500, 2e3);
+        const { lines, totalLines, nextOffset, hasMore } = getProcessLogs(args.processId, since, maxLines);
+        return helpers.success(JSON.stringify({
+          processId: args.processId,
+          lines,
+          totalLines,
+          nextOffset,
+          hasMore,
+          truncated: hasMore
+        }, null, 2));
+      }
+      default:
+        return helpers.error(`Unknown action: ${args.action}`);
+    }
+  }
+);
+
 // src/server/tools/index.ts
 function parseToolPermissions(allowedTools) {
   const result = {};
@@ -4315,7 +4482,8 @@ function getAllToolsMap() {
       returnValueTool,
       webFetchTool,
       devServerTool,
-      stepDoneTool
+      stepDoneTool,
+      backgroundProcessTool
     ].map((t) => [t.name, t])
   ]);
 }
@@ -4590,4 +4758,4 @@ export {
   getToolRegistryForAgent,
   createToolRegistry
 };
-//# sourceMappingURL=chunk-GXVA5W7Q.js.map
+//# sourceMappingURL=chunk-GBBTJ6ND.js.map