machine-bridge-mcp 1.2.6 → 1.2.8

package/src/local/managed-jobs.mjs

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants as fsConstants, existsSync, ftruncateSync, lstatSync, readSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertStateMaintenanceAvailable, ensureOwnerOnlyDir, ownerOnlyFile } from "./state.mjs";
 import { createExclusiveFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
@@ -12,6 +12,7 @@ import { BridgeError } from "./errors.mjs";
 import { inspectResourceFile, normalizeResourceRegistry, validatePlan } from "./managed-job-plan.mjs";
 export { inspectResourceFile, publicResourceRegistry, validateResourceName } from "./managed-job-plan.mjs";
 import { clampInteger } from "./numbers.mjs";
+import { classifyOperationalError } from "./log.mjs";
 
 const JOB_ID = /^job_[A-Za-z0-9_-]{24,}$/;
 const MAX_JOBS = 50;
@@ -124,7 +125,7 @@ export class ManagedJobManager {
       status.cleanup_guarantee = "best-effort-finally-and-recovery";
       atomicWriteJson(statusFile, status, 256 * 1024);
       try {
-        launchRunner(dir);
+        launchRunner(dir, false, "", { logger: this.logger });
       } catch (error) {
         failRunnerLaunch(dir, status, error);
         throw error;
@@ -181,7 +182,7 @@ export class ManagedJobManager {
     atomicWriteJson(join(dir, "status.json"), status, 256 * 1024);
     if (launch) {
       try {
-        launchRunner(dir);
+        launchRunner(dir, false, "", { logger: this.logger });
       } catch (error) {
         failRunnerLaunch(dir, status, error);
         throw error;
@@ -356,7 +357,7 @@ export class ManagedJobManager {
         markRecoveryExhausted(dir, file, status, recoveryAttempts);
         return;
       }
-      const runnerPid = relaunchInterruptedJob(dir, file, status, recoveryAttempts, recoveryLock.token);
+      const runnerPid = relaunchInterruptedJob(dir, file, status, recoveryAttempts, recoveryLock.token, this.logger);
       recoveryLock.handoff(runnerPid);
       handedOff = true;
     } finally {
@@ -513,7 +514,7 @@ function markRecoveryExhausted(dir, statusFile, status, recoveryAttempts) {
   scrubFinishedPlan(dir, status);
 }
 
-function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recoveryToken) {
+function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recoveryToken, logger) {
   status.status = "interrupted";
   status.updated_at = new Date().toISOString();
   status.finished_at = status.updated_at;
@@ -522,7 +523,7 @@ function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recov
   atomicWriteJson(statusFile, status, 256 * 1024);
   rmSync(join(dir, "runtime"), { recursive: true, force: true });
   rmSync(join(dir, "runner.pid"), { force: true });
-  return launchRunner(dir, true, recoveryToken);
+  return launchRunner(dir, true, recoveryToken, { logger });
 }
 
 function acquireRecoveryLock(dir) {
@@ -634,7 +635,7 @@ function replacePrivateTextFile(file, content) {
   ownerOnlyFile(file);
 }
 
-function launchRunner(dir, recover = false, recoveryToken = "") {
+export function launchRunner(dir, recover = false, recoveryToken = "", options = {}) {
   const args = [RUNNER_PATH, "--job-dir", dir];
   if (recover) args.push("--recover");
   const stdoutFile = join(dir, "runner.out.log");
@@ -647,10 +648,12 @@ function launchRunner(dir, recover = false, recoveryToken = "") {
   try {
     stdoutFd = openPrivateAppendFile(stdoutFile);
     stderrFd = openPrivateAppendFile(stderrFile);
-    child = spawn(process.execPath, args, {
+    const spawnProcess = typeof options.spawnProcess === "function" ? options.spawnProcess : spawn;
+    child = spawnProcess(process.execPath, args, {
       detached: true,
       stdio: ["ignore", stdoutFd, stderrFd],
       windowsHide: true,
+      shell: false,
       env: recoveryToken ? { ...process.env, MBM_RECOVERY_LOCK_TOKEN: recoveryToken } : process.env,
     });
   } finally {
@@ -659,8 +662,18 @@ function launchRunner(dir, recover = false, recoveryToken = "") {
   }
   ownerOnlyFile(stdoutFile);
   ownerOnlyFile(stderrFile);
+  const logger = options.logger || console;
+  child.once?.("error", (error) => {
+    logger.error?.("managed job runner process reported an asynchronous failure", {
+      job_id: basename(dir),
+      recovery: recover,
+      error_class: classifyOperationalError(error),
+    });
+  });
+  const pid = Number(child.pid);
+  if (!Number.isInteger(pid) || pid <= 0) throw new Error("managed job runner did not receive a process id");
   child.unref();
-  return child.pid;
+  return pid;
 }
 
 

package/src/local/process-contract.mjs

@@ -0,0 +1,19 @@
+export const MAX_COMMAND_BYTES = 64 * 1024;
+export const MAX_ARGV_ITEMS = 256;
+
+export function validateArgv(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) {
+    throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
+  }
+  const argv = value.map((item) => {
+    if (typeof item !== "string" || item.includes("\0")) {
+      throw new Error("argv entries must be strings without NUL bytes");
+    }
+    return item;
+  });
+  if (!argv[0]) throw new Error("argv[0] must not be empty");
+  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) {
+    throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
+  }
+  return argv;
+}

package/src/local/process-execution.mjs

@@ -2,12 +2,13 @@ import { spawn } from "node:child_process";
 import { stat } from "node:fs/promises";
 import { BoundedOutput } from "./bounded-output.mjs";
 import { executionEnv, workspaceShellCommand } from "./shell.mjs";
-import { MAX_COMMAND_BYTES, terminateProcessTreeWithEscalation, validateArgv } from "./process-sessions.mjs";
+import { MAX_COMMAND_BYTES, validateArgv } from "./process-contract.mjs";
+import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { BridgeError } from "./errors.mjs";
 import { clampInteger } from "./numbers.mjs";
-
-const MAX_STDIN_BYTES = 1024 * 1024;
-const DEFAULT_OUTPUT_BYTES = 512 * 1024;
+import {
+  DEFAULT_PROCESS_OUTPUT_BYTES, MAX_PROCESS_STDIN_BYTES, MAX_PROCESS_TIMEOUT_SECONDS, MIN_PROCESS_TIMEOUT_SECONDS,
+} from "./execution-limits.mjs";
 
 function spawnDirectProcess(command, args, options) {
   // Keep the production child_process API call structurally separate from the
@@ -41,7 +42,7 @@ export class ProcessExecutionService {
     const argv = validateArgv(args.argv);
     const cwd = await this.resolveExistingPath(args.cwd || ".");
     if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "cwd is not a directory");
-    return this.run(argv[0], argv.slice(1), clampInteger(args.timeout_seconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+    return this.run(argv[0], argv.slice(1), clampInteger(args.timeout_seconds, 120, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS) * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context, cwd);
   }
 
   async runRegistered(args, context = {}) {
@@ -52,9 +53,9 @@ export class ProcessExecutionService {
     if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "registered command cwd is not a directory");
     const requested = args.timeout_seconds === undefined
       ? command.timeoutSeconds
-      : clampInteger(args.timeout_seconds, command.timeoutSeconds, 1, 600);
+      : clampInteger(args.timeout_seconds, command.timeoutSeconds, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS);
     const timeoutSeconds = Math.min(requested, command.timeoutSeconds);
-    const result = await this.run(argv[0], argv.slice(1), timeoutSeconds * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+    const result = await this.run(argv[0], argv.slice(1), timeoutSeconds * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context, cwd);
     return { name: command.name, cwd: this.displayPath(cwd), timeout_seconds: timeoutSeconds, ...result };
   }
 
@@ -69,16 +70,16 @@ export class ProcessExecutionService {
     if (command.includes("\0")) throw new BridgeError("invalid_request", "command contains a NUL byte");
     if (Buffer.byteLength(command) > MAX_COMMAND_BYTES) throw new BridgeError("limit_exceeded", `command exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
     const shell = workspaceShellCommand(command);
-    return this.run(shell.cmd, shell.args, clampInteger(timeoutSeconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context);
+    return this.run(shell.cmd, shell.args, clampInteger(timeoutSeconds, 120, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS) * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context);
   }
 
   terminateAll(signal = "SIGTERM", escalate = false) {
     this.processTracker.terminateAll(signal, escalate);
   }
 
-  async run(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_OUTPUT_BYTES, context = {}, cwd = this.workspace, stdin = null) {
+  async run(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_PROCESS_OUTPUT_BYTES, context = {}, cwd = this.workspace, stdin = null) {
     this.throwIfCancelled(context);
-    if (stdin !== null && Buffer.byteLength(String(stdin)) > MAX_STDIN_BYTES) {
+    if (stdin !== null && Buffer.byteLength(String(stdin)) > MAX_PROCESS_STDIN_BYTES) {
       throw new BridgeError("limit_exceeded", "process stdin exceeds 1 MiB");
     }
 

package/src/local/process-sessions.mjs

@@ -2,16 +2,14 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { executionEnv } from "./shell.mjs";
+import { validateArgv } from "./process-contract.mjs";
+import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { createToolAuthorizer } from "./policy.mjs";
 import { createMonotonicDeadline } from "./monotonic-deadline.mjs";
 import { clampInteger } from "./numbers.mjs";
-
-export const MAX_COMMAND_BYTES = 64 * 1024;
-const MAX_ARGV_ITEMS = 256;
-const MAX_PROCESS_SESSIONS = 8;
-const MAX_SESSION_OUTPUT_BYTES = 1024 * 1024;
-const MAX_PROCESS_STDIN_BYTES = 64 * 1024;
-const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
+import {
+  MAX_PROCESS_SESSIONS, MAX_PROCESS_SESSION_OUTPUT_BYTES, MAX_PROCESS_SESSION_STDIN_BYTES, PROCESS_SESSION_RETENTION_MS,
+} from "./execution-limits.mjs";
 
 export class ProcessSessionManager {
   constructor({ workspace, policy, authorizeTool = null, runtimeDir, processTracker, resolveCwd, displayPath, throwIfCancelled }) {
@@ -70,6 +68,7 @@ export class ProcessSessionManager {
       signal: null,
       stdinClosed: false,
       waiters: new Set(),
+      terminationTimer: null,
     };
     this.sessions.set(session.id, session);
     this.trackChild(child, context.callId);
@@ -94,6 +93,11 @@ export class ProcessSessionManager {
       notifySessionWaiters(session);
     });
 
+    child.on("error", (error) => {
+      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
     try {
       await waitForSpawn(child);
     } catch (error) {
@@ -101,12 +105,6 @@ export class ProcessSessionManager {
       this.untrackChild(child);
       throw error;
     }
-
-    child.on("error", (error) => {
-      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
-      session.lastActivity = Date.now();
-      notifySessionWaiters(session);
-    });
     this.throwIfCancelled(context);
     return this.summary(session);
   }
@@ -144,7 +142,7 @@ export class ProcessSessionManager {
     const session = this.get(args.session_id);
     if (session.closedAt !== null) throw new Error("process session has already exited");
     const data = String(args.data ?? "");
-    if (Buffer.byteLength(data) > MAX_PROCESS_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_STDIN_BYTES} bytes)`);
+    if (Buffer.byteLength(data) > MAX_PROCESS_SESSION_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_SESSION_STDIN_BYTES} bytes)`);
     if (session.stdinClosed || session.child.stdin.destroyed) throw new Error("process session stdin is closed");
     this.throwIfCancelled(context);
     if (data) {
@@ -165,9 +163,18 @@ export class ProcessSessionManager {
     const session = this.get(args.session_id);
     this.throwIfCancelled(context);
     const wasRunning = session.closedAt === null;
-    if (wasRunning) terminateProcessTree(session.child, args.force === true ? "SIGKILL" : "SIGTERM");
+    const force = args.force === true;
+    if (wasRunning && force) terminateProcessTree(session.child, "SIGKILL");
+    else if (wasRunning && !session.terminationTimer) {
+      session.terminationTimer = terminateProcessTreeWithEscalation(session.child);
+    }
     session.lastActivity = Date.now();
-    return { ...this.summary(session), termination_requested: wasRunning, force: args.force === true };
+    return {
+      ...this.summary(session),
+      termination_requested: wasRunning,
+      force,
+      force_after_ms: wasRunning && !force ? 2000 : null,
+    };
   }
 
   get(sessionId) {
@@ -220,38 +227,6 @@ export class ProcessSessionManager {
   }
 }
 
-export function validateArgv(value) {
-  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
-  const argv = value.map((item) => {
-    if (typeof item !== "string" || item.includes("\0")) throw new Error("argv entries must be strings without NUL bytes");
-    return item;
-  });
-  if (!argv[0]) throw new Error("argv[0] must not be empty");
-  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
-  return argv;
-}
-
-export function terminateProcessTree(child, signal) {
-  if (!child?.pid) return;
-  if (process.platform === "win32") {
-    try {
-      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
-      killer.unref();
-      return;
-    } catch {}
-  }
-  try { process.kill(-child.pid, signal); } catch {
-    try { child.kill(signal); } catch {}
-  }
-}
-
-export function terminateProcessTreeWithEscalation(child, options = {}) {
-  const graceMs = Number.isFinite(Number(options.graceMs)) ? Math.max(0, Number(options.graceMs)) : 2000;
-  const schedule = typeof options.setTimeout === "function" ? options.setTimeout : setTimeout;
-  terminateProcessTree(child, "SIGTERM");
-  return schedule(() => terminateProcessTree(child, "SIGKILL"), graceMs);
-}
-
 function waitForSpawn(child) {
   return new Promise((resolvePromise, rejectPromise) => {
     const onSpawn = () => { cleanup(); resolvePromise(); };
@@ -273,8 +248,8 @@ function appendSessionStream(stream, chunk) {
   const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ""));
   stream.totalBytes += input.length;
   let combined = stream.buffer.length ? Buffer.concat([stream.buffer, input]) : Buffer.from(input);
-  if (combined.length > MAX_SESSION_OUTPUT_BYTES) {
-    const dropped = combined.length - MAX_SESSION_OUTPUT_BYTES;
+  if (combined.length > MAX_PROCESS_SESSION_OUTPUT_BYTES) {
+    const dropped = combined.length - MAX_PROCESS_SESSION_OUTPUT_BYTES;
     combined = combined.subarray(dropped);
     stream.baseOffset += dropped;
   }

package/src/local/process-tracker.mjs

@@ -1,4 +1,4 @@
-import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-sessions.mjs";
+import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 
 export class ProcessTracker {
   constructor(options = {}) {

package/src/local/process-tree.mjs

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+
+export const DEFAULT_PROCESS_TERMINATION_GRACE_MS = 2000;
+
+export function terminateProcessTree(child, signal = "SIGTERM", options = {}) {
+  if (!child?.pid) return false;
+  const platform = options.platform || process.platform;
+  if (platform === "win32") {
+    try {
+      const spawnProcess = typeof options.spawnProcess === "function" ? options.spawnProcess : spawn;
+      const force = signal === "SIGKILL";
+      const killer = spawnProcess("taskkill.exe", ["/PID", String(child.pid), "/T", ...(force ? ["/F"] : [])], {
+        stdio: "ignore",
+        windowsHide: true,
+        shell: false,
+      });
+      const fallback = () => {
+        try { child.kill(signal); } catch {}
+      };
+      killer?.once?.("error", fallback);
+      killer?.once?.("exit", (code) => { if (code !== 0) fallback(); });
+      killer?.unref?.();
+      return true;
+    } catch {
+      // Fall through to ChildProcess.kill for environments without taskkill.
+    }
+  }
+
+  const killProcess = typeof options.killProcess === "function" ? options.killProcess : process.kill.bind(process);
+  try {
+    killProcess(-child.pid, signal);
+    return true;
+  } catch {
+    try {
+      return child.kill(signal) !== false;
+    } catch {
+      return false;
+    }
+  }
+}
+
+export function terminateProcessTreeWithEscalation(child, options = {}) {
+  const graceMs = Number.isFinite(Number(options.graceMs))
+    ? Math.max(0, Number(options.graceMs))
+    : DEFAULT_PROCESS_TERMINATION_GRACE_MS;
+  const schedule = typeof options.setTimeout === "function" ? options.setTimeout : setTimeout;
+  const terminate = typeof options.terminate === "function" ? options.terminate : terminateProcessTree;
+  terminate(child, "SIGTERM", options);
+  return schedule(() => {
+    terminate(child, "SIGKILL", options);
+    options.onEscalated?.();
+  }, graceMs);
+}

package/src/local/runtime-reporting.mjs

@@ -3,6 +3,7 @@ import {
   allToolNames, isCanonicalFullPolicy, MCP_PROTOCOL_VERSION, MCP_SUPPORTED_PROTOCOL_VERSIONS,
   POLICY_PROFILES, SERVER_NAME,
 } from "./tools.mjs";
+import { executionGuardrailsSnapshot } from "./execution-limits.mjs";
 
 export function buildRuntimeInfo({
   workspace,
@@ -47,7 +48,7 @@ export function buildRuntimeInfo({
     },
     tools: ["server_info", ...toolNames],
     observability: {
-      relay_readiness: "authenticated-hello-acknowledged",
+      relay_readiness: "end-to-end-relay-probe-verified",
       brief_relay_interruptions: "debug-only",
       raw_transport_details: "debug-only",
       per_tool_events: "structured-debug-events",
@@ -63,6 +64,7 @@ export function buildRuntimeInfo({
       relay: relayStatus(),
       runtime_dir: policy.exposeAbsolutePaths ? runtimeDir : "<private-runtime-dir>",
       processes: processTracker.snapshot(),
+      execution_guardrails: executionGuardrailsSnapshot(),
       process_sessions: processSessionManager.status(),
       managed_jobs: managedJobManager.status(),
       local_resources: managedJobManager.resourceInfo(),

package/src/local/runtime.mjs

@@ -4,7 +4,8 @@ import { tmpdir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { isRelayReadyContext, RelayConnection } from "./relay-connection.mjs";
 import { ProcessSessionManager } from "./process-sessions.mjs";
-export { MAX_COMMAND_BYTES } from "./process-sessions.mjs";
+import { MAX_CONCURRENT_TOOL_CALLS } from "./execution-limits.mjs";
+export { MAX_COMMAND_BYTES } from "./process-contract.mjs";
 import { MCP_SUPPORTED_PROTOCOL_VERSIONS, normalizePolicy, PolicyGate, SERVER_NAME } from "./tools.mjs";
 import { publicError } from "./errors.mjs";
 import { ProcessTracker } from "./process-tracker.mjs";
@@ -36,7 +37,6 @@ import {
 } from "./runtime-capabilities.mjs";
 
 const MAX_WS_MESSAGE_BYTES = 8 * 1024 * 1024;
-const MAX_CONCURRENT_TOOL_CALLS = 16;
 const SLOW_TOOL_CALL_MS = 30_000;
 
 const RUNTIME_TOOL_HANDLERS = Object.freeze({
@@ -212,6 +212,7 @@ export class LocalRuntime {
       readResourceText,
       readResourceBinary,
       throwIfCancelled: (context) => this.throwIfCancelled(context),
+      logger: this.logger,
     });
     this.toolExecutor = new ToolExecutor({
       handlers: Object.fromEntries(Object.entries(RUNTIME_TOOL_HANDLERS).map(([name, handler]) => [
@@ -234,9 +235,7 @@ export class LocalRuntime {
     });
   }
 
-  tools() {
-    return this.policyGate.names().filter((name) => name !== "server_info");
-  }
+  tools() { return this.policyGate.names().filter((name) => name !== "server_info"); }
 
   runtimeInfo() {
     return buildRuntimeInfo({

package/src/local/shell.mjs

@@ -3,6 +3,7 @@ import { existsSync } from "node:fs";
 import path from "node:path";
 import { packageRoot } from "./state.mjs";
 import { BoundedOutput } from "./bounded-output.mjs";
+import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 
 export function runExecutable(command, args = [], options = {}) {
   const executable = validateExecutable(command);
@@ -28,8 +29,7 @@ export function runExecutable(command, args = [], options = {}) {
     if (Number.isFinite(timeoutMs) && timeoutMs > 0) {
       timer = setTimeout(() => {
         timedOut = true;
-        terminateCommandTree(child, false);
-        killTimer = setTimeout(() => terminateCommandTree(child, true), 2000);
+        killTimer = terminateProcessTreeWithEscalation(child);
       }, timeoutMs);
       timer.unref?.();
     }
@@ -84,23 +84,6 @@ function validateExecutableArgs(value) {
   });
 }
 
-function terminateCommandTree(child, force) {
-  if (!child?.pid) return;
-  if (process.platform === "win32") {
-    try {
-      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", ...(force ? ["/F"] : [])], {
-        stdio: "ignore",
-        windowsHide: true,
-      });
-      killer.unref();
-      return;
-    } catch {}
-  }
-  const signal = force ? "SIGKILL" : "SIGTERM";
-  try { process.kill(-child.pid, signal); } catch {
-    try { child.kill(signal); } catch {}
-  }
-}
 
 function capturedResult(code, stdout, stderr, extraStderr = "") {
   const stderrText = [stderr.text(), extraStderr].filter(Boolean).join("\n");

package/src/worker/index.ts

@@ -27,7 +27,7 @@ import {
 } from "./http.ts";
 
 const SERVER_NAME = String(serverMetadata.name);
-const SERVER_VERSION = "1.2.6";
+const SERVER_VERSION = "1.2.8";
 const MCP_PROTOCOL_VERSION = String(serverMetadata.protocolVersion);
 const MCP_SUPPORTED_PROTOCOL_VERSIONS = serverMetadata.supportedProtocolVersions.map((value) => String(value));
 const JSONRPC_VERSION = "2.0";