@letrquan/book 0.2.0 → 0.3.0

package/dist/{interactive-assets-CCAAWVKH.js → interactive-assets-T4I4SEHU.js}

@@ -1,17 +1,21 @@
 import {
+  DEFAULT_THEME_NAME,
   listCustomThemes,
   resolveTheme
-} from "./chunk-L6LK2QIQ.js";
+} from "./chunk-J4F2QLM2.js";
 import {
   discoverSkills
-} from "./chunk-KWHQ2XXL.js";
+} from "./chunk-67UZEWWF.js";
 import {
   discoverCommands
-} from "./chunk-E75IPST5.js";
-import "./chunk-5KLVH3PY.js";
-import "./chunk-DGMQEI6Y.js";
-import "./chunk-574C6MQR.js";
-import "./chunk-24AXE6SP.js";
+} from "./chunk-EFJ2NH6E.js";
+import "./chunk-KXAYUIKP.js";
+import "./chunk-HQI7NYGX.js";
+import "./chunk-2AAOF5B5.js";
+import "./chunk-XHAO3K7I.js";
+import "./chunk-VPNLCMVR.js";
+import "./chunk-X4NJT436.js";
+import "./chunk-ZPSZZUWF.js";
 
 // src/tui/interactive-assets.ts
 function loadInteractiveAssets(config) {
@@ -22,10 +26,10 @@ function loadInteractiveAssets(config) {
       enabled: config.settings.skills.enabled
     }),
     customThemes: listCustomThemes(config.workspace),
-    initialTheme: resolveTheme(config.workspace, config.settings.theme ?? "apple")
+    initialTheme: resolveTheme(config.workspace, config.settings.theme ?? DEFAULT_THEME_NAME)
   };
 }
 export {
   loadInteractiveAssets
 };
-//# sourceMappingURL=interactive-assets-CCAAWVKH.js.map
+//# sourceMappingURL=interactive-assets-T4I4SEHU.js.map

