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

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

@@ -15,14 +15,14 @@ import { OWNED_TEXT_HEADER_PREFIX, createSharedOwnerToken, createSkillOwnerMarke
 import { resolveArtifactRenderConfig, resolveArtifactRendererTarget, runArtifactRenderer, } from '../utils/artifact-renderer.js';
 import { createArtifactConfigDigest, validateArtifactPlan, } from '../utils/artifact-plan.js';
 import { resolveAwDeliveredArtifactRequestBatches } from '../utils/artifact-request.js';
-import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, } from '../utils/manifest.js';
+import { createAwPluginRequirementsReceipt, parseAwPluginRequirementsReceipt, tryParseStrictSemVer, } 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';
 import { findSensitiveTokenPath } from '../utils/sensitive-content.js';
 import { atomicRemoveConfigFile, atomicReplaceConfigFile, withConfigFileMutation, } from '../utils/plugin-config.js';
 import { readCatalogSourcesConfigSnapshot } from '../utils/catalog-sources.js';
-import { getNamespacedMarketplaceName, projectMarketplaceManifestForPlatform, readStrictNamespacedMarketplaceRoot, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
+import { getNamespacedMarketplaceName, MarketplaceRootValidationError, projectMarketplaceManifestForPlatform, readStrictNamespacedMarketplaceRoot, replayNamespacedCodexNativeRenderProjections, replayNamespacedCodexSkillOverlays, } from '../utils/local-marketplace.js';
 import { commitMarketplaceGenerationBackup } from '../utils/orphan-marketplace-cleanup.js';
 import { readClaudeSettings, writeClaudeSettings } from '../adapters/helpers.js';
 import { analyzeCodexSurface } from '../utils/codex-surface-analysis.js';
@@ -1813,6 +1813,8 @@ async function codexPayloadPathSafe(payloadRoot, allowedRoot = payloadRoot) {
     }
     return true;
 }
