dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/packages/market-translation/src/runtime/host/translation-providers.js

@@ -0,0 +1,116 @@
+import { googleTranslate, microsoftTranslate } from './machine-translator.js';
+import { maskText, unmaskText } from './text-masking.js';
+/** Retry is one subset of the original batch, with complete input semantics. */
+const MAX_REPAIR_INPUTS = 20;
+const STRUCTURE_MARKER = /⟪d\d+⟫/g;
+function restoreAnswer(source, masked, answer) {
+    const text = unmaskText(answer, masked.placeholders);
+    if (text === undefined)
+        return undefined;
+    const expected = source.match(STRUCTURE_MARKER) ?? [];
+    const actual = text.match(STRUCTURE_MARKER) ?? [];
+    if (expected.length !== actual.length || expected.some((marker, i) => marker !== actual[i]))
+        return undefined;
+    return text.replace(STRUCTURE_MARKER, '').trim() === '' ? undefined : text;
+}
+/**
+ * Preserve valid siblings and retry damaged structural inputs once, in full.
+ * A failed repair stays empty for the localizer retry policy. Formatting leaves
+ * never become separate translation requests.
+ */
+function withMasking(base) {
+    return {
+        id: base.id,
+        available: () => base.available(),
+        async translate(request) {
+            const masked = request.texts.map(maskText);
+            const translated = await base.translate({ ...request, texts: masked.map(entry => entry.text) });
+            request.signal.throwIfAborted();
+            if (translated.length !== masked.length)
+                throw new Error(base.id + ' translate: result count mismatch');
+            const restored = request.texts.map(() => '');
+            /** First reason one slot could not be answered, reported only if no slot was. */
+            let firstFailure;
+            const repairs = [];
+            for (let index = 0; index < request.texts.length; index++) {
+                const source = request.texts[index];
+                const answer = translated[index];
+                const text = restoreAnswer(source, masked[index], answer);
+                if (text !== undefined) {
+                    restored[index] = text;
+                    continue;
+                }
+                const markers = source.match(STRUCTURE_MARKER) ?? [];
+                // Empty results and unstructured descriptions keep the existing retry
+                // policy. Only damaged structural prose gets the whole-input retry.
+                const prose = answer.replace(/⟦?[A-Z]\d+⟧|⟪d\d+⟫/g, '').trim();
+                if (markers.length === 0) {
+                    firstFailure ??= base.id + ' translate: the answer lost or duplicated a placeholder';
+                    continue;
+                }
+                if (prose === '') {
+                    firstFailure ??= base.id + ' translate: invalid translated text';
+                    continue;
+                }
+                if (repairs.length < MAX_REPAIR_INPUTS)
+                    repairs.push(index);
+            }
+            if (repairs.length > 0) {
+                request.signal.throwIfAborted();
+                try {
+                    const answers = await base.translate({ ...request, texts: repairs.map(index => masked[index].text) });
+                    request.signal.throwIfAborted();
+                    if (answers.length !== repairs.length)
+                        throw new Error(base.id + ' translate: repair result count mismatch');
+                    repairs.forEach((index, offset) => {
+                        restored[index] = restoreAnswer(request.texts[index], masked[index], answers[offset]) ?? '';
+                    });
+                }
+                catch (error) {
+                    if (request.signal.aborted)
+                        throw error;
+                    // Valid siblings remain available when the complete-input retry fails.
+                }
+            }
+            request.signal.throwIfAborted();
+            if (restored.every(text => text === ''))
+                throw new Error(firstFailure ?? base.id + ' translate: no valid translations');
+            return restored;
+        }
+    };
+}
+/**
+ * Build the ordered chain: google -> microsoft -> llm.
+ *
+ * The two public endpoints report themselves available unconditionally: they
+ * need no key, no registration and no configuration, which is what makes
+ * translation work out of the box on a fresh deployment. Whether one of them
+ * actually answers is settled by calling it, and the chain's circuit breaker is
+ * what stops a blocked network from costing a timeout per batch.
+ *
+ * The model hop is absent when the caller has none, so a deployment without a
+ * configured route gets a two-hop chain rather than a hop that always fails.
+ *
+ * The host context is accepted but unread: neither keyless endpoint needs a
+ * seam, and the field is part of the composition root's frozen call shape so a
+ * keyed provider can join the chain without changing that call.
+ * @param options - the host context and the already-built model provider.
+ * @returns the chain, best hop first.
+ */
+export function createTranslationProviders(options) {
+    const providers = [
+        withMasking({
+            id: 'google',
+            available: () => true,
+            translate: async (request) => (await googleTranslate(request)).texts
+        }),
+        withMasking({
+            id: 'microsoft',
+            available: () => true,
+            translate: async (request) => (await microsoftTranslate(request)).texts
+        })
+    ];
+    if (options.llm !== undefined)
+        providers.push(withMasking(options.llm));
+    return providers;
+}

