@visual-z/xeno 0.8.4 → 0.9.1

package/src/store/restore.ts

@@ -1,110 +0,0 @@
-/**
- * Walking a node's ancestry for history: every ancestor's events, bounded by
- * the fork point below each one.
- *
- * WHY THIS DOES NOT REUSE readAncestry. That walk stops at a cut, because a
- * handoff basis means the parent's events do not replay -- correct for
- * context, wrong for files and turns. File history (checkpoint-history.ts)
- * therefore walks to the root whatever each node declared about context; the
- * "context" scope stops at an explicit new root instead.
- */
-
-import { readNode, readManifest, digestNode, MAX_ANCESTRY_DEPTH, type Manifest } from "./log.ts";
-import type { LogEvent } from "../core/events.ts";
-
-/**
- * Where to move the workspace to. A bare node means the end of that node;
- * `atEvent` names a point inside it, which is what makes an ordinary undo
- * possible within the node being worked in.
- */
-export type RestoreTarget = number | { node: number; atEvent?: string };
-
-/** One ancestor's contribution: its events, bounded by any fork point below it. */
-export interface NodeEvents {
-  node: number;
-  events: LogEvent[];
-}
-
-export type NodeHistoryResult =
-  | { ok: true; nodes: NodeEvents[] }
-  | { ok: false; error: string };
-
-/**
- * Every ancestor's events, root-to-leaf, bounded by the fork points below.
- *
- * The one traversal both file history and turn history are built on. They
- * have to agree about where a node's history begins, or a rewind would move
- * the files to one point and the conversation to another.
- */
-export async function readNodeHistory(
-  dir: string,
-  node: number,
-  manifest?: Manifest,
-  scope: "workspace" | "context" = "workspace",
-): Promise<NodeHistoryResult> {
-  const index = manifest ?? await readManifest(dir);
-  const chain: NodeEvents[] = [];
-  const seen = new Set<number>();
-  let current: number | null = node;
-  // Set by a child's parent pointer: this ancestor contributes only the
-  // events up to and including that one.
-  let cutoff: string | undefined;
-  let depth = 0;
-
-  while (current !== null) {
-    if (seen.has(current)) {
-      return {
-        ok: false,
-        error: `CYCLE: parent chain from node ${node} revisits node ${current}`,
-      };
-    }
-    seen.add(current);
-    if (depth++ >= MAX_ANCESTRY_DEPTH) {
-      return {
-        ok: false,
-        error: `TOO_DEEP: history of node ${node} exceeded ${MAX_ANCESTRY_DEPTH} nodes`,
-      };
-    }
-
-    const { header, events, corrupt } = await readNode(dir, current);
-    const sealed = index.nodes.find((n) => n.node === current);
-    if (sealed && sealed.sha256 !== await digestNode(dir, current)) {
-      return { ok: false, error: `INTEGRITY: node ${current} digest differs from its sealed record` };
-    }
-    if (header === null) {
-      return { ok: false, error: `MISSING_HEADER: node ${current} has no header line` };
-    }
-    if (corrupt.length > 0) {
-      return {
-        ok: false,
-        error: `CORRUPT: node ${current} has ${corrupt.length} unparsable line(s)`,
-      };
-    }
-
-    // The fork point is an event id in the node's whole stream, never a
-    // count of checkpoints: a turn that changed nothing writes none.
-    let contributed = events;
-    if (cutoff !== undefined) {
-      const at = events.findIndex((e) => e.id === cutoff);
-      if (at === -1) {
-        // Refused rather than falling back to the whole node. The fallback is
-        // the silent form of the bug the cutoff exists to prevent: it would
-        // restore exactly the work the fork was made to leave behind.
-        return {
-          ok: false,
-          error: `NO_SUCH_EVENT: node ${current} has no event ${cutoff} (fork point reached from ${node})`,
-        };
-      }
-      contributed = events.slice(0, at + 1);
-    }
-
-    chain.push({ node: current, events: contributed });
-    cutoff = header.parent?.at_event;
-    // A fresh subagent inherits files, not the parent's observations. Context
-    // history crosses compaction boundaries but stops at an explicit new root.
-    current = scope === "context" && header.basis === "none" ? null : header.parent?.node ?? null;
-  }
-
-  chain.reverse();
-  return { ok: true, nodes: chain };
-}

package/src/store/review.ts

