@animalabs/agent-framework 0.26.1 → 0.27.0

package/dist/src/modules/workspace/direct-write.d.ts

@@ -0,0 +1,181 @@
+/**
+ * A direct mount's writes (MountConfig.backend): disk is the only copy, so a
+ * write lands there whole when its call answers, or doesn't happen and leaves
+ * disk as it was. Ported from anima-research/hands-mcp's staged write
+ * (src/shared.ts), behind the mount's boundary as the workspace's other
+ * effects hold it (effects.ts):
+ *
+ * - The file's directory is located inside the mount (checkDir), and where
+ *   the file lands is judged as a push's write judges it (refusedLanding):
+ *   inside the mount, in no nested mount's directory, and covered by the
+ *   mount's include. A link at the file is refused on a mount that doesn't
+ *   follow links; on one that does, the write goes to the file it leads to
+ *   when the call stages it, judged the same way, and the link stays.
+ * - The new bytes are staged beside the file, in `.workspace-staged-<id>`,
+ *   at the file's mode, special bits included as far as the kernel lets this
+ *   process set them (a setgid bit only for a member of the file's group),
+ *   and renamed over it, so a reader beside the agent never sees half a file
+ *   and a process killed mid-write leaves the old file whole. A file this
+ *   process may not write is refused, as a push's write, which opens it for
+ *   writing, is refused: the rename needs only the directory's permission.
+ *   A process that dies between staging and its rename leaves the staged
+ *   file, under that name, which `ls` and `git status` show; so does a
+ *   refused write whose removal of its staged file fails or can't tell the
+ *   file is its own, or whose directory another writer moved after the
+ *   staging, since the removal goes by path (discard) and the path then
+ *   leads elsewhere. Nothing sweeps it, and the answer doesn't name it.
+ *   The removal checks the staged name holds that file and unlinks it with
+ *   no turn of the event loop between, so only a file another writer puts
+ *   there in that instant can be removed in its place, or one put there
+ *   that a stat can't tell from it: on the freed inode number, with the
+ *   same size, mode and owner, in the same tick of a coarse clock.
+ * - The rename gives a hard-linked path a file of its own, and the other
+ *   links keep the old text: `otherLinks` counts them for the answer.
+ * - Just before the rename, an edit's file is checked unchanged since its
+ *   read, by its bytes, read again, and its identity (checkUnchanged),
+ *   synchronously, so the check and the renames after it run with no turn
+ *   of the event loop between. Only a change landing in that instant isn't
+ *   seen, which for edit_many runs from the check through its last rename:
+ *   no rename can be made conditional.
+ * - No sync. The store-backed kind syncs its pushes for its agreement
+ *   record (reconcile.ts), and a direct mount keeps none, so a power loss
+ *   or a kernel crash can lose a direct write after its answer said it
+ *   landed, as it can a hands-mcp write. A process dying can't: the rename is
+ *   whole by then.
+ *
+ * Node has no openat or renameat, so the stage and the rename go through the
+ * checked directory's path: a directory replaced by another writer on disk
+ * between the directory's check and the staging, or after its last check
+ * (placedStill), can redirect them, as effects.ts says of a create. For
+ * edit_many that last check is each file's, before the other files' checks.
+ */
+import type { BigIntStats } from 'node:fs';
+import { type CheckedDir, type MountView } from './observe.js';
+/** The name a staged file starts with, beside the file it replaces. */
+export declare const STAGED_PREFIX = ".workspace-staged-";
+/**
+ * Why a direct write didn't happen when its mount's root was replaced under
+ * it: a direct mount keeps no root to sync to (MountConfig.backend), so its
+ * next call works beneath whatever is there then.
+ */
+export declare const ROOT_MOVED = "the mount root changed while this call was being applied: a new call works beneath whatever directory the mount's path leads to then";
+/**
+ * A file's identity as a write must find it unchanged: device, inode, size,
+ * mode, owner, group, and modification and change times, to the nanosecond.
+ * The mode, owner and group are fields of their own, since a chmod or chown
+ * in the same tick of a coarse clock as the file's last change leaves its
+ * change time as it was (checkUnchanged).
+ */
+export interface FileIdentity {
+    dev: bigint;
+    ino: bigint;
+    size: bigint;
+    mode: bigint;
+    uid: bigint;
+    gid: bigint;
+    mtimeNs: bigint;
+    ctimeNs: bigint;
+}
+export declare const identityOf: (info: BigIntStats) => FileIdentity;
+export declare const sameIdentity: (a: FileIdentity, b: FileIdentity) => boolean;
+/** Another writer replaced, changed or removed the file between its read and its rename; nothing was written. */
+export declare class FileChanged extends Error {
+}
+/** Why a direct write didn't happen, in words for its answer; disk is as it was. */
+export declare class WriteRefused extends Error {
+}
+/** A file's new bytes staged beside it, ready to be renamed over it (stageContained). */
+export interface Staged {
+    /** Where the rename lands: the file's entry in its checked directory, a followed link's file's included. */
+    path: string;
+    /** The staged file, beside it. */
+    temp: string;
+    /**
+     * Which file the staged file is, so the rename moves, and a refusal
+     * removes, that one and no other put at its name: its whole identity,
+     * since a file made where it was unlinked can take its inode number.
+     */
+    tempIdentity: FileIdentity;
+    /** The mount's root and the file's directory, as checked when it was staged. */
+    root: CheckedDir;
+    parent: CheckedDir;
+    /**
+     * The other hard links the replaced file had, counted just before the
+     * rename and kept once it succeeds: the rename gives this path a file of
+     * its own, and they keep the old text. 0 until then, and for a new file.
+     */
+    otherLinks: number;
+}
+/**
+ * Test seams. `afterStage` is called once a call's files are staged, before
+ * they're checked unchanged (another writer acting then); `beforeRename`
+ * just before each rename, inside its refusal, so throwing stands for the
+ * rename failing. Production sets neither.
+ */
+export declare const directWriteTestSeam: {
+    afterStage?: (paths: string[]) => void | Promise<void>;
+    beforeRename?: (path: string) => void;
+};
+/**
+ * Stage `bytes` beside the mount-relative file `rel`, to be renamed over it:
+ * the first half of a direct write. The file keeps its mode, special bits
+ * included, as far as the kernel lets this process set them; a new file
+ * takes `0666` less the umask, as a shell's would. Its owner and group are
+ * this process's and the ones its directory gives a new file, and an ACL or
+ * extended attribute on the file isn't carried over, as with any write that
+ * renames over a file. Anything there that isn't a regular file is refused,
+ * and a refusal removes the staged file it made, except where the header
+ * says one is left. The staged file is written and moded through its own
+ * handle, never through its name again.
+ */
+export declare function stageContained(view: MountView, rootReal: string, rel: string, bytes: Buffer, { makeDirectory }?: {
+    makeDirectory?: boolean;
+}): Promise<Staged>;
+/**
+ * Throw unless the root and the file's directory are still the ones the
+ * staging checked, with a push's words for the directory (effects.ts
+ * moved()).
+ */
+export declare function placedStill(staged: Staged): Promise<void>;
+/**
+ * Throw unless the file is still what its read found: FileChanged when it
+ * changed or is gone, nothing written. `expected` is null for a write, which
+ * read nothing and replaces whatever is there. Either way a link swapped in
+ * at the file the rename replaces (on a mount that follows links, the file
+ * the link at the agent's path led to when the call staged it) is refused
+ * rather than replaced, and so is a file this process may not write. It reads the entry the
+ * rename replaces, and then the file's bytes, synchronously, as renameInto
+ * runs, so a check and the renames after it run with no turn of the event
+ * loop between.
+ *
+ * The identity, taken once the bytes are read, catches a file replaced or
+ * re-moded under the call, which equal bytes wouldn't show. The bytes are
+ * compared with the ones the edit read: a kernel that stamps files from a
+ * coarse clock, as Linux before 6.13 does, leaves a file's identity as it
+ * was after a second write of the same size within one tick of its last
+ * change (on Debian's Linux 6.12.113 with ext4, 1,632 to 1,752 of 2,000
+ * such rewrites kept every stamp, in three runs), and the bytes show that
+ * change on every clock. The bytes are read through an open that follows
+ * no link and doesn't wait on a pipe put at the path since its lstat, and
+ * at most one byte past what the edit read, so the check never blocks and
+ * reads no more than that.
+ */
+export declare function checkUnchanged(staged: Staged, expected: {
+    identity: FileIdentity;
+    bytes: Buffer;
+} | null): void;
+/**
+ * Rename the staged file over the file, synchronously (checkUnchanged says
+ * why), counting the other hard links it splits the path from just before.
+ * A failed rename leaves the file as it was; the caller removes the staged
+ * file (discard).
+ */
+export declare function renameInto(staged: Staged): void;
+/**
+ * Remove a staged file that won't be renamed, best effort: only the file
+ * this call staged, by its whole identity, since whatever another writer
+ * put at its name since is theirs, as renameInto leaves it too. Checked and
+ * removed synchronously, as the rename is (checkUnchanged says why).
+ */
+export declare function discard(staged: Staged): Promise<void>;
+//# sourceMappingURL=direct-write.d.ts.map

