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

package/src/graders/shell.ts

@@ -1,6 +1,20 @@
+import { runtimeLocalHttpEnabled, runtimeSeedSources } from "../runtime/config";
+import {
+  candidateArtifactEnvironment,
+  type CandidateArtifactRoots,
+} from "../candidate-artifacts";
 import { mkdir, stat } from "node:fs/promises";
 import { delimiter, join } from "node:path";
-import { prepareMacSandboxCommand } from "../hosts/mac-sandbox";
+import { prepareIsolatedCommand } from "../hosts/isolation";
+import type { RuntimePolicy } from "../runtime/config";
+import { prepareRuntimeState } from "../runtime/state";
+import { sharedCacheDenyRoots } from "../runtime/shared-cache";
+import { hashJson } from "../identity";
+import {
+  captureBoundedText,
+  ProcessDeadline,
+  terminateOwnedProcessGroup,
+} from "../process-lifecycle";
 
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_TIMEOUT_MS = 120_000;
@@ -23,91 +37,141 @@ export interface PreparedShellCheck {
   captureStdout: boolean;
 }
 
+function requireShellDeclaration(
+  id: string,
+  value: unknown,
+): asserts value is Record<string, unknown> {
+  if (!id || !value || typeof value !== "object")
+    throw new Error("invalid shell check declaration");
+}
+function requireShellKeys(config: Record<string, unknown>): void {
+  const allowed = [
+    "run",
+    "expectedExitCode",
+    "timeoutMs",
+    "expectExact",
+    "expectRegex",
+    "notRegex",
+    "flags",
+  ];
+  if (Object.keys(config).some((key) => !allowed.includes(key)))
+    throw new Error("unsupported shell check configuration");
+}
+function requireShellCommand(run: unknown): asserts run is string {
+  if (typeof run !== "string" || !run.trim() || run.length > 4096)
+    throw new Error("shell check requires a bounded command");
+}
+function requireExpectedExit(code: unknown): asserts code is number {
+  if (
+    typeof code !== "number" ||
+    !Number.isSafeInteger(code) ||
+    code < 0 ||
+    code > 255
+  )
+    throw new Error("invalid expected shell exit code");
+}
+function requireShellTimeout(timeout: unknown): asserts timeout is number {
+  if (
+    typeof timeout !== "number" ||
+    !Number.isSafeInteger(timeout) ||
+    timeout < 1 ||
+    timeout > MAX_TIMEOUT_MS
+  )
+    throw new Error("invalid shell check timeout");
+}
+function requireExactShellOutput(
+  output: unknown,
+): asserts output is string | undefined {
+  if (
+    output !== undefined &&
+    (typeof output !== "string" ||
+      Buffer.byteLength(output, "utf8") > MAX_OUTPUT_BYTES)
+  )
+    throw new Error("invalid exact shell output expectation");
+}
+function requireShellFlags(flags: unknown): asserts flags is string {
+  if (
+    flags !== "" &&
+    (typeof flags !== "string" ||
+      !/^[isu]*$/.test(flags) ||
+      new Set(flags).size !== flags.length)
+  )
+    throw new Error("invalid shell regex flags");
+}
+function requireFlagPattern(
+  flags: string,
+  expected: unknown,
+  forbidden: unknown,
+): void {
+  if (flags && expected === undefined && forbidden === undefined)
+    throw new Error("shell regex flags require a pattern");
+}
+function shellOptions(config: Record<string, unknown>) {
+  const {
+    run,
+    expectedExitCode = 0,
+    timeoutMs = DEFAULT_TIMEOUT_MS,
+    expectExact,
+    expectRegex,
+    notRegex,
+    flags = "",
+  } = config;
+  requireShellCommand(run);
+  requireExpectedExit(expectedExitCode);
+  requireShellTimeout(timeoutMs);
+  requireExactShellOutput(expectExact);
+  requireShellFlags(flags);
+  requireFlagPattern(flags, expectRegex, notRegex);
+  return {
+    run,
+    expectedExitCode,
+    timeoutMs,
+    expectExact,
+    expectRegex,
+    notRegex,
+    flags,
+  };
+}
+function compileShellPattern(
+  value: unknown,
+  flags: string,
+): RegExp | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string" || value.length > 4096)
+    throw new Error("invalid shell regex pattern");
+  try {
+    return new RegExp(value, `m${flags}`);
+  } catch (cause) {
+    throw new Error("invalid shell regex pattern or flags", { cause });
+  }
+}
+function prepareShellCheck({
+  id,
+  configuration,
+}: ShellCheckDeclaration): PreparedShellCheck {
+  requireShellDeclaration(id, configuration);
+  requireShellKeys(configuration);
+  const config = shellOptions(configuration);
+  const expectRegex = compileShellPattern(config.expectRegex, config.flags),
+    notRegex = compileShellPattern(config.notRegex, config.flags);
+  return {
+    id,
+    run: config.run,
+    expectedExitCode: config.expectedExitCode,
+    timeoutMs: config.timeoutMs,
+    expectExact: config.expectExact,
+    expectRegex,
+    notRegex,
+    captureStdout:
+      config.expectExact !== undefined ||
+      expectRegex !== undefined ||
+      notRegex !== undefined,
+  };
+}
 export function prepareShellChecks(
   declarations: ShellCheckDeclaration[],
 ): PreparedShellCheck[] {
-  return declarations.map(({ id, configuration }) => {
-    if (!id || !configuration || typeof configuration !== "object")
-      throw new Error("invalid shell check declaration");
-    if (
-      Object.keys(configuration).some(
-        (key) =>
-          ![
-            "run",
-            "expectedExitCode",
-            "timeoutMs",
-            "expectExact",
-            "expectRegex",
-            "notRegex",
-            "flags",
-          ].includes(key),
-      )
-    )
-      throw new Error("unsupported shell check configuration");
-    const {
-      run,
-      expectedExitCode = 0,
-      timeoutMs = DEFAULT_TIMEOUT_MS,
-      expectExact,
-      expectRegex,
-      notRegex,
-      flags = "",
-    } = configuration;
-    if (typeof run !== "string" || !run.trim() || run.length > 4096)
-      throw new Error("shell check requires a bounded command");
-    if (
-      !Number.isSafeInteger(expectedExitCode) ||
-      (expectedExitCode as number) < 0 ||
-      (expectedExitCode as number) > 255
-    )
-      throw new Error("invalid expected shell exit code");
-    if (
-      !Number.isSafeInteger(timeoutMs) ||
-      (timeoutMs as number) < 1 ||
-      (timeoutMs as number) > MAX_TIMEOUT_MS
-    )
-      throw new Error("invalid shell check timeout");
-    if (
-      expectExact !== undefined &&
-      (typeof expectExact !== "string" ||
-        Buffer.byteLength(expectExact, "utf8") > MAX_OUTPUT_BYTES)
-    )
-      throw new Error("invalid exact shell output expectation");
-    if (
-      flags !== "" &&
-      (typeof flags !== "string" ||
-        !/^[isu]*$/.test(flags) ||
-        new Set(flags).size !== flags.length)
-    )
-      throw new Error("invalid shell regex flags");
-    if (flags && expectRegex === undefined && notRegex === undefined)
-      throw new Error("shell regex flags require a pattern");
-    const pattern = (value: unknown): RegExp | undefined => {
-      if (value === undefined) return undefined;
-      if (typeof value !== "string" || value.length > 4096)
-        throw new Error("invalid shell regex pattern");
-      try {
-        return new RegExp(value, `m${flags}`);
-      } catch {
-        throw new Error("invalid shell regex pattern or flags");
-      }
-    };
-    const expectedPattern = pattern(expectRegex);
-    const forbiddenPattern = pattern(notRegex);
-    return {
-      id,
-      run,
-      expectedExitCode: expectedExitCode as number,
-      timeoutMs: timeoutMs as number,
-      expectExact: expectExact as string | undefined,
-      expectRegex: expectedPattern,
-      notRegex: forbiddenPattern,
-      captureStdout:
-        expectExact !== undefined ||
-        expectedPattern !== undefined ||
-        forbiddenPattern !== undefined,
-    };
-  });
+  return declarations.map(prepareShellCheck);
 }
 
 export interface ShellCheckResult {
@@ -125,153 +189,261 @@ export function assessShellCheck(
       passed: false,
       detail: `exit code ${result.exitCode} (expected ${check.expectedExitCode})`,
     };
-  const out = result.stdout;
-  if (check.captureStdout && out === null)
+  if (check.captureStdout && result.stdout === null)
     throw new Error("shell stdout observation is missing");
-  if (
-    check.expectExact !== undefined &&
-    (out!.endsWith("\n") ? out!.slice(0, -1) : out) !== check.expectExact
-  )
-    return { passed: false, detail: "exact shell output did not match" };
-  if (check.expectRegex && !check.expectRegex.test(out!))
-    return {
-      passed: false,
-      detail: "expected shell output pattern did not match",
-    };
-  if (check.notRegex && check.notRegex.test(out!))
-    return { passed: false, detail: "forbidden shell output pattern matched" };
-  return { passed: true, detail: `exit code ${result.exitCode}` };
+  const detail = shellOutputFailure(check, result.stdout);
+  return assessedShellOutput(detail, result.exitCode);
+}
+
+function shellOutputFailure(
+  check: PreparedShellCheck,
+  out: string | null,
+): string | undefined {
+  return (
+    exactOutputFailure(check, out) ??
+    expectedPatternFailure(check, out) ??
+    forbiddenPatternFailure(check, out)
+  );
+}
+
+function assessedShellOutput(
+  detail: string | undefined,
+  exitCode: number,
+): { passed: boolean; detail: string } {
+  return detail === undefined
+    ? { passed: true, detail: `exit code ${exitCode}` }
+    : { passed: false, detail };
+}
+function exactOutputFailure(
+  check: PreparedShellCheck,
+  out: string | null,
+): string | undefined {
+  if (check.expectExact === undefined) return undefined;
+  if (out === null) throw new Error("shell stdout observation is missing");
+  const actual = out.endsWith("\n") ? out.slice(0, -1) : out;
+  return actual === check.expectExact
+    ? undefined
+    : "exact shell output did not match";
+}
+function expectedPatternFailure(
+  check: PreparedShellCheck,
+  out: string | null,
+): string | undefined {
+  return check.expectRegex && !check.expectRegex.test(String(out))
+    ? "expected shell output pattern did not match"
+    : undefined;
+}
+function forbiddenPatternFailure(
+  check: PreparedShellCheck,
+  out: string | null,
+): string | undefined {
+  return check.notRegex && check.notRegex.test(String(out))
+    ? "forbidden shell output pattern matched"
+    : undefined;
 }
 
 async function boundedOutput(
   stream: ReadableStream<Uint8Array>,
 ): Promise<string> {
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  for await (const chunk of stream) {
-    size += chunk.byteLength;
-    if (size > MAX_OUTPUT_BYTES) throw new Error("shell stdout exceeds 1 MiB");
-    chunks.push(chunk);
-  }
-  return new TextDecoder("utf-8", { fatal: true }).decode(
-    Buffer.concat(chunks),
-  );
+  return captureBoundedText(stream, {
+    limit: MAX_OUTPUT_BYTES,
+    overflow: "reject",
+    exceeded: () => new Error("shell stdout exceeds 1 MiB"),
+    cancelOnError: true,
+  });
 }
 
