@sema-agent/core 5.65.0 → 6.0.0

package/dist/stores/file/file-snapshot-store.js

@@ -1,353 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readdirSync, readFileSync, rmSync } from "node:fs";
-import { join } from "node:path";
-import { applyManifest, captureManifest, DEFAULT_SNAPSHOT_BOUNDS, } from "../../core/file-snapshot-store.js";
-import { canonicalStoreKey, ensureDir, sanitizePathComponent, sanitizeScope, writeThenLink } from "./fs-atomic.js";
-import { assertAdoptionBootGate } from "./adoption/marker.js";
-const sharedInFlight = new Map();
-function containSinkThenable(r) {
-    if (typeof r?.then === "function") {
-        r.then(undefined, () => {
-        });
-    }
-}
-export class FileFileSnapshotStore {
-    base;
-    blobsDir;
-    manifestsDir;
-    get inFlight() {
-        let t = sharedInFlight.get(this.inFlightKey);
-        if (t === undefined) {
-            t = new Map();
-            sharedInFlight.set(this.inFlightKey, t);
-        }
-        return t;
-    }
-    inFlightKey;
-    bounds;
-    onCorruptRead;
-    constructor(root, bounds, opts) {
-        assertAdoptionBootGate(root, "FileFileSnapshotStore");
-        this.base = join(root, "file-snapshots");
-        this.blobsDir = join(this.base, "blobs");
-        this.manifestsDir = join(this.base, "manifests");
-        ensureDir(this.blobsDir);
-        ensureDir(this.manifestsDir);
-        this.inFlightKey = canonicalStoreKey(this.base);
-        this.bounds = {
-            maxFiles: bounds?.maxFiles ?? DEFAULT_SNAPSHOT_BOUNDS.maxFiles,
-            maxBytes: bounds?.maxBytes ?? DEFAULT_SNAPSHOT_BOUNDS.maxBytes,
-            ignoreDirs: new Set(bounds?.ignoreDirs ?? DEFAULT_SNAPSHOT_BOUNDS.ignoreDirs),
-        };
-        this.onCorruptRead = opts?.onCorruptRead;
-    }
-    disclose(path, reason) {
-        try {
-            containSinkThenable(this.onCorruptRead?.({ path, reason }));
-        }
-        catch {
-        }
-    }
-    scopeDir(scope) {
-        return join(this.manifestsDir, sanitizeScope(scope));
-    }
-    manifestPath(scope, key) {
-        return join(this.scopeDir(scope), `${sanitizePathComponent(key)}.json`);
-    }
-    tryManifestPath(scope, key) {
-        try {
-            return this.manifestPath(scope, key);
-        }
-        catch {
-            return null;
-        }
-    }
-    blobPath(hash) {
-        return join(this.blobsDir, sanitizePathComponent(hash));
-    }
-    readManifest(path) {
-        let raw;
-        try {
-            raw = readFileSync(path, "utf8");
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return null;
-            throw err;
-        }
-        try {
-            const parsed = JSON.parse(raw);
-            if (Array.isArray(parsed))
-                return new Map(parsed);
-            this.disclose(path, "manifest is not a pair array — read as no snapshot");
-            return null;
-        }
-        catch {
-            this.disclose(path, "unparseable manifest JSON (torn/zero-byte write?) — read as no snapshot");
-            return null;
-        }
-    }
-    async snapshot(scope, key, env, root, signal) {
-        const mpath = this.tryManifestPath(scope, key);
-        if (!mpath)
-            return { ok: false, error: { code: "restore_failed", message: `unsafe snapshot key ${JSON.stringify(key)}` } };
-        if (this.inFlight.has(mpath))
-            return { ok: true };
-        if (this.readManifest(mpath) !== null)
-            return { ok: true };
-        if (existsSync(mpath)) {
-            try {
-                rmSync(mpath, { force: true });
-            }
-            catch {
-            }
-        }
-        const written = new Set();
-        this.inFlight.set(mpath, written);
-        try {
-            const captured = await captureManifest(env, root, this.bounds, signal, (hash, bytes) => {
-                written.add(hash);
-                try {
-                    writeThenLink(this.blobPath(hash), bytes);
-                }
-                catch (err) {
-                    if (err.code !== "EEXIST")
-                        throw err;
-                }
-            });
-            if (!captured.ok)
-                return captured;
-            ensureDir(this.scopeDir(scope));
-            writeThenLink(mpath, JSON.stringify([...captured.value]));
-            return { ok: true };
-        }
-        catch (err) {
-            if (err.code === "EEXIST")
-                return { ok: true };
-            return { ok: false, error: { code: "restore_failed", message: `snapshot persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(mpath);
-        }
-    }
-    async restore(scope, key, env, root, signal) {
-        const mpath = this.tryManifestPath(scope, key);
-        const manifest = mpath ? this.readManifest(mpath) : null;
-        if (!manifest)
-            return { ok: false, error: { code: "not_found", message: `no snapshot for key ${key}` } };
-        return applyManifest(env, root, this.bounds, signal, manifest, (hash) => {
-            try {
-                return readFileSync(this.blobPath(hash));
-            }
-            catch (err) {
-                return undefined;
-            }
-        });
-    }
-    async listKeys(scope) {
-        const dir = this.scopeDir(scope);
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                return [];
-            this.disclose(dir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — listed as no keys`);
-            return [];
-        }
-        return entries
-            .filter((f) => f.endsWith(".json"))
-            .filter((f) => this.readManifest(join(dir, f)) !== null)
-            .map((f) => f.slice(0, -".json".length));
-    }
-    async has(scope, key) {
-        const mpath = this.tryManifestPath(scope, key);
-        return mpath !== null && this.readManifest(mpath) !== null;
-    }
-    async exportManifest(scope, key) {
-        const mpath = this.tryManifestPath(scope, key);
-        return mpath ? this.readManifest(mpath) : null;
-    }
-    async getBlob(hash) {
-        try {
-            return readFileSync(this.blobPath(hash));
-        }
-        catch {
-            return undefined;
-        }
-    }
-    async putBlob(hash, bytes) {
-        if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-            return { ok: false, error: { code: "read_failed", message: `blob bytes fail content-address integrity for ${hash}` } };
-        }
-        try {
-            writeThenLink(this.blobPath(hash), bytes);
-        }
-        catch (err) {
-            if (err.code === "EEXIST")
-                return { ok: true };
-            return { ok: false, error: { code: "restore_failed", message: `putBlob persist failed: ${err.message}` } };
-        }
-        return { ok: true };
-    }
-    async importManifest(scope, key, manifest, srcGetBlob) {
-        const mpath = this.tryManifestPath(scope, key);
-        if (!mpath)
-            return { ok: false, error: { code: "restore_failed", message: `unsafe snapshot key ${JSON.stringify(key)}` } };
-        if (this.inFlight.has(mpath))
-            return { ok: true };
-        if (this.readManifest(mpath) !== null)
-            return { ok: true };
-        if (existsSync(mpath)) {
-            try {
-                rmSync(mpath, { force: true });
-            }
-            catch {
-            }
-        }
-        const written = new Set();
-        this.inFlight.set(mpath, written);
-        try {
-            for (const hash of new Set(manifest.values())) {
-                written.add(hash);
-                let bpath;
-                try {
-                    bpath = this.blobPath(hash);
-                }
-                catch {
-                    return { ok: false, error: { code: "read_failed", message: `unsafe blob hash ${JSON.stringify(hash)}` } };
-                }
-                if (existsSync(bpath))
-                    continue;
-                let bytes;
-                try {
-                    bytes = await srcGetBlob(hash);
-                }
-                catch (err) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fetch failed: ${err.message}` } };
-                }
-                if (!bytes)
-                    return { ok: false, error: { code: "read_failed", message: `missing source blob ${hash}` } };
-                if (createHash("sha256").update(bytes).digest("hex") !== hash) {
-                    return { ok: false, error: { code: "read_failed", message: `source blob ${hash} fails content-address integrity` } };
-                }
-                try {
-                    writeThenLink(bpath, bytes);
-                }
-                catch (err) {
-                    if (err.code !== "EEXIST")
-                        throw err;
-                }
-            }
-            ensureDir(this.scopeDir(scope));
-            writeThenLink(mpath, JSON.stringify([...manifest]));
-            return { ok: true };
-        }
-        catch (err) {
-            if (err.code === "EEXIST")
-                return { ok: true };
-            return { ok: false, error: { code: "restore_failed", message: `import persist failed: ${err.message}` } };
-        }
-        finally {
-            this.inFlight.delete(mpath);
-        }
-    }
-    async reap(scope, keepKeys) {
-        const keep = new Set(keepKeys);
-        const dir = this.scopeDir(scope);
-        let removed = 0;
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                entries = [];
-            else {
-                entries = [];
-                this.disclose(dir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — the manifest-deletion pass was skipped`);
-            }
-        }
-        for (const file of entries) {
-            if (!file.endsWith(".json"))
-                continue;
-            const key = file.slice(0, -".json".length);
-            if (!keep.has(key)) {
-                if (safeRm(join(dir, file)))
-                    removed++;
-            }
-        }
-        const live = new Set();
-        for (const hs of this.inFlight.values())
-            for (const h of hs)
-                live.add(h);
-        let complete = true;
-        let scopeDirs;
-        try {
-            scopeDirs = readdirSync(this.manifestsDir);
-        }
-        catch (err) {
-            if (err.code === "ENOENT")
-                scopeDirs = [];
-            else {
-                this.disclose(this.manifestsDir, `manifest root unreadable (${err.code ?? "unknown"}) — blob GC aborted, every blob kept`);
-                return removed;
-            }
-        }
-        for (const scopeName of scopeDirs) {
-            const sdir = join(this.manifestsDir, scopeName);
-            let files;
-            try {
-                files = readdirSync(sdir);
-            }
-            catch (err) {
-                if (err.code === "ENOENT")
-                    continue;
-                complete = false;
-                this.disclose(sdir, `manifest scope directory unreadable (${err.code ?? "unknown"}) — blob GC aborted, every blob kept`);
-                break;
-            }
-            for (const file of files) {
-                if (!file.endsWith(".json"))
-                    continue;
-                const m = this.readManifest(join(sdir, file));
-                if (!m) {
-                    complete = false;
-                    this.disclose(join(sdir, file), "manifest unreadable during the live-set scan — blob GC aborted, every blob kept");
-                    break;
-                }
-                for (const h of m.values())
-                    live.add(h);
-            }
-            if (!complete)
-                break;
-        }
-        if (!complete)
-            return removed;
-        let blobs;
-        try {
-            blobs = readdirSync(this.blobsDir);
-        }
-        catch (err) {
-            if (err.code !== "ENOENT") {
-                this.disclose(this.blobsDir, `blob directory unreadable (${err.code ?? "unknown"}) — blob GC skipped, every blob kept`);
-            }
-            return removed;
-        }
-        for (const blob of blobs) {
-            if (!live.has(blob))
-                safeRm(join(this.blobsDir, blob));
-        }
-        return removed;
-    }
-}
-function safeRm(path) {
-    try {
-        rmSync(path, { force: true });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}