@lesliechan721/aw 0.1.0-beta.10

package/dist/src/utils/plugin-config-write.js

@@ -0,0 +1,773 @@
+import { stablePluginConfigStringify } from '@lesliechan721/aw-plugin-core/manifest';
+import { statusCommandV7, statusTargetIntent, } from '../commands/status-v6.js';
+import { syncWriteCommand } from '../commands/write-commands.js';
+import { CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION, } from '../types.js';
+import { getDefaultNativeCliRunner } from './native-cli.js';
+import { assertReadyPluginConfigStore, assertSafePluginConfigSegment, codexNativeRefreshKeys, coercePluginConfigUpdates, patchPluginConfigStore, readPluginConfigStore, readNamespacedPluginConfigStoreIdentity, resetPluginConfigStore, resolveConfigRead, resolveEffectivePluginConfig, resolvePluginConfigStorePath, resolvePluginConfigSchemaAccess, summarizeEffectivePluginConfig, } from './plugin-config.js';
+import { collectSensitivePluginConfigValues, redactPluginScriptOutput, } from './plugin-scripts.js';
+import { resolveClaudeProjectKey, resolveCodexProjectKey } from './paths.js';
+import { withAwHomeMutationLock, } from './aw-home-mutation-lock.js';
+export function buildConfigMutationReceipt(command, receipt) {
+    return {
+        ...receipt,
+        receiptSchemaVersion: CONFIG_MUTATION_RECEIPT_SCHEMA_VERSION,
+        command,
+    };
+}
+function uniqueInOrder(values) {
+    return [...new Set(values)];
+}
+function collectRemovedConfigKeys(values) {
+    return uniqueInOrder(Object.keys(values));
+}
+function targetKey(target) {
+    return `${target.platform}:${target.scope}:${target.projectKey ?? '-'}`;
+}
+function dedupeTargets(targets) {
+    const deduped = new Map();
+    for (const target of targets)
+        deduped.set(targetKey(target), target);
+    return [...deduped.values()];
+}
+async function resolveProjectKey(platform, cwd) {
+    return platform === 'codex'
+        ? resolveCodexProjectKey(cwd)
+        : resolveClaudeProjectKey(cwd);
+}
+async function createCandidateTarget(options) {
+    return {
+        pluginName: options.pluginName,
+        platform: options.platform,
+        scope: options.scope,
+        ...(options.scope === 'project'
+            ? { projectKey: await resolveProjectKey(options.platform, options.cwd) }
+            : {}),
+    };
+}
+async function discoverVisibleTargets(options) {
+    const targets = [];
+    const failures = [];
+    const selector = options.plugin.pluginId ?? options.pluginName;
+    const status = await statusCommandV7({
+        plugins: [selector],
+        cwd: options.cwd,
+        env: options.env,
+        nativeCliRunner: options.nativeCliRunner,
+        ...(options.scope === 'project' ? { scope: 'project' } : {}),
+        ...(options.rebuildRuntime?.catalogOperationContext
+            ? { catalogOperationContext: options.rebuildRuntime.catalogOperationContext }
+            : {}),
+    });
+    for (const statusTarget of status.payload.targets) {
+        const intent = statusTargetIntent(statusTarget);
+        if ((statusTarget.pluginId !== selector && statusTarget.pluginName !== options.pluginName)
+            || !intent.enabled)
+            continue;
+        for (const scope of intent.scopes) {
+            if (options.scope === 'project' && scope !== 'project')
+                continue;
+            targets.push(await createCandidateTarget({
+                pluginName: options.pluginName,
+                platform: statusTarget.platform,
+                scope,
+                cwd: options.cwd,
+            }));
+        }
+    }
+    return { targets: dedupeTargets(targets), failures };
+}
+async function reinstallVisibleTargets(options) {
+    const nativeCliRunner = options.nativeCliRunner ?? getDefaultNativeCliRunner();
+    const discovered = options.discovered ?? (options.applyTargets === undefined
+        ? await discoverVisibleTargets({
+            pluginName: options.plugin.manifest.name,
+            plugin: options.plugin,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+            nativeCliRunner,
+            rebuildRuntime: options.rebuildRuntime,
+        })
+        : { targets: dedupeTargets(options.applyTargets), failures: [] });
+    const targetResults = [...discovered.failures];
+    let runtimeFailed = discovered.failures.length > 0;
+    const reinstall = options.reinstallCommandImpl ?? syncWriteCommand;
+    if (options.plugin.sourceId && !options.plugin.pluginId) {
+        throw new Error(`Plugin "${options.plugin.manifest.name}" is missing its namespaced plugin ID.`);
+    }
+    const selector = options.plugin.sourceId
+        ? options.plugin.pluginId
+        : options.plugin.manifest.name;
+    const sanitizeFailure = async (message, target) => {
+        let sensitiveValues = [];
+        try {
+            const effective = await resolveEffectivePluginConfig({
+                ...(options.plugin.sourceId ? {
+                    sourceId: options.plugin.sourceId,
+                    sourceIdentity: options.plugin.sourceIdentity,
+                } : {}),
+                pluginName: options.plugin.manifest.name,
+                manifest: options.plugin.manifest,
+                targetScope: target.scope,
+                cwd: options.cwd,
+                env: options.env,
+            });
+            sensitiveValues = collectSensitivePluginConfigValues(options.plugin.manifest, effective.values);
+        }
+        catch {
+            // Generic credential redaction and known config paths still apply.
+        }
+        let sanitized = redactPluginScriptOutput(message, sensitiveValues);
+        for (const scope of ['user', 'project']) {
+            const configPath = resolvePluginConfigStorePath({
+                sourceId: options.plugin.sourceId,
+                pluginName: options.plugin.manifest.name,
+                scope,
+                cwd: options.cwd,
+                env: options.env,
+            });
+            const safeTarget = `${scope}/plugin-config/${[
+                options.plugin.sourceId,
+                options.plugin.manifest.name,
+                'config.json',
+            ].filter(Boolean).join('/')}`;
+            sanitized = sanitized.split(configPath).join(safeTarget);
+        }
+        return sanitized;
+    };
+    const sanitizeProjection = async (value, target, freeText = false) => {
+        if (typeof value === 'string')
+            return freeText ? sanitizeFailure(value, target) : value;
+        if (value === null || typeof value !== 'object')
+            return value;
+        if (Array.isArray(value)) {
+            return Promise.all(value.map((entry) => sanitizeProjection(entry, target, freeText)));
+        }
+        return Object.fromEntries(await Promise.all(Object.entries(value).map(async ([key, entry]) => [
+            key,
+            await sanitizeProjection(entry, target, typeof entry === 'string'
+                ? /^(?:message|error|stack|stdout|stderr|output|warning)$/u.test(key)
+                : Array.isArray(entry) && /^(?:messages|warnings)$/u.test(key)),
+        ])));
+    };
+    for (const target of discovered.targets) {
+        try {
+            const debugLogger = options.rebuildRuntime?.debugLogger;
+            const reporter = options.rebuildRuntime?.reporter;
+            const result = await reinstall([selector], {
+                cwd: options.cwd,
+                platform: target.platform,
+                scope: target.scope,
+            }, {
+                ...options.rebuildRuntime,
+                env: options.env,
+                nativeCliRunner,
+                ...(debugLogger ? {
+                    debugLogger: {
+                        ...debugLogger,
+                        log: async (value) => debugLogger.log(await sanitizeProjection(value, target)),
+                    },
+                } : {}),
+                ...(reporter ? {
+                    reporter: {
+                        event: async (value) => reporter.event(await sanitizeProjection(value, target)),
+                        notice: async (value) => reporter.notice(await sanitizeProjection(value, target)),
+                    },
+                } : {}),
+            });
+            if (result.overallState === 'failed')
+                runtimeFailed = true;
+            targetResults.push(...await Promise.all(result.targetResults.map(async (entry) => ({
+                ...entry,
+                ...(entry.message ? { message: await sanitizeFailure(entry.message, entry.target) } : {}),
+            }))));
+        }
+        catch (error) {
+            runtimeFailed = true;
+            const message = await sanitizeFailure(error instanceof Error ? error.message : String(error), target);
+            targetResults.push({
+                target,
+                action: 'reinstall',
+                state: 'failed',
+                message,
+            });
+        }
+    }
+    const overallState = runtimeFailed || targetResults.some((entry) => entry.state === 'failed')
+        ? 'partial' : 'succeeded';
+    return {
+        overallState,
+        targetResults,
+        ...(discovered.targets.length === 0 && discovered.failures.length === 0
+            ? { applySkippedReason: 'noVisibleTarget' }
+            : {}),
+    };
+}
+async function resolveConfigApplyTargets(options) {
+    if (options.applyTargets !== undefined) {
+        return { targets: dedupeTargets(options.applyTargets), failures: [] };
+    }
+    return discoverVisibleTargets({
+        pluginName: options.plugin.manifest.name,
+        plugin: options.plugin,
+        scope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+        nativeCliRunner: options.nativeCliRunner ?? getDefaultNativeCliRunner(),
+        rebuildRuntime: options.rebuildRuntime,
+    });
+}
+async function configApplyHasIssues(options) {
+    const scopes = [...new Set(options.targets.map((target) => target.scope))];
+    for (const scope of scopes) {
+        if (options.knownValidScopes?.includes(scope))
+            continue;
+        const effective = await resolveEffectivePluginConfig({
+            ...(options.plugin.sourceId ? {
+                sourceId: options.plugin.sourceId,
+                sourceIdentity: options.plugin.sourceIdentity,
+            } : {}),
+            pluginName: options.plugin.manifest.name,
+            manifest: options.plugin.manifest,
+            targetScope: scope,
+            cwd: options.cwd,
+            env: options.env,
+        });
+        if (effective.issues.length > 0)
+            return true;
+    }
+    return false;
+}
+function otherProjectsWarning(scope) {
+    return scope === 'user'
+        ? ['其它项目不会由本次命令扫描或更新。请在每个项目目录中运行对应的 aw reinstall 命令。']
+        : [];
+}
+function buildReceiptFieldEntry(options) {
+    return {
+        key: options.key,
+        title: options.title,
+        kind: options.kind,
+        reserved: options.reserved,
+        action: options.action,
+        scope: options.scope,
+        ...(options.valueState ? { valueState: options.valueState } : {}),
+    };
+}
+export async function replayConfigRuntimeWrites(options) {
+    return withAwHomeMutationLock({
+        env: options.env,
+        token: options.awHomeMutationToken,
+        action: async (awHomeMutationToken) => {
+            const env = options.env ?? process.env;
+            const rebuildRuntime = { ...options.rebuildRuntime, awHomeMutationToken };
+            const discovered = await resolveConfigApplyTargets({
+                plugin: options.plugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env,
+                applyTargets: options.applyTargets,
+                nativeCliRunner: options.nativeCliRunner,
+                rebuildRuntime,
+            });
+            const applied = await configApplyHasIssues({
+                plugin: options.plugin,
+                targets: discovered.targets,
+                cwd: options.cwd,
+                env,
+            }) ? {
+                overallState: 'partial',
+                targetResults: [],
+                applySkippedReason: 'invalidConfig',
+            } : await reinstallVisibleTargets({
+                plugin: options.plugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env,
+                applyTargets: options.applyTargets,
+                nativeCliRunner: options.nativeCliRunner,
+                reinstallCommandImpl: options.reinstallCommandImpl,
+                rebuildRuntime,
+                discovered,
+            });
+            return {
+                configWrite: 'succeeded',
+                overallState: applied.overallState,
+                targetResults: applied.targetResults,
+                ...(applied.applySkippedReason ? { applySkippedReason: applied.applySkippedReason } : {}),
+                otherProjectsRequireReinstall: options.scope === 'user',
+            };
+        },
+    });
+}
+function changedKeysAffectSharedNativeTarget(options) {
+    const changedKeys = new Set(options.changedKeys);
+    return (options.plugin.manifest.artifacts?.targets ?? []).some((target) => target.platform === 'codex'
+        && target.target === 'codex.skill'
+        && target.delivery?.mode === 'codex-native'
+        && target.refreshKeys.some((key) => changedKeys.has(key)));
+}
+async function applyPluginConfigWriteUnlocked(options) {
+    const requestedPluginName = options.pluginName ?? options.plugin?.manifest.name;
+    if (!requestedPluginName)
+        throw new Error('Plugin name is required for config write.');
+    const pluginName = assertSafePluginConfigSegment(requestedPluginName);
+    const configIdentity = options.plugin?.sourceId ? {
+        sourceId: options.plugin.sourceId,
+        sourceIdentity: options.plugin.sourceIdentity,
+    } : {};
+    const requestedUpdates = options.request.updates ?? {};
+    const requestedRemoveKeys = uniqueInOrder(options.request.removeKeys ?? []);
+    const duplicateKeys = requestedRemoveKeys.filter((key) => Object.hasOwn(requestedUpdates, key));
+    if (duplicateKeys.length > 0) {
+        throw new Error(`Config write cannot update and remove the same key: ${duplicateKeys.join(', ')}.`);
+    }
+    const schemaAccess = await resolvePluginConfigSchemaAccess({
+        pluginName,
+        currentPlugin: options.plugin,
+        currentPluginError: options.pluginError,
+        scope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+    });
+    const schemaPlugin = schemaAccess.plugin;
+    const schema = schemaPlugin?.manifest.config?.fields;
+    if (!schema || !schemaPlugin) {
+        throw new Error(`configSchemaUnavailable: Plugin "${pluginName}" does not declare an AW config schema.`);
+    }
+    if (options.scope === 'project') {
+        const userStore = await readPluginConfigStore({
+            ...configIdentity,
+            pluginName,
+            scope: 'user',
+            cwd: options.cwd,
+            env: options.env,
+            schema,
+        });
+        assertReadyPluginConfigStore(userStore);
+    }
+    for (const key of requestedRemoveKeys) {
+        if (!schema[key])
+            throw new Error(`Unknown config key "${key}".`);
+    }
+    if (options.scope === 'project') {
+        const userOnlyKeys = codexNativeRefreshKeys(schemaPlugin.manifest);
+        const rejectedKeys = Object.keys(requestedUpdates).filter((key) => userOnlyKeys.has(key));
+        if (rejectedKeys.length > 0) {
+            const error = new Error(`sharedNativeConfigUserScopeRequired: Codex native Skill refresh keys can only be set in user scope: ${rejectedKeys.join(', ')}.`);
+            error.code = 'sharedNativeConfigUserScopeRequired';
+            throw error;
+        }
+    }
+    const updates = await coercePluginConfigUpdates({ schema, updates: requestedUpdates, cwd: options.cwd });
+    const store = await readPluginConfigStore({
+        ...configIdentity,
+        pluginName,
+        scope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+        schema,
+    });
+    assertReadyPluginConfigStore(store);
+    const warnings = [];
+    const removedKeys = requestedRemoveKeys.filter((key) => Object.hasOwn(store.values, key));
+    const updatedKeys = Object.entries(updates)
+        .filter(([key, value]) => !Object.hasOwn(store.values, key)
+        || stablePluginConfigStringify(store.values[key]) !== stablePluginConfigStringify(value))
+        .map(([key]) => key);
+    const changedKeys = [...updatedKeys, ...removedKeys];
+    let applyTargets = options.applyTargets;
+    const sharedNativeAffected = changedKeysAffectSharedNativeTarget({
+        plugin: schemaPlugin,
+        changedKeys,
+    });
+    if (options.apply !== false
+        && options.scope === 'user'
+        && options.sharedNativeApplyConfirmed === false
+        && sharedNativeAffected) {
+        applyTargets ??= (await discoverVisibleTargets({
+            plugin: schemaPlugin,
+            pluginName,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            nativeCliRunner: options.nativeCliRunner ?? getDefaultNativeCliRunner(),
+            rebuildRuntime: options.rebuildRuntime,
+        })).targets;
+        if (applyTargets.some((target) => target.platform === 'codex')) {
+            const error = new Error('sharedNativeConfigApplyConfirmationRequired: Applying this user config changes a shared Codex native artifact. Re-run with --yes.');
+            error.code = 'sharedNativeConfigApplyConfirmationRequired';
+            throw error;
+        }
+    }
+    if (changedKeys.length > 0) {
+        await patchPluginConfigStore({
+            ...configIdentity,
+            pluginName,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+            updates: Object.fromEntries(updatedKeys.map((key) => [key, updates[key]])),
+            removeKeys: requestedRemoveKeys,
+            schema,
+        });
+    }
+    const effective = summarizeEffectivePluginConfig(await resolveEffectivePluginConfig({
+        ...configIdentity,
+        pluginName,
+        manifest: schemaPlugin.manifest,
+        targetScope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+    }));
+    let applied;
+    if (changedKeys.length === 0) {
+        applied = {
+            overallState: 'succeeded',
+            targetResults: [],
+            applySkippedReason: 'noConfigChange',
+        };
+    }
+    else if (effective.issues.length > 0) {
+        applied = {
+            overallState: 'partial',
+            targetResults: [],
+            applySkippedReason: 'invalidConfig',
+        };
+    }
+    else if (options.apply === false) {
+        applied = {
+            overallState: 'succeeded',
+            targetResults: [],
+            applySkippedReason: 'notRequested',
+        };
+    }
+    else {
+        const discovered = await resolveConfigApplyTargets({
+            plugin: schemaPlugin,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            applyTargets: options.applyTargets,
+            nativeCliRunner: options.nativeCliRunner,
+            rebuildRuntime: options.rebuildRuntime,
+        });
+        applied = await configApplyHasIssues({
+            plugin: schemaPlugin,
+            targets: discovered.targets,
+            cwd: options.cwd,
+            env: options.env,
+            knownValidScopes: [options.scope],
+        }) ? {
+            overallState: 'partial',
+            targetResults: [],
+            applySkippedReason: 'invalidConfig',
+        } : await reinstallVisibleTargets({
+            plugin: schemaPlugin,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            applyTargets,
+            nativeCliRunner: options.nativeCliRunner,
+            reinstallCommandImpl: options.reinstallCommandImpl,
+            rebuildRuntime: options.rebuildRuntime,
+            discovered,
+        });
+    }
+    const otherProjectsRequireReinstall = options.scope === 'user'
+        && changedKeys.length > 0
+        && effective.issues.length === 0
+        && applied.applySkippedReason !== 'invalidConfig';
+    if (otherProjectsRequireReinstall)
+        warnings.push(...otherProjectsWarning(options.scope));
+    return {
+        plugin: pluginName,
+        scope: options.scope,
+        ...(schemaAccess.schema ? { schema: schemaAccess.schema } : {}),
+        updatedKeys,
+        removedKeys,
+        effective,
+        configWrite: 'succeeded',
+        overallState: applied.overallState,
+        targetResults: applied.targetResults,
+        ...(applied.applySkippedReason ? { applySkippedReason: applied.applySkippedReason } : {}),
+        otherProjectsRequireReinstall,
+        warnings,
+    };
+}
+export async function applyPluginConfigWrite(options) {
+    const requestedPluginName = options.pluginName ?? options.plugin?.manifest.name;
+    if (!requestedPluginName)
+        throw new Error('Plugin name is required for config write.');
+    assertSafePluginConfigSegment(requestedPluginName);
+    return withAwHomeMutationLock({
+        env: options.env,
+        token: options.awHomeMutationToken,
+        action: async (awHomeMutationToken) => {
+            await options.reviewPreflight?.();
+            try {
+                return await applyPluginConfigWriteUnlocked({
+                    ...options,
+                    awHomeMutationToken,
+                    rebuildRuntime: { ...options.rebuildRuntime, awHomeMutationToken },
+                });
+            }
+            catch (error) {
+                let sensitiveValues = options.plugin
+                    ? collectSensitivePluginConfigValues(options.plugin.manifest, (options.request.updates ?? {}))
+                    : [];
+                if (options.plugin) {
+                    try {
+                        const effective = await resolveEffectivePluginConfig({
+                            ...(options.plugin.sourceId ? {
+                                sourceId: options.plugin.sourceId,
+                                sourceIdentity: options.plugin.sourceIdentity,
+                            } : {}),
+                            pluginName: options.plugin.manifest.name,
+                            manifest: options.plugin.manifest,
+                            targetScope: options.scope,
+                            cwd: options.cwd,
+                            env: options.env,
+                        });
+                        sensitiveValues = [
+                            ...sensitiveValues,
+                            ...collectSensitivePluginConfigValues(options.plugin.manifest, effective.values),
+                        ];
+                    }
+                    catch {
+                        // Requested sensitive values and generic credential redaction remain available.
+                    }
+                }
+                let message = redactPluginScriptOutput(error instanceof Error ? error.message : String(error), sensitiveValues);
+                for (const scope of ['user', 'project']) {
+                    const configPath = resolvePluginConfigStorePath({
+                        sourceId: options.plugin?.sourceId,
+                        pluginName: requestedPluginName,
+                        scope,
+                        cwd: options.cwd,
+                        env: options.env,
+                    });
+                    message = message.split(configPath).join(`${scope}/plugin-config/${[
+                        options.plugin?.sourceId,
+                        requestedPluginName,
+                        'config.json',
+                    ].filter(Boolean).join('/')}`);
+                }
+                const safeError = new Error(message);
+                const code = error.code;
+                safeError.code = typeof code === 'string' ? code : 'configApplyFailed';
+                throw safeError;
+            }
+        },
+    });
+}
+async function resetPluginConfigWithHelperUnlocked(options) {
+    const pluginName = assertSafePluginConfigSegment(options.pluginName);
+    const schemaAccess = options.plugin ? await resolvePluginConfigSchemaAccess({
+        pluginName,
+        currentPlugin: options.plugin,
+        scope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+    }) : undefined;
+    let configIdentity = options.plugin?.sourceId ? {
+        sourceId: options.plugin.sourceId,
+        sourceIdentity: options.plugin.sourceIdentity,
+    } : options.sourceId ? {
+        sourceId: options.sourceId,
+        sourceIdentity: options.sourceIdentity,
+    } : {};
+    if (options.sourceId && !options.sourceIdentity) {
+        try {
+            const identity = await readNamespacedPluginConfigStoreIdentity({
+                sourceId: options.sourceId,
+                pluginName,
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env,
+            });
+            if (identity)
+                configIdentity = {
+                    sourceId: options.sourceId,
+                    sourceIdentity: identity.sourceIdentity,
+                };
+        }
+        catch {
+            // Reset does not require a readable or valid envelope.
+        }
+    }
+    let removedKeys = [];
+    try {
+        const store = await readPluginConfigStore({
+            ...configIdentity,
+            pluginName,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+        });
+        removedKeys = collectRemovedConfigKeys(store.values);
+    }
+    catch {
+        // Reset is the final recovery boundary and does not require a readable store.
+    }
+    const warnings = [];
+    const reset = await resetPluginConfigStore({
+        ...configIdentity,
+        pluginName,
+        scope: options.scope,
+        cwd: options.cwd,
+        env: options.env,
+    });
+    let applied = {
+        overallState: 'succeeded',
+        targetResults: [],
+        applySkippedReason: reset.deleted ? 'notRequested' : 'noConfigChange',
+    };
+    let effective;
+    if (schemaAccess?.plugin) {
+        if (schemaAccess.plugin.manifest.config?.fields) {
+            try {
+                effective = summarizeEffectivePluginConfig(await resolveEffectivePluginConfig({
+                    ...configIdentity,
+                    pluginName,
+                    manifest: schemaAccess.plugin.manifest,
+                    targetScope: options.scope,
+                    cwd: options.cwd,
+                    env: options.env,
+                }));
+            }
+            catch {
+                if (options.apply !== false) {
+                    applied = {
+                        overallState: 'partial',
+                        targetResults: [],
+                        applySkippedReason: 'invalidConfig',
+                    };
+                }
+            }
+        }
+        if (reset.deleted && effective && effective.issues.length > 0) {
+            applied = {
+                overallState: 'partial',
+                targetResults: [],
+                applySkippedReason: 'invalidConfig',
+            };
+        }
+        else if (reset.deleted && options.apply !== false && applied.applySkippedReason !== 'invalidConfig') {
+            const discovered = await resolveConfigApplyTargets({
+                plugin: schemaAccess.plugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env ?? process.env,
+                applyTargets: options.applyTargets,
+                nativeCliRunner: options.nativeCliRunner,
+                rebuildRuntime: options.rebuildRuntime,
+            });
+            applied = await configApplyHasIssues({
+                plugin: schemaAccess.plugin,
+                targets: discovered.targets,
+                cwd: options.cwd,
+                env: options.env,
+                knownValidScopes: effective ? [options.scope] : undefined,
+            }) ? {
+                overallState: 'partial',
+                targetResults: [],
+                applySkippedReason: 'invalidConfig',
+            } : await reinstallVisibleTargets({
+                plugin: schemaAccess.plugin,
+                scope: options.scope,
+                cwd: options.cwd,
+                env: options.env ?? process.env,
+                applyTargets: options.applyTargets,
+                nativeCliRunner: options.nativeCliRunner,
+                reinstallCommandImpl: options.reinstallCommandImpl,
+                rebuildRuntime: options.rebuildRuntime,
+                discovered,
+            });
+        }
+    }
+    const otherProjectsRequireReinstall = Boolean(schemaAccess?.plugin)
+        && options.scope === 'user'
+        && reset.deleted
+        && (effective?.issues.length ?? 0) === 0
+        && applied.applySkippedReason !== 'invalidConfig';
+    if (otherProjectsRequireReinstall)
+        warnings.push(...otherProjectsWarning(options.scope));
+    return {
+        plugin: pluginName,
+        scope: options.scope,
+        ...(schemaAccess?.schema ? { schema: schemaAccess.schema } : {}),
+        existed: reset.existed,
+        deleted: reset.deleted,
+        resetDisposition: reset.resetDisposition,
+        ...(reset.quarantineBasename ? { quarantineBasename: reset.quarantineBasename } : {}),
+        removedKeys,
+        ...(effective ? { effective } : {}),
+        configWrite: 'succeeded',
+        overallState: applied.overallState,
+        targetResults: applied.targetResults,
+        ...(applied.applySkippedReason ? { applySkippedReason: applied.applySkippedReason } : {}),
+        otherProjectsRequireReinstall,
+        warnings,
+    };
+}
+export async function resetPluginConfigWithHelper(options) {
+    assertSafePluginConfigSegment(options.pluginName);
+    return withAwHomeMutationLock({
+        env: options.env,
+        token: options.awHomeMutationToken,
+        action: async (awHomeMutationToken) => {
+            await options.reviewPreflight?.();
+            return resetPluginConfigWithHelperUnlocked({
+                ...options,
+                awHomeMutationToken,
+                rebuildRuntime: { ...options.rebuildRuntime, awHomeMutationToken },
+            });
+        },
+    });
+}
+export async function describeResetAffectedFields(options) {
+    try {
+        const resolved = await resolveConfigRead({
+            pluginName: options.pluginName,
+            plugin: options.plugin,
+            ...(options.pluginError ? { pluginError: options.pluginError } : {}),
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+        });
+        return resolved.fields.map((field) => buildReceiptFieldEntry({
+            key: field.key,
+            title: field.title,
+            kind: field.kind,
+            reserved: field.reserved,
+            action: 'reset',
+            scope: options.scope,
+            valueState: field.valueState,
+        }));
+    }
+    catch {
+        const store = await readPluginConfigStore({
+            ...(options.plugin?.sourceId ? {
+                sourceId: options.plugin.sourceId,
+                sourceIdentity: options.plugin.sourceIdentity,
+            } : options.sourceId ? {
+                sourceId: options.sourceId,
+                sourceIdentity: options.sourceIdentity,
+            } : {}),
+            pluginName: options.pluginName,
+            scope: options.scope,
+            cwd: options.cwd,
+            env: options.env,
+        });
+        return collectRemovedConfigKeys(store.values).map((key) => buildReceiptFieldEntry({
+            key,
+            title: key,
+            kind: 'manifest',
+            reserved: false,
+            action: 'reset',
+            scope: options.scope,
+        }));
+    }
+}
+//# sourceMappingURL=plugin-config-write.js.map