@venturewild/workspace 0.6.17 → 0.6.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@venturewild/workspace",
-  "version": "0.6.17",
+  "version": "0.6.18",
   "description": "Claude Code Web — Replit/Lovable-style chat-first browser UI that wraps the AI agent already installed on your machine.",
   "license": "MIT",
   "bin": {

package/server/src/background-tasks.mjs

@@ -26,6 +26,9 @@
 // silent past a threshold — surfaced as "no output for Xm", never a false "done".
 
 import fs from 'node:fs';
+import { resolveHolders as defaultResolveHolders, killTree as defaultKillTree } from './process-holders.mjs';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 
 const DEFAULT_POLL_MS = 3000; // how often we stat each live task's output file
 const DEFAULT_QUIET_MS = 90_000; // silence past this → flag `quiet` (maybe stuck / maybe just slow)
@@ -92,6 +95,9 @@ export function createBackgroundTasks(opts = {}) {
   const quietMs = opts.quietMs || DEFAULT_QUIET_MS;
   const maxPerWs = opts.maxPerWorkspace || DEFAULT_MAX_PER_WS;
   const fsi = opts.fsImpl || fs;
+  // The OS holder/kill engine (Restart Manager on Windows, lsof on Unix). Injectable
+  // so tests never spawn PowerShell or kill a real process.
+  const holders = opts.holders || { resolveHolders: defaultResolveHolders, killTree: defaultKillTree };
 
   // taskId (= the LAUNCH tool_use id) → task. Keying by the launch id (not the
   // shellId) means the chat card, which is created at launch time and only knows the
@@ -292,6 +298,44 @@ export function createBackgroundTasks(opts = {}) {
         .sort((a, b) => b.startedAt - a.startedAt)
         .map(publicView);
     },
+    /**
+     * Stop a running task: find who holds its output file open (Restart Manager /
+     * lsof) and kill that tree. No PID was captured at launch — the output-file path
+     * we already track IS the handle. Returns {ok, status, ...}.
+     *
+     * `excludePids` MUST include any live claude pids; this method always also
+     * excludes our own pid. That guard is load-bearing: RM/lsof report READERS too,
+     * and the server tails this very file — without it we could kill ourselves.
+     */
+    async stop(workspaceId, taskId, { excludePids = [], retries = 4, retryDelayMs = 400 } = {}) {
+      const t = tasks.get(taskId);
+      if (!t || t.workspaceId !== workspaceId) return { ok: false, error: 'not-found' };
+      if (TERMINAL.has(t.status)) return { ok: true, status: t.status, alreadyTerminal: true };
+      if (!t.outputFile) return { ok: false, error: 'no-output-file' };
+      const exclude = new Set([process.pid, ...excludePids].map(Number).filter(Boolean));
+      // Retry: a single RM/lsof shot occasionally misses a live task (measured ~10%).
+      // Three clean misses on a live task is ~0.1%; a genuine empty means it finished.
+      let pids = [];
+      for (let attempt = 0; attempt <= retries; attempt++) {
+        const found = await holders.resolveHolders(t.outputFile);
+        pids = (found || []).filter((p) => !exclude.has(Number(p)));
+        if (pids.length) break;
+        if (attempt < retries) await sleep(retryDelayMs);
+      }
+      if (!pids.length) {
+        // Nobody holds it after retries → the process already exited. It finished; we
+        // did NOT stop it — say so honestly (never claim a kill we didn't make).
+        if (!TERMINAL.has(t.status)) { t.status = 'completed'; t.endedAt = now(); t.quiet = false; emit(t); }
+        return { ok: true, status: 'completed', note: 'already-finished' };
+      }
+      const killed = await holders.killTree(pids);
+      t.status = 'killed';
+      t.endedAt = now();
+      t.exitCode = null;
+      t.quiet = false;
+      emit(t);
+      return { ok: true, status: 'killed', pids, killed };
+    },
     /** Tail the output file for one task (best-effort; null if unavailable). */
     tail(workspaceId, taskId, bytes = TAIL_BYTES) {
       const t = tasks.get(taskId);

package/server/src/index.mjs

@@ -2597,6 +2597,24 @@ export async function createServer(overrides = {}) {
     return c.json({ id, output });
   });
 
+  // Stop a running background task — resolve who holds its output file open and kill
+  // that tree (Restart Manager on Windows, lsof on Unix). Owner-only. We pass every
+  // LIVE claude pid to exclude so a Stop during an in-flight turn can't kill the
+  // active agent (and `stop` always also excludes our own server pid — the guard that
+  // matters, since RM/lsof report the file's readers too).
+  app.post('/api/workspace/tasks/:id/stop', async (c) => {
+    const forbidden = require(c, 'fileTree');
+    if (forbidden) return forbidden;
+    const id = c.req.param('id');
+    const claudePids = [...currentTurns.values()]
+      .map((t) => t?.session?.proc?.pid)
+      .filter((p) => Number.isInteger(p));
+    auditAction(c, 'task-stop', `id=${id}`);
+    const res = await bgTasks.stop(workspaceFor(c).id, id, { excludePids: claudePids });
+    if (!res.ok) return c.json(res, res.error === 'not-found' ? 404 : 400);
+    return c.json(res);
+  });
+
   // --- component inbox ---
   app.get('/api/inbox', async (c) => {
     // Enforce the `inbox` capability (partner-only). It existed in the matrix

package/server/src/process-holders.mjs

@@ -0,0 +1,122 @@
+// Cross-platform "who is running this background task, and stop it" — without ever
+// capturing a PID at launch (which fighting claude's opaque background mechanism
+// proved unreliable). Instead we use the one thing we already know: the task's
+// OUTPUT FILE path. The running process holds that file open, so:
+//
+//   resolveHolders(file) -> the PIDs holding it open
+//   killTree(pids)       -> stop them (whole tree)
+//
+//   Windows: Restart Manager (rstrtmgr.dll) — the API installers use to find which
+//            process locks a file — driven by a tiny embedded PowerShell helper.
+//   macOS/Linux: `lsof -t` (terse, PIDs only).
+//
+// SAFETY (proven necessary in the spike): RM/lsof also report READERS — our own
+// server tails the file, so a naive kill could `taskkill` the wild-workspace server
+// itself. Callers MUST pass the pids to exclude (our pid + any live claude pids);
+// this module never kills blindly.
+
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const execFileP = promisify(execFile);
+
+// PowerShell Restart Manager locker-finder. Embedded (not a shipped .ps1) so it
+// works regardless of how the package is published; written to a temp file on first
+// use and invoked with -File. Prints the holding PIDs, one per line.
+const RM_PS = [
+  'param([string]$Path)',
+  "$ErrorActionPreference='SilentlyContinue'",
+  "$sig = @'",
+  'using System; using System.Runtime.InteropServices; using System.Collections.Generic;',
+  'public static class RmFile {',
+  ' [StructLayout(LayoutKind.Sequential)] struct RM_UNIQUE_PROCESS { public int dwProcessId; public System.Runtime.InteropServices.ComTypes.FILETIME ProcessStartTime; }',
+  ' [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)] struct RM_PROCESS_INFO {',
+  '  public RM_UNIQUE_PROCESS Process;',
+  '  [MarshalAs(UnmanagedType.ByValTStr, SizeConst=256)] public string strAppName;',
+  '  [MarshalAs(UnmanagedType.ByValTStr, SizeConst=64)] public string strServiceShortName;',
+  '  public int ApplicationType; public uint AppStatus; public uint TSSessionId; [MarshalAs(UnmanagedType.Bool)] public bool bRestartable; }',
+  ' [DllImport("rstrtmgr.dll", CharSet=CharSet.Unicode)] static extern int RmStartSession(out uint h, int flags, string key);',
+  ' [DllImport("rstrtmgr.dll")] static extern int RmEndSession(uint h);',
+  ' [DllImport("rstrtmgr.dll", CharSet=CharSet.Unicode)] static extern int RmRegisterResources(uint h, uint nf, string[] files, uint na, RM_UNIQUE_PROCESS[] apps, uint ns, string[] svc);',
+  ' [DllImport("rstrtmgr.dll")] static extern int RmGetList(uint h, out uint need, ref uint count, [In,Out] RM_PROCESS_INFO[] info, ref uint reasons);',
+  ' public static List<int> Lockers(string p){ var r=new List<int>(); uint h; if(RmStartSession(out h,0,Guid.NewGuid().ToString())!=0)return r;',
+  '  try{ if(RmRegisterResources(h,1,new[]{p},0,null,0,null)!=0)return r; uint need=0,count=0,reasons=0; int res=RmGetList(h,out need,ref count,null,ref reasons);',
+  '   if(res==234){ var info=new RM_PROCESS_INFO[need]; count=need; if(RmGetList(h,out need,ref count,info,ref reasons)==0){ for(int i=0;i<count;i++) r.Add(info[i].Process.dwProcessId);} } }',
+  '  finally{ RmEndSession(h); } return r; } }',
+  "'@",
+  'Add-Type -TypeDefinition $sig',
+  '[RmFile]::Lockers($Path) | ForEach-Object { $_ }',
+].join('\r\n');
+
+let _rmScriptPath = null;
+function ensureRmScript() {
+  if (_rmScriptPath && fs.existsSync(_rmScriptPath)) return _rmScriptPath;
+  const p = path.join(os.tmpdir(), 'wild-workspace-rm-holders.ps1');
+  try { fs.writeFileSync(p, RM_PS, 'utf8'); _rmScriptPath = p; } catch { _rmScriptPath = null; }
+  return _rmScriptPath;
+}
+
+function parsePids(stdout) {
+  return String(stdout || '')
+    .split(/\r?\n/)
+    .map((l) => parseInt(l.trim(), 10))
+    .filter((n) => Number.isInteger(n) && n > 0);
+}
+
+/**
+ * PIDs currently holding `filePath` open (the running task's process tree + any
+ * readers). Returns [] on any failure or when nothing holds it (task finished).
+ */
+export async function resolveHolders(filePath, { exec = execFileP, platform = process.platform } = {}) {
+  if (!filePath) return [];
+  try {
+    if (platform === 'win32') {
+      const script = ensureRmScript();
+      if (!script) return [];
+      const { stdout } = await exec(
+        'powershell',
+        ['-NoProfile', '-ExecutionPolicy', 'Bypass', '-File', script, '-Path', filePath],
+        { timeout: 9000, windowsHide: true },
+      );
+      return uniq(parsePids(stdout));
+    }
+    const { stdout } = await exec('lsof', ['-t', '--', filePath], { timeout: 9000 });
+    return uniq(parsePids(stdout));
+  } catch (e) {
+    // lsof exits 1 with no output when nothing holds the file — that's "empty", not
+    // an error. Salvage any stdout the failed call captured, else treat as empty.
+    if (e && e.stdout) return uniq(parsePids(e.stdout));
+    return [];
+  }
+}
+
+/** Force-kill each pid AND its child tree. Returns per-pid {pid, ok}. */
+export async function killTree(pids, { exec = execFileP, platform = process.platform, kill = (p, s) => process.kill(p, s) } = {}) {
+  const out = [];
+  for (const pid of uniq(pids)) {
+    try {
+      if (platform === 'win32') {
+        await exec('taskkill', ['/PID', String(pid), '/T', '/F'], { timeout: 9000, windowsHide: true });
+      } else {
+        // SIGKILL the holder; lsof returned the whole fd-sharing chain, so killing
+        // each holder takes down the tree. A transient child (e.g. `sleep`) exits on
+        // its own once its parent is gone.
+        try { kill(pid, 'SIGKILL'); } catch { /* already gone */ }
+      }
+      out.push({ pid, ok: true });
+    } catch (e) {
+      // taskkill exits non-zero with "process not found" when /T already reaped it as
+      // part of an earlier pid's tree — that's success, not failure.
+      const msg = String((e && (e.stderr || e.message)) || '');
+      out.push({ pid, ok: /not found|not be terminated/i.test(msg) });
+    }
+  }
+  return out;
+}
+
+function uniq(arr) {
+  return [...new Set(arr)];
+}