@nowcrew/daemon 0.6.16 → 0.6.18

package/dist/project-skills/projection-state-transaction.js

@@ -0,0 +1,318 @@
+import { randomUUID } from "node:crypto";
+import { chmod, link, lstat, mkdir, readlink, rename, symlink } from "node:fs/promises";
+import { join } from "node:path";
+import { appliedProjectSkillManifestPath, projectSkillManifestStoreInternals as store, } from "./projection-state-store.js";
+const manifestsMatch = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+export const projectSkillManifestUpdateRecord = (update) => Object.freeze({
+    managedBy: "nowcrew-project-skills-v2-update",
+    version: 1,
+    operationId: update.operationId,
+    previous: update.previous,
+    next: update.next,
+});
+export const parseProjectSkillManifestUpdateRecord = (candidate) => {
+    if (candidate === null || typeof candidate !== "object")
+        return store.pathUnmanaged();
+    const record = candidate;
+    if (record.managedBy !== "nowcrew-project-skills-v2-update"
+        || record.version !== 1
+        || typeof record.operationId !== "string"
+        || !store.ARTIFACT_ID.test(record.operationId)
+        || !("previous" in record)
+        || !("next" in record)
+        || Object.keys(record).sort().join(",") !== "managedBy,next,operationId,previous,version") {
+        return store.pathUnmanaged();
+    }
+    const previous = record.previous === null
+        ? null
+        : store.parseAppliedProjectSkillManifest(record.previous);
+    const next = record.next === null ? null : store.parseAppliedProjectSkillManifest(record.next);
+    return Object.freeze({
+        managedBy: "nowcrew-project-skills-v2-update",
+        version: 1,
+        operationId: record.operationId,
+        previous,
+        next,
+    });
+};
+export const preparedProjectSkillManifestUpdateFromRecord = (agentRoot, candidate) => {
+    const record = parseProjectSkillManifestUpdateRecord(candidate);
+    return Object.freeze({
+        agentRoot,
+        operationId: record.operationId,
+        previous: record.previous,
+        next: record.next,
+    });
+};
+const stateContext = async (agentRoot, options, settle) => {
+    const syncDirectory = store.projectionDirectorySync(options);
+    await store.realOwnedDirectory(agentRoot, false);
+    const stateDirectory = join(agentRoot, ".crew");
+    if (!await store.realOwnedDirectory(stateDirectory, true)) {
+        try {
+            await mkdir(stateDirectory, { mode: 0o700 });
+        }
+        catch (error) {
+            if (!store.isExisting(error))
+                return store.pathUnmanaged();
+        }
+        await store.realOwnedDirectory(stateDirectory, false);
+    }
+    await chmod(stateDirectory, 0o700).catch(() => store.pathUnmanaged());
+    const manifestPath = appliedProjectSkillManifestPath(agentRoot);
+    if (settle) {
+        await store.settleDiscardResidues(stateDirectory, syncDirectory);
+        await store.settlePreparingResidues(stateDirectory, syncDirectory);
+        await store.settleAnyExistingOperation(manifestPath, stateDirectory, syncDirectory);
+    }
+    return Object.freeze({ manifestPath, stateDirectory, syncDirectory });
+};
+const operationPath = (stateDirectory, operationId) => {
+    if (!store.ARTIFACT_ID.test(operationId))
+        return store.pathUnmanaged();
+    return join(stateDirectory, `${store.OPERATION_PREFIX}${operationId}${store.OPERATION_SUFFIX}`);
+};
+const loadBoundUpdate = async (update, options) => {
+    const context = await stateContext(update.agentRoot, options, false);
+    const operation = await store.loadOperation(operationPath(context.stateDirectory, update.operationId));
+    if (operation.intent.nonce !== update.operationId || operation.stage === null)
+        return store.pathUnmanaged();
+    const next = store.isAbsenceMarkerRaw(operation.intent.stage.content)
+        ? null
+        : store.parseManifestRaw(operation.intent.stage.content);
+    const previous = operation.intent.previous === null
+        ? null
+        : store.parseManifestRaw(operation.intent.previous.content);
+    if (!manifestsMatch(next, update.next) || !manifestsMatch(previous, update.previous)) {
+        return store.pathUnmanaged();
+    }
+    return Object.freeze({ ...context, operation });
+};
+const completedWithoutOperation = async (update, expected, options) => {
+    const context = await stateContext(update.agentRoot, options, false);
+    const path = operationPath(context.stateDirectory, update.operationId);
+    try {
+        await lstat(path);
+        return false;
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return store.pathUnmanaged();
+    }
+    await store.settleDiscardResidues(context.stateDirectory, context.syncDirectory);
+    const current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    const manifest = current === null ? null : store.parseManifestRaw(current.raw);
+    if (!manifestsMatch(manifest, expected))
+        return store.pathUnmanaged();
+    return true;
+};
+const restoreUnknownClaimNoClobber = async (claimedPath, manifestPath, syncDirectory, stateDirectory, afterSlotChecked) => {
+    const claimedIdentity = await lstat(claimedPath, { bigint: true }).catch(() => store.pathUnmanaged());
+    if (claimedIdentity.isFile()) {
+        try {
+            await link(claimedPath, manifestPath);
+            await syncDirectory(stateDirectory);
+        }
+        catch {
+            return store.pathUnmanaged();
+        }
+        const restored = await lstat(manifestPath, { bigint: true }).catch(() => store.pathUnmanaged());
+        if (restored.dev !== claimedIdentity.dev || restored.ino !== claimedIdentity.ino) {
+            return store.pathUnmanaged();
+        }
+        return store.pathUnmanaged();
+    }
+    try {
+        await lstat(manifestPath);
+        return store.pathUnmanaged();
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            return store.pathUnmanaged();
+    }
+    await afterSlotChecked?.();
+    if (!claimedIdentity.isSymbolicLink())
+        return store.pathUnmanaged();
+    const target = await readlink(claimedPath).catch(() => store.pathUnmanaged());
+    const beforeRestore = await lstat(claimedPath, { bigint: true }).catch(() => store.pathUnmanaged());
+    if (!beforeRestore.isSymbolicLink()
+        || beforeRestore.dev !== claimedIdentity.dev
+        || beforeRestore.ino !== claimedIdentity.ino) {
+        return store.pathUnmanaged();
+    }
+    try {
+        await symlink(target, manifestPath);
+        await syncDirectory(stateDirectory);
+    }
+    catch {
+        return store.pathUnmanaged();
+    }
+    const restored = await lstat(manifestPath, { bigint: true }).catch(() => store.pathUnmanaged());
+    if (!restored.isSymbolicLink()
+        || await readlink(manifestPath).catch(() => store.pathUnmanaged()) !== target) {
+        return store.pathUnmanaged();
+    }
+    return store.pathUnmanaged();
+};
+const claimPublicManifest = async (context, destinationBasename, expected, beforeClaim, afterClaim, afterRestoreSlotChecked) => {
+    const claimedPath = join(context.operation.path, destinationBasename);
+    await beforeClaim?.();
+    try {
+        await rename(context.manifestPath, claimedPath);
+        await context.syncDirectory(context.operation.path);
+        await context.syncDirectory(context.stateDirectory);
+    }
+    catch {
+        return store.pathUnmanaged();
+    }
+    await afterClaim?.(claimedPath);
+    const claimed = await store.readStableFile(claimedPath, store.MAX_MANIFEST_BYTES).catch(() => restoreUnknownClaimNoClobber(claimedPath, context.manifestPath, context.syncDirectory, context.stateDirectory, afterRestoreSlotChecked === undefined ? undefined : () => afterRestoreSlotChecked(claimedPath)));
+    if (claimed === null || !store.snapshotMatchesBinding(claimed, expected, true)) {
+        return restoreUnknownClaimNoClobber(claimedPath, context.manifestPath, context.syncDirectory, context.stateDirectory, afterRestoreSlotChecked === undefined ? undefined : () => afterRestoreSlotChecked(claimedPath));
+    }
+};
+const prepareManifestTransition = async (agentRoot, next, options = {}) => {
+    const context = await stateContext(agentRoot, options, true);
+    const current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    const previous = current === null ? null : store.parseManifestRaw(current.raw);
+    const content = next === null ? store.ABSENCE_MARKER_RAW : `${JSON.stringify(next)}\n`;
+    const operation = await store.createOperation(context.stateDirectory, current, content, options.randomId ?? randomUUID, context.syncDirectory, options.afterIntentDurableBeforeActivate);
+    await options.afterStageDurable?.(join(operation.path, store.STAGE_BASENAME));
+    const reloaded = await store.loadOperation(operation.path);
+    const observed = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    if (!store.sameSnapshot(reloaded.intentSnapshot, operation.intentSnapshot)
+        || reloaded.stage === null
+        || !store.snapshotMatchesBinding(reloaded.stage, operation.intent.stage, false)
+        || (current === null ? observed !== null : observed === null || !store.sameSnapshot(current, observed))) {
+        await store.cleanupOperation(operation.path, context.syncDirectory);
+        return store.pathUnmanaged();
+    }
+    return Object.freeze({ agentRoot, operationId: operation.intent.nonce, previous, next });
+};
+export async function prepareAppliedProjectSkillManifestUpdate(agentRoot, manifest, options = {}) {
+    return prepareManifestTransition(agentRoot, store.parseAppliedProjectSkillManifest(manifest), options);
+}
+export async function prepareAppliedProjectSkillManifestRemoval(agentRoot, options = {}) {
+    return prepareManifestTransition(agentRoot, null, options);
+}
+export async function publishPreparedProjectSkillManifestUpdate(update, options = {}) {
+    if (await completedWithoutOperation(update, update.next, options))
+        return;
+    const context = await loadBoundUpdate(update, options);
+    const { operation } = context;
+    const existing = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    if (update.next !== null
+        && existing !== null
+        && store.snapshotMatchesBinding(existing, operation.intent.stage, true))
+        return;
+    if (operation.intent.previous === null) {
+        if (existing !== null || operation.previous !== null)
+            return store.pathUnmanaged();
+    }
+    else if (operation.previous === null) {
+        if (existing === null || !store.snapshotMatchesBinding(existing, operation.intent.previous, true)) {
+            return store.pathUnmanaged();
+        }
+        await claimPublicManifest(context, store.PREVIOUS_BASENAME, operation.intent.previous, undefined, options.afterCurrentClaimed);
+    }
+    else if (existing !== null) {
+        return store.pathUnmanaged();
+    }
+    const publishable = await store.loadOperation(operation.path);
+    if (update.next === null && publishable.published !== null) {
+        if (existing !== null)
+            return store.pathUnmanaged();
+        return;
+    }
+    const stagePath = join(operation.path, store.STAGE_BASENAME);
+    const stage = await store.readStableFile(stagePath, store.MAX_MANIFEST_BYTES);
+    if (!store.sameSnapshot(publishable.intentSnapshot, operation.intentSnapshot)
+        || stage === null
+        || !store.snapshotMatchesBinding(stage, operation.intent.stage, false))
+        return store.pathUnmanaged();
+    if (update.next === null) {
+        try {
+            await link(stagePath, context.manifestPath);
+            await context.syncDirectory(context.stateDirectory);
+        }
+        catch (error) {
+            if (!store.isExisting(error))
+                return store.pathUnmanaged();
+        }
+        const claim = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+        if (claim === null || !store.snapshotMatchesBinding(claim, operation.intent.stage, true)) {
+            return store.pathUnmanaged();
+        }
+        await claimPublicManifest(context, store.PUBLISHED_BASENAME, operation.intent.stage, options.afterRemovalMarkerPublished === undefined
+            ? undefined
+            : () => options.afterRemovalMarkerPublished(context.manifestPath));
+        return;
+    }
+    try {
+        await link(stagePath, context.manifestPath);
+        await context.syncDirectory(context.stateDirectory);
+    }
+    catch (error) {
+        if (!store.isExisting(error))
+            return store.pathUnmanaged();
+    }
+    const published = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    if (published === null
+        || !store.snapshotMatchesBinding(published, operation.intent.stage, true)
+        || published.identity.dev !== stage.identity.dev
+        || published.identity.ino !== stage.identity.ino)
+        return store.pathUnmanaged();
+}
+export async function commitPreparedProjectSkillManifestUpdate(update, options = {}) {
+    if (await completedWithoutOperation(update, update.next, options))
+        return;
+    const context = await loadBoundUpdate(update, options);
+    const published = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    const removalPublished = update.next === null
+        && published === null
+        && context.operation.published !== null;
+    if (!removalPublished && (published === null
+        || !store.snapshotMatchesBinding(published, context.operation.intent.stage, true))) {
+        return store.pathUnmanaged();
+    }
+    await store.cleanupOperation(context.operation.path, context.syncDirectory, options);
+}
+export async function rollbackPreparedProjectSkillManifestUpdate(update, options = {}) {
+    if (await completedWithoutOperation(update, update.previous, options))
+        return;
+    let context = await loadBoundUpdate(update, options);
+    let current = await store.readStableFile(context.manifestPath, store.MAX_MANIFEST_BYTES);
+    if (current !== null && store.snapshotMatchesBinding(current, context.operation.intent.stage, true)) {
+        try {
+            await lstat(join(context.operation.path, store.PUBLISHED_BASENAME));
+            return store.pathUnmanaged();
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                return store.pathUnmanaged();
+        }
+        await claimPublicManifest(context, store.PUBLISHED_BASENAME, context.operation.intent.stage, options.afterRollbackFinalCheck === undefined
+            ? undefined
+            : () => options.afterRollbackFinalCheck(context.manifestPath), options.afterRollbackUnknownClaimed === undefined
+            ? undefined
+            : (claimedPath) => options.afterRollbackUnknownClaimed(claimedPath, context.manifestPath), options.afterRollbackRestoreSlotChecked === undefined
+            ? undefined
+            : (claimedPath) => options.afterRollbackRestoreSlotChecked(claimedPath, context.manifestPath));
+        context = await loadBoundUpdate(update, options);
+        if (context.operation.published === null)
+            return store.pathUnmanaged();
+        current = null;
+    }
+    const previousBinding = context.operation.intent.previous;
+    if (previousBinding === null) {
+        if (current !== null)
+            return store.pathUnmanaged();
+    }
+    else if (current === null) {
+        await store.restorePreviousNoClobber(context.operation, context.manifestPath, context.stateDirectory, context.syncDirectory);
+    }
+    else if (!store.snapshotMatchesBinding(current, previousBinding, true)) {
+        return store.pathUnmanaged();
+    }
+    await store.cleanupOperation(context.operation.path, context.syncDirectory, options);
+}

package/dist/project-skills/projection-state.js

@@ -0,0 +1,3 @@
+export { computeProjectSkillBindingDigest, computeProjectSkillResolutionDigest, createAppliedProjectSkillManifest, normalizeProjectSkillResolutionRecords, ProjectSkillProjectionStateError, } from "./projection-state-domain.js";
+export { appliedProjectSkillManifestPath, readAppliedProjectSkillManifest, writeAppliedProjectSkillManifest, } from "./projection-state-store.js";
+export { commitPreparedProjectSkillManifestUpdate, parseProjectSkillManifestUpdateRecord, prepareAppliedProjectSkillManifestRemoval, prepareAppliedProjectSkillManifestUpdate, preparedProjectSkillManifestUpdateFromRecord, projectSkillManifestUpdateRecord, publishPreparedProjectSkillManifestUpdate, rollbackPreparedProjectSkillManifestUpdate, } from "./projection-state-transaction.js";