dsh-agent-plugins-market 0.6.2 → 0.7.0

package/lib/catalog/project-hooks.js

@@ -3,6 +3,14 @@ const EVENTS = new Set(['SessionStart', 'UserPromptSubmit', 'PreToolUse', 'PostT
 function object(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+/**
+ * Render a declared hook field inside a diagnostic. Declarations are
+ * untrusted JSON, so the value is whatever the file carried — including an
+ * object, which reads as `[object Object]` in the message.
+ */
+function declarationText(value) {
+    return String(value);
+}
 /** Merge settings layers additively, deduplicating identical event/matcher/command triples. */
 export async function discoverProjectHooks(projectRoot, files, errors, format = 'claude') {
     const documents = [];
@@ -74,7 +82,7 @@ export function normalizeHookDocuments(projectRoot, documents, errors, format =
                     if (hook.enabled === false)
                         continue;
                     if (hook.type !== undefined && hook.type !== 'command') {
-                        errors.push(`${file}: unsupported ${event} hook type ${String(hook.type)}`);
+                        errors.push(`${file}: unsupported ${event} hook type ${declarationText(hook.type)}`);
                         continue;
                     }
                     if (typeof hook.command !== 'string' ||

package/lib/catalog/scan-resolvers.js

@@ -18,18 +18,16 @@
  * 3. `FlatCollectionsStrategy` — the terminal fallback: manifest-less
  *    `<root>/<name>/SKILL.md` collections.
  */
-import { readdir, realpath, stat } from 'node:fs/promises';
+import { realpath } from 'node:fs/promises';
 import { join, resolve } from 'node:path';
-import { isDirectory, sanitizeId } from './paths.js';
-import { componentDeclarations, detectManifest, readManifest, readMarketplaces, syntheticManifestName } from './manifests.js';
+import { isWithin, sanitizeId } from './paths.js';
+import { isDirectory, isFile, listChildDirs } from './fs-probes.js';
+import { componentDeclarations, hasSuiteManifest, readManifest, readMarketplaces, syntheticManifestName } from './manifests.js';
 import { countSurfaces, discoverMcp, discoverSkills, listMdFiles } from './surfaces.js';
-import { discoverMarkdownResources } from './component-files.js';
+import { discoverMarkdownResources, isUnknownArray } from './component-files.js';
 import { discoverSuiteHooks, discoverSuiteLsp, discoverSystemPrompt } from './suite-components.js';
 import { runScanChain } from './scan-pipeline.js';
-export { repoName } from './manifests.js';
-export { listMdFiles, discoverLspEntries } from './surfaces.js';
 const CONTAINER_DIRS = ['plugins', 'external_plugins', 'skills'];
-const DOT_DIRS = new Set(['.git', '.github', '.claude', '.cursor', '.kimi', '.plugin', '.sources', 'node_modules']);
 /**
  * Canonical `https://host/owner/repo` form of a git URL, for equality
  * comparisons between a source's configured URL and an entry's remote.
@@ -75,7 +73,7 @@ export function entryRemoteUrl(entry) {
 async function claimLocal(checkout, declaredPath) {
     const dir = resolve(checkout, declaredPath);
     // Containment guard: a relative entry must stay inside the checkout.
-    if (dir !== checkout && !dir.startsWith(`${checkout}/`)) {
+    if (!isWithin(checkout, dir)) {
         // `rejected`: the handler positively identified a local path, but the
         // path escapes the checkout. Its verdict is authoritative — later
         // handlers must not reinterpret it as something else.
@@ -83,7 +81,7 @@ async function claimLocal(checkout, declaredPath) {
     }
     try {
         const [realCheckout, realDir] = await Promise.all([realpath(checkout), realpath(dir)]);
-        if (realDir !== realCheckout && !realDir.startsWith(`${realCheckout}/`)) {
+        if (!isWithin(realCheckout, realDir)) {
             return { kind: 'rejected', reason: `path "${declaredPath}" escapes the checkout through a symlink` };
         }
     }
@@ -168,8 +166,7 @@ export class MarketplaceStrategy {
                 context.notes.push(`marketplace ${marketplace.path}: no entry resolved (all ${marketplace.entries.length} dropped or remote)`);
                 continue;
             }
-            const suites = await Promise.all(roots.map(async (root) => root.dir === undefined ? remoteSuite(context.sourceId, context.dimension, root) : readSuite(root.dir, context.sourceId, context.dimension, root.hint, context.notes)));
-            const resolved = suites.filter((suite) => suite !== undefined);
+            const resolved = await readSuites(roots, context);
             if (resolved.length === 0) {
                 context.notes.push(`marketplace ${marketplace.path}: every resolved entry failed to parse a manifest`);
                 continue;
@@ -243,8 +240,7 @@ export class RootedStrategy {
         const found = await collectRoots(context.checkout, undefined, new Set());
         if (found.length === 0)
             return chain.next(context);
-        const suites = await Promise.all(found.map(async (root) => root.dir === undefined ? remoteSuite(context.sourceId, context.dimension, root) : readSuite(root.dir, context.sourceId, context.dimension, root.hint, context.notes)));
-        const resolved = suites.filter((suite) => suite !== undefined);
+        const resolved = await readSuites(found, context);
         return resolved.length === 0 ? chain.next(context) : { kind: 'resolved', suites: resolved };
     }
 }
@@ -265,8 +261,8 @@ export class FlatCollectionsStrategy {
             context.notes.push('checkout declares no recognizable plugin shape');
             return { kind: 'resolved', suites: [] };
         }
-        const suites = await Promise.all(collection.map(async (root) => root.dir === undefined ? remoteSuite(context.sourceId, context.dimension, root) : readSuite(root.dir, context.sourceId, context.dimension, root.hint, context.notes)));
-        return { kind: 'resolved', suites: suites.filter((suite) => suite !== undefined) };
+        const suites = await readSuites(collection, context);
+        return { kind: 'resolved', suites };
     }
 }
 /** The default chain, most specific first with a terminal fallback. */
@@ -276,11 +272,6 @@ export function defaultScanFilters() {
 // ---------------------------------------------------------------------------
 // Public entry points
 // ---------------------------------------------------------------------------
-/** Discover every suite under one source checkout. */
-export async function discoverSuitesInSource(checkoutDir, sourceId, dimension, sourceUrl) {
-    const result = await scanSource(checkoutDir, sourceId, dimension, sourceUrl);
-    return result.suites;
-}
 /** Scan one checkout through the filter chain with full diagnostics. */
 export async function scanSource(checkoutDir, sourceId, dimension, sourceUrl) {
     return runScanChain(defaultScanFilters(), { checkout: checkoutDir, sourceId, dimension, ...(sourceUrl !== undefined ? { sourceUrl } : {}), notes: [] });
@@ -288,6 +279,16 @@ export async function scanSource(checkoutDir, sourceId, dimension, sourceUrl) {
 // ---------------------------------------------------------------------------
 // Shared root/manifest plumbing
 // ---------------------------------------------------------------------------
+/**
+ * Materialize resolved suite roots into suites: a remote root becomes a
+ * metadata-only suite, a local root that fails to parse drops out.
+ */
+async function readSuites(roots, context) {
+    const suites = await Promise.all(roots.map(root => root.dir === undefined
+        ? Promise.resolve(remoteSuite(context.sourceId, context.dimension, root))
+        : readSuite(root.dir, context.sourceId, context.dimension, root.hint, context.notes)));
+    return suites.filter((suite) => suite !== undefined);
+}
 /**
  * Collect nested plugin roots up to four levels deep. Sibling subtrees are
  * traversed concurrently (readdir/stat are I/O-bound); results concat in
@@ -308,10 +309,6 @@ async function collectRoots(dir, hint, seen, depth = 0) {
     const nested = await Promise.all(children.map(child => collectRoots(child, hint, seen, depth + 1)));
     return nested.flat();
 }
-/** Whether a directory carries any known suite manifest. */
-export async function hasSuiteManifest(dir) {
-    return (await detectManifest(dir)) !== undefined;
-}
 /** Whether a directory carries skill files in the flat or bundled shape. */
 export async function hasSkillFiles(dir) {
     if (await isFile(join(dir, 'SKILL.md')))
@@ -327,25 +324,20 @@ export async function hasSkillFiles(dir) {
     }
     return false;
 }
-async function listChildDirs(dir) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return entries.filter(entry => entry.isDirectory() && !DOT_DIRS.has(entry.name) && !entry.name.startsWith('.')).map(entry => join(dir, entry.name));
-}
 /** Read one suite root into the normalized shape, or undefined when no manifest parses. */
 export async function readSuite(root, sourceId, dimension, hint, notes = []) {
     const errors = [];
+    const fallbacks = [];
     const declaredManifest = await hasSuiteManifest(root);
-    let manifest = declaredManifest ? await readManifest(root, errors, hint) : await syntheticManifest(root);
+    let manifest = declaredManifest ? await readManifest(root, errors, hint, fallbacks) : await syntheticManifest(root);
     if (declaredManifest && (manifest === undefined || errors.length > 0)) {
-        notes.push(...errors, `suite ${root}: rejected declared manifest`);
+        notes.push(...errors, ...fallbacks, `suite ${root}: rejected declared manifest`);
         return undefined;
     }
+    // A lower-priority manifest carried the suite: keep the reason the
+    // higher-priority declaration was skipped visible without failing the suite.
+    if (fallbacks.length > 0)
+        notes.push(`suite ${root}: a higher-priority manifest was rejected`, ...fallbacks);
     // A declaration-only suite (official CC lsp plugins ship just a README):
     // the marketplace entry's inline lspServers are its manifest.
     if (manifest === undefined && hint !== undefined && Object.keys(componentDeclarations(hint)).length > 0) {
@@ -364,7 +356,7 @@ export async function readSuite(root, sourceId, dimension, hint, notes = []) {
         return undefined;
     let declared = manifest.components?.skills;
     if (declared !== undefined && (manifest.layout === 'claude-code' || manifest.layout === 'codex') && (await isDirectory(join(root, 'skills')))) {
-        declared = ['skills', ...(Array.isArray(declared) ? declared : [declared])];
+        declared = ['skills', ...(isUnknownArray(declared) ? declared : [declared])];
     }
     const skills = await discoverSkills(root, errors, declared);
     if (manifest.layout === 'skill-collection' && skills.length === 0) {
@@ -436,11 +428,3 @@ async function syntheticManifest(root) {
         name
     };
 }
-async function isFile(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}

package/lib/catalog/skills-parse.js

@@ -9,14 +9,14 @@
  */
 import { parse as parseYaml } from 'yaml';
 /** Kebab-case skill names only, matching the shipped provider's rule. */
-export function isSkillName(name) {
+function isSkillName(name) {
     return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(name);
 }
 /**
  * Normalize a display-style skill name into kebab-case (e.g. "Presentations"
  * → "presentations"), or `undefined` when nothing usable remains.
  */
-export function normalizeSkillName(name) {
+function normalizeSkillName(name) {
     const normalized = name
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, '-')
@@ -50,29 +50,31 @@ function parseBoolean(value) {
  *   skill must be dropped from discovery.
  */
 export function parseSkillFrontmatter(text, expectedName) {
-    const match = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
-    if (match === null)
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text)?.[1];
+    if (frontmatter === undefined)
         return 'missing YAML frontmatter';
     let raw;
     try {
-        raw = parseYaml(match[1]);
+        raw = parseYaml(frontmatter);
     }
     catch {
         // Claude Code-authored frontmatter sometimes carries unquoted `: `
         // sequences in prose fields, which strict YAML rejects. A lenient
         // line-based fallback recovers the standard fields first-occurrence
         // wins; values that still fail the field checks below drop the skill.
-        raw = lenientFrontmatter(match[1]);
+        raw = lenientFrontmatter(frontmatter);
     }
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw))
         return 'frontmatter is not an object';
     const record = raw;
     const rawName = record['name'];
     const description = record['description'];
+    if (typeof rawName !== 'string')
+        return 'frontmatter name is missing or not kebab-case';
     // Codex plugins ship display names in `name` (e.g. "Presentations"); the
     // skill identity is its kebab form, so normalize instead of dropping.
-    const name = typeof rawName === 'string' && !isSkillName(rawName) ? normalizeSkillName(rawName) : rawName;
-    if (name === undefined || typeof name !== 'string')
+    const name = isSkillName(rawName) ? rawName : normalizeSkillName(rawName);
+    if (name === undefined)
         return 'frontmatter name is missing or not kebab-case';
     if (expectedName !== undefined && name !== expectedName)
         return `frontmatter name "${rawName}" does not match skill directory "${expectedName}"`;
@@ -104,9 +106,11 @@ function lenientFrontmatter(body) {
         const match = /^([A-Za-z][A-Za-z0-9_-]*):\s*(.*)$/.exec(line);
         if (match === null)
             continue;
-        const key = match[1];
+        const [, key, value] = match;
+        if (key === undefined || value === undefined)
+            continue;
         if (record[key] === undefined)
-            record[key] = match[2].trim();
+            record[key] = value.trim();
     }
     return record;
 }

package/lib/catalog/source-catalog.js

@@ -9,7 +9,8 @@
  */
 import { readdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { expandHome, isDirectory, sourcesDir } from './paths.js';
+import { expandHome, sourcesDir } from './paths.js';
+import { isDirectory } from './fs-probes.js';
 import { scanSource as scanSourceWithNotes } from './suite-scanner.js';
 import { discoverNativeProjectSuites } from './native-project.js';
 /** Discover suites from the selected configured or project checkouts. */
@@ -17,7 +18,7 @@ export async function discoverSourceList(sources, dimension, dimensionRoot) {
     return (await discoverSourceListWithNotes(sources, dimension, dimensionRoot)).suites;
 }
 /** Discover suites plus per-source scan diagnostics for one dimension. */
-export async function discoverSourceListWithNotes(sources, dimension, dimensionRoot, scanProjectLayouts = true) {
+export async function discoverSourceListWithNotes(sources, dimension, dimensionRoot, scanProjectLayouts = false) {
     const checkoutRoot = sourcesDir(dimensionRoot);
     const listed = new Set(sources.map(source => source.id));
     const checkouts = sources.map(source => ({

package/lib/catalog/suite-components.js

@@ -1,7 +1,7 @@
 /** Resolve all plugin component declarations into the same normalized resources used by runtime consumers. */
 import { readFile } from 'node:fs/promises';
 import { relative } from 'node:path';
-import { componentDocuments, componentPath, firstComponentFile, isRecord } from './component-files.js';
+import { componentDocuments, componentPath, firstComponentFile, isRecord, isStringArray, isUnknownArray } from './component-files.js';
 import { parseLspServers } from './lsp-spec.js';
 import { normalizeHookDocuments } from './project-hooks.js';
 import { PLUGIN_ROOT_VARIABLES } from '../model/layouts.js';
@@ -68,18 +68,18 @@ export async function discoverSuiteHooks(root, manifest, errors) {
         const output = {};
         for (const [event, groups] of Object.entries(events)) {
             const canonicalEvent = EVENT_ALIASES[event] ?? event;
-            if (!Array.isArray(groups)) {
+            if (!isUnknownArray(groups)) {
                 output[canonicalEvent] = groups;
                 continue;
             }
             output[canonicalEvent] = groups.map(rawGroup => {
-                const group = isRecord(rawGroup) && !Array.isArray(rawGroup.hooks) && (typeof rawGroup.command === 'string' || typeof rawGroup.bash === 'string')
+                const group = isRecord(rawGroup) && !isUnknownArray(rawGroup.hooks) && (typeof rawGroup.command === 'string' || typeof rawGroup.bash === 'string')
                     ? {
                         matcher: rawGroup.matcher,
                         hooks: [{ ...rawGroup, type: rawGroup.type ?? 'command', command: rawGroup.command ?? rawGroup.bash, timeout: rawGroup.timeout ?? rawGroup.timeoutSec }]
                     }
                     : rawGroup;
-                if (!isRecord(group) || !Array.isArray(group.hooks))
+                if (!isRecord(group) || !isUnknownArray(group.hooks))
                     return group;
                 return {
                     ...group,
@@ -88,7 +88,7 @@ export async function discoverSuiteHooks(root, manifest, errors) {
                             return hook;
                         if (hook.type !== 'process')
                             return typeof hook.command === 'string' ? { ...hook, command: rootVariables(hook.command, root) } : hook;
-                        if (typeof hook.command !== 'string' || (hook.args !== undefined && (!Array.isArray(hook.args) || !hook.args.every(arg => typeof arg === 'string'))))
+                        if (typeof hook.command !== 'string' || (hook.args !== undefined && !isStringArray(hook.args)))
                             return { ...hook, type: 'command', command: undefined };
                         const argv = [hook.command, ...(hook.args ?? [])].map(arg => quote(rootVariables(arg, root)));
                         return { ...hook, type: 'command', command: argv.join(' '), ...(typeof hook.timeoutMs === 'number' ? { timeout: hook.timeoutMs / 1000 } : {}) };

package/lib/catalog/suite-scanner.js

@@ -1,5 +1,7 @@
 import { scanSource } from './scan-resolvers.js';
-export { repoName, listMdFiles, discoverLspEntries, scanSource, canonicalGitUrl, resolveMarketplaceEntry, defaultScanFilters, MarketplaceStrategy, RootedStrategy, FlatCollectionsStrategy } from './scan-resolvers.js';
+export { repoName } from './manifests.js';
+export { listMdFiles, discoverLspEntries } from './surfaces.js';
+export { scanSource, canonicalGitUrl, resolveMarketplaceEntry, defaultScanFilters, MarketplaceStrategy, RootedStrategy, FlatCollectionsStrategy } from './scan-resolvers.js';
 export { runScanChain } from './scan-pipeline.js';
 /** Discover every suite under one source checkout. */
 export async function discoverSuitesInSource(checkoutDir, sourceId, dimension, sourceUrl) {

package/lib/catalog/surfaces.js

@@ -12,11 +12,10 @@
 import { readFile, readdir, stat } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { parseSkillFrontmatter } from './skills-parse.js';
-import { isDirectory } from './paths.js';
+import { isDirectory, isFile, listChildDirs } from './fs-probes.js';
 import { validateMcpJson } from './validate.js';
 import { readManifest } from './manifests.js';
-import { componentDocuments, componentPath, firstComponentFile } from './component-files.js';
-const DOT_DIRS = new Set(['.git', '.github', '.claude', '.cursor', '.kimi', '.plugin', '.sources', 'node_modules']);
+import { componentDocuments, componentPath, firstComponentFile, isUnknownArray } from './component-files.js';
 /**
  * Resolve a manifest-declared skills path into absolute directories (string or
  * array form). Containment is checked on the *realpath* of both sides: the
@@ -168,7 +167,7 @@ export async function discoverMcp(root, errors, manifest) {
         ? fallback === undefined
             ? []
             : [fallback]
-        : [...(additive && fallback !== undefined ? [fallback] : []), ...(Array.isArray(declared) ? declared : [declared])];
+        : [...(additive && fallback !== undefined ? [fallback] : []), ...(isUnknownArray(declared) ? declared : [declared])];
     if (values.length === 0)
         return undefined;
     const documents = await componentDocuments(root, values, errors);
@@ -183,10 +182,8 @@ export async function discoverMcp(root, errors, manifest) {
         errors.push(...result.errors);
         if (result.config === undefined)
             return undefined;
-        if (result.config !== undefined) {
-            Object.assign(servers, result.config.servers);
-            schema = result.config.schema;
-        }
+        Object.assign(servers, result.config.servers);
+        schema = result.config.schema;
     }
     return { schema, servers };
 }
@@ -274,21 +271,3 @@ export async function listMdFiles(dir) {
     }
     return entries.filter(name => name.endsWith('.md')).sort();
 }
-async function listChildDirs(dir) {
-    let entries;
-    try {
-        entries = await readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return entries.filter(entry => entry.isDirectory() && !DOT_DIRS.has(entry.name) && !entry.name.startsWith('.')).map(entry => join(dir, entry.name));
-}
-async function isFile(path) {
-    try {
-        return (await stat(path)).isFile();
-    }
-    catch {
-        return false;
-    }
-}

package/lib/catalog/validate.js

@@ -9,12 +9,13 @@
  * the `${PLUGIN_ROOT}` / `${PLUGIN_DATA}` expansion the spec makes mandatory.
  */
 import { readFile, realpath } from 'node:fs/promises';
-import { dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
+import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 // The 2020-12 dist build's d.ts resolves to a CJS namespace under NodeNext;
 // the runtime default export is the class itself (module.exports = Ajv2020).
 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 Ajv2020Class = Ajv2020Default;
 export const PLUGIN_SCHEMA_ID = 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json';
@@ -63,7 +64,6 @@ export async function pathContainmentError(pluginRoot, value) {
     catch {
         rootResolved = resolve(pluginRoot);
     }
-    const rootPrefix = rootResolved.endsWith(sep) ? rootResolved : `${rootResolved}${sep}`;
     let candidateResolved;
     try {
         candidateResolved = await realpath(candidate);
@@ -71,7 +71,7 @@ export async function pathContainmentError(pluginRoot, value) {
     catch {
         candidateResolved = candidate;
     }
-    if (candidateResolved !== rootResolved && !candidateResolved.startsWith(rootPrefix)) {
+    if (!isWithin(rootResolved, candidateResolved)) {
         return `path "${value}" resolves outside the plugin root`;
     }
     return undefined;
@@ -158,12 +158,13 @@ export async function validateMcpJson(pluginRoot, raw, options) {
                     problems.push(reason);
             }
         }
-        if (stdioServer.cwd !== undefined && typeof stdioServer.cwd !== 'string') {
+        const declaredCwd = stdioServer.cwd;
+        if (declaredCwd !== undefined && typeof declaredCwd !== 'string') {
             problems.push('cwd must be a string');
         }
-        else if (options?.pathMode !== 'project' && stdioServer.cwd !== undefined && ![...PLUGIN_DATA_VARIABLES].some(name => stdioServer.cwd.startsWith(`\${${name}}`))) {
+        else if (options?.pathMode !== 'project' && declaredCwd !== undefined && ![...PLUGIN_DATA_VARIABLES].some(name => declaredCwd.startsWith(`\${${name}}`))) {
             // `.` is the Codex dialect spelling for the plugin root.
-            const cwd = stdioServer.cwd === '.' ? './' : stdioServer.cwd;
+            const cwd = declaredCwd === '.' ? './' : declaredCwd;
             const reason = await pathContainmentError(pluginRoot, cwd);
             if (reason !== undefined)
                 problems.push(reason);
@@ -197,8 +198,3 @@ export function resolveCwd(value, pluginRoot, pluginData) {
         return resolve(pluginRoot, value.slice('${PLUGIN_ROOT}'.length).replace(/^\/+/, ''));
     return resolve(pluginRoot, value.replace(/^\.\//, ''));
 }
-/** Whether one absolute path equals or lies under another absolute path. */
-export function isWithin(root, candidate) {
-    const relativePath = relative(root, candidate);
-    return relativePath === '' || (!relativePath.startsWith('..') && !isAbsolute(relativePath));
-}

package/lib/contracts/market.js

@@ -9,6 +9,7 @@ export const MARKET_ROUTES = {
     lspStatus: `${MARKET_API_PREFIX}lsp-status`,
     lspServers: `${MARKET_API_PREFIX}lsp-servers`,
     addLspServer: `${MARKET_API_PREFIX}lsp-servers/add`,
+    migrateLspSeam: `${MARKET_API_PREFIX}lsp-servers/migrate-seam`,
     serverConfig: `${MARKET_API_PREFIX}server-config`,
     saveServerConfig: `${MARKET_API_PREFIX}server-config/save`,
     progress: `${MARKET_API_PREFIX}progress`,