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

package/src/{repository-fixture.ts → fixtures/repository.ts}

@@ -1,8 +1,10 @@
+import { isRecord, isStringArray } from "../value-guards";
+import { isMissingFile } from "./tools";
 import { lstat, mkdir, realpath, stat, writeFile } from "node:fs/promises";
 import { isAbsolute, join, relative, sep } from "node:path";
 import { fileURLToPath } from "node:url";
-import { canonicalJson } from "./identity";
-import { prepareFixtureBin } from "./fixture-bin";
+import { canonicalJson } from "../identity";
+import { prepareFixtureBin } from "./bin";
 import { prepareGitHooks } from "./git-hooks";
 import type { PreparationSources } from "./preparation";
 import { fixtureParts } from "./preparation";
@@ -21,53 +23,110 @@ export interface RepositoryFixture {
   bin?: Record<string, string>;
 }
 
-/** Validate repository source identity and bounded working-tree changes. */
-export function prepareRepositoryFixture(value: unknown): RepositoryFixture {
-  if (!value || typeof value !== "object" || Array.isArray(value))
-    throw new Error("invalid repository fixture");
-  const fixture = value as Record<string, unknown>;
+function repositoryRecord(value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error("invalid repository fixture");
+  return value;
+}
+function requireRepositoryIdentity(
+  fixture: Record<string, unknown>,
+): asserts fixture is Record<string, unknown> & {
+  kind: "repository";
+  sourceRef: string;
+} {
+  const allowed = [
+    "kind",
+    "sourceRef",
+    "files",
+    "staged",
+    "commitFiles",
+    "hooks",
+    "bin",
+  ];
   if (
     fixture.kind !== "repository" ||
-    Object.keys(fixture).some(
-      (key) =>
-        ![
-          "kind",
-          "sourceRef",
-          "files",
-          "staged",
-          "commitFiles",
-          "hooks",
-          "bin",
-        ].includes(key),
-    ) ||
+    Object.keys(fixture).some((key) => !allowed.includes(key)) ||
     typeof fixture.sourceRef !== "string" ||
-    !fixture.sourceRef ||
-    (fixture.files !== undefined &&
-      (!fixture.files ||
-        typeof fixture.files !== "object" ||
-        Array.isArray(fixture.files) ||
-        Object.values(fixture.files).some(
-          (item) => typeof item !== "string",
-        ))) ||
-    (fixture.staged !== undefined &&
-      (!Array.isArray(fixture.staged) ||
-        fixture.staged.some((item) => typeof item !== "string"))) ||
-    (fixture.commitFiles !== undefined &&
-      typeof fixture.commitFiles !== "boolean")
+    !fixture.sourceRef
+  )
+    throw new Error("invalid repository fixture");
+}
+function optionalRepositoryFiles(
+  value: unknown,
+): value is Record<string, string> | undefined {
+  return (
+    value === undefined ||
+    (isRecord(value) &&
+      Object.values(value).every((item) => typeof item === "string"))
+  );
+}
+function optionalRepositoryStaging(
+  value: unknown,
+): value is string[] | undefined {
+  return value === undefined || isStringArray(value);
+}
+function optionalRepositoryCommit(
+  value: unknown,
+): value is boolean | undefined {
+  return value === undefined || typeof value === "boolean";
+}
+function requireRepositoryOptions(
+  fixture: Record<string, unknown>,
+): asserts fixture is Record<string, unknown> & {
+  files?: Record<string, string>;
+  staged?: string[];
+  commitFiles?: boolean;
+} {
+  if (
+    !optionalRepositoryFiles(fixture.files) ||
+    !optionalRepositoryStaging(fixture.staged) ||
+    !optionalRepositoryCommit(fixture.commitFiles)
   )
     throw new Error("invalid repository fixture");
+}
+function requireRepositoryTools(
+  fixture: Record<string, unknown>,
+): asserts fixture is Record<string, unknown> & {
+  hooks?: Record<string, string>;
+  bin?: Record<string, string>;
+} {
   prepareGitHooks(fixture.hooks);
   prepareFixtureBin(fixture.bin);
-  const files = (fixture.files ?? {}) as Record<string, string>;
-  const staged = (fixture.staged ?? []) as string[];
+}
+function repositoryFixtureData(value: unknown): RepositoryFixture {
+  const fixture = repositoryRecord(value);
+  requireRepositoryIdentity(fixture);
+  requireRepositoryOptions(fixture);
+  requireRepositoryTools(fixture);
+  return fixture;
+}
+function requireOverlayPath(path: string): void {
+  if (fixtureParts(path).some((part) => part.toLowerCase() === ".git"))
+    throw new Error("repository fixture cannot write repository metadata");
+}
+function overlayPathsCollide(left: string, right: string): boolean {
+  return (
+    left === right ||
+    left.startsWith(`${right}/`) ||
+    right.startsWith(`${left}/`)
+  );
+}
+function requireDistinctOverlayPaths(paths: string[]): void {
+  const normalized = paths.map((path) => path.toLowerCase());
+  for (const [index, path] of normalized.entries())
+    for (const other of normalized.slice(0, index))
+      if (overlayPathsCollide(path, other))
+        throw new Error("repository fixture overlay paths collide");
+}
+function requireBoundedOverlay(
+  files: Record<string, string>,
+  staged: string[],
+): void {
   const paths = Object.keys(files);
   if (paths.length > MAX_OVERLAY_FILES)
     throw new Error("repository fixture exceeds the file limit");
   let bytes = 0;
   for (const [path, content] of Object.entries(files)) {
-    const parts = fixtureParts(path);
-    if (parts.some((part) => part.toLowerCase() === ".git"))
-      throw new Error("repository fixture cannot write repository metadata");
+    requireOverlayPath(path);
     bytes +=
       Buffer.byteLength(path, "utf8") + Buffer.byteLength(content, "utf8");
   }
@@ -77,24 +136,30 @@ export function prepareRepositoryFixture(value: unknown): RepositoryFixture {
   );
   if (bytes > MAX_OVERLAY_BYTES)
     throw new Error("repository fixture exceeds the size limit");
-  const normalized = paths.map((path) => path.toLowerCase());
-  for (let index = 0; index < normalized.length; index++) {
-    for (let other = 0; other < index; other++) {
-      if (
-        normalized[index] === normalized[other] ||
-        normalized[index]!.startsWith(`${normalized[other]}/`) ||
-        normalized[other]!.startsWith(`${normalized[index]}/`)
-      )
-        throw new Error("repository fixture overlay paths collide");
-    }
-  }
+  requireDistinctOverlayPaths(paths);
+}
+function requireRepositoryStaging(
+  fixture: RepositoryFixture,
+  files: Record<string, string>,
+  staged: string[],
+): void {
   if (
     new Set(staged.map((path) => path.toLowerCase())).size !== staged.length ||
     staged.some((path) => !Object.hasOwn(files, path)) ||
-    (fixture.commitFiles === true && paths.length === 0)
+    (fixture.commitFiles === true && Object.keys(files).length === 0)
   )
     throw new Error("invalid repository fixture staging");
-  return JSON.parse(canonicalJson(fixture)) as RepositoryFixture;
+}
+
+/** Validate repository source identity and bounded working-tree changes. */
+export function prepareRepositoryFixture(value: unknown): RepositoryFixture {
+  const fixture = repositoryFixtureData(value);
+  const files = fixture.files ?? {},
+    staged = fixture.staged ?? [];
+  requireBoundedOverlay(files, staged);
+  requireRepositoryStaging(fixture, files, staged);
+  const clone: unknown = JSON.parse(canonicalJson(fixture));
+  return repositoryFixtureData(clone);
 }
 
 export interface RepositorySource {
@@ -137,7 +202,7 @@ async function git(args: string[], cwd: string): Promise<string> {
     },
   });
   try {
-    const [stdout, _stderr, code] = await Promise.all([
+    const [stdout, , code] = await Promise.all([
       boundedText(proc.stdout),
       boundedText(proc.stderr),
       proc.exited,
@@ -156,38 +221,78 @@ export async function resolveRepositorySource(
   sourceRef: string,
   sources?: PreparationSources,
 ): Promise<RepositorySource> {
+  const selected = repositorySourceSelection(sourceRef, sources);
+  const { root, path } = await canonicalRepositorySource(selected);
+  requireContainedRepository(root, path);
+  return { path, revision: await repositoryCommit(path) };
+}
+
+function requireRepositorySources(
+  sources: PreparationSources | undefined,
+): asserts sources is PreparationSources {
   if (!sources || !isAbsolute(sources.root))
     throw new Error("repository source root is required and must be absolute");
+}
+function repositorySourceSelection(
+  sourceRef: string,
+  sources: PreparationSources | undefined,
+) {
+  requireRepositorySources(sources);
   if (!Object.hasOwn(sources.refs, sourceRef))
     throw new Error("repository source reference is not declared");
   const url = sources.refs[sourceRef];
   if (typeof url !== "string" || !url.startsWith("file:///"))
     throw new Error("repository source reference must be a file URL");
-  let root: string;
-  let path: string;
+  return { root: sources.root, url };
+}
+async function canonicalRepositorySource(selected: {
+  root: string;
+  url: string;
+}) {
   try {
-    [root, path] = await Promise.all([
-      realpath(sources.root),
-      realpath(fileURLToPath(url)),
+    const [root, path] = await Promise.all([
+      realpath(selected.root),
+      realpath(fileURLToPath(selected.url)),
     ]);
     if (!(await stat(path)).isDirectory()) throw new Error();
-  } catch {
-    throw new Error("repository source is unreadable");
+    return { root, path };
+  } catch (cause) {
+    throw new Error("repository source is unreadable", { cause });
   }
+}
+function requireContainedRepository(root: string, path: string): void {
   const child = relative(root, path);
   if (child === ".." || child.startsWith(`..${sep}`) || isAbsolute(child))
     throw new Error("repository source escapes its declared root");
+}
+async function repositoryCommit(path: string): Promise<string> {
   const top = await git(["rev-parse", "--show-toplevel"], path);
   if ((await realpath(top)) !== path)
     throw new Error("repository source must name the repository root");
   const revision = await git(["rev-parse", "--verify", "HEAD^{commit}"], path);
   if (!/^[a-f0-9]{40,64}$/.test(revision))
     throw new Error("repository source has no valid commit");
-  if (await git(["status", "--porcelain=v1", "--untracked-files=all"], path))
+  if (
+    await git(
+      [
+        "status",
+        "--porcelain=v1",
+        "--untracked-files=all",
+        "--ignore-submodules=none",
+      ],
+      path,
+    )
+  )
     throw new Error("repository source has uncommitted changes");
-  if (await git(["submodule", "status"], path))
-    throw new Error("repository submodules are not supported");
-  return { path, revision };
+  return revision;
+}
+function requireRepositorySnapshot(
+  current: RepositorySource,
+  expected: RepositorySource,
+  message: string,
+): void {
+  if (current.path !== expected.path || current.revision !== expected.revision)
+    throw new Error(message);
 }
 
 /** Clone a fixed commit without hardlinks or a remote back to the source. */
@@ -198,14 +303,18 @@ export async function cloneRepositorySource(
   workspace: string,
 ): Promise<void> {
   const current = await resolveRepositorySource(sourceRef, sources);
-  if (current.path !== expected.path || current.revision !== expected.revision)
-    throw new Error("repository source changed during run");
+  requireRepositorySnapshot(
+    current,
+    expected,
+    "repository source changed during run",
+  );
   await git(
     [
       "clone",
       "--local",
       "--no-hardlinks",
       "--no-checkout",
+      "--no-recurse-submodules",
       "--quiet",
       current.path,
       workspace,
@@ -220,8 +329,11 @@ export async function cloneRepositorySource(
     .filter(Boolean))
     await git(["remote", "remove", remote], workspace);
   const after = await resolveRepositorySource(sourceRef, sources);
-  if (after.path !== expected.path || after.revision !== expected.revision)
-    throw new Error("repository source changed during clone");
+  requireRepositorySnapshot(
+    after,
+    expected,
+    "repository source changed during clone",
+  );
 }
 
 async function safeOverlayTarget(
@@ -232,30 +344,31 @@ async function safeOverlayTarget(
   let parent = workspace;
   for (const part of parts.slice(0, -1)) {
     parent = join(parent, part);
-    try {
-      const entry = await lstat(parent);
-      if (!entry.isDirectory() || entry.isSymbolicLink())
-        throw new Error("repository fixture overlay traverses a non-directory");
-    } catch (error) {
-      if (!(
-        error instanceof Error &&
-        "code" in error &&
-        error.code === "ENOENT"
-      ))
-        throw error;
-      await mkdir(parent, { mode: 0o700 });
-    }
+    await overlayParent(parent);
   }
   const target = join(workspace, ...parts);
+  await requireOverlayTarget(target);
+  return target;
+}
+
+async function overlayParent(path: string): Promise<void> {
   try {
-    const entry = await lstat(target);
+    const entry = await lstat(path);
+    if (!entry.isDirectory() || entry.isSymbolicLink())
+      throw new Error("repository fixture overlay traverses a non-directory");
+  } catch (error) {
+    if (!isMissingFile(error)) throw error;
+    await mkdir(path, { mode: 0o700 });
+  }
+}
+async function requireOverlayTarget(path: string): Promise<void> {
+  try {
+    const entry = await lstat(path);
     if (!entry.isFile() || entry.isSymbolicLink())
       throw new Error("repository fixture overlay targets a non-file");
   } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-      throw error;
+    if (!isMissingFile(error)) throw error;
   }
-  return target;
 }
 
 /** Apply declared files after cloning, optionally committing or staging them. */
@@ -269,11 +382,20 @@ export async function applyRepositoryOverlay(
       flag: "w",
       mode: 0o600,
     });
-  const paths = Object.keys(files);
-  const noHooks = [
+  await stageRepositoryOverlay(fixture, workspace, Object.keys(files));
+}
+function disabledHooksArgs(): string[] {
+  return [
     "-c",
     `core.hooksPath=${process.platform === "win32" ? "NUL" : "/dev/null"}`,
   ];
+}
+async function stageRepositoryOverlay(
+  fixture: RepositoryFixture,
+  workspace: string,
+  paths: string[],
+): Promise<void> {
+  const noHooks = disabledHooksArgs();
   if (fixture.commitFiles) {
     await git([...noHooks, "add", "--", ...paths], workspace);
     await git(

package/src/fixtures/setup.ts

@@ -0,0 +1,224 @@
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { delimiter, isAbsolute, join } from "node:path";
+import { isRecord } from "../value-guards";
+import { requireCandidateRuntime } from "../candidate-artifacts";
+import {
+  ProcessDeadline,
+  terminateOwnedProcessGroup,
+} from "../process-lifecycle";
+
+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>;
+}
+
+function setupRecord(value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error("invalid fixture setup");
+  return value;
+}
+
+function validArgument(value: unknown): value is string {
+  return typeof value === "string" && value.length > 0 && !value.includes("\0");
+}
+
+function argumentList(value: unknown): value is string[] {
+  return (
+    Array.isArray(value) &&
+    value.length > 0 &&
+    value.length <= 16 &&
+    value.every(validArgument)
+  );
+}
+
+function setupCommand(value: unknown): string[] {
+  if (!argumentList(value)) throw new Error("invalid fixture setup command");
+  const executable = value[0];
+  if (
+    !absoluteExecutable(executable) ||
+    Buffer.byteLength(value.join("\0"), "utf8") > MAX_COMMAND_BYTES
+  )
+    throw new Error("invalid fixture setup command");
+  return value;
+}
+
+function absoluteExecutable(value: string | undefined): boolean {
+  return value !== undefined && isAbsolute(value);
+}
+
+function validEnvironmentEntry([name, value]: [string, unknown]): boolean {
+  return (
+    /^[A-Z][A-Z0-9_]*$/.test(name) &&
+    !RESERVED_ENV.has(name) &&
+    validEnvironmentValue(value)
+  );
+}
+
+function validEnvironmentValue(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    !value.includes("\0") &&
+    !/\{\{(?!sevro\.(?:project|workspace)\}\})/.test(value)
+  );
+}
+
+function environmentRecord(value: unknown): Record<string, unknown> {
+  if (!isRecord(value)) throw new Error("invalid fixture setup environment");
+  return value;
+}
+
+function setupEnvironment(value: unknown): Record<string, string> {
+  const environment = environmentRecord(value);
+  const entries = Object.entries(environment);
+  if (
+    entries.length > 32 ||
+    entries.some((entry) => !validEnvironmentEntry(entry)) ||
+    Buffer.byteLength(JSON.stringify(environment), "utf8") > MAX_ENV_BYTES
+  )
+    throw new Error("invalid fixture setup environment");
+  return environment as Record<string, string>;
+}
+
+/** Validate a trusted extension's bounded fixture setup command. */
+export function prepareFixtureSetup(value: unknown): FixtureSetup | null {
+  if (value === undefined) return null;
+  const input = setupRecord(value);
+  if (
+    Object.keys(input).some((key) => key !== "command" && key !== "environment")
+  )
+    throw new Error("unsupported fixture setup field");
+  const command = setupCommand(input.command);
+  const environment = setupEnvironment(input.environment ?? {});
+  return { command, environment };
+}
+
+interface FixtureSetupOptions {
+  workspace: string;
+  projectRoot: string;
+  fixtureBinDir?: string;
+  signal?: AbortSignal;
+  candidateRuntimeRoot?: string;
+}
+
+function setupPath(directory: string | undefined): string {
+  const inherited = process.env.PATH ?? "/usr/bin:/bin";
+  return directory ? `${directory}${delimiter}${inherited}` : inherited;
+}
+
+function executionEnvironment(
+  setup: FixtureSetup,
+  options: FixtureSetupOptions,
+  home: string,
+) {
+  const environment = Object.fromEntries(
+    Object.entries(setup.environment).map(([name, value]) => [
+      name,
+      value
+        .replaceAll("{{sevro.project}}", options.projectRoot)
+        .replaceAll("{{sevro.workspace}}", options.workspace),
+    ]),
+  );
+  return {
+    PATH: setupPath(options.fixtureBinDir),
+    HOME: options.candidateRuntimeRoot
+      ? join(options.candidateRuntimeRoot, "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,
+  };
+}
+
+class FixtureSetupExecution {
+  private proc: Bun.Subprocess | undefined;
+  private readonly deadline: ProcessDeadline;
+  constructor(
+    private readonly setup: FixtureSetup,
+    private readonly options: FixtureSetupOptions,
+    private readonly home: string,
+  ) {
+    this.deadline = new ProcessDeadline({
+      timeoutMs: TIMEOUT_MS,
+      signal: options.signal,
+      interruption: (reason) =>
+        new Error(
+          reason === "timeout"
+            ? "fixture setup timed out"
+            : "fixture setup cancelled",
+        ),
+    });
+  }
+
+  async run(): Promise<void> {
+    this.proc = Bun.spawn(this.setup.command, {
+      cwd: this.options.workspace,
+      env: executionEnvironment(this.setup, this.options, this.home),
+      detached: process.platform !== "win32",
+      stdin: "ignore",
+      stdout: "ignore",
+      stderr: "ignore",
+    });
+    const code = await this.deadline.wait(this.proc.exited);
+    if (code !== 0) throw new Error(`fixture setup failed (${code})`);
+  }
+
+  async stop(): Promise<void> {
+    if (!this.proc) return;
+    terminateOwnedProcessGroup(this.proc);
+    await this.proc.exited;
+  }
+
+  async dispose(): Promise<void> {
+    this.deadline.dispose();
+    await rm(this.home, { recursive: true, force: true });
+  }
+}
+
+/** Run setup after fixture history and before evaluator artifacts are mounted. */
+export async function runFixtureSetup(
+  setup: FixtureSetup,
+  options: FixtureSetupOptions,
+): Promise<void> {
+  if (options.signal?.aborted) throw new Error("fixture setup cancelled");
+  await requireCandidateRuntime(options.candidateRuntimeRoot);
+  if (options.candidateRuntimeRoot)
+    await mkdir(join(options.candidateRuntimeRoot, "home"), {
+      recursive: true,
+      mode: 0o700,
+    });
+  const home = await mkdtemp(join(tmpdir(), "sevro-setup-"));
+  const execution = new FixtureSetupExecution(setup, options, home);
+  try {
+    await execution.run();
+  } catch (error) {
+    await execution.stop();
+    throw error;
+  } finally {
+    await execution.dispose();
+  }
+}