dsh-agent-plugins-market 0.9.2 → 0.11.0

package/lib/packages/market-bundle/src/application/catalog.js

@@ -388,6 +388,14 @@ export class Catalog {
     async addMcpServer(name, server, policy) {
         await this.mcp.addServer(name, server, policy);
     }
+    /**
+     * Remove one user-owned MCP service, its override record, and its OAuth
+     * grant. A server a suite declares is refused: that declaration is
+     * source-owned, so disabling it is the supported operation.
+     */
+    async removeMcpServer(suiteKey, serverKey) {
+        await this.mcp.removeServer(suiteKey, serverKey);
+    }
     /**
      * Read a service without credential literals, or an unsaved template when
      * `create` is true. The two transports have separate owners, so this facade

package/lib/packages/market-bundle/src/index.js

@@ -194,10 +194,7 @@ export async function apply(ctx, config = {
         syncTranslationEnabled: () => {
             catalog.syncTranslationEnabled();
         }
-    }, 
-    // The cached preference above, not a fresh host read: the translation default
-    // follows the language, and this reader is called on every settings read.
-    () => localePreference);
+    });
     // Legacy surface and entry routes share one committed workspace policy.
     const resourceFilters = new ResourceFilterService(dataRoot, process.cwd(), { onFiltersChanged: onChanged });
     const surfaceToggles = new SurfaceToggleService(resourceFilters);
@@ -223,6 +220,9 @@ export async function apply(ctx, config = {
         mcpRemount: (suiteId, serverKey) => runtime.forceMcpRemount(suiteId, serverKey),
         mcpRemountAll: () => runtime.forceMcpRemountAll(),
         mcpServerOwner: serverName => runtime.mcpServerOwner(serverName),
+        // Read per call: the set is rebuilt by every mount pass, so a snapshot here
+        // would report the demand of whichever pass happened to run at apply time.
+        mcpDemandedMounts: () => runtime.demandedMcpMounts(),
         lspStatusSource: runtime.lsp,
         mcpBackend: () => settings.backend(),
         setMcpBackend: backend => settings.setBackend(backend),

package/lib/packages/market-bundle/src/platform/settings-namespace.js

@@ -5,7 +5,6 @@ export class MarketSettingsNamespace {
     dataRoot;
     locale;
     host;
-    localePreference;
     refs;
     watchers = [];
     feedbackDisposer;
@@ -16,18 +15,11 @@ export class MarketSettingsNamespace {
      * switch, or skipped because the host has no tools registry to register on.
      */
     feedbackMountState;
-    constructor(ctx, refs, dataRoot, locale, host, 
-    /**
-     * The host interface language, read per call. It is a reader rather than a
-     * captured string because a language switch must move the translation
-     * default without rebuilding this namespace.
-     */
-    localePreference) {
+    constructor(ctx, refs, dataRoot, locale, host) {
         this.ctx = ctx;
         this.dataRoot = dataRoot;
         this.locale = locale;
         this.host = host;
-        this.localePreference = localePreference;
         // A caller may hand in a partial ref set (a test, or a config written
         // before this field existed); an absent switch reads as its default.
         this.refs = {
@@ -55,10 +47,6 @@ export class MarketSettingsNamespace {
             this.syncFeedbackTool();
         });
         this.watchers.push(watcher);
-        // A locale edit can change the default without changing this plugin's refs.
-        this.watchers.push(this.ctx.on('settings/document-updated', () => {
-            previousTranslation = this.syncTranslationProviders(previousTranslation);
-        }));
     }
     /** Release every watcher and unmount the feedback tool. */
     dispose() {
@@ -69,7 +57,7 @@ export class MarketSettingsNamespace {
     }
     /**
      * The resolved settings, from the volatile references the host updates in
-     * place and the interface language they resolve over.
+     * place. A field whose reference has no value yet takes the contract default.
      */
     settings() {
         return resolveMarketSettings({
@@ -80,7 +68,7 @@ export class MarketSettingsNamespace {
             autoUpdateSources: this.refs.autoUpdateSources.get(),
             translationEnabled: this.refs.translationEnabled.get(),
             agentPresetsEnabled: this.refs.agentPresetsEnabled.get()
-        }, this.localePreference());
+        });
     }
     /** The persisted MCP backend choice; the built-in client until the host applies a value. */
     async backend() {
@@ -100,7 +88,7 @@ export class MarketSettingsNamespace {
     }
     /**
      * Read the live translation switch: the stored preference while the user has
-     * one, the interface language's default otherwise.
+     * one, the plugin default (on) otherwise.
      */
     translationEnabled() {
         return this.settings().translationEnabled;

package/lib/packages/market-bundle/src/platform/settings-schema.js

@@ -6,12 +6,12 @@ import { MARKET_SETTINGS_DEFAULTS } from '../../../market-contracts/src/contract
  * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
  * not own them.
  *
- * `translationEnabled` deliberately declares no default. Its default follows
- * the interface language, and a declared default would be materialized into the
- * live config reference, where "the user never set this" and "the user turned it
- * off" would both read `false` — the distinction the derivation rests on. With
- * the field absent, the reference answers `undefined` until the user writes it,
- * and {@link resolveMarketSettings} fills the language's own default in.
+ * `translationEnabled` deliberately declares no default. A declared default
+ * would be materialized into the live config reference, where "the user never
+ * set this" and "the user turned it off" would both read the same boolean, and
+ * the card could no longer tell the two states apart. With the field absent,
+ * the reference answers `undefined` until the user writes it, and
+ * {@link resolveMarketSettings} answers the plugin default for that case.
  */
 export const MarketSettingsFields = {
     mcpEnhanced: z.boolean().default(MARKET_SETTINGS_DEFAULTS.mcpEnhanced),

package/lib/packages/market-bundle/src/routes.js

@@ -192,6 +192,20 @@ export function mountSuiteRoutes(hostCtx, manager, panels, surfaceToggles, sessi
         await manager.addMcpServer(body.name, body.config, body.policy);
         return {};
     });
+    // Remove one user-owned MCP server. Addressed by the same source-qualified
+    // suite id the status rows carry, so the card names the server it shows. A
+    // suite-declared server is refused by the service, not by this parser: the
+    // rule lives with the code that owns the declaration file.
+    post(MARKET_ROUTES.removeMcpServer, async (body) => {
+        const suiteKey = textField(body['suiteId'] ?? '', 'MCP suite id');
+        const serverKey = textField(body['serverKey'] ?? '', 'MCP server key');
+        if (suiteKey === '')
+            throw new Error('missing MCP suite id');
+        if (serverKey === '')
+            throw new Error('missing MCP server key');
+        await manager.removeMcpServer(suiteKey, serverKey);
+        return {};
+    });
     get(MARKET_ROUTES.lspStatus, async (request, response) => {
         const source = readSource(request);
         if ('error' in source) {

package/lib/packages/market-catalog/src/scanning/archive.js

@@ -141,8 +141,39 @@ export async function archiveInstall(url, dest, options = {}) {
  * within fflate's synchronous push recursion overflows the stack); the
  * chunked feed halts at the next slice.
  */
+/**
+ * Entry count declared by a zip's end-of-central-directory record.
+ *
+ * The stream cannot always reach its per-entry guard: fflate parses a
+ * whole-archive central directory recursively, and a zip with tens of thousands
+ * of tiny members overflows the stack inside one `push()` before `onfile` can
+ * count them. Reading the declared count first refuses such an archive before
+ * any decompression, and the streaming guard still covers what the record
+ * understates.
+ * @param bytes - the complete archive.
+ * @returns the declared total entry count, or undefined when unreadable or zip64.
+ */
+function zipDeclaredEntryCount(bytes) {
+    const EOCD_SIGNATURE = 0x06_05_4b_50;
+    const EOCD_MIN_BYTES = 22;
+    const MAX_COMMENT_BYTES = 0xffff;
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const lowest = Math.max(0, bytes.byteLength - EOCD_MIN_BYTES - MAX_COMMENT_BYTES);
+    for (let offset = bytes.byteLength - EOCD_MIN_BYTES; offset >= lowest; offset -= 1) {
+        if (view.getUint32(offset, true) !== EOCD_SIGNATURE)
+            continue;
+        const declared = view.getUint16(offset + 10, true);
+        // 0xffff defers to zip64, whose real count lives in a different record.
+        return declared === 0xffff ? undefined : declared;
+    }
+    return undefined;
+}
 async function extractZip(archiveFile, dest) {
     const compressed = await readFile(archiveFile);
+    const declared = zipDeclaredEntryCount(compressed);
+    if (declared !== undefined && declared > ARCHIVE_MAX_ENTRIES) {
+        throw new Error(`archive exceeds the ${ARCHIVE_MAX_ENTRIES} entry limit`);
+    }
     let totalBytes = 0;
     let entryCount = 0;
     let failure;

package/lib/packages/market-catalog/src/scanning/validate.js

@@ -33,8 +33,25 @@ function schemasDirectory() {
     let directory = dirname(fileURLToPath(import.meta.url));
     while (true) {
         const manifest = join(directory, 'package.json');
-        if (existsSync(manifest) && JSON.parse(readFileSync(manifest, 'utf8')).name === 'dsh-agent-plugins-market')
+        if (!existsSync(manifest)) {
+            const parent = dirname(directory);
+            if (parent === directory)
+                throw new Error('dsh-agent-plugins-market package root is unavailable');
+            directory = parent;
+            continue;
+        }
+        const name = JSON.parse(readFileSync(manifest, 'utf8')).name;
+        // The workspace package and the packed artifact expose the library at the
+        // same two relative spots: beside the catalog package, or under the
+        // packages/ path preserved by the npm files entry.
+        if (name === '@dsh-market/catalog')
             return join(directory, 'schemas');
+        if (name === 'dsh-agent-plugins-market')
+            return join(directory, 'packages/market-catalog/schemas');
+        const parentDir = dirname(directory);
+        if (parentDir === directory)
+            throw new Error('dsh-agent-plugins-market package root is unavailable');
+        directory = parentDir;
         const parent = dirname(directory);
         if (parent === directory)
             throw new Error('dsh-agent-plugins-market package root is unavailable');

package/lib/packages/market-contracts/src/contracts/market.js

@@ -8,6 +8,7 @@ export const MARKET_ROUTES = {
     setSurfaceToggle: `${MARKET_API_PREFIX}surface-toggles/set`,
     mcpStatus: `${MARKET_API_PREFIX}mcp-status`,
     addMcpServer: `${MARKET_API_PREFIX}mcp-servers/add`,
+    removeMcpServer: `${MARKET_API_PREFIX}mcp-servers/remove`,
     lspStatus: `${MARKET_API_PREFIX}lsp-status`,
     lspServers: `${MARKET_API_PREFIX}lsp-servers`,
     addLspServer: `${MARKET_API_PREFIX}lsp-servers/add`,

package/lib/packages/market-contracts/src/contracts/settings.js

@@ -9,11 +9,10 @@
  * resolved values off the settings snapshot it is handed. Changing a default is
  * therefore a one-line edit in this module.
  *
- * One default is not a constant: `translationEnabled` follows the interface
- * language, so its reader takes the language as an argument and
- * {@link interfaceLanguageTranslates} answers that default only. An explicit
- * preference is independent of language. {@link resolveTranslationTarget}
- * selects the language of displayed translations, including English.
+ * Every default is a plain boolean or word, so this module alone answers a
+ * section that says nothing. {@link resolveTranslationTarget} still selects the
+ * language translations are written in; that choice is independent of whether
+ * translations are displayed.
  *
  * @module contracts/settings
  */
@@ -25,14 +24,11 @@ export const MARKET_SETTINGS_NAMESPACE = 'dsh-agent-plugins-market';
  * These are user-visible behavior: a flip here is a behavior change that ships
  * with its documentation, not a private implementation detail.
  *
- * `translationEnabled` is the one exception: the interface language decides it
- * (see {@link interfaceLanguageTranslates}), so this constant is not where its
- * effective default lives. It is what the browser store holds before the host
- * answers, and that pre-answer state deliberately withholds the translation
- * control rather than flashing it. The namespace schema declares no default for
- * the field at all, an absence that is load-bearing: a schema default would
- * reach the live config reference and erase the difference between "the user
- * never set this" and "the user turned it off".
+ * `translationEnabled` is the one field the namespace schema declares no
+ * default for. The field stays absent until the user writes it, which is what
+ * lets the card tell "never set" from an explicit value, and this constant
+ * answers the absent case. A schema default would reach the live config
+ * reference and erase that difference.
  */
 export const MARKET_SETTINGS_DEFAULTS = {
     mcpEnhanced: true,
@@ -40,13 +36,12 @@ export const MARKET_SETTINGS_DEFAULTS = {
     downloadRegion: 'auto',
     feedbackEnabled: true,
     autoUpdateSources: false,
-    // The browser-side value before the effective one is known — not the
-    // effective default, which interfaceLanguageTranslates derives from the
-    // interface language. Off here keeps a fresh install from spending a provider
-    // request before the host has answered.
-    translationEnabled: false,
-    // Experimental capability: the manager stays hidden until the user opts in.
-    agentPresetsEnabled: false
+    // On for every interface language: a fresh install translates without
+    // visiting the settings page, and a stored false turns it off.
+    translationEnabled: true,
+    // On by default: the preset manager entry shows without an opt-in step, and a
+    // stored false hides it.
+    agentPresetsEnabled: true
 };
 /**
  * Narrow an untrusted stored region to a setting; anything else reads as the
@@ -61,22 +56,6 @@ export function narrowDownloadRegion(value, fallback = MARKET_SETTINGS_DEFAULTS.
 function narrowBoolean(value, fallback) {
     return typeof value === 'boolean' ? value : fallback;
 }
-/**
- * Whether one interface language renders the market's Chinese dictionary.
- *
- * This is the host's own rule rather than a second reading of it:
- * `bindHostLocale` (`runtime/host/host-locale.ts`) answers every preference
- * that is not English with the Chinese dictionary, so as far as the interface is
- * concerned everything that is not English is Chinese — an absent preference
- * included, which the host reads as zh.
- *
- * This determines only the default display preference: Chinese starts on and
- * English starts off. It must not gate an explicitly enabled translation.
- * @param localePreference - the host `locale.preference`, or undefined while nothing supplies one.
- */
-export function interfaceLanguageTranslates(localePreference) {
-    return localePreference === undefined || !localePreference.toLowerCase().startsWith('en');
-}
 /**
  * The language the interface renders, as the translation chain names it.
  *
@@ -109,14 +88,12 @@ export function resolveTranslationTarget(localePreference) {
  * function is what keeps a second reading of "what does missing mean" from
  * growing somewhere else.
  *
- * A stored boolean always wins: the user's own answer is never overridden by
- * the language. Only a section that says nothing about the field takes the
- * language's answer, which is what makes a language switch move the default for
- * a user who never set the field and leave every other user alone.
+ * A stored value always wins: the user's own answer is never overridden by a
+ * default. Only a section that says nothing about the field takes the value in
+ * {@link MARKET_SETTINGS_DEFAULTS}.
  * @param section - the stored (or absent) namespace section, untrusted.
- * @param localePreference - the host `locale.preference` the language-derived default follows.
  */
-export function resolveMarketSettings(section, localePreference) {
+export function resolveMarketSettings(section) {
     const stored = (typeof section === 'object' && section !== null ? section : {});
     return {
         mcpEnhanced: narrowBoolean(stored['mcpEnhanced'], MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
@@ -124,7 +101,7 @@ export function resolveMarketSettings(section, localePreference) {
         downloadRegion: narrowDownloadRegion(stored['downloadRegion']),
         feedbackEnabled: narrowBoolean(stored['feedbackEnabled'], MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
         autoUpdateSources: narrowBoolean(stored['autoUpdateSources'], MARKET_SETTINGS_DEFAULTS.autoUpdateSources),
-        translationEnabled: narrowBoolean(stored['translationEnabled'], interfaceLanguageTranslates(localePreference)),
+        translationEnabled: narrowBoolean(stored['translationEnabled'], MARKET_SETTINGS_DEFAULTS.translationEnabled),
         agentPresetsEnabled: narrowBoolean(stored['agentPresetsEnabled'], MARKET_SETTINGS_DEFAULTS.agentPresetsEnabled)
     };
 }

package/lib/packages/market-contracts/src/ports/ports.js

@@ -8,6 +8,7 @@ export const defaultCatalogPorts = {
     mcpRemount: () => { },
     mcpRemountAll: () => { },
     mcpServerOwner: () => undefined,
+    mcpDemandedMounts: () => [],
     lspStatusSource: { diagnosticsSnapshot: () => new Map(), hasLiveMounts: () => false },
     mcpBackend: async () => 'builtin',
     localePreference: () => 'zh',

package/lib/packages/market-mcp/src/application/mcp/mcp-direct-config.js

@@ -97,6 +97,34 @@ export async function prepareUserMcpServer(agentsRoot, name, server) {
     await validateUserMcp(agentsRoot, document);
     return () => writeJsonDocument(userMcpPath(agentsRoot), document);
 }
+/**
+ * Validate a removal without publishing it. Call the returned atomic write once,
+ * within the same serialized mutation, after the plan is settled.
+ *
+ * The file is re-read rather than rebuilt from the parsed suite: rebuilding
+ * would drop top-level keys this client does not model and rewrite the other
+ * declarations into the parsed shape, while a removal must change exactly one
+ * key. A file the loader rejected is refused here for the same reason creation
+ * refuses it — the write would otherwise discard a declaration nothing could
+ * read.
+ */
+export async function prepareUserMcpServerRemoval(agentsRoot, name) {
+    const suite = await loadUserMcpSuite(agentsRoot);
+    if (suite.errors.length > 0)
+        throw new Error(suite.errors.join('; '));
+    if (!Object.hasOwn(suite.mcp.servers, name))
+        throw new Error(`MCP server "${name}" is not declared`);
+    const raw = await readJsonFile(userMcpPath(agentsRoot));
+    if (!isRecord(raw) || !isRecord(raw['mcpServers']))
+        throw new Error('mcp.json is not a JSON object');
+    const servers = { ...raw['mcpServers'] };
+    delete servers[name];
+    const document = { ...raw, mcpServers: servers };
+    // The remaining document is validated before the write: a removal must not
+    // publish a file the next scan would reject and disable wholesale.
+    await validateUserMcp(agentsRoot, document);
+    return () => writeJsonDocument(userMcpPath(agentsRoot), document);
+}
 /** The user's hand-written MCP declaration file: `<agentsRoot>/mcp.json`. */
 export function userMcpPath(agentsRoot) {
     return join(agentsRoot, 'mcp.json');

package/lib/packages/market-mcp/src/application/mcp/mcp-status.js

@@ -29,9 +29,15 @@ export function declaresAuthHeader(config) {
  * resolver bound to it, when the deployment translates at all. Resolved once by
  * the caller: a server and each of its tools is localized from this one value,
  * never from a fresh read of the host preference.
+ * @param demanded - the suite/server pairs a live session's selection keeps
+ * mounted. The mount pass merged them in as `enabled: true`, so a stored
+ * `enabled: false` beside live tools has two possible causes: this demand, or
+ * a teardown that failed. Only the caller knows the demand, so it travels
+ * here; an omitted list means nothing is demanded and every such row keeps
+ * reading as an orphan.
  * @returns the status payload with every translatable field carrying its translation.
  */
-export function buildMcpStatus(suites, diagnostics, observed, overrides = new Map(), localization) {
+export function buildMcpStatus(suites, diagnostics, observed, overrides = new Map(), localization, demanded = []) {
     const entries = [];
     // Counted so a caller can re-read until the translated text lands, exactly as
     // the market overview reports its own pending count.
@@ -59,6 +65,9 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
         }
     }
     const diagnosticsByKey = new Map(diagnostics.map(diagnostic => [`${diagnostic.suiteId}\u0000${diagnostic.serverKey}`, diagnostic]));
+    // One demand identity per suite/server, joined the same way diagnostics are:
+    // suite ids carry a slash, so the separator cannot be one.
+    const demandedKeys = new Set(demanded.map(mount => `${mount.suiteId}\u0000${mount.serverKey}`));
     const observedByServer = groupObservedTools(observed, knownServerNames);
     for (const suite of suites) {
         // This is an operational inventory, not a configuration audit: suite MCP
@@ -75,7 +84,13 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
             // The declaration stays on the inventory when an override disables it:
             // the panel shows what the suite ships and how the user changed it.
             const disabled = !enabled || suite.activeSurfaces.mcp === false;
-            const orphaned = disabled && tools.length > 0;
+            // Live tools under a stored switch-off are the observed truth either way.
+            // What differs is the cause: session demand keeps the mount, which is the
+            // user's own selection speaking, not a teardown that left registrations
+            // behind. A real diagnostic still wins, so a failed mount underneath the
+            // demand is never explained away as demand.
+            const presetDemand = disabled && tools.length > 0 && diagnostic === undefined && demandedKeys.has(`${suiteKey}\u0000${serverKey}`);
+            const orphaned = disabled && tools.length > 0 && !presetDemand;
             // A duplicate copy shares the live serverName, so observed tools land
             // on it too — that does not make it connected: its own diagnostic says
             // another source's mount is the one serving.
@@ -95,13 +110,24 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
                                     : 'degraded';
             // A diagnostic's reason keeps the code the mount pipeline gave it. The
             // notes this builder adds describe the declaration's own state — an
-            // override switched it off, an override rewrote it, or its surface is
-            // gone while its tools remain — so each carries the matching state code
-            // for the panel to localize.
+            // override switched it off, an override rewrote it, its surface is gone
+            // while its tools remain, or the session's own selection keeps it
+            // mounted — so each carries the matching state code for the panel to
+            // localize.
             const orphanNote = orphaned ? 'MCP tools remain after this plugin surface was disabled' : undefined;
+            // The switch was honoured in the configuration and overruled at mount
+            // time, so the row says which of the two won. The tools stay listed: they
+            // are live, and hiding them would hide the demand too.
+            const presetDemandNote = presetDemand
+                ? 'this service is selected by the active session preset, which keeps it mounted; the panel switch cannot unmount it while that preset is active'
+                : undefined;
             const overrideNote = override === undefined || (state !== 'disabled' && tools.length > 0) ? undefined : disabled ? 'disabled by override' : 'modified by override';
-            const reason = orphanNote ?? diagnostic?.reason ?? overrideNote;
-            const code = orphanNote !== undefined ? 'orphaned-tools' : (diagnostic?.code ?? (overrideNote === undefined ? undefined : disabled ? 'disabled-override' : 'modified-override'));
+            const reason = orphanNote ?? presetDemandNote ?? diagnostic?.reason ?? overrideNote;
+            const code = orphanNote !== undefined
+                ? 'orphaned-tools'
+                : presetDemandNote !== undefined
+                    ? 'preset-demand'
+                    : (diagnostic?.code ?? (overrideNote === undefined ? undefined : disabled ? 'disabled-override' : 'modified-override'));
             entries.push({
                 id: `plugin:${suiteKey}/${serverKey}`,
                 name: serverName,
@@ -113,7 +139,9 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
                 transport: effective.type,
                 endpoint: endpointOf(effective),
                 config: redactMcpConfig(effective),
-                tools: disabled && !orphaned ? [] : observedTools(tools, serverName, localization === undefined ? undefined : localize),
+                // A demanded server keeps its tools on the row: they are live, and the
+                // row says why. Only a plain override-off server has none to show.
+                tools: disabled && !orphaned && !presetDemand ? [] : observedTools(tools, serverName, localization === undefined ? undefined : localize),
                 ...(localization === undefined ? {} : localize(serverName, { name: serverName })),
                 advertisedTools: tools.length > 0,
                 retryable: diagnostic?.code === 'mount-failed' || diagnostic?.code === 'unmount-failed',

package/lib/packages/market-mcp/src/application/mcp-service.js

@@ -10,8 +10,8 @@ import { qualifiedSuiteId } from '../../../market-catalog/src/index.js';
 import { isDirectory } from '../../../market-catalog/src/index.js';
 import { discoverSuitesInSource } from '../../../market-catalog/src/index.js';
 import { probeHostMcpClient } from './mcp/mcp-backend.js';
-import { declaredMcpPolicy, namespaceMcpPolicy, resolveMcpPolicy } from './mcp/mcp-config.js';
-import { prepareUserMcpServer, loadUserMcpSuite, USER_MCP_SOURCE, USER_MCP_SUITE } from './mcp/mcp-direct-config.js';
+import { declaredMcpPolicy, deriveServerName, namespaceMcpPolicy, resolveMcpPolicy } from './mcp/mcp-config.js';
+import { prepareUserMcpServer, prepareUserMcpServerRemoval, loadUserMcpSuite, USER_MCP_SOURCE, USER_MCP_SUITE } from './mcp/mcp-direct-config.js';
 import { applyOverride, loadSuiteOverrides, mergeOverridePatch, parseMcpPolicyPatch, saveSuiteOverrides, withoutPolicyFields } from './mcp/mcp-overrides.js';
 import { redactMcpConfig, redactMcpOverrides } from '../../../market-contracts/src/redaction.js';
 import { buildMcpStatus, declaresAuthHeader } from './mcp/mcp-status.js';
@@ -42,7 +42,11 @@ export class McpService {
         // configuration, so resolving it per entity made this status — one MCP server
         // with many tools especially — scale with the tool count.
         const localization = { locale: this.ports.localePreference(), localizeFields: this.localizeFields };
-        const payload = buildMcpStatus(suites, this.diagnostics, this.ports.mcpToolSnapshot(), await this.allOverrides(suites), localization);
+        // A server this switch turned off can still be mounted by the session's own
+        // preset selection. The builder needs the demand to name that cause instead
+        // of reporting tools the switch never managed to stop.
+        const demanded = this.ports.mcpDemandedMounts?.() ?? [];
+        const payload = buildMcpStatus(suites, this.diagnostics, this.ports.mcpToolSnapshot(), await this.allOverrides(suites), localization, demanded);
         for (const entry of payload.entries)
             if (entry.suiteId === `${USER_MCP_SOURCE}/${USER_MCP_SUITE}`) {
                 entry.kind = 'direct';
@@ -105,6 +109,43 @@ export class McpService {
             await this.context.notifyChanged(true);
         });
     }
+    /**
+     * Remove one user-owned server from the declaration file and drop everything
+     * the plugin stored about it: the override record (edited config, enablement,
+     * policy) and the OAuth grant. Only the user's own declaration may be removed
+     * — a suite's `mcp.json` is source-owned, so a refresh would restore a server
+     * deleted from it, and disabling is the supported operation there.
+     *
+     * The declaration is written first. An interruption can then leave an inert
+     * override or grant record behind, never a live server whose stored policy was
+     * silently dropped.
+     */
+    async removeServer(suiteKey, serverKey) {
+        return this.context.enqueue(async () => {
+            const { sourceId, suiteId } = splitSuiteKey(suiteKey);
+            if (!isUserOwnedMcp(suiteKey))
+                throw new Error(`server "${serverKey}" belongs to suite "${suiteKey}"; disable it instead of removing it`);
+            const publish = await prepareUserMcpServerRemoval(this.context.agentsRoot, serverKey);
+            await publish();
+            // The record would otherwise outlive its declaration: it carries the
+            // user's edited config and policy, and a later server of the same name
+            // would inherit both.
+            const overrides = await loadSuiteOverrides(this.context.dataRoot, suiteKey);
+            if (Object.hasOwn(overrides, serverKey)) {
+                delete overrides[serverKey];
+                await saveSuiteOverrides(this.context.dataRoot, suiteKey, overrides);
+            }
+            // A removed server must not keep its OAuth grant: the bridge folds the
+            // record by the same derived mount name a future server could reuse.
+            await this.ports.credentialsStore?.deleteGrantRecord(deriveServerName({ sourceId, id: suiteId }, serverKey));
+            await this.context.notifyChanged(true);
+            // The status surface reads the live tool registry, so an immediate read
+            // races the reconciler's teardown and would still show the removed server.
+            // Joining the pass here is bounded — one stuck mount costs the request its
+            // deadline, never the plugin.
+            await this.context.refreshSettled();
+        });
+    }
     /** Read one MCP service without credential literals, or an unsaved creation template. */
     async serverConfig(id, create = false) {
         if (create) {

package/lib/packages/market-mcp/src/runtime/mcp/bridge/connection.js

@@ -83,9 +83,11 @@ export function resolveReconnectPolicy(config, path) {
  * @param policy - Resolved reconnect policy from {@link resolveReconnectPolicy}.
  * @param credentials - The composition's credential store, when mounted; OAuth
  *   state persists only when it is.
+ * @param opener - Browser opener for the OAuth human leg; the platform browser
+ *   by default.
  * @returns Handle with a `ready` promise for startup-await and a `dispose` for teardown.
  */
-export function startConnection(host, config, policy, credentials) {
+export function startConnection(host, config, policy, credentials, opener) {
     const label = `mcp-client(${config.serverName})`;
     const opts = {
         registrationFailure: 'contain',
@@ -258,9 +260,33 @@ export function startConnection(host, config, policy, credentials) {
             clientClosed = undefined;
             host.logger.error(`${label}: failed generation did not close within ${GENERATION_CLOSE_TIMEOUT_MS}ms — reconnect stopped to avoid overlapping server processes; reload the plugin or restart the Host to retry`);
         }
+        /**
+         * Retire the generation that raised the `401` and re-establish in place.
+         *
+         * The SDK aborts that generation's handshake the moment the human leg
+         * returns: the initialize that triggered the authorization is gone, so the
+         * saved tokens only ever reach the server on a fresh call. Running that
+         * call here — instead of scheduling a backoff retry — lets `ready` report
+         * the mount's real outcome rather than a failure the caller has to count on
+         * a retry to repair after the user already approved.
+         */
+        async function reestablishAfterAuthorization() {
+            attemptSettled = true;
+            client = undefined;
+            clientClosed = undefined;
+            try {
+                await generation.close();
+            }
+            catch {
+                /* transport already gone */
+            }
+            if (disposed)
+                return;
+            await connectGeneration(false);
+        }
         const { transport, oauthProvider } = createTransport(config, credentials, (message) => {
             host.logger.info(message);
-        });
+        }, opener);
         try {
             await generation.connect(transport, { timeout: opts.startupTimeoutMs });
             if (hasClosed()) {
@@ -288,32 +314,25 @@ export function startConnection(host, config, policy, credentials) {
                 attemptSettled = true;
                 if (!isCurrent(generation))
                     return;
-                // The leg failed, or the transport closed while it ran: no generation
-                // is left to finish establishing.
-                if (hasClosed() || !legSettled) {
-                    generationDown(generation);
-                    return;
-                }
-                // The exchange succeeded inside this generation: finish establishing
-                // it (tool sync + connected bookkeeping) instead of respawning.
-                try {
-                    await enqueueSync(generation, startup ? startupOpts : opts);
-                }
-                catch (syncError) {
-                    if (isCurrent(generation))
-                        host.logger.warn(`${label}: tool sync after authorization failed: ${String(syncError)}`);
-                    await teardownFailedAttempt();
-                    return;
-                }
-                if (hasClosed()) {
+                // A failed leg leaves nothing to establish. A successful one always
+                // needs a fresh generation: the SDK closes this one as soon as the
+                // initialize that raised the `401` fails, whether that was the request
+                // timeout the human approval outlived or the redirect the leg returns.
+                if (!legSettled) {
                     generationDown(generation);
                     return;
                 }
+                await reestablishAfterAuthorization();
+                return;
+            }
+            // A leg that finished inside this attempt leaves no pending promise: the
+            // SDK aborts the connect that raised the `401` as soon as the browser leg
+            // returns. The tokens are saved either way, so no handshake on this
+            // generation can carry them.
+            if (oauthProvider?.lastBrowserLegOutcome === true) {
                 if (!isCurrent(generation))
                     return;
-                connectedAt = Date.now();
-                if (failedAttempts > 0)
-                    host.logger.info(`${label}: authorized and re-synced tools (attempt ${failedAttempts}/${policy.maxAttempts})`);
+                await reestablishAfterAuthorization();
                 return;
             }
             await teardownFailedAttempt();