dsh-agent-plugins-market 0.7.0 → 0.7.2

package/lib/catalog/surfaces.js

@@ -10,10 +10,10 @@
  * thrown discovery.
  */
 import { readFile, readdir, stat } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
+import { dirname, join, relative } from 'node:path';
 import { parseSkillFrontmatter } from './skills-parse.js';
 import { isDirectory, isFile, listChildDirs } from './fs-probes.js';
-import { validateMcpJson } from './validate.js';
+import { validateMcpJson, pathContainmentError, recognizedSpecVersion } from './validate.js';
 import { readManifest } from './manifests.js';
 import { componentDocuments, componentPath, firstComponentFile, isUnknownArray } from './component-files.js';
 /**
@@ -38,16 +38,29 @@ async function declaredSkillDirs(root, declared, errors) {
     }
     return dirs;
 }
-/** Discover SKILL.md files under the suite's skills directory, up to 3 levels deep. */
-export async function discoverSkills(root, errors, declared) {
+/**
+ * Discover SKILL.md files under the suite's skills directory, up to 3 levels
+ * deep. Portable v1 suites (§7.1) instead discover exactly one level of
+ * `skills/` subdirectories each carrying a `SKILL.md` — the spec forbids
+ * recursive deeper search and root-level or flat skill files are outside the
+ * portable discovery shape.
+ */
+export async function discoverSkills(root, errors, declared, portable = false) {
     const skills = [];
-    const rootSkill = join(root, 'SKILL.md');
-    const rootName = root.split(/[\\/]/).at(-1) ?? 'plugin';
-    const rootParsed = await parseOneSkill(rootSkill, root, rootName, errors);
-    if (rootParsed !== undefined)
-        skills.push(rootParsed);
     const skillsDirs = await declaredSkillDirs(root, declared, errors);
-    if (declared === undefined) {
+    if (!portable) {
+        const rootSkill = join(root, 'SKILL.md');
+        const rootName = root.split(/[\\/]/).at(-1) ?? 'plugin';
+        const rootParsed = await parseOneSkill(rootSkill, root, rootName, errors);
+        if (rootParsed !== undefined)
+            skills.push(rootParsed);
+        if (declared === undefined) {
+            const fallback = join(root, 'skills');
+            if (await isDirectory(fallback))
+                skillsDirs.push(fallback);
+        }
+    }
+    else if (declared === undefined) {
         const fallback = join(root, 'skills');
         if (await isDirectory(fallback))
             skillsDirs.push(fallback);
@@ -60,6 +73,25 @@ export async function discoverSkills(root, errors, declared) {
         skills.push(skill);
     };
     for (const skillsDir of skillsDirs) {
+        if (portable) {
+            // §7.1: each immediate child directory containing `SKILL.md` is one
+            // skill; no deeper descendants are searched and flat files are not
+            // skills. Each candidate also passes a realpath containment check so a
+            // symlink pointing outside the plugin root is skipped (§4.1 boundary 3).
+            for (const child of await listChildDirs(skillsDir)) {
+                const skillFile = join(child, 'SKILL.md');
+                if (!(await isFile(skillFile)))
+                    continue;
+                const reason = await pathContainmentError(root, `./${relative(root, skillFile).replace(/\\/g, '/')}`);
+                if (reason !== undefined) {
+                    errors.push(`skill "${child.split(/[\\/]/).at(-1) ?? ''}": ${reason}`);
+                    continue;
+                }
+                const name = child.split(/[\\/]/).at(-1) ?? '';
+                pushUnique(await parseOneSkill(skillFile, child, name, errors));
+            }
+            continue;
+        }
         if (await isFile(skillsDir)) {
             pushUnique(await parseOneSkill(skillsDir, dirname(skillsDir), '', errors));
             continue;
@@ -145,23 +177,34 @@ async function parseOneSkill(file, directory, fallbackName, errors) {
     }
     return { ...verdict, directory };
 }
-/** Read the suite's MCP config: `mcp.json` or `.mcp.json`, else the winning manifest's inline `mcpServers`. */
-export async function discoverMcp(root, errors, manifest) {
+/**
+ * Read the suite's MCP config: `mcp.json` or `.mcp.json`, else the winning
+ * manifest's inline `mcpServers`. Portable v1 suites read only `mcp.json` at
+ * the plugin root (§7.2.1: no alternative core path, no inline declarations).
+ */
+export async function discoverMcp(root, errors, manifest, portable = false) {
     const resolved = manifest ?? (await readManifest(root, errors, undefined));
     const layout = resolved?.layout;
-    const names = layout === 'zcode'
-        ? ['.mcp.json']
-        : layout === 'qoder'
-            ? ['.mcp.json', 'mcp.json']
-            : layout === 'github-copilot' || layout === 'universal'
-                ? ['.mcp.json', '.github/mcp.json', 'mcp.json']
-                : layout === 'codex' || layout === 'claude-code'
-                    ? ['.mcp.json', 'mcp.json']
-                    : layout === 'cursor'
-                        ? ['mcp.json']
-                        : ['mcp.json', '.mcp.json'];
-    const declared = resolved?.components?.mcpServers;
-    const fallback = layout === 'kimi' ? undefined : await firstComponentFile(root, names);
+    const names = portable
+        ? ['mcp.json']
+        : layout === 'zcode'
+            ? ['.mcp.json']
+            : layout === 'qoder'
+                ? ['.mcp.json', 'mcp.json']
+                : layout === 'github-copilot' || layout === 'universal'
+                    ? ['.mcp.json', '.github/mcp.json', 'mcp.json']
+                    : layout === 'codex' || layout === 'claude-code'
+                        ? ['.mcp.json', 'mcp.json']
+                        : layout === 'cursor'
+                            ? ['mcp.json']
+                            : ['mcp.json', '.mcp.json'];
+    const declared = portable ? undefined : resolved?.components?.mcpServers;
+    // Portable mode reads exactly the fixed location `mcp.json` (§7.2.1), so
+    // the candidate list is the location itself rather than a fallback probe.
+    // The file is optional for portable suites too — §7.2 fixes its location,
+    // not its presence — so an absent file resolves to zero servers without a
+    // diagnostic; an existing but unreadable path still fails loudly below.
+    const fallback = portable ? ((await isFile(join(root, 'mcp.json'))) ? 'mcp.json' : undefined) : layout === 'kimi' ? undefined : await firstComponentFile(root, names);
     const additive = layout === 'zcode' || layout === 'claude-code';
     const values = declared === undefined
         ? fallback === undefined
@@ -177,8 +220,11 @@ export async function discoverMcp(root, errors, manifest) {
     let schema = '';
     for (const document of documents) {
         const isBareFile = document.path === join(root, 'mcp.json');
-        const strict = isBareFile && (layout === 'agent-plugin-v1' || (declared === undefined && layout !== 'cursor' && layout !== 'qoder'));
-        const result = await validateMcpJson(root, document.value, { strict });
+        const strict = portable || (isBareFile && (layout === 'agent-plugin-v1' || (declared === undefined && layout !== 'cursor' && layout !== 'qoder')));
+        const result = await validateMcpJson(root, document.value, {
+            strict,
+            ...(portable && resolved?.schemaVersion !== undefined ? { manifestVersion: recognizedSpecVersion(resolved.schemaVersion)?.version } : {})
+        });
         errors.push(...result.errors);
         if (result.config === undefined)
             return undefined;

package/lib/catalog/validate.js

@@ -1,12 +1,17 @@
 /**
- * agent-plugins.org v1.0.0 validation: vendored JSON Schemas plus the
- * specification's semantic filesystem rules.
+ * agent-plugins.org v1 validation: vendored JSON Schemas per supported
+ * specification version plus the specification's semantic rules.
  *
- * The schemas live under `schemas/1.0.0/` and are bundled into the package —
- * the spec forbids retrieving a schema while loading a plugin. Schema
- * validation is one failure boundary (per server / per manifest); the
- * semantic pass then enforces §4 path containment, `$schema` recognition, and
- * the `${PLUGIN_ROOT}` / `${PLUGIN_DATA}` expansion the spec makes mandatory.
+ * The schemas live under `schemas/<version>/` and are bundled into the
+ * package — the spec forbids retrieving a schema while loading a plugin
+ * (§5.2, §7.2.1). Validation follows the specification's failure boundaries:
+ * manifest unknown top-level fields and the whole `extensions` subtree are
+ * reported and ignored (§5.2, §8.1) while any other manifest violation is
+ * fatal; `mcp.json` file-level violations disable MCP for the plugin (§7.2.2
+ * rule 2) and per-server violations skip only their server (§7.2.2 rule 3).
+ * The semantic pass then enforces §4 path containment, §7.2.1 remote URL and
+ * header rules, §9.2 placeholder discipline, and the `${PLUGIN_ROOT}` /
+ * `${PLUGIN_DATA}` expansion the spec makes mandatory.
  */
 import { readFile, realpath } from 'node:fs/promises';
 import { dirname, join, resolve } from 'node:path';
@@ -16,35 +21,62 @@ import { fileURLToPath } from 'node:url';
 import Ajv2020Default from 'ajv/dist/2020.js';
 import { PLUGIN_ROOT_VARIABLES, PLUGIN_DATA_VARIABLES } from '../model/layouts.js';
 import { isWithin } from './paths.js';
-const SCHEMAS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'schemas', '1.0.0');
+const SUPPORTED_VERSIONS = [
+    { version: '1.0.0', pluginSchemaId: 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json', mcpSchemaId: 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json' },
+    // 1.1.0 is explicitly recognized as compatible: its two published schemas
+    // differ from 1.0.0 only in the version string (§5.2 allows mapping
+    // explicitly recognized compatible versions onto one implementation).
+    { version: '1.1.0', pluginSchemaId: 'https://agent-plugins.org/schemas/1.1.0/plugin.schema.json', mcpSchemaId: 'https://agent-plugins.org/schemas/1.1.0/mcp.schema.json' }
+];
+const SCHEMAS_DIR = join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'schemas');
 const Ajv2020Class = Ajv2020Default;
-export const PLUGIN_SCHEMA_ID = 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json';
-export const MCP_SCHEMA_ID = 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json';
+const BASELINE = SUPPORTED_VERSIONS[0];
+/** The canonical plugin manifest schema identifier of the baseline release. */
+export const PLUGIN_SCHEMA_ID = BASELINE.pluginSchemaId;
+/** The canonical MCP configuration schema identifier of the baseline release. */
+export const MCP_SCHEMA_ID = BASELINE.mcpSchemaId;
+/** The spec version a recognized `$schema` id selects, or undefined when unrecognized. */
+export function recognizedSpecVersion(schemaId) {
+    if (typeof schemaId !== 'string')
+        return undefined;
+    return SUPPORTED_VERSIONS.find(version => version.pluginSchemaId === schemaId || version.mcpSchemaId === schemaId);
+}
+/** Whether a `$schema` value selects a locally supported ruleset. */
+export function isRecognizedSchema(value) {
+    return recognizedSpecVersion(value) !== undefined;
+}
 let ajvPromise;
-/** Lazily build one Ajv instance holding the two vendored schemas. */
+/** Lazily build one Ajv instance holding every vendored schema. */
 async function ajv() {
     ajvPromise ??= (async () => {
-        const instance = new Ajv2020Class({ strict: false });
-        for (const name of ['plugin.schema.json', 'mcp.schema.json']) {
-            const schemaText = await readFile(join(SCHEMAS_DIR, name), 'utf8');
-            instance.addSchema(JSON.parse(schemaText));
+        const instance = new Ajv2020Class({ strict: false, allErrors: true });
+        for (const version of SUPPORTED_VERSIONS) {
+            for (const name of ['plugin.schema.json', 'mcp.schema.json']) {
+                const schemaText = await readFile(join(SCHEMAS_DIR, version.version, name), 'utf8');
+                instance.addSchema(JSON.parse(schemaText));
+            }
         }
         return instance;
     })();
     return ajvPromise;
 }
-/** Validate one JSON document against a vendored schema; errors joined for surfacing. */
+/** Validate one JSON document against a vendored schema; structured errors. */
 export async function validateAgainstSchema(schemaId, document) {
     const instance = await ajv();
     const validate = instance.getSchema(schemaId);
     if (validate === undefined)
-        return [`no bundled validator for ${schemaId}`];
+        return [{ keyword: 'schema', instancePath: '', message: `no bundled validator for ${schemaId}` }];
     validate(document);
-    return (validate.errors ?? []).map(error => `${error.instancePath === '' ? 'root' : error.instancePath} ${error.message ?? 'invalid'}`);
+    return (validate.errors ?? []).map(error => ({
+        keyword: error.keyword ?? 'schema',
+        instancePath: error.instancePath ?? '',
+        message: error.message ?? 'invalid',
+        ...(error.params === undefined ? {} : { params: error.params })
+    }));
 }
-/** Whether a `$schema` value selects the local v1.0.0 ruleset. */
-export function isRecognizedSchema(value) {
-    return value === PLUGIN_SCHEMA_ID || value === MCP_SCHEMA_ID;
+/** Render structured errors as one diagnostic string per error for surfacing. */
+export function formatSchemaErrors(errors) {
+    return errors.map(error => `${error.instancePath === '' ? 'root' : error.instancePath} ${error.message}`);
 }
 /**
  * Spec §4 containment: a plugin-relative path must begin with `./` and, after
@@ -76,39 +108,124 @@ export async function pathContainmentError(pluginRoot, value) {
     }
     return undefined;
 }
-/** Validate a plugin manifest per the vendored schema plus `$schema` recognition. */
+const EXTENSIONS_PATH = '/extensions';
+function isExtensionPath(instancePath) {
+    return instancePath === EXTENSIONS_PATH || instancePath.startsWith(`${EXTENSIONS_PATH}/`);
+}
+/** Validate a plugin manifest against its declared spec version's schema and split the verdict. */
 export async function validatePluginManifest(raw) {
-    const errors = [];
-    if (typeof raw !== 'object' || raw === null)
-        return ['manifest is not a JSON object'];
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return { fatal: [{ keyword: 'type', instancePath: '', message: 'manifest is not a JSON object' }], ignored: [] };
+    }
     const record = raw;
-    if (!isRecognizedSchema(record['$schema'])) {
-        errors.push(`unrecognized $schema ${JSON.stringify(record['$schema'])}; this manager supports agent-plugins 1.0.0 only`);
+    const version = recognizedSpecVersion(record['$schema']);
+    if (version === undefined) {
+        return {
+            fatal: [{ keyword: 'const', instancePath: '', message: `unrecognized $schema ${JSON.stringify(record['$schema'])}; supported: agent-plugins 1.0.0, 1.1.0` }],
+            ignored: []
+        };
     }
-    errors.push(...(await validateAgainstSchema(PLUGIN_SCHEMA_ID, raw)));
-    return errors;
+    const errors = await validateAgainstSchema(version.pluginSchemaId, raw);
+    const fatal = [];
+    const ignored = [];
+    for (const error of errors) {
+        if (isExtensionPath(error.instancePath))
+            ignored.push(error);
+        else if (error.keyword === 'additionalProperties' && error.instancePath === '') {
+            const name = typeof error.params?.additionalProperty === 'string' ? error.params.additionalProperty : 'unknown field';
+            ignored.push({ ...error, message: `unknown top-level field "${name}" is not part of the portable manifest; ignored` });
+        }
+        else
+            fatal.push(error);
+    }
+    return { fatal, ignored };
 }
+const KNOWN_MCP_TRANSPORTS = new Set(['stdio', 'streamable-http', 'sse']);
 /**
- * Parse and validate an `mcp.json` document: schema first, then §4 path
- * containment for `command` and `cwd` of every stdio server.
- * @returns the validated config plus per-problem strings; a failed `$schema`
- *   or schema body drops the whole file, while per-server path problems
- *   invalidate only their server.
+ * §7.2.1 remote URL rules: absolute http/https, no user information, no
+ * fragment, HTTPS everywhere except loopback hosts.
+ */
+export function remoteUrlError(value) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        return `url "${value}" is not an absolute URL`;
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        return `url "${value}" must use http or https`;
+    if (url.username !== '' || url.password !== '')
+        return `url "${value}" must not contain user information`;
+    if (url.hash !== '')
+        return `url "${value}" must not contain a fragment`;
+    if (url.protocol === 'http:') {
+        const host = url.hostname;
+        const loopback = host === 'localhost' || host === '::1' || host === '[::1]' || host.endsWith('.localhost') || /^127\.\d+\.\d+\.\d+$/.test(host);
+        if (!loopback)
+            return `url "${value}" must use https (http is allowed only for loopback)`;
+    }
+    return undefined;
+}
+/**
+ * §7.2.1 header rules: valid field names, and a duplicate name under
+ * different casing makes the entry invalid.
+ */
+export function headersError(headers) {
+    const seen = new Set();
+    for (const [name, value] of Object.entries(headers)) {
+        if (!/^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/.test(name))
+            return `header name ${JSON.stringify(name)} is not a valid HTTP header field name`;
+        if (typeof value !== 'string')
+            return `header ${JSON.stringify(name)} must have a string value`;
+        const lower = name.toLowerCase();
+        if (seen.has(lower))
+            return `header "${name}" is declared more than once under different casing`;
+        seen.add(lower);
+    }
+    return undefined;
+}
+/**
+ * Parse and validate an `mcp.json` document.
+ *
+ * Strict mode applies the two-level failure boundary of §7.2.2: a file-level
+ * violation (bad `$schema`, version mismatch with the manifest, non-object
+ * `mcpServers`) disables MCP for the whole plugin, while a per-server
+ * violation skips only that server. Lenient mode keeps the native-client
+ * behavior: no `$schema` requirement, unknown transports skipped per server.
+ *
+ * @returns the validated config plus per-problem strings; `config` stays
+ *   defined whenever at least the file shell was valid, even when some
+ *   servers were skipped.
  */
-const KNOWN_MCP_TRANSPORTS = new Set(['stdio', 'streamable-http', 'sse']);
 export async function validateMcpJson(pluginRoot, raw, options) {
     if (typeof raw !== 'object' || raw === null)
         return { errors: ['mcp.json is not a JSON object'] };
     const record = raw;
     const errors = [];
     const strict = options?.strict !== false;
+    const packageRules = strict && options?.packageRules !== false;
+    let version;
     if (strict) {
-        if (!isRecognizedSchema(record['$schema'])) {
-            return { errors: [`unrecognized mcp.json $schema ${JSON.stringify(record['$schema'])}; this manager supports agent-plugins 1.0.0 only`] };
+        version = recognizedSpecVersion(record['$schema']);
+        if (version === undefined) {
+            return { errors: [`unrecognized mcp.json $schema ${JSON.stringify(record['$schema'])}; supported: agent-plugins 1.0.0, 1.1.0`] };
         }
-        const schemaErrors = await validateAgainstSchema(MCP_SCHEMA_ID, raw);
-        if (schemaErrors.length > 0)
-            return { errors: schemaErrors };
+        if (options?.manifestVersion !== undefined && options.manifestVersion !== version.version) {
+            return {
+                errors: [
+                    `mcp.json declares agent-plugins ${version.version} while plugin.json declares ${options.manifestVersion}; the versions must match (§10.1) and MCP is disabled for this plugin`
+                ]
+            };
+        }
+        // File-level shape only: `$schema`, `mcpServers`, unknown top-level
+        // fields. Server entries are validated per server below (§7.2.2 rule 3).
+        const shellErrors = (await validateAgainstSchema(version.mcpSchemaId, raw)).filter(error => !error.instancePath.startsWith('/mcpServers/'));
+        // User-owned data may carry keys this client does not know; they ride along
+        // rather than failing the file.
+        const fatal = packageRules ? shellErrors : shellErrors.filter(error => error.keyword !== 'additionalProperties');
+        if (fatal.length > 0)
+            return { errors: formatSchemaErrors(fatal) };
     }
     // Lenient native-client files may omit the `mcpServers` wrapper and put the
     // server map at the top level (Claude Code `.mcp.json` shorthand).
@@ -125,6 +242,27 @@ export async function validateMcpJson(pluginRoot, raw, options) {
             errors.push(`server "${name}": not an object`);
             continue;
         }
+        if (strict && packageRules) {
+            // §7.2.1 exposes `#/$defs/server` so each entry can be validated
+            // independently, preserving §7.2.2 rule 3: a violation skips only its
+            // own server. Validate the bare entry against that ref directly —
+            // errors are then rooted at the entry itself (`/env`, `` for required).
+            // User-owned data goes straight to the per-transport checks below: its
+            // closed-set shape is deliberately not the package one.
+            const serverErrors = await validateAgainstSchema(`${version.mcpSchemaId}#/$defs/server`, value);
+            if (serverErrors.length > 0) {
+                const rendered = new Set();
+                for (const error of serverErrors) {
+                    if (error.keyword === 'oneOf' || error.keyword === 'required')
+                        continue;
+                    rendered.add(`${error.instancePath === '' ? '' : `${error.instancePath} `}${error.message}`);
+                }
+                if (rendered.size === 0)
+                    rendered.add('does not match any supported server variant');
+                errors.push(...[...rendered].map(problem => `server "${name}": ${problem || 'invalid server entry'}`));
+                continue;
+            }
+        }
         const server = value;
         // Claude Code dialects: `http`/`streamable-http` are the same remote
         // transport, and `local` or a missing `type` (with `command`) mean stdio.
@@ -138,6 +276,28 @@ export async function validateMcpJson(pluginRoot, raw, options) {
             continue;
         }
         if (type !== 'stdio') {
+            if (strict) {
+                if (typeof server.url !== 'string') {
+                    errors.push(`server "${name}": remote servers require a url`);
+                    continue;
+                }
+                const urlProblem = remoteUrlError(server.url);
+                if (urlProblem !== undefined) {
+                    errors.push(`server "${name}": ${urlProblem}`);
+                    continue;
+                }
+                if (server.headers !== undefined) {
+                    if (typeof server.headers !== 'object' || server.headers === null) {
+                        errors.push(`server "${name}": headers must be an object`);
+                        continue;
+                    }
+                    const headerProblem = headersError(server.headers);
+                    if (headerProblem !== undefined) {
+                        errors.push(`server "${name}": ${headerProblem}`);
+                        continue;
+                    }
+                }
+            }
             valid[name] = { ...server, type };
             continue;
         }
@@ -147,8 +307,11 @@ export async function validateMcpJson(pluginRoot, raw, options) {
             errors.push(`server "${name}": stdio servers require a command`);
             continue;
         }
+        if (packageRules && /\$\{/.test(stdioServer.command)) {
+            problems.push(`command ${JSON.stringify(stdioServer.command)} must not contain placeholders (§9.2: command is resolved as one token, not expanded)`);
+        }
         const command = stdioServer.command.replace(/^\$\{([A-Z_]+)\}\//, (match, name) => (PLUGIN_ROOT_VARIABLES.has(name) ? './' : match));
-        if (options?.pathMode !== 'project' && command.includes('/')) {
+        if (packageRules && options?.pathMode !== 'project' && command.includes('/')) {
             if (!command.startsWith('./')) {
                 problems.push(`command "${command}" must be a bare executable name or a plugin-relative path beginning with "./"`);
             }
@@ -162,7 +325,7 @@ export async function validateMcpJson(pluginRoot, raw, options) {
         if (declaredCwd !== undefined && typeof declaredCwd !== 'string') {
             problems.push('cwd must be a string');
         }
-        else if (options?.pathMode !== 'project' && declaredCwd !== undefined && ![...PLUGIN_DATA_VARIABLES].some(name => declaredCwd.startsWith(`\${${name}}`))) {
+        else if (packageRules && options?.pathMode !== 'project' && declaredCwd !== undefined && ![...PLUGIN_DATA_VARIABLES].some(name => declaredCwd.startsWith(`\${${name}}`))) {
             // `.` is the Codex dialect spelling for the plugin root.
             const cwd = declaredCwd === '.' ? './' : declaredCwd;
             const reason = await pathContainmentError(pluginRoot, cwd);
@@ -178,18 +341,6 @@ export async function validateMcpJson(pluginRoot, raw, options) {
     }
     return { config: { schema: typeof record['$schema'] === 'string' ? record['$schema'] : 'native-client', servers: valid }, errors };
 }
-/** Expand `${PLUGIN_ROOT}`, `${PLUGIN_DATA}`, and `${NAME}` (process env) in one string.
- *  Claude Code aliases `${CLAUDE_PLUGIN_ROOT}` / `${CLAUDE_PLUGIN_DATA}` and
- *  `${NAME:-default}` fallbacks are honored for unset/empty env vars. */
-export function expandPlaceholders(value, pluginRoot, pluginData, env = process.env) {
-    return value.replace(/\$\{([A-Za-z_][A-Za-z0-9_]*)(?::-([^}]*))?\}/g, (match, name, fallback) => {
-        if (PLUGIN_ROOT_VARIABLES.has(name))
-            return pluginRoot;
-        if (PLUGIN_DATA_VARIABLES.has(name))
-            return pluginData;
-        return env[name] || fallback || '';
-    });
-}
 /** Resolve an expanded plugin-relative cwd to an absolute path. */
 export function resolveCwd(value, pluginRoot, pluginData) {
     if (value.startsWith('${PLUGIN_DATA}'))

package/lib/contracts/market.js

@@ -6,6 +6,7 @@ export const MARKET_ROUTES = {
     overview: `${MARKET_API_PREFIX}overview`,
     mcpStatus: `${MARKET_API_PREFIX}mcp-status`,
     addMcpServer: `${MARKET_API_PREFIX}mcp-servers/add`,
+    importMcpServers: `${MARKET_API_PREFIX}mcp-servers/import`,
     lspStatus: `${MARKET_API_PREFIX}lsp-status`,
     lspServers: `${MARKET_API_PREFIX}lsp-servers`,
     addLspServer: `${MARKET_API_PREFIX}lsp-servers/add`,
@@ -28,6 +29,8 @@ export const MARKET_ROUTES = {
     setSurface: `${MARKET_API_PREFIX}set-surface`,
     mcpOverrides: `${MARKET_API_PREFIX}mcp-overrides`,
     setMcpOverride: `${MARKET_API_PREFIX}set-mcp-override`,
+    setMcpServerEnabled: `${MARKET_API_PREFIX}set-mcp-server-enabled`,
+    setMcpServerTool: `${MARKET_API_PREFIX}set-mcp-server-tool`,
     mcpRetry: `${MARKET_API_PREFIX}mcp-retry`,
     mcpReauthorize: `${MARKET_API_PREFIX}mcp-reauthorize`,
     mcpBackend: `${MARKET_API_PREFIX}mcp-backend`,

package/lib/contracts/settings.js

@@ -0,0 +1,63 @@
+/**
+ * Browser-safe settings contract of the market's host settings namespace: the
+ * namespace key, the fields with their defaults, and the one reader that turns
+ * a stored section into resolved values.
+ *
+ * The defaults live here and nowhere else. The namespace schema declares them
+ * to the host, the node half reads them back through {@link resolveMarketSettings},
+ * and the browser half — which cannot import `src/runtime` — reads the same
+ * resolved values off the settings snapshot it is handed. Changing a default is
+ * therefore a one-line edit in this module.
+ *
+ * @module contracts/settings
+ */
+/** Settings namespace this plugin registers; the key the plugin-config tab pairs our card by. */
+export const MARKET_SETTINGS_NAMESPACE = 'dsh-agent-plugins-market';
+/**
+ * The default of every market setting — the single place one is written.
+ *
+ * These are user-visible behavior: a flip here is a behavior change that ships
+ * with its documentation, not a private implementation detail.
+ */
+export const MARKET_SETTINGS_DEFAULTS = {
+    mcpEnhanced: true,
+    scanProjectLayouts: false,
+    downloadRegion: 'auto',
+    feedbackEnabled: true,
+    autoUpdateSources: false
+};
+/**
+ * Narrow an untrusted stored region to a setting; anything else reads as the
+ * declared default.
+ * @param value - the stored `downloadRegion` value.
+ * @param fallback - the value an unrecognized input reads as.
+ */
+export function narrowDownloadRegion(value, fallback = MARKET_SETTINGS_DEFAULTS.downloadRegion) {
+    return value === 'auto' || value === 'global' || value === 'china' ? value : fallback;
+}
+/** One boolean field: a stored boolean, else the field's default. */
+function narrowBoolean(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+/**
+ * Resolve a stored settings section the way the host resolves it: each field
+ * takes its stored value when it is one this field accepts, and its declared
+ * default otherwise.
+ *
+ * The host hands the resolved section back on its own, but not every caller has
+ * one — the plugin's own halves read a section they may not have received yet,
+ * and a test hands in a bare literal. Funnelling all of them through this
+ * function is what keeps a second reading of "what does missing mean" from
+ * growing somewhere else.
+ * @param section - the stored (or absent) namespace section, untrusted.
+ */
+export function resolveMarketSettings(section) {
+    const stored = (typeof section === 'object' && section !== null ? section : {});
+    return {
+        mcpEnhanced: narrowBoolean(stored['mcpEnhanced'], MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
+        scanProjectLayouts: narrowBoolean(stored['scanProjectLayouts'], MARKET_SETTINGS_DEFAULTS.scanProjectLayouts),
+        downloadRegion: narrowDownloadRegion(stored['downloadRegion']),
+        feedbackEnabled: narrowBoolean(stored['feedbackEnabled'], MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
+        autoUpdateSources: narrowBoolean(stored['autoUpdateSources'], MARKET_SETTINGS_DEFAULTS.autoUpdateSources)
+    };
+}