dsh-agent-plugins-market 0.7.0 → 0.7.2

package/lib/runtime/mcp-mounts.js

@@ -1,9 +1,11 @@
 import { createHash } from 'node:crypto';
+import { mkdir } from 'node:fs/promises';
 import * as mcpBridge from './mcp-client/bridge.js';
 import { toMcpMounts } from './mcp-config.js';
 import { mcpCredentialResolver } from './mcp-credentials.js';
 import { SerialPassQueue, RetryScheduler } from './mount-lifecycle.js';
-import { qualifiedSuiteId } from '../catalog/paths.js';
+import { qualifiedSuiteId, suiteDataDir } from '../catalog/paths.js';
+import { redactErrorMessage } from './mcp-redaction.js';
 export class McpMountRegistry {
     ctx;
     pluginDataRoot;
@@ -178,6 +180,16 @@ export class McpMountRegistry {
     }
     /** Mount one precomputed request (source config merged with overrides). */
     async mountWith(request) {
+        // §9.1: the client-managed PLUGIN_DATA directory must exist and be
+        // writable before any plugin subprocess starts. Created recursively and
+        // idempotently on every mount so an uninstalled-then-reinstalled suite
+        // starts over with a fresh directory while an update keeps its contents.
+        if (request.config.transport === 'stdio') {
+            const separator = request.suiteId.indexOf('/');
+            const sourceId = separator === -1 ? request.suiteId : request.suiteId.slice(0, separator);
+            const suiteId = separator === -1 ? request.suiteId : request.suiteId.slice(separator + 1);
+            await mkdir(suiteDataDir(this.pluginDataRoot, sourceId, suiteId), { recursive: true });
+        }
         const owner = this.serverOwner(request.config.serverName);
         if (owner !== undefined) {
             // Two sources shipping the same suite/server pair derive one serverName:
@@ -251,7 +263,7 @@ export class McpMountRegistry {
                     // Ignore teardown errors: the startup failure is the real signal.
                 }
             }
-            return { reason: `mount failed: ${error instanceof Error ? error.message : String(error)}`, code: 'mount-failed' };
+            return { reason: `mount failed: ${redactErrorMessage(error instanceof Error ? error.message : String(error))}`, code: 'mount-failed' };
         }
         this.live.set(mountKey(request.suiteId, request.serverKey), {
             suiteId: request.suiteId,
@@ -271,7 +283,7 @@ export class McpMountRegistry {
             return undefined;
         }
         catch (error) {
-            const reason = `unmount failed: ${error instanceof Error ? error.message : String(error)}`;
+            const reason = `unmount failed: ${redactErrorMessage(error instanceof Error ? error.message : String(error))}`;
             this.ctx.logger?.warn(`[dsh-agent-plugins-market] ${reason} (${live.suiteId}/${live.serverKey})`);
             return reason;
         }

package/lib/runtime/mcp-overrides.js

@@ -15,6 +15,8 @@ import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { writeFileAtomic } from '@deepseek-ai/dsh-atomic-write';
 import { isSensitiveKey } from './mcp-redaction.js';
+/** The largest timeout a bridge config and the host timer can hold. */
+export const MAX_TIMEOUT_MS = 2_147_483_647;
 /** The overrides directory under the plugin data root. */
 export function overridesDir(dataRoot) {
     return join(dataRoot, 'overrides');
@@ -69,11 +71,41 @@ export function sanitizeOverrides(raw) {
         if (Array.isArray(record['args']) && record['args'].every(entry => typeof entry === 'string')) {
             override.args = record['args'];
         }
+        const toolCallTimeoutMs = timeoutMs(record['toolCallTimeoutMs']);
+        if (toolCallTimeoutMs !== undefined)
+            override.toolCallTimeoutMs = toolCallTimeoutMs;
+        const startupTimeoutMs = timeoutMs(record['startupTimeoutMs']);
+        if (startupTimeoutMs !== undefined)
+            override.startupTimeoutMs = startupTimeoutMs;
+        const disabledTools = toolNames(record['disabledTools']);
+        if (disabledTools !== undefined)
+            override.disabledTools = disabledTools;
         if (Object.keys(override).length > 0)
             result[serverKey] = override;
     }
     return result;
 }
+/**
+ * Keep a timeout that a millisecond count can hold. Anything else passes
+ * nothing through, so one malformed field cannot take the rest of the record
+ * with it.
+ */
+function timeoutMs(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw <= 0 || raw > MAX_TIMEOUT_MS)
+        return undefined;
+    return raw;
+}
+/**
+ * Keep a tool-name list for a deny list: non-empty names, deduplicated, with
+ * the empty result reading as "nothing denied" so the field never persists as
+ * an empty array.
+ */
+function toolNames(raw) {
+    if (!Array.isArray(raw))
+        return undefined;
+    const names = [...new Set(raw.filter((entry) => typeof entry === 'string' && entry !== ''))];
+    return names.length > 0 ? names : undefined;
+}
 /** Keep a well-formed auth block; anything else passes nothing through. */
 function sanitizeAuth(raw) {
     if (typeof raw !== 'object' || raw === null)
@@ -94,6 +126,69 @@ export function sanitizeOverridePatch(patch) {
         return undefined;
     return sanitizeOverrides({ server: patch })['server'];
 }
+/**
+ * Validate one policy save as it arrives over the wire. An absent field leaves
+ * its stored value alone, `null` clears one back to inheritance, and a positive
+ * whole number of milliseconds within the timer range sets it; anything else
+ * rejects the save with a readable reason.
+ */
+export function parseTimeoutPatch(raw) {
+    if (raw === undefined)
+        return {};
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw new Error('policy must be an object');
+    const record = raw;
+    return {
+        ...(record['toolCallTimeoutMs'] === undefined ? {} : { toolCallTimeoutMs: timeoutField(record['toolCallTimeoutMs'], 'tool call timeout') }),
+        ...(record['startupTimeoutMs'] === undefined ? {} : { startupTimeoutMs: timeoutField(record['startupTimeoutMs'], 'startup timeout') })
+    };
+}
+/**
+ * Validate a client-supplied policy patch. An absent field keeps its stored
+ * value, `null` clears it back to the suite's declaration or the default, and
+ * any other shape is rejected with the reason it failed.
+ */
+export function parseMcpPolicyPatch(raw) {
+    if (raw === undefined)
+        return {};
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
+        throw new Error('policy must be an object');
+    const record = raw;
+    const patch = {};
+    if (record['toolCallTimeoutMs'] !== undefined)
+        patch.toolCallTimeoutMs = timeoutField(record['toolCallTimeoutMs'], 'tool call timeout');
+    if (record['startupTimeoutMs'] !== undefined)
+        patch.startupTimeoutMs = timeoutField(record['startupTimeoutMs'], 'startup timeout');
+    if (record['disabledTools'] !== undefined) {
+        if (record['disabledTools'] === null)
+            patch.disabledTools = null;
+        else {
+            const names = toolNames(record['disabledTools']);
+            if (names === undefined && record['disabledTools'].length > 0)
+                throw new Error('denied tools must be a list of tool names');
+            patch.disabledTools = names ?? [];
+        }
+    }
+    if (record['auth'] !== undefined) {
+        if (record['auth'] === null)
+            patch.auth = null;
+        else {
+            const auth = sanitizeAuth(record['auth']);
+            if (auth === undefined)
+                throw new Error('auth must be an object with a boolean "enabled"');
+            patch.auth = auth;
+        }
+    }
+    return patch;
+}
+function timeoutField(value, label) {
+    if (value === null)
+        return null;
+    if (typeof value !== 'number' || !Number.isInteger(value) || value <= 0 || value > MAX_TIMEOUT_MS) {
+        throw new Error(`${label} must be a positive whole number of milliseconds no greater than ${MAX_TIMEOUT_MS}`);
+    }
+    return value;
+}
 /**
  * Merge one client patch into the override already on disk.
  *
@@ -113,7 +208,18 @@ export function mergeOverridePatch(existing, patch) {
         ...(headers === undefined ? {} : { headers }),
         ...(env === undefined ? {} : { env }),
         ...(patch.args !== undefined ? { args: patch.args } : existing.args === undefined ? {} : { args: existing.args }),
-        ...(patch.auth !== undefined ? { auth: patch.auth } : existing.auth === undefined ? {} : { auth: existing.auth })
+        ...(patch.auth !== undefined ? { auth: patch.auth } : existing.auth === undefined ? {} : { auth: existing.auth }),
+        ...(patch.toolCallTimeoutMs !== undefined
+            ? { toolCallTimeoutMs: patch.toolCallTimeoutMs }
+            : existing.toolCallTimeoutMs === undefined
+                ? {}
+                : { toolCallTimeoutMs: existing.toolCallTimeoutMs }),
+        ...(patch.startupTimeoutMs !== undefined
+            ? { startupTimeoutMs: patch.startupTimeoutMs }
+            : existing.startupTimeoutMs === undefined
+                ? {}
+                : { startupTimeoutMs: existing.startupTimeoutMs }),
+        ...(patch.disabledTools !== undefined ? { disabledTools: patch.disabledTools } : existing.disabledTools === undefined ? {} : { disabledTools: existing.disabledTools })
     };
 }
 function mergeStringMap(existing, patch) {
@@ -156,22 +262,46 @@ function stringMap(value) {
 export function applyOverride(server, override) {
     if (override === undefined)
         return server;
+    const policy = policyFields(override);
     if (override.config !== undefined)
         server = override.config;
     if (server.type === 'stdio') {
         return {
             ...server,
+            ...policy,
             ...(override.args !== undefined ? { args: override.args } : {}),
             ...(override.env !== undefined ? { env: override.env } : {})
         };
     }
     return {
         ...server,
+        ...policy,
         ...(override.url !== undefined ? { url: override.url } : {}),
         ...(override.headers !== undefined ? { headers: override.headers } : {}),
         ...(override.auth !== undefined ? { auth: override.auth } : {})
     };
 }
+/** The user-owned policy fields of one override, in server shape. */
+function policyFields(override) {
+    return {
+        ...(override.toolCallTimeoutMs === undefined ? {} : { toolCallTimeoutMs: override.toolCallTimeoutMs }),
+        ...(override.startupTimeoutMs === undefined ? {} : { startupTimeoutMs: override.startupTimeoutMs }),
+        ...(override.disabledTools === undefined ? {} : { disabledTools: override.disabledTools })
+    };
+}
+/**
+ * One server with its client policy fields removed: the shape the portable
+ * `mcp.json` schema accepts. The service editor renders and saves this shape,
+ * so a timeout never reaches a document that has no seat for it.
+ */
+export function withoutPolicyFields(server) {
+    const portable = { ...server };
+    delete portable['enabledTools'];
+    delete portable['disabledTools'];
+    delete portable['startupTimeoutMs'];
+    delete portable['toolCallTimeoutMs'];
+    return portable;
+}
 function sanitizeFileName(raw) {
     return raw.replace(/[^A-Za-z0-9_-]+/g, '_');
 }

package/lib/runtime/mcp-redaction.js

@@ -45,6 +45,14 @@ export function redactUrl(raw) {
         .join('&');
     return safeQuery === '' ? base : `${base}?${safeQuery}`;
 }
+/**
+ * Redact every URL embedded in an error message before the message reaches a
+ * log line or a diagnostic: connection failures echo the server's endpoint,
+ * and endpoints carry credential-bearing queries.
+ */
+export function redactErrorMessage(raw) {
+    return raw.replace(/https?:\/\/[^\s"'<>]+/gi, value => redactUrl(value));
+}
 function splitOnce(value, separator) {
     const index = value.indexOf(separator);
     if (index === -1)

package/lib/runtime/mcp-status.js

@@ -28,7 +28,7 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
         if (suite.mcp === undefined || suite.installedAt === undefined || !suite.enabled)
             continue;
         const suiteKey = qualifiedSuiteId(suite.sourceId, suite.id);
-        for (const { serverKey, server: effective, override, enabled, credentialRefs: refs } of effectiveMcpServers(suite, overrides.get(suiteKey))) {
+        for (const { serverKey, server: effective, override, enabled, credentialRefs: refs, policy } of effectiveMcpServers(suite, overrides.get(suiteKey))) {
             const serverName = deriveServerName(suite.id, serverKey);
             const tools = observedByServer.get(serverName) ?? [];
             claimedServers.add(serverName);
@@ -69,10 +69,13 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
                 transport: effective.type,
                 endpoint: endpointOf(effective),
                 config: redactMcpConfig(effective),
-                tools: disabled && !orphaned ? [] : tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) })),
+                tools: disabled && !orphaned ? [] : observedTools(tools),
                 advertisedTools: tools.length > 0,
                 retryable: diagnostic?.code === 'mount-failed' || diagnostic?.code === 'unmount-failed',
                 ...(effective.type === 'stdio' || effective.auth !== undefined ? {} : { oauthDefault: true }),
+                ...(policy.enabledTools === undefined ? {} : { suiteEnabledTools: policy.enabledTools }),
+                ...(policy.suiteDisabledTools === undefined ? {} : { suiteDisabledTools: policy.suiteDisabledTools }),
+                ...(override?.disabledTools === undefined ? {} : { userDisabledTools: override.disabledTools }),
                 ...(diagnostic?.code === undefined ? {} : { code: diagnostic.code }),
                 ...(reason === undefined ? {} : { reason }),
                 ...(credentialRefs.length === 0 ? {} : { credentialRefs })
@@ -97,7 +100,7 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
                 transport: stale.server.type,
                 endpoint: endpointOf(stale.server),
                 config: redactMcpConfig(stale.server),
-                tools: tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) })),
+                tools: observedTools(tools),
                 reason: 'MCP tools remain after this plugin was disabled or uninstalled',
                 ...(staleRefs.length === 0 ? {} : { credentialRefs: staleRefs })
             });
