dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/{routes.js → packages/market-bundle/src/routes.js}

@@ -7,13 +7,38 @@
  * enable/disable against a local profile.
  */
 import { isAbsolute } from 'node:path';
-import { MARKET_ROUTES, userPanelRoute } from './contracts/market.js';
-import { expandHome } from './catalog/paths.js';
-import { sanitizeOverridePatch } from './application/mcp/mcp-overrides.js';
-import { readModelCatalog } from './runtime/host/model-catalog.js';
+import { MARKET_ROUTES, userPanelRoute } from '../../market-contracts/src/contracts/market.js';
+import { expandHome } from '../../market-catalog/src/index.js';
+import { sanitizeOverridePatch } from '../../market-mcp/src/index.js';
+import { readModelCatalog } from '../../market-runtime/src/index.js';
 const MAX_BODY_BYTES = 64 * 1024;
+/** Recount a merged MCP view so its totals describe the entries actually returned. */
+function mcpTotals(entries) {
+    const count = (state) => entries.filter(entry => entry.state === state).length;
+    return {
+        all: entries.length,
+        connected: count('connected'),
+        degraded: count('degraded'),
+        failed: count('failed'),
+        needsCredentials: count('needs-credentials'),
+        orphaned: count('orphaned'),
+        disabled: count('disabled'),
+        foreign: count('foreign')
+    };
+}
+/** Recount a merged LSP view the way the status builder counts its own rows. */
+function lspTotals(entries) {
+    const count = (state) => entries.filter(entry => entry.state === state).length;
+    return {
+        all: entries.length,
+        mounted: count('mounted'),
+        failed: count('failed'),
+        blocked: count('host-missing') + count('conflict'),
+        disabled: count('disabled')
+    };
+}
 /** Mount every route; returns the disposer releasing them all. */
-export function mountSuiteRoutes(hostCtx, manager, panels) {
+export function mountSuiteRoutes(hostCtx, manager, panels, surfaceToggles, session) {
     const host = hostCtx;
     const disposers = [];
     const get = (path, handler) => {
@@ -52,9 +77,71 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
             }
         }));
     };
+    /**
+     * A read naming a session answers for that session's workspace; a read without
+     * one keeps answering from the global user catalog. Resolution failures are
+     * diagnosable rather than silent: an unknown session, a workspace-less agent,
+     * or an unwired project reader never falls back to a request path or to the
+     * process working directory.
+     */
+    const readSource = (request) => {
+        const sessionId = queryOf(request).get('sessionId');
+        if (sessionId === null || sessionId === '')
+            return {};
+        const agent = session?.agent(sessionId);
+        if (agent === undefined)
+            return { error: 'no live session "' + sessionId + '"' };
+        const cwd = agent.session.header.cwd;
+        if (typeof cwd !== 'string' || !isAbsolute(cwd))
+            return { error: 'session "' + sessionId + '" has no absolute workspace' };
+        const reader = session?.project?.(agent);
+        return reader === undefined ? { error: 'session-scoped project reads are unavailable' } : { reader };
+    };
+    /**
+     * Read one resource from whichever source owns it. A source-qualified id can
+     * name a user-dimension suite that merely rode along with a session, so a
+     * session-scoped request asks that workspace's project reader first and falls
+     * back to the user catalog. The session itself is validated before either, so
+     * an unknown session can never become a global read.
+     */
+    const readOwned = async (source, fromProject, fromCatalog) => {
+        if ('error' in source)
+            throw new Error(source.error);
+        if (source.reader === undefined)
+            return fromCatalog();
+        try {
+            return await fromProject(source.reader);
+        }
+        catch {
+            // The id is not this workspace's project resource; the catalog that owns it answers.
+            return fromCatalog();
+        }
+    };
+    /**
+     * One status view for a session: the user catalog stays visible and that
+     * workspace's own declarations join it. Replacing the catalog outright would
+     * hide every user server behind a session id.
+     */
+    const mergeById = (base, extra) => {
+        const seen = new Set(base.map(entry => entry.id));
+        return [...base, ...extra.filter(entry => !seen.has(entry.id))];
+    };
     get(MARKET_ROUTES.overview, async (_request, response) => {
         sendJson(response, 200, await manager.overview());
     });
+    // The slash menu's row faces. The menu asks on mount and on a locale change;
+    // translation stays lazy, so this reads the cache the panels filled and never
+    // starts a provider round of its own.
+    get(MARKET_ROUTES.menuRowFaces, async (_request, response) => {
+        sendJson(response, 200, await manager.menuRowFaces());
+    });
+    // The reset control in the plugin's configuration card. Dropping the cache is
+    // the whole operation: translation is lazy, so the next overview read
+    // repopulates it and the panel shows the authored text until it lands.
+    post(MARKET_ROUTES.clearTranslations, async () => {
+        await manager.clearTranslations();
+        return {};
+    });
     get(MARKET_ROUTES.modelCatalog, async (request, response) => {
         try {
             const query = queryOf(request);
@@ -64,8 +151,20 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
             sendJson(response, 503, { ok: false, error: error instanceof Error ? error.message : String(error) });
         }
     });