package/lib/types/index.d.ts

@@ -1,130 +1,2 @@
-/**
- * dsh-agent-plugins-market host entry: the Agent Plugins Market manager.
- *
- * Function plugin (named exports, no default export). It registers one skill
- * provider feeding enabled suites into `ctx.skills`, reconciles enabled
- * suites' `mcp.json` servers into live self-built bridge mounts (stdio,
- * Streamable HTTP with OAuth, and legacy SSE — no host MCP client needed),
- * and mounts the market page's HTTP routes on the web server. Skills and MCP
- * tools are exposed through the host's native model surfaces; this plugin
- * does not register a redundant suite-inventory model tool.
- *
- * Requires `ctx.skills` (the dsh skill registry). MCP mounting is
- * self-contained: suites' MCP servers mount through the market's own bridge
- * plugin on the host `tools` registry.
- */
-import { type Context, type Volatile } from '@deepseek-ai/cordis';
-import z from '@deepseek-ai/schemastery';
-import type { DownloadRegionSetting } from './contracts/settings.js';
-import type { SourceRef } from './model/types.js';
-export declare const name = "dsh-agent-plugins-market";
-export declare const inject: string[];
-/** Host configuration. */
-/** Host configuration; the five market settings arrive as volatile references the host updates in place. */
-export interface Config {
-    /** User-dimension suite root; defaults to `~/.dsh/agent-plugins` (`$DSH_HOME/agent-plugins`). */
-    userRoot?: string;
-    /** Legacy mutable data root to migrate; writes always use the canonical root/data. */
-    dataRoot?: string;
-    /** Initial repository sources, merged into the persisted state on first load. */
-    sources?: SourceRef[];
-    /**
-     * Git/archive acquisition tuning: `proxy` (http/https proxy URL),
-     * `insteadOf` URL-prefix rewrites (mirror acceleration), `timeoutMs` per
-     * git invocation, `cloneRetry` (default true), `fallbackTarball` (retry a
-     * failed GitHub clone as a codeload tarball download; default false), and
-     * `allowHttpArchives` (permit plain-http archive URLs; default false).
-     */
-    git?: {
-        proxy?: string;
-        insteadOf?: Record<string, string>;
-        timeoutMs?: number;
-        cloneRetry?: boolean;
-        fallbackTarball?: boolean;
-        allowHttpArchives?: boolean;
-    };
-    /** MCP mount backend switch; updated live through the host settings service. */
-    mcpEnhanced: Volatile<boolean | undefined>;
-    /** Project-layout discovery switch; updated live through the host settings service. */
-    scanProjectLayouts: Volatile<boolean | undefined>;
-    /** Download region choice; updated live through the host settings service. */
-    downloadRegion: Volatile<DownloadRegionSetting | undefined>;
-    /** Experience-feedback tool switch; updated live through the host settings service. */
-    feedbackEnabled: Volatile<boolean | undefined>;
-    /** Background source-update switch; updated live through the host settings service. */
-    autoUpdateSources: Volatile<boolean | undefined>;
-}
-/**
- * Schemastery projection the host loader reads: the five volatile fields become
- * the `dsh-agent-plugins-market` settings namespace (the Plugins panel's
- * configuration page reads it), while the startup fields stay plain.
- */
-/** The schema's input face: every field optional, exactly what a profile patch may carry. */
-export interface ConfigInput {
-    userRoot?: string | null;
-    dataRoot?: string | null;
-    sources?: unknown;
-    git?: {
-        proxy?: string | null;
-        insteadOf?: Record<string, unknown>;
-        timeoutMs?: number | null;
-        cloneRetry?: boolean | null;
-        fallbackTarball?: boolean | null;
-        allowHttpArchives?: boolean | null;
-    };
-    mcpEnhanced?: boolean | null;
-    scanProjectLayouts?: boolean | null;
-    downloadRegion?: 'auto' | 'global' | 'china' | null;
-    feedbackEnabled?: boolean | null;
-    autoUpdateSources?: boolean | null;
-}
-export declare const Config: z<Schemastery.ObjectS<NoInfer<{
-    userRoot: z<string | undefined, string | undefined, "plain">;
-    dataRoot: z<string | undefined, string | undefined, "plain">;
-    sources: z<any, any, "plain">;
-    git: z<Schemastery.ObjectS<NoInfer<{
-        proxy: z<string, string, "plain">;
-        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
-        timeoutMs: z<number, number, "plain">;
-        cloneRetry: z<boolean, boolean, "plain">;
-        fallbackTarball: z<boolean, boolean, "plain">;
-        allowHttpArchives: z<boolean, boolean, "plain">;
-    }>>, Schemastery.ObjectT<NoInfer<{
-        proxy: z<string, string, "plain">;
-        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
-        timeoutMs: z<number, number, "plain">;
-        cloneRetry: z<boolean, boolean, "plain">;
-        fallbackTarball: z<boolean, boolean, "plain">;
-        allowHttpArchives: z<boolean, boolean, "plain">;
-    }>>, "plain">;
-    mcpEnhanced: z<boolean, boolean, "volatile-defined">;
-    scanProjectLayouts: z<boolean, boolean, "volatile-defined">;
-    downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "volatile-defined">;
-    feedbackEnabled: z<boolean, boolean, "volatile-defined">;
-    autoUpdateSources: z<boolean, boolean, "volatile-defined">;
-}>>, Schemastery.ObjectT<NoInfer<{
-    userRoot: z<string | undefined, string | undefined, "plain">;
-    dataRoot: z<string | undefined, string | undefined, "plain">;
-    sources: z<any, any, "plain">;
-    git: z<Schemastery.ObjectS<NoInfer<{
-        proxy: z<string, string, "plain">;
-        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
-        timeoutMs: z<number, number, "plain">;
-        cloneRetry: z<boolean, boolean, "plain">;
-        fallbackTarball: z<boolean, boolean, "plain">;
-        allowHttpArchives: z<boolean, boolean, "plain">;
-    }>>, Schemastery.ObjectT<NoInfer<{
-        proxy: z<string, string, "plain">;
-        insteadOf: z<import("@deepseek-ai/cosmokit").Dict<string, any>, import("@deepseek-ai/cosmokit").Dict<string, any>, "plain">;
-        timeoutMs: z<number, number, "plain">;
-        cloneRetry: z<boolean, boolean, "plain">;
-        fallbackTarball: z<boolean, boolean, "plain">;
-        allowHttpArchives: z<boolean, boolean, "plain">;
-    }>>, "plain">;
-    mcpEnhanced: z<boolean, boolean, "volatile-defined">;
-    scanProjectLayouts: z<boolean, boolean, "volatile-defined">;
-    downloadRegion: z<"auto" | "global" | "china", "auto" | "global" | "china", "volatile-defined">;
-    feedbackEnabled: z<boolean, boolean, "volatile-defined">;
-    autoUpdateSources: z<boolean, boolean, "volatile-defined">;
-}>>, "plain">;
-export declare function apply(ctx: Context, config?: Config): Promise<void>;
+/** Public installation entry; domain ownership lives in private workspace packages. */
+export * from './packages/market-bundle/src/index.js';

