@lesliechan721/aw 0.1.0-beta.7 → 0.1.0-beta.8

package/dist/src/utils/lifecycle-active-store.js

@@ -1,10 +1,8 @@
 import crypto from 'node:crypto';
 import path from 'node:path';
 import fs from 'fs-extra';
-import { calculateFileDigest, calculatePluginBundleFingerprintV2, } from './bundle-integrity.js';
-import { acquireActiveMarketplaceLifecycleLeaseAtRoot, markActiveMarketplaceDurableCommit, releaseActiveMarketplaceCoordinationLease, resolveActiveMarketplaceRuntimeCoordinationRoot, withActiveMarketplaceLifecycleLease, } from './active-marketplace-runtime-lock.js';
+import { calculateFileDigest, calculatePluginBundleFingerprint, } from './bundle-integrity.js';
 import { PLUGIN_LIFECYCLE_EVENTS } from './plugin-script-contract.js';
-import { acquireProcessLock, } from './process-lock.js';
 import { canonicalizePathThroughExistingAncestor, createProjectLocationKey, getClaudeHome, getCodexHome, resolveCanonicalRepoProjectKey, resolveAwHome, resolveAwHomeCanonical, resolveRepoRoot, } from './state-paths.js';
 import { assertTestWritablePath } from './test-path-fence.js';
 export const LIFECYCLE_ACTIVE_DIR = 'lifecycle-active';
@@ -30,18 +28,12 @@ const ARTIFACT_TARGETS = new Set([
     'claude.skill',
 ]);
 const ARTIFACT_STATES = new Set(['present', 'disabled']);
-const preparedContexts = new WeakMap();
-const readContexts = new WeakMap();
-const releasedReads = new WeakSet();
+const preparedLoaders = new WeakMap();
 const finalizedPrepared = new WeakSet();
 let beforePruneStagingRootForTests;
-let processLockFileSystemForTests;
 export function setLifecycleActiveBeforePruneForTests(hook) {
     beforePruneStagingRootForTests = hook;
 }
