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

package/src/advisory-fixture.ts

@@ -1,282 +0,0 @@
-import {
-  lstat,
-  mkdir,
-  mkdtemp,
-  readlink,
-  readdir,
-  realpath,
-  rm,
-  symlink,
-  copyFile,
-} from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { fixtureParts } from "./preparation";
-
-const MAX_GIT_OUTPUT = 16 * 1024 * 1024;
-const MAX_UNTRACKED_BYTES = 32 * 1024 * 1024;
-const MAX_UNTRACKED_FILES = 1024;
-const HIDDEN_ROOTS = [".agents", ".claude", ".codex", ".git"];
-
-function contained(root: string, path: string): boolean {
-  const child = relative(root, path);
-  return (
-    child === "" ||
-    (child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child))
-  );
-}
-
-function excluded(path: string, roots: string[]): boolean {
-  return roots.some((root) => path === root || path.startsWith(`${root}/`));
-}
-
-async function bounded(stream: ReadableStream<Uint8Array>): Promise<Buffer> {
-  const chunks: Uint8Array[] = [];
-  let size = 0;
-  for await (const chunk of stream) {
-    size += chunk.byteLength;
-    if (size > MAX_GIT_OUTPUT)
-      throw new Error("advisory fixture Git output is too large");
-    chunks.push(chunk);
-  }
-  return Buffer.concat(chunks);
-}
-
-async function git(
-  cwd: string,
-  args: string[],
-  input?: Uint8Array,
-): Promise<Buffer> {
-  const proc = Bun.spawn(
-    [
-      "git",
-      "-c",
-      `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`,
-      ...args,
-    ],
-    {
-      cwd,
-      stdin: input ? "pipe" : "ignore",
-      stdout: "pipe",
-      stderr: "pipe",
-      env: {
-        PATH: process.env.PATH ?? "/usr/bin:/bin",
-        ...(process.env.SystemRoot
-          ? { SystemRoot: process.env.SystemRoot }
-          : {}),
-        GIT_CONFIG_NOSYSTEM: "1",
-        GIT_CONFIG_GLOBAL: process.platform === "win32" ? "NUL" : "/dev/null",
-        GIT_TERMINAL_PROMPT: "0",
-        GIT_AUTHOR_NAME: "Sevro Advisory",
-        GIT_AUTHOR_EMAIL: "advisory@sevro.invalid",
-        GIT_COMMITTER_NAME: "Sevro Advisory",
-        GIT_COMMITTER_EMAIL: "advisory@sevro.invalid",
-        GIT_AUTHOR_DATE: "2000-01-01T00:00:00+00:00",
-        GIT_COMMITTER_DATE: "2000-01-01T00:00:00+00:00",
-      },
-    },
-  );
-  try {
-    const write = (async () => {
-      if (!input) return;
-      if (!proc.stdin || typeof proc.stdin === "number")
-        throw new Error("advisory fixture Git input unavailable");
-      await proc.stdin.write(input);
-      await proc.stdin.end();
-    })();
-    const [out, , code] = await Promise.all([
-      bounded(proc.stdout),
-      bounded(proc.stderr),
-      proc.exited,
-      write,
-    ]);
-    if (code !== 0) throw new Error("advisory fixture Git operation failed");
-    return out;
-  } catch {
-    try {
-      proc.kill("SIGKILL");
-    } catch {
-      // The process may already have exited.
-    }
-    await proc.exited;
-    throw new Error("advisory fixture Git operation failed");
-  }
-}
-
-async function checkSymlinks(root: string, directory = root): Promise<void> {
-  for (const entry of await readdir(directory, { withFileTypes: true })) {
-    if (directory === root && entry.name === ".git") continue;
-    const path = join(directory, entry.name);
-    if (entry.isDirectory()) await checkSymlinks(root, path);
-    else if (entry.isSymbolicLink()) {
-      const target = await readlink(path);
-      if (
-        isAbsolute(target) ||
-        !contained(root, resolve(dirname(path), target))
-      )
-        throw new Error("advisory fixture contains an escaping symlink");
-      const resolved = await realpath(path).catch(() => {
-        throw new Error("advisory fixture contains a broken symlink");
-      });
-      if (!contained(root, resolved))
-        throw new Error("advisory fixture contains an escaping symlink");
-    }
-  }
-}
-
-async function safeParent(root: string, parts: string[]): Promise<void> {
-  let directory = root;
-  for (const part of parts.slice(0, -1)) {
-    directory = join(directory, part);
-    await mkdir(directory, { mode: 0o700 }).catch((error: unknown) => {
-      if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-    });
-    if (!(await lstat(directory)).isDirectory())
-      throw new Error("advisory fixture path has a non-directory parent");
-  }
-}
-
-async function copyUntracked(
-  source: string,
-  destination: string,
-  exclusions: string[],
-): Promise<void> {
-  const output = await git(source, [
-    "ls-files",
-    "--others",
-    "--exclude-standard",
-    "-z",
-  ]);
-  const paths = new TextDecoder("utf-8", { fatal: true })
-    .decode(output)
-    .split("\0")
-    .filter(Boolean)
-    .filter((path) => !excluded(path, exclusions));
-  if (paths.length > MAX_UNTRACKED_FILES)
-    throw new Error("advisory fixture has too many untracked files");
-  let totalBytes = 0;
-  for (const path of paths) {
-    const parts = fixtureParts(path);
-    const from = join(source, ...parts);
-    const to = join(destination, ...parts);
-    if (!contained(source, from) || !contained(destination, to))
-      throw new Error("advisory fixture path escapes its root");
-    const info = await lstat(from);
-    totalBytes += info.size;
-    if (totalBytes > MAX_UNTRACKED_BYTES)
-      throw new Error("advisory fixture untracked files exceed the size limit");
-    await safeParent(destination, parts);
-    if (
-      await lstat(to).then(
-        () => true,
-        (error: NodeJS.ErrnoException) => {
-          if (error.code === "ENOENT") return false;
-          throw error;
-        },
-      )
-    )
-      throw new Error("advisory fixture untracked path already exists");
-    if (info.isFile()) await copyFile(from, to);
-    else if (info.isSymbolicLink()) {
-      const target = await readlink(from);
-      if (
-        isAbsolute(target) ||
-        !contained(destination, resolve(dirname(to), target))
-      )
-        throw new Error("advisory fixture contains an escaping symlink");
-      await symlink(target, to);
-    } else
-      throw new Error("advisory fixture has an unsupported untracked entry");
-  }
-}
-
-export interface BlindAdvisoryOptions {
-  /** Fixture HEAD before candidate execution. */
-  baseRevision: string;
-  /** Additional root-relative evaluator paths to omit from the judge view. */
-  excludedPaths?: string[];
-}
-
-/** Capture the candidate fixture's baseline before the host edits it. */
-export async function advisoryBaseRevision(workspace: string): Promise<string> {
-  const revision = (await git(workspace, ["rev-parse", "--verify", "HEAD"]))
-    .toString("utf8")
-    .trim();
-  if (!/^[a-f0-9]{40,64}$/.test(revision))
-    throw new Error("advisory fixture has no valid Git baseline");
-  return revision;
-}
-
-/** Rebuild a condition-blind Git view of the complete candidate change. */
-export async function buildBlindAdvisoryFixture(
-  candidateWorkspace: string,
-  options: BlindAdvisoryOptions,
-): Promise<string> {
-  if (
-    !isAbsolute(candidateWorkspace) ||
-    !/^[a-f0-9]{40,64}$/.test(options.baseRevision)
-  )
-    throw new Error("invalid advisory fixture source");
-  const source = await realpath(candidateWorkspace);
-  const exclusions = [...HIDDEN_ROOTS, ...(options.excludedPaths ?? [])];
-  for (const path of options.excludedPaths ?? []) {
-    fixtureParts(path);
-    if (path.toLowerCase() === ".git" || path.toLowerCase().startsWith(".git/"))
-      throw new Error("invalid advisory exclusion");
-  }
-  const destination = await mkdtemp(join(tmpdir(), "sevro-advisory-"));
-  try {
-    await git(source, [
-      "clone",
-      "--local",
-      "--no-hardlinks",
-      "--no-checkout",
-      "--quiet",
-      source,
-      destination,
-    ]);
-    await git(destination, [
-      "checkout",
-      "--detach",
-      "--quiet",
-      options.baseRevision,
-    ]);
-    for (const root of exclusions)
-      await rm(join(destination, ...fixtureParts(root)), {
-        recursive: true,
-        force: true,
-      });
-    await rm(join(destination, ".git"), { recursive: true, force: true });
-    await git(destination, ["init", "--quiet", "--initial-branch=main"]);
-    await git(destination, ["add", "-A"]);
-    await git(destination, [
-      "commit",
-      "--quiet",
-      "--allow-empty",
-      "-m",
-      "Advisory baseline",
-    ]);
-    const pathspec = exclusions.flatMap((path) => [
-      `:(exclude)${path}`,
-      `:(exclude)${path}/**`,
-    ]);
-    const patch = await git(source, [
-      "diff",
-      "--binary",
-      "--no-ext-diff",
-      "--no-textconv",
-      "--no-renames",
-      options.baseRevision,
-      "--",
-      ".",
-      ...pathspec,
-    ]);
-    if (patch.length) await git(destination, ["apply", "--binary", "-"], patch);
-    await copyUntracked(source, destination, exclusions);
-    await checkSymlinks(destination);
-    return destination;
-  } catch (error) {
-    await rm(destination, { recursive: true, force: true });
-    throw error;
-  }
-}

