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

package/src/hosts/codex-skill-reads.ts

@@ -1,391 +0,0 @@
-import { nativeCommandOutputs } from "./codex-command-output";
-import { readFile, realpath } from "node:fs/promises";
-import { isAbsolute, relative, resolve, sep } from "node:path";
-
-const MAX_SKILL_BYTES = 1024 * 1024;
-const MAX_NATIVE_READ_ATTEMPTS = 64;
-const SKILL_PATH = /^\.agents\/skills\/([A-Za-z0-9._-]+)\/SKILL\.md$/;
-const PLUGIN_SKILL_PATH = /^skills\/([A-Za-z0-9._-]+)\/SKILL\.md$/;
-
-interface CodexItem {
-  id?: unknown;
-  type?: unknown;
-  command?: unknown;
-  status?: unknown;
-  exit_code?: unknown;
-  aggregated_output?: unknown;
-}
-
-interface CodexEvent {
-  type?: unknown;
-  item?: CodexItem;
-}
-
-function shellPayload(command: string): string {
-  let payload = command;
-  for (let depth = 0; depth < 2; depth++) {
-    const wrapper = payload.match(
-      /^(?:\/bin\/(?:ba|z)?sh\s+-l?c|lean-ctx\s+-c)\s+(["'])([\s\S]*)\1$/,
-    );
-    if (!wrapper) break;
-    payload = wrapper[2]!;
-  }
-  return payload;
-}
-
-interface DirectRead {
-  path: string;
-  firstLine?: number;
-  lastLine?: number;
-}
-
-function directRead(command: string): DirectRead | null {
-  const payload = shellPayload(command).trim();
-  const path = "(?:\"([^\"]+)\"|'([^']+)'|([^\\s'\"`$;&|<>]+))";
-  const cat = payload.match(
-    new RegExp(`^(?:/bin/)?cat\\s+(?:--\\s+)?${path}$`),
-  );
-  if (cat) return { path: cat[1] ?? cat[2] ?? cat[3]! };
-  const sed = payload.match(
-    new RegExp(`^(?:/bin/)?sed\\s+-n\\s+['"]?(\\d+),(\\d+)p['"]?\\s+${path}$`),
-  );
-  if (!sed) return null;
-  const firstLine = Number(sed[1]);
-  const lastLine = Number(sed[2]);
-  if (
-    !Number.isSafeInteger(firstLine) ||
-    firstLine < 1 ||
-    !Number.isSafeInteger(lastLine) ||
-    lastLine < firstLine
-  )
-    return null;
-  return { path: sed[3] ?? sed[4] ?? sed[5]!, firstLine, lastLine };
-}
-
-function within(root: string, path: string): boolean {
-  const child = relative(root, path);
-  return child !== ".." && !child.startsWith(`..${sep}`) && !isAbsolute(child);
-}
-
-function readRange(body: string, read: DirectRead): [number, number] {
-  if (read.firstLine === undefined || read.lastLine === undefined)
-    return [0, body.length];
-  const lines = body.match(/[^\n]*\n|[^\n]+$/g) ?? [];
-  const start = lines.slice(0, read.firstLine - 1).join("").length;
-  const end = lines.slice(0, read.lastLine).join("").length;
-  return [start, end];
-}
-
-async function verifiedSkillRead(
-  item: CodexItem,
-  workspace: string,
-  pluginRoots: string[],
-  commandCwd = workspace,
-): Promise<{
-  skill: string;
-  path: string;
-  range: [number, number];
-  bodyLength: number;
-} | null> {
-  if (typeof item.command !== "string") return null;
-  const read = directRead(item.command);
-  if (!read || typeof item.aggregated_output !== "string") return null;
-  const resolved = resolve(commandCwd, read.path);
-  const actual = await realpath(resolved).catch(() => null);
-  if (!actual) return null;
-  const mountedMatch = relative(workspace, actual)
-    .split(sep)
-    .join("/")
-    .match(SKILL_PATH);
-  const pluginMatch = pluginRoots
-    .map((root) =>
-      relative(root, actual).split(sep).join("/").match(PLUGIN_SKILL_PATH),
-    )
-    .find((match) => match !== null);
-  const match = mountedMatch ?? pluginMatch;
-  if (!match) return null;
-  const body = await readFile(actual).catch(() => null);
-  if (!body || body.byteLength > MAX_SKILL_BYTES) return null;
-  const text = body.toString("utf8");
-  const skill = match[1]!;
-  if (!text.startsWith("---\n") || !text.includes(`\nname: ${skill}\n`))
-    return null;
-  const range = readRange(text, read);
-  if (range[0] === range[1]) return null;
-  if (!item.aggregated_output.includes(text.slice(...range))) return null;
-  return { skill, path: actual, range, bodyLength: text.length };
-}
-
-function fullCoverage(
-  ranges: Array<[number, number]>,
-  length: number,
-): boolean {
-  const ordered = ranges.sort((left, right) => left[0] - right[0]);
-  let covered = 0;
-  for (const [start, end] of ordered) {
-    if (start > covered) return false;
-    covered = Math.max(covered, end);
-  }
-  return covered === length;
-}
-
-interface NativeEntry {
-  ordinal: number;
-  payload: Record<string, unknown>;
-}
-
-export interface NativeReadDiagnostic {
-  completeness: "complete" | "partial";
-  observedSkills: string[];
-  completedReads: Array<{ skill: string; ordinal: number }>;
-  recoverySources: Array<{
-    ordinal: number;
-    nativeOutput: boolean;
-    yieldedChunks: number;
-    completedCall: boolean;
-    literalCommandCall: boolean;
-  }>;
-  commandExecutions: number;
-  readAttempts: number;
-  truncated: boolean;
-}
-
-function nativeCommandText(value: unknown): string | null {
-  if (typeof value === "string") return value;
-  if (!Array.isArray(value) || !value.every((part) => typeof part === "string"))
-    return null;
-  if (value.length >= 3 && (value[1] === "-lc" || value[1] === "-c"))
-    return value.slice(2).join(" ");
-  return value.join(" ");
-}
-
-/** Verify native skill-file reads without retaining commands or output. */
-export async function codexNativeReadDiagnostic(
-  entries: NativeEntry[],
-  workspace: string,
-  installedPluginRoots: string[] = [],
-): Promise<NativeReadDiagnostic> {
-  const canonicalWorkspace = await realpath(workspace);
-  const pluginRoots = await Promise.all(
-    installedPluginRoots.map((root) => realpath(root)),
-  );
-  const recoveredOutputs = nativeCommandOutputs(entries);
-  const attempted = new Map<
-    string,
-    { ranges: Array<[number, number]>; bodyLength: number }
-  >();
-  const observedSkills: string[] = [];
-  const completedReads: Array<{ skill: string; ordinal: number }> = [];
-  const recoverySources: NativeReadDiagnostic["recoverySources"] = [];
-  let commandExecutions = 0;
-  let readAttempts = 0;
-  let partial = false;
-  let truncated = false;
-  for (const { ordinal, payload } of entries) {
-    const item = payload.item;
-    if (
-      payload.type !== "item_completed" ||
-      !item ||
-      typeof item !== "object" ||
-      Array.isArray(item) ||
-      (item as CodexItem).type !== "CommandExecution"
-    )
-      continue;
-    const commandItem = item as CodexItem & { cwd?: unknown };
-    commandExecutions++;
-    const command = nativeCommandText(commandItem.command);
-    if (!command) {
-      partial = true;
-      continue;
-    }
-    if (!command.includes("SKILL.md")) continue;
-    readAttempts++;
-    if (readAttempts > MAX_NATIVE_READ_ATTEMPTS) {
-      readAttempts = MAX_NATIVE_READ_ATTEMPTS;
-      truncated = true;
-      partial = true;
-      break;
-    }
-    const recovered = recoveredOutputs.get(ordinal);
-    recoverySources.push({
-      ordinal,
-      nativeOutput:
-        typeof commandItem.aggregated_output === "string" &&
-        commandItem.aggregated_output.length > 0,
-      yieldedChunks: recovered?.chunks ?? 0,
-      completedCall: recovered?.completedCall === true,
-      literalCommandCall: recovered?.literalCommandCall === true,
-    });
-    if (
-      typeof commandItem.exit_code !== "number" ||
-      commandItem.status !== "completed"
-    ) {
-      partial = true;
-      continue;
-    }
-    const cwd =
-      commandItem.cwd === undefined
-        ? canonicalWorkspace
-        : typeof commandItem.cwd === "string" && isAbsolute(commandItem.cwd)
-          ? await realpath(commandItem.cwd).catch(() => null)
-          : null;
-    if (!cwd) {
-      partial = true;
-      continue;
-    }
-    const read = await verifiedSkillRead(
-      {
-        ...commandItem,
-        command,
-        aggregated_output:
-          (recoveredOutputs.get(ordinal)?.output ?? "") +
-          (typeof commandItem.aggregated_output === "string"
-            ? commandItem.aggregated_output
-            : ""),
-      },
-      canonicalWorkspace,
-      pluginRoots,
-      cwd,
-    );
-    if (!read) {
-      partial = true;
-      continue;
-    }
-    const prior = attempted.get(read.path);
-    const coverage =
-      prior && !fullCoverage(prior.ranges, prior.bodyLength)
-        ? prior
-        : {
-            ranges: [],
-            bodyLength: read.bodyLength,
-          };
-    coverage.ranges.push(read.range);
-    attempted.set(read.path, coverage);
-    if (fullCoverage(coverage.ranges, coverage.bodyLength)) {
-      completedReads.push({ skill: read.skill, ordinal });
-      if (!observedSkills.includes(read.skill)) observedSkills.push(read.skill);
-    }
-  }
-  return {
-    completeness:
-      !partial &&
-      [...attempted.values()].every(({ ranges, bodyLength }) =>
-        fullCoverage(ranges, bodyLength),
-      )
-        ? "complete"
-        : "partial",
-    observedSkills,
-    completedReads,
-    recoverySources,
-    commandExecutions,
-    readAttempts,
-    truncated,
-  };
-}
-
-/** Retain only ordered mounted-skill names, never commands or skill bodies. */
-export async function codexSkillReadObservation(
-  stream: string,
-  workspace: string,
-  installedPluginRoots: string[] = [],
-  recoveredReads: Map<string, { command: string; output: string }> = new Map(),
-): Promise<{
-  id: "sevro.codex.skill-reads";
-  completeness: "complete" | "partial";
-  data: {
-    method: "skill_file_read_probe";
-    primarySkill: string | null;
-    observedSkills: string[];
-  };
-}> {
-  const observedSkills: string[] = [];
-  const attempted = new Map<
-    string,
-    { ranges: Array<[number, number]>; bodyLength: number }
-  >();
-  const pending = new Set<string>();
-  let partial = false;
-  let completedTurn = false;
-  const canonicalWorkspace = await realpath(workspace);
-  const pluginRoots = await Promise.all(
-    installedPluginRoots.map((root) => realpath(root)),
-  );
-  for (const line of stream.split("\n")) {
-    if (!line.trim()) continue;
-    const event = JSON.parse(line) as CodexEvent;
-    let item = event.item;
-    if (typeof item?.id === "string") {
-      const recovered = recoveredReads.get(item.id);
-      if (
-        recovered &&
-        typeof item.command === "string" &&
-        shellPayload(item.command) === shellPayload(recovered.command)
-      )
-        item = {
-          ...item,
-          aggregated_output:
-            recovered.output +
-            (typeof item.aggregated_output === "string"
-              ? item.aggregated_output
-              : ""),
-        };
-    }
-    if (event.type === "turn.completed") completedTurn = true;
-    if (event.type === "turn.failed") partial = true;
-    if (!item || item.type !== "command_execution") continue;
-    if (event.type === "item.started") {
-      if (
-        typeof item.command === "string" &&
-        item.command.includes("SKILL.md")
-      ) {
-        if (typeof item.id === "string") pending.add(item.id);
-        else partial = true;
-      }
-      continue;
-    }
-    if (event.type !== "item.completed") continue;
-    if (typeof item.id === "string") pending.delete(item.id);
-    if (typeof item.command !== "string") {
-      partial = true;
-      continue;
-    }
-    if (!item.command.includes("SKILL.md")) continue;
-    if (typeof item.exit_code !== "number" || item.status !== "completed") {
-      partial = true;
-      continue;
-    }
-    const read = await verifiedSkillRead(item, canonicalWorkspace, pluginRoots);
-    if (!read) {
-      partial = true;
-      continue;
-    }
-    const coverage = attempted.get(read.path) ?? {
-      ranges: [],
-      bodyLength: read.bodyLength,
-    };
-    coverage.ranges.push(read.range);
-    attempted.set(read.path, coverage);
-    if (
-      fullCoverage(coverage.ranges, coverage.bodyLength) &&
-      !observedSkills.includes(read.skill)
-    )
-      observedSkills.push(read.skill);
-  }
-  return {
-    id: "sevro.codex.skill-reads",
-    completeness:
-      completedTurn &&
-      !partial &&
-      pending.size === 0 &&
-      [...attempted.values()].every(({ ranges, bodyLength }) =>
-        fullCoverage(ranges, bodyLength),
-      )
-        ? "complete"
-        : "partial",
-    data: {
-      method: "skill_file_read_probe",
-      primarySkill: observedSkills[0] ?? null,
-      observedSkills,
-    },
-  };
-}

package/src/preparation.ts

@@ -1,211 +0,0 @@
-import { createHash } from "node:crypto";
-import { lstat, mkdir, readFile, realpath, stat } from "node:fs/promises";
-import { isAbsolute, join, relative, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const MAX_ARTIFACT_BYTES = 8 * 1024 * 1024;
-const MAX_TOTAL_BYTES = 32 * 1024 * 1024;
-
-export interface PreparationArtifact {
-  id: string;
-  relativePath: string;
-  sha256: string;
-  contentBase64?: string;
-  sourceRef?: string;
-  gitExclude?: boolean;
-  executable?: boolean;
-}
-
-export interface InlineArtifact {
-  id: string;
-  relativePath: string;
-  sha256: string;
-  bytes: Uint8Array;
-  gitExclude?: boolean;
-  executable?: boolean;
-}
-
-export interface PreparationSources {
-  root: string;
-  refs: Record<string, string>;
-}
-
-export function fixtureParts(relativePath: string): string[] {
-  if (
-    !relativePath ||
-    isAbsolute(relativePath) ||
-    relativePath.includes("\\") ||
-    /:/.test(relativePath)
-  )
-    throw new Error(`invalid fixture path: ${relativePath}`);
-  const parts = relativePath.split("/");
-  if (parts.some((part) => !part || part === "." || part === ".."))
-    throw new Error(`invalid fixture path: ${relativePath}`);
-  return parts;
-}
-
-/** Refuse fixture or setup-created links before mounting trusted artifact bytes. */
-export async function safePreparationTarget(
-  workspace: string,
-  relativePath: string,
-): Promise<string> {
-  const parts = fixtureParts(relativePath);
-  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("preparation artifact traverses a non-directory");
-    } catch (error) {
-      if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-        throw error;
-      await mkdir(parent, { mode: 0o700 });
-    }
-  }
-  const target = join(workspace, ...parts);
-  try {
-    await lstat(target);
-    throw new Error("preparation artifact path already exists");
-  } catch (error) {
-    if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-      throw error;
-  }
-  return target;
-}
-
-function validatePaths(paths: string[]): void {
-  const normalized = paths.map((path) =>
-    fixtureParts(path).join("/").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("fixture paths collide");
-    }
-  }
-}
-
-/** Decode declared inline artifacts before creating a candidate workspace. */
-export function prepareInlineArtifacts(
-  declarations: PreparationArtifact[],
-  fixturePaths: string[],
-): InlineArtifact[] {
-  validatePaths([
-    ...fixturePaths,
-    ...declarations.map((item) => item.relativePath),
-  ]);
-  const ids = new Set<string>();
-  let totalBytes = 0;
-  return declarations.map((item) => {
-    if (!item.id || ids.has(item.id))
-      throw new Error("preparation artifact IDs must be unique and nonempty");
-    ids.add(item.id);
-    if (item.gitExclude !== undefined && typeof item.gitExclude !== "boolean")
-      throw new Error("preparation artifact gitExclude must be boolean");
-    if (item.executable !== undefined && typeof item.executable !== "boolean")
-      throw new Error("preparation artifact executable must be boolean");
-    if (item.gitExclude && /[\u0000-\u001f\u007f]/.test(item.relativePath))
-      throw new Error("Git-excluded artifact path contains control characters");
-    if (item.sourceRef !== undefined || typeof item.contentBase64 !== "string")
-      throw new Error("preparation source references are not supported");
-    const encoded = item.contentBase64;
-    if (
-      !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(
-        encoded,
-      )
-    )
-      throw new Error("preparation artifact content is not canonical base64");
-    const bytes = Buffer.from(encoded, "base64");
-    if (bytes.toString("base64") !== encoded)
-      throw new Error("preparation artifact content is not canonical base64");
-    totalBytes += bytes.byteLength;
-    if (bytes.byteLength > MAX_ARTIFACT_BYTES || totalBytes > MAX_TOTAL_BYTES)
-      throw new Error("preparation artifacts exceed the size limit");
-    const actual = createHash("sha256").update(bytes).digest("hex");
-    if (actual !== item.sha256)
-      throw new Error("preparation artifact digest does not match content");
-    return {
-      id: item.id,
-      relativePath: item.relativePath,
-      sha256: item.sha256,
-      bytes,
-      ...(item.gitExclude === undefined ? {} : { gitExclude: item.gitExclude }),
-      ...(item.executable === undefined ? {} : { executable: item.executable }),
-    };
-  });
-}
-
-/** Resolve opaque source IDs only through an explicitly declared case source map. */
-export async function prepareArtifacts(
-  declarations: PreparationArtifact[],
-  fixturePaths: string[],
-  sources?: PreparationSources,
-): Promise<InlineArtifact[]> {
-  if (!declarations.some((item) => item.sourceRef !== undefined))
-    return prepareInlineArtifacts(declarations, fixturePaths);
-  if (!sources || !isAbsolute(sources.root))
-    throw new Error("preparation source root is required and must be absolute");
-  const root = await realpath(sources.root).catch(() => {
-    throw new Error("preparation source root is unreadable");
-  });
-  const resolved: PreparationArtifact[] = [];
-  let sourceBytes = 0;
-  for (const item of declarations) {
-    if (item.sourceRef === undefined) {
-      resolved.push(item);
-      continue;
-    }
-    if (item.contentBase64 !== undefined)
-      throw new Error("preparation artifact has two content sources");
-    if (!Object.hasOwn(sources.refs, item.sourceRef))
-      throw new Error("preparation source reference is not declared");
-    const url = sources.refs[item.sourceRef];
-    if (typeof url !== "string" || !url.startsWith("file:///"))
-      throw new Error("preparation source reference must be a file URL");
-    let path: string;
-    try {
-      path = await realpath(fileURLToPath(url));
-    } catch {
-      throw new Error("preparation source is unreadable");
-    }
-    const child = relative(root, path);
-    if (
-      !child ||
-      child === ".." ||
-      child.startsWith(`..${sep}`) ||
-      isAbsolute(child)
-    )
-      throw new Error("preparation source escapes its declared root");
-    let size: number;
-    try {
-      size = (await stat(path)).size;
-    } catch {
-      throw new Error("preparation source is unreadable");
-    }
-    if (size > MAX_ARTIFACT_BYTES || sourceBytes + size > MAX_TOTAL_BYTES)
-      throw new Error("preparation artifacts exceed the size limit");
-    let bytes: Buffer;
-    try {
-      bytes = await readFile(path);
-    } catch {
-      throw new Error("preparation source is unreadable");
-    }
-    sourceBytes += bytes.byteLength;
-    if (bytes.byteLength > MAX_ARTIFACT_BYTES || sourceBytes > MAX_TOTAL_BYTES)
-      throw new Error("preparation artifacts exceed the size limit");
-    resolved.push({
-      id: item.id,
-      relativePath: item.relativePath,
-      sha256: item.sha256,
-      contentBase64: bytes.toString("base64"),
-      ...(item.gitExclude === undefined ? {} : { gitExclude: item.gitExclude }),
-      ...(item.executable === undefined ? {} : { executable: item.executable }),
-    });
-  }
-  return prepareInlineArtifacts(resolved, fixturePaths);
-}