-export function setLifecycleActiveLockFileSystemForTests(fileSystem) {
-    processLockFileSystemForTests = fileSystem;
-}
 export class LifecycleActiveSnapshotError extends Error {
     code = 'invalidLifecycleActiveSnapshot';
     constructor(message, options) {
@@ -125,12 +117,8 @@ export async function resolveLifecycleActiveTarget(options) {
     const rawPlatformHome = path.resolve(platform === 'codex' ? getCodexHome(env) : getClaudeHome(env));
     const platformHome = await canonicalizePathThroughExistingAncestor(rawPlatformHome);
     const locationKey = projectKey ? createLifecycleProjectLocationKey(projectKey) : 'user';
-    const coordinationRoot = resolveActiveMarketplaceRuntimeCoordinationRoot(env);
     const storeRoot = assertWritableStorePath(path.join(awHome, LIFECYCLE_ACTIVE_DIR));
     const targetRoot = assertWritableStorePath(path.join(storeRoot, ...(options.sourceId ? [options.sourceId] : []), platform, scope, locationKey, options.pluginName));
-    const lockParent = assertWritableStorePath(path.join(coordinationRoot, 'lifecycle-locks', platform, scope, locationKey));
-    const lockPath = assertWritableStorePath(path.join(lockParent, `.${options.sourceId ? `${options.sourceId}.` : ''}${options.pluginName}.lock`));
-    const operationLockPath = assertWritableStorePath(path.join(lockParent, `.${options.sourceId ? `${options.sourceId}.` : ''}${options.pluginName}.operation.lock`));
     return {
         ...(options.sourceId ? {
             sourceId: options.sourceId,
@@ -143,13 +131,10 @@ export async function resolveLifecycleActiveTarget(options) {
         projectKey,
         locationKey,
         awHome,
-        coordinationRoot,
         storeRoot,
         targetRoot,
         activeRoot: path.join(targetRoot, 'active'),
         stagingRoot: path.join(targetRoot, 'staging'),
-        lockPath,
-        operationLockPath,
         artifactOutputRoots: [awHome, platformHome, ...(projectKey ? [projectKey] : [])],
         pathAliases: [
             { source: rawAwHome, canonical: awHome },
@@ -215,59 +200,6 @@ async function assertExistingDirectoryBoundary(target, candidatePath, fieldName)
         fail(`${fieldName} escapes the canonical lifecycle active store.`);
     }
 }
-async function acquireTargetLock(target, lifecycleLeaseHeld = false) {
-    const lifecycleLease = lifecycleLeaseHeld
-        ? undefined
-        : await acquireActiveMarketplaceLifecycleLeaseAtRoot(target.coordinationRoot);
-    const lockParent = path.dirname(target.lockPath);
-    let targetLease;
-    try {
-        await assertExistingPathChainHasNoSymlinks(target.coordinationRoot, lockParent);
-        await fs.ensureDir(lockParent);
-        await assertExistingPathChainHasNoSymlinks(target.coordinationRoot, lockParent);
-        targetLease = await acquireProcessLock({
-            lockPath: target.lockPath,
-            fileSystem: processLockFileSystemForTests,
-        });
-    }
-    catch (error) {
-        try {
-            if (lifecycleLease)
-                await releaseActiveMarketplaceCoordinationLease(lifecycleLease);
-        }
-        catch (releaseError) {
-            emitLifecycleReleaseWarning('Lifecycle target lock acquisition failed, and lifecycle lease release also failed', releaseError);
-        }
-        throw error;
-    }
-    let targetReleased = false;
-    let lifecycleReleased = false;
-    return {
-        lockPath: targetLease.lockPath,
-        owner: targetLease.owner,
-        release: async () => {
-            if (!targetReleased) {
-                await targetLease.release();
-                targetReleased = true;
-            }
-            if (lifecycleLease && !lifecycleReleased) {
-                await lifecycleLease.release();
-                lifecycleReleased = true;
-            }
-        },
-    };
-}
-export async function acquireLifecycleOperationLock(options) {
-    const target = await resolveLifecycleActiveTarget(options);
-    const lockParent = path.dirname(target.operationLockPath);
-    await assertExistingPathChainHasNoSymlinks(target.coordinationRoot, lockParent);
-    await fs.ensureDir(lockParent);
-    await assertExistingPathChainHasNoSymlinks(target.coordinationRoot, lockParent);
-    return acquireProcessLock({
-        lockPath: target.operationLockPath,
-        fileSystem: processLockFileSystemForTests,
-    });
-}
 async function assertNoSymlinks(rootPath) {
     const rootStat = await fs.lstat(rootPath);
     if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
@@ -692,7 +624,7 @@ async function validateSnapshotRoot(snapshotRoot, target, loadPlugin) {
     const metadata = parseMetadata(rawMetadata, target);
     const [manifestDigest, bundleFingerprint] = await Promise.all([
         calculateFileDigest(resolvedManifestPath),
-        calculatePluginBundleFingerprintV2(resolvedBundleRoot),
+        calculatePluginBundleFingerprint(resolvedBundleRoot),
     ]);
     if (manifestDigest !== metadata.sourceManifestDigest) {
         fail('Lifecycle active manifest digest does not match metadata.');
@@ -830,47 +762,16 @@ async function cleanupTransientState(target, loadPlugin) {
     await recoverTransientBackup(target, loadPlugin);
     await cleanupOrphanStages(target);
 }
-function attachPreparedLock(prepared, lock, loadPlugin) {
-    preparedContexts.set(prepared, { lock, loadPlugin });
+function attachPreparedLoader(prepared, loadPlugin) {
+    preparedLoaders.set(prepared, loadPlugin);
     return prepared;
 }
-function requirePreparedContext(prepared) {
-    const context = preparedContexts.get(prepared);
-    if (!context) {
-        fail('Lifecycle active prepared snapshot no longer owns its target lock.');
-    }
-    return context;
-}
-function isRetryableReleaseError(error) {
-    return new Set(['EACCES', 'EBUSY', 'EINTR', 'EIO', 'ENOTEMPTY', 'EPERM']).has(error.code ?? '');
-}
-function isPostCommitReleaseWarning(error) {
-    const code = error.code ?? '';
-    return code === 'EBUSY' || code === 'EPERM';
-}
-async function releaseLeaseWithRetry(lock) {
-    let lastError;
-    for (let attempt = 0; attempt < 3; attempt += 1) {
-        try {
-            await lock.release();
-            return;
-        }
-        catch (error) {
-            lastError = error;
-            if (!isRetryableReleaseError(error))
-                throw error;
-        }
-    }
-    await lock.release().catch(() => undefined);
-    throw lastError;
-}
-function emitLifecycleReleaseWarning(message, _releaseError) {
-    try {
-        process.emitWarning(`${message}.`, { code: 'AW_LIFECYCLE_LOCK_RELEASE_FAILED' });
-    }
-    catch {
-        // Diagnostics cannot replace the primary lifecycle error.
+function requirePreparedLoader(prepared) {
+    const loadPlugin = preparedLoaders.get(prepared);
+    if (!loadPlugin) {
+        fail('Lifecycle active prepared snapshot is no longer valid.');
     }
+    return loadPlugin;
 }
 function emitLifecycleHousekeepingWarning() {
     try {
@@ -893,7 +794,6 @@ export async function prepareLifecycleActiveSnapshot(options) {
         cwd: options.cwd,
         env,
     });
-    const lock = await acquireTargetLock(target, options.lifecycleLeaseHeld);
     let stageRoot = null;
     try {
         await cleanupTransientState(target, options.loadPlugin);
@@ -921,15 +821,15 @@ export async function prepareLifecycleActiveSnapshot(options) {
             await fs.remove(stageRoot);
             stageRoot = null;
             await pruneEmptyStagingRoot(target.stagingRoot);
-            return attachPreparedLock({
+            return attachPreparedLoader({
                 status: 'not-required',
                 reason: 'no-uninstall-lifecycle',
                 target,
-            }, lock, options.loadPlugin);
+            }, options.loadPlugin);
         }
         const [sourceManifestDigest, bundleFingerprint] = await Promise.all([
             calculateFileDigest(stagedPlugin.manifestPath),
-            calculatePluginBundleFingerprintV2(bundleRoot),
+            calculatePluginBundleFingerprint(bundleRoot),
         ]);
         const payload = {
             schemaVersion: target.sourceId ? LIFECYCLE_ACTIVE_SCHEMA_VERSION : 1,
@@ -958,19 +858,13 @@ export async function prepareLifecycleActiveSnapshot(options) {
         if (stableStringify(validated.metadata) !== stableStringify(metadata)) {
             fail('Lifecycle active staged metadata changed during validation.');
         }
-        return attachPreparedLock({ status: 'staged', target, stageId, stageRoot, metadata }, lock, options.loadPlugin);
+        return attachPreparedLoader({ status: 'staged', target, stageId, stageRoot, metadata }, options.loadPlugin);
     }
     catch (error) {
         if (stageRoot) {
             await fs.remove(stageRoot).catch(() => undefined);
             await pruneEmptyStagingRoot(target.stagingRoot).catch(() => undefined);
         }
-        try {
-            await releaseLeaseWithRetry(lock);
-        }
-        catch (releaseError) {
-            emitLifecycleReleaseWarning('Lifecycle active prepare failed, and its target lock could not be released', releaseError);
-        }
         throw error;
     }
 }
@@ -998,7 +892,7 @@ async function restoreBackupAfterFailedPromote(options) {
     }
 }
 export async function promoteLifecycleActiveSnapshot(prepared) {
-    const { lock, loadPlugin } = requirePreparedContext(prepared);
+    const loadPlugin = requirePreparedLoader(prepared);
     let backupPath = null;
     let installedNewActive = false;
     let durableCommit = false;
@@ -1008,7 +902,6 @@ export async function promoteLifecycleActiveSnapshot(prepared) {
         if (prepared.status === 'not-required') {
             await removeLifecycleSnapshotDataLocked(prepared.target);
             durableCommit = true;
-            markActiveMarketplaceDurableCommit();
             return null;
         }
         const expectedStageRoot = path.join(prepared.target.stagingRoot, prepared.stageId);
@@ -1032,7 +925,6 @@ export async function promoteLifecycleActiveSnapshot(prepared) {
             fail('Lifecycle active promoted generation changed during promotion.');
         }
         durableCommit = true;
-        markActiveMarketplaceDurableCommit();
         if (backupPath) {
             try {
                 await fs.remove(backupPath);
@@ -1067,36 +959,18 @@ export async function promoteLifecycleActiveSnapshot(prepared) {
         throw error;
     }
     finally {
-        try {
-            await releaseLeaseWithRetry(lock);
-        }
-        catch (releaseError) {
-            if (primaryError !== undefined) {
-                emitLifecycleReleaseWarning('Lifecycle active promote failed, and its target lock could not be released', releaseError);
-            }
-            else if (durableCommit && isPostCommitReleaseWarning(releaseError)) {
-                emitLifecycleReleaseWarning('Lifecycle active promote committed, but its target lock could not be released', releaseError);
-            }
-            else {
-                throw releaseError;
-            }
-        }
-        finally {
-            finalizedPrepared.add(prepared);
-            preparedContexts.delete(prepared);
-        }
+        finalizedPrepared.add(prepared);
+        preparedLoaders.delete(prepared);
     }
 }
 export async function discardLifecycleActiveSnapshot(prepared) {
-    const context = preparedContexts.get(prepared);
-    if (!context && finalizedPrepared.has(prepared)) {
+    const loadPlugin = preparedLoaders.get(prepared);
+    if (!loadPlugin && finalizedPrepared.has(prepared)) {
         return;
     }
-    if (!context) {
-        fail('Lifecycle active prepared snapshot no longer owns its target lock.');
+    if (!loadPlugin) {
+        fail('Lifecycle active prepared snapshot is no longer valid.');
     }
-    const { lock } = context;
-    let primaryError;
     try {
         if (prepared.status === 'staged') {
             const expectedStageRoot = path.join(prepared.target.stagingRoot, prepared.stageId);
@@ -1108,23 +982,9 @@ export async function discardLifecycleActiveSnapshot(prepared) {
             await pruneEmptyStagingRoot(prepared.target.stagingRoot);
         }
     }
-    catch (error) {
-        primaryError = error;
-        throw error;
-    }
     finally {
-        try {
-            await releaseLeaseWithRetry(lock);
-        }
-        catch (releaseError) {
-            if (primaryError !== undefined) {
-                emitLifecycleReleaseWarning('Lifecycle active discard failed, and its target lock could not be released', releaseError);
-                throw primaryError;
-            }
-            throw releaseError;
-        }
         finalizedPrepared.add(prepared);
-        preparedContexts.delete(prepared);
+        preparedLoaders.delete(prepared);
     }
 }
 async function readLifecycleActiveSnapshotUnlocked(options) {
@@ -1144,56 +1004,11 @@ async function readLifecycleActiveSnapshotUnlocked(options) {
     }
 }
 export async function readLifecycleActiveSnapshot(options) {
-    return withActiveMarketplaceLifecycleLease(options.env, () => readLifecycleActiveSnapshotUnlocked(options));
+    return readLifecycleActiveSnapshotUnlocked(options);
 }
-// Catalog reference inventory can run while the runtime coordination lease is held.
-// Active publication also needs that lease, so inventory must not acquire lifecycle after runtime.
 export async function inspectLifecycleActiveSnapshotForInventory(options) {
     return readLifecycleActiveSnapshotUnlocked(options);
 }
-export async function leaseLifecycleActiveSnapshot(options) {
-    const target = await resolveLifecycleActiveTarget(options);
-    const lock = await acquireTargetLock(target, options.lifecycleLeaseHeld);
-    let snapshot;
-    try {
-        await assertExistingPathChainHasNoSymlinks(target.awHome, target.activeRoot);
-        if (!await lstatIfExists(target.activeRoot)) {
-            snapshot = null;
-        }
-        else {
-            snapshot = createReadSnapshot(target, await validateSnapshotRoot(target.activeRoot, target, options.loadPlugin));
-        }
-    }
-    catch (error) {
-        const primaryError = error instanceof LifecycleActiveSnapshotError
-            ? error
-            : new LifecycleActiveSnapshotError('Lifecycle active snapshot is corrupt.', { cause: error });
-        try {
-            await releaseLeaseWithRetry(lock);
-        }
-        catch (releaseError) {
-            emitLifecycleReleaseWarning('Lifecycle active read failed, and its target lock could not be released', releaseError);
-        }
-        throw primaryError;
-    }
-    if (!snapshot) {
-        await releaseLeaseWithRetry(lock);
-        return null;
-    }
-    readContexts.set(snapshot, lock);
-    return snapshot;
-}
-export async function releaseLifecycleActiveSnapshot(snapshot) {
-    const lock = readContexts.get(snapshot);
-    if (!lock && releasedReads.has(snapshot))
-        return;
-    if (!lock) {
-        fail('Lifecycle active read snapshot no longer owns its target lock.');
-    }
-    await releaseLeaseWithRetry(lock);
-    readContexts.delete(snapshot);
-    releasedReads.add(snapshot);
-}
 export function restoreLifecycleActiveScriptInputs(snapshot) {
     return { currentPlugin: snapshot.plugin, artifacts: snapshot.artifacts };
 }
@@ -1231,46 +1046,19 @@ async function removeTransientBackupsLocked(target) {
 }
 export async function removeLifecycleActiveSnapshot(options) {
     const target = await resolveLifecycleActiveTarget(options);
-    const lock = await acquireTargetLock(target, options.lifecycleLeaseHeld);
-    let durableCommit = false;
-    let primaryError;
-    try {
-        if (options.expectedMetadataIntegrityDigest !== undefined) {
-            await assertExistingDirectoryBoundary(target, target.activeRoot, 'activeRoot');
-            const metadata = await fs.readJson(path.join(target.activeRoot, LIFECYCLE_ACTIVE_METADATA_FILE));
-            if (metadata === null
-                || typeof metadata !== 'object'
-                || Array.isArray(metadata)
-                || metadata.metadataIntegrityDigest
-                    !== options.expectedMetadataIntegrityDigest) {
-                fail('stateInventoryFailed: lifecycle active generation changed before removal.');
-            }
-        }
-        await cleanupOrphanStages(target);
-        await removeTransientBackupsLocked(target);
-        await removeLifecycleSnapshotDataLocked(target);
-        durableCommit = true;
-        markActiveMarketplaceDurableCommit();
-    }
-    catch (error) {
-        primaryError = error;
-        throw error;
-    }
-    finally {
-        try {
-            await releaseLeaseWithRetry(lock);
-        }
-        catch (releaseError) {
-            if (primaryError !== undefined) {
-                emitLifecycleReleaseWarning('Lifecycle active remove failed, and its target lock could not be released', releaseError);
-            }
-            else if (durableCommit && isPostCommitReleaseWarning(releaseError)) {
-                emitLifecycleReleaseWarning('Lifecycle active remove committed, but its target lock could not be released', releaseError);
-            }
-            else {
-                throw releaseError;
-            }
+    if (options.expectedMetadataIntegrityDigest !== undefined) {
+        await assertExistingDirectoryBoundary(target, target.activeRoot, 'activeRoot');
+        const metadata = await fs.readJson(path.join(target.activeRoot, LIFECYCLE_ACTIVE_METADATA_FILE));
+        if (metadata === null
+            || typeof metadata !== 'object'
+            || Array.isArray(metadata)
+            || metadata.metadataIntegrityDigest
+                !== options.expectedMetadataIntegrityDigest) {
+            fail('stateInventoryFailed: lifecycle active generation changed before removal.');
         }
     }
+    await cleanupOrphanStages(target);
+    await removeTransientBackupsLocked(target);
+    await removeLifecycleSnapshotDataLocked(target);
 }
 //# sourceMappingURL=lifecycle-active-store.js.map