-function stopProcess(proc: Bun.Subprocess): void {
-  if (process.platform !== "win32") {
+interface ShellRunOptions {
+  candidateTranscriptRoot?: string;
+  candidateArtifactRoots?: CandidateArtifactRoots;
+  runtimePolicy?: RuntimePolicy;
+  workspace: string;
+  fixtureBinDir?: string;
+  toolchainBinDir?: string;
+  uvRuntimeCache?: boolean;
+  protectedRoots: string[];
+  protectedRootsCanonical?: boolean;
+  privateStateRoot: string;
+  signal?: AbortSignal;
+}
+async function shellRuntime(options: ShellRunOptions) {
+  if (options.runtimePolicy) {
+    const runtime = await prepareRuntimeState(
+      options.workspace,
+      options.runtimePolicy,
+      "checks",
+      join(options.privateStateRoot, "runtime", hashJson(options.workspace)),
+    );
+    return {
+      ...runtime,
+      uvCache: join(runtime.root, "uv-cache"),
+      privateRuntimeRoot: runtime.root,
+    };
+  }
+  const root = join(
+      options.privateStateRoot,
+      "runtime",
+      hashJson(options.workspace),
+    ),
+    home = join(root, "check-home"),
+    temp = join(root, "check-tmp");
+  await Promise.all([
+    mkdir(home, { recursive: true, mode: 0o700 }),
+    mkdir(temp, { recursive: true, mode: 0o700 }),
+  ]);
+  return {
+    root,
+    home,
+    temp,
+    uvCache: join(options.workspace, ".git", "sevro-runtime", "uv-cache"),
+    environment: {} as Record<string, string>,
+    privateRuntimeRoot: root,
+    writableCacheRoots: [],
+  };
+}
+type ShellRuntime = Awaited<ReturnType<typeof shellRuntime>>;
+type Isolation = Awaited<ReturnType<typeof prepareIsolatedCommand>>;
+function shellRuntimeEnvironment(
+  runtime: ShellRuntime,
+  enabled: boolean | undefined,
+): Record<string, string> {
+  return enabled
+    ? {
+        UV_CACHE_DIR: runtime.uvCache,
+        UV_PROJECT_ENVIRONMENT: join(runtime.root, "project-environment"),
+        UV_OFFLINE: "1",
+        PYTHONDONTWRITEBYTECODE: "1",
+      }
+    : {};
+}
+function shellEnvironment(
+  options: ShellRunOptions,
+  runtime: ShellRuntime,
+): Record<string, string> {
+  return {
+    ...runtime.environment,
+    ...candidateArtifactEnvironment(options.candidateArtifactRoots),
+    ...(options.candidateTranscriptRoot
+      ? { SEVRO_CANDIDATE_TRANSCRIPTS: options.candidateTranscriptRoot }
+      : {}),
+    PATH: [
+      options.fixtureBinDir,
+      options.toolchainBinDir,
+      runtime.environment.PATH ?? "/usr/bin:/bin:/usr/sbin:/sbin",
+    ]
+      .filter(Boolean)
+      .join(delimiter),
+    HOME: runtime.home,
+    TMPDIR: runtime.temp,
+    LANG: process.env.LANG ?? "C",
+    GIT_CONFIG_GLOBAL: "/dev/null",
+    GIT_CONFIG_NOSYSTEM: "1",
+    ...shellRuntimeEnvironment(runtime, options.uvRuntimeCache),
+  };
+}
+async function requireShellRuntimeCache(
+  options: ShellRunOptions,
+  runtime: ShellRuntime,
+): Promise<void> {
+  if (options.uvRuntimeCache && !(await stat(runtime.uvCache)).isDirectory())
+    throw new Error("isolated UV cache is missing");
+}
+function shellStdout(
+  check: PreparedShellCheck,
+  output: Bun.Subprocess["stdout"],
+): ReadableStream<Uint8Array> | null {
+  if (!check.captureStdout) return null;
+  if (!(output instanceof ReadableStream))
+    throw new Error("shell stdout pipe is unavailable");
+  return output;
+}
+class ShellExecution {
+  private proc?: Bun.Subprocess;
+  private readonly deadline: ProcessDeadline;
+  constructor(
+    private check: PreparedShellCheck,
+    private options: ShellRunOptions,
+    private isolation: Isolation,
+    private runtime: ShellRuntime,
+  ) {
+    this.deadline = new ProcessDeadline({
+      timeoutMs: check.timeoutMs,
+      signal: options.signal,
+      interruption: (reason) =>
+        new Error(
+          reason === "timeout"
+            ? "shell check timed out"
+            : "shell check cancelled",
+        ),
+    });
+  }
+  async run(): Promise<ShellCheckResult> {
     try {
-      process.kill(-proc.pid, "SIGKILL");
-      return;
-    } catch {
-      // The group may already be gone.
+      const running = this.spawn();
+      const stream = shellStdout(this.check, running.stdout);
+      return await this.deadline.wait(() =>
+        Promise.all([
+          running.exited,
+          stream ? boundedOutput(stream) : Promise.resolve(null),
+        ]).then(([exitCode, stdout]) => ({ exitCode, stdout })),
+      );
+    } catch (error) {
+      await this.stop();
+      throw error;
+    } finally {
+      this.deadline.dispose();
+      await this.isolation.release();
     }
   }
-  try {
-    proc.kill("SIGKILL");
-  } catch {
-    // The process already exited.
+  private spawn() {
+    this.proc = Bun.spawn(this.isolation.argv, {
+      cwd: this.options.workspace,
+      env: shellEnvironment(this.options, this.runtime),
+      detached: true,
+      stdin: "ignore",
+      stdout: this.check.captureStdout ? "pipe" : "ignore",
+      stderr: "ignore",
+    });
+    return this.proc;
+  }
+  private async stop(): Promise<void> {
+    const proc = this.proc;
+    if (!proc) return;
+    terminateOwnedProcessGroup(proc);
+    await proc.exited;
   }
 }
 
 /** Run a check without inherited credentials or retaining raw process output. */
 export async function runShellCheck(
   check: PreparedShellCheck,
-  options: {
-    workspace: string;
-    fixtureBinDir?: string;
-    toolchainBinDir?: string;
-    uvRuntimeCache?: boolean;
-    protectedRoots: string[];
-    protectedRootsCanonical?: boolean;
-    privateStateRoot: string;
-    signal?: AbortSignal;
-  },
+  options: ShellRunOptions,
 ): Promise<ShellCheckResult> {
   if (options.signal?.aborted) throw new Error("shell check cancelled");
-  const runtimeRoot = join(options.workspace, ".git", "sevro-runtime");
-  const home = join(runtimeRoot, "check-home");
-  const temp = join(runtimeRoot, "check-tmp");
-  await Promise.all([
-    mkdir(home, { recursive: true, mode: 0o700 }),
-    mkdir(temp, { recursive: true, mode: 0o700 }),
-  ]);
-  const isolated = await prepareMacSandboxCommand({
+  const runtime = await shellRuntime(options);
+  const isolated = await prepareIsolatedCommand({
     argv: ["/bin/sh", "-e", "-c", check.run],
     workspace: options.workspace,
-    protectedRoots: options.protectedRoots,
+    protectedRoots: [...options.protectedRoots, ...shellSeedSources(options)],
     protectedRootsCanonical: options.protectedRootsCanonical,
     privateStateRoot: options.privateStateRoot,
     denyNetwork: true,
+    localHttp: runtimeLocalHttpEnabled(options.runtimePolicy, "checks"),
+    readOnlyRoots: options.runtimePolicy?.readOnlyRoots,
+    candidateArtifactRoots: options.candidateArtifactRoots,
+    transcriptReadRoots: options.candidateTranscriptRoot
+      ? [options.candidateTranscriptRoot]
+      : [],
+    writableRuntimeRoot: runtime.privateRuntimeRoot,
+    writableCacheRoots: runtime.writableCacheRoots,
   });
-  const uvCache = join(runtimeRoot, "uv-cache");
-  if (options.uvRuntimeCache && !(await stat(uvCache)).isDirectory())
-    throw new Error("isolated UV cache is missing");
-  let proc: Bun.Subprocess | undefined;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let cancel: (() => void) | undefined;
-  try {
-    proc = Bun.spawn(isolated.argv, {
-      cwd: options.workspace,
-      env: {
-        PATH: [
-          options.fixtureBinDir,
-          options.toolchainBinDir,
-          "/usr/bin:/bin:/usr/sbin:/sbin",
-        ]
-          .filter(Boolean)
-          .join(delimiter),
-        HOME: home,
-        TMPDIR: temp,
-        LANG: process.env.LANG ?? "C",
-        GIT_CONFIG_GLOBAL: "/dev/null",
-        GIT_CONFIG_NOSYSTEM: "1",
-        ...(options.uvRuntimeCache
-          ? {
-              UV_CACHE_DIR: uvCache,
-              UV_PROJECT_ENVIRONMENT: join(runtimeRoot, "project-environment"),
-              UV_OFFLINE: "1",
-              PYTHONDONTWRITEBYTECODE: "1",
-            }
-          : {}),
-      },
-      detached: true,
-      stdin: "ignore",
-      stdout: check.captureStdout ? "pipe" : "ignore",
-      stderr: "ignore",
-    });
-    const running = proc;
-    const outputStream = running.stdout;
-    if (check.captureStdout && !(outputStream instanceof ReadableStream))
-      throw new Error("shell stdout pipe is unavailable");
-    const timeout = new Promise<never>((_resolve, reject) => {
-      timer = setTimeout(
-        () => reject(new Error("shell check timed out")),
-        check.timeoutMs,
-      );
-    });
-    const aborted = new Promise<never>((_resolve, reject) => {
-      if (!options.signal) return;
-      cancel = () => reject(new Error("shell check cancelled"));
-      if (options.signal.aborted) cancel();
-      else options.signal.addEventListener("abort", cancel, { once: true });
-    });
-    const completed = Promise.all([
-      running.exited,
-      check.captureStdout
-        ? boundedOutput(outputStream as ReadableStream<Uint8Array>)
-        : Promise.resolve(null),
-    ]).then(([exitCode, stdout]) => ({ exitCode, stdout }));
-    return await Promise.race([completed, timeout, aborted]);
-  } catch (error) {
-    if (proc) {
-      stopProcess(proc);
-      await proc.exited;
-    }
-    throw error;
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (cancel) options.signal?.removeEventListener("abort", cancel);
-    await isolated.release();
-  }
+  await requireShellRuntimeCache(options, runtime);
+  return new ShellExecution(check, options, isolated, runtime).run();
+}
+
+function shellSeedSources(options: ShellRunOptions): string[] {
+  return [
+    ...runtimeSeedSources(options.runtimePolicy),
+    ...sharedCacheDenyRoots(options.runtimePolicy, "checks"),
+  ];
 }

package/src/host-diagnostic-redaction.ts

@@ -0,0 +1,52 @@
+import { readFile, stat } from "node:fs/promises";
+import { isRecord } from "./value-guards";
+
+function credentialStrings(value: unknown): string[] {
+  const pending: unknown[] = [value];
+  const secrets: string[] = [];
+  for (let visited = 0; visited < 256; visited++) {
+    const item = pending.pop();
+    if (typeof item === "string") {
+      if (item.length >= 8) secrets.push(item);
+    } else if (isRecord(item)) pending.push(...Object.values(item));
+  }
+  return secrets;
+}
+
+/** Read credentials only for scrubbing; failures belong to the actual host preparation. */
+export async function diagnosticSecrets(path: string): Promise<string[]> {
+  try {
+    if ((await stat(path)).size > 1024 * 1024) return [];
+    const text = await readFile(path, "utf8");
+    try {
+      const value: unknown = JSON.parse(text);
+      return credentialStrings(value);
+    } catch {
+      return text.trim() ? [text.trim()] : [];
+    }
+  } catch {
+    return [];
+  }
+}
+
+export function redactDiagnosticText(text: string, secrets: string[]): string {
+  for (const secret of secrets) {
+    text = text.replaceAll(secret, "[redacted]");
+    text = redactCredentialSuffix(text, secret);
+  }
+  return text
+    .replace(/(authorization\s*:\s*)[^\r\n]+/gi, "$1[redacted]")
+    .replace(/\bBearer\s+\S+/gi, "Bearer [redacted]")
+    .replace(/\bsk-[A-Za-z0-9_-]+/g, "[redacted]")
+    .replace(
+      /((?:api[_-]?key|access[_-]?token|refresh[_-]?token)\s*[=:]\s*)\S+/gi,
+      "$1[redacted]",
+    );
+}
+
+function redactCredentialSuffix(text: string, secret: string): string {
+  const start = text.lastIndexOf(secret.slice(0, Math.min(8, secret.length)));
+  if (start >= 0 && secret.startsWith(text.slice(start)))
+    return text.slice(0, start) + "[redacted]";
+  return text;
+}