dsh-agent-plugins-market 0.7.1 → 0.7.2

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`,
@@ -29,6 +30,7 @@ export const MARKET_ROUTES = {
     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/index.js

@@ -21,6 +21,7 @@ import { createUserPanelStores } from './runtime/user-panels.js';
 import { SourceAutoUpdater } from './runtime/source-auto-update.js';
 import { UserPanelSkillProvider } from './runtime/user-panels.js';
 import { UserCommandMountRegistry } from './runtime/user-commands.js';
+import { presetSourceRef } from './model/preset-source.js';
 export const name = 'dsh-agent-plugins-market';
 export const inject = ['skills', 'commands'];
 export async function apply(ctx, config = {}) {
@@ -144,7 +145,10 @@ export async function apply(ctx, config = {}) {
     };
     const catalog = new Catalog({ userRoot, dataRoot, agentsRoot, onChanged, ports, ...(config.git === undefined ? {} : { git: config.git }) });
     await catalog.load();
-    await catalog.mergeSources(config.sources ?? []);
+    // Configured seeds first, then the record this plugin presets: the market
+    // lists the first-party collection on the first open, and the ordinary
+    // refresh path clones it. Registration performs no network access.
+    await catalog.mergeSources([...(config.sources ?? []), presetSourceRef()]);
     const resources = createPanelResources(catalog, panels);
     runtime.setMcpOverridesProvider(async () => catalog.allMcpOverrides(await catalog.enabledUserSuites()));
     runtime.lsp.setDirectProvider(async () => (await loadLspServers(agentsRoot)).servers);
@@ -184,7 +188,7 @@ export async function apply(ctx, config = {}) {
         hostCtx.effect(() => mountAgentRoleTool(hostCtx, async (parent) => [
             ...(await resources.agents.list(true)).map(entry => ({ ...entry, title: entry.name, name: entry.id ?? entry.name })),
             ...(await projectAgentRoles(catalog, parent))
-        ], (key, params) => hostLocale.t(key, params)), 'dsh-agent-plugins-market: agent role routing');
+        ]), 'dsh-agent-plugins-market: agent role routing');
     });
     ctx.inject(['agents'], hostCtx => {
         hostCtx.effect(() => {

package/lib/model/layouts.js

@@ -12,6 +12,22 @@ export const PLUGIN_LAYOUTS = [
 ];
 /** Kimi Code's primary spelling precedes its compatibility spelling within that dialect. */
 export const MANIFEST_ALIASES = { kimi: ['kimi.plugin.json'] };
+/**
+ * This client's Agent Plugins extension namespace (§8): manifest data rides
+ * `plugin.json` `extensions` under this key, and file-based extensions live
+ * in the top-level directory named exactly this. The namespace contract
+ * version is declared inside the manifest data.
+ */
+export const EXTENSION_NAMESPACE = 'com.deepseek.harness';
+/** Namespace contract versions this manager implements. */
+export const NAMESPACE_SCHEMA_VERSIONS = new Set(['1.0.0']);
+/** Namespace directory locations, relative to the plugin root. */
+export const NAMESPACE_DIR = EXTENSION_NAMESPACE;
+export const NAMESPACE_HOOKS_FILE = joinNamespace(NAMESPACE_DIR, 'hooks', 'hooks.json');
+export const NAMESPACE_LSP_FILE = joinNamespace(NAMESPACE_DIR, 'lsp.json');
+function joinNamespace(...parts) {
+    return parts.join('/');
+}
 /** Equivalent plugin-owned path variables; these never resolve as credentials. */
 export const PLUGIN_ROOT_VARIABLES = new Set(['PLUGIN_ROOT', 'CLAUDE_PLUGIN_ROOT', 'CODEX_PLUGIN_ROOT', 'ZCODE_PLUGIN_ROOT', 'QODER_PLUGIN_ROOT']);
 export const PLUGIN_DATA_VARIABLES = new Set(['PLUGIN_DATA', 'CLAUDE_PLUGIN_DATA', 'ZCODE_PLUGIN_DATA', 'QODER_PLUGIN_DATA']);
@@ -56,3 +72,21 @@ export const PROJECT_LAYOUTS = [
 ];
 /** Marketplace catalogs follow manifest layout order; the shared root catalog is the fallback. */
 export const MARKETPLACE_PATHS = [...PLUGIN_LAYOUTS.flatMap(layout => layout.marketplaces), 'marketplace.json'];
+/**
+ * Inline top-level manifest keys this manager reads for the portable v1
+ * dialect. The specification's closed manifest schema carries none of them
+ * (§5.2, §6.1), so under `agent-plugin-v1` they are reported as unknown
+ * top-level fields and ignored; every other dialect keeps reading them.
+ */
+export const V1_IGNORED_MANIFEST_KEYS = [
+    'skills',
+    'commands',
+    'agents',
+    'hooks',
+    'mcpServers',
+    'lspServers',
+    'skillInstructions',
+    'systemPrompt',
+    'systemPromptPath',
+    'sessionStart'
+];

package/lib/model/preset-source.js

@@ -0,0 +1,8 @@
+/** Source id the preset record registers under. */
+export const PRESET_SOURCE_ID = 'dsh-agent-plugins';
+/** Repository the preset record points at. */
+export const PRESET_SOURCE_URL = 'https://github.com/Sivan757/dsh-agent-plugins.git';
+/** The preset registration, as the market stores it. */
+export function presetSourceRef() {
+    return { id: PRESET_SOURCE_ID, url: PRESET_SOURCE_URL, kind: 'git' };
+}

package/lib/routes.js

@@ -39,7 +39,14 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
                         sendJson(response, 200, { ok: true, ...value });
                     }
                     catch (error) {
-                        sendJson(response, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+                        // A rejection that names its fields travels with them, so the editor
+                        // can place each reason beside the input it belongs to.
+                        const fields = error.fields;
+                        sendJson(response, 400, {
+                            ok: false,
+                            error: error instanceof Error ? error.message : String(error),
+                            ...(Array.isArray(fields) ? { fields } : {})
+                        });
                     }
                 })();
             }
@@ -77,7 +84,7 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
             throw new Error('invalid service kind');
         if (typeof body.id !== 'string' || body.id === '')
             throw new Error('missing service id');
-        await manager.saveServerConfig(body.kind, body.id, body.config);
+        await manager.saveServerConfig(body.kind, body.id, body.config, body.policy);
         return {};
     });
     post(MARKET_ROUTES.addMcpServer, async (body) => {
@@ -86,6 +93,13 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
         await manager.addMcpServer(body.name, body.config);
         return {};
     });
+    // Paste import: many services in one write. Each entry reports its own
+    // outcome, so one rejected definition never fails the whole paste.
+    post(MARKET_ROUTES.importMcpServers, async (body) => {
+        const overwrite = body['overwrite'] === true;
+        const result = await manager.importMcpServers(body['servers'], overwrite);
+        return { imported: result.imported, skipped: result.skipped };
+    });
     get(MARKET_ROUTES.lspStatus, async (_request, response) => {
         sendJson(response, 200, await manager.lspStatus());
     });
@@ -269,6 +283,21 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
         await manager.setMcpServerEnabled(suiteKey, serverKey, enabled);
         return {};
     });
+    // Allow or deny one tool of a declared MCP server. Addressed by the same
+    // source-qualified suite id the status rows carry; the denial lands in the
+    // override record, so the suite's own mcp.json stays source-owned.
+    post(MARKET_ROUTES.setMcpServerTool, async (body) => {
+        const suiteKey = textField(body['suiteId'] ?? '', 'MCP suite id');
+        const serverKey = textField(body['serverKey'] ?? '', 'MCP server key');
+        const tool = textField(body['tool'] ?? '', 'MCP tool name');
+        const enabled = body['enabled'];
+        if (tool === '')
+            throw new Error('missing MCP tool name');
+        if (typeof enabled !== 'boolean')
+            throw new Error('missing boolean enabled');
+        await manager.setMcpServerToolEnabled(suiteKey, serverKey, tool, enabled);
+        return {};
+    });
     // Manual MCP reconcile: retries failed mounts and clears residual tools
     // without touching any catalog state.
     post(MARKET_ROUTES.mcpRetry, async () => {