stitchkit 0.103.9 → 0.103.11

package/dist/{index-a4ajxwmb.js → index-g4jxe7ve.js}

@@ -2,6 +2,11 @@ import {
   forbidden2,
   conflict2
 } from "./index-n53mswt3.js";
+import {
+  NativeCommandError2,
+  stopCommandGroup,
+  startNativeCommand
+} from "./index-32jkwkdm.js";
 import {
   probeAgentProcessSandbox2,
   missingSandboxRestrictions2,
@@ -981,7 +986,6 @@ function createSearchAndPatchCodingTools(config, limits) {
 import { realpath as realpath5, stat } from "node:fs/promises";
 
 // src/agent-runtime/coding-shell-process.ts
-import { spawn } from "node:child_process";
 function preview(data, budget) {
   if (data.byteLength <= budget) {
     return { data, headBytes: data.byteLength, tailBytes: 0, omittedBytes: 0 };
@@ -1024,140 +1028,118 @@ async function runCodingShell(input) {
       outcome: "cancelled"
     });
   }
-  return await new Promise((resolve, reject) => {
-    const ownsProcessGroup = process.platform !== "win32";
-    const child = input.spawn ? input.spawn() : spawn(input.executable, input.args, {
-      cwd: input.cwd,
-      env: input.environment,
-      stdio: ["ignore", "pipe", "pipe"],
-      detached: ownsProcessGroup
-    });
-    const stdout = [];
-    const stderr = [];
-    const artifactStdout = [];
-    const artifactStderr = [];
-    let retained = 0;
-    let artifactBytes = 0;
-    let outcome = "exited";
-    let settled = false;
-    let settlementTimer;
-    const cancel = () => terminate("cancelled");
-    const cleanup = () => {
-      clearTimeout(timer);
-      if (settlementTimer)
-        clearTimeout(settlementTimer);
-      input.signal?.removeEventListener("abort", cancel);
-    };
-    const persistAndResolve = async (exitCode, signal) => {
-      if (settled)
-        return;
-      settled = true;
-      cleanup();
-      try {
-        const hasArtifact = input.artifacts && artifactBytes > input.maxOutputBytes;
-        const completeStdout = Buffer.concat(artifactStdout);
-        const completeStderr = Buffer.concat(artifactStderr);
-        const artifactData = hasArtifact ? Buffer.concat([stdoutHeader, completeStdout, stderrHeader, completeStderr]) : undefined;
-        const stdoutBudget = completeStderr.byteLength === 0 ? input.maxOutputBytes : Math.ceil(input.maxOutputBytes / 2);
-        const stderrBudget = completeStdout.byteLength === 0 ? input.maxOutputBytes : Math.floor(input.maxOutputBytes / 2);
-        const stdoutPreview = hasArtifact ? preview(completeStdout, stdoutBudget) : retainedPreview(Buffer.concat(stdout));
-        const stderrPreview = hasArtifact ? preview(completeStderr, stderrBudget) : retainedPreview(Buffer.concat(stderr));
-        const persisted = hasArtifact ? await input.artifacts?.write({
-          mediaType: "text/plain; charset=utf-8",
-          data: artifactData ?? new Uint8Array,
-          ...input.authorization && { authorization: input.authorization }
-        }) : undefined;
-        resolve(ShellOutputSchema.parse({
-          executable: input.executableName,
-          exitCode,
-          signal,
-          stdout: stdoutPreview.data.toString("utf8"),
-          stderr: stderrPreview.data.toString("utf8"),
-          outcome,
-          ...persisted && {
-            artifact: {
-              reference: persisted.reference,
-              bytes: artifactData?.byteLength ?? 0,
-              truncated: outcome === "output-limit",
-              headBytes: stdoutPreview.headBytes + stderrPreview.headBytes,
-              tailBytes: stdoutPreview.tailBytes + stderrPreview.tailBytes,
-              omittedBytes: stdoutPreview.omittedBytes + stderrPreview.omittedBytes
-            }
-          }
-        }));
-      } catch (error) {
-        reject(error);
-      }
-    };
-    const killOwnedProcessGroup = () => {
-      if (!ownsProcessGroup || child.pid === undefined)
-        return false;
-      try {
-        process.kill(-child.pid, "SIGKILL");
-        return true;
-      } catch {
-        return false;
+  const stdout = [];
+  const stderr = [];
+  const artifactStdout = [];
+  const artifactStderr = [];
+  let retained = 0;
+  let artifactBytes = 0;
+  let outcome = "exited";
+  let child;
+  let exitCode = null;
+  let signal = null;
+  const outputLimit = new Error("Coding command output retention budget exceeded");
+  const launch = input.spawn;
+  const retain = (target, artifactTarget, chunk) => {
+    const remaining = Math.max(0, input.maxOutputBytes - retained);
+    if (remaining > 0) {
+      const kept = Buffer.from(chunk.subarray(0, remaining));
+      target.push(kept);
+      retained += kept.byteLength;
+    }
+    if (input.artifacts) {
+      const artifactRemaining = Math.max(0, artifactPayloadLimit - artifactBytes);
+      if (artifactRemaining > 0) {
+        const kept = Buffer.from(chunk.subarray(0, artifactRemaining));
+        artifactTarget.push(kept);
+        artifactBytes += kept.byteLength;
       }
-    };
-    const boundStreamSettlement = () => {
-      if (settlementTimer)
-        return;
-      settlementTimer = setTimeout(() => {
-        child.stdout.destroy();
-        child.stderr.destroy();
-        persistAndResolve(child.exitCode, child.signalCode);
-      }, input.terminationGraceMs);
-    };
-    const terminate = (reason) => {
-      if (settled || outcome !== "exited")
+      if (chunk.byteLength > artifactRemaining)
+        throw outputLimit;
+    } else if (chunk.byteLength > remaining)
+      throw outputLimit;
+  };
+  const command = startNativeCommand({
+    executable: input.executable,
+    args: [...input.args],
+    cwd: input.cwd,
+    env: { ...input.environment },
+    envPolicy: "declared-only",
+    signal: input.signal ?? new AbortController().signal,
+    killGraceMs: 0,
+    onOutput: (bytes, channel) => retain(channel === "stdout" ? stdout : stderr, channel === "stdout" ? artifactStdout : artifactStderr, bytes),
+    onLeaderSettled: async (event) => {
+      if (event.kind !== "exit")
         return;
-      outcome = reason;
-      if (!killOwnedProcessGroup())
-        child.kill("SIGKILL");
-      boundStreamSettlement();
-    };
-    const timer = setTimeout(() => terminate("timeout"), input.timeoutMs);
-    timer.unref();
-    const retain = (target, artifactTarget, chunk) => {
-      const remaining = Math.max(0, input.maxOutputBytes - retained);
-      if (remaining > 0) {
-        const kept = chunk.subarray(0, remaining);
-        target.push(kept);
-        retained += kept.byteLength;
+      exitCode = event.exitCode;
+      signal = event.signal;
+      if (process.platform !== "win32")
+        await stopCommandGroup(child?.pid, 0, input.terminationGraceMs, true);
+    }
+  }, (started) => {
+    child = started;
+  }, {
+    group: process.platform !== "win32",
+    force: true,
+    timeoutMs: input.timeoutMs,
+    cleanupTimeoutMs: input.terminationGraceMs,
+    closeTimeoutMs: input.terminationGraceMs,
+    ...launch ? {
+      launch: () => {
+        child = launch();
+        return child;
       }
-      if (input.artifacts) {
-        const artifactRemaining = Math.max(0, artifactPayloadLimit - artifactBytes);
-        if (artifactRemaining > 0) {
-          const kept = chunk.subarray(0, artifactRemaining);
-          artifactTarget.push(kept);
-          artifactBytes += kept.byteLength;
-        }
-        if (chunk.byteLength > artifactRemaining)
-          terminate("output-limit");
-      } else if (chunk.byteLength > remaining)
-        terminate("output-limit");
-    };
-    child.stdout.on("data", (chunk) => retain(stdout, artifactStdout, Buffer.from(chunk)));
-    child.stderr.on("data", (chunk) => retain(stderr, artifactStderr, Buffer.from(chunk)));
-    child.on("error", (error) => {
-      if (settled)
-        return;
-      settled = true;
-      cleanup();
-      reject(error);
-    });
-    child.on("exit", (exitCode, signal) => {
-      if (outcome === "exited")
-        killOwnedProcessGroup();
-      boundStreamSettlement();
-      if (child.stdout.destroyed && child.stderr.destroyed) {
-        persistAndResolve(exitCode, signal);
+    } : {},
+    maxBufferedBytes: Math.max(64 * 1024, input.maxOutputBytes, input.artifacts ? artifactPayloadLimit : 0)
+  });
+  try {
+    const result = await command.result;
+    exitCode = result.exitCode;
+    signal = result.signal;
+  } catch (error) {
+    if (error === outputLimit)
+      outcome = "output-limit";
+    else if (input.signal?.aborted && error === input.signal.reason)
+      outcome = "cancelled";
+    else if (error instanceof NativeCommandError2 && error.code === "COMMAND_LIMIT" && (error.reason === "deadline" || error.reason === "output-budget"))
+      outcome = error.reason === "deadline" ? "timeout" : "output-limit";
+    else if (error instanceof DOMException && error.name === "AbortError" && error.message === "Command stopped")
+      outcome = "cancelled";
+    else
+      throw error;
+    exitCode = child?.exitCode ?? exitCode;
+    signal = child?.signalCode ?? signal;
+  }
+  const hasArtifact = input.artifacts && artifactBytes > input.maxOutputBytes;
+  const completeStdout = Buffer.concat(artifactStdout);
+  const completeStderr = Buffer.concat(artifactStderr);
+  const artifactData = hasArtifact ? Buffer.concat([stdoutHeader, completeStdout, stderrHeader, completeStderr]) : undefined;
+  const stdoutBudget = completeStderr.byteLength === 0 ? input.maxOutputBytes : Math.ceil(input.maxOutputBytes / 2);
+  const stderrBudget = completeStdout.byteLength === 0 ? input.maxOutputBytes : Math.floor(input.maxOutputBytes / 2);
+  const stdoutPreview = hasArtifact ? preview(completeStdout, stdoutBudget) : retainedPreview(Buffer.concat(stdout));
+  const stderrPreview = hasArtifact ? preview(completeStderr, stderrBudget) : retainedPreview(Buffer.concat(stderr));
+  const persisted = hasArtifact ? await input.artifacts?.write({
+    mediaType: "text/plain; charset=utf-8",
+    data: artifactData ?? new Uint8Array,
+    ...input.authorization && { authorization: input.authorization }
+  }) : undefined;
+  return ShellOutputSchema.parse({
+    executable: input.executableName,
+    exitCode,
+    signal,
+    stdout: stdoutPreview.data.toString("utf8"),
+    stderr: stderrPreview.data.toString("utf8"),
+    outcome,
+    ...persisted && {
+      artifact: {
+        reference: persisted.reference,
+        bytes: artifactData?.byteLength ?? 0,
+        truncated: outcome === "output-limit",
+        headBytes: stdoutPreview.headBytes + stderrPreview.headBytes,
+        tailBytes: stdoutPreview.tailBytes + stderrPreview.tailBytes,
+        omittedBytes: stdoutPreview.omittedBytes + stderrPreview.omittedBytes
       }
-    });
-    child.on("close", (exitCode, signal) => void persistAndResolve(exitCode, signal));
-    input.signal?.addEventListener("abort", cancel, { once: true });
-    if (input.signal?.aborted)
-      cancel();
+    }
   });
 }
 

package/dist/index-nybn2err.js

@@ -0,0 +1,213 @@
+import {
+  loadDarwinBinding
+} from "./index-d4pa2bgs.js";
+import {
+  isRecord
+} from "./index-9jfdm5tg.js";
+
+// src/internal/process-instance.ts
+import { readFile as readFile2, readlink } from "node:fs/promises";
+import { platform as platform2 } from "node:os";
+import { z } from "zod";
+
+// src/internal/process-identity.ts
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { platform } from "node:os";
+import { promisify } from "node:util";
+var detectedIdentity;
+async function firstReadableLine(paths) {
+  for (const path of paths) {
+    try {
+      const text = (await readFile(path, "utf8")).trim();
+      if (text.length > 0)
+        return text;
+    } catch {}
+  }
+  return null;
+}
+var run = promisify(execFile);
+function parsePlatformUuid(dump) {
+  return /"IOPlatformUUID"\s*=\s*"([^"]+)"/.exec(dump)?.[1] ?? null;
+}
+async function readDarwinPlatformUuid(command = "ioreg") {
+  try {
+    const { stdout } = await run(command, ["-rd1", "-c", "IOPlatformExpertDevice"], {
+      timeout: 2000,
+      maxBuffer: 1 << 20,
+      encoding: "utf8"
+    });
+    return parsePlatformUuid(stdout);
+  } catch {
+    return null;
+  }
+}
+async function machineIdentity(declared) {
+  if (declared !== undefined)
+    return declared;
+  if (detectedIdentity !== undefined)
+    return detectedIdentity;
+  detectedIdentity = platform() === "darwin" ? await readDarwinPlatformUuid() : await firstReadableLine(["/etc/machine-id", "/var/lib/dbus/machine-id"]);
+  return detectedIdentity;
+}
+async function probeLiveness(pid, reach = (target) => process.kill(target, 0)) {
+  try {
+    reach(pid);
+  } catch (error) {
+    return isRecord(error) && error.code === "ESRCH" ? "gone" : "alive";
+  }
+  return await isZombieProcess(pid) ? "gone" : "alive";
+}
+async function isZombieProcess(pid, seam = {}) {
+  const { procRoot = "/proc", psCommand = "ps" } = seam;
+  try {
+    const stat = await readFile(`${procRoot}/${pid}/stat`, "utf8");
+    return stat.slice(stat.lastIndexOf(")") + 1).trimStart().startsWith("Z");
+  } catch {}
+  try {
+    const { stdout } = await run(psCommand, ["-o", "state=", "-p", String(pid)], {
+      timeout: 2000,
+      maxBuffer: 1 << 16,
+      encoding: "utf8"
+    });
+    return stdout.trim().startsWith("Z");
+  } catch {
+    return false;
+  }
+}
+
+// src/internal/process-instance.ts
+var ProcessInstanceSchema2 = z.object({
+  platform: z.enum(["linux", "darwin"]),
+  bootId: z.string().min(1),
+  namespace: z.string().min(1),
+  startId: z.string().regex(/^\d+$/)
+}).strict();
+var ProcessInstanceObservationSchema = z.discriminatedUnion("state", [
+  z.object({ state: z.literal("observed"), instance: ProcessInstanceSchema2 }),
+  z.object({ state: z.literal("unavailable"), cause: z.unknown() })
+]);
+async function observeProcessInstance2(pid) {
+  z.number().int().positive().max(2147483647).parse(pid);
+  return observeProcessInstanceAt(pid, "/proc");
+}
+function linuxProcessStart(stat, pid) {
+  if (!stat.startsWith(`${pid} (`))
+    return null;
+  const end = stat.lastIndexOf(")");
+  if (end < 0)
+    return null;
+  const start = stat.slice(end + 1).trim().split(/\s+/)[19];
+  return start !== undefined && /^\d+$/.test(start) ? start : null;
+}
+async function readProcessInstance(pid, procRoot = "/proc") {
+  const result = await observeProcessInstanceAt(pid, procRoot);
+  return result.state === "observed" ? result.instance : null;
+}
+async function observeProcessInstanceAt(pid, procRoot) {
+  try {
+    if (platform2() === "darwin") {
+      return {
+        state: "observed",
+        instance: ProcessInstanceSchema2.parse(loadDarwinBinding().processIdentity(pid))
+      };
+    }
+    if (platform2() !== "linux")
+      throw new Error("Process lifetime observation requires Linux or Darwin");
+    const [bootId, namespace, ownStatus, timeNamespace, ownStat, stat] = await Promise.all([
+      readFile2(`${procRoot}/sys/kernel/random/boot_id`, "utf8"),
+      readlink(`${procRoot}/self/ns/pid`),
+      readFile2(`${procRoot}/self/status`, "utf8"),
+      readlink(`${procRoot}/self/ns/time`).catch((error) => {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+          return "";
+        throw error;
+      }),
+      readFile2(`${procRoot}/self/stat`, "utf8"),
+      readFile2(`${procRoot}/${pid}/stat`, "utf8")
+    ]);
+    const namespacePids = ownStatus.match(/^NStgid:[ \t]*(.*)$/m)?.[1]?.trim().split(/\s+/);
+    if (namespacePids?.length !== 1 || namespacePids[0] !== String(process.pid) || linuxProcessStart(ownStat, process.pid) === null)
+      throw new Error("Process namespace evidence is partial or belongs to a foreign proc mount");
+    const startId = linuxProcessStart(stat, pid);
+    if (startId === null || !bootId.trim())
+      throw new Error("Process boot/start evidence is incomplete");
+    return {
+      state: "observed",
+      instance: {
+        platform: "linux",
+        bootId: bootId.trim(),
+        namespace: `${namespace};${timeNamespace}`,
+        startId
+      }
+    };
+  } catch (cause) {
+    return { state: "unavailable", cause };
+  }
+}
+var ProcessOwnerEvidenceSchema = z.object({
+  liveness: z.enum(["alive", "gone", "not-probed"]),
+  identity: z.enum([
+    "matched",
+    "different-boot",
+    "reused-pid",
+    "pid-gone",
+    "legacy",
+    "unavailable"
+  ]),
+  cause: z.unknown().optional()
+});
+async function probeProcessOwner2(pid, recorded) {
+  z.number().int().positive().max(2147483647).parse(pid);
+  if (recorded != null)
+    ProcessInstanceSchema2.parse(recorded);
+  return probeProcessOwnerWith(pid, recorded, {
+    read: readProcessInstance,
+    observe: observeProcessInstance2,
+    liveness: probeLiveness
+  });
+}
+async function probeProcessOwnerWith(pid, recorded, probes = { read: readProcessInstance, liveness: probeLiveness }) {
+  if (recorded === undefined)
+    return { liveness: await probes.liveness(pid), identity: "legacy" };
+  const unavailable = (cause) => ({
+    liveness: "not-probed",
+    identity: "unavailable",
+    cause
+  });
+  if (recorded === null)
+    return unavailable(new Error("Recorded process lifetime is unavailable"));
+  const observe = async (target) => {
+    if (probes.observe)
+      return probes.observe(target);
+    const instance = await probes.read(target);
+    return instance ? { state: "observed", instance } : {
+      state: "unavailable",
+      cause: new Error("Process lifetime reader returned no evidence")
+    };
+  };
+  const own = await observe(process.pid);
+  if (own.state === "unavailable")
+    return unavailable(own.cause);
+  const current = own.instance;
+  if (recorded.platform !== current.platform)
+    return unavailable(new Error("Process platforms differ"));
+  if (recorded.bootId !== current.bootId)
+    return { liveness: "gone", identity: "different-boot" };
+  if (recorded.namespace !== current.namespace)
+    return unavailable(new Error("Process namespaces differ"));
+  const liveness = await probes.liveness(pid);
+  if (liveness === "gone")
+    return { liveness, identity: "pid-gone" };
+  const observation = await observe(pid);
+  if (observation.state === "unavailable")
+    return unavailable(observation.cause);
+  const observed = observation.instance;
+  if (!observed || observed.bootId !== current.bootId || observed.namespace !== current.namespace)
+    return unavailable(new Error("Observed boot or namespace changed during probe"));
+  if (recorded.startId !== observed.startId)
+    return { liveness: "gone", identity: "reused-pid" };
+  return { liveness: "alive", identity: "matched" };
+}
+
+export { machineIdentity, ProcessInstanceSchema2, observeProcessInstance2, readProcessInstance, probeProcessOwner2 };