@lesliechan721/aw 0.1.0-beta.56 → 0.1.0-beta.58

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

@@ -16,6 +16,7 @@ import { analyzeCodexSurface } from '../utils/codex-surface-analysis.js';
 import { buildGeneratedName } from '../generators/shared.js';
 import { createCodexReconcilePlan, } from '../utils/codex-reconciler.js';
 import { readCodexConfigFile } from '../utils/codex-config.js';
+import { isCanonicalCodexMarketplaceRegistration } from '../utils/codex-shared-native.js';
 import { executeRebuildComponentCleanup, executeRebuildOperation, prepareRebuildOperation, } from './rebuild-operations.js';
 import { assertNoClaudeUnboundNativeNameCollision, CodexActivationPostcheckError, createRebuildIntegration, executeCodexReconcileActivations, inspectCodexPluginRegistrationLive, inspectCodexSharedNativeLive, hasPreparedStaticNativeCommandDrift, inspectNativeMarketplaceRegistrations, removeCodexPluginActivation, removeNamespacedMarketplacePluginProjection, postcheckCodexReconcileActivations, } from './rebuild-integration.js';
 import { assertSafeNamespacedMarketplacePluginRoot, getNamespacedMarketplaceName, readStrictNamespacedMarketplaceRoot, } from '../utils/local-marketplace.js';
@@ -3413,6 +3414,7 @@ async function runRebuildCommandInSession(options) {
                 const executionContext = {
                     env: runtimeEnv,
                     nativeCliRunner: options.runtime?.nativeCliRunner ?? getDefaultNativeCliRunner(),
+                    codexManager: options.runtime?.codexManager,
                     reporter: options.runtime?.reporter ?? createNoopReporter(),
                     debugLogger: options.runtime?.debugLogger ?? createNoopDebugLogger(),
                     expectedCatalogConfigDigest: catalog.configDigest,
@@ -4548,7 +4550,7 @@ async function runRebuildCommandInSession(options) {
                     const previewActivationOnly = !previewNeedsNativeMaterialization
                         && provisionalCodexPlans.some((plan) => plan.postcheck.support === 'observed'
                             && plan.postcheck.plugins.length > 0);
-                    const previewActivationScope = provisionalCodexPlans.some((plan) => plan.requirement.requiresProjectPluginContract) ? 'project' : 'user';
+                    const previewActivationScope = provisionalCodexPlans.some((plan) => plan.requirement.scope === 'project') ? 'project' : 'user';
                     const previewConsumer = previewActivationOnly
                         ? await (options.runtime?.codexOperationConsumerResolver ?? resolveCodexOperationConsumer)({
                             cwd: options.commandOptions.cwd,
@@ -4915,6 +4917,71 @@ async function runRebuildCommandInSession(options) {
                     && lockedCodexPlans.some((plan) => plan.review.requiresConfirmation)) {
                     throw namespacedPreflightError('sharedNativeImpactAuthorizationRequired: Replacing or force-reinstalling shared Codex native state requires --yes.', preflightTargets);
                 }
+                if (!executionContext.codexManager) {
+                    const removalTargets = [];
+                    for (const [key, prepared] of lockedPreparation.preparedTargets) {
+                        const target = prepared.target;
+                        if (target.identity.platform !== 'codex'
+                            || target.writeNativeRequired
+                            || operationPreparationFailures.has(key))
+                            continue;
+                        const nativeComponents = target.ownedComponents.filter((component) => component.kind === 'native-plugin'
+                            || (component.kind === 'shared-config' && component.locator.kind === 'codex-marketplace'));
+                        if (nativeComponents.length === 0)
+                            continue;
+                        const inspected = await inspectOwnedComponents({
+                            components: nativeComponents,
+                            executor: lockedPreparation.integration.driver.ownership,
+                            nativeProbe: lockedPreparation.integration.driver.probeNative,
+                        });
+                        let requiresManager = inspected.components.some((component) => component.state === 'present'
+                            || (component.state === 'partial' && component.component.kind !== 'native-plugin'));
+                        if (!requiresManager && inspected.components.some((component) => component.component.kind === 'native-plugin'
+                            && (component.state === 'partial' || component.state === 'error'))) {
+                            try {
+                                const config = await readCodexConfigFile(resolveCodexPaths(target.identity.cwd, 'user', runtimeEnv).configTomlPath);
+                                requiresManager = Boolean(target.identity.marketplaceName && target.identity.marketplaceRoot
+                                    && isCanonicalCodexMarketplaceRegistration(config.snapshot.marketplaces[target.identity.marketplaceName], target.identity.marketplaceRoot));
+                            }
+                            catch (error) {
+                                const message = error instanceof Error ? error.message : String(error);
+                                operationPreparationFailures.set(key, failedResult(options.command, target.identity, message));
+                                continue;
+                            }
+                        }
+                        if (requiresManager) {
+                            removalTargets.push({ key, target });
+                        }
+                    }
+                    if (removalTargets.length > 0) {
+                        try {
+                            const managerOptions = {
+                                cwd: options.commandOptions.cwd,
+                                env: runtimeEnv,
+                                runner: executionContext.nativeCliRunner,
+                                authorizer: options.runtime?.managedCodexAuthorizer,
+                                operationRequirement: getCodexOperationRequirement(options.commandOptions.scope),
+                            };
+                            if (options.runtime?.codexManagerResolver) {
+                                executionContext.codexManager = await options.runtime.codexManagerResolver(managerOptions);
+                            }
+                            else {
+                                const consumer = await (options.runtime?.codexOperationConsumerResolver ?? resolveCodexOperationConsumer)({ ...managerOptions, requiresNativeMaterialization: true });
+                                if (consumer.support !== 'observed') {
+                                    throw new Error('Codex native removal requires an observed CLI consumer.');
+                                }
+                                executionContext.codexManager = consumer.manager;
+                            }
+                            executionContext.codexObservationSession?.setManager(executionContext.codexManager);
+                        }
+                        catch (error) {
+                            const message = error instanceof Error ? error.message : String(error);
+                            for (const { key, target } of removalTargets) {
+                                operationPreparationFailures.set(key, failedResult(options.command, target.identity, message));
+                            }
+                        }
+                    }
+                }
                 if (options.runtime?.awHomeMutationToken) {
                     if (lifecycleCommand) {
                         const preparedKeys = new Set(operationPreparations.keys());
@@ -5164,7 +5231,8 @@ async function runRebuildCommandInSession(options) {
                         && plannedNativeAction !== undefined
                         && (plannedNativeAction.action === 'reuse'
                             || plannedNativeAction.action === 'none')
-                        && !hasCodexExtensionMutation;
+                        && !hasCodexExtensionMutation
+                        && !lockedPreparation.preparedTargets.get(key)?.target.ownedComponents.some((component) => component.kind === 'native-plugin');
                     if (failedDependency || failedConsumer || planned.action === 'block') {
                         const code = failedConsumer
                             ? 'dependencyStillRequired'