@@ -1,109 +0,0 @@
-/** Read-only Git review with fixed argv; project diff drivers cannot execute code. */
-import { lstat } from "node:fs/promises";
-import { join } from "node:path";
-import type { FileChanges } from "../core/checkpoints.ts";
-import { changedPaths } from "../core/checkpoints.ts";
-import { ToolFault, READ_ATTEMPTED } from "../core/tool-failure.ts";
-import { unifiedFileDiff, type ReviewScope, type ReviewSnapshot } from "../core/review.ts";
-import { gitBytes, MAX_UNTRACKED_BYTES } from "./workspace-observation.ts";
-import { readEditableFile } from "./file-checkpoints.ts";
-import { getBlobBytes, blobAddress } from "./blobs.ts";
-
-// Assumed bounded review memory. Exceeding it is unavailable, never silently partial.
-export const MAX_REVIEW_BYTES = 16 * 1024 * 1024;
-const decode = (bytes: Uint8Array) => new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-const flags = ["--no-pager", "--literal-pathspecs", "-c", "core.hooksPath=/dev/null"];
-const diffFlags = ["--no-ext-diff", "--no-textconv", "--no-renames", "--relative"];
-const checkedText = (bytes: Uint8Array) => {
-  if (bytes.byteLength > MAX_REVIEW_BYTES) throw new Error("review exceeds the byte budget; choose a narrower scope");
-  return decode(bytes);
-};
-const ordinaryText = (bytes: Uint8Array): string | null => {
-  if (bytes.includes(0)) return null;
-  try { return decode(bytes); } catch { return null; }
-};
-
-export async function readReview(root: string, scope: Exclude<ReviewScope, { kind: "last-turn" }>, signal?: AbortSignal, canRead?: (path: string) => Promise<boolean>): Promise<ReviewSnapshot> {
-  const git = (args: readonly string[], input?: Uint8Array) => gitBytes(root, [...flags, ...args], input, signal);
-  const revision = async (value: string) => {
-    if (!value || value.includes("\0") || value.startsWith("-")) throw new Error("review revision must name a commit or branch");
-    const sha = decode(await git(["rev-parse", "--verify", "--end-of-options", value + "^{commit}"])).trim();
-    if (!/^[a-f0-9]{40,64}$/.test(sha)) throw new Error("review revision did not resolve to a commit");
-    return sha;
-  };
-  const emptyTree = async () => decode(await git(["hash-object", "-t", "tree", "--stdin"], new Uint8Array())).trim();
-  let base: string, end: string | undefined, label: string;
-  if (scope.kind === "commit") {
-    end = await revision(scope.commit);
-    const parents = decode(await git(["rev-list", "--parents", "-n", "1", end])).trim().split(" ");
-    base = parents[1] ?? await emptyTree();
-    label = `commit ${end.slice(0, 12)}${parents.length > 2 ? " against its first parent" : ""}`;
-  } else if (scope.kind === "branch") {
-    const branch = await revision(scope.base), head = await revision("HEAD");
-    base = decode(await git(["merge-base", head, branch])).trim();
-    label = `changes against ${scope.base} (merge base ${base.slice(0, 12)})`;
-  } else {
-    try { base = await revision("HEAD"); }
-    catch {
-      // An unborn branch has no HEAD; a corrupt/missing existing HEAD stays unavailable.
-      const heads = decode(await git(["rev-list", "--all", "--count"])).trim();
-      if (heads !== "0") throw new Error("working review cannot resolve HEAD");
-      base = await emptyTree();
-    }
-    label = "current staged, unstaged and untracked changes";
-  }
-  const range = [base, ...(end === undefined ? [] : [end])];
-  const paths = decode(await git(["diff", ...diffFlags, "--name-only", "-z", ...range, "--", "."])).split("\0").filter(Boolean);
-  const untracked = scope.kind === "commit" ? [] : decode(await git(["ls-files", "--others", "--exclude-standard", "-z", "--", "."])).split("\0").filter(Boolean);
-  for (const path of [...new Set([...paths, ...untracked])]) if (canRead && !await canRead(path))
-    throw new ToolFault("permission_denied", `diff resource access denied: ${path}`, READ_ATTEMPTED);
-  // Freeze the authorized path set in the actual collection argv. A concurrent
-  // change to a different path must not widen this observation after admission.
-  const diff = paths.length ? checkedText(await git(["diff", ...diffFlags, ...range, "--", ...paths])) : "";
-  const parts = [diff], limitations: string[] = [];
-  let bytes = Buffer.byteLength(diff);
-  if (scope.kind !== "commit") {
-    for (const path of untracked.sort()) {
-      if (signal?.aborted) throw new Error("review cancelled");
-      const info = await lstat(join(root, path));
-      if (info.size > MAX_UNTRACKED_BYTES) { limitations.push(`Untracked file ${JSON.stringify(path)} exceeds ${MAX_UNTRACKED_BYTES} bytes and is unavailable.`); continue; }
-      let source: Awaited<ReturnType<typeof readEditableFile>>;
-      try { source = await readEditableFile(root, path); }
-      catch { limitations.push(`Untracked file ${JSON.stringify(path)} is not an ordinary confined file.`); continue; }
-      if (source.bytes === null) throw new Error(`untracked file disappeared during review: ${path}`);
-      const text = ordinaryText(source.bytes);
-      const addition = text === null ? `Binary untracked file ${JSON.stringify(path)}: ${source.bytes.byteLength} bytes, sha256 ${source.version!.sha256}\n`
-        : unifiedFileDiff(path, null, text);
-      bytes += Buffer.byteLength(addition);
-      if (bytes > MAX_REVIEW_BYTES) throw new Error("review exceeds the byte budget; choose a narrower scope");
-      parts.push(addition); paths.push(path);
-      if (text === null) limitations.push(`Binary untracked content is identified but cannot be reviewed as text: ${JSON.stringify(path)}.`);
-    }
-  }
-  return { scope, label, diff: parts.join("\n"), paths: [...new Set(paths)].sort(), limitations, base };
-}
-
-/** Build last-turn review from verified checkpoint blobs, independent of present disk bytes. */
-export async function readCheckpointReview(blobs: string, changes: FileChanges, limitations: readonly string[] = [], canRead?: (path: string) => Promise<boolean>): Promise<ReviewSnapshot> {
-  const parts: string[] = [], notices = [...limitations], paths = changedPaths(changes);
-  for (const path of paths) if (canRead && !await canRead(path))
-    throw new ToolFault("permission_denied", `diff resource access denied: ${path}`, READ_ATTEMPTED);
-  let bytes = 0;
-  for (const path of paths) {
-    const firstPart = parts.length;
-    const { before, after } = changes[path]!;
-    const source = before === null ? null : await getBlobBytes(blobs, before.sha256);
-    const target = after === null ? null : await getBlobBytes(blobs, after.sha256);
-    if (before && (source === null || blobAddress(source) !== before.sha256) || after && (target === null || blobAddress(target) !== after.sha256))
-      throw new Error(`missing or corrupt last-turn checkpoint object: ${path}`);
-    const oldText = source === null ? null : ordinaryText(source), newText = target === null ? null : ordinaryText(target);
-    if (source !== null && oldText === null || target !== null && newText === null) {
-      parts.push(`Binary checkpoint change ${JSON.stringify(path)}: ${before?.sha256 ?? "absent"} -> ${after?.sha256 ?? "absent"}\n`);
-      notices.push(`Binary checkpoint content cannot be reviewed as text: ${JSON.stringify(path)}.`);
-    } else parts.push(unifiedFileDiff(path, oldText, newText));
-    if (before && after && before.mode !== after.mode) parts.push(`mode ${JSON.stringify(path)}: ${before.mode.toString(8)} -> ${after.mode.toString(8)}\n`);
-    bytes += parts.slice(firstPart).reduce((total, part) => total + Buffer.byteLength(part), 0);
-    if (bytes > MAX_REVIEW_BYTES) throw new Error("last-turn review exceeds the byte budget");
-  }
-  return { scope: { kind: "last-turn" }, label: "captured file changes in the last user turn", diff: parts.join("\n"), paths, limitations: notices };
-}

