dsh-agent-plugins-market 0.9.0 → 0.9.2

package/lib/types/packages/market-contracts/src/ports/ports.d.ts

@@ -0,0 +1,183 @@
+/**
+ * The host seams a catalog consumes, in one declared place.
+ *
+ * Every seam is read at call time rather than captured at construction: the
+ * credentials, tools and settings services resolve *after* `apply()` returns,
+ * so a value snapshotted when the catalog is built would stay undefined for
+ * the rest of the process. A composition root wires the seams it has;
+ * {@link resolveCatalogPorts} fills in the rest from
+ * {@link defaultCatalogPorts}, which keeps a bare `new Catalog({...})` — the
+ * shape the tests build — fully functional.
+ */
+import type { LspServerSpec, SourceKind } from '../model/types.js';
+import type { MenuRowSource } from '../contracts/market.js';
+export type { McpBackendInfo } from '../contracts/market.js';
+import type { DownloadRegionSetting } from '../contracts/settings.js';
+import type { McpBackend } from '../contracts/mcp.js';
+import type { LspMountDiagnostic } from '../contracts/lsp.js';
+import type { DocumentTranslation, TranslationFields, TranslationProvider, TranslationSurfaceKind } from '../contracts/translation.js';
+/**
+ * One localization read: the fields resolved now, and how many of them this
+ * read queued and has not seen land yet. A surface reports the count so its
+ * reader can re-read until the translations arrive instead of staying on the
+ * authored text.
+ */
+export interface LocalizeResult {
+    fields: TranslationFields;
+    pending: number;
+}
+/**
+ * Resolve one entity's translatable fields for a surface.
+ *
+ * `locale` is required: the caller resolved the host preference once for the
+ * read it is serving. Resolving it is not free — the host projects every active
+ * profile entry's live configuration to answer it — so there is deliberately no
+ * default and no omitted form here: a resolver that fell back to resolving the
+ * preference itself made a read's cost scale with its entity count.
+ */
+export type LocalizeFields = (surface: TranslationSurfaceKind, id: string, fields: {
+    name?: string | undefined;
+    description?: string | undefined;
+}, locale: string) => LocalizeResult;
+/**
+ * Resolve one document body for a surface, chunk by chunk.
+ *
+ * A document is not a field: it is longer than any single provider request may
+ * carry, so the resolver splits it, queues what is missing, and answers with
+ * whatever is ready. The same "never wait, report pending" contract as
+ * {@link LocalizeFields} holds, and for the same reason — a reader must be able
+ * to open a document without a provider round trip standing between it and the
+ * page.
+ *
+ * `locale` is required for the reason {@link LocalizeFields} documents.
+ */
+export type LocalizeDocument = (surface: TranslationSurfaceKind, id: string, text: string, locale: string, retry?: boolean) => DocumentTranslation;
+/**
+ * One read's localization: the host locale, and the resolver that applies it.
+ *
+ * The two travel together because resolving the locale is a whole-profile
+ * projection, never a per-entity question. A surface that walks entities — the
+ * MCP and LSP status inventories — receives the pair from the caller that owns
+ * the read instead of resolving anything itself.
+ */
+export interface Localization {
+    locale: string;
+    localizeFields: LocalizeFields;
+}
+/** One MCP tool observed from the host tool registry (structural). */
+export interface McpToolSnapshot {
+    name: string;
+    description?: string;
+    /** The input schema the server advertised, when the host exposes it. */
+    parameters?: unknown;
+}
+/** The LSP mount-registry surface the aggregator consumes (structural, for tests). */
+export interface LspMountStatusSource {
+    diagnosticsSnapshot(): Map<string, LspMountDiagnostic>;
+    hasLiveMounts(): boolean;
+    disabledServers?(): Set<string>;
+}
+/** A new source: its location, optional branch, and acquisition kind. */
+export interface SourceInput {
+    url: string;
+    branch?: string;
+    local?: boolean;
+    kind?: SourceKind;
+    sha256?: string;
+}
+/** A partial source update; omitted fields keep their persisted value. */
+export interface SourcePatch {
+    url?: string;
+    branch?: string;
+    local?: boolean;
+    kind?: SourceKind;
+    sha256?: string;
+}
+/** The user's direct LSP server table, keyed by server name. */
+export type LspServerTable = Record<string, LspServerSpec>;
+/** Credential-store seam backing the MCP re-authorize action. */
+export interface CredentialGrantStore {
+    deleteGrantRecord(serverName: string): Promise<void>;
+}
+/**
+ * One menu row this plugin owns, paired with the panel identity that
+ * translates it.
+ *
+ * The runtime half of the join lives behind this record because only the
+ * registries know the call name a command actually got, while only the panels
+ * know the id and authored text a translation is cached under. The catalog
+ * joins them without importing either.
+ */
+export interface MenuRowIdentity {
+    /** Which `/` menu group the row belongs to. */
+    readonly source: MenuRowSource;
+    /** The name the menu row carries — the allocated call name for a command. */
+    readonly name: string;
+    /** The identity the panel translates the entry under; the same id means the same cache entry. */
+    readonly id: string;
+    /** The authored name the panel handed to the translator. */
+    readonly authoredName: string;
+    /** The authored description the panel handed to the translator; absent when it had none. */
+    readonly authoredDescription?: string;
+}
+/** The complete set of host seams a catalog needs; every member is resolved. */
+export interface CatalogPorts {
+    /** Live host MCP tool registry snapshot for the status surface. */
+    mcpToolSnapshot(): readonly McpToolSnapshot[];
+    /** Absent when the credentials service is not mounted in this composition. */
+    credentialsStore: CredentialGrantStore | undefined;
+    /** Flags one mount key for an explicit rebuild on the next reconcile. */
+    mcpRemount(suiteId: string, serverKey: string): void;
+    /** Flags every live mount for an explicit rebuild on the next reconcile. */
+    mcpRemountAll(): void;
+    /** Resolves the mount key owning one derived serverName; undefined when not mounted. */
+    mcpServerOwner(serverName: string): {
+        suiteId: string;
+        serverKey: string;
+    } | undefined;
+    /** Latest LSP mount diagnostics. */
+    lspStatusSource: LspMountStatusSource;
+    /** The persisted MCP mount backend choice. */
+    mcpBackend(): Promise<McpBackend>;
+    /** Persists an MCP mount backend choice. */
+    setMcpBackend(backend: McpBackend): Promise<void>;
+    /** The persisted download-region setting. */
+    downloadRegion(): Promise<DownloadRegionSetting>;
+    /** The host locale preference ('zh' default when unset). */
+    localePreference(): string;
+    /**
+     * Every `/` menu row this plugin currently owns, with the panel identity it
+     * translates as. Empty when nothing is registered.
+     */
+    menuRowIdentities(): Promise<readonly MenuRowIdentity[]>;
+    /**
+     * The ordered translation chain, best provider first. An empty array means
+     * this deployment translates nothing and every surface renders the upstream
+     * text as authored.
+     */
+    translationProviders?: readonly TranslationProvider[] | undefined;
+    /**
+     * Whether translation is switched on, read per call.
+     *
+     * The chain above is built once, while the user's switch can flip at any
+     * time, so the switch is a live read rather than a second captured value.
+     * Absent means on, so a composition that omits it keeps translating.
+     */
+    translationEnabled?: (() => boolean) | undefined;
+    /**
+     * Stable identity of the current chain, folded into every cache key.
+     *
+     * A deployment that changes engines must miss the entries the previous chain
+     * filled rather than serve its output as if the new chain had produced it.
+     */
+    translationProviderIdentity?: (() => string) | undefined;
+}
+/** The seams a composition root may wire; the rest fall back to the defaults. */
+export type CatalogPortsOverride = Partial<CatalogPorts>;
+/**
+ * The seams a catalog runs on when nothing is wired. The MCP backend writer
+ * rejects rather than silently accepting a choice nothing can persist.
+ */
+export declare const defaultCatalogPorts: CatalogPorts;
+/** Fill in every seam the composition root left unwired. */
+export declare function resolveCatalogPorts(overrides?: CatalogPortsOverride): CatalogPorts;

