openfox 1.5.2 → 1.5.3

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-DDQPVS7Z.js}

@@ -2,16 +2,18 @@ import {
   maybeAutoCompactContext,
   performManualContextCompaction,
   resolveCompactionStatsIdentity
-} from "./chunk-GXVA5W7Q.js";
+} from "./chunk-QJIHXG4P.js";
+import "./chunk-JHL5ZO3K.js";
+import "./chunk-574HZVLE.js";
 import "./chunk-XFXOSPYH.js";
 import "./chunk-NW7PIZH3.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-DDQPVS7Z.js.map

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

@@ -1,11 +1,13 @@
-import {
-  runChatTurn
-} from "./chunk-F7PUG5WA.js";
-import "./chunk-GXVA5W7Q.js";
 import {
   generateSessionName,
   needsNameGeneration
 } from "./chunk-QDEKU5RL.js";
+import {
+  runChatTurn
+} from "./chunk-TWUJFSH6.js";
+import "./chunk-QJIHXG4P.js";
+import "./chunk-JHL5ZO3K.js";
+import "./chunk-574HZVLE.js";
 import "./chunk-XFXOSPYH.js";
 import {
   getEventStore,
@@ -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-DDQPVS7Z.js");
     await maybeAutoCompactContext({
       sessionManager,
       sessionId,
@@ -198,4 +200,4 @@ export {
   startChatSession,
   stopSessionExecution
 };
-//# sourceMappingURL=chat-handler-Y7KR2RLL.js.map
+//# sourceMappingURL=chat-handler-S3LRWAEV.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-UBWZDTZ4.js → chunk-AL7KUHBF.js}

@@ -1,8 +1,12 @@
+import {
+  generateSessionName,
+  needsNameGeneration
+} from "./chunk-QDEKU5RL.js";
 import {
   createVerifierNudgeConfig,
   runBuilderTurn,
   runChatTurn
-} from "./chunk-F7PUG5WA.js";
+} from "./chunk-TWUJFSH6.js";
 import {
   TurnMetrics,
   agentExists,
@@ -40,11 +44,10 @@ import {
   saveSkill,
   setSkillEnabled,
   skillExists
-} from "./chunk-GXVA5W7Q.js";
+} from "./chunk-QJIHXG4P.js";
 import {
-  generateSessionName,
-  needsNameGeneration
-} from "./chunk-QDEKU5RL.js";
+  onProcessEvent
+} from "./chunk-JHL5ZO3K.js";
 import {
   createProviderManager,
   parseDefaultModelSelection
@@ -103,7 +106,7 @@ import {
   parseClientMessage,
   serializeServerMessage,
   storedEventToServerMessage
-} from "./chunk-S4QKTRGJ.js";
+} from "./chunk-EBOKO2PW.js";
 import {
   EventEmitter,
   cancelQuestionsForSession,
@@ -120,7 +123,7 @@ import {
 } from "./chunk-QY7BMXWT.js";
 import {
   createServerMessage
-} from "./chunk-TPT6HP4H.js";
+} from "./chunk-XQQ2BRJA.js";
 import {
   getGlobalConfigDir
 } from "./chunk-R4HADRYO.js";
@@ -2488,6 +2491,17 @@ function createWebSocketServer(httpServer, config, getLLMClient, getActiveProvid
       errorMessage
     }));
   });
