harnery 0.44.0 → 0.45.0

package/dist/core/turn-rollback/content.d.ts

@@ -0,0 +1,53 @@
+import type { WorkspaceBinding } from "../workflow/workspaces/types.js";
+export declare const SNAPSHOT_LIMIT: number;
+export interface BlobEntry {
+    oid: string;
+    mode: "100644" | "100755";
+}
+export interface ContentEntry {
+    path: string;
+    index: BlobEntry | null;
+    worktree: BlobEntry | null;
+    untracked: boolean;
+}
+export interface ContentSnapshot {
+    head: string;
+    index_tree: string;
+    worktree_tree: string;
+    entries: ContentEntry[];
+    total_bytes: number;
+    sha256: string;
+}
+interface ObservedContent {
+    entries: ContentEntry[];
+    blobs: Map<string, Buffer>;
+    total: number;
+    head: string;
+}
+export declare function git(root: string, args: string[], options?: {
+    input?: Buffer | string;
+    index?: string;
+    bare?: boolean;
+}): Buffer;
+export declare function textGit(root: string, args: string[], options?: Parameters<typeof git>[2]): string;
+export declare function safePaths(binding: WorkspaceBinding, paths: readonly string[]): string[];
+export declare function openParent(binding: WorkspaceBinding, path: string): {
+    path: string;
+    close(): void;
+};
+export declare function observe(binding: WorkspaceBinding, store: string, paths: string[]): ObservedContent;
+export declare function persistSnapshot(store: string, observed: ObservedContent, ref: string): ContentSnapshot;
+export declare function verifySnapshot(store: string, snapshot: ContentSnapshot): void;
+export declare function currentMatches(binding: WorkspaceBinding, store: string, snapshot: ContentSnapshot): boolean;
+export interface IndexLock {
+    path: string;
+    privatePath: string;
+    publish(): void;
+    close(): void;
+}
+export declare function lockIndex(binding: WorkspaceBinding, state: string): IndexLock;
+export declare function stageBefore(binding: WorkspaceBinding, store: string, before: ContentSnapshot, index: IndexLock): void;
+export declare function restoreFile(binding: WorkspaceBinding, store: string, entry: ContentEntry): void;
+export declare function ensureDirectory(path: string): void;
+export {};
+//# sourceMappingURL=content.d.ts.map

package/dist/core/turn-rollback/content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["../../../src/core/turn-rollback/content.ts"],"names":[],"mappings":"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"}

package/dist/core/turn-rollback/content.js

