@noopolis/daimon 0.2.0 → 0.2.1

package/dist/runtime/wakeMomentSnapshot.js

@@ -0,0 +1,248 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import path from "node:path";
+import { WAKE_MOMENTS } from "../contracts/wakeMomentContract.js";
+import { assertNoSymlinkComponents } from "./physicalReadiness.js";
+import { cleanMomentPaths, ensureMomentDirectory, manifestBytes, momentPathExists, openMomentFile, pinMomentStore, readMomentJson, syncMomentDirectory, WakeMomentFault, writeMomentJson } from "./wakeMomentFs.js";
+import { WakeMomentIo } from "./wakeMomentIo.js";
+import { indexWithSnapshot, latestSnapshotIndex, snapshotName, snapshotRootName, snapshotTime, writeSnapshotIndex } from "./wakeMomentHistory.js";
+export { completeSnapshotNames, snapshotName, snapshotRootName, snapshotTime } from "./wakeMomentHistory.js";
+export async function readSnapshotManifest(directory, name, id, io = new WakeMomentIo(), maxManifestBytes = WAKE_MOMENTS.maxManifestBytes) {
+    try {
+        const value = await readMomentJson(path.join(directory, `${name}.manifest.json`), io, maxManifestBytes);
+        if (!value || value.version !== WAKE_MOMENTS.version || value.id !== id || value.snapshot !== name || Date.parse(value.started_at) !== snapshotTime(name)
+            || typeof value.sourcePath !== "string" || !value.entries || typeof value.entries !== "object" || Array.isArray(value.entries)
+            || Object.keys(value.entries).length > WAKE_MOMENTS.maxSnapshotEntries)
+            return undefined;
+        return value;
+    }
+    catch {
+        io.check();
+        return undefined;
+    }
+}
+/** SOURCE identity, never the copied inode's metadata: ordinary writers cannot restore ctime. */
+export function sameSnapshotSource(left, right) {
+    return left.dev === right.dev && left.ino === right.ino && left.size === right.size
+        && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs && left.mode === right.mode;
+}
+function identity(stat) {
+    return { dev: String(stat.dev), ino: String(stat.ino), size: String(stat.size), mtimeNs: String(stat.mtimeNs), ctimeNs: String(stat.ctimeNs), mode: Number(stat.mode) };
+}
+export async function captureWakeSnapshot(input) {
+    if (input.io && input.cleanup)
+        return capture(input, input.io, input.cleanup);
+    const io = new WakeMomentIo(), cleanup = new Set();
+    let store;
+    try {
+        return await io.bounded(WAKE_MOMENTS.captureDeadlineMs, async () => {
+            store = await pinMomentStore(input.directory, io);
+            io.verifyWrite = (target) => store.verify(io, target);
+            return capture(input, io, cleanup);
+        });
+    }
+    finally {
+        if (store) {
+            const finalizer = new WakeMomentIo();
+            finalizer.verifyWrite = (target) => store.verify(finalizer, target);
+            try {
+                await finalizer.bounded(WAKE_MOMENTS.finalizationDeadlineMs, () => cleanMomentPaths(cleanup, store, finalizer));
+            }
+            finally {
+                void store.close().catch(() => undefined);
+            }
+        }
+    }
+}
+async function capture(input, io, cleanup) {
+    const namespace = path.join(input.directory, WAKE_MOMENTS.snapshotsDirectory);
+    await ensureMomentDirectory(namespace, io);
+    const base = path.join(namespace, snapshotRootName(input.root.id));
+    await ensureMomentDirectory(base, io);
+    const requestedName = snapshotName(input.startedAt, input.executionId);
+    let name = requestedName;
+    while (await collides(name))
+        name = `${requestedName}-${randomUUID()}`;
+    const partial = path.join(base, `${name}.partial`), destination = path.join(base, name);
+    const { index } = await latestSnapshotIndex(base, io, cleanup), previousName = index?.snapshot;
+    let previous = previousName ? await readSnapshotManifest(base, previousName, input.root.id, io, input.maxManifestBytes) : undefined;
+    if (previous?.sourcePath !== input.root.path)
+        previous = undefined;
+    const manifest = { version: WAKE_MOMENTS.version, id: input.root.id, snapshot: name, started_at: input.startedAt, sourcePath: input.root.path, entries: Object.create(null) };
+    const snapshot = { id: input.root.id, snapshot: name, files: 0, copied: 0, linked: 0, skipped: 0 };
+    const max = Math.min(input.maxEntries ?? WAKE_MOMENTS.maxSnapshotEntries, WAKE_MOMENTS.maxSnapshotEntries);
+    let entries = 0, note;
+    await io.fs.mkdir(partial, { mode: 0o700 });
+    cleanup.add(partial);
+    {
+        let root;
+        try {
+            await assertNoSymlinkComponents(input.root.path, io.fs.lstat);
+            root = await openSourceDirectory(input.root.path, io);
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                note = "root_missing";
+            else
+                throw error;
+        }
+        if (root) {
+            try {
+                await walk(root, input.root.path, "");
+            }
+            finally {
+                await root.close();
+            }
+        }
+        // The writer enforces exactly the reader's byte bound BEFORE either publication rename.
+        const bytes = manifestBytes(manifest, input.maxManifestBytes);
+        await syncMomentDirectory(partial, io);
+        // Reserve the final name exclusively before rename can replace anything at it.
+        await io.fs.mkdir(destination, { mode: 0o700 });
+        cleanup.add(destination);
+        await io.fs.rename(partial, destination);
+        cleanup.delete(partial);
+        await syncMomentDirectory(base, io);
+        const manifestPath = path.join(base, `${name}.manifest.json`);
+        await writeMomentJson(manifestPath, bytes, io, cleanup);
+        try {
+            await writeSnapshotIndex(base, indexWithSnapshot(index, name), io, cleanup);
+        }
+        catch (error) {
+            if (!(error instanceof WakeMomentFault) || error.reason !== "invalid_latest_index")
+                throw error;
+            note = [note, error.reason].filter(Boolean).join("; ");
+        }
+        const markerPath = path.join(base, `${name}${WAKE_MOMENTS.completionSuffix}`);
+        const marker = await openMomentFile(markerPath, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL, io);
+        cleanup.add(markerPath);
+        try {
+            await marker.sync();
+        }
+        finally {
+            await marker.close();
+        }
+        await syncMomentDirectory(base, io);
+        cleanup.delete(markerPath);
+        cleanup.delete(manifestPath);
+        cleanup.delete(destination);
+        return { snapshot, ...(note ? { note } : {}) };
+    }
+    async function collides(candidate) {
+        for (const suffix of ["", ".partial", ".manifest.json", WAKE_MOMENTS.completionSuffix]) {
+            if (await momentPathExists(path.join(base, `${candidate}${suffix}`), io))
+                return true;
+        }
+        return false; // Temporary metadata names are separately checked and exclusively created.
+    }
+    async function walk(directory, source, relative) {
+        // Linux's descriptor-relative paths pin ancestors against a concurrent rename/symlink swap.
+        const anchored = process.platform === "linux" ? `/proc/self/fd/${directory.fd}` : source;
+        const expected = await directory.stat({ bigint: true });
+        await checkSourceDirectory(directory, source, expected, io);
+        for await (const entry of await io.fs.opendir(anchored)) {
+            await checkSourceDirectory(directory, source, expected, io);
+            if (++entries > max)
+                throw new WakeMomentFault("snapshot_entry_limit");
+            const rel = relative ? `${relative}/${entry.name}` : entry.name;
+            const from = path.join(anchored, entry.name), to = path.join(partial, rel);
+            const stat = await io.fs.lstat(from, { bigint: true }), sourceIdentity = identity(stat);
+            await checkSourceDirectory(directory, source, expected, io);
+            if (stat.isDirectory()) {
+                const child = await openSourceDirectory(from, io, stat);
+                try {
+                    await io.fs.mkdir(to, { mode: 0o700 });
+                    manifest.entries[rel] = { type: "directory", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity };
+                    await walk(child, from, rel);
+                    await syncMomentDirectory(to, io);
+                }
+                finally {
+                    await child.close();
+                }
+            }
+            else if (stat.isSymbolicLink()) {
+                const target = await io.fs.readlink(from);
+                await io.fs.symlink(target, to);
+                manifest.entries[rel] = { type: "symlink", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity, target };
+            }
+            else if (stat.isFile()) {
+                const sourceFile = await io.fs.open(from, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+                try {
+                    if (!sameSnapshotSource(sourceIdentity, identity(await sourceFile.stat({ bigint: true }))))
+                        throw new WakeMomentFault("source_changed");
+                    await checkSourceDirectory(directory, source, expected, io);
+                    const prior = previous && Object.hasOwn(previous.entries, rel) ? previous.entries[rel] : undefined;
+                    if (prior?.type === "file" && prior.source && sameSnapshotSource(prior.source, sourceIdentity)) {
+                        const old = path.join(base, previous.snapshot, rel);
+                        await assertNoSymlinkComponents(path.dirname(old), io.fs.lstat);
+                        if (!(await io.fs.lstat(old)).isFile())
+                            throw new WakeMomentFault("invalid_link_base");
+                        await io.fs.link(old, to);
+                        snapshot.linked++;
+                    }
+                    else {
+                        await copyFile(sourceFile, to, stat, io);
+                        snapshot.copied++;
+                    }
+                    if (!sameSnapshotSource(sourceIdentity, identity(await sourceFile.stat({ bigint: true }))))
+                        throw new WakeMomentFault("source_changed");
+                    manifest.entries[rel] = { type: "file", mode: Number(stat.mode), size: String(stat.size), source: sourceIdentity };
+                    snapshot.files++;
+                }
+                finally {
+                    await sourceFile.close();
+                }
+            }
+            else
+                snapshot.skipped++;
+        }
+        await checkSourceDirectory(directory, source, expected, io);
+    }
+}
+async function openSourceDirectory(source, io, before) {
+    if (process.platform !== "linux" || !source.startsWith("/proc/self/fd/"))
+        await assertNoSymlinkComponents(source, io.fs.lstat);
+    before ??= await io.fs.lstat(source, { bigint: true });
+    const fd = await io.fs.open(source, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+    try {
+        await checkSourceDirectory(fd, source, before, io);
+        return fd;
+    }
+    catch (error) {
+        await fd.close();
+        throw error;
+    }
+}
+async function checkSourceDirectory(directory, source, before, io) {
+    const opened = await directory.stat({ bigint: true }), current = await io.fs.lstat(source, { bigint: true });
+    if (![before, opened, current].every((stat) => stat.isDirectory() && stat.dev === before.dev && stat.ino === before.ino)) {
+        throw new WakeMomentFault("source_changed");
+    }
+}
+async function copyFile(source, target, stat, io) {
+    if (stat.size > BigInt(Number.MAX_SAFE_INTEGER))
+        throw new WakeMomentFault("source_size_limit");
+    const output = await io.fs.open(target, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    try {
+        const buffer = Buffer.alloc(1024 * 1024);
+        let position = 0;
+        while (position < Number(stat.size)) {
+            const { bytesRead } = await source.read(buffer, 0, Math.min(buffer.length, Number(stat.size) - position), position);
+            if (!bytesRead)
+                throw new WakeMomentFault("source_changed");
+            let written = 0;
+            while (written < bytesRead) {
+                const result = await output.write(buffer, written, bytesRead - written, position + written);
+                if (!result.bytesWritten)
+                    throw new WakeMomentFault("short_write");
+                written += result.bytesWritten;
+            }
+            position += bytesRead;
+        }
+        await output.chmod(Number(stat.mode) & 0o777);
+        await output.sync();
+    }
+    finally {
+        await output.close();
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noopolis/daimon",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Noopolis native per-agent runtime harness built on Pi.",
   "license": "MIT",
   "type": "module",
@@ -33,7 +33,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com/noopolis/daimon.git"
+    "url": "git+ssh://git@github.com/noopolis/daimon-harness.git"
   },
   "publishConfig": {
     "access": "public"
@@ -44,7 +44,7 @@
     "clean": "rm -rf dist",
     "prepack": "npm run build",
     "prepublishOnly": "npm run typecheck && npm test",
-    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project scripts/tsconfig.json --noEmit",
+    "typecheck": "tsc --project tsconfig.json --noEmit && tsc --project scripts/tsconfig.json --noEmit && tsc --project .github/scripts/ci/tsconfig.json",
     "verify:contract-manifest": "node --import tsx scripts/emitRuntimeContractManifest.ts --check",
     "verify:native": "node --experimental-strip-types src/runtime/native/verifyArtifacts.ts",
     "verify:production-closure": "node --experimental-strip-types scripts/verifyProductionClosure.ts",
@@ -65,7 +65,7 @@
     "@earendil-works/pi-ai": "^0.79.10",
     "@earendil-works/pi-coding-agent": "^0.79.10",
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@noopolis/mneme": "^0.1.1",
+    "@noopolis/mneme": "^0.1.3",
     "ajv": "^8.17.1",
     "zod": "^4.4.3"
   },