package/dist/src/modules/workspace/direct-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-write.d.ts","sourceRoot":"","sources":["../../../../src/modules/workspace/direct-write.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAI3C,OAAO,EACL,KAAK,UAAU,EACf,KAAK,SAAS,EASf,MAAM,cAAc,CAAC;AAKtB,uEAAuE;AACvE,eAAO,MAAM,aAAa,uBAAuB,CAAC;AAElD;;;;GAIG;AACH,eAAO,MAAM,UAAU,yIAA0I,CAAC;AAElK;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,UAAU,SAAU,WAAW,KAAG,YAS7C,CAAC;AAEH,eAAO,MAAM,YAAY,MAAO,YAAY,KAAK,YAAY,KAAG,OAET,CAAC;AAExD,iHAAiH;AACjH,qBAAa,WAAY,SAAQ,KAAK;CAAG;AAEzC,oFAAoF;AACpF,qBAAa,YAAa,SAAQ,KAAK;CAAG;AAE1C,yFAAyF;AACzF,MAAM,WAAW,MAAM;IACrB,4GAA4G;IAC5G,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,YAAY,EAAE,YAAY,CAAC;IAC3B,gFAAgF;IAChF,IAAI,EAAE,UAAU,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB;;;;OAIG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE;IAChC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACvD,YAAY,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CAClC,CAAC;AAoBP;;;;;;;;;;;GAWG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,SAAS,EACf,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,MAAM,EACb,EAAE,aAAqB,EAAE,GAAE;IAAE,aAAa,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1D,OAAO,CAAC,MAAM,CAAC,CA8EjB;AAED;;;;GAIG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAG/D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,GAAG,IAAI,CAoD/G;AAeD;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAiB/C;AAWD;;;;;GAKG;AACH,wBAAsB,OAAO,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE3D"}

