pi-openai-codex-compat 0.0.9 → 0.0.10-alpha.2

package/extensions/openai-codex-compat/apply-patch-diagnostics.ts

@@ -0,0 +1,573 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { Stats } from "node:fs";
+import { chmod, lstat, mkdir, readFile, readlink, rename, rm, writeFile } from "node:fs/promises";
+import { arch, platform, release } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import {
+  getAgentDir,
+  VERSION as PI_VERSION,
+  type ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import type {
+  ApplyPatchDetails,
+  ApplyPatchDiagnosticsReference,
+  PatchOperation,
+} from "./apply-patch-engine.ts";
+import {
+  parsePatchDocument,
+  scanPatchInstructions,
+} from "./apply-patch-engine/apply-patch-engine-parser.ts";
+import { isObject } from "./codex-protocol.ts";
+import { nodeErrorCode } from "./value-contracts.ts";
+
+export const APPLY_PATCH_DIAGNOSTICS_DIRECTORY = "openai-codex-compat-apply-patch-diagnostics";
+export const APPLY_PATCH_DIAGNOSTICS_SCHEMA_VERSION = 2;
+
+type ApplyPatchDiagnosticsSessionManager = Pick<
+  ExtensionContext["sessionManager"],
+  "getBranch" | "getSessionFile" | "getSessionId"
+>;
+
+export type ApplyPatchDiagnosticsContext = {
+  cwd: string;
+  sessionManager: ApplyPatchDiagnosticsSessionManager;
+};
+
+type DiagnosticError = {
+  name: string;
+  message: string;
+  stack?: string;
+  code?: string;
+  errno?: number | string;
+  syscall?: string;
+  path?: string;
+  destination?: string;
+  cause?: DiagnosticError;
+};
+
+type FilesystemMetadata = {
+  mode: number;
+  modifiedMs: number;
+  size: number;
+  device: number;
+  inode: number;
+  linkCount: number;
+  userId: number;
+  groupId: number;
+};
+
+type SnapshotContent =
+  | {
+      encoding: "binary";
+      byteLength: number;
+      sha256: string;
+    }
+  | {
+      encoding: "utf8";
+      data: string;
+      byteLength: number;
+      sha256: string;
+    };
+
+type SnapshotReference = {
+  instruction: number;
+  role: "destination" | "source";
+  patchPath: string;
+};
+
+type FileSnapshot = {
+  absolutePath: string;
+  references: SnapshotReference[];
+  entry:
+    | { kind: "absent" }
+    | ({ kind: "directory" } & FilesystemMetadata)
+    | ({
+        kind: "regular-file";
+        content: SnapshotContent;
+      } & FilesystemMetadata)
+    | ({
+        kind: "symlink";
+        target: string;
+        resolvedTarget: string;
+        content?: SnapshotContent;
+        contentError?: DiagnosticError;
+      } & FilesystemMetadata)
+    | ({ kind: "unsupported" } & FilesystemMetadata)
+    | { kind: "inspection-error"; error: DiagnosticError };
+};
+
+type ParentSnapshot = {
+  absolutePath: string;
+  entry:
+    | { kind: "absent" }
+    | ({ kind: "directory" } & FilesystemMetadata)
+    | ({ kind: "regular-file" } & FilesystemMetadata)
+    | ({ kind: "unsupported" } & FilesystemMetadata)
+    | ({ kind: "symlink"; target: string; resolvedTarget: string } & FilesystemMetadata)
+    | { kind: "inspection-error"; error: DiagnosticError };
+};
+
+export type ApplyPatchDiagnosticsOutcome = {
+  status: "failed";
+  durationMs: number;
+  error: DiagnosticError;
+  details?: ApplyPatchDetails;
+};
+
+export type PreparedApplyPatchDiagnostics = {
+  diagnosticsDirectory: string;
+  directory: string;
+  reference: ApplyPatchDiagnosticsReference;
+  request: Record<string, unknown> & { snapshots: FileSnapshot[] };
+};
+
+const MAX_ERROR_CAUSE_DEPTH = 8;
+
+function diagnosticError(error: unknown, seen = new Set<unknown>(), depth = 0): DiagnosticError {
+  if (seen.has(error)) {
+    return {
+      name: "CircularErrorCause",
+      message: "Error cause cycle omitted.",
+    };
+  }
+  if (depth >= MAX_ERROR_CAUSE_DEPTH) {
+    return {
+      name: "TruncatedErrorCause",
+      message: `Error cause depth exceeded ${MAX_ERROR_CAUSE_DEPTH}.`,
+    };
+  }
+  if (!(error instanceof Error)) {
+    return {
+      name: "NonErrorThrown",
+      message: String(error),
+    };
+  }
+  seen.add(error);
+  const diagnostic: DiagnosticError = {
+    name: error.name,
+    message: error.message,
+  };
+  if (error.stack) diagnostic.stack = error.stack;
+  const code = nodeErrorCode(error);
+  if (code) diagnostic.code = code;
+  const errno: unknown = Reflect.get(error, "errno");
+  if (typeof errno === "number" || typeof errno === "string") diagnostic.errno = errno;
+  for (const [source, target] of [
+    ["syscall", "syscall"],
+    ["path", "path"],
+    ["dest", "destination"],
+  ] as const) {
+    const value: unknown = Reflect.get(error, source);
+    if (typeof value === "string") diagnostic[target] = value;
+  }
+  if (error.cause !== undefined) {
+    diagnostic.cause = diagnosticError(error.cause, seen, depth + 1);
+  }
+  return diagnostic;
+}
+
+function filesystemMetadata(metadata: Stats): FilesystemMetadata {
+  return {
+    mode: metadata.mode & 0o7777,
+    modifiedMs: metadata.mtimeMs,
+    size: metadata.size,
+    device: metadata.dev,
+    inode: metadata.ino,
+    linkCount: metadata.nlink,
+    userId: metadata.uid,
+    groupId: metadata.gid,
+  };
+}
+
+type CompatibilityVersionResult = {
+  version: string;
+  error?: DiagnosticError;
+};
+
+let compatibilityVersionPromise: Promise<CompatibilityVersionResult> | undefined;
+
+function compatibilityVersion(): Promise<CompatibilityVersionResult> {
+  compatibilityVersionPromise ??= readFile(new URL("../../package.json", import.meta.url), "utf8")
+    .then((source) => {
+      const manifest: unknown = JSON.parse(source);
+      const version = isObject(manifest) ? manifest["version"] : undefined;
+      return { version: typeof version === "string" ? version : "unknown" };
+    })
+    .catch((error: unknown) => ({
+      version: "unknown",
+      error: diagnosticError(error),
+    }));
+  return compatibilityVersionPromise;
+}
+
+function processMetadata(): Record<string, unknown> {
+  const metadata: Record<string, unknown> = {
+    id: process.pid,
+    workingDirectory: process.cwd(),
+    umask: process.umask(),
+  };
+  for (const [key, value] of [
+    ["userId", typeof process.getuid === "function" ? process.getuid() : undefined],
+    ["effectiveUserId", typeof process.geteuid === "function" ? process.geteuid() : undefined],
+    ["groupId", typeof process.getgid === "function" ? process.getgid() : undefined],
+    ["effectiveGroupId", typeof process.getegid === "function" ? process.getegid() : undefined],
+  ] as const) {
+    if (value !== undefined) metadata[key] = value;
+  }
+  return metadata;
+}
+
+async function runtimeMetadata(): Promise<Record<string, unknown>> {
+  const compatibility = await compatibilityVersion();
+  return {
+    compatibilityVersion: compatibility.version,
+    ...(compatibility.error ? { compatibilityVersionError: compatibility.error } : {}),
+    piVersion: PI_VERSION,
+    nodeVersion: process.version,
+    operatingSystem: {
+      platform: platform(),
+      release: release(),
+      architecture: arch(),
+    },
+    process: processMetadata(),
+  };
+}
+
+function safePathSegment(value: string): string {
+  const safe = value.replace(/[^0-9A-Za-z._-]/gu, "_");
+  return safe || "unknown-session";
+}
+
+function snapshotContent(content: Buffer): SnapshotContent {
+  const metadata = {
+    byteLength: content.byteLength,
+    sha256: createHash("sha256").update(content).digest("hex"),
+  };
+  try {
+    return {
+      encoding: "utf8",
+      data: new TextDecoder("utf-8", { fatal: true }).decode(content),
+      ...metadata,
+    };
+  } catch (error) {
+    if (!(error instanceof TypeError)) throw error;
+    return {
+      encoding: "binary",
+      ...metadata,
+    };
+  }
+}
+
+async function fileSnapshot(
+  absolutePath: string,
+  references: SnapshotReference[],
+): Promise<FileSnapshot> {
+  try {
+    const metadata = await lstat(absolutePath);
+    const filesystem = filesystemMetadata(metadata);
+    if (metadata.isFile()) {
+      return {
+        absolutePath,
+        references,
+        entry: {
+          kind: "regular-file",
+          ...filesystem,
+          content: snapshotContent(await readFile(absolutePath)),
+        },
+      };
+    }
+    if (metadata.isSymbolicLink()) {
+      const target = await readlink(absolutePath);
+      const resolvedTarget = isAbsolute(target)
+        ? resolve(target)
+        : resolve(dirname(absolutePath), target);
+      const entry: Extract<FileSnapshot["entry"], { kind: "symlink" }> = {
+        kind: "symlink",
+        ...filesystem,
+        target,
+        resolvedTarget,
+      };
+      try {
+        entry.content = snapshotContent(await readFile(absolutePath));
+      } catch (error) {
+        entry.contentError = diagnosticError(error);
+      }
+      return { absolutePath, references, entry };
+    }
+    return {
+      absolutePath,
+      references,
+      entry: metadata.isDirectory()
+        ? { kind: "directory", ...filesystem }
+        : { kind: "unsupported", ...filesystem },
+    };
+  } catch (error) {
+    if (nodeErrorCode(error) === "ENOENT") {
+      return { absolutePath, references, entry: { kind: "absent" } };
+    }
+    return {
+      absolutePath,
+      references,
+      entry: { kind: "inspection-error", error: diagnosticError(error) },
+    };
+  }
+}
+
+async function parentSnapshot(absolutePath: string): Promise<ParentSnapshot> {
+  try {
+    const metadata = await lstat(absolutePath);
+    const filesystem = filesystemMetadata(metadata);
+    if (metadata.isSymbolicLink()) {
+      const target = await readlink(absolutePath);
+      return {
+        absolutePath,
+        entry: {
+          kind: "symlink",
+          ...filesystem,
+          target,
+          resolvedTarget: isAbsolute(target)
+            ? resolve(target)
+            : resolve(dirname(absolutePath), target),
+        },
+      };
+    }
+    return {
+      absolutePath,
+      entry: metadata.isDirectory()
+        ? { kind: "directory", ...filesystem }
+        : metadata.isFile()
+          ? { kind: "regular-file", ...filesystem }
+          : { kind: "unsupported", ...filesystem },
+    };
+  } catch (error) {
+    if (nodeErrorCode(error) === "ENOENT") {
+      return { absolutePath, entry: { kind: "absent" } };
+    }
+    return {
+      absolutePath,
+      entry: { kind: "inspection-error", error: diagnosticError(error) },
+    };
+  }
+}
+
+function parentPaths(paths: Iterable<string>): string[] {
+  const parents = new Set<string>();
+  for (const path of paths) {
+    let parent = dirname(path);
+    while (!parents.has(parent)) {
+      parents.add(parent);
+      const next = dirname(parent);
+      if (next === parent) break;
+      parent = next;
+    }
+  }
+  return [...parents];
+}
+
+function diagnosticOperations(patch: string):
+  | { status: "parsed"; operations: PatchOperation[] }
+  | {
+      status: "parse-error";
+      error: DiagnosticError;
+      instructions: ReturnType<typeof scanPatchInstructions>;
+    } {
+  try {
+    return {
+      status: "parsed",
+      operations: parsePatchDocument(patch).operations,
+    };
+  } catch (error) {
+    return {
+      status: "parse-error",
+      error: diagnosticError(error),
+      instructions: scanPatchInstructions(patch),
+    };
+  }
+}
+
+function snapshotReferences(
+  cwd: string,
+  parsed: ReturnType<typeof diagnosticOperations>,
+): Map<string, SnapshotReference[]> {
+  const paths = new Map<string, SnapshotReference[]>();
+  const add = (instruction: number, role: SnapshotReference["role"], patchPath: string): void => {
+    const absolutePath = isAbsolute(patchPath) ? resolve(patchPath) : resolve(cwd, patchPath);
+    const references = paths.get(absolutePath) ?? [];
+    references.push({ instruction, role, patchPath });
+    paths.set(absolutePath, references);
+  };
+
+  if (parsed.status === "parsed") {
+    for (const [index, operation] of parsed.operations.entries()) {
+      add(index + 1, operation.kind === "add" ? "destination" : "source", operation.path);
+      if (operation.kind === "update" && operation.moveTo) {
+        add(index + 1, "destination", operation.moveTo);
+      }
+    }
+  } else {
+    for (const instruction of parsed.instructions) {
+      add(
+        instruction.index,
+        instruction.kind === "add" ? "destination" : "source",
+        instruction.path,
+      );
+      if (instruction.moveTo) add(instruction.index, "destination", instruction.moveTo);
+    }
+  }
+  return paths;
+}
+
+function optionalString(record: Record<string, unknown>, key: string): string | undefined {
+  const value = record[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function requestIdentifiers(
+  context: ApplyPatchDiagnosticsContext,
+  toolCallId: string,
+): Record<string, unknown> {
+  const separator = toolCallId.indexOf("|");
+  const identifiers: Record<string, unknown> = {
+    toolCallId,
+    providerCallId: separator < 0 ? toolCallId : toolCallId.slice(0, separator),
+  };
+  if (separator >= 0 && separator < toolCallId.length - 1) {
+    identifiers["providerItemId"] = toolCallId.slice(separator + 1);
+  }
+
+  for (const entry of context.sessionManager.getBranch().toReversed()) {
+    if (entry.type !== "message" || entry.message.role !== "assistant") continue;
+    const hasCall = entry.message.content.some(
+      (block) => block.type === "toolCall" && block.id === toolCallId,
+    );
+    if (!hasCall) continue;
+
+    identifiers["assistantEntryId"] = entry.id;
+    identifiers["provider"] = entry.message.provider;
+    identifiers["api"] = entry.message.api;
+    identifiers["model"] = entry.message.model;
+    if (entry.message.responseId) identifiers["responseId"] = entry.message.responseId;
+
+    const transportDiagnostic = entry.message.diagnostics?.findLast(
+      (diagnostic) => diagnostic.type === "codex_transport_request",
+    );
+    if (!isObject(transportDiagnostic?.details)) break;
+    const details = transportDiagnostic.details;
+    for (const key of [
+      "turnId",
+      "threadId",
+      "windowId",
+      "sessionId",
+      "promptCacheKey",
+      "previousResponseId",
+    ]) {
+      const value = optionalString(details, key);
+      if (value !== undefined) identifiers[key] = value;
+    }
+    if (isObject(details["cacheIdentity"])) {
+      const cacheIdentity = details["cacheIdentity"];
+      for (const [source, target] of [
+        ["clientRequestHeader", "clientRequestId"],
+        ["sessionHeader", "sessionHeader"],
+        ["threadHeader", "threadHeader"],
+      ] as const) {
+        const value = optionalString(cacheIdentity, source);
+        if (value !== undefined) identifiers[target] = value;
+      }
+    }
+    break;
+  }
+  return identifiers;
+}
+
+async function privateDirectory(path: string): Promise<void> {
+  await mkdir(path, { recursive: true, mode: 0o700 });
+  await chmod(path, 0o700);
+}
+
+async function writePrivateJson(path: string, value: unknown): Promise<void> {
+  const temporaryPath = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    await writeFile(temporaryPath, `${JSON.stringify(value, null, 2)}\n`, {
+      encoding: "utf8",
+      flag: "wx",
+      mode: 0o600,
+    });
+    await rename(temporaryPath, path);
+  } finally {
+    await rm(temporaryPath, { force: true });
+  }
+}
+
+export async function prepareApplyPatchDiagnostics(
+  context: ApplyPatchDiagnosticsContext,
+  toolCallId: string,
+  patch: string,
+  agentDir = getAgentDir(),
+): Promise<PreparedApplyPatchDiagnostics> {
+  const capturedAt = new Date().toISOString();
+  const recordId = randomUUID();
+  const sessionId = context.sessionManager.getSessionId();
+  const diagnosticsDirectory = join(agentDir, APPLY_PATCH_DIAGNOSTICS_DIRECTORY);
+  const directory = join(diagnosticsDirectory, safePathSegment(sessionId));
+
+  const prefix = `${capturedAt.replace(/[:.]/gu, "-")}_${recordId}`;
+  const requestPath = join(directory, `${prefix}.request.json`);
+  const resultPath = join(directory, `${prefix}.result.json`);
+  const parsed = diagnosticOperations(patch);
+  const references = snapshotReferences(context.cwd, parsed);
+  const [runtime, snapshots, parents] = await Promise.all([
+    runtimeMetadata(),
+    Promise.all(
+      [...references].map(([path, pathReferences]) => fileSnapshot(path, pathReferences)),
+    ),
+    Promise.all(parentPaths(references.keys()).map(parentSnapshot)),
+  ]);
+  const sessionFile = context.sessionManager.getSessionFile();
+  const request = {
+    schemaVersion: APPLY_PATCH_DIAGNOSTICS_SCHEMA_VERSION,
+    recordId,
+    capturedAt,
+    cwd: context.cwd,
+    runtime,
+    session: {
+      id: sessionId,
+      ...(sessionFile ? { file: sessionFile } : {}),
+    },
+    request: requestIdentifiers(context, toolCallId),
+    patch,
+    parsed,
+    snapshots,
+    parents,
+  };
+  return {
+    diagnosticsDirectory,
+    directory,
+    reference: { recordId, requestPath, resultPath },
+    request,
+  };
+}
+
+export async function writeApplyPatchDiagnosticsRequest(
+  prepared: PreparedApplyPatchDiagnostics,
+): Promise<void> {
+  await privateDirectory(prepared.diagnosticsDirectory);
+  await privateDirectory(prepared.directory);
+  await writePrivateJson(prepared.reference.requestPath, prepared.request);
+}
+
+export async function writeApplyPatchDiagnosticsOutcome(
+  reference: ApplyPatchDiagnosticsReference,
+  outcome: ApplyPatchDiagnosticsOutcome,
+): Promise<void> {
+  await writePrivateJson(reference.resultPath, {
+    schemaVersion: APPLY_PATCH_DIAGNOSTICS_SCHEMA_VERSION,
+    recordId: reference.recordId,
+    completedAt: new Date().toISOString(),
+    ...outcome,
+  });
+}
+
+export function applyPatchDiagnosticError(error: unknown): DiagnosticError {
+  return diagnosticError(error);
+}