-    get(MARKET_ROUTES.mcpStatus, async (_request, response) => {
-        sendJson(response, 200, await manager.mcpStatus());
+    get(MARKET_ROUTES.mcpStatus, async (request, response) => {
+        const source = readSource(request);
+        if ('error' in source) {
+            sendJson(response, 404, { ok: false, error: source.error });
+            return;
+        }
+        const global = await manager.mcpStatus();
+        if (source.reader === undefined) {
+            sendJson(response, 200, global);
+            return;
+        }
+        const project = await source.reader.mcpStatus();
+        const entries = mergeById(global.entries, project.entries);
+        sendJson(response, 200, { ...global, entries, totals: mcpTotals(entries) });
     });
     get(MARKET_ROUTES.serverConfig, async (request, response) => {
         try {
@@ -73,7 +172,7 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
             const kind = query.get('kind');
             if (kind !== 'mcp' && kind !== 'lsp')
                 throw new Error('invalid service kind');
-            sendJson(response, 200, await manager.serverConfig(kind, query.get('id') ?? ''));
+            sendJson(response, 200, await manager.serverConfig(kind, query.get('id') ?? '', query.get('create') === 'true'));
         }
         catch (error) {
             sendJson(response, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
@@ -90,15 +189,42 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
     post(MARKET_ROUTES.addMcpServer, async (body) => {
         if (typeof body.name !== 'string')
             throw new Error('MCP server name is required');
-        await manager.addMcpServer(body.name, body.config);
+        await manager.addMcpServer(body.name, body.config, body.policy);
         return {};
     });
-    get(MARKET_ROUTES.lspStatus, async (_request, response) => {
-        sendJson(response, 200, await manager.lspStatus());
+    get(MARKET_ROUTES.lspStatus, async (request, response) => {
+        const source = readSource(request);
+        if ('error' in source) {
+            sendJson(response, 404, { ok: false, error: source.error });
+            return;
+        }
+        const global = await manager.lspStatus();
+        if (source.reader === undefined) {
+            sendJson(response, 200, global);
+            return;
+        }
+        const project = await source.reader.lspStatus();
+        const entries = mergeById(global.entries, project.entries);
+        sendJson(response, 200, { ...global, entries, totals: lspTotals(entries), hostMissing: entries.length > 0 && entries.every(entry => entry.state === 'host-missing') });
     });
     get(MARKET_ROUTES.lspServers, async (_request, response) => {
         sendJson(response, 200, { lspServers: await manager.lspServers() });
     });
+    get(MARKET_ROUTES.surfaceToggles, async (_request, response) => {
+        sendJson(response, 200, surfaceToggles?.currentToggles() ?? {});
+    });
+    post(MARKET_ROUTES.setSurfaceToggle, async (body) => {
+        if (surfaceToggles === undefined)
+            throw new Error('surface toggles are not available');
+        const key = body.key;
+        if (typeof key !== 'string' || !['market', 'skills', 'commands', 'agents', 'mcp', 'lsp'].includes(key)) {
+            throw new Error('invalid surface key');
+        }
+        if (typeof body.enabled !== 'boolean')
+            throw new Error('enabled must be a boolean');
+        await surfaceToggles.set(key, body.enabled);
+        return { toggles: surfaceToggles.currentToggles() };
+    });
     get(MARKET_ROUTES.progress, async (_request, response) => {
         sendJson(response, 200, manager.sourceProgress());
     });
@@ -114,28 +240,63 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
             return;
         }
         try {
-            sendJson(response, 200, await manager.suiteDetail(sourceId, suiteId));
+            const source = readSource(request);
+            if ('error' in source)
+                throw new Error(source.error);
+            // The project reader resolves source and suite inside this session's own
+            // workspace, so an id invented for another workspace simply is not found.
+            sendJson(response, 200, await readOwned(source, reader => reader.suiteDetail(sourceId, suiteId), () => manager.suiteDetail(sourceId, suiteId)));
         }
         catch (error) {
             sendJson(response, 404, { ok: false, error: error instanceof Error ? error.message : String(error) });
         }
     });
-    get(MARKET_ROUTES.skill, async (request, response) => {
+    // One suite document's authored text, whole. This is the market detail page's
+    // only document read — skills, commands, and agents all arrive through it when
+    // a reader opens the row — and it names the suite and the document rather than
+    // a path, so the catalog re-reads the file the scan found.
+    get(MARKET_ROUTES.suiteDocument, async (request, response) => {
         const query = queryOf(request);
         const sourceId = query.get('sourceId');
         const suiteId = query.get('suiteId');
-        const skill = query.get('skill');
-        if (sourceId === null || suiteId === null || skill === null) {
-            sendJson(response, 400, { ok: false, error: 'missing sourceId, suiteId, or skill' });
+        const kind = query.get('kind');
+        const name = query.get('name');
+        if (sourceId === null || suiteId === null || name === null || (kind !== 'skills' && kind !== 'commands' && kind !== 'agents')) {
+            sendJson(response, 400, { ok: false, error: 'missing sourceId, suiteId, kind, or name' });
             return;
         }
         try {
-            sendJson(response, 200, await manager.skillContent(sourceId, suiteId, skill));
+            const source = readSource(request);
+            sendJson(response, 200, await readOwned(source, reader => reader.suiteDocument(sourceId, suiteId, kind, name), () => manager.suiteDocument(sourceId, suiteId, kind, name)));
         }
         catch (error) {
             sendJson(response, 404, { ok: false, error: error instanceof Error ? error.message : String(error) });
         }
     });
+    // One suite document's translation, for the market detail page's skills,
+    // commands, and agents. The body names the suite and the document and nothing
+    // else: the catalog re-reads that file from the suite's own checkout, so a
+    // script on the page cannot spend the operator's translation quota on text of
+    // its own choosing — the same contract the user-panel route keeps. The
+    // document the reader sees arrives through the document route above, and this
+    // route re-reads the same file rather than trusting the page.
+    post(MARKET_ROUTES.suiteDocumentTranslation, async (body, request) => {
+        const { sourceId, suiteId } = parseTarget(body);
+        const kind = body['kind'];
+        if (kind !== 'skills' && kind !== 'commands' && kind !== 'agents')
+            throw new Error('invalid document kind');
+        const name = textField(body['name'] ?? '', 'document name');
+        if (name === '')
+            throw new Error('missing document name');
+        if (body['retry'] !== undefined && typeof body['retry'] !== 'boolean')
+            throw new Error('retry must be a boolean');
+        const retry = body['retry'] === true;
+        // The same reader the document GET uses: the session is taken from the query,
+        // validated once, and an unknown or workspace-less session is a diagnostic.
+        const source = readSource(request);
+        const translated = await readOwned(source, reader => reader.suiteDocumentTranslation(sourceId, suiteId, kind, name, retry), () => manager.suiteDocumentTranslation(sourceId, suiteId, kind, name, retry));
+        return { ...translated };
+    });
     post(MARKET_ROUTES.addSource, async (body) => {
         const url = textField(body['url'] ?? '', 'source url').trim();
         if (url === '')
@@ -358,20 +519,63 @@ export function mountSuiteRoutes(hostCtx, manager, panels) {
     // each mutation notifies the change pipeline so skills/commands remount.
     if (panels !== undefined) {
         const kinds = ['skills', 'commands', 'agents'];
-        const storeOf = (kind) => panels[kind];
+        // Reads answer for the requesting session's own panels when one is named;
+        // the mutations below stay global, so a project query can never edit the
+        // user's own panel documents.
+        const storeOf = (kind, reader) => (reader?.panels ?? panels)[kind];
+        const readStore = (kind, request) => {
+            const source = readSource(request);
+            return 'error' in source ? { error: source.error } : { store: storeOf(kind, source.reader) };
+        };
         for (const kind of kinds) {
-            get(userPanelRoute(kind), async (_request, response) => {
-                sendJson(response, 200, { entries: await storeOf(kind).list() });
+            get(userPanelRoute(kind), async (request, response) => {
+                const source = readStore(kind, request);
+                if ('error' in source) {
+                    sendJson(response, 404, { ok: false, error: source.error });
+                    return;
+                }
+                // `refresh=1` is the panel's Refresh button: a user asking for the
+                // working tree as it stands must never be answered from the row cache,
+                // so the route carries an explicit force path instead of relying on how
+                // old the cached rows happen to be.
+                const force = queryOf(request).get('refresh') === '1';
+                // The pending count rides the same read: a panel re-reads while it is
+                // non-zero, so translated text arrives without a manual refresh.
+                const read = await source.store.read(false, force);
+                sendJson(response, 200, {
+                    entries: read.entries,
+                    ...(read.translationPending === 0 ? {} : { translationPending: read.translationPending })
+                });
             });
             get(`${userPanelRoute(kind)}/entry`, async (request, response) => {
+                const source = readStore(kind, request);
+                if ('error' in source) {
+                    sendJson(response, 404, { ok: false, error: source.error });
+                    return;
+                }
                 const name = queryOf(request).get('name') ?? '';
-                const entry = await storeOf(kind).get(name);
+                const entry = await source.store.get(name);
                 if (entry === undefined) {
                     sendJson(response, 404, { ok: false, error: `no entry named "${name}"` });
                     return;
                 }
                 sendJson(response, 200, { entry });
             });
+            // One entry's document, translated chunk by chunk. The body names the
+            // entry and nothing else: the store re-reads that entry itself, so a
+            // script on the page cannot spend the operator's translation quota on
+            // text of its own choosing.
+            post(`${userPanelRoute(kind)}/entry/translation`, async (body, request) => {
+                const source = readStore(kind, request);
+                if ('error' in source)
+                    throw new Error(source.error);
+                const name = textField(body['name'] ?? '', 'entry name');
+                if (name === '')
+                    throw new Error('missing entry name');
+                if (body['retry'] !== undefined && typeof body['retry'] !== 'boolean')
+                    throw new Error('retry must be a boolean');
+                return { ...(await source.store.translateDocument(name, body['retry'] === true)) };
+            });
             post(`${userPanelRoute(kind)}/create`, async (body) => {
                 const name = textField(body['name'] ?? '', 'entry name').trim();
                 const text = textField(body['text'] ?? '', 'entry text');

package/lib/packages/market-bundle/src/runtime-adapters.js

@@ -0,0 +1,57 @@
+import { McpMountRegistry } from '../../market-mcp/src/index.js';
+import { deriveServerName } from '../../market-mcp/src/index.js';
+import { LspMountRegistry } from '../../market-lsp/src/index.js';
+/**
+ * Build the shared-service MCP adapter over one context.
+ *
+ * The mount registry stays the sole owner of its transport state: this wrapper
+ * only adds the mount proof, which needs the registry's own server-name
+ * derivation, and forwards every other call unchanged.
+ * @param ctx - the context the registry mounts through.
+ * @param dataRoot - the plugin data root the registry stores overrides under.
+ * @returns the MCP adapter the coordinator drives.
+ */
+export function createSharedMcpMount(ctx, dataRoot) {
+    const registry = new McpMountRegistry(ctx, dataRoot);
+    return {
+        setOverridesProvider: provider => registry.setOverridesProvider(provider),
+        setBackendProvider: provider => registry.setBackendProvider(provider),
+        setToolNamesProvider: provider => registry.setToolNamesProvider(provider),
+        setEntryFilter: filter => registry.setEntryFilter(filter),
+        usesCredential: ref => registry.usesCredential(ref),
+        forceRemount: (suiteId, serverKey) => registry.forceRemount(suiteId, serverKey),
+        forceRemountAll: () => registry.forceRemountAll(),
+        serverOwner: serverName => registry.serverOwner(serverName),
+        reconcile: suites => registry.reconcile(suites),
+        disposeAll: () => registry.disposeAll(),
+        toolOwnership: () => registry.toolOwnership(),
+        assertMounted: (suite, diagnostics, failed) => {
+            const key = suite.sourceId + '/' + suite.id;
+            for (const serverKey of Object.keys(suite.mcp?.servers ?? {})) {
+                const owner = registry.serverOwner(deriveServerName(suite, serverKey));
+                if (owner?.suiteId !== key || owner.serverKey !== serverKey || diagnostics.some(row => row.suiteId === key && row.serverKey === serverKey) || failed)
+                    throw new Error('extension-shared-mcp-unavailable: ' + key + '/' + serverKey);
+            }
+        }
+    };
+}
+/**
+ * Create one MCP mount for an agent-scoped contributor.
+ *
+ * The contributor mounts into contexts it does not own, so it takes the factory
+ * and calls it per context; the adapter is the same object the coordinator
+ * drives, which keeps one registry implementation behind both seams.
+ * @param ctx - the context the mount registers into.
+ * @param dataRoot - the plugin data root the mount stores overrides under.
+ * @returns the MCP mount for that context.
+ */
+export const createMcpMount = (ctx, dataRoot) => createSharedMcpMount(ctx, dataRoot);
+/**
+ * Build both mount adapters one reconciler drives.
+ * @param ctx - the context the registries mount through.
+ * @param dataRoot - the plugin data root the MCP registry stores overrides under.
+ * @returns the MCP and LSP adapters for that reconciler.
+ */
+export function createRuntimeMounts(ctx, dataRoot) {
+    return { mcp: createSharedMcpMount(ctx, dataRoot), lsp: new LspMountRegistry(ctx) };
+}