package/lib/types/{application → packages/market-bundle/src/application}/catalog.d.ts

@@ -1,15 +1,17 @@
-import type { LspLegacySeamMigration, LspStatusPayload } from '../contracts/lsp-status.js';
-import type { OverviewPayload, ServerConfigPayload, SkillContent, SourceProgress, SuiteDetail } from '../contracts/market.js';
-import type { McpStatusPayload } from './mcp/mcp-status.js';
-import type { SourceRef, Suite, SuiteSurfaceKey } from '../model/types.js';
-import type { McpBackend } from '../contracts/mcp.js';
-import type { McpMountDiagnostic } from '../contracts/mcp.js';
-import { type McpServerOverride, type McpSuiteOverrides } from './mcp/mcp-overrides.js';
-import { type CatalogGitOptions, type CatalogOptions } from './catalog-context.js';
-import { type LspServerTable, type McpBackendInfo, type SourceInput, type SourcePatch } from './ports.js';
-import { type CatalogSnapshot } from './snapshot-cache.js';
-import { codeloadTarballUrl } from './source-store.js';
-import type { MarketService } from './queries.js';
+import type { LspLegacySeamMigration, LspStatusPayload } from '../../../market-contracts/src/contracts/lsp-status.js';
+import type { MenuRowFaceWire, OverviewPayload, ServerConfigPayload, SourceProgress, SuiteDetail, SuiteDocumentText, UserPanelKind } from '../../../market-contracts/src/contracts/market.js';
+import type { McpStatusPayload } from '../../../market-mcp/src/index.js';
+import type { SourceRef, Suite, SuiteSurfaceKey } from '../../../market-contracts/src/model/types.js';
+import type { McpBackend } from '../../../market-contracts/src/contracts/mcp.js';
+import type { McpMountDiagnostic } from '../../../market-contracts/src/contracts/mcp.js';
+import { type McpServerOverride, type McpSuiteOverrides } from '../../../market-mcp/src/index.js';
+import { type CatalogGitOptions, type CatalogOptions } from '../../../market-catalog/src/index.js';
+import type { DocumentTranslation, TranslationFields, TranslationSurfaceKind } from '../../../market-contracts/src/contracts/translation.js';
+import { type LspServerTable, type McpBackendInfo, type SourceInput, type SourcePatch } from '../../../market-contracts/src/ports/ports.js';
+import { type CatalogSnapshot } from '../../../market-catalog/src/index.js';
+import { codeloadTarballUrl } from '../../../market-catalog/src/index.js';
+import type { MarketService } from '../../../market-contracts/src/ports/queries.js';
+import type { ExtensionSuiteCandidate } from '../../../market-runtime/src/index.js';
 export declare class Catalog implements MarketService {
     private readonly context;
     private readonly ports;
@@ -18,6 +20,8 @@ export declare class Catalog implements MarketService {
     private readonly installs;
     private readonly mcp;
     private readonly lsp;
+    private readonly translation;
+    private readonly suiteQueries;
     constructor(options: CatalogOptions);
     /** Latest MCP mount diagnostics (suiteId -> reasons), fed by host reconcile. */
     get mcpDiagnostics(): McpMountDiagnostic[];
@@ -26,6 +30,26 @@ export declare class Catalog implements MarketService {
     get userRoot(): string;
     /** The plugin storage root holding per-suite `${PLUGIN_DATA}` directories and overrides. */
     get dataRoot(): string;
+    /** The shared Agent layout root the direct user declarations (hooks, MCP) are read from. */
+    get agentsRoot(): string;
+    /**
+     * The host locale preference the panels render in.
+     *
+     * A read that walks many rows resolves it once and passes the value to every
+     * {@link translateFields} call: the host answers the preference by projecting
+     * every profile entry's live configuration, so reading it per row made a
+     * panel's latency scale with its row count instead of its work.
+     */
+    get localePreference(): string;
+    /**
+     * The clock this catalog's caches age against.
+     *
+     * The panel row cache is derived from the same files the snapshot cache
+     * walks, so it measures its maximum age on the same timeline: a test that
+     * drives the catalog's injected clock drives both, and a deployment gets the
+     * one process clock.
+     */
+    now(): number;
     get sources(): SourceRef[];
     /** Whether one suite currently carries an install entry. */
     isInstalled(sourceId: string, suiteId: string): boolean;
@@ -33,6 +57,30 @@ export declare class Catalog implements MarketService {
     setScanProjectLayouts(enabled: boolean): Promise<void>;
     /** Load persisted user state once at plugin activation. */
     load(): Promise<void>;
+    /** Release the localizer's and the snapshot cache's timers; in-flight work still persists. */
+    dispose(): void;
+    /**
+     * Drop every cached translation, in memory and on disk.
+     *
+     * Translation is lazy, so this is the whole of the reset: nothing is queued
+     * here, and the next panel read repopulates the cache from scratch. The
+     * in-memory copy is emptied too, or the same process would keep serving text
+     * the file no longer holds.
+     * @returns fulfillment once the cache is empty.
+     */
+    clearTranslations(): Promise<void>;
+    /** Apply the current display preference to pending translation work. */
+    syncTranslationEnabled(): void;
+    /**
+     * Wait for queued translations to finish.
+     *
+     * Nothing on the request path calls this — the panel renders upstream text
+     * and re-reads. It exists so a test can observe the settled state instead of
+     * polling.
+     * @param deadlineMs - maximum wait; omitted waits for the queue alone.
+     * @returns whether the queue drained before the deadline.
+     */
+    settleDescriptions(deadlineMs?: number): Promise<boolean>;
     /** Append config-seeded sources missing from user state and persist them. */
     mergeSources(sources: SourceRef[]): Promise<void>;
     /**
@@ -49,16 +97,55 @@ export declare class Catalog implements MarketService {
     refreshSettled(deadlineMs?: number): Promise<boolean>;
     /** Read one coherent user-dimension snapshot, reusing in-flight discovery. */
     readUserCatalog(): Promise<CatalogSnapshot>;
+    /** Installed local user declarations, including globally disabled suites; never changes global runtime discovery. */
+    installedSuiteDeclarations(): Promise<ExtensionSuiteCandidate[]>;
     /** Read one coherent project-dimension snapshot for a workspace cwd. */
     readProjectCatalog(cwd: string): Promise<CatalogSnapshot>;
     /** Runtime discovery scans only sources containing an enabled install. No acquisition or network access. */
     enabledUserSuites(): Promise<Suite[]>;
-    /** The full market overview from one user snapshot. */
+    /**
+     * The full market overview from one user snapshot.
+     *
+     * The description is localized on the way out: a suite whose text is already
+     * Chinese (or already bilingual) is served as authored, and every other
+     * description is translated in the background. The read itself never waits on
+     * a provider call — a suite with no cached translation carries its original
+     * text plus a translated field only once one lands, and the panel re-reads
+     * while anything reports itself pending.
+     */
     overview(): Promise<OverviewPayload>;
-    /** One suite's full detail for the market detail modal. */
-    suiteDetail(sourceId: string, suiteId: string): Promise<SuiteDetail>;
-    /** One skill's full SKILL.md text for the market detail modal. */
-    skillContent(sourceId: string, suiteId: string, skillName: string): Promise<SkillContent>;
+    /** One entity's translated description, pending count included. {@link TranslationService.translateFields} owns the rule. */
+    translateFields(surface: TranslationSurfaceKind, id: string, fields: {
+        name?: string | undefined;
+        description?: string | undefined;
+    }, locale: string): {
+        fields: TranslationFields;
+        pending: number;
+    };
+    /** One authored text translated chunk by chunk. {@link TranslationService.translateDocument} owns the rule for bodies. */
+    translateDocument(surface: TranslationSurfaceKind, id: string, text: string, locale: string, retry?: boolean): DocumentTranslation;
+    /**
+     * The localized face of every `/` menu row this plugin owns.
+     *
+     * The rows come from the runtime registries (through
+     * {@link CatalogPorts.menuRowIdentities}) because only they know the call name
+     * a command actually got; the text comes from the shared translation service,
+     * because the panel reads it through the same translation cache. Resolution
+     * is a cache read and never a provider call: a row whose text is not cached
+     * yet answers without a face, and the panel read that follows queues it.
+     *
+     * A field is emitted only when the translation differs from the authored
+     * text. The menu shows the call name beside the label, so a name that
+     * translated to itself would only duplicate the alias.
+     * @returns one wire row per owned menu row, without rows carrying no translation.
+     */
+    menuRowFaces(): Promise<MenuRowFaceWire[]>;
+    /** One suite's full detail. {@link SuiteQueries.suiteDetail} owns the composition. */
+    suiteDetail(sourceId: string, suiteId: string, projectCwd?: string): Promise<SuiteDetail>;
+    /** One suite document's authored text. {@link SuiteQueries.suiteDocument} owns the read. */
+    suiteDocument(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, projectCwd?: string): Promise<SuiteDocumentText>;
+    /** One suite document's translation. {@link SuiteQueries.suiteDocumentTranslation} owns the keying. */
+    suiteDocumentTranslation(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, retry?: boolean, projectCwd?: string): Promise<DocumentTranslation>;
     /** Add a source and acquire it immediately (clone, download, or in-place). */
     addSource(input: SourceInput): Promise<SourceRef>;
     /** Register one unmanaged `.sources/` checkout as a source without touching its files. */
@@ -92,11 +179,19 @@ export declare class Catalog implements MarketService {
     setSurface(sourceId: string, suiteId: string, surface: SuiteSurfaceKey, enabled: boolean): Promise<void>;
     /** Build the flat MCP service inventory for the status surface. */
     mcpStatus(): Promise<McpStatusPayload>;
-    /** Persist a user-owned MCP service and reconcile its bridge mount. */
-    addMcpServer(name: string, server: unknown): Promise<void>;
-    /** Read effective service configuration without exposing credential literals. */
-    serverConfig(kind: 'mcp' | 'lsp', id: string): Promise<ServerConfigPayload>;
-    /** Validate a complete replacement before writing; plugin checkouts remain untouched. */
+    /** Validate and persist a user-owned MCP service with optional policy before reconciling its mount. */
+    addMcpServer(name: string, server: unknown, policy?: unknown): Promise<void>;
+    /**
+     * Read a service without credential literals, or an unsaved template when
+     * `create` is true. The two transports have separate owners, so this facade
+     * only routes the request to the module that owns the declaration.
+     */
+    serverConfig(kind: 'mcp' | 'lsp', id: string, create?: boolean): Promise<ServerConfigPayload>;
+    /**
+     * Validate a complete replacement before writing; plugin checkouts remain
+     * untouched. The MCP half also carries the editing policy, which the LSP
+     * document has no seat for.
+     */
     saveServerConfig(kind: 'mcp' | 'lsp', id: string, config: unknown, policy?: unknown): Promise<void>;
     /** One suite's persisted MCP overrides, addressed by qualified suite id. */
     mcpOverrides(sourceId: string, suiteId: string): Promise<McpSuiteOverrides>;

package/lib/types/packages/market-bundle/src/application/details.d.ts

@@ -0,0 +1,24 @@
+import type { SuiteDetail, UserPanelKind } from '../../../market-contracts/src/contracts/market.js';
+import { type InstalledEntry, type Suite } from '../../../market-contracts/src/model/types.js';
+import type { McpMountDiagnostic as McpDiagnostic } from '../../../market-contracts/src/contracts/mcp.js';
+/** Build the detail response for one normalized suite. */
+export declare function buildSuiteDetail(suite: Suite, installed: InstalledEntry | undefined, diagnostics: readonly McpDiagnostic[], mcpOverrides?: Record<string, Record<string, unknown>>): Promise<SuiteDetail>;
+/**
+ * Read one of a suite's document surfaces — a skill, a command, or an agent —
+ * by the identity the market detail page addresses it with.
+ *
+ * This is the only body the market ever serves. The detail payload carries a
+ * document's name and description so its row can render, and the text arrives
+ * here when a reader opens that row, whole and uncut.
+ *
+ * The suite's own scanned resource list is the only source of a path: the
+ * caller names a document, never a path, and a name the scan did not produce is
+ * a miss rather than a lookup. Commands and agents read the same resource the
+ * scan that built the detail payload found, so a document read here is the
+ * document that payload named — re-read rather than taken from the request.
+ * @param suite - the normalized suite the document belongs to.
+ * @param kind - which of the three document surfaces the name belongs to.
+ * @param name - the document's name inside that surface.
+ * @returns the document's text exactly as authored.
+ */
+export declare function readSuiteDocument(suite: Suite, kind: UserPanelKind, name: string): Promise<string>;

package/lib/types/packages/market-bundle/src/application/extension-inventory.d.ts

@@ -0,0 +1,45 @@
+import type { CatalogPort as Catalog } from '../../../market-runtime/src/index.js';
+import type { PanelResourceStore } from '../../../market-runtime/src/index.js';
+import { type ExtensionResource } from '../../../market-contracts/src/contracts/extension-presets.js';
+import type { UserPanelEntryWire, UserPanelKind } from '../../../market-contracts/src/contracts/market.js';
+import { type Suite } from '../../../market-contracts/src/model/types.js';
+import type { McpSuiteOverrides } from '../../../market-mcp/src/index.js';
+import type { ExtensionSuiteCandidate } from '../../../market-runtime/src/index.js';
+export interface ExtensionInventoryPorts {
+    catalog: Pick<Catalog, 'overview' | 'mcpStatus' | 'lspStatus'>;
+    panels: Record<UserPanelKind, Pick<PanelResourceStore, 'list'>>;
+}
+/** Shared options every mode honours. */
+interface ExtensionInventoryBaseOptions {
+    sessionId?: string;
+    mcpSessionControl?: boolean;
+    /** Legacy mode: installed/local suites without validated declarations. */
+    projectSuites?: readonly Suite[];
+    /**
+     * Suites whose hook declarations this read publishes. The session inventory
+     * lists project hooks, installed user-dimension suites and the @user-hooks
+     * suite here; it stays separate from {@link projectSuites} so project owner
+     * addressing keeps its meaning. Absent, the hook source is projectSuites.
+     */
+    hookSuites?: readonly Suite[];
+}
+/** Candidate mode: the override data must be explicit, because a missing value would read as "enabled". */
+export interface ExtensionInventoryCandidateOptions extends ExtensionInventoryBaseOptions {
+    /** Validated declarations from the parse owner; `validSurfaces` is the availability evidence. */
+    candidates: readonly ExtensionSuiteCandidate[];
+    /** Per-suite MCP overrides, keyed by resource id. Required: absence is never "on". */
+    mcpOverrides: ReadonlyMap<string, McpSuiteOverrides>;
+    /** LSP server ids the user disabled, in the identity the LSP rows use. Required for the same reason. */
+    lspDisabledIds: ReadonlySet<string>;
+}
+/** Legacy mode: no candidates, so no validated-surface or override data exists. */
+export interface ExtensionInventoryLegacyOptions extends ExtensionInventoryBaseOptions {
+    candidates?: undefined;
+    mcpOverrides?: undefined;
+    lspDisabledIds?: undefined;
+}
+export type ExtensionInventoryOptions = ExtensionInventoryCandidateOptions | ExtensionInventoryLegacyOptions;
+/** Suite panel ids are JSON tuples, not display names or flattened command identifiers. */
+export declare function suiteResourceOwner(entry: UserPanelEntryWire): string | undefined;
+export declare function readExtensionInventory(ports: ExtensionInventoryPorts, options?: ExtensionInventoryOptions): Promise<ExtensionResource[]>;
+export { extensionResourceEnabled } from '../../../market-runtime/src/index.js';

package/lib/types/packages/market-bundle/src/application/extension-project.d.ts

@@ -0,0 +1,26 @@
+/** Read-only project resources reuse the full user-facing detail and document readers. */
+import type { CatalogPort as Catalog } from '../../../market-runtime/src/index.js';
+import { createPanelResources } from '../../../market-runtime/src/index.js';
+import type { McpToolSnapshot } from '../../../market-contracts/src/ports/ports.js';
+import type { McpMountDiagnostic } from '../../../market-contracts/src/contracts/mcp.js';
+import type { Suite } from '../../../market-contracts/src/model/types.js';
+import type { UserPanelKind } from '../../../market-contracts/src/contracts/market.js';
+/** What one session's workspace can read: the project suites plus the full user-facing detail readers. */
+export type ProjectExtensionReader = ReturnType<typeof createProjectExtensionResources>;
+export declare function createProjectExtensionResources(catalog: Catalog, users: Parameters<typeof createPanelResources>[1], cwd: string): {
+    panels: Record<UserPanelKind, import("../../../market-runtime/src/index.js").PanelResourceStore>;
+    suites: () => Promise<Suite[]>;
+    suiteDetail(sourceId: string, suiteId: string): Promise<import("../../../market-contracts/src/contracts/market.js").SuiteDetail>;
+    /**
+     * One document of this workspace's suite, on any of the three surfaces.
+     *
+     * The lookup stays in Catalog — one reader for skills, commands and agents — and
+     * the project cwd only selects which snapshot answers. Re-scanning here would
+     * duplicate the catalog's own identity handling.
+     */
+    suiteDocument(sourceId: string, suiteId: string, kind: UserPanelKind, name: string): Promise<import("../../../market-contracts/src/contracts/market.js").SuiteDocumentText>;
+    /** The same document's translation, answered from this workspace's snapshot. */
+    suiteDocumentTranslation(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, retry?: boolean): Promise<import("@dsh-market/contracts/contracts/translation").DocumentTranslation>;
+    mcpStatus(diagnostics?: McpMountDiagnostic[], observed?: readonly McpToolSnapshot[]): Promise<import("@dsh-market/contracts/contracts/mcp-status").McpStatusPayload>;
+    lspStatus(): Promise<import("@dsh-market/contracts/contracts/lsp-status").LspStatusPayload>;
+};

package/lib/types/packages/market-bundle/src/application/resource-inventory.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The project resource window's installed inventory.
+ *
+ * One aggregation over the data planes that already exist — the market
+ * overview (installed suites), the three user panels (skills, commands,
+ * agents), the MCP status surface, and the LSP status surface — assembled
+ * here into the row shape the window renders. No second scan pipeline runs:
+ * every row cites the source of truth that already feeds the settings panels,
+ * and the per-entry enable flags come from the workspace filter state.
+ *
+ * @module application/resource-inventory
+ */
+import type { Catalog } from './catalog.js';
+import type { PanelResourceStore } from '../../../market-runtime/src/index.js';
+import type { ResourceFavoriteWire, ResourceWindowPayload } from '../../../market-contracts/src/contracts/resource-window.js';
+import type { ResourceFilters } from '../../../market-runtime/src/index.js';
+/** Structural catalog surface the inventory reads. */
+interface InventoryCatalog {
+    overview(): Promise<import('../../../market-contracts/src/contracts/market.js').OverviewPayload>;
+    mcpStatus(): Promise<import('../../../market-contracts/src/contracts/mcp-status.js').McpStatusPayload>;
+    lspStatus(): Promise<import('../../../market-contracts/src/contracts/lsp-status.js').LspStatusPayload>;
+}
+/** Structural filter state the inventory reads (implemented by the runtime service). */
+export interface InventoryFilterSource {
+    currentFilters(): ResourceFilters;
+    favorites(): Promise<ResourceFavoriteWire[]>;
+}
+/** The stores and services one inventory read needs. */
+export interface ResourceInventoryDeps {
+    catalog: InventoryCatalog | Catalog;
+    panels: {
+        skills: PanelResourceStore;
+        commands: PanelResourceStore;
+        agents: PanelResourceStore;
+    };
+    filters: InventoryFilterSource;
+    /** The workspace label the header chip shows; defaults to the process cwd. */
+    workspace?: string;
+}
+/** Build one window payload from the live stores. */
+export declare function buildResourceWindow(deps: ResourceInventoryDeps): Promise<ResourceWindowPayload>;
+export {};

package/lib/types/packages/market-bundle/src/application/server-config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Compatibility barrel for the service-configuration helpers that used to live
+ * here. Each declaration now belongs to the domain that owns it: MCP validation
+ * and redaction-restore to market-mcp, LSP validation and the override layer to
+ * market-lsp. The re-exports stay so existing importers and tests keep their
+ * current specifier; new code imports the owning module directly.
+ */
+export { McpConfigError, restoreRedactedConfig, validateServerMcp, type McpFieldError } from '../../../market-mcp/src/index.js';
+export { applyLspOverrides, loadLspOverrides, lspConfig, saveLspOverride, validateServerLsp } from '../../../market-lsp/src/index.js';