@bjoernrochel/sevro 0.1.0-rc.8 → 1.1.0

package/src/native-transcript-view.ts

@@ -1,10 +1,15 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
+import { gunzipSync } from "node:zlib";
 import { allocateNativeState } from "./native-transcript-state";
-import { fixtureParts } from "./preparation";
+import { fixtureParts } from "./fixtures/preparation";
 import { isRecord, isUnknownArray } from "./value-guards";
 import { sha256 } from "./identity";
 
+const MAX_NATIVE_BYTES = 5 * 1024 * 1024;
+type NativeFormat =
+  "sevro.native-transcripts.v1" | "sevro.native-transcripts.v2";
+
 export async function materializeNativeTranscriptView(
   bytes: Uint8Array,
 ): Promise<string> {
@@ -12,19 +17,33 @@ export async function materializeNativeTranscriptView(
   const bundle = nativeBundle(value);
   const root = await allocateNativeState("view-");
   await writeFile(join(root, "index.json"), bytes, { flag: "wx", mode: 0o600 });
+  const filesRoot = join(root, bundle.host);
+  let remainingBytes = MAX_NATIVE_BYTES;
   for (const item of bundle.files)
-    await materializeNativeFile(root, bundle.host, item);
+    remainingBytes -= await materializeNativeFile(
+      filesRoot,
+      item,
+      bundle.format,
+      remainingBytes,
+    );
   return root;
 }
 
 function nativeBundle(value: unknown) {
-  if (!isRecord(value) || value.format !== "sevro.native-transcripts.v1")
+  if (!isRecord(value) || !nativeFormat(value.format))
     throw new Error("invalid native transcript bundle");
   if (!nativeHost(value.host))
     throw new Error("invalid native transcript host");
   if (!isUnknownArray(value.files))
     throw new Error("invalid native transcript files");
-  return { host: value.host, files: value.files };
+  return { host: value.host, files: value.files, format: value.format };
+}
+
+function nativeFormat(value: unknown): value is NativeFormat {
+  return (
+    value === "sevro.native-transcripts.v1" ||
+    value === "sevro.native-transcripts.v2"
+  );
 }
 
 function nativeHost(value: unknown): value is "codex" | "claude" {
@@ -33,19 +52,39 @@ function nativeHost(value: unknown): value is "codex" | "claude" {
 
 async function materializeNativeFile(
   root: string,
-  host: string,
   value: unknown,
-): Promise<void> {
-  if (
-    !isRecord(value) ||
-    typeof value.path !== "string" ||
-    typeof value.bytesBase64 !== "string"
-  )
+  format: NativeFormat,
+  remainingBytes: number,
+): Promise<number> {
+  if (!isRecord(value) || typeof value.path !== "string")
     throw new Error("invalid native transcript file");
-  const path = join(root, host, ...fixtureParts(value.path));
-  const bytes = Buffer.from(value.bytesBase64, "base64");
+  const path = join(root, ...fixtureParts(value.path));
+  const bytes = nativeFileBytes(value, format, remainingBytes);
+  if (bytes.length > remainingBytes)
+    throw new Error("native transcript byte limit exceeded");
   if (sha256(bytes) !== value.sha256)
     throw new Error("native transcript hash mismatch");
   await mkdir(dirname(path), { recursive: true, mode: 0o700 });
   await writeFile(path, bytes, { flag: "wx", mode: 0o600 });
+  return bytes.length;
+}
+
+function nativeFileBytes(
+  value: Record<string, unknown>,
+  format: NativeFormat,
+  remainingBytes: number,
+): Buffer {
+  const encoded =
+    format === "sevro.native-transcripts.v1"
+      ? value.bytesBase64
+      : value.gzipBase64;
+  if (typeof encoded !== "string")
+    throw new Error("invalid native transcript file");
+  const bytes = Buffer.from(encoded, "base64");
+  if (format === "sevro.native-transcripts.v1") return bytes;
+  try {
+    return gunzipSync(bytes, { maxOutputLength: Math.max(1, remainingBytes) });
+  } catch (cause) {
+    throw new Error("invalid native transcript gzip", { cause });
+  }
 }

package/src/native-transcripts.ts

@@ -1,11 +1,15 @@
 import { lstat, readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
+import { gzipSync } from "node:zlib";
 import { sha256 } from "./identity";
-import type { HostResult } from "./evaluation-types";
-import type { RuntimeRole } from "./runtime-state";
-import type { RuntimePolicy } from "./runtime-config";
+import { HostExecutionFailure, type HostResult } from "./evaluation/types";
+import type { RuntimeRole } from "./runtime/state";
+import type { RuntimePolicy } from "./runtime/config";
 import { isRecord } from "./value-guards";
-import { CodexProcessFailure } from "./hosts/codex-process";
+import {
+  rethrowDiagnosticPersistenceError,
+  type HostDiagnostics,
+} from "./host-diagnostics";
 
 export function candidateTranscriptRoots(root: string | undefined): string[] {
   return root ? [root] : [];
@@ -48,11 +52,13 @@ export async function failedNativeTranscripts(
   policy: RuntimePolicy | undefined,
   root: string,
   host: "codex" | "claude",
-  role?: RuntimeRole,
+  role: RuntimeRole | undefined,
+  diagnostics: HostDiagnostics,
 ): Promise<HostResult> {
-  if (policy?.nativeTranscripts !== true) throw cause;
+  rethrowDiagnosticPersistenceError(cause);
+  requireFailureCapture(cause, policy, diagnostics);
   const result: HostResult =
-    cause instanceof CodexProcessFailure
+    cause instanceof HostExecutionFailure
       ? cause.result
       : {
           finalMessage: null,
@@ -60,14 +66,23 @@ export async function failedNativeTranscripts(
           executionFailed: true,
           actualCondition: "passive",
         };
-  await retainNativeTranscripts(result, root, host, role);
+  await diagnostics.retain(result, cause);
+  await retainEnabledNativeTranscripts(result, policy, root, host, role);
   return result;
 }
 
+function requireFailureCapture(
+  cause: unknown,
+  policy: RuntimePolicy | undefined,
+  diagnostics: HostDiagnostics,
+): void {
+  if (policy?.nativeTranscripts !== true && !diagnostics.enabled) throw cause;
+}
+
 const MAX_FILES = 4096;
 const MAX_BYTES = 5 * 1024 * 1024;
 const MAX_ENCODED_FILES_BYTES = 7 * 1024 * 1024;
-type NativeFile = { path: string; sha256: string; bytesBase64: string };
+type NativeFile = { path: string; sha256: string; gzipBase64: string };
 type Capture = {
   files: NativeFile[];
   bytes: number;
@@ -99,7 +114,7 @@ export async function retainNativeTranscripts(
   observeCaptureRoot(capture, rootSessionId, host);
   const completeness = captureCompleteness(capture, result);
   const bundle = {
-    format: "sevro.native-transcripts.v1",
+    format: "sevro.native-transcripts.v2",
     host,
     role,
     rootSessionId,
@@ -212,7 +227,7 @@ async function captureFile(
   const file = {
     path,
     sha256: sha256(bytes),
-    bytesBase64: bytes.toString("base64"),
+    gzipBase64: gzipSync(bytes).toString("base64"),
   };
   const issue = nativeFileIssue(path, bytes);
   if (issue && !capture.issues.includes(issue)) capture.issues.push(issue);

package/src/paths.ts

@@ -0,0 +1,22 @@
+import { isAbsolute, relative, sep } from "node:path";
+
+/** Lexical containment includes the root itself; callers resolve symlinks first. */
+export function insideRoot(root: string, path: string): boolean {
+  const child = relative(root, path);
+  return (
+    child === "" ||
+    (child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child))
+  );
+}
+
+/** Keep outermost roots in input order, retaining the first equivalent spelling. */
+export function minimalRoots(roots: string[]): string[] {
+  return roots.filter(
+    (root, index) =>
+      !roots.some(
+        (other, otherIndex) =>
+          insideRoot(other, root) &&
+          (!insideRoot(root, other) || otherIndex < index),
+      ),
+  );
+}

package/src/process-lifecycle.ts

@@ -0,0 +1,150 @@
+export type ProcessInterruptionReason = "timeout" | "cancelled";
+
+interface DeadlineOptions {
+  timeoutMs: number;
+  signal?: AbortSignal;
+  interruption: (reason: ProcessInterruptionReason) => Error;
+}
+
+/** Keep the deadline active until the caller has finished failure cleanup. */
+export class ProcessDeadline {
+  private timer: ReturnType<typeof setTimeout> | undefined;
+  private cancel: (() => void) | undefined;
+
+  constructor(private readonly options: DeadlineOptions) {}
+
+  wait<T>(completed: Promise<T> | (() => Promise<T>)): Promise<T> {
+    const timeout = this.timeout();
+    const aborted = this.aborted();
+    const completion =
+      typeof completed === "function" ? completed() : completed;
+    return Promise.race([completion, timeout, aborted]);
+  }
+
+  private timeout(): Promise<never> {
+    return new Promise((_resolve, reject) => {
+      this.timer = setTimeout(() => {
+        reject(this.options.interruption("timeout"));
+      }, this.options.timeoutMs);
+    });
+  }
+
+  private aborted(): Promise<never> {
+    return new Promise((_resolve, reject) => {
+      const signal = this.options.signal;
+      if (!signal) return;
+      this.cancel = () => {
+        reject(this.options.interruption("cancelled"));
+      };
+      if (signal.aborted) this.cancel();
+      else signal.addEventListener("abort", this.cancel, { once: true });
+    });
+  }
+
+  dispose(): void {
+    if (this.timer) clearTimeout(this.timer);
+    if (this.cancel)
+      this.options.signal?.removeEventListener("abort", this.cancel);
+  }
+}
+
+interface OwnedProcess {
+  pid: number;
+  kill: (signal: "SIGKILL") => unknown;
+}
+
+interface TerminationOptions {
+  alwaysGroup?: boolean;
+  fallbackError?: "ignore" | "propagate";
+}
+
+function killGroup(pid: number): boolean {
+  try {
+    process.kill(-pid, "SIGKILL");
+    return true;
+  } catch {
+    // The owned process group may already be gone.
+    return false;
+  }
+}
+
+function useProcessGroup(options: TerminationOptions): boolean {
+  return options.alwaysGroup === true || process.platform !== "win32";
+}
+
+function killOwnedProcess(
+  proc: OwnedProcess,
+  options: TerminationOptions,
+): void {
+  if (options.fallbackError === "propagate") {
+    proc.kill("SIGKILL");
+    return;
+  }
+  try {
+    proc.kill("SIGKILL");
+  } catch {
+    // The owned process may already have exited.
+  }
+}
+
+/** Only use for children spawned in a new, runner-owned process group. */
+export function terminateOwnedProcessGroup(
+  proc: OwnedProcess,
+  options: TerminationOptions = {},
+): void {
+  if (useProcessGroup(options) && killGroup(proc.pid)) return;
+  killOwnedProcess(proc, options);
+}
+
+type RejectedCapture = {
+  overflow: "reject";
+  exceeded: () => Error;
+};
+
+interface CaptureOptions {
+  limit: number;
+  observe?: (bytes: Uint8Array) => void;
+  cancelOnError?: boolean;
+}
+
+type ByteCaptureOptions = CaptureOptions &
+  (RejectedCapture | { overflow: "truncate" });
+
+function retainedChunk(
+  bytes: Uint8Array,
+  size: number,
+  options: ByteCaptureOptions,
+): Uint8Array {
+  if (options.overflow === "reject" && size + bytes.byteLength > options.limit)
+    throw options.exceeded();
+  return bytes.subarray(0, Math.max(0, options.limit - size));
+}
+
+/** Truncation retains a byte prefix while still draining the entire stream. */
+export async function captureBoundedBytes(
+  stream: ReadableStream<Uint8Array>,
+  options: ByteCaptureOptions,
+): Promise<{ bytes: Uint8Array; truncated: boolean }> {
+  const chunks: Uint8Array[] = [];
+  let size = 0;
+  let truncated = false;
+  for await (const bytes of stream.values({
+    preventCancel: !options.cancelOnError,
+  })) {
+    options.observe?.(bytes);
+    const retained = retainedChunk(bytes, size, options);
+    if (retained.byteLength) chunks.push(retained);
+    size += retained.byteLength;
+    truncated ||= retained.byteLength !== bytes.byteLength;
+  }
+  return { bytes: Buffer.concat(chunks), truncated };
+}
+
+/** Reject oversize output before strictly decoding the complete UTF-8 stream. */
+export async function captureBoundedText(
+  stream: ReadableStream<Uint8Array>,
+  options: CaptureOptions & RejectedCapture,
+): Promise<string> {
+  const { bytes } = await captureBoundedBytes(stream, options);
+  return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+}

package/src/provenance.ts

@@ -1,10 +1,14 @@
+import { runnerRoot, sourceRuntime } from "./runner-paths";
+import { spawnSync } from "./runtime-process";
 import type { Stats } from "node:fs";
 import { lstat, readFile, readdir, readlink, realpath } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { insideRoot } from "./paths";
 import { pathToFileURL } from "node:url";
-import packageJson from "../package.json";
+import packageJson from "../package.json" with { type: "json" };
 import { hashJson, sha256 } from "./identity";
+import { insideRuntimeRoot } from "./runtime/paths";
 
 const MAX_DIRTY_BYTES = 32 * 1024 * 1024;
 const MAX_BUILD_BYTES = 64 * 1024 * 1024;
@@ -47,9 +51,7 @@ class BuildSnapshot {
 }
 
 /** Digest the packaged runtime and public contract files in path order. */
-export async function packageBuildDigest(
-  root = join(import.meta.dir, ".."),
-): Promise<string> {
+export async function packageBuildDigest(root = runnerRoot): Promise<string> {
   const snapshot = new BuildSnapshot(await realpath(root));
   for (const path of [
     "package.json",
@@ -58,6 +60,7 @@ export async function packageBuildDigest(
     "examples",
     "schemas",
     "src",
+    ...(!sourceRuntime ? ["dist"] : []),
   ])
     await snapshot.collect(path);
   return hashJson({
@@ -136,7 +139,7 @@ export async function projectIdentityDigest(
 }
 
 function git(root: string, ...arguments_: string[]): Buffer {
-  const result = Bun.spawnSync(["git", "-C", root, ...arguments_], {
+  const result = spawnSync(["git", "-C", root, ...arguments_], {
     env: { PATH: process.env.PATH ?? "/usr/bin:/bin", LC_ALL: "C" },
     stdout: "pipe",
     stderr: "ignore",
@@ -147,7 +150,10 @@ function git(root: string, ...arguments_: string[]): Buffer {
   return Buffer.from(result.stdout);
 }
 
-async function dirtyPatchDigest(gitRoot: string): Promise<string | null> {
+async function dirtyPatchDigest(
+  gitRoot: string,
+  excludedRoots: string[],
+): Promise<string | null> {
   const trackedPatch = git(gitRoot, "diff", "--binary", "HEAD", "--");
   const untrackedPaths = git(
     gitRoot,
@@ -159,6 +165,12 @@ async function dirtyPatchDigest(gitRoot: string): Promise<string | null> {
     .toString("utf8")
     .split("\0")
     .filter(Boolean)
+    .filter(
+      (path) =>
+        !excludedRoots.some((root) =>
+          insideRuntimeRoot(root, resolve(gitRoot, path)),
+        ),
+    )
     .sort();
   let dirtyBytes = trackedPatch.byteLength;
   const untracked: { path: string; sha256: string }[] = [];
@@ -175,8 +187,7 @@ async function dirtyPatchDigest(gitRoot: string): Promise<string | null> {
 }
 
 function requireSafeUntrackedPath(root: string, absolute: string): void {
-  const path = relative(root, absolute);
-  if (isAbsolute(path) || path === ".." || path.startsWith(`..${sep}`))
+  if (!insideRoot(root, absolute))
     throw new Error("Git checkout has an unsafe untracked path");
 }
 async function untrackedIdentityBytes(
@@ -209,7 +220,7 @@ export async function checkoutProvenance(root: string, buildDigest: string) {
     source: "checkout" as const,
     root: pathToFileURL(canonicalRoot).href,
     revision,
-    dirtyPatchDigest: await dirtyPatchDigest(canonicalRoot),
+    dirtyPatchDigest: await dirtyPatchDigest(canonicalRoot, []),
     buildDigest,
   };
 }
@@ -249,7 +260,10 @@ async function emptyTemporaryGitPlaceholder(
   );
 }
 
-export async function projectProvenance(root: string) {
+export async function projectProvenance(
+  root: string,
+  excludedRoots?: string[],
+) {
   const canonicalRoot = await realpath(root);
   const gitEntryRoot = await enclosingGitRoot(canonicalRoot);
   if (!gitEntryRoot)
@@ -279,16 +293,23 @@ export async function projectProvenance(root: string) {
   return {
     root: pathToFileURL(canonicalRoot).href,
     revision,
-    dirtyPatchDigest: await dirtyPatchDigest(gitRoot),
+    dirtyPatchDigest: await projectDirtyDigest(gitRoot, excludedRoots),
   };
 }
 
+async function projectDirtyDigest(
+  root: string,
+  excludedRoots: string[] | undefined,
+) {
+  return dirtyPatchDigest(root, excludedRoots ?? []);
+}
+
 export async function runnerProvenance(
   buildDigest: string,
   checkoutRoot?: string,
 ) {
   if (checkoutRoot) {
-    const actualRoot = await realpath(join(import.meta.dir, ".."));
+    const actualRoot = await realpath(runnerRoot);
     if ((await realpath(checkoutRoot)) !== actualRoot)
       throw new Error(
         "local Sevro checkout root does not match the running package",