package/src/fixture-bin.ts

@@ -1,87 +0,0 @@
-import { chmod, lstat, mkdir, realpath, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-const MAX_TOOLS = 64;
-const MAX_BYTES = 1024 * 1024;
-
-/** Validate executable fixture tools without allowing path traversal. */
-export function prepareFixtureBin(
-  value: unknown,
-): Record<string, string> | null {
-  if (value === undefined) return null;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid fixture binaries");
-  const bin = value as Record<string, unknown>;
-  const entries = Object.entries(bin);
-  if (
-    entries.length > MAX_TOOLS ||
-    entries.some(
-      ([name, content]) =>
-        !/^[A-Za-z][A-Za-z0-9._-]*$/.test(name) ||
-        name.length > 64 ||
-        typeof content !== "string" ||
-        !content ||
-        content.includes("\0"),
-    ) ||
-    entries.reduce(
-      (size, [name, content]) =>
-        size +
-        Buffer.byteLength(name, "utf8") +
-        Buffer.byteLength(content as string, "utf8"),
-      0,
-    ) > MAX_BYTES
-  )
-    throw new Error("invalid fixture binaries");
-  return bin as Record<string, string>;
-}
-
-/** Install declared tools inside the fixture's Git metadata, after commits. */
-export async function installFixtureBin(
-  bin: Record<string, string> | undefined,
-  workspace: string,
-): Promise<void> {
-  if (!bin || Object.keys(bin).length === 0) return;
-  const directory = join(workspace, ".git", "fixture-bin");
-  await mkdir(directory, { recursive: true, mode: 0o700 });
-  const root = await lstat(directory);
-  if (!root.isDirectory() || root.isSymbolicLink())
-    throw new Error("fixture binary directory is invalid");
-  for (const [name, content] of Object.entries(bin)) {
-    const target = join(directory, name);
-    try {
-      const existing = await lstat(target);
-      if (!existing.isFile() || existing.isSymbolicLink())
-        throw new Error("fixture binary target is invalid");
-    } catch (error) {
-      if (!(
-        error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT"
-      ))
-        throw error;
-    }
-    await writeFile(target, content, { mode: 0o755 });
-    await chmod(target, 0o755);
-  }
-}
-
-/** Setup may also install trusted tools, such as a repository ticket stub. */
-export async function fixtureBinDirectory(
-  workspace: string,
-): Promise<string | null> {
-  const path = join(workspace, ".git", "fixture-bin");
-  try {
-    const entry = await lstat(path);
-    if (!entry.isDirectory() || entry.isSymbolicLink())
-      throw new Error("fixture binary directory is invalid");
-    const canonicalWorkspace = await realpath(workspace);
-    const canonicalBin = await realpath(path);
-    if (canonicalBin !== join(canonicalWorkspace, ".git", "fixture-bin"))
-      throw new Error("fixture binary directory escapes the workspace");
-    return path;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT")
-      return null;
-    throw error;
-  }
-}

package/src/fixture-setup.ts

@@ -1,163 +0,0 @@
-import { mkdtemp, rm } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { delimiter, isAbsolute, join } from "node:path";
-
-const MAX_COMMAND_BYTES = 64 * 1024;
-const MAX_ENV_BYTES = 16 * 1024;
-const TIMEOUT_MS = 120_000;
-const RESERVED_ENV = new Set([
-  "PATH",
-  "HOME",
-  "TMPDIR",
-  "GIT_CONFIG_GLOBAL",
-  "GIT_CONFIG_NOSYSTEM",
-  "GIT_TERMINAL_PROMPT",
-]);
-
-export interface FixtureSetupDeclaration {
-  command: string[];
-  environment?: Record<string, string>;
-}
-
-export interface FixtureSetup extends FixtureSetupDeclaration {
-  environment: Record<string, string>;
-}
-
-/** Validate a trusted extension's bounded fixture setup command. */
-export function prepareFixtureSetup(value: unknown): FixtureSetup | null {
-  if (value === undefined) return null;
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid fixture setup");
-  const input = value as Record<string, unknown>;
-  if (
-    Object.keys(input).some((key) => key !== "command" && key !== "environment")
-  )
-    throw new Error("unsupported fixture setup field");
-  const command = input.command;
-  if (
-    !Array.isArray(command) ||
-    !command.length ||
-    command.length > 16 ||
-    command.some(
-      (arg) => typeof arg !== "string" || !arg.length || arg.includes("\0"),
-    ) ||
-    !isAbsolute(command[0]) ||
-    Buffer.byteLength(command.join("\0"), "utf8") > MAX_COMMAND_BYTES
-  )
-    throw new Error("invalid fixture setup command");
-  const environment = input.environment ?? {};
-  if (
-    !environment ||
-    typeof environment !== "object" ||
-    Array.isArray(environment)
-  )
-    throw new Error("invalid fixture setup environment");
-  const entries = Object.entries(environment);
-  if (
-    entries.length > 32 ||
-    entries.some(
-      ([name, value]) =>
-        !/^[A-Z][A-Z0-9_]*$/.test(name) ||
-        RESERVED_ENV.has(name) ||
-        typeof value !== "string" ||
-        value.includes("\0") ||
-        /\{\{(?!sevro\.(?:project|workspace)\}\})/.test(value),
-    ) ||
-    Buffer.byteLength(JSON.stringify(environment), "utf8") > MAX_ENV_BYTES
-  )
-    throw new Error("invalid fixture setup environment");
-  return { command, environment: environment as Record<string, string> };
-}
-
-function stopProcess(proc: Bun.Subprocess): void {
-  if (process.platform !== "win32") {
-    try {
-      process.kill(-proc.pid, "SIGKILL");
-      return;
-    } catch {
-      // The process group may already be gone.
-    }
-  }
-  try {
-    proc.kill("SIGKILL");
-  } catch {
-    // The process already exited.
-  }
-}
-
-/** Run setup after fixture history and before evaluator artifacts are mounted. */
-export async function runFixtureSetup(
-  setup: FixtureSetup,
-  options: {
-    workspace: string;
-    projectRoot: string;
-    fixtureBinDir?: string;
-    signal?: AbortSignal;
-  },
-): Promise<void> {
-  if (options.signal?.aborted) throw new Error("fixture setup cancelled");
-  const home = await mkdtemp(join(tmpdir(), "sevro-setup-"));
-  let proc: Bun.Subprocess | undefined;
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  let cancel: (() => void) | undefined;
-  try {
-    const environment = Object.fromEntries(
-      Object.entries(setup.environment).map(([name, value]) => [
-        name,
-        value
-          .replaceAll("{{sevro.project}}", options.projectRoot)
-          .replaceAll("{{sevro.workspace}}", options.workspace),
-      ]),
-    );
-    proc = Bun.spawn(setup.command, {
-      cwd: options.workspace,
-      env: {
-        PATH: options.fixtureBinDir
-          ? `${options.fixtureBinDir}${delimiter}${process.env.PATH ?? "/usr/bin:/bin"}`
-          : (process.env.PATH ?? "/usr/bin:/bin"),
-        HOME: home,
-        TMPDIR: home,
-        LANG: process.env.LANG ?? "C",
-        GIT_CONFIG_GLOBAL: process.platform === "win32" ? "NUL" : "/dev/null",
-        GIT_CONFIG_NOSYSTEM: "1",
-        GIT_TERMINAL_PROMPT: "0",
-        GIT_AUTHOR_NAME: "Sevro Fixture",
-        GIT_AUTHOR_EMAIL: "fixture@sevro.invalid",
-        GIT_COMMITTER_NAME: "Sevro Fixture",
-        GIT_COMMITTER_EMAIL: "fixture@sevro.invalid",
-        GIT_AUTHOR_DATE: "2000-01-01T00:00:00+00:00",
-        GIT_COMMITTER_DATE: "2000-01-01T00:00:00+00:00",
-        ...environment,
-      },
-      detached: process.platform !== "win32",
-      stdin: "ignore",
-      stdout: "ignore",
-      stderr: "ignore",
-    });
-    const running = proc;
-    const timeout = new Promise<never>((_resolve, reject) => {
-      timer = setTimeout(
-        () => reject(new Error("fixture setup timed out")),
-        TIMEOUT_MS,
-      );
-    });
-    const aborted = new Promise<never>((_resolve, reject) => {
-      if (!options.signal) return;
-      cancel = () => reject(new Error("fixture setup cancelled"));
-      if (options.signal.aborted) cancel();
-      else options.signal.addEventListener("abort", cancel, { once: true });
-    });
-    const code = await Promise.race([running.exited, timeout, aborted]);
-    if (code !== 0) throw new Error(`fixture setup failed (${code})`);
-  } catch (error) {
-    if (proc) {
-      stopProcess(proc);
-      await proc.exited;
-    }
-    throw error;
-  } finally {
-    if (timer) clearTimeout(timer);
-    if (cancel) options.signal?.removeEventListener("abort", cancel);
-    await rm(home, { recursive: true, force: true });
-  }
-}