@lesliechan721/aw 0.1.0-beta.4 → 0.1.0-beta.6

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

@@ -1536,11 +1536,13 @@ async function inspectCodexNativeResidue(options) {
     const labels = [];
     const foreignLabels = [];
     const versions = new Set();
+    const installedVersions = new Set();
+    const cacheVersions = new Set();
     const configEntry = config.snapshot.plugins[pluginId];
     if (configEntry) {
         (canonicalMarketplace ? labels : foreignLabels).push(`${configPath}#plugins.${pluginId}`);
     }
-    const inspectManifest = async (manifestPath, directoryVersion) => {
+    const inspectManifest = async (manifestPath, kind, directoryVersion) => {
         const stats = await lstatCodexResidueIfPresent(manifestPath);
         if (!stats)
             return;
@@ -1560,6 +1562,7 @@ async function inspectCodexNativeResidue(options) {
         }
         labels.push(manifestPath);
         versions.add(version);
+        (kind === 'installed' ? installedVersions : cacheVersions).add(version);
     };
     for (const entry of await readdirCodexResidueIfPresent(cacheRoot)) {
         if (!entry.isDirectory() || entry.isSymbolicLink()) {
@@ -1579,23 +1582,31 @@ async function inspectCodexNativeResidue(options) {
         if (existing.length === 0)
             foreignLabels.push(versionRoot);
         for (const candidate of existing)
-            await inspectManifest(candidate, entry.name);
+            await inspectManifest(candidate, 'cache', entry.name);
     }
     const installedStats = await lstatCodexResidueIfPresent(installedRoot);
     if (installedStats && (!installedStats.isDirectory() || installedStats.isSymbolicLink())) {
         foreignLabels.push(installedRoot);
     }
     else if (installedStats) {
-        await inspectManifest(installedManifest);
+        await inspectManifest(installedManifest, 'installed');
     }
     return foreignLabels.length > 0
         ? {
             state: 'foreign', labels: [...labels, ...foreignLabels], versions: [...versions],
+            installedVersions: [...installedVersions], cacheVersions: [...cacheVersions],
             enabled: configEntry?.enabled === true,
         }
         : labels.length > 0
-            ? { state: 'present', labels, versions: [...versions], enabled: configEntry?.enabled === true }
-            : { state: 'absent', labels: [], versions: [], enabled: false };
+            ? {
+                state: 'present', labels, versions: [...versions],
+                installedVersions: [...installedVersions], cacheVersions: [...cacheVersions],
+                enabled: configEntry?.enabled === true,
+            }
+            : {
+                state: 'absent', labels: [], versions: [],
+                installedVersions: [], cacheVersions: [], enabled: false,
+            };
 }
 export async function discoverCodexNativeResidueNames(options) {
     const marketplaceName = options.marketplaceName ?? MARKETPLACE_NAME;
@@ -2259,41 +2270,6 @@ function createClaudeMarketplaceComponent(options) {
         },
     };
 }
-function createNativeVersionComponent(options) {
-    return {
-        kind: 'shared-config',
-        identity: ownerIdentity(options.pluginName, internalArtifactKey('native-version', options.pluginVersion), options.platform, options.scope),
-        label: `${options.pluginName}@${options.marketplaceName ?? MARKETPLACE_NAME}#version=${options.pluginVersion}`,
-        inspect: async () => {
-            let versions;
-            if (options.platform === 'codex') {
-                const residue = await inspectCodexNativeResidue({
-                    pluginName: options.pluginName,
-                    cwd: options.cwd,
-                    env: options.env,
-                    marketplaceName: options.marketplaceName,
-                    marketplaceRoot: options.marketplaceRoot,
-                });
-                versions = residue.enabled && residue.state === 'present' ? residue.versions : [];
-            }
-            else {
-                const state = await readClaudeNativeState({
-                    pluginName: options.pluginName,
-                    scope: options.scope,
-                    cwd: options.cwd,
-                    env: options.env,
-                    marketplaceName: options.marketplaceName,
-                    marketplaceRoot: options.marketplaceRoot,
-                });
-                versions = state.pluginEnabled && state.pluginState === 'present'
-                    ? state.pluginVersions
-                    : [];
-            }
-            return versions.includes(options.pluginVersion) ? 'present' : 'absent';
-        },
-        remove: async () => undefined,
-    };
-}
 async function mirrorCatalog(catalog, env, target) {
     if (!target?.sourceId || !target.marketplaceRoot) {
         const rootDir = resolveAwHome(env);
@@ -2996,24 +2972,10 @@ export function createRebuildIntegration(options) {
                             desired: marketplaceDesired,
                         })]
                     : [];
-            const nativeVersion = nativeRequired
-                && input.command !== 'cleanup'
-                && input.command !== 'uninstall'
-                ? [createNativeVersionComponent({
-                        pluginName: input.plugin.manifest.name,
-                        pluginVersion: input.plugin.manifest.version,
-                        platform: input.platform,
-                        scope: input.scope,
-                        cwd: input.cwd,
-                        env: options.context.env,
-                        marketplaceName: input.marketplaceName,
-                        marketplaceRoot: input.marketplaceRoot,
-                    })]
-                : [];
             if (nativeRequired
                 && input.command !== 'cleanup'
                 && input.command !== 'uninstall')
-                desiredComponents.push(...nativePlugin, ...marketplace, ...nativeVersion);
+                desiredComponents.push(...nativePlugin, ...marketplace);
             const allComponents = dedupeComponents([
                 ...desiredComponents,
                 ...optionalComponents,
@@ -3024,7 +2986,6 @@ export function createRebuildIntegration(options) {
                 ...(input.platform === 'claude' ? sharedComponents : []),
                 ...nativePlugin,
                 ...marketplace,
-                ...nativeVersion,
             ]);
             bindNamespacedOwnerIdentity(allComponents, input);
             const desiredKeys = new Set(desiredComponents.map(componentIdentityKey));
@@ -3087,7 +3048,44 @@ export async function inspectRebuildTarget(options) {
         nativeProbe: integration.driver.probeNativeHealth ?? integration.driver.probeNative,
         verifyHealth: true,
     });
-    return { target, inspection };
+    if (!target.requiresNative)
+        return { target, inspection };
+    if (target.identity.platform === 'codex') {
+        const residue = await inspectCodexNativeResidue({
+            pluginName: target.identity.pluginName,
+            cwd: target.identity.cwd,
+            env: options.context.env,
+            marketplaceName: target.identity.marketplaceName,
+            marketplaceRoot: target.identity.marketplaceRoot,
+        });
+        if (residue.state !== 'present' || !residue.enabled)
+            return { target, inspection };
+        const installed = [...new Set(residue.installedVersions)];
+        if (installed.length > 0) {
+            return installed.length === 1
+                ? { target, inspection, installedVersion: installed[0] }
+                : { target, inspection };
+        }
+        const cached = [...new Set(residue.cacheVersions)];
+        return cached.length === 1
+            ? { target, inspection, installedVersion: cached[0] }
+            : { target, inspection };
+    }
+    const native = await readClaudeNativeState({
+        pluginName: target.identity.pluginName,
+        scope: target.identity.scope,
+        cwd: target.identity.cwd,
+        env: options.context.env,
+        marketplaceName: target.identity.marketplaceName,
+        marketplaceRoot: target.identity.marketplaceRoot,
+    });
+    const versions = [...new Set(native.pluginVersions)];
+    return native.marketplaceState === 'canonical'
+        && native.pluginState === 'present'
+        && native.pluginEnabled
+        && versions.length === 1
+        ? { target, inspection, installedVersion: versions[0] }
+        : { target, inspection };
 }
 async function discoverOwnerNamesInTextRoot(root, platform, scope) {
     if (!await fs.pathExists(root))