package/lib/types/{application → packages/market-contracts/src/ports}/queries.d.ts

@@ -1,15 +1,17 @@
 /** Narrow application interfaces consumed by the HTTP transport adapter. */
-import type { McpStatusPayload } from './mcp/mcp-status.js';
+import type { McpStatusPayload } from '../contracts/mcp-status.js';
 import type { LspLegacySeamMigration, LspStatusPayload } from '../contracts/lsp-status.js';
-import type { OverviewPayload, SkillContent, SourceProgress, SuiteDetail } from '../contracts/market.js';
+import type { MenuRowFaceWire, OverviewPayload, SourceProgress, SuiteDetail, SuiteDocumentText, UserPanelKind } from '../contracts/market.js';
+import type { DocumentTranslation } from '../contracts/translation.js';
 import type { SourceRef, SuiteSurfaceKey } from '../model/types.js';
-import type { McpServerOverride, McpSuiteOverrides } from './mcp/mcp-overrides.js';
+import type { McpServerOverride, McpSuiteOverrides } from '../contracts/mcp-overrides.js';
 import type { McpBackend } from '../contracts/mcp.js';
 import type { ServerConfigPayload } from '../contracts/market.js';
 import type { LspServerTable, McpBackendInfo, SourceInput, SourcePatch } from './ports.js';
 /** Read-only market operations required by HTTP routes. */
 export interface MarketQueries {
-    serverConfig(kind: 'mcp' | 'lsp', id: string): Promise<ServerConfigPayload>;
+    /** Creation templates carry empty identity fields and the current backend defaults. */
+    serverConfig(kind: 'mcp' | 'lsp', id: string, create?: boolean): Promise<ServerConfigPayload>;
     readonly sources: SourceRef[];
     overview(): Promise<OverviewPayload>;
     mcpStatus(): Promise<McpStatusPayload>;
@@ -17,13 +19,30 @@ export interface MarketQueries {
     lspServers(): Promise<LspServerTable>;
     sourceProgress(): SourceProgress;
     suiteDetail(sourceId: string, suiteId: string): Promise<SuiteDetail>;
-    skillContent(sourceId: string, suiteId: string, skillName: string): Promise<SkillContent>;
+    /**
+     * One suite document's authored text — a skill, a command, or an agent — for
+     * the market detail page's lazy row read. The suite and the document are
+     * resolved here: the caller names an identity and never a path or text.
+     */
+    suiteDocument(sourceId: string, suiteId: string, kind: UserPanelKind, name: string): Promise<SuiteDocumentText>;
+    /**
+     * One suite document translated for the market detail page's locale, chunk by
+     * chunk. The suite and the document are re-read here: the route names an
+     * identity and never carries text.
+     */
+    suiteDocumentTranslation(sourceId: string, suiteId: string, kind: UserPanelKind, name: string, retry?: boolean): Promise<DocumentTranslation>;
     mcpOverrides(sourceId: string, suiteId: string): Promise<McpSuiteOverrides>;
+    /**
+     * The localized face of every `/` menu row this plugin owns: the slash
+     * commands and skills the menu shows, with the text the panels already
+     * translated. Empty while nothing is translated.
+     */
+    menuRowFaces(): Promise<MenuRowFaceWire[]>;
 }
 /** Mutating market operations required by HTTP routes. */
 export interface MarketMutations {
     saveServerConfig(kind: 'mcp' | 'lsp', id: string, config: unknown, policy?: unknown): Promise<void>;
-    addMcpServer(name: string, server: unknown): Promise<void>;
+    addMcpServer(name: string, server: unknown, policy?: unknown): Promise<void>;
     addLspServer(name: string, config: unknown): Promise<void>;
     addSource(input: SourceInput): Promise<SourceRef>;
     updateSource(sourceId: string, patch: SourcePatch): Promise<void>;
@@ -58,6 +77,8 @@ export interface MarketMutations {
     mcpReauthorizeAvailable(): boolean;
     /** The active MCP backend, host-client probe, and download region. */
     mcpBackendInfo(): Promise<McpBackendInfo>;
+    /** Drop every cached translation; translation is lazy, so the next read refills it. */
+    clearTranslations(): Promise<void>;
     /** Switch the MCP mount backend and remount every suite server through it. */
     setMcpBackend(backend: McpBackend): Promise<void>;
     /**

package/lib/types/{application/mcp/mcp-redaction.d.ts → packages/market-contracts/src/redaction.d.ts}

@@ -10,3 +10,5 @@ export declare function redactUrl(raw: string): string;
  * and endpoints carry credential-bearing queries.
  */
 export declare function redactErrorMessage(raw: string): string;
+/** Restore only unchanged redacted leaves, rejecting invented masked values. */
+export declare function restoreRedactedConfig(input: unknown, original: unknown, redacted?: unknown): unknown;

package/lib/types/{application → packages/market-lsp/src/application}/lsp/lsp-direct-config.d.ts

@@ -1,4 +1,4 @@
-import type { LspServerSpec } from '../../model/types.js';
+import type { LspServerSpec } from '../../../../market-contracts/src/model/types.js';
 /** The direct LSP server configuration file path. */
 export declare function lspServersPath(agentsRoot: string): string;
 /** Load the user-configured LSP servers; unreadable or invalid files yield an empty table. */

package/lib/types/{application → packages/market-lsp/src/application}/lsp/lsp-status.d.ts

@@ -12,9 +12,10 @@
  * Direct user-configured rows follow the same model under the sentinel suite
  * id `direct` (mirroring mcp-status's `plugin`/`direct` split).
  */
-import type { LspStatusPayload } from '../../contracts/lsp-status.js';
-import type { LspMountDiagnostic } from '../../contracts/lsp.js';
-import type { LspServerSpec, Suite } from '../../model/types.js';
+import type { LspStatusPayload } from '../../../../market-contracts/src/contracts/lsp-status.js';
+import type { LspMountDiagnostic } from '../../../../market-contracts/src/contracts/lsp.js';
+import type { Localization } from '../../../../market-contracts/src/ports/ports.js';
+import type { LspServerSpec, Suite } from '../../../../market-contracts/src/model/types.js';
 /** Sentinel suite id for user-configured (non-suite) LSP servers. */
 export declare const DIRECT_LSP_SUITE_ID = "direct";
 /** The subset of LspMountRegistry the aggregator consumes (structural, for tests). */
@@ -28,5 +29,20 @@ export interface LspDirectServersSource {
     servers: Record<string, LspServerSpec>;
     errors: string[];
 }
-/** Build the status payload from declarations, direct configuration, and mount diagnostics. */
-export declare function buildLspStatus(suites: readonly Suite[], registry: LspMountStatusSource, direct?: LspDirectServersSource): LspStatusPayload;
+/**
+ * Build the status payload from declarations, direct configuration, and mount diagnostics.
+ *
+ * A row carries only its server key, and a name is never translated: the
+ * declaration has no description, so the LSP surface yields no translation unit
+ * and the localization read answers with no fields. The parameter is optional,
+ * and a caller that omits it renders the same upstream key.
+ * @param suites - the discovered suites whose LSP declarations form the inventory.
+ * @param registry - the mount registry's diagnostics and live-mount flag.
+ * @param direct - the user's own configured servers.
+ * @param localization - the locale this whole inventory renders in and the
+ * resolver bound to it, when the deployment translates at all. Resolved once by
+ * the caller: every declared server is localized from this one value, never from
+ * a fresh read of the host preference.
+ * @returns the status payload.
+ */
+export declare function buildLspStatus(suites: readonly Suite[], registry: LspMountStatusSource, direct?: LspDirectServersSource, localization?: Localization): LspStatusPayload;

package/lib/types/packages/market-lsp/src/application/lsp/validation.d.ts

@@ -0,0 +1,8 @@
+import type { LspServerSpec, Suite } from '../../../../market-contracts/src/model/types.js';
+/** Validate one language-server declaration before it is stored. */
+export declare function validateServerLsp(key: string, config: unknown): LspServerSpec;
+/** Public configuration excludes the parser's derived identity. */
+export declare function lspConfig(spec: LspServerSpec): Record<string, unknown>;
+export declare function loadLspOverrides(root: string): Promise<Record<string, LspServerSpec>>;
+export declare function saveLspOverride(root: string, id: string, config: LspServerSpec): Promise<void>;
+export declare function applyLspOverrides(root: string, suites: Suite[]): Promise<Suite[]>;

package/lib/types/{application → packages/market-lsp/src/application}/lsp-service.d.ts

@@ -1,19 +1,22 @@
 /**
- * LSP use cases: the status surface, the user's direct server table, and the
- * per-server enable switch.
+ * LSP use cases: the status surface, the user's direct server table, the
+ * per-server enable switch, and the service-configuration editor for one
+ * language-server declaration.
  *
  * Direct servers live in the shared Agent layout root (`~/.agents/lsp.json`)
  * and are merged with the suites' inline declarations at mount time; a
  * suite's own declaration stays source-owned and is never rewritten. The
  * per-server enable switch stays plugin state under the data root.
  */
-import type { LspLegacySeamMigration, LspStatusPayload } from '../contracts/lsp-status.js';
-import type { CatalogContext } from './catalog-context.js';
-import type { CatalogPorts, LspServerTable } from './ports.js';
+import type { LspLegacySeamMigration, LspStatusPayload } from '../../../market-contracts/src/contracts/lsp-status.js';
+import type { ServerConfigPayload } from '../../../market-contracts/src/contracts/market.js';
+import type { CatalogContext } from '../../../market-catalog/src/index.js';
+import type { CatalogPorts, LocalizeFields, LspServerTable } from '../../../market-contracts/src/ports/ports.js';
 export declare class LspService {
     private readonly context;
     private readonly ports;
-    constructor(context: CatalogContext, ports: CatalogPorts);
+    private readonly localizeFields;
+    constructor(context: CatalogContext, ports: CatalogPorts, localizeFields: LocalizeFields);
     /** The LSP status surface: declared servers merged with mount diagnostics. */
     status(): Promise<LspStatusPayload>;
     /** The profile layer behind a reported seam conflict, when one can be found. */
@@ -33,4 +36,14 @@ export declare class LspService {
     setServers(raw: unknown): Promise<LspServerTable>;
     /** Enable or disable one declared language server by row id. */
     setEnabled(id: string, enabled: boolean): Promise<void>;
+    /** Read one LSP declaration without credential literals, or an unsaved creation template. */
+    serverConfig(id: string, create?: boolean): Promise<ServerConfigPayload>;
+    /** Validate a complete replacement before writing; plugin checkouts remain untouched. */
+    saveServerConfig(id: string, config: unknown): Promise<void>;
+    /**
+     * Resolve one editable declaration: its key, owning suite, root, and the
+     * public document the editor renders. A suite's replacement override is
+     * applied first, so an edited declaration renders what will be mounted.
+     */
+    private resolve;
 }

package/lib/types/packages/market-lsp/src/index.d.ts

@@ -0,0 +1,8 @@
+/** Explicit cross-domain entry surface. Internal modules are not import targets for siblings. */
+export { loadLspOverrides, lspConfig, saveLspOverride, validateServerLsp } from './application/lsp/validation.js';
+export { applyLspOverrides } from './application/lsp/validation.js';
+export { LspService } from './application/lsp-service.js';
+export { DIRECT_LSP_SUITE_ID, buildLspStatus } from './application/lsp/lsp-status.js';
+export { loadLspServers } from './application/lsp/lsp-direct-config.js';
+export { loadDisabledLspServers } from './application/lsp/lsp-server-state.js';
+export { LspMountRegistry } from './runtime/lsp/lsp-mounts.js';

package/lib/types/{runtime → packages/market-lsp/src/runtime}/lsp/lsp-mounts.d.ts

@@ -1,6 +1,6 @@
 /**
  * Runtime LSP mounts: one live `dsh-lsp-stdio` child plugin per enabled
- * suite's inline `lspServers` table, mounted through `ctx.plugin`.
+ * provider in a suite's inline `lspServers` table, mounted through `ctx.plugin`.
  *
  * Mounts reconcile against the enabled-suite set exactly like the MCP mounts:
  * reconcile() unmounts rows whose suite was disabled or removed and mounts
@@ -28,10 +28,11 @@
  * user resolves it through per-suite surface toggles.
  */
 import type { Context } from '@deepseek-ai/cordis';
+import type { ExtensionLspProvider } from '../../../../market-runtime/src/index.js';
 import { type LegacyLspSeam } from '../../application/lsp/profile-seam.js';
-import { type PluginPathContext } from '../../catalog/plugin-variables.js';
-import { type Suite } from '../../model/types.js';
-import type { LspMountDiagnostic } from '../../contracts/lsp.js';
+import { type PluginPathContext } from '../../../../market-catalog/src/index.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+import type { LspMountDiagnostic } from '../../../../market-contracts/src/contracts/lsp.js';
 export type { LspMountDiagnostic };
 /** One dsh-lsp-stdio server configuration row (its Config.servers entry). */
 export interface LspStdioServerConfig {
@@ -90,8 +91,11 @@ export declare class LspMountRegistry {
     private pluginDataRoot?;
     /** Direct (user-configured) server provider; defaults to none. */
     private directProvider;
+    /** Per-workspace entry filter; an absent provider mounts everything wanted. */
+    private entryFilter;
     private disabledProvider;
     private disabledSnapshot;
+    private demandedProviderIds;
     constructor(ctx: Context, loadHost?: () => Promise<HostModule | undefined>, loadService?: () => Promise<HostModule | undefined>, loadTool?: () => Promise<HostModule | undefined>, locateSeams?: () => Promise<LegacyLspSeam[]>);
     /** Queue one reconciliation behind any in-flight mount/unmount pass. */
     reconcile(enabledSuites: Suite[]): Promise<LspMountDiagnostic[]>;
@@ -134,14 +138,30 @@ export declare class LspMountRegistry {
     /** Install the plugin storage root per-suite data directories resolve against. */
     setPluginDataRoot(root: string): void;
     /** Install the direct (user-configured) server provider used at reconcile time. */
-    setDirectProvider(provider: () => Promise<Record<string, import('../../model/types.js').LspServerSpec>>): void;
+    setDirectProvider(provider: () => Promise<Record<string, import('../../../../market-contracts/src/model/types.js').LspServerSpec>>): void;
+    /**
+     * Install the per-workspace entry filter read at wanted-row time. A filtered
+     * server is never added to its suite's wanted config, so it unmounts through
+     * the ordinary fingerprint pass; the registry itself stays attached.
+     */
+    setEntryFilter(filter: () => {
+        allows(face: 'lsp', entryId: string): boolean;
+    }): void;
+    /** Session demand overrides ordinary disabled-provider defaults only; validation and entry filters still apply. */
+    setDemandedProviderIdsProvider(provider: () => ReadonlySet<string>): void;
     setDisabledProvider(provider: () => Promise<Set<string>>): void;
+    /** Read current global disabled IDs without merging session demand. */
+    globalDisabledProviderIds(): Promise<ReadonlySet<string>>;
     disabledServers(): Set<string>;
     /** The latest mount diagnostic per suite, for the LSP status surface. */
     diagnosticsSnapshot(): Map<string, LspMountDiagnostic>;
+    /** Whether this registry owns the LSP tool, including its startup publication window. */
+    ownsTool(): boolean;
+    /** Routes from successfully mounted provider tables; conflicts and failed mounts publish none. */
+    providerOwnership(): ExtensionLspProvider[];
     /** Whether at least one suite mount is live. */
     hasLiveMounts(): boolean;
-    /** Mount one suite's full server table as a single `dsh-lsp-stdio` instance. */
+    /** Mount one provider as an independently disposable `dsh-lsp-stdio` instance. */
     private mountWith;
     private unmount;
     /** Dispose every live mount after queued reconciliation passes settle. */

package/lib/types/packages/market-mcp/src/application/mcp/mcp-backend.d.ts

@@ -0,0 +1,28 @@
+/**
+ * MCP backend selection: whether suite MCP servers mount through the
+ * market's self-built bridge (default — stdio, Streamable HTTP with OAuth,
+ * and legacy SSE) or through the host's `@deepseek-ai/dsh-mcp-client`
+ * (compatibility mode: no OAuth, no SSE, but the host-native implementation).
+ *
+ * The choice is the `mcpEnhanced` field of the market's host settings
+ * namespace (see `contracts/settings.ts`) registered by the plugin's node half:
+ * the registration is what makes the host 插件配置 tab serve our card, the
+ * client card binds it for state, and the node half watches it to remount
+ * servers when the switch flips.
+ *
+ * @module application/mcp-backend
+ */
+import type { McpBackend } from '../../../../market-contracts/src/contracts/mcp.js';
+export type { McpBackend };
+/** What the host client probe reports: resolvability plus its version. */
+export interface HostMcpClientProbe {
+    available: boolean;
+    version?: string;
+}
+/**
+ * Probe whether the host's `dsh-mcp-client` is resolvable from this plugin's
+ * module context, and at which version. Best effort: any failure reads as
+ * "unavailable", which the mount path surfaces as a per-server diagnostic
+ * when the host backend is selected.
+ */
+export declare function probeHostMcpClient(): Promise<HostMcpClientProbe>;

package/lib/types/{application → packages/market-mcp/src/application}/mcp/mcp-bridge-config.d.ts

@@ -19,7 +19,7 @@ export interface ReconnectConfig {
     /** Consecutive failed attempts per outage before giving up for good (default 10). */
     maxAttempts?: number;
 }
-import type { McpServerPolicy } from '../../model/types.js';
+import type { McpServerPolicy } from '../../../../market-contracts/src/model/types.js';
 /** Default timeout for individual MCP tool calls (ms). */
 export declare const DEFAULT_TOOL_CALL_TIMEOUT_MS = 60000;
 /**

package/lib/types/{application → packages/market-mcp/src/application}/mcp/mcp-config.d.ts

@@ -1,7 +1,7 @@
 import type { Config } from './mcp-bridge-config.js';
 import { type McpServerOverride, type McpSuiteOverrides } from './mcp-overrides.js';
-import type { McpStatusCode } from '../../contracts/mcp-status.js';
-import type { HarnessMcpPolicy, McpServer, McpServerPolicy, McpServerSse, McpServerStdio, McpServerStreamableHttp, Suite } from '../../model/types.js';
+import type { McpStatusCode } from '../../../../market-contracts/src/contracts/mcp-status.js';
+import type { HarnessMcpPolicy, McpServer, McpServerPolicy, McpServerSse, McpServerStdio, McpServerStreamableHttp, Suite } from '../../../../market-contracts/src/model/types.js';
 export interface McpMountRequest {
     suiteId: string;
     serverKey: string;

package/lib/types/{application → packages/market-mcp/src/application}/mcp/mcp-direct-config.d.ts

@@ -1,4 +1,4 @@
-import { type McpSuiteConfig, type Suite } from '../../model/types.js';
+import { type McpSuiteConfig, type Suite } from '../../../../market-contracts/src/model/types.js';
 export declare const USER_MCP_SOURCE = "@user-mcp";
 export declare const USER_MCP_SUITE = "user-mcp";
 /**
@@ -22,5 +22,10 @@ export declare function loadUserMcpSuite(agentsRoot: string): Promise<Suite & {
 }>;
 /** Add one service atomically; reject collisions and malformed config before writing. */
 export declare function addUserMcpServer(agentsRoot: string, name: string, server: unknown): Promise<void>;
+/**
+ * Validate an addition without publishing it. Call the returned atomic write
+ * once, within the same serialized mutation, after any policy has been saved.
+ */
+export declare function prepareUserMcpServer(agentsRoot: string, name: string, server: unknown): Promise<() => Promise<void>>;
 /** The user's hand-written MCP declaration file: `<agentsRoot>/mcp.json`. */
 export declare function userMcpPath(agentsRoot: string): string;

package/lib/types/{application → packages/market-mcp/src/application}/mcp/mcp-overrides.d.ts

@@ -1,41 +1,8 @@
-import type { McpServerSse, McpServerStreamableHttp, McpServerStdio } from '../../model/types.js';
-/** HTTP-shaped server sources (url + headers carriers) overrides can edit. */
+import type { McpServerSse, McpServerStreamableHttp, McpServerStdio } from '../../../../market-contracts/src/model/types.js';
 type McpServerHttp = McpServerStreamableHttp | McpServerSse;
-/** The largest timeout a bridge config and the host timer can hold. */
-export declare const MAX_TIMEOUT_MS = 2147483647;
-/** Per-server override record; absent fields pass through from the source. */
-export type McpServerOverride = {
-    /** Validated complete user configuration, retaining source-owned identity. */
-    config?: McpServerStdio | McpServerHttp;
-    /** Disabled servers are not mounted at all (default enabled). */
-    enabled?: boolean;
-    /** Replaces the source URL (streamable-http only). */
-    url?: string;
-    /** Replaces the whole header map (streamable-http only). */
-    headers?: Record<string, string>;
-    /** Replaces the whole env map (stdio). */
-    env?: Record<string, string>;
-    /** Replaces the whole args list (stdio). */
-    args?: string[];
-    /** Replaces the OAuth block (streamable-http only); `enabled: false` disables a source-declared flow. */
-    auth?: {
-        enabled: boolean;
-        scope?: string;
-    };
-    /** Per-tool-call timeout in milliseconds; absent inherits the suite's value or the bridge default. */
-    toolCallTimeoutMs?: number;
-    /** Startup timeout in milliseconds; absent inherits the suite's value or the bridge default. */
-    startupTimeoutMs?: number;
-    /** Tool names the user turned off; the suite's own deny list stays in force beside them. */
-    disabledTools?: string[];
-};
-/** Timeout fields a policy save can set (`number`) or clear back to inheritance (`null`). */
-export interface McpTimeoutPatch {
-    toolCallTimeoutMs?: number | null;
-    startupTimeoutMs?: number | null;
-}
-/** Overrides for one suite, keyed by mcp.json server key. */
-export type McpSuiteOverrides = Record<string, McpServerOverride>;
+export { MAX_TIMEOUT_MS } from '../../../../market-contracts/src/contracts/mcp-overrides.js';
+export type { McpServerOverride, McpSuiteOverrides, McpTimeoutPatch } from '../../../../market-contracts/src/contracts/mcp-overrides.js';
+import { type McpServerOverride, type McpSuiteOverrides, type McpTimeoutPatch } from '../../../../market-contracts/src/contracts/mcp-overrides.js';
 /** The overrides directory under the plugin data root. */
 export declare function overridesDir(dataRoot: string): string;
 /** One suite's override file path. */
@@ -99,4 +66,3 @@ export declare function applyOverride(server: McpServerStdio | McpServerHttp, ov
  * so a timeout never reaches a document that has no seat for it.
  */
 export declare function withoutPolicyFields<T extends McpServerStdio | McpServerHttp>(server: T): T;
-export {};

package/lib/types/packages/market-mcp/src/application/mcp/mcp-status.d.ts

@@ -0,0 +1,40 @@
+import type { McpSuiteOverrides } from './mcp-overrides.js';
+import type { McpStatusCode, McpStatusPayload } from '../../../../market-contracts/src/contracts/mcp-status.js';
+import type { Localization, McpToolSnapshot } from '../../../../market-contracts/src/ports/ports.js';
+import type { Suite } from '../../../../market-contracts/src/model/types.js';
+export type { McpStatusEntry, McpStatusPayload, McpStatusKind, McpStatusState } from '../../../../market-contracts/src/contracts/mcp-status.js';
+export type { McpToolSnapshot };
+export interface McpDiagnostic {
+    suiteId: string;
+    serverKey: string;
+    reason: string;
+    code?: McpStatusCode;
+    causes?: string[];
+    credentialRefs?: string[];
+}
+/**
+ * Whether one effective configuration supplies its own Authorization header.
+ *
+ * Such a server authenticates with that header: the browser authorization a
+ * re-authorize would restart is not the path it uses, so the action is not
+ * offered for it.
+ */
+export declare function declaresAuthHeader(config: Record<string, unknown> | undefined): boolean;
+/**
+ * Build status rows from discovered plugin MCP definitions and observed tool names.
+ *
+ * Each tool's description is translated on the way out; a service name and a
+ * tool's own `name` are call identifiers and are never translated. The
+ * callback is optional: a caller that omits it gets the upstream text, which is
+ * what the contract's absent translated field means.
+ * @param suites - the discovered suites whose MCP declarations form the inventory.
+ * @param diagnostics - the latest mount diagnostics, keyed by suite and server.
+ * @param observed - the live host tool registry snapshot.
+ * @param overrides - persisted per-server overrides, keyed by qualified suite id.
+ * @param localization - the locale this whole inventory renders in and the
+ * resolver bound to it, when the deployment translates at all. Resolved once by
+ * the caller: a server and each of its tools is localized from this one value,
+ * never from a fresh read of the host preference.
+ * @returns the status payload with every translatable field carrying its translation.
+ */
+export declare function buildMcpStatus(suites: Suite[], diagnostics: McpDiagnostic[], observed: readonly McpToolSnapshot[], overrides?: Map<string, McpSuiteOverrides>, localization?: Localization): McpStatusPayload;

package/lib/types/{application/server-config.d.ts → packages/market-mcp/src/application/mcp/validation.d.ts}

@@ -1,4 +1,3 @@
-import type { LspServerSpec, Suite } from '../model/types.js';
 /** One rejected value, with the field it belongs to when the schema knows it. */
 export interface McpFieldError {
     /** Dotted path inside the server object; empty for a problem with the document itself. */
@@ -14,8 +13,7 @@ export declare class McpConfigError extends Error {
     readonly fields: McpFieldError[];
     constructor(fields: McpFieldError[]);
 }
-/** Restore only unchanged redacted leaves, rejecting invented masked values. */
-export declare function restoreRedactedConfig(input: unknown, original: unknown, redacted?: unknown): unknown;
+export { restoreRedactedConfig } from '../../../../market-contracts/src/redaction.js';
 /**
  * Validate one service definition before it is stored.
  *
@@ -26,10 +24,4 @@ export declare function restoreRedactedConfig(input: unknown, original: unknown,
  */
 export declare function validateServerMcp(root: string, key: string, config: unknown, options?: {
     userOwned?: boolean;
-}): Promise<import("../model/types.js").McpServer>;
-export declare function validateServerLsp(key: string, config: unknown): LspServerSpec;
-/** Public configuration excludes the parser's derived identity. */
-export declare function lspConfig(spec: LspServerSpec): Record<string, unknown>;
-export declare function loadLspOverrides(root: string): Promise<Record<string, LspServerSpec>>;
-export declare function saveLspOverride(root: string, id: string, config: LspServerSpec): Promise<void>;
-export declare function applyLspOverrides(root: string, suites: Suite[]): Promise<Suite[]>;
+}): Promise<import("@dsh-market/contracts").McpServer>;