@nowcrew/daemon 0.6.19 → 0.6.21

package/dist/project-skills/runtime-root-state-artifact-domain.js

@@ -0,0 +1,143 @@
+import { createHash } from "node:crypto";
+import { lstat, open, opendir } from "node:fs/promises";
+import { ProjectSkillRuntimeStoreError, parseProjectSkillRuntimeStoreState, } from "./runtime-root-domain.js";
+export const RUNTIME_ROOT_STATE_MAX_BYTES = 4 * 1024 * 1024;
+const MAX_CONSISTENT_READ_ATTEMPTS = 6;
+const fail = (code) => { throw new ProjectSkillRuntimeStoreError(code); };
+const isMissing = (error) => error.code === "ENOENT";
+const ownedByCurrentUser = (uid) => process.getuid === undefined || uid === BigInt(process.getuid());
+const fileIdentity = (info) => Object.freeze({
+    dev: info.dev,
+    ino: info.ino,
+    uid: info.uid,
+    size: info.size,
+    mtimeNs: info.mtimeNs,
+    ctimeNs: info.ctimeNs,
+    birthtimeNs: info.birthtimeNs,
+});
+const sameFileIdentity = (left, right, allowCtimeChange = false) => left.dev === right.dev
+    && left.ino === right.ino
+    && left.uid === right.uid
+    && left.size === right.size
+    && left.mtimeNs === right.mtimeNs
+    && left.birthtimeNs === right.birthtimeNs
+    && (allowCtimeChange || left.ctimeNs === right.ctimeNs);
+export const digestRuntimeRootStateRaw = (raw) => `sha256:${createHash("sha256").update(raw, "utf8").digest("hex")}`;
+export const serializeRuntimeRootStateFileIdentity = (identity) => ({
+    dev: identity.dev.toString(),
+    ino: identity.ino.toString(),
+    uid: identity.uid.toString(),
+    size: identity.size.toString(),
+    mtimeNs: identity.mtimeNs.toString(),
+    ctimeNs: identity.ctimeNs.toString(),
+    birthtimeNs: identity.birthtimeNs.toString(),
+});
+export const snapshotMatchesRuntimeRootStateBinding = (snapshot, binding, allowCtimeChange) => snapshot.raw === binding.content
+    && digestRuntimeRootStateRaw(snapshot.raw) === binding.digest
+    && snapshot.identity.dev.toString() === binding.identity.dev
+    && snapshot.identity.ino.toString() === binding.identity.ino
+    && snapshot.identity.uid.toString() === binding.identity.uid
+    && snapshot.identity.size.toString() === binding.identity.size
+    && snapshot.identity.mtimeNs.toString() === binding.identity.mtimeNs
+    && snapshot.identity.birthtimeNs.toString() === binding.identity.birthtimeNs
+    && (allowCtimeChange || snapshot.identity.ctimeNs.toString() === binding.identity.ctimeNs);
+export const readRuntimeRootStateStableFile = async (filePath, maximumBytes) => {
+    for (let attempt = 0; attempt < MAX_CONSISTENT_READ_ATTEMPTS; attempt += 1) {
+        let before;
+        try {
+            before = await lstat(filePath, { bigint: true });
+        }
+        catch (error) {
+            if (isMissing(error))
+                return null;
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        if (!before.isFile() || before.isSymbolicLink() || !ownedByCurrentUser(before.uid)
+            || before.size > BigInt(maximumBytes)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        let handle = null;
+        try {
+            handle = await open(filePath, "r");
+            const opened = await handle.stat({ bigint: true });
+            if (!opened.isFile() || opened.isSymbolicLink() || !ownedByCurrentUser(opened.uid)
+                || opened.size > BigInt(maximumBytes)
+                || !sameFileIdentity(fileIdentity(before), fileIdentity(opened)))
+                continue;
+            const raw = await handle.readFile("utf8");
+            const after = await handle.stat({ bigint: true });
+            let pathAfter;
+            try {
+                pathAfter = await lstat(filePath, { bigint: true });
+            }
+            catch (error) {
+                if (isMissing(error))
+                    continue;
+                return fail("skill_projection_runtime_root_unmanaged");
+            }
+            if (!pathAfter.isFile() || pathAfter.isSymbolicLink()
+                || Buffer.byteLength(raw, "utf8") !== Number(after.size)
+                || !sameFileIdentity(fileIdentity(opened), fileIdentity(after))
+                || !sameFileIdentity(fileIdentity(after), fileIdentity(pathAfter)))
+                continue;
+            return Object.freeze({ identity: fileIdentity(after), raw });
+        }
+        catch (error) {
+            if (error instanceof ProjectSkillRuntimeStoreError)
+                throw error;
+            if (isMissing(error))
+                continue;
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        finally {
+            await handle?.close().catch(() => undefined);
+        }
+    }
+    return fail("skill_projection_runtime_root_unmanaged");
+};
+const parseStateRaw = (raw) => {
+    let candidate;
+    try {
+        candidate = JSON.parse(raw);
+    }
+    catch {
+        return fail("skill_projection_snapshot_corrupt");
+    }
+    return parseProjectSkillRuntimeStoreState(candidate);
+};
+export const loadRuntimeRootState = async (statePath) => {
+    const snapshot = await readRuntimeRootStateStableFile(statePath, RUNTIME_ROOT_STATE_MAX_BYTES);
+    if (snapshot === null)
+        return null;
+    return Object.freeze({ state: parseStateRaw(snapshot.raw), snapshot });
+};
+export const boundedRuntimeRootStateNames = async (directoryPath, maximumEntries) => {
+    let directory;
+    try {
+        directory = await opendir(directoryPath);
+    }
+    catch {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    const names = [];
+    try {
+        for (;;) {
+            const entry = await directory.read();
+            if (entry === null)
+                break;
+            names.push(entry.name);
+            if (names.length > maximumEntries) {
+                return fail("skill_projection_runtime_store_limit_exceeded");
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof ProjectSkillRuntimeStoreError)
+            throw error;
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    finally {
+        await directory.close().catch(() => undefined);
+    }
+    return Object.freeze(names.sort());
+};

package/dist/project-skills/runtime-root-state-index.js

@@ -0,0 +1,356 @@
+import { randomUUID } from "node:crypto";
+import { open, unlink } from "node:fs/promises";
+import { z } from "zod";
+import { ProjectSkillRuntimeStoreError, createProjectSkillRuntimeStoreState, isCanonicalProjectSkillRuntimeRootId, parseProjectSkillRuntimeStoreState, } from "./runtime-root-domain.js";
+import { RUNTIME_ROOT_STATE_MAX_BYTES, boundedRuntimeRootStateNames, digestRuntimeRootStateRaw, loadRuntimeRootState, readRuntimeRootStateStableFile, serializeRuntimeRootStateFileIdentity, snapshotMatchesRuntimeRootStateBinding, } from "./runtime-root-state-artifact-domain.js";
+const MANAGED_BY = "nowcrew-project-skill-runtime-state-index";
+const MAX_INDEX_ENTRIES = 64;
+const MAX_INDEX_RECORD_BYTES = (RUNTIME_ROOT_STATE_MAX_BYTES * 2) + (128 * 1024);
+const PRIVATE_NAME = /^\.state-index-private-([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.tmp$/u;
+const FINAL_NAME = /^(legacy-import|high-water)-([0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})\.json$/u;
+const DECIMAL = /^(?:0|[1-9][0-9]*)$/u;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+// The store's single-daemon-writer invariant is enforced by its coordinator. This process-local
+// queue also closes the capacity-check/publication gap for callers that share this owner directly.
+// A separate process remains outside that invariant; any resulting over-cap inventory fails closed.
+const indexCreationTails = new Map();
+const fail = (code) => {
+    throw new ProjectSkillRuntimeStoreError(code);
+};
+const ownedByCurrentUser = (uid) => process.getuid === undefined || uid === BigInt(process.getuid());
+const SerializedIdentitySchema = z.object({
+    dev: z.string().regex(DECIMAL),
+    ino: z.string().regex(DECIMAL),
+    uid: z.string().regex(DECIMAL),
+    birthtimeNs: z.string().regex(DECIMAL),
+}).strict();
+const LegacyFileIdentitySchema = z.object({
+    dev: z.string().regex(DECIMAL),
+    ino: z.string().regex(DECIMAL),
+    uid: z.string().regex(DECIMAL),
+    size: z.string().regex(DECIMAL),
+    mtimeNs: z.string().regex(DECIMAL),
+    ctimeNs: z.string().regex(DECIMAL),
+    birthtimeNs: z.string().regex(DECIMAL),
+}).strict();
+const BaseRecordSchema = z.object({
+    managedBy: z.literal(MANAGED_BY),
+    version: z.literal(1),
+    nonce: z.string().refine(isCanonicalProjectSkillRuntimeRootId),
+    nextSequence: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+    artifactIdentity: SerializedIdentitySchema,
+});
+const LegacyImportRecordSchema = BaseRecordSchema.extend({
+    kind: z.literal("legacy-import"),
+    state: z.object({
+        content: z.string(),
+        digest: z.string().regex(DIGEST),
+        identity: LegacyFileIdentitySchema,
+    }).strict(),
+}).strict();
+const HighWaterRecordSchema = BaseRecordSchema.extend({
+    kind: z.literal("high-water"),
+}).strict();
+const IndexRecordSchema = z.discriminatedUnion("kind", [
+    LegacyImportRecordSchema,
+    HighWaterRecordSchema,
+]);
+const sameRecord = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+const serializeIndexIdentity = (identity) => Object.freeze({
+    dev: identity.dev.toString(),
+    ino: identity.ino.toString(),
+    uid: identity.uid.toString(),
+    birthtimeNs: identity.birthtimeNs.toString(),
+});
+const identityMatches = (actual, expected) => actual.dev.toString() === expected.dev
+    && actual.ino.toString() === expected.ino
+    && actual.uid.toString() === expected.uid
+    && actual.birthtimeNs.toString() === expected.birthtimeNs;
+const parseIndexRecord = async (filePath, expectedNonce, expectedKind) => {
+    const snapshot = await readRuntimeRootStateStableFile(filePath, MAX_INDEX_RECORD_BYTES);
+    if (snapshot === null)
+        return fail("skill_projection_runtime_root_unmanaged");
+    let candidate;
+    try {
+        candidate = JSON.parse(snapshot.raw);
+    }
+    catch {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    const parsed = IndexRecordSchema.safeParse(candidate);
+    if (!parsed.success
+        || parsed.data.nonce !== expectedNonce
+        || (expectedKind !== undefined && parsed.data.kind !== expectedKind)) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    if (!identityMatches(snapshot.identity, parsed.data.artifactIdentity)) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    return Object.freeze(parsed.data);
+};
+const finalName = (record) => `${record.kind}-${record.nonce}.json`;
+const withIndexCreationLock = async (key, operation) => {
+    const previous = indexCreationTails.get(key) ?? Promise.resolve();
+    let release;
+    const turn = new Promise((resolve) => { release = resolve; });
+    const tail = previous.then(() => turn);
+    indexCreationTails.set(key, tail);
+    await previous;
+    try {
+        return await operation();
+    }
+    finally {
+        release?.();
+        if (indexCreationTails.get(key) === tail)
+            indexCreationTails.delete(key);
+    }
+};
+const activateStagedRecord = async (context, stagingPath, nonce, invokeHook) => {
+    const staged = await parseIndexRecord(stagingPath, nonce);
+    const destination = context.path.join(context.indexDirectory, finalName(staged));
+    const hookContext = Object.freeze({
+        stagingPath,
+        finalPath: destination,
+        kind: staged.kind,
+        nonce,
+    });
+    if (invokeHook)
+        await context.hooks?.afterStagingDurableBeforeRename?.(hookContext);
+    const result = await context.atomicRename(stagingPath, destination);
+    if (result !== "published")
+        return fail("skill_projection_runtime_root_unmanaged");
+    if (invokeHook)
+        await context.hooks?.afterRenamedBeforeParentSync?.(hookContext);
+    await context.syncDirectory(context.indexDirectory);
+    if (invokeHook)
+        await context.hooks?.afterParentSyncedBeforeRevalidate?.(hookContext);
+    return parseIndexRecord(destination, nonce, staged.kind);
+};
+const writeIndexRecord = async (context, input) => {
+    const nonce = (context.randomId ?? randomUUID)();
+    if (!isCanonicalProjectSkillRuntimeRootId(nonce)) {
+        return fail("skill_projection_snapshot_corrupt");
+    }
+    const stagingPath = context.path.join(context.indexDirectory, `.state-index-private-${nonce}.tmp`);
+    let handle = null;
+    try {
+        handle = await open(stagingPath, "wx", 0o600);
+        const info = await handle.stat({ bigint: true });
+        if (!info.isFile() || info.isSymbolicLink() || !ownedByCurrentUser(info.uid)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        const record = Object.freeze({
+            managedBy: MANAGED_BY,
+            version: 1,
+            ...input,
+            nonce,
+            artifactIdentity: serializeIndexIdentity({
+                dev: info.dev,
+                ino: info.ino,
+                uid: info.uid,
+                birthtimeNs: info.birthtimeNs,
+            }),
+        });
+        const raw = `${JSON.stringify(record)}\n`;
+        if (Buffer.byteLength(raw, "utf8") > MAX_INDEX_RECORD_BYTES) {
+            return fail("skill_projection_runtime_store_limit_exceeded");
+        }
+        await handle.writeFile(raw, "utf8");
+        await handle.sync();
+        await handle.close();
+        handle = null;
+        await context.syncDirectory(context.indexDirectory);
+        await parseIndexRecord(stagingPath, nonce, input.kind);
+        return activateStagedRecord(context, stagingPath, nonce, true);
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+};
+const scanIndex = async (context) => {
+    const initialNames = await boundedRuntimeRootStateNames(context.indexDirectory, MAX_INDEX_ENTRIES);
+    for (const name of initialNames) {
+        const privateMatch = PRIVATE_NAME.exec(name);
+        if (privateMatch === null)
+            continue;
+        await activateStagedRecord(context, context.path.join(context.indexDirectory, name), privateMatch[1], false);
+    }
+    const names = await boundedRuntimeRootStateNames(context.indexDirectory, MAX_INDEX_ENTRIES);
+    const records = [];
+    for (const name of names) {
+        const match = FINAL_NAME.exec(name);
+        if (match === null)
+            return fail("skill_projection_runtime_root_unmanaged");
+        records.push(await parseIndexRecord(context.path.join(context.indexDirectory, name), match[2], match[1]));
+    }
+    return Object.freeze(records);
+};
+const createIndexRecord = async (context, input) => withIndexCreationLock(context.path.resolve(context.indexDirectory), async () => {
+    const inventory = await scanIndex(context);
+    if (inventory.length >= MAX_INDEX_ENTRIES) {
+        return fail("skill_projection_runtime_store_limit_exceeded");
+    }
+    return writeIndexRecord(context, input);
+});
+const exactLegacyBinding = (snapshot) => Object.freeze({
+    content: snapshot.raw,
+    digest: digestRuntimeRootStateRaw(snapshot.raw),
+    identity: Object.freeze(serializeRuntimeRootStateFileIdentity(snapshot.identity)),
+});
+const parseEmbeddedLegacyState = (receipt) => {
+    if (Buffer.byteLength(receipt.state.content, "utf8") > RUNTIME_ROOT_STATE_MAX_BYTES
+        || receipt.state.identity.size !== String(Buffer.byteLength(receipt.state.content, "utf8"))
+        || digestRuntimeRootStateRaw(receipt.state.content) !== receipt.state.digest) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    let candidate;
+    try {
+        candidate = JSON.parse(receipt.state.content);
+    }
+    catch {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    let state;
+    try {
+        state = parseProjectSkillRuntimeStoreState(candidate);
+    }
+    catch {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    if (state.nextSequence !== receipt.nextSequence) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    return state;
+};
+const validateLegacyRoots = (legacy, roots) => {
+    for (const record of legacy.roots) {
+        const actual = roots.find(({ rootId }) => rootId === record.rootId);
+        if (actual === undefined || !sameRecord(actual, record)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+    }
+};
+const validateImportedRootSemantics = (imported, roots) => {
+    for (const root of roots) {
+        const importedById = imported.roots.find(({ rootId }) => rootId === root.rootId);
+        const importedBySequence = imported.roots.find(({ publishedSequence }) => publishedSequence === root.publishedSequence);
+        if ((importedById !== undefined && !sameRecord(importedById, root))
+            || (importedBySequence !== undefined && !sameRecord(importedBySequence, root))
+            || (importedById === undefined
+                && importedBySequence === undefined
+                && root.publishedSequence < imported.nextSequence)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+    }
+};
+const validateLegacyEvidence = async (context, receipt) => {
+    const current = await readRuntimeRootStateStableFile(context.statePath, RUNTIME_ROOT_STATE_MAX_BYTES);
+    if (current === null || !snapshotMatchesRuntimeRootStateBinding(current, receipt.state, false)) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+};
+export async function reconstructRuntimeRootState(context, roots) {
+    let records = await scanIndex(context);
+    let legacyReceipts = records.filter((record) => record.kind === "legacy-import");
+    if (legacyReceipts.length > 1)
+        return fail("skill_projection_runtime_root_unmanaged");
+    const existingReceipt = legacyReceipts[0];
+    let importedState;
+    if (existingReceipt !== undefined) {
+        importedState = parseEmbeddedLegacyState(existingReceipt);
+        validateImportedRootSemantics(importedState, roots);
+    }
+    const legacyFile = await loadRuntimeRootState(context.statePath);
+    if (legacyReceipts.length === 0 && legacyFile !== null) {
+        validateLegacyRoots(legacyFile.state, roots);
+        await context.hooks?.afterLegacyStateValidatedBeforeImport?.(Object.freeze({ statePath: context.statePath }));
+        const created = await createIndexRecord(context, {
+            kind: "legacy-import",
+            nextSequence: legacyFile.state.nextSequence,
+            state: exactLegacyBinding(legacyFile.snapshot),
+        });
+        if (created.kind !== "legacy-import")
+            return fail("skill_projection_runtime_root_unmanaged");
+        records = Object.freeze([...records, created]);
+        legacyReceipts = [created];
+    }
+    const receipt = legacyReceipts[0];
+    if (receipt !== undefined) {
+        if (importedState === undefined) {
+            importedState = parseEmbeddedLegacyState(receipt);
+            validateImportedRootSemantics(importedState, roots);
+        }
+        await validateLegacyEvidence(context, receipt);
+    }
+    const rootIds = new Set();
+    const sequences = new Set();
+    let nextSequence = receipt?.nextSequence ?? 0;
+    for (const root of roots) {
+        if (rootIds.has(root.rootId) || sequences.has(root.publishedSequence)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        rootIds.add(root.rootId);
+        sequences.add(root.publishedSequence);
+        nextSequence = Math.max(nextSequence, root.publishedSequence + 1);
+    }
+    const highWaterSequences = new Set();
+    for (const record of records) {
+        if (record.kind !== "high-water")
+            continue;
+        if (highWaterSequences.has(record.nextSequence)) {
+            return fail("skill_projection_runtime_root_unmanaged");
+        }
+        highWaterSequences.add(record.nextSequence);
+        nextSequence = Math.max(nextSequence, record.nextSequence);
+    }
+    if (!Number.isSafeInteger(nextSequence)) {
+        return fail("skill_projection_runtime_store_limit_exceeded");
+    }
+    return createProjectSkillRuntimeStoreState({ nextSequence, roots });
+}
+export async function checkpointRuntimeRootNextSequence(context, state, options = {}) {
+    const records = await scanIndex(context);
+    const durable = records
+        .filter((record) => record.kind === "high-water")
+        .some((record) => record.nextSequence >= state.nextSequence);
+    if (!durable) {
+        try {
+            await createIndexRecord(context, { kind: "high-water", nextSequence: state.nextSequence });
+        }
+        catch (error) {
+            if (!(options.allowCapacityCompaction === true
+                && error instanceof ProjectSkillRuntimeStoreError
+                && error.code === "skill_projection_runtime_store_limit_exceeded"))
+                throw error;
+            const records = await scanIndex(context);
+            const maximum = Math.max(...records.map((record) => record.nextSequence));
+            const dominated = records
+                .filter((record) => record.kind === "high-water" && record.nextSequence < maximum)
+                .sort((left, right) => left.nextSequence - right.nextSequence)[0];
+            if (dominated === undefined)
+                throw error;
+            const source = context.path.join(context.indexDirectory, finalName(dominated));
+            // Reuse the recoverable private-artifact grammar so a crash after claim restores the
+            // dominated record on the next scan instead of poisoning the state-index inventory.
+            const claim = context.path.join(context.indexDirectory, `.state-index-private-${dominated.nonce}.tmp`);
+            const claimed = await context.atomicRename(source, claim);
+            if (claimed !== "published")
+                throw error;
+            try {
+                await parseIndexRecord(claim, dominated.nonce, "high-water");
+                await unlink(claim);
+                await context.syncDirectory(context.indexDirectory);
+            }
+            catch (claimError) {
+                throw claimError;
+            }
+            await context.syncDirectory(context.indexDirectory);
+            await createIndexRecord(context, { kind: "high-water", nextSequence: state.nextSequence });
+        }
+    }
+    const reconstructed = await reconstructRuntimeRootState(context, state.roots);
+    if (reconstructed.nextSequence < state.nextSequence) {
+        return fail("skill_projection_runtime_root_unmanaged");
+    }
+    return reconstructed.nextSequence;
+}