dsh-agent-plugins-market 0.5.2 → 0.6.0

package/lib/runtime/mcp-config.js

@@ -1,29 +1,37 @@
 /**
- * Maps one validated suite `mcp.json` onto `dsh-mcp-client` config rows.
+ * Maps one validated suite `mcp.json` onto self-built bridge config rows.
  *
  * The portable format is translated, not executed directly: stdio commands
  * resolve against the suite root (spec §7.2.1), `${PLUGIN_ROOT}` /
  * `${PLUGIN_DATA}` expand against the suite root and its data directory, and
- * `${NAME}` expands from the process environment (documented extension over
- * the portable format, matching how hook commands already consume ambient
- * env). Legacy HTTP+SSE servers have no transport in the dsh MCP client and
- * are skipped with a per-server reason.
+ * every `${NAME}` — including ones inside a streamable-http `url` — expands
+ * through the optional DSH credentials seam at mount time. Legacy HTTP+SSE
+ * servers are supported by the market's own bridge (the host client had no
+ * such transport); unrecognized shapes are still skipped with a per-server
+ * reason.
  */
 import { createHash } from 'node:crypto';
-import { expandPlaceholders, resolveCwd } from '../catalog/validate.js';
+import { DEFAULT_TOOL_CALL_TIMEOUT_MS } from './mcp-client/config.js';
+import { resolveCwd } from '../catalog/validate.js';
+import { qualifiedSuiteId } from '../catalog/paths.js';
 import { applyOverride } from './mcp-overrides.js';
-/** The max length `dsh-mcp-client` accepts for a serverName. */
+/** The max length the bridge accepts for a serverName. */
 const SERVER_NAME_MAX = 32;
+const PLACEHOLDER = /\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g;
+const BUILTIN_PLACEHOLDERS = new Set(['PLUGIN_ROOT', 'CLAUDE_PLUGIN_ROOT', 'PLUGIN_DATA', 'CLAUDE_PLUGIN_DATA']);
 /**
- * Build one mount request per supported mcp.json server.
+ * Build one mount request per supported mcp.json server, resolving every
+ * `${NAME}` through the credential resolver before a child process or HTTP
+ * request is created. Missing references fail closed per server instead of
+ * becoming empty strings.
+ *
  * @param overrides user-owned per-server overrides (url/headers/env/args
- *   replacement plus enable/disable); applied after source expansion, before
- *   mount. Disabled servers are omitted from the result entirely.
- * @returns mount requests plus per-server failures (unsupported transport,
- *   invalid server key, or derived serverName collision candidates are
- *   checked by the mount registry, not here).
+ *   replacement plus enable/disable); applied before mount. Disabled servers
+ *   are omitted entirely.
+ * @returns mount requests plus per-server failures. serverName collisions are
+ *   reported by the mount registry, not here.
  */