package/src/store/runtime-target.ts

@@ -1,64 +0,0 @@
-/** R8: OS inspection is confined to the exact owned PID; never discover a target by its name or port. */
-import { realpath, readlink, stat } from "node:fs/promises";
-import { dirname, basename, resolve, relative, sep } from "node:path";
-import { connect } from "node:net";
-import { observeArgvCommand } from "./command.ts";
-import { readObservation } from "./observations.ts";
-import { observeArtifactFiles, archiveCommandArtifacts } from "./command-artifacts.ts";
-import { lsofOwnsImage, lsofOwnsPort } from "../core/runtime-target.ts";
-import type { ArtifactRef } from "../core/events.ts";
-
-// Assumed probe limits. Output beyond the budget and unavailable OS fields remain unknown.
-const PROBE_BYTES = 64 * 1024;
-const PROBE_MS = 2_000;
-export async function targetDirectory(root: string, path: string): Promise<string> {
-  const base = await realpath(root), cwd = await realpath(resolve(base, path)), rel = relative(base, cwd);
-  if (rel === ".." || rel.startsWith(`..${sep}`) || rel.startsWith(sep) || !(await stat(cwd)).isDirectory()) throw Error("target workdir escapes the workspace or is not a directory");
-  return cwd;
-}
-export async function targetProgram(path: string, signal?: AbortSignal) {
-  const absolute = await realpath(path);
-  const [file] = await observeArtifactFiles(dirname(absolute), [basename(absolute)], signal);
-  if (file?.state !== "observed") throw Error("target executable cannot be observed as a stable ordinary file");
-  return { path: absolute, sha256: file.sha256, device: file.identity.device, inode: file.identity.inode };
-}
-export async function observeRuntimeIdentity(pid: number, program: { path: string; device: string; inode: string }, port: number | undefined,
-  outputStore: string, signal?: AbortSignal): Promise<{ image: boolean; port: boolean | null; known: boolean; raw: ArtifactRef[]; reason: string }> {
-  const raw: ArtifactRef[] = [];
-  const lsof = process.platform === "darwin" ? "/usr/sbin/lsof" : "/usr/bin/lsof";
-  const probe = async (args: string[]) => {
-    const result = await observeArgvCommand({ argv: [lsof, ...args], cwd: "/", outputStore, maxOutputBytes: PROBE_BYTES,
-      timeoutMs: PROBE_MS, outputLimitBytes: PROBE_BYTES, ...(signal ? { signal } : {}) });
-    raw.push(result.stdout, result.stderr);
-    raw.push(await archiveCommandArtifacts(outputStore, { argv: [lsof, ...args], cwd: "/", exit: result.exit, capture: result.capture,
-      stdout: result.stdout, stderr: result.stderr, stopped: result.stopped ?? null, cleanup: result.cleanup ?? null }));
-    if (result.stopped || result.cleanup || result.capture !== "complete" || result.stdout.bytes > PROBE_BYTES || ![0, 1].includes(result.exit)) throw Error("OS target observation was incomplete");
-    return (await readObservation(outputStore, result.stdout.sha256, 0, PROBE_BYTES)).text;
-  };
-  try {
-    let image: boolean;
-    if (process.platform === "darwin") image = lsofOwnsImage(await probe(["-a", "-p", String(pid), "-d", "txt", "-F0pftDin"]), pid, program.device, program.inode);
-    else if (process.platform === "linux") {
-      const path = `/proc/${pid}/exe`, observed = await stat(path, { bigint: true });
-      const link = await readlink(path), device = String(observed.dev), inode = String(observed.ino);
-      raw.push(await archiveCommandArtifacts(outputStore, { path, link, device, inode }));
-      image = link === program.path && device === program.device && inode === program.inode;
-    } else return { image: false, port: port === undefined ? null : false, known: false, raw, reason: "OS executable identity is unsupported on this platform" };
-    const ownsPort = port === undefined ? null : lsofOwnsPort(await probe(["-nP", "-a", "-p", String(pid), `-iTCP:${port}`, "-sTCP:LISTEN", "-F0pftPnT"]), pid, port);
-    const reachable = port === undefined ? null : ownsPort && await loopbackReady(port, signal);
-    return { image, port: reachable, known: true, raw, reason: !image ? "owned process executable does not match the launch observation" : reachable === false ? "the owned PID does not serve the declared IPv4 loopback port" : "owned executable and declared endpoint observed" };
-  } catch { return { image: false, port: port === undefined ? null : false, known: false, raw, reason: "OS target identity could not be established" }; }
-}
-
-async function loopbackReady(port: number, signal?: AbortSignal): Promise<boolean> {
-  if (signal?.aborted) return false;
-  return new Promise(resolve => {
-    const socket = connect({ host: "127.0.0.1", port });
-    const done = (ok: boolean) => { signal?.removeEventListener("abort", abort); socket.destroy(); resolve(ok); };
-    const abort = () => done(false);
-    socket.setTimeout(PROBE_MS, () => done(false));
-    socket.once("connect", () => done(true)); socket.once("error", () => done(false));
-    signal?.addEventListener("abort", abort, { once: true });
-    if (signal?.aborted) abort();
-  });
-}