dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/{runtime/host → packages/market-bundle/src/platform}/settings-namespace.js

@@ -1,11 +1,12 @@
-import { resolveMarketSettings } from '../../contracts/settings.js';
+import { resolveMarketSettings } from '../../../market-contracts/src/contracts/settings.js';
 import { FEEDBACK_TOOL_NAME, mountFeedbackTool } from './feedback-tool.js';
 export class MarketSettingsNamespace {
     ctx;
-    refs;
     dataRoot;
     locale;
     host;
+    localePreference;
+    refs;
     watchers = [];
     feedbackDisposer;
     /**
@@ -15,12 +16,25 @@ export class MarketSettingsNamespace {
      * switch, or skipped because the host has no tools registry to register on.
      */
     feedbackMountState;
-    constructor(ctx, refs, dataRoot, locale, host) {
+    constructor(ctx, refs, dataRoot, locale, host, 
+    /**
+     * The host interface language, read per call. It is a reader rather than a
+     * captured string because a language switch must move the translation
+     * default without rebuilding this namespace.
+     */
+    localePreference) {
         this.ctx = ctx;
-        this.refs = refs;
         this.dataRoot = dataRoot;
         this.locale = locale;
         this.host = host;
+        this.localePreference = localePreference;
+        // A caller may hand in a partial ref set (a test, or a config written
+        // before this field existed); an absent switch reads as its default.
+        this.refs = {
+            ...refs,
+            translationEnabled: refs.translationEnabled ?? { get: () => undefined },
+            agentPresetsEnabled: refs.agentPresetsEnabled ?? { get: () => undefined }
+        };
     }
     /** Subscribe the runtime reactions to live settings updates. */
     mount() {
@@ -28,17 +42,23 @@ export class MarketSettingsNamespace {
         this.syncAutoUpdateSources();
         this.syncFeedbackTool();
         let previousBackend = this.settings().mcpEnhanced;
+        let previousTranslation = this.settings().translationEnabled;
         const watcher = this.ctx.on('loader/volatile-update', () => {
             const backend = this.settings().mcpEnhanced;
             if (backend !== previousBackend) {
                 previousBackend = backend;
                 this.host.refreshMcpMounts();
             }
+            previousTranslation = this.syncTranslationProviders(previousTranslation);
             this.syncProjectLayouts();
             this.syncAutoUpdateSources();
             this.syncFeedbackTool();
         });
         this.watchers.push(watcher);
+        // A locale edit can change the default without changing this plugin's refs.
+        this.watchers.push(this.ctx.on('settings/document-updated', () => {
+            previousTranslation = this.syncTranslationProviders(previousTranslation);
+        }));
     }
     /** Release every watcher and unmount the feedback tool. */
     dispose() {
@@ -48,7 +68,8 @@ export class MarketSettingsNamespace {
         this.feedbackDisposer = undefined;
     }
     /**
-     * The resolved settings, from the volatile references the host updates in place.
+     * The resolved settings, from the volatile references the host updates in
+     * place and the interface language they resolve over.
      */
     settings() {
         return resolveMarketSettings({
@@ -56,8 +77,10 @@ export class MarketSettingsNamespace {
             scanProjectLayouts: this.refs.scanProjectLayouts.get(),
             downloadRegion: this.refs.downloadRegion.get(),
             feedbackEnabled: this.refs.feedbackEnabled.get(),
-            autoUpdateSources: this.refs.autoUpdateSources.get()
-        });
+            autoUpdateSources: this.refs.autoUpdateSources.get(),
+            translationEnabled: this.refs.translationEnabled.get(),
+            agentPresetsEnabled: this.refs.agentPresetsEnabled.get()
+        }, this.localePreference());
     }
     /** The persisted MCP backend choice; the built-in client until the host applies a value. */
     async backend() {
@@ -75,6 +98,31 @@ export class MarketSettingsNamespace {
     async downloadRegion() {
         return this.settings().downloadRegion;
     }
+    /**
+     * Read the live translation switch: the stored preference while the user has
+     * one, the interface language's default otherwise.
+     */
+    translationEnabled() {
+        return this.settings().translationEnabled;
+    }
+    /**
+     * Notify the translation owner on either effective preference edge. Unrelated
+     * writes do not reset failures or disturb cached results.
+     * @param previous - whether translation was on at the last look.
+     * @returns whether it is on now, for the next comparison.
+     */
+    syncTranslationProviders(previous) {
+        const enabled = this.settings().translationEnabled;
+        if (enabled !== previous) {
+            try {
+                this.host.syncTranslationEnabled();
+            }
+            catch (error) {
+                this.ctx.logger?.error?.(`[dsh-agent-plugins-market] translation state synchronization failed: ${String(error)}`);
+            }
+        }
+        return enabled;
+    }
     /** Apply the background source-update switch. */
     syncAutoUpdateSources() {
         try {

package/lib/packages/market-bundle/src/platform/settings-schema.js

@@ -0,0 +1,25 @@
+import z from '@deepseek-ai/schemastery';
+import { MARKET_SETTINGS_DEFAULTS } from '../../../market-contracts/src/contracts/settings.js';
+/**
+ * Schema of the market settings namespace: the switches this plugin's config
+ * card serves, with the defaults declared to the host. The values themselves
+ * belong to {@link MARKET_SETTINGS_DEFAULTS}; this schema states them, it does
+ * not own them.
+ *
+ * `translationEnabled` deliberately declares no default. Its default follows
+ * the interface language, and a declared default would be materialized into the
+ * live config reference, where "the user never set this" and "the user turned it
+ * off" would both read `false` — the distinction the derivation rests on. With
+ * the field absent, the reference answers `undefined` until the user writes it,
+ * and {@link resolveMarketSettings} fills the language's own default in.
+ */
+export const MarketSettingsFields = {
+    mcpEnhanced: z.boolean().default(MARKET_SETTINGS_DEFAULTS.mcpEnhanced),
+    scanProjectLayouts: z.boolean().default(MARKET_SETTINGS_DEFAULTS.scanProjectLayouts),
+    downloadRegion: z.union([z.const('auto'), z.const('global'), z.const('china')]).default(MARKET_SETTINGS_DEFAULTS.downloadRegion),
+    feedbackEnabled: z.boolean().default(MARKET_SETTINGS_DEFAULTS.feedbackEnabled),
+    autoUpdateSources: z.boolean().default(MARKET_SETTINGS_DEFAULTS.autoUpdateSources),
+    translationEnabled: z.boolean(),
+    agentPresetsEnabled: z.boolean().default(MARKET_SETTINGS_DEFAULTS.agentPresetsEnabled)
+};
+export const MarketSettingsSchema = z.object(MarketSettingsFields);

package/lib/packages/market-bundle/src/routes-extension-presets.js

@@ -0,0 +1,161 @@
+import { EXTENSION_ROUTES, parseExtensionIds, parseExtensionName } from '../../market-contracts/src/contracts/extension-presets.js';
+function id(value) {
+    if (typeof value !== 'string' || value.length === 0 || value.length > 1024)
+        throw new Error('invalid identifier');
+    return value;
+}
+function revision(value) {
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 0)
+        throw new Error('invalid revision');
+    return value;
+}
+async function body(request) {
+    const chunks = [];
+    let length = 0;
+    for await (const chunk of request) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        length += bytes.length;
+        if (length > 64 * 1024)
+            throw new Error('request too large');
+        chunks.push(bytes);
+    }
+    const value = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        throw new Error('invalid request body');
+    return value;
+}
+function json(response, status, value) {
+    const text = JSON.stringify(value);
+    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'content-length': Buffer.byteLength(text), 'cache-control': 'no-store' });
+    response.end(text);
+}
+function sameOrigin(request) {
+    const origin = request.headers.origin;
+    if (origin === undefined)
+        return true;
+    try {
+        return new URL(origin).host === request.headers.host;
+    }
+    catch {
+        return false;
+    }
+}
+/** Mount only after session initialization has an enforcement gate. */
+export function mountExtensionPresetRoutes(host, service) {
+    const disposers = [];
+    const add = (path, method, action) => {
+        disposers.push(host.webServer.register({
+            kind: 'exact',
+            path,
+            async handler(request, response) {
+                if (request.method !== method) {
+                    json(response, 405, { ok: false, code: 'method-not-allowed', error: 'method not allowed' });
+                    return;
+                }
+                if (!sameOrigin(request)) {
+                    json(response, 403, { ok: false, code: 'cross-origin', error: 'cross-origin request rejected' });
+                    return;
+                }
+                try {
+                    const input = method === 'GET' ? Object.fromEntries(new URL(request.url ?? '/', 'http://localhost').searchParams) : await body(request);
+                    const sessionId = await action(input);
+                    const window = await service.window(sessionId);
+                    json(response, 200, method === 'GET' ? window : { ok: true, window });
+                }
+                catch (error) {
+                    const code = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : 'invalid-extension-request';
+                    const status = code.includes('conflict') || code.includes('busy') || code.includes('not-ready') ? 409 : code.includes('not-found') ? 404 : 400;
+                    json(response, status, { ok: false, code, error: error instanceof Error ? error.message : String(error) });
+                }
+            }
+        }));
+    };
+    add(EXTENSION_ROUTES.window, 'GET', input => Promise.resolve(id(input.sessionId)));
+    // The Hooks overview is sessionless: the route answers the read directly
+    // instead of resolving a live Agent, because hook declarations belong to
+    // the user Agent layout root, not to any one workspace.
+    disposers.push(host.webServer.register({
+        kind: 'exact',
+        path: EXTENSION_ROUTES.hooksOverview,
+        async handler(request, response) {
+            if (request.method !== 'GET') {
+                json(response, 405, { ok: false, code: 'method-not-allowed', error: 'method not allowed' });
+                return;
+            }
+            if (!sameOrigin(request)) {
+                json(response, 403, { ok: false, code: 'cross-origin', error: 'cross-origin request rejected' });
+                return;
+            }
+            try {
+                if (!service.hooksOverview)
+                    throw Object.assign(new Error('extension hooks overview is unavailable'), { code: 'extension-hooks-unavailable' });
+                json(response, 200, await service.hooksOverview());
+            }
+            catch (error) {
+                const code = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : 'invalid-extension-request';
+                json(response, code.includes('not-found') ? 404 : 400, { ok: false, code, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }));
+    // The hook detail modal's dry run. The body names the declaration only: the
+    // command is resolved from the scanned catalog, so a caller can never choose
+    // what runs, and the working directory is always the server's home directory.
+    disposers.push(host.webServer.register({
+        kind: 'exact',
+        path: EXTENSION_ROUTES.hookRun,
+        async handler(request, response) {
+            if (request.method !== 'POST') {
+                json(response, 405, { ok: false, code: 'method-not-allowed', error: 'method not allowed' });
+                return;
+            }
+            if (!sameOrigin(request)) {
+                json(response, 403, { ok: false, code: 'cross-origin', error: 'cross-origin request rejected' });
+                return;
+            }
+            try {
+                const hookRun = service.hookRun?.bind(service);
+                if (hookRun === undefined)
+                    throw Object.assign(new Error('extension hook dry run is unavailable'), { code: 'extension-hook-run-unavailable' });
+                const input = await body(request);
+                const rawIndex = input.hookIndex;
+                if (rawIndex !== undefined && (typeof rawIndex !== 'number' || !Number.isSafeInteger(rawIndex) || rawIndex < 0))
+                    throw new Error('invalid hook index');
+                const hookIndex = rawIndex;
+                const sessionId = input.sessionId === undefined ? undefined : id(input.sessionId);
+                json(response, 200, await hookRun({
+                    sourceId: id(input.sourceId),
+                    suiteId: id(input.suiteId),
+                    event: id(input.event),
+                    ...(hookIndex === undefined ? {} : { hookIndex }),
+                    ...(sessionId === undefined ? {} : { sessionId })
+                }));
+            }
+            catch (error) {
+                const code = typeof error === 'object' && error !== null && 'code' in error && typeof error.code === 'string' ? error.code : 'invalid-extension-request';
+                json(response, code.includes('not-found') ? 404 : 400, { ok: false, code, error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }));
+    const mutate = (path, operation) => {
+        add(path, 'POST', async (input) => {
+            const session = id(input.sessionId);
+            await operation(session, revision(input.expectedRevision), input);
+            return session;
+        });
+    };
+    const preset = (input) => ({ name: parseExtensionName(input.name), enabledIds: parseExtensionIds(input.enabledIds) });
+    mutate(EXTENSION_ROUTES.create, (session, rev, input) => service.create(session, rev, preset(input)));
+    mutate(EXTENSION_ROUTES.update, (session, rev, input) => service.update(session, rev, id(input.id), preset(input)));
+    mutate(EXTENSION_ROUTES.delete, (session, rev, input) => service.delete(session, rev, id(input.id)));
+    mutate(EXTENSION_ROUTES.default, (session, rev, input) => service.setDefault(session, rev, input.id === null ? null : id(input.id)));
+    mutate(EXTENSION_ROUTES.select, (session, rev, input) => service.select(session, rev, input.presetId === null ? null : id(input.presetId)));
+    mutate(EXTENSION_ROUTES.recover, async (session, rev) => {
+        if (!service.recover)
+            throw new Error('extension recovery is unavailable');
+        await service.recover(session, rev);
+    });
+    return () => {
+        for (const dispose of disposers)
+            dispose();
+    };
+}

package/lib/packages/market-bundle/src/routes-resources.js

@@ -0,0 +1,127 @@
+import { RESOURCE_ROUTES, resolveFavoriteInput } from '../../market-contracts/src/contracts/resource-window.js';
+import { SURFACE_TOGGLE_KEYS } from '../../market-contracts/src/contracts/surface-toggles.js';
+import { buildResourceWindow } from './application/resource-inventory.js';
+const MAX_BODY_BYTES = 64 * 1024;
+/** Mount the resource-window routes; returns the disposer releasing them all. */
+export function mountResourceRoutes(hostCtx, deps) {
+    const host = hostCtx;
+    const disposers = [];
+    const get = (path, handler) => {
+        disposers.push(host.webServer.register({ kind: 'exact', path, handler }));
+    };
+    const post = (path, handler) => {
+        disposers.push(host.webServer.register({
+            kind: 'exact',
+            path,
+            handler: (request, response) => {
+                if (!sameOrigin(request)) {
+                    sendJson(response, 403, { ok: false, error: 'cross-origin request rejected' });
+                    return;
+                }
+                void (async () => {
+                    const body = await readJsonBody(request);
+                    if (body === undefined) {
+                        sendJson(response, 400, { ok: false, error: 'invalid JSON body' });
+                        return;
+                    }
+                    try {
+                        const value = await handler(body, request);
+                        sendJson(response, 200, { ok: true, ...value });
+                    }
+                    catch (error) {
+                        sendJson(response, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
+                    }
+                })();
+            }
+        }));
+    };
+    get(RESOURCE_ROUTES.inventory, async (_request, response) => {
+        sendJson(response, 200, await buildResourceWindow(deps));
+    });
+    post(RESOURCE_ROUTES.setEntry, async (body) => {
+        const face = body.face;
+        if (typeof face !== 'string' || !SURFACE_TOGGLE_KEYS.includes(face))
+            throw new Error('invalid resource face');
+        if (typeof body.entryId !== 'string' || body.entryId === '')
+            throw new Error('missing entry id');
+        if (typeof body.enabled !== 'boolean')
+            throw new Error('enabled must be a boolean');
+        await deps.setEntry(face, body.entryId, body.enabled);
+        return { window: await buildResourceWindow(deps) };
+    });
+    post(RESOURCE_ROUTES.applyFavorite, async (body) => {
+        if (typeof body.id !== 'string' || body.id === '')
+            throw new Error('missing favorite id');
+        await deps.applyFavorite(body.id);
+        return { window: await buildResourceWindow(deps) };
+    });
+    post(RESOURCE_ROUTES.saveFavorite, async (body) => {
+        // The snapshot is read server-side from the live workspace state, so a
+        // client cannot store a state it never had.
+        const input = resolveFavoriteInput(body);
+        if (input === undefined)
+            throw new Error('favorite name is required');
+        const favoriteId = await deps.saveFavorite(input.name);
+        return { window: await buildResourceWindow(deps), favoriteId };
+    });
+    post(RESOURCE_ROUTES.deleteFavorite, async (body) => {
+        if (typeof body.id !== 'string' || body.id === '')
+            throw new Error('missing favorite id');
+        await deps.deleteFavorite(body.id);
+        return { window: await buildResourceWindow(deps) };
+    });
+    // Follow global: the workspace drops every project-level opinion — no entry
+    // filters, all six surface switches back on — and the payload returns the
+    // plain installed inventory.
+    post(RESOURCE_ROUTES.reset, async () => {
+        await deps.resetWorkspace();
+        return { window: await buildResourceWindow(deps) };
+    });
+    return () => {
+        for (const dispose of disposers)
+            dispose();
+    };
+}
+function sameOrigin(request) {
+    const origin = request.headers['origin'];
+    if (origin === undefined)
+        return true;
+    try {
+        return new URL(origin).host === request.headers['host'];
+    }
+    catch {
+        return false;
+    }
+}
+/** Parses the request body; `undefined` for an oversized, unparsable, or failed read. */
+function readJsonBody(request) {
+    return new Promise(resolve => {
+        let size = 0;
+        const chunks = [];
+        request.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > MAX_BODY_BYTES) {
+                resolve(undefined);
+                request.destroy();
+                return;
+            }
+            chunks.push(chunk);
+        });
+        request.on('end', () => {
+            if (size > MAX_BODY_BYTES)
+                return;
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString('utf8')));
+            }
+            catch {
+                resolve(undefined);
+            }
+        });
+        request.on('error', () => resolve(undefined));
+    });
+}
+function sendJson(response, status, payload) {
+    const body = JSON.stringify(payload);
+    response.writeHead(status, { 'content-type': 'application/json; charset=utf-8', 'content-length': Buffer.byteLength(body) });
+    response.end(body);
+}