tamperward 2.29.13 → 2.29.15

package/dist/cli/index.js

@@ -14640,6 +14640,7 @@ function parseCapturedSupervisorResult(stdoutText) {
     signal: typeof raw.signal === "string" ? raw.signal : null,
     timedOut: Boolean(raw.timedOut),
     ...typeof raw.error === "string" && raw.error ? { error: raw.error } : {},
+    ...raw.pipeHeldOpen === true ? { pipeHeldOpen: true } : {},
     diagnostics
   };
 }
@@ -14657,6 +14658,7 @@ function runCapturedProcessSync(executable, args, opts) {
         timeoutMs: opts.timeoutMs,
         detached: Boolean(opts.detached),
         killGroupOnFinish: Boolean(opts.killGroupOnFinish),
+        drainMs: opts.drainMs ?? 1e3,
         captureBytes: DIAGNOSTIC_TAIL_BYTES
       }),
       { mode: 384 }
@@ -14789,6 +14791,7 @@ let done = false;
 let timedOut = false;
 let exitInfo = { exit: null, signal: null };
 let descendantTracker = null;
+let drainTimer = null;
 
 function killOwned() {
   if (!child || !child.pid) return;
@@ -14810,6 +14813,7 @@ function finish(extra) {
   if (done) return;
   done = true;
   if (descendantTracker) clearInterval(descendantTracker);
+  if (drainTimer) clearTimeout(drainTimer);
   try {
     // stdout is reserved for the trusted supervisor result. Candidate suite
     // stdout/stderr are separate pipes and are never inherited here.
@@ -14864,12 +14868,19 @@ if (child) {
       signal: signal == null ? null : String(signal),
     };
     if (cfg.killGroupOnFinish) killOwned();
+    // A leaked descendant can hold a pipe open so 'close' never fires; finish off
+    // exit after a bounded drain instead of hanging. 'close' still wins if first.
+    if (!drainTimer) {
+      drainTimer = setTimeout(() => finish({ pipeHeldOpen: true }), Number(cfg.drainMs));
+      drainTimer.unref();
+    }
   });
 
   // close fires after the stdio pipes close, so the retained tails include all
   // output that was drained before owned descendants were terminated.
   child.on('close', (code, signal) => {
     clearTimeout(timer);
+    if (drainTimer) clearTimeout(drainTimer);
     if (exitInfo.exit === null && code != null) exitInfo.exit = Number(code);
     if (exitInfo.signal === null && signal != null) exitInfo.signal = String(signal);
     finish({});
@@ -15714,7 +15725,12 @@ function runLocalSuite(dir, cmd, budgetSecs) {
         diagnostics: r.diagnostics
       };
     }
-    return { exit: r.exit, secs, diagnostics: r.diagnostics };
+    return {
+      exit: r.exit,
+      secs,
+      ...r.pipeHeldOpen ? { pipeHeldOpen: true } : {},
+      diagnostics: r.diagnostics
+    };
   } finally {
     rmSync7(scratch, { recursive: true, force: true });
   }
@@ -15873,7 +15889,29 @@ function runVerify(opts) {
   }
   const frozenNodeModules = dependencyEnvironment ? dependencyEnvironment.roots.find((root) => root.kind === "node_modules")?.realPath ?? null : null;
   const checkDeps = () => dependencyEnvironment ? checkDependencyEnvironment(cwd, dependencyEnvironment) : { ok: true };
-  const runStage = (dir) => isolated ? runContainerStage(verifierBackend, dir, cmd, budget) : runLocalSuite(dir, cmd, budget);
+  const runStage = opts.runStage ?? ((dir) => isolated ? runContainerStage(verifierBackend, dir, cmd, budget) : runLocalSuite(dir, cmd, budget));
+  const notQuiescent = (stage, r) => {
+    const detail = `the ${stage} suite exited (code ${r.exit ?? "unknown"}) but left a process holding stdout open after termination was attempted; the stage is not quiescent, so the run cannot be certified`;
+    opts.onVerdict?.({ verdict: "CANNOT_VERIFY", reason: "VERIFIER_BACKEND_RUNTIME_FAILURE", detail });
+    if (opts.json) {
+      out3(JSON.stringify({
+        schema_version: MACHINE_SCHEMA_VERSION,
+        verdict: "CANNOT_VERIFY",
+        reason: "VERIFIER_BACKEND_RUNTIME_FAILURE",
+        stage,
+        ...caseReport(),
+        detail,
+        diagnostics: diagnosticsJson(r.diagnostics, true),
+        verifier_backend: backendReport(),
+        oracle_assurance: oracleAssuranceReport()
+      }));
+    } else {
+      out3(`verify: the ${stage} suite exited but left a process holding stdout open \u2014 the stage is not quiescent, failing closed`);
+      out3("verify: " + detail);
+      renderStageDiagnostics(out3, stage, r);
+    }
+    return 2;
+  };
   let base;
   try {
     base = resolveBase(opts.base ?? "HEAD", cwd);
@@ -15933,6 +15971,10 @@ function runVerify(opts) {
     );
   }
   const visible = runStage(visDir);
+  if (visible.pipeHeldOpen) {
+    cleanup([visRoot]);
+    return notQuiescent("visible", visible);
+  }
   if (visible.failure === "backend" || visible.failure === "resource") {
     cleanup([visRoot]);
     const exhausted = visible.failure === "resource";
@@ -16002,6 +16044,10 @@ function runVerify(opts) {
   }
   const overlayBefore = overlayDigest(priDir, restored);
   const pristine = runStage(priDir);
+  if (pristine.pipeHeldOpen) {
+    cleanup([visRoot, priRoot]);
+    return notQuiescent("pristine", pristine);
+  }
   if (pristine.failure === "backend" || pristine.failure === "resource") {
     cleanup([visRoot, priRoot]);
     const exhausted = pristine.failure === "resource";
@@ -17883,6 +17929,22 @@ function parseStraceFileAccess(raw) {
   }
   return out3;
 }
+function tracerDenialDiagnostic(stderr) {
+  for (const raw of stderr.split("\n")) {
+    const line = raw.trim();
+    if (line.startsWith("strace:") && TRACER_DENIAL_RE.test(line)) return line;
+  }
+  return null;
+}
+function classifyTraceRun(r) {
+  if (r.spawnError) return { kind: "tracer-error", diagnostic: `strace could not be launched: ${r.spawnError}` };
+  const denial = tracerDenialDiagnostic(r.stderr);
+  if (denial) return { kind: "tracer-error", diagnostic: denial };
+  if (r.signal) return { kind: "tracer-error", diagnostic: `strace was killed by ${r.signal} before the trace completed` };
+  if (r.traceFileCount === 0) return { kind: "tracer-error", diagnostic: "strace produced no trace files; the tracer did not attach (ptrace may be denied)" };
+  if (r.accessCount === 0) return { kind: "tracer-error", diagnostic: "strace recorded no file syscalls; the tracer attached to nothing (ptrace may be denied)" };
+  return { kind: "ok", exit: r.status ?? 1 };
+}
 function inside3(root, path) {
   const rel = relative6(resolve11(root), resolve11(path));
   return rel === "" || rel !== ".." && !rel.startsWith(`..${sep4}`) && !isAbsolute12(rel);
@@ -18009,11 +18071,9 @@ function rewriteTraceRoot(accesses, actualRoot) {
     return { ...item, path: join22(TRACE_ROOT, ...rel.split("/")) };
   });
 }
-function runOneTrace(cwd, base, command, budget) {
-  const root = mkdtempSync5(join22(tmpdir6(), "tw-trace-base-"));
+function straceOnce(root, command, budget) {
   const traceDir = mkdtempSync5(join22(tmpdir6(), "tw-trace-log-"));
   try {
-    materializeBase(base, cwd, root);
     const prefix = join22(traceDir, "trace");
     const traced = spawnSync5(
       "strace",
@@ -18042,21 +18102,40 @@ function runOneTrace(cwd, base, command, budget) {
         maxBuffer: 64 * 1024 * 1024
       }
     );
-    if (traced.error) throw traced.error;
-    const logs = traceFiles(prefix);
-    if (logs.length === 0) {
-      throw new Error("strace produced no trace files");
-    }
+    const logs = traced.error ? [] : traceFiles(prefix);
     const accesses = logs.flatMap((path) => parseStraceFileAccess(readFileSync20(path, "utf8")));
-    return {
-      exit: traced.status ?? 1,
-      accesses: rewriteTraceRoot(accesses, root)
+    const raw = {
+      spawnError: traced.error ? traced.error.message : null,
+      status: traced.status,
+      signal: traced.signal ?? null,
+      stderr: String(traced.stderr ?? "").slice(0, 8192),
+      traceFileCount: logs.length,
+      accessCount: accesses.length
     };
+    return { raw, accesses };
   } finally {
-    rmSync9(root, { recursive: true, force: true });
     rmSync9(traceDir, { recursive: true, force: true });
   }
 }
+function runOneTrace(cwd, base, command, budget) {
+  const root = mkdtempSync5(join22(tmpdir6(), "tw-trace-base-"));
+  try {
+    materializeBase(base, cwd, root);
+    const { raw, accesses } = straceOnce(root, command, budget);
+    return { outcome: classifyTraceRun(raw), accesses: rewriteTraceRoot(accesses, root) };
+  } finally {
+    rmSync9(root, { recursive: true, force: true });
+  }
+}
+function tracerPreflight(budget = 10) {
+  const probeRoot = mkdtempSync5(join22(tmpdir6(), "tw-trace-probe-"));
+  try {
+    const { raw } = straceOnce(probeRoot, "true", Math.max(1, Math.min(budget, 10)));
+    return classifyTraceRun(raw);
+  } finally {
+    rmSync9(probeRoot, { recursive: true, force: true });
+  }
+}
 function renderText2(report2) {
   const out3 = (s = "") => void process.stdout.write(s + "\n");
   out3("tamperward trace-verify \u2014 ADVISORY observation, not an enforcement verdict");
@@ -18143,6 +18222,15 @@ function runTraceVerify(opts = {}) {
 `);
     return 2;
   }
+  const preflight = tracerPreflight(budget);
+  if (preflight.kind === "tracer-error") {
+    process.stderr.write(
+      `tamperward trace-verify: the tracer cannot observe in this environment, so no verifier input can be discovered \u2014 ${preflight.diagnostic}.
+This is a tracing/tooling limitation (e.g. ptrace denied by seccomp or Yama), not a verifier result.
+`
+    );
+    return 2;
+  }
   const atBase = trackedAt(base, cwd);
   const tracked = new Set(atBase);
   const covered = verifierCoveredInputs(command, atBase, policy);
@@ -18150,9 +18238,16 @@ function runTraceVerify(opts = {}) {
   const runExits = [];
   try {
     for (let i = 0; i < runs; i++) {
-      const result = runOneTrace(cwd, base, command, budget);
-      observed.push(result.accesses);
-      runExits.push(result.exit);
+      const { outcome, accesses } = runOneTrace(cwd, base, command, budget);
+      if (outcome.kind === "tracer-error") {
+        process.stderr.write(
+          `tamperward trace-verify: tracing failed during run ${i + 1}/${runs} \u2014 ${outcome.diagnostic}. No advisory report emitted.
+`
+        );
+        return 2;
+      }
+      observed.push(accesses);
+      runExits.push(outcome.exit);
     }
   } catch (e) {
     process.stderr.write(`tamperward trace-verify: tracing failed (${e instanceof Error ? e.message : String(e)}).
@@ -18199,7 +18294,7 @@ function parseTraceVerify(args) {
   }
   return out3;
 }
-var TRACE_ROOT, CONFIG_BASENAMES;
+var TRACE_ROOT, TRACER_DENIAL_RE, CONFIG_BASENAMES;
 var init_trace_verify = __esm({
   "src/cli/trace-verify.ts"() {
     "use strict";
@@ -18209,6 +18304,7 @@ var init_trace_verify = __esm({
     init_policy_load();
     init_verify();
     TRACE_ROOT = "/__tamperward_trusted_base__";
+    TRACER_DENIAL_RE = /\b(?:PTRACE_[A-Z_]+|ptrace|seccomp|no[-_ ]new[-_ ]privs|yama)\b|Operation not permitted|Permission denied/i;
     CONFIG_BASENAMES = /* @__PURE__ */ new Set([
       "package.json",
       "pytest.ini",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tamperward",
-  "version": "2.29.13",
+  "version": "2.29.15",
   "description": "The deterministic agent-integrity gate. One ruleset, evaluated on the actual diff/commands as a verdict, enforced everywhere a change can be made.",
   "license": "Apache-2.0",
   "author": "hexrift",