@bevel-software/platform-core-backend 0.13.3 → 0.13.6

package/src/modules/workspace/__tests__/workspace.tools.test.ts

@@ -1,6 +1,6 @@
 import type { Server as HttpServer } from 'node:http';
 import { execFile } from 'node:child_process';
-import { mkdir, mkdtemp, rm } from 'node:fs/promises';
+import { mkdir, mkdtemp, readFile, rm } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { promisify } from 'node:util';
@@ -147,6 +147,25 @@ afterEach(async () => {
   }
 });
 
+/**
+ * True once `pid` has been killed: either it is gone, or it is a zombie
+ * waiting on a reaper (Linux: `State:\tZ` in /proc). `kill(pid, 0)` alone
+ * cannot tell a zombie from a live process.
+ */
+async function isDeadOrZombie(pid: number): Promise<boolean> {
+  try {
+    process.kill(pid, 0);
+  } catch {
+    return true;
+  }
+  try {
+    const status = await readFile(`/proc/${pid}/status`, 'utf8');
+    return /^State:\s*Z/m.test(status);
+  } catch {
+    return false; // no /proc (macOS): alive as far as the signal says
+  }
+}
+
 describe('workspace file primitives', () => {
   it('read_file returns the content', async () => {
     const base = await start();
@@ -191,6 +210,40 @@ describe('workspace file primitives', () => {
     expect(res.exitCode).toBe(0);
   });
 
+  // The command runs under `sh -c`; a timeout used to SIGKILL that shell and
+  // leave what it had started running on as an orphan. The whole process
+  // group goes now. POSIX only: Windows has no process groups to kill.
+  it.skipIf(process.platform === 'win32')('execute_command kills what the command started, not just its shell, on timeout', async () => {
+    const base = await start();
+    // Print the grandchild's pid, then block on it so the timeout fires. The
+    // timeout is the schema's minimum — inside the tool's declared contract,
+    // and long enough that a slow spawn still prints the pid before it fires.
+    const res = (await (
+      await post(`${base}/api/agent/tools/execute_command`, {
+        branch: 'main',
+        command: 'sleep 30 & echo $!; wait',
+        timeout_ms: 1000,
+      })
+    ).json()) as { stdout: string; exitCode: number };
+    expect(res.exitCode).toBe(-1);
+    const grandchild = Number(res.stdout.trim());
+    expect(grandchild).toBeGreaterThan(0);
+    // Dead means killed, not reaped: a SIGKILLed process keeps its pid — and
+    // answers `kill(pid, 0)` as alive — until whoever inherited it reaps it,
+    // and on a host with no reaper (the very thing this guards) that is
+    // never. So where /proc exists, a zombie (`State: Z`) counts as dead; a
+    // vanished pid counts everywhere. Poll to a deadline rather than trust
+    // one fixed pause. Without the fix the grandchild is still sleeping at
+    // the deadline, so what fails is the deadline — never an early check.
+    const deadline = Date.now() + 3_000;
+    let dead = false;
+    while (!dead && Date.now() < deadline) {
+      dead = await isDeadOrZombie(grandchild);
+      if (!dead) await new Promise((r) => setTimeout(r, 50));
+    }
+    expect(dead).toBe(true);
+  });
+
   it('execute_command 400s when no branch is given AND no focused branch (external caller)', async () => {
     const base = await start();
     // No `branch` arg and no `ctx.focusedBranch` (an external caller carries no

package/src/modules/workspace/file-readers/extract-pdf.ts

@@ -64,12 +64,24 @@ export async function extractPdf(bytes: Buffer): Promise<ExtractResult> {
       message: `could not be extracted as a PDF (the file is ${bytes.length} bytes — over the ${MAX_DOC_PART_BYTES}-byte (50 MB) extraction limit)`,
     };
   }
-  let doc: Awaited<ReturnType<typeof openPdf>>;
+  // The loading TASK is what gets destroyed at the end, not the document:
+  // pdf.js 6 dropped `PDFDocumentProxy.destroy()`, and destroying the task
+  // frees the document (and its pages) with it — the shape the viewer uses.
+  let task: Awaited<ReturnType<typeof openPdf>>;
   try {
-    doc = await openPdf(bytes);
+    task = await openPdf(bytes);
   } catch (err) {
     return { ok: false, message: `could not be parsed as a PDF (${(err as Error).message})` };
   }
+  let doc: Awaited<typeof task.promise>;
+  try {
+    doc = await task.promise;
+  } catch (err) {
+    // A task exists even when the document never will (malformed, truncated):
+    // destroy it, or its worker-side state outlives every failed extraction.
+    await task.destroy().catch(() => undefined);
+    return { ok: false, message: `could not be parsed as a PDF (${(err as Error).message})` };
+  }
   try {
     if (doc.numPages > MAX_PDF_PAGES) {
       return {
@@ -151,7 +163,7 @@ export async function extractPdf(bytes: Buffer): Promise<ExtractResult> {
   } catch (err) {
     return { ok: false, message: `could not extract the PDF's text (${(err as Error).message})` };
   } finally {
-    await doc.destroy();
+    await task.destroy();
   }
 }
 
@@ -167,6 +179,8 @@ async function openPdf(bytes: Buffer) {
     throw err;
   });
   const { getDocument } = await pdfjsPromise;
+  // Returns the loading task; the caller awaits `.promise` for the document
+  // and destroys the task when done (see `extractPdf`).
   return getDocument({
     // Copy into a fresh Uint8Array: pdf.js TRANSFERS the buffer it is given
     // (detaching it), and the caller's Buffer must stay usable for hashing.
@@ -174,5 +188,5 @@ async function openPdf(bytes: Buffer) {
     // Server side: no font rendering — text content is all we consume.
     disableFontFace: true,
     useSystemFonts: true,
-  }).promise;
+  });
 }

package/src/modules/workspace/workspace.tools.ts

@@ -1069,14 +1069,32 @@ export function registerWorkspaceTools(
           }
         : process.env;
       return new Promise((resolve) => {
-        const child = spawn(a.command as string, { cwd, shell: true, env });
+        // Own process group on POSIX, so a timeout or abort kills the WHOLE
+        // tree. `shell: true` puts an `sh` between us and the command; killing
+        // only that shell left whatever it had started running on — orphaned,
+        // unreaped, still holding the workspace and its memory. A self-hosted
+        // deployment leaked ~4,500 tasks that way before nothing could fork.
+        const detached = process.platform !== 'win32';
+        const child = spawn(a.command as string, { cwd, shell: true, env, detached });
         let stdout = '';
         let stderr = '';
-        const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
-        // If the caller disconnects (request aborted), kill the child instead of
+        const killTree = () => {
+          try {
+            if (detached && child.pid) process.kill(-child.pid, 'SIGKILL');
+            else child.kill('SIGKILL');
+          } catch {
+            try {
+              child.kill('SIGKILL');
+            } catch {
+              // Already gone.
+            }
+          }
+        };
+        const timer = setTimeout(killTree, timeoutMs);
+        // If the caller disconnects (request aborted), kill the tree instead of
         // letting it run to the timeout; the resulting `close`/`error` settles
         // the promise through `finish`.
-        const onAbort = () => child.kill('SIGKILL');
+        const onAbort = killTree;
         ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
         const finish = (value: unknown) => {
           clearTimeout(timer);