+class CodexNativeProjectionUnsafeError extends Error {
+}
 async function resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot) {
     const normalizedSeparators = rawSkillsRoot.replace(/\\/gu, '/');
     const relativeRoot = path.posix.normalize(normalizedSeparators.replace(/^\.\//u, ''));
@@ -1822,11 +1824,11 @@ async function resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot) {
         || relativeRoot.startsWith('../')
         || path.posix.isAbsolute(normalizedSeparators)
         || path.win32.isAbsolute(rawSkillsRoot)) {
-        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
+        throw new CodexNativeProjectionUnsafeError('codexNativeSkillsRootInvalid: Codex native Skills root is invalid.');
     }
     const root = path.join(payloadRoot, ...relativeRoot.split('/'));
     if (!await codexReadPathSafe(payloadRoot, root)) {
-        throw new Error('codexNativeSkillsRootInvalid: Codex native Skills root is unsafe.');
+        throw new CodexNativeProjectionUnsafeError('codexNativeSkillsRootInvalid: Codex native Skills root is unsafe.');
     }
     return { relativeRoot, root };
 }
@@ -1842,16 +1844,45 @@ async function readCodexNativeRenderReceiptEvidence(payloadRoot) {
         return { state: 'absent' };
     if (!stats.isFile() || stats.isSymbolicLink())
         return { state: 'unsafe' };
+    let content;
     try {
-        return {
-            state: 'present',
-            receipt: parseCodexNativeRenderReceipt(await fs.readFile(receiptPath, 'utf8')),
-        };
+        content = await fs.readFile(receiptPath, 'utf8');
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    try {
+        return { state: 'present', receipt: parseCodexNativeRenderReceipt(content) };
     }
     catch {
         return { state: 'invalid' };
     }
 }
+function codexNativeRenderEvidenceIssue(reason, diagnostic) {
+    return { state: 'issue', reason, diagnostic };
+}
+async function readCodexNativeProjectionManifest(manifestPath) {
+    let stats;
+    try {
+        stats = await lstatIfPresent(manifestPath);
+    }
+    catch {
+        return { state: 'unreadable' };
+    }
+    if (!stats)
+        return { state: 'missing' };
+    if (!stats.isFile() || stats.isSymbolicLink())
+        return { state: 'unsafe' };
+    try {
+        const value = await fs.readJson(manifestPath);
+        return typeof value === 'object' && value !== null && !Array.isArray(value)
+            ? { state: 'present', value: value }
+            : { state: 'invalid' };
+    }
+    catch (error) {
+        return { state: error instanceof SyntaxError ? 'invalid' : 'unreadable' };
+    }
+}
 async function resolveCodexNativeRenderExpectedEvidence(options) {
     const logicalPluginId = options.plugin.pluginId
         ?? (options.plugin.sourceId ? `${options.plugin.sourceId}/${options.plugin.manifest.name}` : undefined);
@@ -1861,54 +1892,101 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     const marketplace = await readStrictNamespacedMarketplaceRoot({
         trustedMarketplaceRoot: path.join(resolveAwHome(options.env), 'marketplaces'),
         rootDir: options.marketplaceRoot,
-        sourceId: options.plugin.sourceId,
-        marketplaceName: options.marketplaceName,
     });
     if (!marketplace) {
-        throw new Error('Codex native render canonical marketplace generation is missing.');
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
     }
-    if (marketplace.config.sourceIdentity !== options.plugin.sourceIdentity) {
-        return { state: 'foreign' };
+    if (marketplace.config.sourceId !== options.plugin.sourceId
+        || marketplace.config.sourceIdentity !== options.plugin.sourceIdentity
+        || marketplace.config.marketplaceName !== options.marketplaceName) {
+        return codexNativeRenderEvidenceIssue('foreign', 'projectionReceiptIdentityMismatch');
     }
     const payloadRoot = path.join(options.marketplaceRoot, 'plugins', options.plugin.manifest.name);
-    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
-        throw new Error('Codex native render canonical marketplace payload path is unsafe.');
-    }
-    const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
-    if (receiptEvidence.state !== 'present') {
-        throw new Error('Codex native render canonical marketplace receipt is missing or unreadable.');
+    const payloadStats = await lstatIfPresent(payloadRoot);
+    if (!payloadStats) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
     }
-    const receipt = receiptEvidence.receipt;
-    if (receipt.logicalPluginId !== logicalPluginId
-        || receipt.strategy !== 'shared-user'
-        || receipt.sourceIdentity !== marketplace.config.sourceIdentity) {
-        throw new Error('Codex native render canonical marketplace receipt identity is invalid.');
+    if (!payloadStats.isDirectory() || payloadStats.isSymbolicLink()) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
     }
-    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(payloadRoot);
-    if (payloadDigest !== receipt.payloadDigest) {
-        throw new Error('Codex native render canonical marketplace payload does not match its receipt.');
-    }
-    const sourceManifestPath = path.join(payloadRoot, '.agents-plugin', 'plugin.json');
-    const sourceManifestStats = await lstatIfPresent(sourceManifestPath);
-    const sourceManifest = sourceManifestStats?.isFile() && !sourceManifestStats.isSymbolicLink()
-        ? await fs.readJson(sourceManifestPath).catch(() => null)
-        : null;
-    if (sourceManifest?.name !== options.plugin.manifest.name
-        || sourceManifest.version !== receipt.pluginVersion) {
-        throw new Error('Codex native render canonical marketplace plugin identity is invalid.');
+    if (!await codexPayloadPathSafe(payloadRoot, options.marketplaceRoot)) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
     }
     const codexManifestPath = path.join(payloadRoot, '.codex-plugin', 'plugin.json');
-    const codexManifestStats = await lstatIfPresent(codexManifestPath);
-    const codexManifest = codexManifestStats?.isFile() && !codexManifestStats.isSymbolicLink()
-        ? await fs.readJson(codexManifestPath).catch(() => null)
-        : null;
-    if (!codexManifest) {
-        throw new Error('Codex native render canonical marketplace manifest is invalid.');
+    const [sourceManifestEvidence, codexManifestEvidence] = await Promise.all([
+        readCodexNativeProjectionManifest(path.join(payloadRoot, '.agents-plugin', 'plugin.json')),
+        readCodexNativeProjectionManifest(codexManifestPath),
+    ]);
+    if (sourceManifestEvidence.state === 'unsafe'
+        || codexManifestEvidence.state === 'unsafe') {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    if ((sourceManifestEvidence.state === 'present'
+        && sourceManifestEvidence.value.name !== options.plugin.manifest.name)
+        || (codexManifestEvidence.state === 'present'
+            && codexManifestEvidence.value.name !== options.plugin.manifest.name)
+        || (sourceManifestEvidence.state === 'present'
+            && codexManifestEvidence.state === 'present'
+            && sourceManifestEvidence.value.version !== codexManifestEvidence.value.version)) {
+        return codexNativeRenderEvidenceIssue('foreign', 'manifestIdentityMismatch');
+    }
+    if (sourceManifestEvidence.state === 'unreadable'
+        || codexManifestEvidence.state === 'unreadable') {
+        return codexNativeRenderEvidenceIssue('unreadable', 'manifestUnreadable');
+    }
+    if (sourceManifestEvidence.state === 'missing'
+        || codexManifestEvidence.state === 'missing') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestMissing');
+    }
+    if (sourceManifestEvidence.state === 'invalid'
+        || codexManifestEvidence.state === 'invalid') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestUnreadable');
+    }
+    if (sourceManifestEvidence.state !== 'present'
+        || codexManifestEvidence.state !== 'present') {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestUnreadable');
+    }
+    const sourceManifest = sourceManifestEvidence.value;
+    const codexManifest = codexManifestEvidence.value;
+    if (typeof sourceManifest.version !== 'string'
+        || !tryParseStrictSemVer(sourceManifest.version)) {
+        return codexNativeRenderEvidenceIssue('damaged', 'manifestVersionInvalid');
     }
     const rawSkillsRoot = typeof codexManifest.skills === 'string' && codexManifest.skills.trim() !== ''
         ? codexManifest.skills
         : './codex/skills';
     const { relativeRoot: skillsRelativeRoot } = await resolveCodexSkillsRoot(payloadRoot, rawSkillsRoot);
+    const skillsRoot = path.join(payloadRoot, ...skillsRelativeRoot.split('/'));
+    const skillsRootStats = await lstatIfPresent(skillsRoot);
+    if (skillsRootStats && (!skillsRootStats.isDirectory() || skillsRootStats.isSymbolicLink())) {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    const targets = codexNativeRenderTargets(options.plugin);
+    for (const target of targets) {
+        if (await lstatIfPresent(path.join(skillsRoot, target.skillKey, '.agent-workflows-owner.json'))) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+        }
+    }
+    const receiptEvidence = await readCodexNativeRenderReceiptEvidence(payloadRoot);
+    if (receiptEvidence.state === 'absent') {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptMissing');
+    }
+    if (receiptEvidence.state === 'unsafe') {
+        return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+    }
+    if (receiptEvidence.state === 'invalid') {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionReceiptUnreadable');
+    }
+    if (receiptEvidence.state === 'unreadable') {
+        return codexNativeRenderEvidenceIssue('unreadable', 'projectionReceiptUnreadable');
+    }
+    const receipt = receiptEvidence.receipt;
+    if (receipt.logicalPluginId !== logicalPluginId
+        || receipt.strategy !== 'shared-user'
+        || receipt.sourceIdentity !== marketplace.config.sourceIdentity
+        || receipt.pluginVersion !== sourceManifest.version) {
+        return codexNativeRenderEvidenceIssue('foreign', 'projectionReceiptIdentityMismatch');
+    }
     const emptyArtifactDigest = createCodexSkillStagingTreeContentDigest({
         skillKey: 'empty',
         files: {},
@@ -1916,17 +1994,32 @@ async function resolveCodexNativeRenderExpectedEvidence(options) {
     for (const receiptTarget of receipt.targets) {
         const skillRoot = path.join(payloadRoot, ...skillsRelativeRoot.split('/'), receiptTarget.skillKey);
         if (await lstatIfPresent(path.join(skillRoot, '.agent-workflows-owner.json'))) {
-            throw new Error('Codex native render canonical marketplace Skill has an AW owner marker.');
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+        }
+        const skillStats = await lstatIfPresent(skillRoot);
+        if (skillStats && (!skillStats.isDirectory() || skillStats.isSymbolicLink())) {
+            return codexNativeRenderEvidenceIssue('foreign', 'payloadPathUnsafe');
+        }
+        let tree;
+        try {
+            tree = skillStats ? await readDynamicSkillTree(skillRoot, 'codex.skill') : null;
+        }
+        catch (error) {
+            return codexNativeRenderEvidenceIssue(error instanceof Error && typeof error.code !== 'string'
+                ? 'damaged'
+                : 'unreadable', 'projectionPayloadDigestMismatch');
         }
-        const tree = await readDynamicSkillTree(skillRoot, 'codex.skill');
         const artifactDigest = tree
             ? createCodexSkillStagingTreeContentDigest(tree)
             : emptyArtifactDigest;
         if (artifactDigest !== receiptTarget.artifactDigest) {
-            throw new Error('Codex native render canonical marketplace Skill does not match its receipt.');
+            return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
         }
     }
-    const targets = codexNativeRenderTargets(options.plugin);
+    const payloadDigest = await calculateCodexNativeRenderPayloadDigest(payloadRoot);
+    if (payloadDigest !== receipt.payloadDigest) {
+        return codexNativeRenderEvidenceIssue('damaged', 'projectionPayloadDigestMismatch');
+    }
     const receiptTargets = new Map(receipt.targets.map((target) => [target.id, target]));
     if (targets.length === 0
         || targets.length !== receipt.targets.length
@@ -2105,7 +2198,7 @@ export async function inspectCodexSharedNativeLive(options) {
     });
     let expectedPayloadDigest = dynamicProjectionExpected ? undefined : options.expectedPayloadDigest;
     let sourceProjection;
-    let expectedMarketplaceForeign = false;
+    let sourceProjectionIssue;
     const installed = pluginList.observation.state === 'observed'
         && pluginList.observation.value === 'installed';
     if (installed && dynamicProjectionExpected && options.nativeRenderPlugin) {
@@ -2116,32 +2209,48 @@ export async function inspectCodexSharedNativeLive(options) {
                 marketplaceName,
                 env: options.env,
             });
-            if (expected.state === 'foreign') {
-                expectedMarketplaceForeign = true;
+            if (expected.state === 'issue') {
+                sourceProjectionIssue = expected;
             }
             else {
                 expectedPayloadDigest = expected.payloadDigest;
                 sourceProjection = expected.sourceProjection;
             }
         }
-        catch {
-            sourceProjection = 'drifted';
+        catch (error) {
+            if (error instanceof MarketplaceRootValidationError) {
+                sourceProjectionIssue = {
+                    reason: error.reason === 'unsafe'
+                        ? 'foreign'
+                        : error.reason === 'invalid' ? 'damaged' : 'unreadable',
+                    diagnostic: error.reason === 'unsafe'
+                        ? 'payloadPathUnsafe'
+                        : 'projectionReceiptUnreadable',
+                };
+            }
+            else {
+                sourceProjectionIssue = {
+                    reason: error instanceof CodexNativeProjectionUnsafeError ? 'foreign' : 'unreadable',
+                    diagnostic: error instanceof CodexNativeProjectionUnsafeError
+                        ? 'payloadPathUnsafe'
+                        : 'projectionReceiptUnreadable',
+                };
+            }
         }
     }
-    const sharedNative = expectedMarketplaceForeign
-        ? { state: 'blocked', reason: 'foreign', diagnostic: 'marketplaceRegistrationForeign' }
-        : inspectCodexSharedNative({
-            pluginName: options.pluginName,
-            pluginId,
-            marketplaceName,
-            canonicalMarketplaceRoot: marketplaceRoot,
-            desiredVersion: options.desiredVersion,
-            expectedPayloadDigest,
-            marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
-            marketplacePathSafe,
-            observation: pluginList.observation,
-            ...(sourceProjection ? { sourceProjection } : {}),
-        });
+    const sharedNative = inspectCodexSharedNative({
+        pluginName: options.pluginName,
+        pluginId,
+        marketplaceName,
+        canonicalMarketplaceRoot: marketplaceRoot,
+        desiredVersion: options.desiredVersion,
+        expectedPayloadDigest,
+        marketplaceRegistration: config.snapshot.marketplaces[marketplaceName],
+        marketplacePathSafe,
+        observation: pluginList.observation,
+        ...(sourceProjection ? { sourceProjection } : {}),
+        ...(sourceProjectionIssue ? { sourceProjectionIssue } : {}),
+    });
     return {
         sharedNative,
         ...(expectedPayloadDigest ? { expectedPayloadDigest } : {}),
@@ -2762,7 +2871,7 @@ async function materializeCodexNativeRender(options) {
         targetSkillKeys: options.prepared.targetSkillKeys,
     };
 }
-async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging) {
+async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStaging, rematerializedCodexNativePluginIds = new Set()) {
     if (!target?.sourceId || !target.marketplaceRoot) {
         const rootDir = resolveAwHome(env);
         await fs.ensureDir(rootDir);
@@ -2826,6 +2935,14 @@ async function mirrorCatalog(catalog, env, target, logicalIdentity, prepareStagi
                 sourceIdentity: target.sourceIdentity,
                 marketplaceName,
             });
+            await replayNamespacedCodexNativeRenderProjections({
+                sourceRoot: destination,
+                stagingRoot: staging,
+                sourceId: target.sourceId,
+                sourceIdentity: target.sourceIdentity,
+                marketplaceName,
+                rematerializedPluginIds: rematerializedCodexNativePluginIds,
+            });
         }
         await prepareStaging?.(staging);
         const backup = `${destination}.backup-${crypto.randomUUID()}`;
@@ -3154,7 +3271,11 @@ function createNativeDriver(options) {
                             });
                         }
                     }
-                } : undefined);
+                } : undefined, new Set(first.identity.platform === 'codex'
+                    ? materializationTargets.flatMap((candidate) => pluginHasCodexNativeSkillSurface(candidate.plugin)
+                        ? [candidate.identity.pluginId ?? `${candidate.identity.sourceId}/${candidate.identity.pluginName}`]
+                        : [])
+                    : []));
                 try {
                     await transaction.commit();
                 }