@@ -109,7 +112,7 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
             kind: 'direct',
             state: 'connected',
             transport: 'observed',
-            tools: tools.map(tool => ({ name: tool.name, ...(tool.description === undefined ? {} : { description: tool.description }) }))
+            tools: observedTools(tools)
         });
     }
     const totals = {
@@ -124,6 +127,15 @@ export function buildMcpStatus(suites, diagnostics, observed, overrides = new Ma
     };
     return { entries, observedAt: new Date().toISOString(), totals, directObservationOnly: true };
 }
+/** One tool projection for the status wire: the input schema rides along only while it stays small. */
+const MAX_SCHEMA_CHARS = 20_000;
+function observedTools(tools) {
+    return tools.map(tool => ({
+        name: tool.name,
+        ...(tool.description === undefined ? {} : { description: tool.description }),
+        ...(tool.parameters === undefined || JSON.stringify(tool.parameters).length > MAX_SCHEMA_CHARS ? {} : { parameters: tool.parameters })
+    }));
+}
 function groupObservedTools(observed, knownServerNames) {
     const grouped = new Map();
     for (const tool of observed) {
@@ -150,7 +162,11 @@ function groupObservedTools(observed, knownServerNames) {
         if (serverName === undefined || rawName === undefined || rawName === '')
             continue;
         const list = grouped.get(serverName) ?? [];
-        list.push({ name: rawName, ...(tool.description === undefined ? {} : { description: tool.description }) });
+        list.push({
+            name: rawName,
+            ...(tool.description === undefined ? {} : { description: tool.description }),
+            ...(tool.parameters === undefined ? {} : { parameters: tool.parameters })
+        });
         grouped.set(serverName, list);
     }
     return grouped;

package/lib/runtime/project-runtime.js

@@ -1,12 +1,14 @@
 import { CommandMountRegistry } from './commands-mounts.js';
+import { expandPluginPaths, pluginRootOf } from '../catalog/plugin-variables.js';
+import { suiteDataDir } from '../catalog/paths.js';
 import { McpMountRegistry } from './mcp-mounts.js';
 import { HooksMountRegistry } from './hooks-mounts.js';
 import { readFile } from 'node:fs/promises';
 import { stripFrontmatter } from '../catalog/skills-parse.js';
 import { parseFrontmatterRecord } from './user-store.js';
 /** Mount under existing and newly created agents; the caller owns refresh and teardown. */
-export function mountProjectCommands(ctx, catalog, t) {
-    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t));
+export function mountProjectCommands(ctx, catalog, t, dataRoot) {
+    return mountProjectSurface(ctx, catalog, 'commands', scope => new CommandMountRegistry(scope, t, dataRoot));
 }
 /** MCP uses a separate injected child so network startup cannot delay local commands. */
 export function mountProjectMcp(ctx, catalog, dataRoot) {
@@ -21,14 +23,18 @@ export function mountProjectHooks(ctx, catalog) {
     return mountProjectSurface(ctx, catalog, ['shell', 'sessionProjections'], scope => new HooksMountRegistry(scope));
 }
 /** Kimi's startup skill and system-prompt declarations use the existing scoped prompt service. */
-export function mountSuiteInstructions(ctx, catalog) {
-    return mountProjectSurface(ctx, catalog, 'systemPrompt', scope => {
+export function mountSuiteInstructions(ctx, catalog, dataRoot) {
+    return mountProjectSurface(ctx, catalog, 'systemPrompt', (scope, agent) => {
         let text = '';
         const host = scope;
         const dispose = host.systemPrompt.section({ name: 'agent-plugins:instructions', order: 500, text: () => text });
         return {
             async reconcile(projectSuites) {
-                const result = await suiteInstructions([...(await catalog.enabledUserSuites()), ...projectSuites]);
+                const projectDir = agent.session.header.cwd;
+                const result = await suiteInstructions([...(await catalog.enabledUserSuites()), ...projectSuites], {
+                    ...(dataRoot === undefined ? {} : { dataRoot }),
+                    ...(projectDir === undefined ? {} : { projectDir })
+                });
                 text = result.text;
                 return result.errors;
             },
@@ -39,14 +45,22 @@ export function mountSuiteInstructions(ctx, catalog) {
         };
     }, true);
 }
-export async function suiteInstructions(suites) {
+export async function suiteInstructions(suites, paths = {}) {
     const chunks = [];
     const errors = [];
     for (const suite of suites) {
         if (!suite.enabled || suite.activeSurfaces.skills === false)
             continue;
+        // Startup instructions are author-written suite text like any other
+        // surface: the paths they name have to resolve before the model reads them.
+        const root = pluginRootOf(suite);
+        const context = {
+            ...(root === undefined ? {} : { root, ...(paths.dataRoot === undefined ? {} : { data: suiteDataDir(paths.dataRoot, suite.sourceId, suite.id) }) }),
+            ...(paths.projectDir === undefined ? {} : { projectDir: paths.projectDir })
+        };
+        const expand = (text) => expandPluginPaths(text, context);
         if (suite.systemPrompt !== undefined)
-            chunks.push(suite.systemPrompt);
+            chunks.push(expand(suite.systemPrompt));
         if (suite.manifest.startupSkill === undefined)
             continue;
         const skill = suite.skills.find(skill => skill.name === suite.manifest.startupSkill);
@@ -58,9 +72,9 @@ export async function suiteInstructions(suites) {
             const content = await readFile(skill.file, 'utf8');
             if (parseFrontmatterRecord(content).disabled === true)
                 continue;
-            chunks.push(stripFrontmatter(content));
+            chunks.push(expand(stripFrontmatter(content)));
             if (suite.manifest.skillInstructions !== undefined)
-                chunks.push(suite.manifest.skillInstructions);
+                chunks.push(expand(suite.manifest.skillInstructions));
         }
         catch {
             errors.push({ suiteId: `${suite.sourceId}/${suite.id}`, reason: `startup skill ${skill.name} is unreadable` });

package/lib/runtime/reconcile-scheduler.js

@@ -1,3 +1,4 @@
+import { coalesce } from './timer-seat.js';
 /** Credential updates are batched for this long before one reconcile runs. */
 const CREDENTIAL_DEBOUNCE_MS = 150;
 export class ReconcileScheduler {
@@ -15,13 +16,13 @@ export class ReconcileScheduler {
         this.runtime = runtime;
         this.host = host;
         const eventHost = ctx;
+        // One reconcile per burst of credential updates: the host fires one event
+        // per reference, and every mount that reads them must see the whole set.
+        this.credentialFlush = coalesce(ctx, () => this.flushCredentialUpdates(), CREDENTIAL_DEBOUNCE_MS);
         this.releaseCredentialUpdates =
             eventHost.on?.('credentials/reference-updated', ref => {
                 this.pendingCredentialRefs.add(ref);
-                if (this.credentialFlush !== undefined)
-                    clearTimeout(this.credentialFlush);
-                this.credentialFlush = setTimeout(() => this.flushCredentialUpdates(), CREDENTIAL_DEBOUNCE_MS);
-                this.credentialFlush.unref?.();
+                this.credentialFlush();
             }) ?? (() => { });
     }
     /** Reconcile now, joining the pass in flight and remembering one follow-up for it. */
@@ -46,9 +47,7 @@ export class ReconcileScheduler {
     dispose() {
         this.disposed = true;
         this.releaseCredentialUpdates();
-        if (this.credentialFlush !== undefined)
-            clearTimeout(this.credentialFlush);
-        this.credentialFlush = undefined;
+        this.credentialFlush.dispose();
         this.pendingCredentialRefs.clear();
     }
     async reconcileOnce() {
@@ -86,7 +85,6 @@ export class ReconcileScheduler {
      * mid-reconcile is never dropped.
      */
     flushCredentialUpdates() {
-        this.credentialFlush = undefined;
         const refs = [...this.pendingCredentialRefs];
         this.pendingCredentialRefs.clear();
         // Re-read the catalog first: an unknown ref means the snapshot predates

package/lib/runtime/reconciler.js

@@ -12,9 +12,10 @@ export class RuntimeReconciler {
     disposed = false;
     constructor(ctx, dataRoot, t = bindHostLocale(undefined)) {
         this.mcp = new McpMountRegistry(ctx, dataRoot);
-        this.commands = new CommandMountRegistry(ctx, t);
+        this.commands = new CommandMountRegistry(ctx, t, dataRoot);
         this.hooks = new HooksMountRegistry(ctx);
         this.lspRegistry = new LspMountRegistry(ctx);
+        this.lspRegistry.setPluginDataRoot(dataRoot);
     }
     /** The LSP mount registry, consumed by the LSP status surface. */
     get lsp() {

package/lib/runtime/regions.js

@@ -1,24 +1,5 @@
-/**
- * Download regions for GitHub acquisition, modeled on dshmarket's regions.js:
- * one setting answers "where are you" instead of a row of mirror toggles.
- *
- * The China route proxies github.com clones through a public prefix proxy —
- * `git clone https://gh-proxy.com/https://github.com/owner/repo` — rather
- * than rewriting the hostname, which is what lets one prefix cover clone,
- * fetch, and release downloads without a mapping table per service. Public
- * proxies come and go, so the route carries an environment escape hatch
- * (`DSH_MARKET_GITHUB_PROXY`), and the region itself is a setting the user
- * can flip at any time; sources already cloned keep their proxied origin and
- * follow it on refresh.
- *
- * @module runtime/regions
- */
 /** The China-route GitHub prefix proxy, no trailing slash. */
 const DEFAULT_GITHUB_PROXY = 'https://gh-proxy.com';
-/** Narrow an untrusted stored value to a setting; anything else reads as auto. */
-export function narrowDownloadRegion(value) {
-    return value === 'global' || value === 'china' ? value : 'auto';
-}
 /**
  * Resolve the effective region: an explicit choice wins; `auto` follows the
  * interface language — a Chinese-language user defaults to the China route.

package/lib/runtime/server-config.js

@@ -5,6 +5,24 @@ import { MCP_SCHEMA_ID, validateAgainstSchema, validateMcpJson } from '../catalo
 import { parseLspServers } from '../catalog/lsp-spec.js';
 import { qualifiedSuiteId } from '../catalog/paths.js';
 import { redactMcpConfig } from './mcp-redaction.js';
+/**
+ * The errors the closed-set package shape produces. A user-owned service does
+ * not obey that shape, and the per-transport checks still require what it needs.
+ */
+const PACKAGE_SHAPE_KEYWORDS = new Set(['additionalProperties', 'oneOf', 'required', 'const']);
+/**
+ * A rejected MCP configuration. The message keeps the flat form the API has
+ * always returned, and `fields` carries the same reasons keyed by field so the
+ * editor can put each one beside its input.
+ */
+export class McpConfigError extends Error {
+    fields;
+    constructor(fields) {
+        super(`invalid MCP configuration: ${fields.map(entry => (entry.field === '' ? entry.message : `${entry.field} ${entry.message}`)).join('; ')}`);
+        this.fields = fields;
+        this.name = 'McpConfigError';
+    }
+}
 /** Restore only unchanged redacted leaves, rejecting invented masked values. */
 export function restoreRedactedConfig(input, original, redacted = redactMcpConfig(original)) {
     if (typeof input === 'string' && input.includes('[redacted]')) {
@@ -21,15 +39,38 @@ export function restoreRedactedConfig(input, original, redacted = redactMcpConfi
     }
     return input;
 }
-export async function validateServerMcp(root, key, config) {
+/**
+ * Validate one service definition before it is stored.
+ *
+ * A service the user declared themselves is local data rather than a
+ * distributable package: keys this client does not know are kept as written
+ * instead of being rejected by the closed-set package schema, and the
+ * package-only rules (bare command names, plugin-relative paths) stay off.
+ */
+export async function validateServerMcp(root, key, config, options) {
+    const userOwned = options?.userOwned === true;
     const document = { $schema: MCP_SCHEMA_ID, mcpServers: { [key]: config } };
-    const errors = await validateAgainstSchema(MCP_SCHEMA_ID, document);
-    if (errors.length > 0)
-        throw new Error(`invalid MCP configuration: ${errors.join('; ')}`);
-    const result = await validateMcpJson(root, document);
-    const server = result.config?.servers[key];
-    if (server === undefined || result.errors.length > 0)
-        throw new Error(`invalid MCP configuration: ${result.errors.join('; ')}`);
+    // A JSON pointer needs its own escapes so a server key containing `/` or `~`
+    // still yields the right prefix for the field paths below.
+    const pointer = `/mcpServers/${key.replaceAll('~', '~0').replaceAll('/', '~1')}`;
+    const structural = (await validateAgainstSchema(MCP_SCHEMA_ID, document))
+        .filter(error => error.instancePath === pointer || error.instancePath.startsWith(`${pointer}/`))
+        // The closed-set package shape reports `additionalProperties` plus the
+        // `oneOf`/`required` pair its failure produces; user-owned data does not
+        // obey it, and the per-transport checks below still require what it needs.
+        .filter(error => !(userOwned && PACKAGE_SHAPE_KEYWORDS.has(error.keyword)))
+        .map(error => ({
+        field: error.instancePath.slice(pointer.length).replace(/^\//, '').replaceAll('/', '.'),
+        message: error.message
+    }));
+    if (structural.length > 0)
+        throw new McpConfigError(structural);
+    const result = await validateMcpJson(root, document, userOwned ? { packageRules: false } : undefined);
+    if (result.config === undefined || result.errors.length > 0)
+        throw new McpConfigError(result.errors.map(message => ({ field: '', message })));
+    const server = result.config.servers[key];
+    if (server === undefined)
+        throw new McpConfigError([{ field: '', message: `server "${key}" was rejected` }]);
     return server;
 }
 export function validateServerLsp(key, config) {

package/lib/runtime/settings-namespace.js

@@ -1,6 +1,6 @@
+import { MARKET_SETTINGS_NAMESPACE, resolveMarketSettings } from '../contracts/settings.js';
 import { FEEDBACK_TOOL_NAME, mountFeedbackTool } from './feedback-tool.js';
-import { MCP_SETTINGS_NAMESPACE, MarketSettingsSchema, readMcpBackend } from './mcp-backend.js';
-import { narrowDownloadRegion } from './regions.js';
+import { MarketSettingsSchema, readMcpBackend } from './mcp-backend.js';
 export class MarketSettingsNamespace {
     ctx;
     dataRoot;
@@ -28,7 +28,7 @@ export class MarketSettingsNamespace {
     }
     /** The persisted MCP backend choice; the built-in client until registration lands. */
     async backend() {
-        return this.scope !== undefined && this.scope.get().mcpEnhanced === false ? 'host' : 'builtin';
+        return this.settings().mcpEnhanced ? 'builtin' : 'host';
     }
     /**
      * Persist a backend choice.
@@ -41,7 +41,17 @@ export class MarketSettingsNamespace {
     }
     /** The persisted download-region setting. */
     async downloadRegion() {
-        return narrowDownloadRegion(this.scope?.get().downloadRegion);
+        return this.settings().downloadRegion;
+    }
+    /**
+     * The resolved settings, whether or not the namespace is registered yet.
+     *
+     * Every reader goes through here so "the field is absent" has exactly one
+     * answer — {@link resolveMarketSettings} — instead of each caller inventing
+     * its own fallback for the window before registration lands.
+     */
+    settings() {
+        return resolveMarketSettings(this.scope?.get());
     }
     /** Release every watcher and unmount the feedback tool. */
     dispose() {
@@ -54,9 +64,7 @@ export class MarketSettingsNamespace {
         try {
             this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings inject resolved — registering namespace');
             const settings = settingsCtx.settings;
-            const scope = settings.register(MCP_SETTINGS_NAMESPACE, MarketSettingsSchema, {
-                base: { mcpEnhanced: true, downloadRegion: 'auto', feedbackEnabled: true, scanProjectLayouts: false }
-            });
+            const scope = settings.register(MARKET_SETTINGS_NAMESPACE, MarketSettingsSchema);
             this.scope = scope;
             this.ctx.logger?.info?.('[dsh-agent-plugins-market] settings namespace registered — plugin-config card will serve');
             this.syncProjectLayouts();
@@ -68,9 +76,9 @@ export class MarketSettingsNamespace {
                 if (backend === 'host')
                     void scope.update({ mcpEnhanced: false }).catch(() => { });
             });
-            let previousBackend = scope.get().mcpEnhanced !== false;
+            let previousBackend = this.settings().mcpEnhanced;
             this.watchers.push(scope.watch(() => {
-                const backend = scope.get().mcpEnhanced !== false;
+                const backend = this.settings().mcpEnhanced;
                 if (backend === previousBackend)
                     return;
                 previousBackend = backend;
@@ -89,23 +97,23 @@ export class MarketSettingsNamespace {
             this.ctx.logger?.error?.(`[dsh-agent-plugins-market] settings namespace registration failed — the plugin-config card will be hidden this boot: ${error instanceof Error ? (error.stack ?? error.message) : String(error)}`);
         }
     }
-    /** Apply the background source-update switch; OFF is the default. */
+    /** Apply the background source-update switch. */
     syncAutoUpdateSources() {
         try {
-            this.host.setAutoUpdateSources(this.scope?.get().autoUpdateSources === true);
+            this.host.setAutoUpdateSources(this.settings().autoUpdateSources);
         }
         catch (error) {
             this.ctx.logger?.error?.(`[dsh-agent-plugins-market] background source update switch failed: ${String(error)}`);
         }
     }
     syncProjectLayouts() {
-        void this.host.setScanProjectLayouts(this.scope?.get().scanProjectLayouts === true).catch(error => {
+        void this.host.setScanProjectLayouts(this.settings().scanProjectLayouts).catch(error => {
             this.ctx.logger?.error?.(`[dsh-agent-plugins-market] project layout reconciliation failed: ${String(error)}`);
         });
     }
     syncFeedbackTool() {
         try {
-            const wanted = this.scope?.get().feedbackEnabled !== false;
+            const wanted = this.settings().feedbackEnabled;
             if (!wanted) {
                 if (this.feedbackDisposer !== undefined) {
                     this.feedbackDisposer();