package/dist/src/modules/workspace/direct-write.js

@@ -0,0 +1,384 @@
+/**
+ * A direct mount's writes (MountConfig.backend): disk is the only copy, so a
+ * write lands there whole when its call answers, or doesn't happen and leaves
+ * disk as it was. Ported from anima-research/hands-mcp's staged write
+ * (src/shared.ts), behind the mount's boundary as the workspace's other
+ * effects hold it (effects.ts):
+ *
+ * - The file's directory is located inside the mount (checkDir), and where
+ *   the file lands is judged as a push's write judges it (refusedLanding):
+ *   inside the mount, in no nested mount's directory, and covered by the
+ *   mount's include. A link at the file is refused on a mount that doesn't
+ *   follow links; on one that does, the write goes to the file it leads to
+ *   when the call stages it, judged the same way, and the link stays.
+ * - The new bytes are staged beside the file, in `.workspace-staged-<id>`,
+ *   at the file's mode, special bits included as far as the kernel lets this
+ *   process set them (a setgid bit only for a member of the file's group),
+ *   and renamed over it, so a reader beside the agent never sees half a file
+ *   and a process killed mid-write leaves the old file whole. A file this
+ *   process may not write is refused, as a push's write, which opens it for
+ *   writing, is refused: the rename needs only the directory's permission.
+ *   A process that dies between staging and its rename leaves the staged
+ *   file, under that name, which `ls` and `git status` show; so does a
+ *   refused write whose removal of its staged file fails or can't tell the
+ *   file is its own, or whose directory another writer moved after the
+ *   staging, since the removal goes by path (discard) and the path then
+ *   leads elsewhere. Nothing sweeps it, and the answer doesn't name it.
+ *   The removal checks the staged name holds that file and unlinks it with
+ *   no turn of the event loop between, so only a file another writer puts
+ *   there in that instant can be removed in its place, or one put there
+ *   that a stat can't tell from it: on the freed inode number, with the
+ *   same size, mode and owner, in the same tick of a coarse clock.
+ * - The rename gives a hard-linked path a file of its own, and the other
+ *   links keep the old text: `otherLinks` counts them for the answer.
+ * - Just before the rename, an edit's file is checked unchanged since its
+ *   read, by its bytes, read again, and its identity (checkUnchanged),
+ *   synchronously, so the check and the renames after it run with no turn
+ *   of the event loop between. Only a change landing in that instant isn't
+ *   seen, which for edit_many runs from the check through its last rename:
+ *   no rename can be made conditional.
+ * - No sync. The store-backed kind syncs its pushes for its agreement
+ *   record (reconcile.ts), and a direct mount keeps none, so a power loss
+ *   or a kernel crash can lose a direct write after its answer said it
+ *   landed, as it can a hands-mcp write. A process dying can't: the rename is
+ *   whole by then.
+ *
+ * Node has no openat or renameat, so the stage and the rename go through the
+ * checked directory's path: a directory replaced by another writer on disk
+ * between the directory's check and the staging, or after its last check
+ * (placedStill), can redirect them, as effects.ts says of a create. For
+ * edit_many that last check is each file's, before the other files' checks.
+ */
+import { randomUUID } from 'node:crypto';
+import { accessSync, closeSync, constants as fsConstants, lstatSync, openSync, readSync, renameSync, unlinkSync } from 'node:fs';
+import { lstat, open, realpath } from 'node:fs/promises';
+import { relative, sep } from 'node:path';
+import { refusedLanding } from './effects.js';
+import { NONBLOCK, NOT_FOLLOWED, OUTSIDE_PARENT, checkDir, checkRoot, errno, nameOf, parentOf, } from './observe.js';
+/** An open that follows no link at the path, where the platform has one. */
+const NOFOLLOW = typeof fsConstants.O_NOFOLLOW === 'number' ? fsConstants.O_NOFOLLOW : 0;
+/** The name a staged file starts with, beside the file it replaces. */
+export const STAGED_PREFIX = '.workspace-staged-';
+/**
+ * Why a direct write didn't happen when its mount's root was replaced under
+ * it: a direct mount keeps no root to sync to (MountConfig.backend), so its
+ * next call works beneath whatever is there then.
+ */
+export const ROOT_MOVED = 'the mount root changed while this call was being applied: a new call works beneath whatever directory the mount\'s path leads to then';
+export const identityOf = (info) => ({
+    dev: info.dev,
+    ino: info.ino,
+    size: info.size,
+    mode: info.mode,
+    uid: info.uid,
+    gid: info.gid,
+    mtimeNs: info.mtimeNs,
+    ctimeNs: info.ctimeNs,
+});
+export const sameIdentity = (a, b) => a.dev === b.dev && a.ino === b.ino && a.size === b.size && a.mode === b.mode && a.uid === b.uid && a.gid === b.gid
+    && a.mtimeNs === b.mtimeNs && a.ctimeNs === b.ctimeNs;
+/** Another writer replaced, changed or removed the file between its read and its rename; nothing was written. */
+export class FileChanged extends Error {
+}
+/** Why a direct write didn't happen, in words for its answer; disk is as it was. */
+export class WriteRefused extends Error {
+}
+/**
+ * Test seams. `afterStage` is called once a call's files are staged, before
+ * they're checked unchanged (another writer acting then); `beforeRename`
+ * just before each rename, inside its refusal, so throwing stands for the
+ * rename failing. Production sets neither.
+ */
+export const directWriteTestSeam = {};
+/** The mount-relative path of a real path inside the mount's root, `/`-separated. */
+function relativeTo(rootReal, real) {
+    return relative(rootReal, real).split(sep).join('/');
+}
+/**
+ * The checked directory a mount-relative file lies in, beneath a checked
+ * root, or why not. With `makeDirectory`, missing directories are made, as
+ * a push's write makes them; without it, a missing one refuses the write,
+ * since an edit replaces a file that exists.
+ */
+async function directoryOf(view, rootReal, rel, makeDirectory) {
+    const checked = await checkDir(view, rootReal, parentOf(rel), { create: makeDirectory });
+    if (checked.kind === 'checked')
+        return checked.dir;
+    if (checked.kind === 'absent')
+        throw new FileChanged(rel);
+    throw new WriteRefused(checked.outside ? OUTSIDE_PARENT : checked.reason);
+}
+/**
+ * Stage `bytes` beside the mount-relative file `rel`, to be renamed over it:
+ * the first half of a direct write. The file keeps its mode, special bits
+ * included, as far as the kernel lets this process set them; a new file
+ * takes `0666` less the umask, as a shell's would. Its owner and group are
+ * this process's and the ones its directory gives a new file, and an ACL or
+ * extended attribute on the file isn't carried over, as with any write that
+ * renames over a file. Anything there that isn't a regular file is refused,
+ * and a refusal removes the staged file it made, except where the header
+ * says one is left. The staged file is written and moded through its own
+ * handle, never through its name again.
+ */
+export async function stageContained(view, rootReal, rel, bytes, { makeDirectory = false } = {}) {
+    const root = await checkRoot(view, rootReal);
+    if ('reason' in root)
+        throw new WriteRefused(root.reason);
+    let parent = await directoryOf(view, rootReal, rel, makeDirectory);
+    let path = parent.at(nameOf(rel));
+    let info = await lstat(path, { bigint: true }).catch((err) => {
+        if (errno(err) === 'ENOENT')
+            return null;
+        throw new WriteRefused(`cannot stat the file (${errno(err) ?? String(err)})`);
+    });
+    if (info?.isSymbolicLink()) {
+        if (!view.followSymlinks)
+            throw new WriteRefused(NOT_FOLLOWED);
+        // A followed link stands for the file it leads to, as a read takes it:
+        // the write goes there, judged where it lands, and the link stays.
+        const real = await realpath(path).catch((err) => {
+            throw new WriteRefused(errno(err) === 'ENOENT' ? "a symlink whose target doesn't exist" : `cannot resolve the symlink (${errno(err) ?? String(err)})`);
+        });
+        const leaves = await refusedLanding(view, rootReal, rel, real);
+        if (leaves !== null)
+            throw new WriteRefused(leaves);
+        const realRel = relativeTo(rootReal, real);
+        parent = await directoryOf(view, rootReal, realRel, false);
+        path = parent.at(nameOf(realRel));
+        info = await lstat(path, { bigint: true }).catch((err) => {
+            // Gone since realpath found it: another writer's change.
+            if (errno(err) === 'ENOENT')
+                throw new FileChanged(rel);
+            throw new WriteRefused(`cannot stat the file the symlink leads to (${errno(err) ?? String(err)})`);
+        });
+        if (info.isSymbolicLink())
+            throw new FileChanged(rel);
+    }
+    else {
+        // A file, or none yet, reached through a link among its directories
+        // lands where the mount may not act: in a nested mount's directory, or
+        // on a file its own include leaves out (refusedLanding).
+        const leaves = await refusedLanding(view, rootReal, rel, path);
+        if (leaves !== null)
+            throw new WriteRefused(leaves);
+    }
+    if (info?.isDirectory())
+        throw new WriteRefused('a directory');
+    if (info && !info.isFile())
+        throw new WriteRefused('not a regular file');
+    // A fixed-length name, so a file whose own name is near the 255-byte limit can still be replaced.
+    const temp = parent.at(`${STAGED_PREFIX}${randomUUID()}`);
+    let made = false;
+    try {
+        // A new file is made at 0666 and the kernel takes the umask off as it
+        // makes it. A file being replaced gives the staged file its own mode,
+        // which only a chmod can set past the umask, and only after the bytes
+        // are written, since a write clears a set-user or set-group bit; until
+        // then the staged file is the owner's alone, so no other user can read
+        // a private file's new text while it's staged.
+        const handle = await open(temp, 'wx', info ? 0o600 : 0o666);
+        made = true;
+        let staged;
+        try {
+            await handle.writeFile(bytes);
+            if (info)
+                await handle.chmod(Number(info.mode & 4095n));
+            const own = await handle.stat({ bigint: true });
+            staged = { path, temp, tempIdentity: identityOf(own), root: root.dir, parent, otherLinks: 0 };
+        }
+        catch (err) {
+            // Removed while its handle is still open, so its device and inode
+            // name it and no other file: one made at its name since can't have
+            // taken its inode number. One that can't be told is left.
+            const mine = await handle.stat({ bigint: true }).catch(() => null);
+            if (mine)
+                removeIf(temp, (there) => there.dev === mine.dev && there.ino === mine.ino);
+            await handle.close().catch(() => undefined);
+            throw err;
+        }
+        try {
+            await handle.close();
+        }
+        catch (err) {
+            // Closed, or not, with its bytes in doubt: removed by its whole identity, as a refusal's.
+            await discard(staged);
+            throw err;
+        }
+        return staged;
+    }
+    catch (err) {
+        // A staged file that couldn't be made names the directory: a push's
+        // write in place needs only the file, and this one needs both.
+        throw new WriteRefused(made
+            ? `cannot write the staged file beside it (${errno(err) ?? String(err)})`
+            : `cannot make the staged file in its directory (${errno(err) ?? String(err)}): a direct write needs to write the file's directory as well as the file`);
+    }
+}
+/**
+ * Throw unless the root and the file's directory are still the ones the
+ * staging checked, with a push's words for the directory (effects.ts
+ * moved()).
+ */
+export async function placedStill(staged) {
+    if (!(await staged.root.stillHere()))
+        throw new WriteRefused(ROOT_MOVED);
+    if (!(await staged.parent.stillHere()))
+        throw new WriteRefused('the directory changed since it was checked');
+}
+/**
+ * Throw unless the file is still what its read found: FileChanged when it
+ * changed or is gone, nothing written. `expected` is null for a write, which
+ * read nothing and replaces whatever is there. Either way a link swapped in
+ * at the file the rename replaces (on a mount that follows links, the file
+ * the link at the agent's path led to when the call staged it) is refused
+ * rather than replaced, and so is a file this process may not write. It reads the entry the
+ * rename replaces, and then the file's bytes, synchronously, as renameInto
+ * runs, so a check and the renames after it run with no turn of the event
+ * loop between.
+ *
+ * The identity, taken once the bytes are read, catches a file replaced or
+ * re-moded under the call, which equal bytes wouldn't show. The bytes are
+ * compared with the ones the edit read: a kernel that stamps files from a
+ * coarse clock, as Linux before 6.13 does, leaves a file's identity as it
+ * was after a second write of the same size within one tick of its last
+ * change (on Debian's Linux 6.12.113 with ext4, 1,632 to 1,752 of 2,000
+ * such rewrites kept every stamp, in three runs), and the bytes show that
+ * change on every clock. The bytes are read through an open that follows
+ * no link and doesn't wait on a pipe put at the path since its lstat, and
+ * at most one byte past what the edit read, so the check never blocks and
+ * reads no more than that.
+ */
+export function checkUnchanged(staged, expected) {
+    let now;
+    try {
+        now = lstatSync(staged.path, { bigint: true });
+    }
+    catch (err) {
+        if (errno(err) !== 'ENOENT')
+            throw new WriteRefused(`cannot check that it hadn't changed (${errno(err) ?? String(err)})`);
+        if (expected !== null)
+            throw new FileChanged(staged.path);
+        return;
+    }
+    if (now.isSymbolicLink())
+        throw new WriteRefused('it became a symlink while this call was being applied');
+    if (now.isDirectory())
+        throw new WriteRefused('a directory');
+    if (!now.isFile())
+        throw new WriteRefused('not a regular file');
+    // As a push's write, which opens the file for writing, would be refused:
+    // the rename needs only the directory's permission, and would replace a
+    // file its owner made read-only.
+    try {
+        accessSync(staged.path, fsConstants.W_OK);
+    }
+    catch (err) {
+        const code = errno(err);
+        // Removed since the lstat: a write makes the file anew; an edit's read is gone.
+        if (code === 'ENOENT') {
+            if (expected === null)
+                return;
+            throw new FileChanged(staged.path);
+        }
+        if (code === 'EACCES' || code === 'EPERM') {
+            throw new WriteRefused(`a file the host's process may not write (${code}): its mode or owner keeps that process out, and calling again is refused until the file's owner, or whoever runs the host, changes that`);
+        }
+        throw new WriteRefused(`cannot check that the host's process may write it (${code ?? String(err)})`);
+    }
+    if (expected === null)
+        return;
+    let bytes;
+    let after;
+    try {
+        // No link followed, and no wait on a pipe, if either was put at the path since the lstat.
+        const fd = openSync(staged.path, fsConstants.O_RDONLY | NOFOLLOW | NONBLOCK);
+        try {
+            // One byte past what the edit read, enough to see the file differs:
+            // a file another writer made larger, or a pipe a writer keeps
+            // filling, put at the path since, costs no more than that.
+            bytes = readBounded(fd, expected.bytes.length + 1);
+        }
+        finally {
+            closeSync(fd);
+        }
+        // And the entry is still the file the edit read, after its bytes were read.
+        after = lstatSync(staged.path, { bigint: true });
+    }
+    catch (err) {
+        // ELOOP: a link put at the path since the lstat; EAGAIN: a pipe, with a
+        // writer and nothing in it yet. Either is another writer's change.
+        if (errno(err) === 'ENOENT' || errno(err) === 'ELOOP' || errno(err) === 'EAGAIN')
+            throw new FileChanged(staged.path);
+        throw new WriteRefused(`cannot check that it hadn't changed (${errno(err) ?? String(err)})`);
+    }
+    if (!sameIdentity(identityOf(after), expected.identity) || !bytes.equals(expected.bytes))
+        throw new FileChanged(staged.path);
+}
+/** Up to `limit` bytes from the start of `fd`, fewer at its end. */
+function readBounded(fd, limit) {
+    const buffer = Buffer.alloc(limit);
+    let filled = 0;
+    while (filled < limit) {
+        // From where the last read ended (a pipe has no positions to read at).
+        const got = readSync(fd, buffer, filled, limit - filled, null);
+        if (got === 0)
+            break;
+        filled += got;
+    }
+    return buffer.subarray(0, filled);
+}
+/**
+ * Rename the staged file over the file, synchronously (checkUnchanged says
+ * why), counting the other hard links it splits the path from just before.
+ * A failed rename leaves the file as it was; the caller removes the staged
+ * file (discard).
+ */
+export function renameInto(staged) {
+    let otherLinks;
+    try {
+        directWriteTestSeam.beforeRename?.(staged.path);
+        // The staged file is still the one this call wrote, not another put at its name.
+        const temp = lstatSync(staged.temp, { bigint: true });
+        if (!temp.isFile() || !sameIdentity(identityOf(temp), staged.tempIdentity)) {
+            throw new WriteRefused('another writer replaced the staged copy of the new text before it could be renamed over the file, which is as it was');
+        }
+        otherLinks = otherLinksAt(staged.path);
+        renameSync(staged.temp, staged.path);
+    }
+    catch (err) {
+        if (err instanceof WriteRefused)
+            throw err;
+        throw new WriteRefused(`cannot rename the staged file over it (${errno(err) ?? (err instanceof Error ? err.message : String(err))})`);
+    }
+    // Set once the rename has happened, so a count never stands for a split that didn't.
+    staged.otherLinks = otherLinks;
+}
+/** The other hard links of what the entry at `path` holds: 0 for none there, and when lstat fails, since the count only informs the answer. */
+function otherLinksAt(path) {
+    try {
+        return lstatSync(path).nlink - 1;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Remove a staged file that won't be renamed, best effort: only the file
+ * this call staged, by its whole identity, since whatever another writer
+ * put at its name since is theirs, as renameInto leaves it too. Checked and
+ * removed synchronously, as the rename is (checkUnchanged says why).
+ */
+export async function discard(staged) {
+    removeIf(staged.temp, (there) => there.isFile() && sameIdentity(identityOf(there), staged.tempIdentity));
+}
+/** Unlink what's at `path` if `ours` says it's the file meant; best effort, with no turn of the event loop between the check and the unlink. */
+function removeIf(path, ours) {
+    try {
+        if (ours(lstatSync(path, { bigint: true })))
+            unlinkSync(path);
+    }
+    catch {
+        // Gone already, or not ours to know: left, as the header says.
+    }
+}
+//# sourceMappingURL=direct-write.js.map

package/dist/src/modules/workspace/direct-write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-write.js","sourceRoot":"","sources":["../../../../src/modules/workspace/direct-write.ts"],"names":[],"mappings":"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"}