-export function toMcpMounts(suite, pluginDataRoot, overrides = {}) {
+export async function toMcpMounts(suite, pluginDataRoot, overrides = {}, resolver = { resolve: async () => undefined }) {
     if (suite.mcp === undefined)
         return { mounts: [], failures: [] };
     const mounts = [];
@@ -32,57 +40,191 @@ export function toMcpMounts(suite, pluginDataRoot, overrides = {}) {
         const override = overrides[serverKey];
         if (override?.enabled === false)
             continue;
-        const request = toMount(suite, serverKey, applyOverride(source, override), pluginDataRoot);
-        if (request === undefined) {
-            failures.push({ serverKey, reason: transportReason(source) });
+        const server = applyOverride(source, override);
+        try {
+            const result = await toResolvedMount(suite, serverKey, server, pluginDataRoot, resolver);
+            if (result.failure !== undefined)
+                failures.push(result.failure);
+            if (result.request !== undefined)
+                mounts.push(result.request);
         }
-        else {
-            mounts.push(request);
+        catch {
+            failures.push({ serverKey, code: 'credential-error', credentialRefs: credentialRefsInServer(server), reason: 'credential lookup failed' });
         }
     }
     return { mounts, failures };
 }
-function toMount(suite, serverKey, server, pluginDataRoot) {
-    const serverName = deriveServerName(suite.id, serverKey);
-    if (server.type === 'stdio')
-        return { suiteId: suite.id, serverKey, config: toStdio(serverName, suite, server, pluginDataRoot) };
-    if (server.type === 'streamable-http')
-        return { suiteId: suite.id, serverKey, config: toHttp(serverName, suite, server, pluginDataRoot) };
-    return undefined;
+/** Find external credential references used by one MCP server definition. */
+export function credentialRefsInServer(server) {
+    const values = [];
+    if (server.type === 'stdio') {
+        values.push(...(server.args ?? []), ...(server.cwd === undefined ? [] : [server.cwd]), ...Object.values(server.env ?? {}));
+    }
+    else {
+        // A remote endpoint may carry the token in the URL query as well as in a
+        // header, so both are scanned and both are resolved at mount time.
+        values.push(server.url ?? '', ...Object.values(server.headers ?? {}));
+    }
+    const refs = new Set();
+    for (const value of values) {
+        for (const match of value.matchAll(PLACEHOLDER)) {
+            const name = match[1];
+            if (name !== undefined && !BUILTIN_PLACEHOLDERS.has(name))
+                refs.add(name);
+        }
+    }
+    return [...refs].sort();
+}
+async function toResolvedMount(suite, serverKey, server, pluginDataRoot, resolver) {
+    if (server.type === 'sse') {
+        // The market bridge supports the legacy HTTP+SSE transport natively.
+        const expand = expander(suite, joinInside(pluginDataRoot, qualifiedSuiteId(suite.sourceId, suite.id)), resolver);
+        const url = await expand.one(server.url);
+        const headers = await expand.map(server.headers ?? {});
+        const missing = unique([...url.missing, ...headers.missing]);
+        if (missing.length > 0)
+            return { failure: missingFailure(serverKey, missing) };
+        const sseConfig = {
+            transport: 'sse',
+            serverName: deriveServerName(qualifiedSuiteId(suite.sourceId, suite.id), serverKey),
+            url: url.value,
+            headers: headers.values,
+            ...(server.auth === undefined ? {} : { auth: mapAuth(server.auth) }),
+            toolCallTimeoutMs: DEFAULT_TOOL_CALL_TIMEOUT_MS,
+            failOnStartupError: true
+        };
+        return { request: { suiteId: qualifiedSuiteId(suite.sourceId, suite.id), serverKey, config: sseConfig } };
+    }
+    const expand = expander(suite, joinInside(pluginDataRoot, qualifiedSuiteId(suite.sourceId, suite.id)), resolver);
+    const serverName = deriveServerName(qualifiedSuiteId(suite.sourceId, suite.id), serverKey);
+    if (server.type === 'stdio') {
+        const args = await expand.all(server.args ?? []);
+        const env = await expand.map(server.env ?? {});
+        const cwd = server.cwd === undefined ? { value: suite.root, missing: [] } : await expand.one(server.cwd);
+        const missing = unique([...args.missing, ...env.missing, ...cwd.missing]);
+        if (missing.length > 0)
+            return { failure: missingFailure(serverKey, missing) };
+        return {
+            request: {
+                suiteId: qualifiedSuiteId(suite.sourceId, suite.id),
+                serverKey,
+                config: {
+                    transport: 'stdio',
+                    serverName,
+                    command: server.command.startsWith('./') ? joinInside(suite.root, server.command.slice(2)) : server.command,
+                    args: args.values,
+                    env: env.values,
+                    cwd: resolveCwd(cwd.value, suite.root, joinInside(pluginDataRoot, qualifiedSuiteId(suite.sourceId, suite.id))),
+                    toolCallTimeoutMs: DEFAULT_TOOL_CALL_TIMEOUT_MS,
+                    failOnStartupError: true
+                }
+            }
+        };
+    }
+    const url = await expand.one(server.url);
+    const headers = await expand.map(server.headers ?? {});
+    const missing = unique([...url.missing, ...headers.missing]);
+    if (missing.length > 0)
+        return { failure: missingFailure(serverKey, missing) };
+    return {
+        request: {
+            suiteId: qualifiedSuiteId(suite.sourceId, suite.id),
+            serverKey,
+            config: {
+                transport: 'streamable-http',
+                serverName,
+                url: url.value,
+                headers: headers.values,
+                ...(server.auth === undefined ? {} : { auth: mapAuth(server.auth) }),
+                toolCallTimeoutMs: DEFAULT_TOOL_CALL_TIMEOUT_MS,
+                failOnStartupError: true
+            }
+        }
+    };
+}
+/**
+ * Map the suite format's auth declaration onto the bridge's OAuth config.
+ * `enabled: false` must survive the mapping — it is the explicit opt-out —
+ * while `enabled: true` (or a bare declaration) requests the default-on
+ * flow, optionally with a scope.
+ */
+function mapAuth(auth) {
+    return {
+        enabled: auth.enabled !== false,
+        ...(auth.scope === undefined ? {} : { scope: auth.scope })
+    };
 }
-function toStdio(serverName, suite, server, pluginDataRoot) {
-    const command = server.command.startsWith('./') ? joinInside(suite.root, server.command.slice(2)) : server.command;
-    const pluginData = joinInside(pluginDataRoot, suite.id);
-    const args = (server.args ?? []).map(arg => expandPlaceholders(arg, suite.root, pluginData));
-    const env = Object.fromEntries(Object.entries(server.env ?? {}).map(([key, value]) => [key, expandPlaceholders(value, suite.root, pluginData)]));
-    const cwd = server.cwd === undefined ? suite.root : resolveCwd(expandPlaceholders(server.cwd, suite.root, pluginData), suite.root, pluginData);
+/** Per-mount expansion context; credential lookups are memoized per call. */
+function expander(suite, pluginData, resolver) {
+    // Promise-valued cache: concurrent expansions of the same reference share
+    // one in-flight lookup, so a config using a token twice resolves it once.
+    const inflight = new Map();
+    const lookup = (name) => {
+        const pending = inflight.get(name);
+        if (pending !== undefined)
+            return pending;
+        const created = Promise.resolve(resolver.resolve(name));
+        inflight.set(name, created);
+        return created;
+    };
+    const one = async (value) => {
+        let cursor = 0;
+        let output = '';
+        const missing = [];
+        for (const match of value.matchAll(PLACEHOLDER)) {
+            const index = match.index ?? 0;
+            const name = match[1];
+            if (name === undefined)
+                continue;
+            output += value.slice(cursor, index);
+            const fallback = match[2];
+            let replacement;
+            if (name === 'PLUGIN_ROOT' || name === 'CLAUDE_PLUGIN_ROOT')
+                replacement = suite.root;
+            else if (name === 'PLUGIN_DATA' || name === 'CLAUDE_PLUGIN_DATA')
+                replacement = pluginData;
+            else
+                replacement = (await lookup(name))?.value;
+            if (replacement === undefined || replacement === '') {
+                if (fallback !== undefined && fallback !== '')
+                    replacement = fallback;
+                else {
+                    missing.push(name);
+                    replacement = '';
+                }
+            }
+            output += replacement;
+            cursor = index + match[0].length;
+        }
+        output += value.slice(cursor);
+        return { value: output, missing };
+    };
     return {
-        transport: 'stdio',
-        serverName,
-        command,
-        args,
-        env,
-        cwd,
-        toolCallTimeoutMs: 60_000,
-        failOnStartupError: false
+        one,
+        async all(values) {
+            const expanded = await Promise.all(values.map(one));
+            return { values: expanded.map(item => item.value), missing: expanded.flatMap(item => item.missing) };
+        },
+        async map(values) {
+            const entries = await Promise.all(Object.entries(values).map(async ([key, value]) => [key, await one(value)]));
+            return {
+                values: Object.fromEntries(entries.map(([key, result]) => [key, result.value])),
+                missing: entries.flatMap(([, result]) => result.missing)
+            };
+        }
     };
 }
-function toHttp(serverName, suite, server, pluginDataRoot) {
-    const pluginData = joinInside(pluginDataRoot, suite.id);
-    const headers = Object.fromEntries(Object.entries(server.headers ?? {}).map(([key, value]) => [key, expandPlaceholders(value, suite.root, pluginData)]));
+function missingFailure(serverKey, refs) {
+    const uniqueRefs = unique(refs);
     return {
-        transport: 'streamable-http',
-        serverName,
-        url: server.url,
-        headers,
-        toolCallTimeoutMs: 60_000,
-        failOnStartupError: false
+        serverKey,
+        code: 'missing-credential',
+        credentialRefs: uniqueRefs,
+        reason: uniqueRefs.map(ref => `missing credential reference ${ref}`).join('; ')
     };
 }
-function transportReason(server) {
-    if (server.type === 'sse')
-        return 'legacy HTTP+SSE transport is not supported by the dsh MCP client';
-    return 'unsupported mcp.json server shape';
+function unique(values) {
+    return [...new Set(values)].sort();
 }
 function joinInside(root, segment) {
     return `${root.replace(/[\\/]$/, '')}/${segment}`;
@@ -96,7 +238,7 @@ function sanitizeToken(raw) {
     return cleaned === '' ? 'server' : cleaned;
 }
 /**
- * Derive a stable, unique-ish `dsh-mcp-client` serverName from the suite and
+ * Derive a stable, unique-ish bridge serverName from the suite and
  * server ids: `${suiteId}__${serverKey}` sanitized, truncated to 32 chars
  * with a deterministic 12-hex suffix when the join exceeds the budget (the
  * same deterministic-hash policy the MCP client uses for long tool names).

package/lib/runtime/mcp-credentials.js

@@ -0,0 +1,20 @@
+/**
+ * Build the resolver used at mount time. Standard DSH profiles provide
+ * `ctx.credentials`; minimal profiles retain the historical process-env
+ * fallback so MCP mounting remains backwards compatible.
+ */
+export function mcpCredentialResolver(ctx) {
+    const host = ctx;
+    const service = host.get?.('credentials');
+    if (typeof service?.resolve === 'function') {
+        return {
+            resolve: ref => service.resolve(ref)
+        };
+    }
+    return {
+        async resolve(ref) {
+            const value = process.env[ref];
+            return value === undefined || value === '' ? undefined : { value, source: 'env' };
+        }
+    };
+}

package/lib/runtime/mcp-mounts.js

@@ -1,12 +1,41 @@
-import { toMcpMounts } from './mcp-config.js';
+import { createHash } from 'node:crypto';
+import * as mcpBridge from './mcp-client/bridge.js';
+import { applyOverride } from './mcp-overrides.js';
+import { credentialRefsInServer, toMcpMounts } from './mcp-config.js';
+import { mcpCredentialResolver } from './mcp-credentials.js';
+import { qualifiedSuiteId } from '../catalog/paths.js';
+/**
+ * Bounded retry schedule for a failed mount/unmount. A crash-looping or
+ * permanently broken server must eventually stop consuming attempt budget, so
+ * the schedule is capped and resets with every reconcile pass.
+ */
+const RETRY_SCHEDULE_MS = [1_500, 5_000, 15_000, 45_000, 120_000];
+const MAX_RETRY_ATTEMPTS = RETRY_SCHEDULE_MS.length;
 export class McpMountRegistry {
     ctx;
     pluginDataRoot;
     live = new Map();
     names = new Map();
+    credentialRefs = new Set();
     overridesProvider = async () => new Map();
+    /** Live model-facing tool names, for foreign-namespace detection before a mount. */
+    toolNamesProvider = () => [];
+    /** The active MCP mount backend ('builtin' bridge or host client compat mode). */
+    backendProvider = async () => 'builtin';
     /** Serialize mount and unmount passes so a disable cannot race an in-flight spawn. */
     reconcileQueue = Promise.resolve();
+    /** Pending retry timers keyed by mount key, so a teardown can cancel them. */
+    retries = new Map();
+    /** Attempt count per mount key; reset whenever a retry succeeds. */
+    attempts = new Map();
+    /**
+     * Mount keys flagged for an explicit rebuild (re-authorize): the next
+     * reconcile must tear down and remount them even when the resolved config
+     * fingerprint is unchanged — dropping a grant changes no config field.
+     */
+    forcedRemounts = new Set();
+    /** Snapshot of the last reconciled suite set, replayed by retry passes. */
+    lastEnabled = [];
     constructor(ctx, pluginDataRoot) {
         this.ctx = ctx;
         this.pluginDataRoot = pluginDataRoot;
@@ -15,6 +44,41 @@ export class McpMountRegistry {
     setOverridesProvider(provider) {
         this.overridesProvider = provider;
     }
+    /**
+     * Install the live model-facing tool-name provider (the host registry
+     * snapshot) used to detect foreign `mcp__<serverName>__` namespaces before
+     * a mount is attempted.
+     */
+    setToolNamesProvider(provider) {
+        this.toolNamesProvider = provider;
+    }
+    /** Install the backend provider deciding which client mounts each server. */
+    setBackendProvider(provider) {
+        this.backendProvider = provider;
+    }
+    /** Whether the last catalog snapshot uses one credential reference. */
+    usesCredential(ref) {
+        return this.credentialRefs.has(ref);
+    }
+    /**
+     * Flag one mount for an explicit rebuild on the next reconcile: used by
+     * re-authorize, which deletes a grant without changing any resolved config
+     * field, so a fingerprint-only reconcile would keep the live bridge (and
+     * its in-memory tokens) untouched.
+     */
+    forceRemount(suiteId, serverKey) {
+        this.forcedRemounts.add(mountKey(suiteId, serverKey));
+    }
+    /** The mount key owning one derived serverName; undefined when not mounted here. */
+    serverOwner(serverName) {
+        const owner = this.names.get(serverName);
+        if (owner === undefined)
+            return undefined;
+        // Values are `${suiteId}\u0000${serverKey}` — suite ids may contain a
+        // slash (qualified ids), so the separator is the NUL byte, not '/'.
+        const separator = owner.indexOf('\u0000');
+        return { suiteId: owner.slice(0, separator), serverKey: owner.slice(separator + 1) };
+    }
     /** Queue one reconciliation behind any in-flight mount/unmount pass. */
     async reconcile(enabledSuites) {
         const run = this.reconcileQueue.then(() => this.reconcileNow(enabledSuites));
@@ -23,14 +87,32 @@ export class McpMountRegistry {
     }
     /** Mount/unmount MCP servers to match the enabled suites exactly. */
     async reconcileNow(enabledSuites) {
+        this.lastEnabled = [...enabledSuites];
         const active = enabledSuites.filter(suite => suite.activeSurfaces?.mcp !== false);
         const overrides = await this.overridesProvider();
+        const resolver = mcpCredentialResolver(this.ctx);
         const wanted = new Map();
         const diagnostics = [];
+        this.credentialRefs.clear();
         for (const suite of active) {
-            const { mounts, failures } = toMcpMounts(suite, this.pluginDataRoot, overrides.get(suite.id));
+            const suiteOverrides = overrides.get(qualifiedSuiteId(suite.sourceId, suite.id));
+            for (const [serverKey, source] of Object.entries(suite.mcp?.servers ?? {})) {
+                const override = suiteOverrides?.[serverKey];
+                if (override?.enabled === false)
+                    continue;
+                const effective = applyOverride(source, override);
+                for (const ref of credentialRefsInServer(effective))
+                    this.credentialRefs.add(ref);
+            }
+            const { mounts, failures } = await toMcpMounts(suite, this.pluginDataRoot, suiteOverrides, resolver);
             for (const failure of failures) {
-                diagnostics.push({ suiteId: suite.id, serverKey: failure.serverKey, reason: failure.reason });
+                diagnostics.push({
+                    suiteId: suite.id,
+                    serverKey: failure.serverKey,
+                    reason: failure.reason,
+                    ...(failure.code === undefined ? {} : { code: failure.code }),
+                    ...(failure.credentialRefs === undefined ? {} : { credentialRefs: failure.credentialRefs })
+                });
             }
             for (const mount of mounts) {
                 wanted.set(mountKey(mount.suiteId, mount.serverKey), { suite, serverKey: mount.serverKey, request: mount });
@@ -38,19 +120,80 @@ export class McpMountRegistry {
         }
         for (const [key, live] of [...this.live]) {
             if (!wanted.has(key)) {
-                await this.unmount(key, live);
-                diagnostics.push({ suiteId: live.suiteId, serverKey: live.serverKey, reason: 'unmounted' });
+                const reason = await this.unmount(key, live);
+                diagnostics.push({
+                    suiteId: live.suiteId,
+                    serverKey: live.serverKey,
+                    reason: reason ?? 'unmounted',
+                    ...(reason === undefined ? {} : { code: 'unmount-failed' })
+                });
             }
         }
         for (const [key, entry] of wanted) {
-            if (this.live.has(key))
+            const live = this.live.get(key);
+            // A forced remount (re-authorize) skips the fingerprint match on
+            // purpose: dropping a grant does not change the resolved config, so
+            // only the explicit instruction tears the live bridge down and lets
+            // the server's 401 restart the browser authorization.
+            if (live !== undefined && !this.forcedRemounts.has(key) && live.configFingerprint === fingerprintOf(entry.request))
                 continue;
-            const reason = await this.mountWith(entry.request);
-            if (reason !== undefined)
-                diagnostics.push({ suiteId: entry.suite.id, serverKey: entry.serverKey, reason });
+            this.forcedRemounts.delete(key);
+            // Either a fresh mount, or a remount because the resolved config moved
+            // (a credential rotation rewrites the env/header/url values while the
+            // suite stays enabled) — keeping the old mount would keep serving the
+            // old token until disable or restart.
+            if (live !== undefined) {
+                const reason = await this.unmount(key, live);
+                if (reason !== undefined) {
+                    diagnostics.push({ suiteId: live.suiteId, serverKey: live.serverKey, reason, code: 'unmount-failed' });
+                    continue;
+                }
+            }
+            // A retry attempt runs the same mount path; only the last failure is
+            // reported so a transient error does not shadow the final state.
+            const failure = await this.mountWith(entry.request);
+            if (failure !== undefined) {
+                diagnostics.push({ suiteId: entry.suite.id, serverKey: entry.serverKey, reason: failure.reason, code: failure.code });
+                // A foreign-namespace skip is deterministic, not transient: retrying
+                // it just burns the attempt budget and log lines. The next full
+                // reconcile re-checks it anyway, so the self-heal path is intact.
+                this.scheduleRetry(key, entry.suite.id, entry.serverKey, failure.code === 'foreign-mount' ? undefined : failure.reason);
+            }
         }
         return diagnostics.filter(diagnostic => diagnostic.reason !== 'unmounted');
     }
+    /**
+     * Schedule a delayed re-attempt for a mount that still is not live.
+     *
+     * Mounts are retried because a remote endpoint or a credential may become
+     * available slightly after the suite is enabled. The schedule is bounded, and
+     * a server that keeps failing simply stops retrying until the next reconcile.
+     */
+    scheduleRetry(key, suiteId, serverKey, reason) {
+        const pending = this.retries.get(key);
+        if (pending !== undefined)
+            clearTimeout(pending);
+        this.retries.delete(key);
+        if (reason === undefined) {
+            this.attempts.delete(key);
+            return;
+        }
+        const attempt = (this.attempts.get(key) ?? 0) + 1;
+        this.attempts.set(key, attempt);
+        if (attempt > MAX_RETRY_ATTEMPTS) {
+            this.ctx.logger?.warn(`[dsh-agent-plugins-market] ${suiteId}/${serverKey}: giving up after ${MAX_RETRY_ATTEMPTS} attempts — ${reason}`);
+            return;
+        }
+        const delay = RETRY_SCHEDULE_MS[attempt - 1] ?? RETRY_SCHEDULE_MS[RETRY_SCHEDULE_MS.length - 1];
+        const timer = setTimeout(() => {
+            this.retries.delete(key);
+            // Re-run against the last known suite set: a retry must not resurrect a
+            // server that has since been disabled or uninstalled.
+            void this.reconcile(this.lastEnabled).catch(() => { });
+        }, delay);
+        timer.unref?.();
+        this.retries.set(key, timer);
+    }
     /** Dispose every live mount after queued reconciliation passes settle. */
     async disposeAll() {
         const run = this.reconcileQueue.then(async () => {
@@ -60,45 +203,112 @@ export class McpMountRegistry {
         });
         this.reconcileQueue = run.then(() => undefined, () => undefined);
         await run;
+        for (const timer of this.retries.values())
+            clearTimeout(timer);
+        this.retries.clear();
+        this.attempts.clear();
+        this.credentialRefs.clear();
     }
     /** Mount one precomputed request (source config merged with overrides). */
     async mountWith(request) {
         const owner = this.names.get(request.config.serverName);
-        if (owner !== undefined)
-            return `derived serverName "${request.config.serverName}" already mounted by ${owner}`;
-        let mcpClient;
-        try {
-            mcpClient = await import('@deepseek-ai/dsh-mcp-client');
+        if (owner !== undefined) {
+            return { reason: `derived serverName "${request.config.serverName}" already mounted by ${owner}`, code: 'mount-failed' };
         }
-        catch {
-            return 'the @deepseek-ai/dsh-mcp-client package is not installed in this profile';
+        // Foreign-namespace guard: a native host MCP client (or another plugin's
+        // mount) may already own this `mcp__<serverName>__` namespace. Registering
+        // into it would fail loudly mid-mount; skipping here reports the conflict
+        // as a clear per-server diagnostic instead, and a later reconcile mounts
+        // this server if the foreign owner goes away. The matching names ride the
+        // diagnostic — a leftover of this plugin's own earlier mount (registry
+        // record lost without a teardown) reads as an orphan here, and a Host
+        // restart clears it; a genuinely foreign owner keeps the skip sticky.
+        const prefix = `mcp__${request.config.serverName}__`;
+        const foreign = this.toolNamesProvider().filter(name => name.startsWith(prefix));
+        if (foreign.length > 0) {
+            return {
+                reason: `serverName "${request.config.serverName}" is already mounted by another MCP client (native config or another plugin; matching tools: ${foreign.slice(0, 3).join(', ')}${foreign.length > 3 ? `, +${foreign.length - 3} more` : ''}) — skipped to avoid a duplicate mount; restart the Host if these tools are a leftover`,
+                code: 'foreign-mount'
+            };
         }
+        // Backend dispatch: the built-in bridge connects stdio, Streamable HTTP
+        // (with OAuth), and legacy SSE servers in-process; the host backend
+        // mounts the host's own `dsh-mcp-client` for compatibility, at the cost
+        // of OAuth and SSE support.
         const mountCtx = this.ctx;
-        if (typeof mountCtx.plugin !== 'function')
-            return 'the host context does not support dynamic plugin mounting';
+        if (typeof mountCtx.plugin !== 'function') {
+            return { reason: 'the host context does not support dynamic plugin mounting', code: 'mount-failed' };
+        }
+        let pluginModule = mcpBridge;
+        if ((await this.backendProvider()) === 'host') {
+            if (request.config.transport === 'sse') {
+                return {
+                    reason: 'the host dsh-mcp-client does not support the legacy SSE transport — switch the MCP backend back to the built-in client for this server',
+                    code: 'mount-failed'
+                };
+            }
+            try {
+                pluginModule = await import('@deepseek-ai/dsh-mcp-client');
+            }
+            catch {
+                return {
+                    reason: 'the @deepseek-ai/dsh-mcp-client package is not installed in this profile — switch the MCP backend back to the built-in client',
+                    code: 'mount-failed'
+                };
+            }
+        }
+        let handle;
         try {
-            const handle = mountCtx.plugin(mcpClient, request.config);
+            handle = mountCtx.plugin(pluginModule, request.config);
             await handle.await();
-            const key = mountKey(request.suiteId, request.serverKey);
-            this.live.set(key, { suiteId: request.suiteId, serverKey: request.serverKey, serverName: request.config.serverName, disposer: () => handle.dispose() });
-            this.names.set(request.config.serverName, `${request.suiteId}/${request.serverKey}`);
-            return undefined;
         }
         catch (error) {
-            return `mount failed: ${error instanceof Error ? error.message : String(error)}`;
+            // The bridge mounts with failOnStartupError for suite servers, so a
+            // connection or initialization failure rejects here. Drop the
+            // half-mounted handle before reporting so no orphan child survives a
+            // failed startup.
+            if (handle !== undefined) {
+                try {
+                    await handle.dispose();
+                }
+                catch {
+                    // Ignore teardown errors: the startup failure is the real signal.
+                }
+            }
+            return { reason: `mount failed: ${error instanceof Error ? error.message : String(error)}`, code: 'mount-failed' };
         }
+        this.live.set(mountKey(request.suiteId, request.serverKey), {
+            suiteId: request.suiteId,
+            serverKey: request.serverKey,
+            serverName: request.config.serverName,
+            configFingerprint: fingerprintOf(request),
+            disposer: () => handle.dispose()
+        });
+        this.names.set(request.config.serverName, `${request.suiteId}\u0000${request.serverKey}`);
+        return undefined;
     }
     async unmount(key, live) {
-        this.live.delete(key);
-        this.names.delete(live.serverName);
         try {
             await live.disposer();
+            this.live.delete(key);
+            this.names.delete(live.serverName);
+            return undefined;
         }
         catch (error) {
-            this.ctx.logger?.warn(`[dsh-agent-plugins-market] unmount ${live.suiteId}/${live.serverKey} failed: ${error instanceof Error ? error.message : String(error)}`);
+            const reason = `unmount failed: ${error instanceof Error ? error.message : String(error)}`;
+            this.ctx.logger?.warn(`[dsh-agent-plugins-market] ${reason} (${live.suiteId}/${live.serverKey})`);
+            return reason;
         }
     }
 }
 function mountKey(suiteId, serverKey) {
     return `${suiteId}\u0000${serverKey}`;
 }
+/**
+ * Stable fingerprint of one resolved mount request: any change to the
+ * transport, url, headers, env, args, or auth shape produces a different
+ * fingerprint and forces a remount on the next reconcile pass.
+ */
+function fingerprintOf(request) {
+    return createHash('sha256').update(JSON.stringify(request.config)).digest('hex');
+}