@lesliechan721/aw 0.1.0-beta.11 → 0.1.0-beta.12

package/dist/src/commands/rebuild-integration.d.ts

@@ -52,6 +52,7 @@ export interface RebuildExecutionContext {
     codexUserActivationDesired?: ReadonlySet<string>;
     codexObservationSession?: CodexNativeObservationSession;
     codexObservationScopeByMarketplace?: ReadonlyMap<string, 'user' | 'both'>;
+    preApplyExecutionCache?: Map<string, Promise<void>>;
 }
 export declare function executeCodexReconcileActivations(options: {
     plans: readonly CodexReconcilePlan[];

package/dist/src/commands/rebuild-integration.js

@@ -6,16 +6,16 @@ import { generateInstructionArtifacts, renderCodexManagedInstructionBlock, } fro
 import { generateCodexPermissionArtifacts, mergeClaudePermissions, } from '../generators/permissions.js';
 import { buildGeneratedName } from '../generators/shared.js';
 import { applyConditionalCodexConfigTransactionFile, applyCodexConfigTransactionFile, composeManagedDeveloperInstructionsBlock, readCodexConfigFile, } from '../utils/codex-config.js';
-import { canonicalizePathThroughExistingAncestor } from '../utils/state-paths.js';
+import { canonicalizePathThroughExistingAncestor, resolveClaudeProjectKey, resolveCodexProjectKey, } from '../utils/state-paths.js';
 import { createCodexSkillExpectedTree, createCodexSkillStagingTreeContentDigest, } from '../utils/codex-skill-staging.js';
-import { createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
+import { AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH, createDynamicSkillExpectedTree, createDynamicSkillTreeContentDigest, readDynamicSkillTree, validateSkillDirectory, writeDynamicSkillTree, } from '../utils/dynamic-skill-tree.js';
 import { parseCodexSharedHooksFile, serializeTrackedHookGroupIdentity, } from '../utils/hooks-contract.js';
 import { buildCodexMarketplaceAddInvocation, buildCodexMarketplaceRemoveInvocation, buildCodexPluginAddInvocation, buildCodexPluginRemoveInvocation, CodexProjectConfigNotEffectiveError, runNativeCliChecked, SYSTEM_CODEX_MANAGER, } from '../utils/native-cli.js';
 import { OWNED_TEXT_HEADER_PREFIX, createSharedOwnerToken, createSkillOwnerMarkerContent, parseSharedOwnerToken, parseOwnedTextHeader, readSkillOwnerMarker, renderOwnedTextFile, inspectOwnedComponents, writeOwnedTextFile, } from '../utils/ownership.js';
 import { resolveArtifactRenderConfig, resolveArtifactRendererTarget, runArtifactRenderer, } from '../utils/artifact-renderer.js';
 import { createArtifactConfigDigest, validateArtifactPlan, } from '../utils/artifact-plan.js';
-import { resolveAwDeliveredArtifactIds } from '../utils/artifact-request.js';
-import { createAwPluginRequirementsReceipt, } from '../utils/manifest.js';
+import { resolveAwDeliveredArtifactRequestBatches } from '../utils/artifact-request.js';
+import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, } from '../utils/manifest.js';
 import { resolvePlatformEntries } from '../utils/platform-entries.js';
 import { resolveAwHome, resolveClaudePaths, resolveCodexPaths, resolveRepoRoot, getCodexHome, } from '../utils/paths.js';
 import { assertNoSensitiveConfigInFiles, collectSensitivePluginConfigValues, runPreApplyScript, } from '../utils/plugin-scripts.js';
@@ -39,6 +39,26 @@ function requirementsReceipt(plugin) {
     const receipt = createAwPluginRequirementsReceipt({ name: plugin.manifest.name, version: plugin.manifest.version }, plugin.manifest.requires?.aw.capabilities ?? []);
     return Buffer.from(`${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
 }
+function withoutVerifiedRequirementsReceipt(plugin, files) {
+    const receipt = files[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    if (!receipt)
+        return { ...files };
+    let actual;
+    let expected;
+    try {
+        actual = parseAwPluginRequirementsReceipt(JSON.parse(receipt.toString('utf8')));
+        expected = parseAwPluginRequirementsReceipt(JSON.parse(requirementsReceipt(plugin).toString('utf8')));
+    }
+    catch {
+        return { ...files };
+    }
+    if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+        return { ...files };
+    }
+    const output = { ...files };
+    delete output[AW_PLUGIN_REQUIREMENTS_RECEIPT_PATH];
+    return output;
+}
 export class CodexActivationPostcheckError extends Error {
     code = 'codexActivationPostcheckFailed';
     codexPluginIds;
@@ -924,25 +944,29 @@ function renderCodexRole(options) {
     ].join('\n');
 }
 async function resolveDynamicArtifacts(options) {
-    const requestedArtifactIds = resolveAwDeliveredArtifactIds({
+    const requestBatches = resolveAwDeliveredArtifactRequestBatches({
         manifest: options.plugin.manifest,
         platform: options.platform,
         scope: options.scope,
     });
-    if (requestedArtifactIds.length === 0) {
+    if (requestBatches.length === 0) {
         return { artifacts: [], sourceDirs: () => [], sensitiveValues: [] };
     }
-    const render = await runArtifactRenderer({
-        event: options.event,
-        plugin: options.plugin,
-        platform: options.platform,
-        scope: options.scope,
-        cwd: options.cwd,
-        commandEnv: options.env,
-        previousArtifacts: [...options.previousArtifacts],
-        requestedArtifactIds,
-        scriptTimeoutMs: options.scriptTimeoutMs,
-    });
+    const previousArtifacts = [...options.previousArtifacts];
+    const renders = [];
+    for (const requestedArtifactIds of requestBatches) {
+        renders.push(await runArtifactRenderer({
+            event: options.event,
+            plugin: options.plugin,
+            platform: options.platform,
+            scope: options.scope,
+            cwd: options.cwd,
+            commandEnv: options.env,
+            previousArtifacts,
+            requestedArtifactIds,
+            scriptTimeoutMs: options.scriptTimeoutMs,
+        }));
+    }
     const config = await resolveArtifactRenderConfig({
         sourceId: options.plugin.sourceId,
         sourceIdentity: options.plugin.sourceIdentity,
@@ -953,19 +977,26 @@ async function resolveDynamicArtifacts(options) {
         cwd: options.cwd,
         env: options.env,
     });
-    const artifacts = validateArtifactPlan({
-        manifest: options.plugin.manifest,
-        plan: render.plan,
-        platform: options.platform,
-        scope: options.scope,
-        requestedArtifactIds: render.context.requestedArtifactIds,
-        renderConfig: config,
-        rendererDigest: render.target.rendererDigest,
-        manifestDigest: render.target.manifestDigest,
-    }).artifacts;
+    const artifacts = [];
+    const sourceDirsByArtifact = new Map();
+    for (const render of renders) {
+        artifacts.push(...validateArtifactPlan({
+            manifest: options.plugin.manifest,
+            plan: render.plan,
+            platform: options.platform,
+            scope: options.scope,
+            requestedArtifactIds: render.context.requestedArtifactIds,
+            renderConfig: config,
+            rendererDigest: render.target.rendererDigest,
+            manifestDigest: render.target.manifestDigest,
+        }).artifacts);
+        for (const source of render.context.artifactSources) {
+            sourceDirsByArtifact.set(`${source.id}\0${source.target}`, source.sourceDirs);
+        }
+    }
     return {
         artifacts,
-        sourceDirs: (artifact) => render.context.artifactSources.find((entry) => entry.id === artifact.id && entry.target === artifact.target)?.sourceDirs ?? [],
+        sourceDirs: (artifact) => sourceDirsByArtifact.get(`${artifact.id}\0${artifact.target}`) ?? [],
         sensitiveValues: collectSensitivePluginConfigValues(options.plugin.manifest, config.values),
     };
 }
@@ -1140,7 +1171,7 @@ async function buildClaudeWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
-        assertNoSensitiveConfigInFiles(tree.files, dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'claude',
@@ -1217,7 +1248,7 @@ async function buildCodexWrites(options) {
             requirementsReceipt: requirementsReceipt(options.plugin),
             sourceRequirementsReceiptPolicy: 'allow',
         });
-        assertNoSensitiveConfigInFiles(tree.files, dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+        assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), dynamic.sensitiveValues, 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
         writes.push(dynamicSkillWrite({
             ...options,
             platform: 'codex',
@@ -1810,7 +1841,7 @@ async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
     if (!stats)
         return { state: 'absent' };
     if (!stats.isFile() || stats.isSymbolicLink())
-        return { state: 'unreadable' };
+        return { state: 'unsafe' };
     try {
         return {
             state: 'present',
@@ -1818,7 +1849,7 @@ async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
         };
     }
     catch {
-        return { state: 'unreadable' };
+        return { state: 'invalid' };
     }
 }
 async function resolveCodexNativeRenderExpectedEvidence(options) {
@@ -1900,7 +1931,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     if (targets.length === 0
         || targets.length !== receipt.targets.length
         || targets.some((target) => receiptTargets.get(target.id)?.skillKey !== target.skillKey)) {
-        return { state: 'present', payloadDigest, sourceProjection: 'drifted' };
+        return { state: 'present', payloadDigest, receipt, sourceProjection: 'drifted' };
     }
     const renderer = await resolveArtifactRendererTarget(options.plugin);
     if (renderer.noOp || !renderer.rendererDigest) {
@@ -1934,7 +1965,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
                     target: 'codex.skill',
                     refreshKeys: target.refreshKeys,
                 },
-                configValues: config.values,
+                renderConfig: config,
                 digestSalt: renderer.rendererDigest,
             }),
             artifactDigest: receiptTargets.get(target.id).artifactDigest,
@@ -1942,6 +1973,7 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     });
     return {
         state: 'present',
+        receipt,
         projection,
         payloadDigest,
         sourceProjection: codexNativeRenderProjectionsEqual(receipt, projection)
@@ -1966,11 +1998,31 @@ async function assertNoSensitiveValuesInCanonicalCodexNativePayload(options) {
         throw new Error('Codex native sensitive scan canonical marketplace path is unsafe.');
     }
     const payloadRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name);
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        throw new Error('Codex native sensitive scan payload path is unsafe.');
+    }
+    const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
+    if (receiptEvidence.state === 'unsafe') {
+        throw new Error('codexNativeRenderReceiptInvalid: Codex native render receipt path is unsafe.');
+    }
+    let verifiedRenderReceipt;
+    if (receiptEvidence.state === 'present') {
+        const expected = await resolveCodexNativeRenderExpectedEvidence({
+            plugin: options.plugin,
+            marketplaceRoot: options.marketplaceRoot,
+            marketplaceName: options.marketplaceName,
+            env: options.env,
+        }).catch(() => undefined);
+        if (expected?.state === 'present' && expected.sourceProjection === 'current') {
+            verifiedRenderReceipt = expected.receipt;
+        }
+    }
     await assertNoSensitiveValuesInCodexNativePayload({
         plugin: options.plugin,
         payloadRoot,
         allowedRoot: options.marketplaceRoot,
         sensitiveValues: options.sensitiveValues,
+        verifiedRenderReceipt,
     });
 }
 function observedCodexNativeState(observation, operation) {
@@ -2522,7 +2574,7 @@ async function assertNoSensitiveValuesInCodexNativePayload(options) {
             const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
             if (!tree)
                 continue;
-            const leakedPath = findSensitiveTokenPath(tree.files, options.sensitiveValues);
+            const leakedPath = findSensitiveTokenPath(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), options.sensitiveValues);
             if (leakedPath) {
                 throw new Error(`codexNativeRenderSensitiveValue: Codex native Skill "${entry.name}" exposes ` +
                     `sensitive config in "${leakedPath}".`);
@@ -2535,10 +2587,22 @@ async function assertNoSensitiveValuesInCodexNativePayload(options) {
         if (!receiptStats.isFile()) {
             throw new Error('Codex native sensitive scan render receipt path is unsafe.');
         }
-        const receiptLeak = findSensitiveTokenPath({ [CODEX_NATIVE_RENDER_RECEIPT_PATH]: await fs.readFile(receiptPath) }, options.sensitiveValues);
-        if (receiptLeak) {
-            throw new Error(`codexNativeRenderSensitiveValue: Codex native render receipt exposes sensitive config in ` +
-                `"${receiptLeak}".`);
+        const receiptContent = await fs.readFile(receiptPath);
+        let actualReceipt;
+        try {
+            actualReceipt = parseCodexNativeRenderReceipt(receiptContent.toString('utf8'));
+        }
+        catch {
+            actualReceipt = undefined;
+        }
+        const verified = options.verifiedRenderReceipt
+            && JSON.stringify(actualReceipt) === JSON.stringify(options.verifiedRenderReceipt);
+        if (!verified) {
+            const receiptLeak = findSensitiveTokenPath({ [CODEX_NATIVE_RENDER_RECEIPT_PATH]: receiptContent }, options.sensitiveValues);
+            if (receiptLeak) {
+                throw new Error(`codexNativeRenderSensitiveValue: Codex native render receipt exposes sensitive config in ` +
+                    `"${receiptLeak}".`);
+            }
         }
     }
 }
@@ -2596,7 +2660,7 @@ async function prepareCodexNativeRender(options) {
                 requirementsReceipt: requirementsReceipt(options.plugin),
                 sourceRequirementsReceiptPolicy: 'allow',
             });
-            assertNoSensitiveConfigInFiles(tree.files, collectSensitivePluginConfigValues(options.plugin.manifest, rendered.context.config.values), 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
+            assertNoSensitiveConfigInFiles(withoutVerifiedRequirementsReceipt(options.plugin, tree.files), collectSensitivePluginConfigValues(options.plugin.manifest, rendered.context.config.values), 'artifactRendererSensitiveConfigExposed: Final dynamic Skill contains sensitive config.');
             const skillKey = artifact.skillKey;
             renderedArtifacts.push({
                 artifact,
@@ -2693,6 +2757,7 @@ async function materializeCodexNativeRender(options) {
     return {
         payloadDigest,
         projection: options.prepared.projection,
+        receipt,
         presentSkillKeys: options.prepared.presentSkillKeys,
         targetSkillKeys: options.prepared.targetSkillKeys,
     };
@@ -3085,6 +3150,7 @@ function createNativeDriver(options) {
                                 payloadRoot: path.join(stagingRoot, 'plugins', candidate.identity.pluginName),
                                 allowedRoot: stagingRoot,
                                 sensitiveValues: await resolveSensitiveUserConfigValues(candidate.plugin, options.context.env),
+                                ...(nativeRender ? { verifiedRenderReceipt: nativeRender.receipt } : {}),
                             });
                         }
                     }
@@ -3478,6 +3544,7 @@ function createNativeDriver(options) {
                 await assertNoSensitiveValuesInCanonicalCodexNativePayload({
                     plugin: target.plugin,
                     marketplaceRoot: target.identity.marketplaceRoot ?? resolveAwHome(options.context.env),
+                    marketplaceName: target.identity.marketplaceName ?? MARKETPLACE_NAME,
                     env: options.context.env,
                     sensitiveValues,
                 });
@@ -3803,7 +3870,7 @@ function createNativeDriver(options) {
             return target.artifacts;
         },
         runPreApply: async (invocation) => {
-            await runPreApplyScript({
+            const run = () => runPreApplyScript({
                 plugin: invocation.plugin,
                 platform: invocation.target.identity.platform,
                 scope: invocation.target.identity.scope,
@@ -3811,6 +3878,36 @@ function createNativeDriver(options) {
                 context: options.context,
                 scriptTimeoutMs: options.scriptTimeoutMs,
             });
+            const cache = options.context.preApplyExecutionCache;
+            if (!cache) {
+                await run();
+                return;
+            }
+            const { identity } = invocation.target;
+            const sourceIdentity = invocation.plugin.sourceIdentity ?? identity.sourceIdentity;
+            const pluginId = invocation.plugin.pluginId ?? identity.pluginId;
+            if (!sourceIdentity || !pluginId) {
+                await run();
+                return;
+            }
+            const projectKey = identity.scope === 'project'
+                ? identity.platform === 'codex'
+                    ? await resolveCodexProjectKey(identity.cwd)
+                    : await resolveClaudeProjectKey(identity.cwd)
+                : '';
+            const key = [
+                sourceIdentity,
+                pluginId,
+                identity.platform,
+                identity.scope,
+                projectKey,
+            ].join('\0');
+            let execution = cache.get(key);
+            if (!execution) {
+                execution = run();
+                cache.set(key, execution);
+            }
+            await execution;
         },
     };
 }