+  onProcessEvent((_processId, msg) => {
+    const sessionId = msg.sessionId;
+    if (!sessionId) return;
+    for (const [clientWs, client] of clients) {
+      if (client.activeSessionId === sessionId || client.subscribedSessions.has(sessionId) || client.eventStoreSubscriptions.has(sessionId)) {
+        if (clientWs.readyState === WebSocket2.OPEN) {
+          clientWs.send(serializeServerMessage(msg));
+        }
+      }
+    }
+  });
   wss.on("connection", async (ws, req) => {
     const url = new URL(req.url || "/", `http://${req.headers.host}`);
     const token = url.searchParams.get("token");
@@ -5853,14 +5867,14 @@ async function createServerHandle(config) {
     if (!callId || approved === void 0) {
       return res.status(400).json({ error: "callId and approved are required" });
     }
-    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-MY4TPRP4.js");
+    const { providePathConfirmation: providePathConfirmation2 } = await import("./tools-XSK3J4II.js");
     const result = providePathConfirmation2(callId, approved, alwaysAllow);
     if (!result.found) {
       return res.status(404).json({ error: "No pending path confirmation with that ID" });
     }
     const { getEventStore: getEventStore2 } = await import("./events-B7S4U4DB.js");
     const { buildMessagesFromStoredEvents: buildMessagesFromStoredEvents2, foldPendingConfirmations: foldPendingConfirmations2 } = await import("./folding-NZYOXNKK.js");
-    const { createSessionStateMessage: createSessionStateMessage2 } = await import("./protocol-WQENDK72.js");
+    const { createSessionStateMessage: createSessionStateMessage2 } = await import("./protocol-ODKD7QJO.js");
     const eventStore = getEventStore2();
     const events = eventStore.getEvents(sessionId);
     const messages = buildMessagesFromStoredEvents2(events);
@@ -5878,7 +5892,7 @@ async function createServerHandle(config) {
     if (!callId || !answer) {
       return res.status(400).json({ error: "callId and answer are required" });
     }
-    const { provideAnswer: provideAnswer2 } = await import("./tools-MY4TPRP4.js");
+    const { provideAnswer: provideAnswer2 } = await import("./tools-XSK3J4II.js");
     const found = provideAnswer2(callId, answer);
     if (!found) {
       return res.status(404).json({ error: "No pending question with that ID" });
@@ -5914,8 +5928,8 @@ async function createServerHandle(config) {
     if (!session) {
       return res.status(404).json({ error: "Session not found" });
     }
-    const { stopSessionExecution } = await import("./chat-handler-Y7KR2RLL.js");
-    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-MY4TPRP4.js");
+    const { stopSessionExecution } = await import("./chat-handler-S3LRWAEV.js");
+    const { cancelQuestionsForSession: cancelQuestionsForSession2, cancelPathConfirmationsForSession: cancelPathConfirmationsForSession2 } = await import("./tools-XSK3J4II.js");
     stopSessionExecution(sessionId, sessionManager);
     abortSession(sessionId);
     cancelQuestionsForSession2(sessionId, "Session stopped by user");
@@ -6201,6 +6215,27 @@ async function createServerHandle(config) {
   app.use("/api/workflows", createWorkflowRoutes(configDir, config));
   app.use("/api/dev-server", createDevServerRoutes());
   app.use("/api/terminals", createTerminalRoutes());
+  app.get("/api/sessions/:id/background-processes", async (req, res) => {
+    const { getSessionProcesses } = await import("./manager-TMIDRUVA.js");
+    const sessionId = req.params.id;
+    const processes = getSessionProcesses(sessionId);
+    res.json({ processes });
+  });
+  app.post("/api/sessions/:id/background-process/:processId/stop", async (req, res) => {
+    const { stopProcess } = await import("./manager-TMIDRUVA.js");
+    const sessionId = req.params.id;
+    const processId = req.params.processId;
+    const session = sessionManager.getSession(sessionId);
+    if (!session) {
+      return res.status(404).json({ error: "Session not found" });
+    }
+    try {
+      await stopProcess(processId, sessionId);
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ error: err instanceof Error ? err.message : "Failed to stop process" });
+    }
+  });
   const { getCurrentBranch } = await import("./branch.api-XADFZZAA.js");
   app.get("/api/branch", async (req, res) => {
     await getCurrentBranch(req, res);
@@ -6341,7 +6376,7 @@ async function createServerHandle(config) {
     providerManager
   );
   const wss = wssExports.wss;
-  const { QueueProcessor } = await import("./processor-BFTXIEDV.js");
+  const { QueueProcessor } = await import("./processor-HYEPZECF.js");
   const queueProcessor = new QueueProcessor({
     sessionManager,
     providerManager,
@@ -6379,6 +6414,8 @@ async function createServerHandle(config) {
       logger.info("Shutting down...");
       void (async () => {
         await devServerManager.stopAll();
+        const { cleanupAllProcesses } = await import("./store-2IF3ZSLD.js");
+        cleanupAllProcesses();
         viteServer?.close();
         for (const client of wss.clients) {
           client.terminate();
@@ -6411,4 +6448,4 @@ export {
   createServerHandle,
   createServer
 };
-//# sourceMappingURL=chunk-UBWZDTZ4.js.map
+//# sourceMappingURL=chunk-AL7KUHBF.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-JHL5ZO3K.js

@@ -0,0 +1,156 @@
+import {
+  appendLog,
+  createProcess,
+  getLogsPaginated,
+  getProcess,
+  getSessionProcesses,
+  removeProcess,
+  startProcess,
+  updateStatus
+} from "./chunk-574HZVLE.js";
+
+// src/server/tools/background-process/manager.ts
+import { spawn } from "child_process";
+var STOP_SIGNAL_TIMEOUT = 5e3;
+var listeners = /* @__PURE__ */ new Set();
+function onProcessEvent(callback) {
+  listeners.add(callback);
+  return () => {
+    listeners.delete(callback);
+  };
+}
+function emitProcessEvent(processId, msg) {
+  for (const listener of listeners) {
+    listener(processId, msg);
+  }
+}
+function createProcess2(sessionId, name, command, cwd, timeout) {
+  const process2 = createProcess(sessionId, name, command, cwd);
+  if (!process2) return null;
+  if (timeout && timeout > 0) {
+    setTimeout(() => {
+      const p = getProcess(process2.id, sessionId);
+      if (p && p.status === "running") {
+        stopProcess(process2.id, sessionId);
+      }
+    }, timeout);
+  }
+  return process2;
+}
+function startProcessCommand(processId, sessionId, command, cwd) {
+  const proc = startProcess(processId, sessionId, 0);
+  if (!proc) return null;
+  const child = spawn("sh", ["-c", command], {
+    cwd,
+    env: { ...process.env, FORCE_COLOR: "1" },
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: true
+  });
+  proc.pid = child.pid ?? null;
+  updateStatus(processId, sessionId, "running");
+  emitProcessEvent(processId, {
+    type: "backgroundProcess.started",
+    payload: { processId, name: proc.name, pid: child.pid ?? null, status: "running" },
+    sessionId
+  });
+  child.stdout?.on("data", (chunk) => {
+    const text = chunk.toString();
+    appendLog(processId, text, "stdout");
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.output",
+      payload: { processId, stream: "stdout", content: text },
+      sessionId
+    });
+  });
+  child.stderr?.on("data", (chunk) => {
+    const text = chunk.toString();
+    appendLog(processId, text, "stderr");
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.output",
+      payload: { processId, stream: "stderr", content: text },
+      sessionId
+    });
+  });
+  child.on("exit", (code, signal) => {
+    updateStatus(processId, sessionId, "exited", code ?? (signal ? 1 : null));
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.exited",
+      payload: { processId, exitCode: code ?? (signal ? 1 : null) },
+      sessionId
+    });
+  });
+  child.on("error", (err) => {
+    appendLog(processId, `Error: ${err.message}
+`, "stderr");
+    updateStatus(processId, sessionId, "exited", 1);
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.exited",
+      payload: { processId, exitCode: 1 },
+      sessionId
+    });
+  });
+  return child.pid ?? null;
+}
+async function stopProcess(processId, sessionId) {
+  const proc = getProcess(processId, sessionId);
+  if (!proc || proc.status !== "running" || !proc.pid) {
+    return;
+  }
+  updateStatus(processId, sessionId, "stopping");
+  const pid = proc.pid;
+  try {
+    try {
+      process.kill(-pid, "SIGTERM");
+    } catch {
+      process.kill(pid, "SIGTERM");
+    }
+    await new Promise((resolve) => {
+      setTimeout(() => {
+        try {
+          process.kill(-pid, "SIGKILL");
+        } catch {
+          try {
+            process.kill(pid, "SIGKILL");
+          } catch (_) {
+          }
+        }
+        resolve();
+      }, STOP_SIGNAL_TIMEOUT);
+    });
+    updateStatus(processId, sessionId, "exited", null);
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.removed",
+      payload: { processId },
+      sessionId
+    });
+    removeProcess(processId, sessionId);
+  } catch (_) {
+    updateStatus(processId, sessionId, "exited", 1);
+    emitProcessEvent(processId, {
+      type: "backgroundProcess.removed",
+      payload: { processId },
+      sessionId
+    });
+    removeProcess(processId, sessionId);
+  }
+}
+function getProcessStatus(processId, sessionId) {
+  return getProcess(processId, sessionId);
+}
+function getSessionProcesses2(sessionId) {
+  return getSessionProcesses(sessionId);
+}
+function getProcessLogs(processId, since = 0, maxLines) {
+  return getLogsPaginated(processId, since, maxLines);
+}
+
+export {
+  onProcessEvent,
+  createProcess2 as createProcess,
+  startProcessCommand,
+  stopProcess,
+  getProcessStatus,
+  getSessionProcesses2 as getSessionProcesses,
+  getProcessLogs
+};
+//# sourceMappingURL=chunk-JHL5ZO3K.js.map

package/dist/{chunk-6PV24MJB.js → chunk-KUHCFENT.js}

@@ -154,7 +154,7 @@ async function runCli(options) {
       if (!configExists) {
         await runNetworkSetup(mode);
       }
-      const { runServe } = await import("./serve-JJLKBQXS.js");
+      const { runServe } = await import("./serve-DCCIXC4Q.js");
       await runServe({
         mode,
         port: values.port ? parseInt(values.port) : void 0,
@@ -167,4 +167,4 @@ async function runCli(options) {
 export {
   runCli
 };
-//# sourceMappingURL=chunk-6PV24MJB.js.map
+//# sourceMappingURL=chunk-KUHCFENT.js.map