@bjoernrochel/sevro 0.1.0-rc.7 → 1.0.0

package/src/hosts/process-lifecycle.ts

@@ -1,60 +1,236 @@
-export const MAX_EVENT_BYTES = 8 * 1024 * 1024;
+import { validHostTimeout } from "./native-request";
+import { ProcessDeadline } from "../process-lifecycle";
+import {
+  captureBoundedBytes,
+  captureBoundedText,
+  terminateOwnedProcessGroup,
+} from "../process-lifecycle";
+import { HostExecutionFailure, type HostResult } from "../evaluation/types";
+import {
+  HostProcessDiagnostics,
+  type HostDiagnostics,
+} from "../host-diagnostics";
 
-/** Bound bytes before decoding a host's output with strict UTF-8. */
-export async function boundedProcessText(
-  stream: ReadableStream<Uint8Array>,
-  limit: number,
-  exceededMessage: string,
-): Promise<string> {
-  const reader = stream.getReader();
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  for (;;) {
-    const { value, done } = await reader.read();
-    if (done) break;
-    size += value.byteLength;
-    if (size > limit) throw new Error(exceededMessage);
-    chunks.push(value);
+export const MAX_STDERR_BYTES = 64 * 1024;
+export const MAX_EVENT_BYTES = 8 * 1024 * 1024;
+class HostProcessInterruption extends Error {
+  constructor(
+    host: string,
+    readonly reason: "timeout" | "cancelled",
+  ) {
+    super(`${host} run ${reason === "timeout" ? "timed out" : "cancelled"}`);
   }
-  return new TextDecoder("utf-8", { fatal: true }).decode(
-    Buffer.concat(chunks),
-  );
 }
 
 /** Race completion against the host deadline and cancellation, then release listeners. */
-export async function awaitHostProcess<T>(
+async function awaitHostProcess<T>(
   proc: Bun.Subprocess,
   completed: Promise<T>,
-  options: {
-    host: "Codex" | "Claude";
-    timeoutMs: number;
-    signal?: AbortSignal;
-    stop: (proc: Bun.Subprocess) => void;
-  },
+  options: HostProcessOptions,
 ): Promise<T> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let cancel: (() => void) | undefined;
+  const deadline = new ProcessDeadline({
+    ...options,
+    interruption: (reason) => new HostProcessInterruption(options.host, reason),
+  });
   try {
-    const timeout = new Promise<never>((_resolve, reject) => {
-      timer = setTimeout(() => {
-        reject(new Error(`${options.host} run timed out`));
-      }, options.timeoutMs);
-    });
-    const aborted = new Promise<never>((_resolve, reject) => {
-      if (!options.signal) return;
-      cancel = () => {
-        reject(new Error(`${options.host} run cancelled`));
-      };
-      if (options.signal.aborted) cancel();
-      else options.signal.addEventListener("abort", cancel, { once: true });
-    });
-    return await Promise.race([completed, timeout, aborted]);
+    return await deadline.wait(completed);
   } catch (error) {
-    options.stop(proc);
+    terminateOwnedProcessGroup(proc);
     await proc.exited;
     throw error;
   } finally {
-    if (timer) clearTimeout(timer);
-    if (cancel) options.signal?.removeEventListener("abort", cancel);
+    deadline.dispose();
+  }
+}
+
+export type Phase = NonNullable<HostResult["processFailure"]>["phase"];
+export type HostProcessResult = {
+  code: number;
+  out: string;
+  stderr: Uint8Array;
+  stderrTruncated: boolean;
+  signal: string | null;
+  durationMs: number;
+};
+
+export function hostFailureMessage(
+  result: HostResult,
+  host: string,
+): string | undefined {
+  const failure = result.processFailure;
+  if (!failure) return undefined;
+  const labels = {
+    "isolation-preflight": `${host} isolation preflight`,
+    "executable-preflight": `${host} executable preflight`,
+    execution: `${host} run`,
+  };
+  if (!Object.hasOwn(labels, failure.phase)) return undefined;
+  return `${labels[failure.phase]} ${failureSuffix(failure)}`;
+}
+
+function failureSuffix(
+  failure: NonNullable<HostResult["processFailure"]>,
+): string {
+  if (failure.reason === "timeout" && validHostTimeout(failure.timeoutMs))
+    return `timed out after ${failure.timeoutMs / 1000} s`;
+  return failure.reason === "cancelled" ? "cancelled" : "failed";
+}
+
+export class HostProcessFailure extends HostExecutionFailure {
+  constructor(
+    host: "Codex" | "Claude",
+    phase: Phase,
+    process: HostProcessResult,
+    reason: NonNullable<HostResult["processFailure"]>["reason"] = "exit",
+    timeoutMs = 60_000,
+  ) {
+    const failure = { phase, reason, timeoutMs };
+    const result: HostResult = {
+      finalMessage: null,
+      complete: false,
+      executionFailed: true,
+      actualCondition: "passive",
+      processFailure: failure,
+      artifacts: [
+        {
+          id: `${host.toLowerCase()}.process`,
+          bytes: Buffer.from(
+            JSON.stringify({
+              ...failure,
+              code: process.code,
+              signal: process.signal,
+              durationMs: process.durationMs,
+              stderrTruncated: process.stderrTruncated,
+            }),
+          ),
+        },
+        { id: `${host.toLowerCase()}.stderr`, bytes: process.stderr },
+      ],
+    };
+    super(hostFailureMessage(result, host), result);
+  }
+}
+
+export interface HostProcessOptions {
+  host: "Codex" | "Claude";
+  diagnostics: HostDiagnostics;
+  argv: string[];
+  cwd: string;
+  env: Record<string, string>;
+  input?: string;
+  timeoutMs: number;
+  signal?: AbortSignal;
+  phase?: Phase;
+}
+
+async function writeHostInput(
+  proc: Bun.Subprocess,
+  input?: string,
+): Promise<void> {
+  if (input === undefined) return;
+  if (!proc.stdin || typeof proc.stdin === "number")
+    throw new Error("Codex input pipe unavailable");
+  await proc.stdin.write(input);
+  await proc.stdin.end();
+}
+
+function spawnHostProcess(
+  options: HostProcessOptions,
+  capture: HostProcessDiagnostics,
+) {
+  try {
+    return Bun.spawn(options.argv, {
+      cwd: options.cwd,
+      env: options.env,
+      detached: process.platform !== "win32",
+      stdin: options.input === undefined ? "ignore" : "pipe",
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+  } catch (cause) {
+    capture.recordUnstarted();
+    throw cause;
+  }
+}
+
+function processPhase(options: HostProcessOptions): Phase {
+  return options.phase ?? "execution";
+}
+
+function requireHostProcess(options: HostProcessOptions): void {
+  if (options.signal?.aborted) throw new Error(`${options.host} run cancelled`);
+}
+
+function hostCompletion(
+  proc: ReturnType<typeof spawnHostProcess>,
+  options: HostProcessOptions,
+  capture: HostProcessDiagnostics,
+) {
+  const started = performance.now();
+  const stdout = captureBoundedText(proc.stdout, {
+    limit: MAX_EVENT_BYTES,
+    overflow: "reject",
+    exceeded: () =>
+      new Error(`${options.host} event stream exceeds the size limit`),
+    observe: (bytes) => {
+      capture.stdout.add(bytes);
+    },
+  });
+  const stderr = captureBoundedBytes(proc.stderr, {
+    limit: MAX_STDERR_BYTES,
+    overflow: "truncate",
+    cancelOnError: true,
+    observe: (bytes) => {
+      capture.stderr.add(bytes);
+    },
+  });
+  const input = writeHostInput(proc, options.input);
+  const completed = Promise.all([stdout, proc.exited, stderr, input]).then(
+    ([out, code, err]) => ({
+      out,
+      code,
+      stderr: err.bytes,
+      stderrTruncated: err.truncated,
+      signal: proc.signalCode ?? null,
+      durationMs: performance.now() - started,
+    }),
+  );
+  return { completed, drains: [stdout, stderr, input], started };
+}
+
+export async function runHostProcess(
+  options: HostProcessOptions,
+): Promise<HostProcessResult> {
+  requireHostProcess(options);
+  const capture = new HostProcessDiagnostics(options.diagnostics);
+  const proc = spawnHostProcess(options, capture);
+  const { completed, drains, started } = hostCompletion(proc, options, capture);
+  try {
+    const result = await awaitHostProcess(proc, completed, {
+      ...options,
+    });
+    await capture.record(proc);
+    return result;
+  } catch (cause) {
+    await Promise.allSettled(drains);
+    if (!(cause instanceof HostProcessInterruption)) {
+      await capture.record(proc, "error");
+      throw cause;
+    }
+    await capture.record(proc, cause.reason);
+    throw new HostProcessFailure(
+      options.host,
+      processPhase(options),
+      {
+        code: await proc.exited,
+        out: capture.stdout.bytes().toString("utf8"),
+        stderr: capture.stderr.bytes(),
+        stderrTruncated: capture.stderr.truncated,
+        signal: proc.signalCode ?? null,
+        durationMs: performance.now() - started,
+      },
+      cause.reason,
+      options.timeoutMs,
+    );
   }
 }

package/src/hosts/protected-worktrees.ts

@@ -1,4 +1,4 @@
-import { isMissingFile } from "../fixture-tools";
+import { isMissingFile } from "../fixtures/tools";
 import { lstat, readdir, realpath, stat } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { dirname, isAbsolute, join } from "node:path";

package/src/hosts/skill-hook-catalog.ts

@@ -0,0 +1,131 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir, realpath } from "node:fs/promises";
+import { join, relative, resolve } from "node:path";
+import type { Dirent } from "node:fs";
+import type { HookSkill } from "./skill-hook-handler";
+import { isRecord } from "../value-guards";
+
+const MAX_SKILLS = 128;
+const MAX_SKILL_BYTES = 1024 * 1024;
+const MAX_CATALOG_BYTES = 8 * 1024 * 1024;
+interface Catalog {
+  skills: HookSkill[];
+  complete: boolean;
+  bytes: number;
+}
+export interface SkillCatalogRoot {
+  directory: string;
+  boundary: string;
+  namespace?: string;
+}
+
+export async function codexSkillCatalogRoots(
+  workspace: string,
+  pluginRoots: string[],
+  nativeSkillRoots: SkillCatalogRoot[],
+): Promise<SkillCatalogRoot[]> {
+  const roots: SkillCatalogRoot[] = [
+    { directory: join(workspace, ".agents/skills"), boundary: workspace },
+    ...nativeSkillRoots,
+  ];
+  for (const root of pluginRoots) {
+    const manifest: unknown = JSON.parse(
+      await readFile(join(root, ".claude-plugin/plugin.json"), "utf8"),
+    );
+    if (!isRecord(manifest) || typeof manifest.name !== "string")
+      throw new Error("invalid skill catalog plugin manifest");
+    roots.push({
+      directory: join(root, "skills"),
+      boundary: root,
+      namespace: manifest.name,
+    });
+  }
+  return roots;
+}
+
+/** Snapshot only known skill mounts; shell syntax does not enter discovery. */
+export async function skillHookCatalog(roots: SkillCatalogRoot[]) {
+  const catalog: Catalog = { skills: [], complete: true, bytes: 0 };
+  for (const root of roots) await readRoot(root, catalog);
+  return { skills: catalog.skills, catalogComplete: catalog.complete };
+}
+
+async function readRoot(root: SkillCatalogRoot, catalog: Catalog) {
+  try {
+    await requireCatalogRoot(root);
+    const entries = await readdir(root.directory, { withFileTypes: true });
+    const directories = catalogDirectories(entries, catalog);
+    for (const entry of directories.sort((a, b) =>
+      a.name.localeCompare(b.name),
+    )) {
+      await readSkill(root, entry.name, catalog);
+    }
+  } catch (cause) {
+    if (!missing(cause)) catalog.complete = false;
+  }
+}
+
+function catalogDirectories(entries: Dirent[], catalog: Catalog): Dirent[] {
+  const directories: Dirent[] = [];
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) catalog.complete = false;
+    if (entry.isDirectory() && /^[A-Za-z0-9._-]+$/.test(entry.name))
+      directories.push(entry);
+  }
+  return directories;
+}
+
+async function requireCatalogRoot(root: SkillCatalogRoot) {
+  const expected = resolve(
+    await realpath(root.boundary),
+    relative(root.boundary, root.directory),
+  );
+  if ((await realpath(root.directory)) !== expected)
+    throw new Error("redirected skill catalog root");
+}
+
+function missing(cause: unknown): boolean {
+  return cause instanceof Error && "code" in cause && cause.code === "ENOENT";
+}
+
+async function readSkill(
+  root: SkillCatalogRoot,
+  name: string,
+  catalog: Catalog,
+) {
+  try {
+    const path = join(root.directory, name, "SKILL.md");
+    const file = await lstat(path);
+    if (!readableSkill(file)) {
+      catalog.complete = false;
+      return;
+    }
+    const bytes = await readFile(path);
+    if (bytes.length > MAX_SKILL_BYTES)
+      throw new Error("skill changed during catalog read");
+    addSkill(bytes, [root.namespace, name].filter(Boolean).join(":"), catalog);
+  } catch (cause) {
+    if (!missing(cause)) catalog.complete = false;
+  }
+}
+
+function readableSkill(file: Awaited<ReturnType<typeof lstat>>): boolean {
+  return file.isFile() && file.size <= MAX_SKILL_BYTES;
+}
+
+function addSkill(bytes: Buffer, invocation: string, catalog: Catalog) {
+  if (!bytes.length) return;
+  catalog.bytes += bytes.length;
+  if (
+    catalog.skills.length >= MAX_SKILLS ||
+    catalog.bytes > MAX_CATALOG_BYTES
+  ) {
+    catalog.complete = false;
+    return;
+  }
+  catalog.skills.push({
+    invocation,
+    sha256: createHash("sha256").update(bytes).digest("hex"),
+    body: bytes.toString("utf8"),
+  });
+}