@bjoernrochel/sevro 0.1.0-rc.2 → 0.1.0-rc.21

package/src/native-transcripts.ts

@@ -0,0 +1,286 @@
+import { lstat, readdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { gzipSync } from "node:zlib";
+import { sha256 } from "./identity";
+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 {
+  rethrowDiagnosticPersistenceError,
+  type HostDiagnostics,
+} from "./host-diagnostics";
+
+export function candidateTranscriptRoots(root: string | undefined): string[] {
+  return root ? [root] : [];
+}
+
+export function candidateTranscriptEnvironment(
+  root: string | undefined,
+): Record<string, string> {
+  return root ? { SEVRO_CANDIDATE_TRANSCRIPTS: root } : {};
+}
+
+export async function retainEnabledNativeTranscripts(
+  result: HostResult,
+  policy: RuntimePolicy | undefined,
+  root: string,
+  host: "codex" | "claude",
+  role?: RuntimeRole,
+  rootSessionId?: string,
+): Promise<void> {
+  if (policy?.nativeTranscripts === true)
+    await retainNativeTranscripts(
+      result,
+      root,
+      host,
+      role,
+      rootSessionId ?? observedRootSession(result),
+    );
+}
+
+function observedRootSession(result: HostResult): string | undefined {
+  const observation = result.observations?.find(
+    (item) => item.id === "sevro.host.native-goal",
+  );
+  const session = observation?.data.threadId;
+  return typeof session === "string" ? session : undefined;
+}
+
+export async function failedNativeTranscripts(
+  cause: unknown,
+  policy: RuntimePolicy | undefined,
+  root: string,
+  host: "codex" | "claude",
+  role?: RuntimeRole,
+  diagnostics?: HostDiagnostics,
+): Promise<HostResult> {
+  rethrowDiagnosticPersistenceError(cause);
+  requireFailureCapture(cause, policy, diagnostics);
+  const result: HostResult =
+    cause instanceof HostExecutionFailure
+      ? cause.result
+      : {
+          finalMessage: null,
+          complete: false,
+          executionFailed: true,
+          actualCondition: "passive",
+        };
+  await diagnostics?.retain(result, cause);
+  await retainEnabledNativeTranscripts(result, policy, root, host, role);
+  return result;
+}
+
+function requireFailureCapture(
+  cause: unknown,
+  policy: RuntimePolicy | undefined,
+  diagnostics: HostDiagnostics | undefined,
+): void {
+  if (policy?.nativeTranscripts !== true && !diagnostics) 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; gzipBase64: string };
+type Capture = {
+  files: NativeFile[];
+  bytes: number;
+  entries: number;
+  encodedBytes: number;
+  issues: string[];
+};
+
+/** Capture only a fresh role's transcript tree; never follow native source links. */
+export async function retainNativeTranscripts(
+  result: HostResult,
+  root: string,
+  host: "codex" | "claude",
+  role: RuntimeRole = "candidate",
+  rootSessionId: string | null = null,
+): Promise<void> {
+  const capture: Capture = {
+    files: [],
+    bytes: 0,
+    entries: 0,
+    encodedBytes: 0,
+    issues: [],
+  };
+  try {
+    await captureDirectory(root, "", capture);
+  } catch {
+    capture.issues.push("source_unavailable");
+  }
+  observeCaptureRoot(capture, rootSessionId, host);
+  const completeness = captureCompleteness(capture, result);
+  const bundle = {
+    format: "sevro.native-transcripts.v2",
+    host,
+    role,
+    rootSessionId,
+    completeness,
+    issues: capture.issues,
+    files: capture.files,
+  };
+  const lists = nativeResultLists(result);
+  lists.artifacts.push({
+    id: "sevro.native-transcripts.bundle",
+    bytes: Buffer.from(JSON.stringify(bundle)),
+  });
+  lists.observations.push({
+    id: "sevro.host.native-transcripts",
+    completeness,
+    data: {
+      method: "native_files",
+      host,
+      role,
+      rootSessionId,
+      artifactId: "sevro.native-transcripts.bundle",
+      issues: capture.issues,
+      files: capture.files.map(({ path, sha256 }) => ({ path, sha256 })),
+    },
+  });
+}
+
+function nativeResultLists(result: HostResult) {
+  result.artifacts ??= [];
+  result.observations ??= [];
+  return { artifacts: result.artifacts, observations: result.observations };
+}
+
+function observeCaptureRoot(
+  capture: Capture,
+  session: string | null,
+  host: string,
+): void {
+  if (session === null) {
+    capture.issues.push("root_session_unknown");
+    return;
+  }
+  const suffix = host === "codex" ? `-${session}.jsonl` : `/${session}.jsonl`;
+  if (!capture.files.some((file) => file.path.endsWith(suffix)))
+    capture.issues.push("root_session_missing");
+}
+
+function captureCompleteness(capture: Capture, result: HostResult) {
+  if (!capture.files.some((file) => file.path.endsWith(".jsonl")))
+    return "unavailable" as const;
+  if (capture.issues.length || !result.complete || result.executionFailed)
+    return "partial" as const;
+  return "complete" as const;
+}
+
+async function captureDirectory(
+  root: string,
+  path: string,
+  capture: Capture,
+): Promise<void> {
+  const directory = join(root, path);
+  if (!(await lstat(directory)).isDirectory())
+    throw new Error("invalid source directory");
+  for (const name of (await readdir(directory)).sort()) {
+    capture.entries++;
+    if (capture.entries > MAX_FILES) {
+      capture.issues.push("entry_limit");
+      return;
+    }
+    await captureEntry(root, join(path, name), capture);
+  }
+}
+
+async function captureEntry(
+  root: string,
+  path: string,
+  capture: Capture,
+): Promise<void> {
+  try {
+    const info = await lstat(join(root, path));
+    if (info.isDirectory()) {
+      await captureDirectory(root, path, capture);
+      return;
+    }
+    if (!info.isFile()) {
+      capture.issues.push("unsafe_entry");
+      return;
+    }
+    await captureFile(root, path, info.size, capture);
+  } catch {
+    capture.issues.push("entry_unavailable");
+  }
+}
+
+async function captureFile(
+  root: string,
+  path: string,
+  size: number,
+  capture: Capture,
+): Promise<void> {
+  if (capture.bytes + size > MAX_BYTES) {
+    capture.issues.push("byte_limit");
+    return;
+  }
+  const bytes = await readFile(join(root, path));
+  if (bytes.length !== size) {
+    capture.issues.push("source_changed");
+    return;
+  }
+  const file = {
+    path,
+    sha256: sha256(bytes),
+    gzipBase64: gzipSync(bytes).toString("base64"),
+  };
+  const issue = nativeFileIssue(path, bytes);
+  if (issue && !capture.issues.includes(issue)) capture.issues.push(issue);
+  retainCaptureFile(file, bytes.length, capture);
+}
+
+function nativeFileIssue(path: string, bytes: Buffer): string | null {
+  if (path.endsWith(".json")) return nativeSidecarIssue(bytes);
+  if (!path.endsWith(".jsonl")) return null;
+  return nativeTranscriptIssue(bytes);
+}
+
+function nativeTranscriptIssue(bytes: Buffer): string | null {
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    if (!text.trim()) return "empty_transcript";
+    const records = text.replace(/\r?\n$/, "").split("\n");
+    if (!records.every(validNativeRecord)) return "malformed_transcript";
+    return null;
+  } catch {
+    return "malformed_transcript";
+  }
+}
+
+function nativeSidecarIssue(bytes: Buffer): string | null {
+  try {
+    JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    return null;
+  } catch {
+    return "malformed_sidecar";
+  }
+}
+
+function validNativeRecord(line: string): boolean {
+  const record: unknown = JSON.parse(line);
+  return isRecord(record) && nativeRecordType(record.type);
+}
+
+function nativeRecordType(type: unknown): boolean {
+  return typeof type === "string" && type.trim().length > 0;
+}
+
+function retainCaptureFile(
+  file: NativeFile,
+  size: number,
+  capture: Capture,
+): void {
+  const encoded = Buffer.byteLength(JSON.stringify(file));
+  if (capture.encodedBytes + encoded > MAX_ENCODED_FILES_BYTES) {
+    capture.issues.push("bundle_limit");
+    return;
+  }
+  capture.bytes += size;
+  capture.encodedBytes += encoded;
+  capture.files.push(file);
+}

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);
+}