@@ -0,0 +1,396 @@
+import { execFileSync } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { closeSync, constants, existsSync, fchmodSync, fstatSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync, } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { stateDirMode, stateFileMode } from "../storage/modes.js";
+import { fsyncParentDirectory, stableDigest } from "../workflow/durable-record.js";
+import { assertSafeRelativeSegment, containsPath, descriptorPath, filesystemIdentity, sameFilesystemIdentity, } from "../workflow/workspaces/paths.js";
+export const SNAPSHOT_LIMIT = 8 * 1024 * 1024;
+export function git(root, args, options = {}) {
+    const env = { ...process.env };
+    for (const key of Object.keys(env))
+        if (key.startsWith("GIT_"))
+            delete env[key];
+    Object.assign(env, {
+        GIT_OPTIONAL_LOCKS: "0",
+        GIT_CONFIG_NOSYSTEM: "1",
+        GIT_CONFIG_GLOBAL: "/dev/null",
+        GIT_LITERAL_PATHSPECS: "1",
+    });
+    if (args[0] === "check-ignore")
+        delete env.GIT_LITERAL_PATHSPECS;
+    if (options.index)
+        env.GIT_INDEX_FILE = options.index;
+    return execFileSync("git", [options.bare ? `--git-dir=${root}` : "-C", ...(options.bare ? [] : [root]), ...args], {
+        env,
+        input: options.input,
+        maxBuffer: SNAPSHOT_LIMIT + 1024 * 1024,
+        timeout: 10_000,
+        stdio: ["pipe", "pipe", "pipe"],
+    });
+}
+export function textGit(root, args, options) {
+    return git(root, args, options).toString("utf8").trim();
+}
+export function safePaths(binding, paths) {
+    if (!Array.isArray(paths) || paths.length === 0 || paths.length > 100)
+        throw new Error("path count limit is 1 to 100");
+    const normalized = paths
+        .map((path) => {
+        if (typeof path !== "string" || path.length > 2000)
+            throw new Error("invalid content path");
+        for (const part of path.split("/")) {
+            assertSafeRelativeSegment(part, "content path");
+            if ([".git", ".harnery"].includes(part.toLowerCase()))
+                throw new Error("administrative content path is forbidden");
+        }
+        if (relative(binding.workspace_root, resolve(binding.workspace_root, path)).replaceAll("\\", "/") !== path)
+            throw new Error("content path escapes workspace");
+        return path;
+    })
+        .sort();
+    if (new Set(normalized).size !== normalized.length)
+        throw new Error("duplicate content paths");
+    for (const path of normalized) {
+        const opened = openParent(binding, path);
+        opened.close();
+    }
+    return normalized;
+}
+export function openParent(binding, path) {
+    const fds = [];
+    try {
+        const root = binding.workspace_root;
+        let fd = openSync(root, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        fds.push(fd);
+        if (!sameFilesystemIdentity(filesystemIdentity(descriptorPath(fd)), binding.workspace_root_identity))
+            throw new Error("workspace root identity changed");
+        for (const segment of path.split("/").slice(0, -1)) {
+            fd = openSync(join(descriptorPath(fd), segment), constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+            fds.push(fd);
+            if (existsSync(join(descriptorPath(fd), ".git")))
+                throw new Error("nested repository boundary is forbidden");
+        }
+        const parent = descriptorPath(fd);
+        const real = realpathSync(parent);
+        if (!containsPath(root, real))
+            throw new Error("content parent escaped workspace");
+        for (const reserved of [
+            binding.repository?.gitdir.realpath,
+            binding.repository?.common_dir.realpath,
+        ]) {
+            if (reserved && containsPath(reserved, real))
+                throw new Error("Git administrative content is forbidden");
+        }
+        return {
+            path: join(parent, path.split("/").at(-1)),
+            close: () => {
+                for (const handle of fds.reverse())
+                    closeSync(handle);
+            },
+        };
+    }
+    catch (error) {
+        for (const fd of fds.reverse())
+            closeSync(fd);
+        throw error;
+    }
+}
+function bytesAt(binding, path) {
+    const parent = openParent(binding, path);
+    try {
+        let stat;
+        try {
+            stat = lstatSync(parent.path);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return null;
+            throw error;
+        }
+        if (!stat.isFile() || stat.nlink !== 1)
+            throw new Error("content must be an unlinked regular file");
+        if (stat.size > SNAPSHOT_LIMIT)
+            throw new Error("snapshot byte limit exceeded");
+        const fd = openSync(parent.path, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const current = fstatSync(fd);
+            if (!current.isFile() ||
+                current.nlink !== 1 ||
+                current.ino !== stat.ino ||
+                current.dev !== stat.dev)
+                throw new Error("content identity changed");
+            const bytes = readFileSync(fd);
+            const after = fstatSync(fd);
+            if (after.size !== current.size ||
+                after.mtimeMs !== current.mtimeMs ||
+                after.ctimeMs !== current.ctimeMs)
+                throw new Error("content changed during capture");
+            return { bytes, mode: current.mode & 0o111 ? "100755" : "100644" };
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    finally {
+        parent.close();
+    }
+}
+function indexEntries(binding, paths) {
+    const root = binding.workspace_root;
+    if (textGit(root, ["rev-parse", "--shared-index-path"]))
+        throw new Error("split index is unsupported");
+    try {
+        if (textGit(root, ["config", "--bool", "index.sparse"]) === "true")
+            throw new Error("sparse index is unsupported");
+    }
+    catch (error) {
+        if (!(error && typeof error === "object" && "status" in error && error.status === 1))
+            throw error;
+    }
+    const flags = git(root, ["ls-files", "-v", "-z", "--", ...paths])
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean);
+    if (flags.some((flag) => !flag.startsWith("H ")))
+        throw new Error("selected index flags are unsupported");
+    const entries = new Map();
+    const debugFlags = git(root, ["ls-files", "--debug", "-z", "--", ...paths]).toString("utf8");
+    for (const match of debugFlags.matchAll(/flags: ([a-f0-9]+)\n/g)) {
+        if ((Number.parseInt(match[1], 16) & 0x20000000) !== 0)
+            throw new Error("intent-to-add index entries are unsupported");
+    }
+    for (const line of git(root, ["ls-files", "--stage", "-z", "--", ...paths])
+        .toString("utf8")
+        .split("\0")
+        .filter(Boolean)) {
+        const match = /^(100644|100755) ([a-f0-9]{40,64}) 0\t(.+)$/.exec(line);
+        if (!match || /^0+$/.test(match[2]) || !paths.includes(match[3]))
+            throw new Error("unsupported index entry");
+        entries.set(match[3], { mode: match[1], source: match[2] });
+    }
+    return entries;
+}
+export function observe(binding, store, paths) {
+    const staged = indexEntries(binding, paths);
+    const blobs = new Map();
+    let total = 0;
+    const blob = (bytes, mode) => {
+        total += bytes.length;
+        if (total > SNAPSHOT_LIMIT)
+            throw new Error("snapshot byte limit exceeded");
+        const oid = textGit(store, ["hash-object", "--stdin"], { bare: true, input: bytes });
+        blobs.set(oid, bytes);
+        return { oid, mode };
+    };
+    const entries = paths.map((path) => {
+        const index = staged.get(path);
+        const worktree = bytesAt(binding, path);
+        // check-ignore without --no-index only reports untracked ignored paths.
+        if (!index) {
+            try {
+                git(binding.workspace_root, ["check-ignore", "-q", "--", path]);
+                throw new Error("ignored content path is forbidden");
+            }
+            catch (error) {
+                if (!(error && typeof error === "object" && "status" in error && error.status === 1))
+                    throw error;
+            }
+        }
+        return {
+            path,
+            index: index
+                ? blob(git(binding.workspace_root, ["cat-file", "blob", index.source]), index.mode)
+                : null,
+            worktree: worktree ? blob(worktree.bytes, worktree.mode) : null,
+            untracked: !index && worktree !== null,
+        };
+    });
+    return { entries, blobs, total, head: textGit(binding.workspace_root, ["rev-parse", "HEAD"]) };
+}
+function tree(store, entries, side) {
+    const temporary = join(dirname(store), `tree-${randomUUID()}.index`);
+    try {
+        git(store, ["read-tree", "--empty"], { bare: true, index: temporary });
+        for (const entry of entries) {
+            const blob = entry[side];
+            if (blob)
+                git(store, ["update-index", "--add", "--cacheinfo", `${blob.mode},${blob.oid},${entry.path}`], { bare: true, index: temporary });
+        }
+        return textGit(store, ["write-tree"], { bare: true, index: temporary });
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+    }
+}
+export function persistSnapshot(store, observed, ref) {
+    for (const bytes of observed.blobs.values())
+        git(store, ["hash-object", "-w", "--stdin"], { bare: true, input: bytes });
+    const basis = {
+        head: observed.head,
+        entries: observed.entries,
+        total_bytes: observed.total,
+        index_tree: tree(store, observed.entries, "index"),
+        worktree_tree: tree(store, observed.entries, "worktree"),
+    };
+    for (const side of ["index", "worktree"])
+        git(store, ["update-ref", `refs/turns/${ref}/${side}`, basis[`${side}_tree`]], { bare: true });
+    return { ...basis, sha256: stableDigest(basis) };
+}
+export function verifySnapshot(store, snapshot) {
+    const { sha256, ...basis } = snapshot;
+    if (sha256 !== stableDigest(basis) ||
+        !Number.isSafeInteger(snapshot.total_bytes) ||
+        snapshot.total_bytes < 0 ||
+        snapshot.total_bytes > SNAPSHOT_LIMIT)
+        throw new Error("snapshot digest or byte limit changed");
+    let total = 0;
+    for (const side of ["index", "worktree"]) {
+        const actual = git(store, ["ls-tree", "-r", "-z", snapshot[`${side}_tree`]], { bare: true })
+            .toString("utf8")
+            .split("\0")
+            .filter(Boolean)
+            .sort();
+        const expected = snapshot.entries
+            .filter((entry) => entry[side])
+            .map((entry) => `${entry[side].mode} blob ${entry[side].oid}\t${entry.path}`)
+            .sort();
+        if (stableDigest(actual) !== stableDigest(expected))
+            throw new Error("snapshot tree changed");
+        for (const entry of snapshot.entries) {
+            const blob = entry[side];
+            if (blob) {
+                const bytes = git(store, ["cat-file", "blob", blob.oid], { bare: true });
+                if (textGit(store, ["hash-object", "--stdin"], { bare: true, input: bytes }) !== blob.oid)
+                    throw new Error("snapshot blob digest changed");
+                total += bytes.length;
+            }
+        }
+    }
+    if (total !== snapshot.total_bytes)
+        throw new Error("snapshot byte count changed");
+}
+export function currentMatches(binding, store, snapshot) {
+    const current = observe(binding, store, snapshot.entries.map((entry) => entry.path));
+    return (current.head === snapshot.head &&
+        stableDigest(current.entries) === stableDigest(snapshot.entries));
+}
+export function lockIndex(binding, state) {
+    const path = join(binding.repository.gitdir.realpath, "index");
+    const lock = `${path}.lock`;
+    const fd = openSync(lock, "wx", stateFileMode());
+    const identity = fstatSync(fd, { bigint: true });
+    const privatePath = join(state, `live-${randomUUID()}.index`);
+    let published = false;
+    const exact = () => {
+        const current = lstatSync(lock, { bigint: true });
+        if (!current.isFile() || current.dev !== identity.dev || current.ino !== identity.ino)
+            throw new Error("Git index lock changed");
+    };
+    try {
+        writeFileSync(privatePath, readFileSync(path), { flag: "wx", mode: stateFileMode() });
+    }
+    catch (error) {
+        closeSync(fd);
+        exact();
+        unlinkSync(lock);
+        throw error;
+    }
+    return {
+        path,
+        privatePath,
+        publish() {
+            exact();
+            writeFileSync(fd, readFileSync(privatePath));
+            fsyncSync(fd);
+            exact();
+            renameSync(lock, path);
+            published = true;
+            const dir = openSync(dirname(path), "r");
+            try {
+                fsyncSync(dir);
+            }
+            finally {
+                closeSync(dir);
+            }
+        },
+        close() {
+            closeSync(fd);
+            if (!published) {
+                exact();
+                unlinkSync(lock);
+            }
+            if (existsSync(privatePath))
+                unlinkSync(privatePath);
+        },
+    };
+}
+export function stageBefore(binding, store, before, index) {
+    for (const entry of before.entries) {
+        if (entry.index) {
+            const bytes = git(store, ["cat-file", "blob", entry.index.oid], { bare: true });
+            const sourceOid = textGit(binding.workspace_root, ["hash-object", "-w", "--stdin"], {
+                input: bytes,
+            });
+            git(binding.workspace_root, ["update-index", "--add", "--cacheinfo", `${entry.index.mode},${sourceOid},${entry.path}`], { index: index.privatePath });
+        }
+        else
+            git(binding.workspace_root, ["update-index", "--force-remove", "--", entry.path], {
+                index: index.privatePath,
+            });
+    }
+}
+export function restoreFile(binding, store, entry) {
+    const parent = openParent(binding, entry.path);
+    const temporary = `${parent.path}.restore-${randomUUID()}`;
+    try {
+        if (!entry.worktree) {
+            if (existsSync(parent.path))
+                unlinkSync(parent.path);
+        }
+        else {
+            const fd = openSync(temporary, "wx", entry.worktree.mode === "100755" ? 0o755 : 0o644);
+            try {
+                fchmodSync(fd, entry.worktree.mode === "100755" ? 0o755 : 0o644);
+                writeFileSync(fd, git(store, ["cat-file", "blob", entry.worktree.oid], { bare: true }));
+                fsyncSync(fd);
+            }
+            finally {
+                closeSync(fd);
+            }
+            renameSync(temporary, parent.path);
+        }
+        const fd = openSync(dirname(parent.path), "r");
+        try {
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    finally {
+        if (existsSync(temporary))
+            unlinkSync(temporary);
+        parent.close();
+    }
+}
+export function ensureDirectory(path) {
+    if (!existsSync(path)) {
+        ensureDirectory(dirname(path));
+        mkdirSync(path, { mode: stateDirMode() });
+        const fd = openSync(path, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+        try {
+            fchmodSync(fd, stateDirMode());
+            fsyncSync(fd);
+        }
+        finally {
+            closeSync(fd);
+        }
+        fsyncParentDirectory(path);
+    }
+    if (!lstatSync(path).isDirectory() ||
+        lstatSync(path).isSymbolicLink() ||
+        realpathSync(path) !== resolve(path))
+        throw new Error("rollback state path is unsafe");
+}

package/dist/core/turn-rollback/index.d.ts

@@ -0,0 +1,72 @@
+import type { WorkspaceBinding } from "../workflow/workspaces/types.js";
+import { type ContentEntry, type ContentSnapshot } from "./content.js";
+export type { ContentEntry, ContentSnapshot } from "./content.js";
+export type TurnIdentity = {
+    turn_id: string;
+    generation: number;
+};
+export interface TurnCapture {
+    schema_version: 1;
+    capture_id: string;
+    binding_sha256: string;
+    binding_generation: number;
+    turn: TurnIdentity;
+    paths: string[];
+    before: ContentSnapshot;
+    sha256: string;
+    end?: ContentSnapshot;
+}
+export interface TurnRollbackPlan {
+    schema_version: 1;
+    capture_id: string;
+    binding_sha256: string;
+    turn: TurnIdentity;
+    before_sha256: string;
+    end_sha256: string;
+    paths: Array<{
+        path: string;
+        before: ContentEntry;
+        end: ContentEntry;
+    }>;
+    plan_sha256: string;
+}
+export interface TurnRollbackResult {
+    schema_version: 1;
+    status: "preview" | "applied" | "already_applied" | "unknown";
+    capture_id: string;
+    plan_sha256: string;
+    reason?: string;
+}
+export interface TurnRollbackStatus {
+    status: "missing" | "open" | "sealed" | "applied" | "unknown";
+    capture_id: string;
+}
+type CaptureInput = {
+    binding: WorkspaceBinding;
+    capture_id: string;
+};
+/** Capture the exact named files before a turn, without staging anything. */
+export declare function beginTurnRollback(coordRoot: string, input: {
+    binding: WorkspaceBinding;
+    turn: TurnIdentity;
+    paths: readonly string[];
+    onSnapshotStep?: (step: "content_persisted", captureId: string) => void;
+}): Promise<TurnCapture>;
+/** Seal the end boundary of the latest captured turn. */
+export declare function sealTurnRollback(coordRoot: string, input: CaptureInput & {
+    onSnapshotStep?: (step: "content_persisted", captureId: string) => void;
+}): Promise<TurnCapture>;
+/** Produce a dry-run exact-path proposal bound to both captured boundaries. */
+export declare function prepareTurnRollback(coordRoot: string, input: CaptureInput): Promise<TurnRollbackPlan>;
+export declare function applyTurnRollback(coordRoot: string, input: {
+    binding: WorkspaceBinding;
+    plan: TurnRollbackPlan;
+    yes?: boolean;
+    actor?: string;
+    reason?: string;
+    /** Observation/fault boundary; does not replace any authority or content guard. */
+    onStep?: (step: "started" | "worktree_published" | "index_published") => void;
+}): Promise<TurnRollbackResult>;
+/** Read recovery evidence without attempting to continue an interrupted restore. */
+export declare function inspectTurnRollback(coordRoot: string, input: CaptureInput): TurnRollbackStatus;
+//# sourceMappingURL=index.d.ts.map

package/dist/core/turn-rollback/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/turn-rollback/index.ts"],"names":[],"mappings":"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"}