package/dist/interactive-assets-T4I4SEHU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tui/interactive-assets.ts"],"sourcesContent":["import { discoverCommands } from '../commands/loader.js';\nimport { discoverSkills, type Skill } from '../skills.js';\nimport type { SlashCommand } from '../types/commands.js';\nimport type { AgentConfig } from '../types/runtime.js';\nimport { DEFAULT_THEME_NAME, listCustomThemes, resolveTheme, type ResolvedTheme } from './theme.js';\n\nexport interface InteractiveAssets {\n  commands: SlashCommand[];\n  skills: Skill[];\n  customThemes: string[];\n  initialTheme: ResolvedTheme | null;\n}\n\n/** Load filesystem-backed UI metadata before React begins rendering. */\nexport function loadInteractiveAssets(\n  config: Pick<AgentConfig, 'workspace' | 'settings'>,\n): InteractiveAssets {\n  return {\n    commands: discoverCommands(config.workspace),\n    skills: discoverSkills(config.workspace, config.settings.skills.overrides, {\n      executionOverrides: config.settings.skills.execution,\n      enabled: config.settings.skills.enabled,\n    }),\n    customThemes: listCustomThemes(config.workspace),\n    initialTheme: resolveTheme(config.workspace, config.settings.theme ?? DEFAULT_THEME_NAME),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAcO,SAAS,sBACd,QACmB;AACnB,SAAO;AAAA,IACL,UAAU,iBAAiB,OAAO,SAAS;AAAA,IAC3C,QAAQ,eAAe,OAAO,WAAW,OAAO,SAAS,OAAO,WAAW;AAAA,MACzE,oBAAoB,OAAO,SAAS,OAAO;AAAA,MAC3C,SAAS,OAAO,SAAS,OAAO;AAAA,IAClC,CAAC;AAAA,IACD,cAAc,iBAAiB,OAAO,SAAS;AAAA,IAC/C,cAAc,aAAa,OAAO,WAAW,OAAO,SAAS,SAAS,kBAAkB;AAAA,EAC1F;AACF;","names":[]}

package/dist/job-runner.js

@@ -1,15 +1,24 @@
 import {
+  loadPersistentShellSpec,
   readJsonFile,
-  signalProcessGroup,
-  system32Executable,
-  waitForProcessGroupExit,
   writeJsonAtomic
-} from "./chunk-S4XL7HOM.js";
-import "./chunk-7N4J557C.js";
-import "./chunk-24AXE6SP.js";
+} from "./chunk-YC6W4EJH.js";
+import {
+  TERMINATE_GRACE_MS,
+  signalProcessGroup,
+  terminateProcessTree,
+  waitForProcessClose,
+  waitForProcessGroupExit
+} from "./chunk-C7ADUNPR.js";
+import "./chunk-RT5SATF7.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import "./chunk-224FJZLH.js";
+import "./chunk-ZPSZZUWF.js";
 
 // src/job-runner.ts
-import { execFile, spawn } from "child_process";
+import { spawn } from "child_process";
 import {
   appendFileSync,
   existsSync,
@@ -19,25 +28,23 @@ import {
   truncateSync,
   writeFileSync
 } from "fs";
-import { createHash } from "crypto";
+import { dirname, extname, join } from "path";
+import { fileURLToPath } from "url";
 var specPath = process.argv[2];
 if (!specPath) {
   process.exitCode = 2;
   throw new Error("Missing persistent shell specification path.");
 }
-var loadedSpec = readJsonFile(specPath);
-if (!loadedSpec || loadedSpec.version !== 1 || createHash("sha256").update(loadedSpec.token).digest("hex") !== loadedSpec.tokenHash) {
+var loaded = loadPersistentShellSpec(specPath);
+if ("error" in loaded) {
   process.exitCode = 2;
-  throw new Error("Invalid persistent shell specification.");
+  throw new Error(loaded.error);
 }
-if (loadedSpec.sandboxed && !loadedSpec.exec) {
-  process.exitCode = 2;
-  throw new Error(
-    "Invalid persistent shell specification: sandboxed is set but no sandboxed argv is present."
-  );
-}
-var spec = loadedSpec;
-var TERMINATE_GRACE_MS = 1500;
+var spec = loaded.spec;
+var RECORD_RENAME_RETRY_BUDGET_MS = 1e3;
+var BEST_EFFORT_RENAME_RETRY_BUDGET_MS = 50;
+var TERMINAL_RECORD_RETRY_MS = 250;
+var TERMINAL_RECORD_ATTEMPTS = 20;
 var child;
 var terminal = false;
 var terminationInFlight = false;
@@ -52,7 +59,7 @@ var state = {
   command: spec.command,
   title: spec.title,
   workdir: spec.workdir,
-  status: "running",
+  status: "starting",
   notify: spec.notify,
   sandboxed: spec.sandboxed,
   runnerPid: process.pid,
@@ -72,15 +79,27 @@ var state = {
   completionDeliveredSequence: 0,
   completionAcknowledgedSequence: 0
 };
-function persist() {
+function persist(budgetMs = RECORD_RENAME_RETRY_BUDGET_MS) {
   state = { ...state, revision: state.revision + 1, heartbeatAt: Date.now() };
-  writeJsonAtomic(spec.recordPath, state);
+  writeJsonAtomic(spec.recordPath, state, { renameRetryBudgetMs: budgetMs });
+}
+function persistBestEffort(what) {
+  try {
+    persist(BEST_EFFORT_RENAME_RETRY_BUDGET_MS);
+  } catch (error) {
+    const code = error?.code ?? "unknown error";
+    state = {
+      ...state,
+      recordWriteFailures: (state.recordWriteFailures ?? 0) + 1,
+      lastRecordWriteError: `${what} write failed (${code})`
+    };
+  }
 }
 function appendBounded(data) {
   const chunk = Buffer.isBuffer(data) ? data : Buffer.from(String(data));
   if (chunk.length === 0) return;
-  appendFileSync(spec.outputPath, chunk);
   try {
+    appendFileSync(spec.outputPath, chunk);
     const size = statSync(spec.outputPath).size;
     if (size <= spec.maxLogBytes) return;
     const retained = readFileSync(spec.outputPath).subarray(-spec.maxLogBytes);
@@ -92,61 +111,25 @@ function appendBounded(data) {
       outputRotationSequence: (state.outputRotationSequence ?? 0) + 1,
       truncatedBytes: (state.truncatedBytes ?? 0) + discarded
     };
-    persist();
+    persistBestEffort("log rotation");
   } catch {
   }
 }
-function waitForChildClose(timeoutMs) {
-  if (!child || child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);
-  const proc = child;
-  return new Promise((resolve) => {
-    const timer = setTimeout(() => {
-      cleanup();
-      resolve(proc.exitCode !== null || proc.signalCode !== null);
-    }, timeoutMs);
-    const onClose = () => {
-      cleanup();
-      resolve(true);
-    };
-    const cleanup = () => {
-      clearTimeout(timer);
-      proc.off("close", onClose);
-    };
-    proc.once("close", onClose);
-  });
-}
 async function terminateTree() {
-  if (!child?.pid) return true;
-  const pid = child.pid;
-  if (process.platform !== "win32") {
-    signalProcessGroup(child, pid, "SIGTERM");
-    if (await waitForProcessGroupExit(pid, TERMINATE_GRACE_MS)) return true;
-    signalProcessGroup(child, pid, "SIGKILL");
-    return waitForProcessGroupExit(pid, TERMINATE_GRACE_MS);
-  }
-  const alreadyExited = child.exitCode !== null || child.signalCode !== null;
-  if (alreadyExited) return true;
-  const confirmed = await new Promise((resolve) => {
-    execFile(
-      system32Executable("taskkill"),
-      ["/PID", String(pid), "/T", "/F"],
-      { windowsHide: true, timeout: TERMINATE_GRACE_MS },
-      (error) => resolve(!error)
-    );
-  });
-  if (!confirmed) {
-    try {
-      child.kill("SIGTERM");
-    } catch {
-    }
+  const proc = child;
+  const pid = proc?.pid;
+  if (!proc || pid === void 0) return true;
+  if (process.platform === "win32") {
+    return terminateProcessTree(proc, pid, (timeoutMs) => waitForProcessClose(proc, timeoutMs));
   }
-  if (await waitForChildClose(TERMINATE_GRACE_MS)) return confirmed;
   try {
-    child.kill("SIGKILL");
+    process.kill(pid, "SIGTERM");
   } catch {
-    return false;
+    signalProcessGroup(proc, pid, "SIGTERM");
   }
-  return await waitForChildClose(TERMINATE_GRACE_MS) && confirmed;
+  if (await waitForProcessGroupExit(pid, TERMINATE_GRACE_MS)) return true;
+  signalProcessGroup(proc, pid, "SIGKILL");
+  return waitForProcessGroupExit(pid, TERMINATE_GRACE_MS);
 }
 function finish(status, code, signal, stopReason) {
   if (terminal) return;
@@ -167,47 +150,123 @@ function finish(status, code, signal, stopReason) {
     rmSync(specPath, { force: true });
   } catch {
   }
-  persist();
   if (heartbeat) clearInterval(heartbeat);
   if (controlPoll) clearInterval(controlPoll);
   if (deadline) clearTimeout(deadline);
-  setTimeout(() => process.exit(0), 10).unref();
+  publishTerminalRecord(1);
 }
-writeFileSync(spec.outputPath, "", { encoding: "utf8", mode: 384 });
-try {
-  const spawnBase = {
-    cwd: spec.workdir,
-    env: { ...process.env, ...spec.env },
-    detached: process.platform !== "win32",
-    stdio: ["ignore", "pipe", "pipe"]
-  };
-  child = spec.exec ? spawn(spec.exec.file, spec.exec.args, { ...spawnBase, shell: false }) : spawn(spec.effectiveCommand, { ...spawnBase, shell: true });
-  state = { ...state, childPid: child.pid };
-  persist();
-} catch (error) {
-  appendBounded(error instanceof Error ? `${error.message}
-` : `${String(error)}
+function publishTerminalRecord(attempt) {
+  try {
+    persist();
+  } catch (error) {
+    if (attempt < TERMINAL_RECORD_ATTEMPTS) {
+      setTimeout(() => publishTerminalRecord(attempt + 1), TERMINAL_RECORD_RETRY_MS);
+      return;
+    }
+    reportUnrecordedEnd(error);
+    process.exitCode = 1;
+    setTimeout(() => process.exit(1), 10).unref();
+    return;
+  }
+  setTimeout(() => process.exit(), 10).unref();
+}
+function reportUnrecordedEnd(error) {
+  const code = error?.code ?? "unknown error";
+  const outcome = state.exitCode === void 0 || state.exitCode === null ? state.status : `${state.status}, exit code ${state.exitCode}`;
+  try {
+    appendFileSync(
+      spec.outputPath,
+      `[runner: the job ended (${outcome}) but its record could not be written (${code}); Book will report it as lost]
+`
+    );
+  } catch {
+  }
+}
+function supervisorPath() {
+  const self = fileURLToPath(import.meta.url);
+  return join(dirname(self), `job-supervisor${extname(self)}`);
+}
+function failStartup(what, error) {
+  const reason = error instanceof Error ? error.message : String(error);
+  process.stderr.write(`Persistent background runner could not ${what}: ${reason}
 `);
-  finish("failed");
   process.exit(1);
 }
-child?.stdout?.on("data", appendBounded);
-child?.stderr?.on("data", appendBounded);
-child?.on("error", (error) => {
-  appendBounded(`${error.message}
+function supervisorEnv() {
+  const env = buildChildEnv(process.env, spec.env);
+  const nodeOptions = env.NODE_OPTIONS;
+  delete env.NODE_OPTIONS;
+  if (nodeOptions !== void 0) env.BOOK_SUPERVISED_NODE_OPTIONS = nodeOptions;
+  return env;
+}
+function startRunner() {
+  try {
+    writeFileSync(spec.outputPath, "", { encoding: "utf8", mode: 384 });
+  } catch (error) {
+    failStartup("create its job log", error);
+  }
+  try {
+    persist();
+  } catch (error) {
+    failStartup("write its job record", error);
+  }
+  let proc;
+  try {
+    proc = spawn(process.execPath, [...process.execArgv, supervisorPath(), specPath], {
+      cwd: spec.workdir,
+      env: supervisorEnv(),
+      detached: true,
+      stdio: ["pipe", "pipe", "pipe"],
+      windowsHide: true
+    });
+  } catch (error) {
+    appendBounded(error instanceof Error ? `${error.message}
+` : `${String(error)}
 `);
-  if (state.status !== "stopping") finish("failed");
-});
-child?.on("close", (code, signal) => {
-  if (terminal || state.status === "stopping") return;
-  finish(code === 0 ? "exited" : "failed", code, signal);
-});
-heartbeat = setInterval(persist, 1e3);
+    process.exitCode = 1;
+    finish("failed");
+    return;
+  }
+  child = proc;
+  proc.stdin?.on("error", () => {
+  });
+  proc.stdout?.on("data", appendBounded);
+  proc.stderr?.on("data", appendBounded);
+  proc.on("error", (error) => {
+    appendBounded(`${error.message}
+`);
+    if (state.status !== "stopping") finish("failed");
+  });
+  proc.on("close", (code, signal) => {
+    if (terminal || state.status === "stopping") return;
+    finish(code === 0 ? "exited" : "failed", code, signal);
+  });
+  state = { ...state, status: "running", childPid: proc.pid };
+  try {
+    persist();
+  } catch (error) {
+    terminal = true;
+    void terminateTree().finally(() => failStartup("write its job record", error));
+    return;
+  }
+  heartbeat = setInterval(() => persistBestEffort("heartbeat"), 1e3);
+  controlPoll = setInterval(() => {
+    if (!existsSync(spec.controlPath) || terminal) return;
+    const control = readJsonFile(
+      spec.controlPath
+    );
+    if (control?.token !== spec.token || control.action !== "stop") return;
+    void requestTermination("killed", control.reason ?? "requested");
+  }, 250);
+  deadline = spec.timeoutMs ? setTimeout(() => {
+    void requestTermination("timed_out", "timeout");
+  }, spec.timeoutMs) : void 0;
+}
 async function requestTermination(status, reason) {
   if (terminal || terminationInFlight) return;
   terminationInFlight = true;
   state = { ...state, status: "stopping", stopReason: reason };
-  persist();
+  persistBestEffort("stopping state");
   try {
     if (await terminateTree()) {
       finish(status, child?.exitCode, child?.signalCode, reason);
@@ -220,16 +279,5 @@ async function requestTermination(status, reason) {
     terminationInFlight = false;
   }
 }
-controlPoll = setInterval(() => {
-  if (!existsSync(spec.controlPath) || terminal) return;
-  const control = readJsonFile(
-    spec.controlPath
-  );
-  if (control?.token !== spec.token || control.action !== "stop") return;
-  void requestTermination("killed", control.reason ?? "requested");
-}, 250);
-deadline = spec.timeoutMs ? setTimeout(() => {
-  void requestTermination("timed_out", "timeout");
-}, spec.timeoutMs) : void 0;
-persist();
+startRunner();
 //# sourceMappingURL=job-runner.js.map

package/dist/job-runner.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/job-runner.ts"],"sourcesContent":["import { execFile, spawn, type ChildProcess, type SpawnOptions } from 'node:child_process';\r\nimport {\r\n  appendFileSync,\r\n  existsSync,\r\n  readFileSync,\r\n  rmSync,\r\n  statSync,\r\n  truncateSync,\r\n  writeFileSync,\r\n} from 'node:fs';\r\nimport { createHash } from 'node:crypto';\r\nimport {\r\n  readJsonFile,\r\n  writeJsonAtomic,\r\n  type PersistentShellSpec,\r\n  type PersistentShellState,\r\n} from './jobs/persistent-store.js';\r\nimport { signalProcessGroup, waitForProcessGroupExit } from './jobs/process-tree.js';\r\nimport { system32Executable } from './system32.js';\r\n\r\nconst specPath = process.argv[2];\r\nif (!specPath) {\r\n  process.exitCode = 2;\r\n  throw new Error('Missing persistent shell specification path.');\r\n}\r\nconst loadedSpec = readJsonFile<PersistentShellSpec>(specPath);\r\nif (\r\n  !loadedSpec ||\r\n  loadedSpec.version !== 1 ||\r\n  createHash('sha256').update(loadedSpec.token).digest('hex') !== loadedSpec.tokenHash\r\n) {\r\n  process.exitCode = 2;\r\n  throw new Error('Invalid persistent shell specification.');\r\n}\r\n// `effectiveCommand` is the raw user command now that sandboxing rides on\r\n// `exec`, so a spec claiming `sandboxed` without one would run completely\r\n// unconfined while the job panel and the [sandboxed] marker said otherwise.\r\n// Refuse to start rather than silently downgrade. The reverse is legitimate:\r\n// an unsandboxed command also carries an `exec` when the session shell is\r\n// spawned as argv (Git Bash or PowerShell on Windows).\r\nif (loadedSpec.sandboxed && !loadedSpec.exec) {\r\n  process.exitCode = 2;\r\n  throw new Error(\r\n    'Invalid persistent shell specification: sandboxed is set but no sandboxed argv is present.',\r\n  );\r\n}\r\nconst spec: PersistentShellSpec = loadedSpec;\r\nconst TERMINATE_GRACE_MS = 1_500;\r\n\r\nlet child: ChildProcess | undefined;\r\nlet terminal = false;\r\nlet terminationInFlight = false;\r\n// These timers are assigned after the child is wired so startup failures can still call finish().\r\n// eslint-disable-next-line prefer-const\r\nlet heartbeat: NodeJS.Timeout | undefined;\r\n// eslint-disable-next-line prefer-const\r\nlet controlPoll: NodeJS.Timeout | undefined;\r\n// eslint-disable-next-line prefer-const\r\nlet deadline: NodeJS.Timeout | undefined;\r\nconst startedAt = Date.now();\r\nlet state: PersistentShellState = {\r\n  version: 1,\r\n  revision: 1,\r\n  id: spec.id,\r\n  command: spec.command,\r\n  title: spec.title,\r\n  workdir: spec.workdir,\r\n  status: 'running',\r\n  notify: spec.notify,\r\n  sandboxed: spec.sandboxed,\r\n  runnerPid: process.pid,\r\n  tokenHash: spec.tokenHash,\r\n  startedAt,\r\n  heartbeatAt: startedAt,\r\n  outputRotationSequence: 0,\r\n  truncatedBytes: 0,\r\n  timeoutMs: spec.timeoutMs,\r\n  deadlineAt: spec.timeoutMs ? startedAt + spec.timeoutMs : undefined,\r\n  parentSessionId: spec.parentSessionId,\r\n  rootRunId: spec.rootRunId,\r\n  parentRunId: spec.parentRunId,\r\n  outputPath: spec.outputPath,\r\n  controlPath: spec.controlPath,\r\n  completionSequence: 0,\r\n  completionDeliveredSequence: 0,\r\n  completionAcknowledgedSequence: 0,\r\n};\r\n\r\nfunction persist(): void {\r\n  state = { ...state, revision: state.revision + 1, heartbeatAt: Date.now() };\r\n  writeJsonAtomic(spec.recordPath, state);\r\n}\r\n\r\nfunction appendBounded(data: unknown): void {\r\n  const chunk = Buffer.isBuffer(data) ? data : Buffer.from(String(data));\r\n  if (chunk.length === 0) return;\r\n  appendFileSync(spec.outputPath, chunk);\r\n  try {\r\n    const size = statSync(spec.outputPath).size;\r\n    if (size <= spec.maxLogBytes) return;\r\n    const retained = readFileSync(spec.outputPath).subarray(-spec.maxLogBytes);\r\n    const discarded = size - retained.length;\r\n    truncateSync(spec.outputPath, 0);\r\n    writeFileSync(spec.outputPath, retained);\r\n    state = {\r\n      ...state,\r\n      outputRotationSequence: (state.outputRotationSequence ?? 0) + 1,\r\n      truncatedBytes: (state.truncatedBytes ?? 0) + discarded,\r\n    };\r\n    persist();\r\n  } catch {\r\n    // Output retention is best effort; lifecycle state remains authoritative.\r\n  }\r\n}\r\n\r\nfunction waitForChildClose(timeoutMs: number): Promise<boolean> {\r\n  if (!child || child.exitCode !== null || child.signalCode !== null) return Promise.resolve(true);\r\n  const proc = child;\r\n  return new Promise((resolve) => {\r\n    const timer = setTimeout(() => {\r\n      cleanup();\r\n      resolve(proc.exitCode !== null || proc.signalCode !== null);\r\n    }, timeoutMs);\r\n    const onClose = () => {\r\n      cleanup();\r\n      resolve(true);\r\n    };\r\n    const cleanup = () => {\r\n      clearTimeout(timer);\r\n      proc.off('close', onClose);\r\n    };\r\n    proc.once('close', onClose);\r\n  });\r\n}\r\n\r\nasync function terminateTree(): Promise<boolean> {\r\n  if (!child?.pid) return true;\r\n  const pid = child.pid;\r\n  if (process.platform !== 'win32') {\r\n    // The direct child is the `sh -c` wrapper, which dies from SIGTERM even when the worker it\r\n    // forked ignores it. Escalate on whether the group still holds processes, never on the\r\n    // wrapper's own exit, or the surviving worker is recorded as killed while it keeps running.\r\n    signalProcessGroup(child, pid, 'SIGTERM');\r\n    if (await waitForProcessGroupExit(pid, TERMINATE_GRACE_MS)) return true;\r\n    signalProcessGroup(child, pid, 'SIGKILL');\r\n    return waitForProcessGroupExit(pid, TERMINATE_GRACE_MS);\r\n  }\r\n  // `taskkill /T /F` covers the tree, so the direct child's close speaks for the tree only when\r\n  // taskkill actually ran.\r\n  const alreadyExited = child.exitCode !== null || child.signalCode !== null;\r\n  if (alreadyExited) return true;\r\n  const confirmed = await new Promise<boolean>((resolve) => {\r\n    execFile(\r\n      system32Executable('taskkill'),\r\n      ['/PID', String(pid), '/T', '/F'],\r\n      { windowsHide: true, timeout: TERMINATE_GRACE_MS },\r\n      (error) => resolve(!error),\r\n    );\r\n  });\r\n  if (!confirmed) {\r\n    try {\r\n      child.kill('SIGTERM');\r\n    } catch {\r\n      // The process may have exited between taskkill and the fallback.\r\n    }\r\n  }\r\n  if (await waitForChildClose(TERMINATE_GRACE_MS)) return confirmed;\r\n  try {\r\n    child.kill('SIGKILL');\r\n  } catch {\r\n    return false;\r\n  }\r\n  return (await waitForChildClose(TERMINATE_GRACE_MS)) && confirmed;\r\n}\r\n\r\nfunction finish(\r\n  status: 'exited' | 'failed' | 'killed' | 'timed_out',\r\n  code?: number | null,\r\n  signal?: NodeJS.Signals | string | null,\r\n  stopReason?: string,\r\n): void {\r\n  if (terminal) return;\r\n  terminal = true;\r\n  // Stop capturing output at terminality: once the record reads terminal, the\r\n  // manager may dismiss the job and delete its files, so a straggling stream\r\n  // chunk must not re-create the log after that point.\r\n  child?.stdout?.off('data', appendBounded);\r\n  child?.stderr?.off('data', appendBounded);\r\n  state = {\r\n    ...state,\r\n    status,\r\n    exitCode: code,\r\n    signal,\r\n    stopReason,\r\n    finishedAt: Date.now(),\r\n    completionSequence: state.completionSequence + 1,\r\n  };\r\n  // Remove the runner-owned control/spec files BEFORE persisting the terminal\r\n  // record. The manager treats an observable terminal record as \"stop\r\n  // complete\" and immediately expects these files to be gone, so the removals\r\n  // must happen-before the rename that publishes the terminal state — the old\r\n  // order left a window where a preempted runner had published \"killed\" while\r\n  // the spec file still existed.\r\n  try {\r\n    rmSync(spec.controlPath, { force: true });\r\n    rmSync(specPath, { force: true });\r\n  } catch {\r\n    // Best effort: a leaked control/spec file is cleaned up by the manager's\r\n    // lost-job reconciliation or dismissal, whereas skipping the terminal\r\n    // persist below would strand the job as \"stopping\" forever.\r\n  }\r\n  persist();\r\n  if (heartbeat) clearInterval(heartbeat);\r\n  if (controlPoll) clearInterval(controlPoll);\r\n  if (deadline) clearTimeout(deadline);\r\n  setTimeout(() => process.exit(0), 10).unref();\r\n}\r\n\r\nwriteFileSync(spec.outputPath, '', { encoding: 'utf8', mode: 0o600 });\r\ntry {\r\n  const spawnBase: SpawnOptions = {\r\n    cwd: spec.workdir,\r\n    env: { ...process.env, ...spec.env },\r\n    detached: process.platform !== 'win32',\r\n    stdio: ['ignore', 'pipe', 'pipe'],\r\n  };\r\n  // Sandboxed specs carry an argv; only unsandboxed ones go through a shell.\r\n  child = spec.exec\r\n    ? spawn(spec.exec.file, spec.exec.args, { ...spawnBase, shell: false })\r\n    : spawn(spec.effectiveCommand, { ...spawnBase, shell: true });\r\n  state = { ...state, childPid: child.pid };\r\n  persist();\r\n} catch (error) {\r\n  appendBounded(error instanceof Error ? `${error.message}\\n` : `${String(error)}\\n`);\r\n  finish('failed');\r\n  process.exit(1);\r\n}\r\n\r\nchild?.stdout?.on('data', appendBounded);\r\nchild?.stderr?.on('data', appendBounded);\r\nchild?.on('error', (error) => {\r\n  appendBounded(`${error.message}\\n`);\r\n  if (state.status !== 'stopping') finish('failed');\r\n});\r\nchild?.on('close', (code, signal) => {\r\n  if (terminal || state.status === 'stopping') return;\r\n  finish(code === 0 ? 'exited' : 'failed', code, signal);\r\n});\r\n\r\nheartbeat = setInterval(persist, 1_000);\r\nasync function requestTermination(status: 'killed' | 'timed_out', reason: string): Promise<void> {\r\n  if (terminal || terminationInFlight) return;\r\n  terminationInFlight = true;\r\n  state = { ...state, status: 'stopping', stopReason: reason };\r\n  persist();\r\n  try {\r\n    if (await terminateTree()) {\r\n      finish(status, child?.exitCode, child?.signalCode, reason);\r\n    } else {\r\n      appendBounded('[termination requested; process is still running; retrying]\\n');\r\n      const retry = setTimeout(() => void requestTermination(status, reason), 500);\r\n      retry.unref();\r\n    }\r\n  } finally {\r\n    terminationInFlight = false;\r\n  }\r\n}\r\n\r\ncontrolPoll = setInterval(() => {\r\n  if (!existsSync(spec.controlPath) || terminal) return;\r\n  const control = readJsonFile<{ token?: string; action?: string; reason?: string }>(\r\n    spec.controlPath,\r\n  );\r\n  if (control?.token !== spec.token || control.action !== 'stop') return;\r\n  void requestTermination('killed', control.reason ?? 'requested');\r\n}, 250);\r\ndeadline = spec.timeoutMs\r\n  ? setTimeout(() => {\r\n      void requestTermination('timed_out', 'timeout');\r\n    }, spec.timeoutMs)\r\n  : undefined;\r\n\r\npersist();\r\n"],"mappings":"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","names":[]}
+{"version":3,"sources":["../src/job-runner.ts"],"sourcesContent":["import { spawn, type ChildProcess } from 'node:child_process';\nimport { buildChildEnv } from './child-env.js';\nimport {\n  appendFileSync,\n  existsSync,\n  readFileSync,\n  rmSync,\n  statSync,\n  truncateSync,\n  writeFileSync,\n} from 'node:fs';\nimport { dirname, extname, join } from 'node:path';\nimport { fileURLToPath } from 'node:url';\nimport {\n  loadPersistentShellSpec,\n  readJsonFile,\n  writeJsonAtomic,\n  type PersistentShellSpec,\n  type PersistentShellState,\n} from './jobs/persistent-store.js';\nimport {\n  signalProcessGroup,\n  terminateProcessTree,\n  waitForProcessClose,\n  waitForProcessGroupExit,\n  TERMINATE_GRACE_MS,\n} from './jobs/process-tree.js';\n\nconst specPath = process.argv[2];\nif (!specPath) {\n  process.exitCode = 2;\n  throw new Error('Missing persistent shell specification path.');\n}\nconst loaded = loadPersistentShellSpec(specPath);\nif ('error' in loaded) {\n  process.exitCode = 2;\n  throw new Error(loaded.error);\n}\nconst spec: PersistentShellSpec = loaded.spec;\n/**\n * How long a contended record write may block before it counts as failed. The first record and\n * the terminal record wait up to a second for Windows to release the file: the job cannot start\n * without the first, and the manager waits on the second to call a stop complete. Every other\n * write (the heartbeat, the child pid, `stopping`, a log rotation) is repeated by the next\n * heartbeat, so it gives up almost at once instead of stalling the runner's timers.\n */\nconst RECORD_RENAME_RETRY_BUDGET_MS = 1_000;\nconst BEST_EFFORT_RENAME_RETRY_BUDGET_MS = 50;\n/** A terminal record that still failed to write is retried on a timer this often, this many times. */\nconst TERMINAL_RECORD_RETRY_MS = 250;\nconst TERMINAL_RECORD_ATTEMPTS = 20;\n\nlet child: ChildProcess | undefined;\nlet terminal = false;\nlet terminationInFlight = false;\n// These timers are assigned after the child is wired so startup failures can still call finish().\nlet heartbeat: NodeJS.Timeout | undefined;\nlet controlPoll: NodeJS.Timeout | undefined;\nlet deadline: NodeJS.Timeout | undefined;\nconst startedAt = Date.now();\nlet state: PersistentShellState = {\n  version: 1,\n  revision: 1,\n  id: spec.id,\n  command: spec.command,\n  title: spec.title,\n  workdir: spec.workdir,\n  status: 'starting',\n  notify: spec.notify,\n  sandboxed: spec.sandboxed,\n  runnerPid: process.pid,\n  tokenHash: spec.tokenHash,\n  startedAt,\n  heartbeatAt: startedAt,\n  outputRotationSequence: 0,\n  truncatedBytes: 0,\n  timeoutMs: spec.timeoutMs,\n  deadlineAt: spec.timeoutMs ? startedAt + spec.timeoutMs : undefined,\n  parentSessionId: spec.parentSessionId,\n  rootRunId: spec.rootRunId,\n  parentRunId: spec.parentRunId,\n  outputPath: spec.outputPath,\n  controlPath: spec.controlPath,\n  completionSequence: 0,\n  completionDeliveredSequence: 0,\n  completionAcknowledgedSequence: 0,\n};\n\nfunction persist(budgetMs = RECORD_RENAME_RETRY_BUDGET_MS): void {\n  state = { ...state, revision: state.revision + 1, heartbeatAt: Date.now() };\n  writeJsonAtomic(spec.recordPath, state, { renameRetryBudgetMs: budgetMs });\n}\n\n/**\n * A non-terminal write: the heartbeat, the switch to `stopping`, a log rotation. One that fails\n * must not end the runner, or its job would keep running with nothing left to stop it; the next\n * heartbeat writes the same state again. The failure is counted on the record, which that next\n * write carries, rather than noted in the job's log: the log is the command's own output, and the\n * model reads it through BashOutput.\n */\nfunction persistBestEffort(what: string): void {\n  try {\n    persist(BEST_EFFORT_RENAME_RETRY_BUDGET_MS);\n  } catch (error) {\n    const code = (error as NodeJS.ErrnoException | undefined)?.code ?? 'unknown error';\n    state = {\n      ...state,\n      recordWriteFailures: (state.recordWriteFailures ?? 0) + 1,\n      lastRecordWriteError: `${what} write failed (${code})`,\n    };\n  }\n}\n\nfunction appendBounded(data: unknown): void {\n  const chunk = Buffer.isBuffer(data) ? data : Buffer.from(String(data));\n  if (chunk.length === 0) return;\n  try {\n    appendFileSync(spec.outputPath, chunk);\n    const size = statSync(spec.outputPath).size;\n    if (size <= spec.maxLogBytes) return;\n    const retained = readFileSync(spec.outputPath).subarray(-spec.maxLogBytes);\n    const discarded = size - retained.length;\n    truncateSync(spec.outputPath, 0);\n    writeFileSync(spec.outputPath, retained);\n    state = {\n      ...state,\n      outputRotationSequence: (state.outputRotationSequence ?? 0) + 1,\n      truncatedBytes: (state.truncatedBytes ?? 0) + discarded,\n    };\n    persistBestEffort('log rotation');\n  } catch {\n    // Output and its retention are best effort; lifecycle state remains authoritative.\n  }\n}\n\n/**\n * End the job's tree. Off Windows the first SIGTERM goes to the supervisor alone, because the\n * supervisor leads the job's own process group and passes the signal on to that group exactly once:\n * signalling the group from here as well would hand the command a second SIGTERM, which a command\n * that has installed its own handler or is midway through a graceful shutdown sees as two stops\n * rather than one. A supervisor that has already exited forwards nothing, so the signal falls\n * through to the group itself. From there the escalation is this process's own, exactly as before,\n * because the supervisor no longer passes SIGKILL along. Windows has no signal for a group, so\n * `taskkill /T /F` still walks the tree from the supervisor there.\n */\nasync function terminateTree(): Promise<boolean> {\n  const proc = child;\n  const pid = proc?.pid;\n  if (!proc || pid === undefined) return true;\n  if (process.platform === 'win32') {\n    return terminateProcessTree(proc, pid, (timeoutMs) => waitForProcessClose(proc, timeoutMs));\n  }\n  try {\n    process.kill(pid, 'SIGTERM');\n  } catch {\n    signalProcessGroup(proc, pid, 'SIGTERM');\n  }\n  if (await waitForProcessGroupExit(pid, TERMINATE_GRACE_MS)) return true;\n  signalProcessGroup(proc, pid, 'SIGKILL');\n  return waitForProcessGroupExit(pid, TERMINATE_GRACE_MS);\n}\n\nfunction finish(\n  status: 'exited' | 'failed' | 'killed' | 'timed_out',\n  code?: number | null,\n  signal?: NodeJS.Signals | string | null,\n  stopReason?: string,\n): void {\n  if (terminal) return;\n  terminal = true;\n  // Stop capturing output at terminality: once the record reads terminal, the\n  // manager may dismiss the job and delete its files, so a straggling stream\n  // chunk must not re-create the log after that point.\n  child?.stdout?.off('data', appendBounded);\n  child?.stderr?.off('data', appendBounded);\n  state = {\n    ...state,\n    status,\n    exitCode: code,\n    signal,\n    stopReason,\n    finishedAt: Date.now(),\n    completionSequence: state.completionSequence + 1,\n  };\n  // Remove the runner-owned control/spec files BEFORE persisting the terminal\n  // record. The manager treats an observable terminal record as \"stop\n  // complete\" and immediately expects these files to be gone, so the removals\n  // must happen-before the rename that publishes the terminal state — the old\n  // order left a window where a preempted runner had published \"killed\" while\n  // the spec file still existed.\n  try {\n    rmSync(spec.controlPath, { force: true });\n    rmSync(specPath, { force: true });\n  } catch {\n    // Best effort: a leaked control/spec file is cleaned up by the manager's\n    // lost-job reconciliation or dismissal, whereas skipping the terminal\n    // persist below would strand the job as \"stopping\" forever.\n  }\n  if (heartbeat) clearInterval(heartbeat);\n  if (controlPoll) clearInterval(controlPoll);\n  if (deadline) clearTimeout(deadline);\n  publishTerminalRecord(1);\n}\n\n/**\n * Write the terminal record, then exit. It is the one write the manager waits on to call a stop\n * complete, so a write that fails even after the retry budget is tried again on a timer rather\n * than ending the runner with its job still recorded as running. If every attempt fails, the\n * runner says at the end of the job's log what really happened, exits nonzero, and the manager's\n * heartbeat-staleness check reports the job lost.\n */\nfunction publishTerminalRecord(attempt: number): void {\n  try {\n    persist();\n  } catch (error) {\n    if (attempt < TERMINAL_RECORD_ATTEMPTS) {\n      setTimeout(() => publishTerminalRecord(attempt + 1), TERMINAL_RECORD_RETRY_MS);\n      return;\n    }\n    reportUnrecordedEnd(error);\n    process.exitCode = 1;\n    setTimeout(() => process.exit(1), 10).unref();\n    return;\n  }\n  setTimeout(() => process.exit(), 10).unref();\n}\n\n/**\n * Every attempt at the terminal record failed, so the manager will find a stale heartbeat and\n * call the job lost. Say what really happened at the end of the job's log, the one place left\n * that someone reads. The log is safe to write: the record never turned terminal, so the\n * manager cannot have dismissed the job and deleted it.\n */\nfunction reportUnrecordedEnd(error: unknown): void {\n  const code = (error as NodeJS.ErrnoException | undefined)?.code ?? 'unknown error';\n  const outcome =\n    state.exitCode === undefined || state.exitCode === null\n      ? state.status\n      : `${state.status}, exit code ${state.exitCode}`;\n  try {\n    appendFileSync(\n      spec.outputPath,\n      `[runner: the job ended (${outcome}) but its record could not be written (${code}); Book will report it as lost]\\n`,\n    );\n  } catch {\n    // There is nowhere left to say it.\n  }\n}\n\n/** The supervisor built beside this file: `.js` in dist, `.ts` when run from source through tsx. */\nfunction supervisorPath(): string {\n  const self = fileURLToPath(import.meta.url);\n  return join(dirname(self), `job-supervisor${extname(self)}`);\n}\n\nfunction failStartup(what: string, error: unknown): never {\n  const reason = error instanceof Error ? error.message : String(error);\n  process.stderr.write(`Persistent background runner could not ${what}: ${reason}\\n`);\n  process.exit(1);\n}\n\n/**\n * The env the supervisor is started with. `NODE_OPTIONS` is meant for the command the user asked\n * for, not for the supervisor standing between them: left in place it makes the supervisor open the\n * inspector and write \"Debugger listening...\" into the job's log, which the runner appends to the\n * command's own output. It is therefore taken out here and carried beside it, under a name of this\n * runner's own, which the supervisor puts back for the command alone.\n *\n * This process inherited Book's environment, so a `NODE_ENV` Book defaulted for its own renderer\n * travels the whole chain: it is not the job's, and a persistent job outlives Book to be the one\n * that most certainly must not carry it.\n */\nfunction supervisorEnv(): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = buildChildEnv(process.env, spec.env);\n  const nodeOptions = env.NODE_OPTIONS;\n  delete env.NODE_OPTIONS;\n  if (nodeOptions !== undefined) env.BOOK_SUPERVISED_NODE_OPTIONS = nodeOptions;\n  return env;\n}\n\n/**\n * Create the log, write the first record, then start the command under its supervisor. The first\n * record says `starting`, and the job counts as started once the second, carrying the command's\n * pid, has landed: `start()` returns on the first record whose status is not `starting`, so a\n * record that claimed otherwise would report a persistent job with nothing to stop. That first\n * write is therefore the one that cannot be best effort — without it the manager gives up, forgets\n * the job and deletes its files while the command runs on with nothing left to stop it. So until\n * it has landed, a failure ends the runner before anything runs; a failure on the second ends the\n * command first, and both say why on stderr, which `start()` reports.\n */\nfunction startRunner(): void {\n  try {\n    writeFileSync(spec.outputPath, '', { encoding: 'utf8', mode: 0o600 });\n  } catch (error) {\n    failStartup('create its job log', error);\n  }\n  try {\n    persist();\n  } catch (error) {\n    failStartup('write its job record', error);\n  }\n  let proc: ChildProcess;\n  try {\n    // `process.execArgv` carries tsx's loader when this runner itself runs from source.\n    proc = spawn(process.execPath, [...process.execArgv, supervisorPath(), specPath], {\n      cwd: spec.workdir,\n      env: supervisorEnv(),\n      detached: true,\n      stdio: ['pipe', 'pipe', 'pipe'],\n      windowsHide: true,\n    });\n  } catch (error) {\n    appendBounded(error instanceof Error ? `${error.message}\\n` : `${String(error)}\\n`);\n    process.exitCode = 1;\n    finish('failed');\n    return;\n  }\n  child = proc;\n  // The supervisor's stdin is its lifeline to this process: never written and never closed, it\n  // reaches end-of-file only when this process is gone. See job-supervisor.ts.\n  proc.stdin?.on('error', () => {});\n  proc.stdout?.on('data', appendBounded);\n  proc.stderr?.on('data', appendBounded);\n  proc.on('error', (error) => {\n    appendBounded(`${error.message}\\n`);\n    if (state.status !== 'stopping') finish('failed');\n  });\n  proc.on('close', (code, signal) => {\n    if (terminal || state.status === 'stopping') return;\n    finish(code === 0 ? 'exited' : 'failed', code, signal);\n  });\n  state = { ...state, status: 'running', childPid: proc.pid };\n  try {\n    persist();\n  } catch (error) {\n    // The manager calls the job started only once it reads this record. Without it, it would\n    // give up, forget the job and delete its files while the command ran on: end the command\n    // first, then say why.\n    terminal = true;\n    void terminateTree().finally(() => failStartup('write its job record', error));\n    return;\n  }\n  heartbeat = setInterval(() => persistBestEffort('heartbeat'), 1_000);\n  controlPoll = setInterval(() => {\n    if (!existsSync(spec.controlPath) || terminal) return;\n    const control = readJsonFile<{ token?: string; action?: string; reason?: string }>(\n      spec.controlPath,\n    );\n    if (control?.token !== spec.token || control.action !== 'stop') return;\n    void requestTermination('killed', control.reason ?? 'requested');\n  }, 250);\n  deadline = spec.timeoutMs\n    ? setTimeout(() => {\n        void requestTermination('timed_out', 'timeout');\n      }, spec.timeoutMs)\n    : undefined;\n}\n\nasync function requestTermination(status: 'killed' | 'timed_out', reason: string): Promise<void> {\n  if (terminal || terminationInFlight) return;\n  terminationInFlight = true;\n  state = { ...state, status: 'stopping', stopReason: reason };\n  persistBestEffort('stopping state');\n  try {\n    if (await terminateTree()) {\n      finish(status, child?.exitCode, child?.signalCode, reason);\n    } else {\n      appendBounded('[termination requested; process is still running; retrying]\\n');\n      const retry = setTimeout(() => void requestTermination(status, reason), 500);\n      retry.unref();\n    }\n  } finally {\n    terminationInFlight = false;\n  }\n}\n\nstartRunner();\n"],"mappings":"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","names":[]}

package/dist/job-supervisor.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/job-supervisor.js

@@ -0,0 +1,112 @@
+import {
+  loadPersistentShellSpec
+} from "./chunk-YC6W4EJH.js";
+import {
+  TERMINATE_GRACE_MS,
+  runTaskkill
+} from "./chunk-C7ADUNPR.js";
+import "./chunk-RT5SATF7.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import "./chunk-224FJZLH.js";
+import "./chunk-ZPSZZUWF.js";
+
+// src/job-supervisor.ts
+import { spawn } from "child_process";
+import { constants } from "os";
+var RERAISABLE_SIGNALS = /* @__PURE__ */ new Set([
+  "SIGTERM",
+  "SIGINT",
+  "SIGHUP",
+  "SIGKILL"
+]);
+var [specPath] = process.argv.slice(2);
+if (!specPath) {
+  process.stderr.write("Missing persistent shell specification path.\n");
+  process.exit(2);
+}
+var loaded = loadPersistentShellSpec(specPath);
+if ("error" in loaded) {
+  process.stderr.write(`${loaded.error}
+`);
+  process.exit(2);
+}
+var spec = loaded.spec;
+function commandEnv() {
+  const env = buildChildEnv(process.env);
+  const nodeOptions = env.BOOK_SUPERVISED_NODE_OPTIONS;
+  delete env.BOOK_SUPERVISED_NODE_OPTIONS;
+  if (nodeOptions !== void 0) env.NODE_OPTIONS = nodeOptions;
+  return env;
+}
+var options = {
+  stdio: ["ignore", "inherit", "inherit"],
+  windowsHide: true,
+  env: commandEnv()
+};
+var command = spec.exec ? spawn(spec.exec.file, spec.exec.args, { ...options, shell: false }) : spawn(spec.effectiveCommand, { ...options, shell: true });
+var lifelineLost = false;
+command.on("error", (error) => {
+  process.stderr.write(`${error.message}
+`);
+  if (!lifelineLost) process.exit(1);
+});
+command.on("exit", (code, signal) => {
+  if (lifelineLost) return;
+  if (signal && process.platform !== "win32") {
+    if (RERAISABLE_SIGNALS.has(signal)) {
+      process.removeAllListeners(signal);
+      process.kill(process.pid, signal);
+      setTimeout(() => process.exit(1), 100);
+      return;
+    }
+    process.exit(128 + (constants.signals[signal] ?? 0));
+  }
+  process.exit(code ?? 1);
+});
+var FORWARDED_SIGNALS = ["SIGTERM", "SIGINT", "SIGHUP"];
+var forwarded = /* @__PURE__ */ new Set();
+if (process.platform !== "win32") {
+  for (const kind of FORWARDED_SIGNALS) {
+    process.on(kind, () => {
+      if (lifelineLost || forwarded.has(kind)) return;
+      forwarded.add(kind);
+      try {
+        process.kill(-process.pid, kind);
+      } catch {
+      }
+    });
+  }
+}
+var TASKKILL_TIMEOUT_MS = 1e4;
+var TASKKILL_ATTEMPTS = 3;
+async function killCommandTree(pid) {
+  for (let attempt = 1; attempt <= TASKKILL_ATTEMPTS; attempt++) {
+    if (await runTaskkill(pid, TASKKILL_TIMEOUT_MS)) return;
+  }
+}
+function endCommandTree() {
+  if (lifelineLost) return;
+  lifelineLost = true;
+  if (process.platform === "win32") {
+    if (command.pid === void 0) process.exit(1);
+    void killCommandTree(command.pid).finally(() => process.exit(1));
+    return;
+  }
+  try {
+    process.kill(-process.pid, "SIGTERM");
+  } catch {
+  }
+  setTimeout(() => {
+    try {
+      process.kill(-process.pid, "SIGKILL");
+    } catch {
+    }
+    process.exit(1);
+  }, TERMINATE_GRACE_MS);
+}
+process.stdin.on("end", endCommandTree);
+process.stdin.on("error", endCommandTree);
+process.stdin.resume();
+//# sourceMappingURL=job-supervisor.js.map

package/dist/job-supervisor.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/job-supervisor.ts"],"sourcesContent":["/**\n * The supervisor that keeps a persistent background job's command from outliving its runner.\n *\n * The detached job runner is the only thing that stops a command, so when the runner died any\n * other way than through a stop request (a crash, Task Manager, `kill -9`), the command kept\n * running with nothing left to stop it. On Windows the runner's death did end the shell wrapper,\n * which Node puts in a job object that dies with its parent, but not the process the wrapper had\n * started. Elsewhere the command ran in its own process group, and nothing ended it at all.\n *\n * The runner now starts this process detached, so that it outlives the runner: outside the\n * runner's job object on Windows, as the leader of its own process group elsewhere. This process\n * starts the command. Its stdin is a pipe the runner holds open and never writes, a lifeline: when\n * the runner goes away, for any reason, the operating system closes the pipe, and this process\n * ends the command's whole tree and then itself. The pipe needs no polling and cannot be fooled by\n * a reused pid. The command writes straight into the runner's own pipes, and this process exits\n * with the command's exit code, so the runner records what it always recorded. The pid Book reports\n * for the job is this process's; off Windows a signal sent to it is passed to the whole job.\n *\n * Usage, from the runner: node job-supervisor.js <spec-path>\n */\nimport { spawn, type SpawnOptions } from 'node:child_process';\nimport { constants } from 'node:os';\nimport { buildChildEnv } from './child-env.js';\nimport { loadPersistentShellSpec } from './jobs/persistent-store.js';\nimport { runTaskkill, TERMINATE_GRACE_MS } from './jobs/process-tree.js';\n\n/** Signals this process can die of just as the command did: Node gives them no meaning of its own. */\nconst RERAISABLE_SIGNALS: ReadonlySet<NodeJS.Signals> = new Set([\n  'SIGTERM',\n  'SIGINT',\n  'SIGHUP',\n  'SIGKILL',\n]);\n\nconst [specPath] = process.argv.slice(2);\nif (!specPath) {\n  process.stderr.write('Missing persistent shell specification path.\\n');\n  process.exit(2);\n}\n// The same checks the runner applies: this process starts the command, so a spec it must not\n// execute is exactly as unsafe here as it is there.\nconst loaded = loadPersistentShellSpec(specPath);\nif ('error' in loaded) {\n  process.stderr.write(`${loaded.error}\\n`);\n  process.exit(2);\n}\nconst spec = loaded.spec;\n\n/**\n * The env the command is started with. This process was started without `NODE_OPTIONS`, so that the\n * options the user asked for apply to their command rather than opening an inspector here and\n * writing about it into the job's log; the runner carries them beside it for exactly that reason.\n *\n * A `NODE_ENV` Book defaulted for its own renderer is dropped here too, the last link of the\n * chain: the runner has already removed its own, and this process reads what it inherited.\n */\nfunction commandEnv(): NodeJS.ProcessEnv {\n  const env: NodeJS.ProcessEnv = buildChildEnv(process.env);\n  const nodeOptions = env.BOOK_SUPERVISED_NODE_OPTIONS;\n  delete env.BOOK_SUPERVISED_NODE_OPTIONS;\n  if (nodeOptions !== undefined) env.NODE_OPTIONS = nodeOptions;\n  return env;\n}\n\nconst options: SpawnOptions = {\n  stdio: ['ignore', 'inherit', 'inherit'],\n  windowsHide: true,\n  env: commandEnv(),\n};\n// Sandboxed specs carry an argv; only unsandboxed ones go through a shell.\nconst command = spec.exec\n  ? spawn(spec.exec.file, spec.exec.args, { ...options, shell: false })\n  : spawn(spec.effectiveCommand, { ...options, shell: true });\n\n/** Set once the runner is gone and this process has begun ending the command's tree. */\nlet lifelineLost = false;\n\ncommand.on('error', (error) => {\n  process.stderr.write(`${error.message}\\n`);\n  if (!lifelineLost) process.exit(1);\n});\n\ncommand.on('exit', (code, signal) => {\n  // Once the runner is gone, this process exits when the tree has been ended, not before.\n  if (lifelineLost) return;\n  if (signal && process.platform !== 'win32') {\n    if (RERAISABLE_SIGNALS.has(signal)) {\n      // Die of the command's signal, so the runner records it the way it did before this process\n      // stood between them.\n      // Drop the forwarding handler, or it would swallow the re-raised signal.\n      process.removeAllListeners(signal);\n      process.kill(process.pid, signal);\n      setTimeout(() => process.exit(1), 100);\n      return;\n    }\n    // A signal Node gives a meaning of its own cannot be re-raised: SIGUSR1 would open the\n    // inspector and write \"Debugger listening...\" into the job's log, and SIGSEGV, SIGBUS, SIGABRT\n    // and SIGQUIT would dump this process's core. Report the command's death the way a shell does.\n    process.exit(128 + (constants.signals[signal] ?? 0));\n  }\n  process.exit(code ?? 1);\n});\n\n/**\n * Signals sent to this process, the pid Book reports for the job, are meant for the job: pass each\n * to the whole group, as the runner's own stop does, and exit with the command. Forwarded once per\n * kind, because the forwarded signal reaches this process too. Windows has no such signals; there\n * the runner's stop goes through taskkill.\n */\nconst FORWARDED_SIGNALS: readonly NodeJS.Signals[] = ['SIGTERM', 'SIGINT', 'SIGHUP'];\nconst forwarded = new Set<NodeJS.Signals>();\nif (process.platform !== 'win32') {\n  for (const kind of FORWARDED_SIGNALS) {\n    process.on(kind, () => {\n      if (lifelineLost || forwarded.has(kind)) return;\n      forwarded.add(kind);\n      try {\n        process.kill(-process.pid, kind);\n      } catch {\n        // The group has already exited.\n      }\n    });\n  }\n}\n\n/** How long one `taskkill` may take, and how many times it is tried before the tree is given up on. */\nconst TASKKILL_TIMEOUT_MS = 10_000;\nconst TASKKILL_ATTEMPTS = 3;\n\n/**\n * `taskkill /T /F` on the command's tree, retried until one of them actually runs. A single attempt\n * that fails or times out leaves the command's descendants running, and here there is nobody to\n * escalate afterwards: this process is about to exit and the runner it served is already gone.\n */\nasync function killCommandTree(pid: number): Promise<void> {\n  for (let attempt = 1; attempt <= TASKKILL_ATTEMPTS; attempt++) {\n    if (await runTaskkill(pid, TASKKILL_TIMEOUT_MS)) return;\n  }\n}\n\n/** The runner is gone: end the command's whole tree, then exit. */\nfunction endCommandTree(): void {\n  if (lifelineLost) return;\n  lifelineLost = true;\n  if (process.platform === 'win32') {\n    if (command.pid === undefined) process.exit(1);\n    // taskkill walks the tree from the command's root, which is still alive because this process\n    // holds it. Exit only when the tree kill is done: as a child of this process, it would die with\n    // it, taking the walks it had left undone with it.\n    void killCommandTree(command.pid).finally(() => process.exit(1));\n    return;\n  }\n  // This process leads the command's process group, and the group signal below reaches it too. Its\n  // own SIGTERM is already spared, by the forwarding handler above returning now that the lifeline\n  // is lost; that is what lets the escalation below run, and it is why nothing else has to spare it\n  // a second time.\n  try {\n    process.kill(-process.pid, 'SIGTERM');\n  } catch {\n    // The group has already exited.\n  }\n  // The group includes this process, so waitForProcessGroupExit could never report it empty:\n  // escalate on the grace alone. SIGKILL ends this process too.\n  setTimeout(() => {\n    try {\n      process.kill(-process.pid, 'SIGKILL');\n    } catch {\n      // The group has already exited.\n    }\n    process.exit(1);\n  }, TERMINATE_GRACE_MS);\n}\n\nprocess.stdin.on('end', endCommandTree);\nprocess.stdin.on('error', endCommandTree);\nprocess.stdin.resume();\n"],"mappings":"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","names":[]}

package/dist/loader-S77OVTHH.js

@@ -0,0 +1,18 @@
+import {
+  discoverCommands,
+  generateCommandListing,
+  resolveCommandBody
+} from "./chunk-EFJ2NH6E.js";
+import "./chunk-KXAYUIKP.js";
+import "./chunk-HQI7NYGX.js";
+import "./chunk-2AAOF5B5.js";
+import "./chunk-XHAO3K7I.js";
+import "./chunk-VPNLCMVR.js";
+import "./chunk-X4NJT436.js";
+import "./chunk-ZPSZZUWF.js";
+export {
+  discoverCommands,
+  generateCommandListing,
+  resolveCommandBody
+};
+//# sourceMappingURL=loader-S77OVTHH.js.map