dsh-agent-plugins-market 0.5.2 → 0.6.0

package/lib/types/catalog/scan-resolvers.d.ts

@@ -0,0 +1,81 @@
+import type { Suite, SuiteDimension } from '../model/types.js';
+import { type MarketplaceEntry } from './manifests.js';
+import type { ScanChain, ScanContext, ScanFilter, ScanResolution, ScanResult } from './scan-pipeline.js';
+export { repoName } from './manifests.js';
+export { listMdFiles, discoverLspEntries, type LspEntry } from './surfaces.js';
+export type { MarketplaceEntry } from './manifests.js';
+export interface SuiteHint {
+    name?: string;
+    version?: string;
+    description?: string;
+    /** Inline `lspServers` declared on the marketplace entry itself (Claude Code). */
+    lspServers?: unknown;
+}
+/** Normalized resolution of one marketplace entry inside its checkout. */
+export type EntryResolution = {
+    kind: 'local';
+    dir: string;
+} | {
+    kind: 'remote';
+    url: string;
+} | {
+    kind: 'unclaimed';
+    reason: string;
+} | {
+    kind: 'rejected';
+    reason: string;
+};
+interface EntryContext {
+    checkout: string;
+    entry: MarketplaceEntry;
+}
+interface EntryChain {
+    next(context: EntryContext): EntryResolution | Promise<EntryResolution>;
+}
+/** One handler in the marketplace-entry chain. */
+export interface EntryHandler {
+    name: string;
+    handle(context: EntryContext, chain: EntryChain): EntryResolution | Promise<EntryResolution>;
+}
+/**
+ * Canonical `https://host/owner/repo` form of a git URL, for equality
+ * comparisons between a source's configured URL and an entry's remote.
+ */
+export declare function canonicalGitUrl(url: string): string;
+/** The remote URL an entry points at, across every dialect's shape. */
+export declare function entryRemoteUrl(entry: MarketplaceEntry): string | undefined;
+/**
+ * Resolve one marketplace entry's source against its checkout. Self-
+ * references (an entry pointing back at this very source, as Claude Code
+ * ships for single-repo marketplaces) resolve to the local checkout so the
+ * repo's own manifest and surfaces are scanned directly.
+ */
+export declare function resolveMarketplaceEntry(checkout: string, entry: MarketplaceEntry, sourceUrl: string | undefined): Promise<EntryResolution>;
+/** Read one checkout through marketplace manifests, dialect by dialect. */
+export declare class MarketplaceStrategy implements ScanFilter {
+    readonly name = "marketplace";
+    doScan(context: ScanContext, chain: ScanChain): Promise<ScanResolution>;
+    private marketplaceRoots;
+}
+/** Read nested plugin roots up to four levels deep. */
+export declare class RootedStrategy implements ScanFilter {
+    readonly name = "rooted";
+    doScan(context: ScanContext, chain: ScanChain): Promise<ScanResolution>;
+}
+/** Terminal fallback: manifest-less flat `<child>/SKILL.md` collections. */
+export declare class FlatCollectionsStrategy implements ScanFilter {
+    readonly name = "flat-collections";
+    doScan(context: ScanContext): Promise<ScanResolution>;
+}
+/** The default chain, most specific first with a terminal fallback. */
+export declare function defaultScanFilters(): readonly ScanFilter[];
+/** Discover every suite under one source checkout. */
+export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<Suite[]>;
+/** Scan one checkout through the filter chain with full diagnostics. */
+export declare function scanSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<ScanResult>;
+/** Whether a directory carries any known suite manifest. */
+export declare function hasSuiteManifest(dir: string): Promise<boolean>;
+/** Whether a directory carries skill files in the flat or bundled shape. */
+export declare function hasSkillFiles(dir: string): Promise<boolean>;
+/** Read one suite root into the normalized shape, or undefined when no manifest parses. */
+export declare function readSuite(root: string, sourceId: string, dimension: SuiteDimension, hint: SuiteHint | undefined): Promise<Suite | undefined>;

package/lib/types/catalog/source-catalog.d.ts

@@ -1,3 +1,8 @@
 import type { SourceRef, Suite, SuiteDimension } from '../model/types.js';
 /** Discover suites from the selected configured or project checkouts. */
 export declare function discoverSourceList(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string): Promise<Suite[]>;
+/** Discover suites plus per-source scan diagnostics for one dimension. */
+export declare function discoverSourceListWithNotes(sources: SourceRef[], dimension: SuiteDimension, dimensionRoot: string): Promise<{
+    suites: Suite[];
+    scanNotes: Record<string, string[]>;
+}>;

package/lib/types/catalog/suite-scanner.d.ts

@@ -1,9 +1,16 @@
+/**
+ * Scan one source checkout into normalized suites.
+ *
+ * The actual discovery lives in the strategy chain (`scan-pipeline.ts` +
+ * `scan-resolvers.ts`); this module is the compatibility facade that keeps
+ * the historical imports (`discoverSuitesInSource`, `repoName`,
+ * `listMdFiles`, `LspEntry`) stable for callers and tests.
+ */
 import type { Suite, SuiteDimension } from '../model/types.js';
-import { repoName } from './manifests.js';
-import { discoverLspEntries, listMdFiles, type LspEntry } from './surfaces.js';
-export { repoName, listMdFiles, discoverLspEntries };
-export type { LspEntry };
+export { repoName, listMdFiles, discoverLspEntries, scanSource, canonicalGitUrl, resolveMarketplaceEntry, defaultScanFilters, MarketplaceStrategy, RootedStrategy, FlatCollectionsStrategy } from './scan-resolvers.js';
+export type { MarketplaceEntry, EntryResolution, EntryHandler, SuiteHint } from './scan-resolvers.js';
+export type { LspEntry } from './surfaces.js';
+export { runScanChain } from './scan-pipeline.js';
+export type { ScanContext, ScanFilter, ScanChain, ScanResolution, ScanAttempt, ScanResult } from './scan-pipeline.js';
 /** Discover every suite under one source checkout. */
-export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension): Promise<Suite[]>;
-/** Whether a suite root path lies outside the checkout. */
-export declare function isOutside(root: string, candidate: string): boolean;
+export declare function discoverSuitesInSource(checkoutDir: string, sourceId: string, dimension: SuiteDimension, sourceUrl?: string): Promise<Suite[]>;

package/lib/types/catalog/surfaces.d.ts

@@ -1,10 +1,10 @@
-import type { McpSuiteConfig, SuiteSkill, SuiteSurfaceCounts } from '../model/types.js';
+import type { LspSuiteConfig, McpSuiteConfig, SuiteSkill, SuiteSurfaceCounts } from '../model/types.js';
 /** Discover SKILL.md files under the suite's skills directory, up to 3 levels deep. */
 export declare function discoverSkills(root: string, errors: string[], declared?: unknown): Promise<SuiteSkill[]>;
 /** Read the suite's MCP config: `mcp.json` or `.mcp.json`, else the winning manifest's inline `mcpServers`. */
 export declare function discoverMcp(root: string, errors: string[]): Promise<McpSuiteConfig | undefined>;
-/** Count surfaces for a suite; mcp counts only validated servers. */
-export declare function countSurfaces(root: string, skills: SuiteSkill[], mcp: McpSuiteConfig | undefined): Promise<SuiteSurfaceCounts>;
+/** Count surfaces for a suite; mcp counts only validated servers, lsp counts inline servers plus directory entries. */
+export declare function countSurfaces(root: string, skills: SuiteSkill[], mcp: McpSuiteConfig | undefined, lsp?: LspSuiteConfig): Promise<SuiteSurfaceCounts>;
 export interface LspEntry {
     name: string;
     path: string;

package/lib/types/contracts/lsp-status.d.ts

@@ -0,0 +1,53 @@
+/** Browser-safe LSP status records shared by host aggregation and client rendering. */
+/** Whether an LSP row comes from a suite declaration or direct user configuration. */
+export type LspStatusKind = 'plugin' | 'direct';
+/** Operational state rendered for an LSP server row. */
+export type LspStatusState = 'mounted' | 'starting' | 'host-missing' | 'failed' | 'conflict' | 'disabled';
+/**
+ * One declared language-server row for the status surface.
+ *
+ * Rows are built from the enabled suites' inline `lspServers` declarations
+ * plus the user's direct configuration, merged with the latest mount
+ * diagnostics; the DSH `ctx.lsp` seam exposes no provider snapshot, so this
+ * is a declaration-and-diagnostic model, not a process probe.
+ */
+export interface LspStatusEntry {
+    /** Stable row id: `${suiteId}/${serverKey}` (suite rows) or `direct/${serverKey}`. */
+    id: string;
+    /** Server key from the declaring `lspServers` table. */
+    serverKey: string;
+    /** Declaring suite id; the sentinel `direct` for user-configured rows. */
+    suiteId: string;
+    /** Declaring suite display name. */
+    suiteName: string;
+    /** Source id of the declaring suite; empty for user-configured rows. */
+    sourceId: string;
+    /** Where the row comes from. */
+    kind: LspStatusKind;
+    /** Executable the host will spawn. */
+    command: string;
+    /** Executable arguments. */
+    args: string[];
+    /** Lowercase leading-dot extension → LSP language id. */
+    extensions: Record<string, string>;
+    /** Operational state. */
+    state: LspStatusState;
+    /** Latest diagnostic reason, when the state is not `mounted`/`disabled`. */
+    reason?: string;
+    /** Whether a failed mount will be retried automatically. */
+    retryable?: boolean;
+}
+/** The LSP status response returned by the host. */
+export interface LspStatusPayload {
+    entries: LspStatusEntry[];
+    observedAt: string;
+    totals: {
+        all: number;
+        mounted: number;
+        failed: number;
+        blocked: number;
+        disabled: number;
+    };
+    /** True when the host lacks the LSP packages, so every declaration is blocked. */
+    hostMissing: boolean;
+}

package/lib/types/contracts/market.d.ts

@@ -5,12 +5,15 @@ export declare const MARKET_API_PREFIX: "/api/agent-plugins/";
 export declare const MARKET_ROUTES: {
     readonly overview: "/api/agent-plugins/overview";
     readonly mcpStatus: "/api/agent-plugins/mcp-status";
+    readonly lspStatus: "/api/agent-plugins/lsp-status";
+    readonly lspServers: "/api/agent-plugins/lsp-servers";
     readonly progress: "/api/agent-plugins/progress";
     readonly config: "/api/agent-plugins/config";
     readonly suite: "/api/agent-plugins/suite";
     readonly skill: "/api/agent-plugins/skill";
     readonly addSource: "/api/agent-plugins/sources/add";
     readonly updateSource: "/api/agent-plugins/sources/update";
+    readonly adoptSource: "/api/agent-plugins/sources/adopt";
     readonly removeSource: "/api/agent-plugins/sources/remove";
     readonly refreshSource: "/api/agent-plugins/sources/refresh";
     readonly install: "/api/agent-plugins/install";
@@ -19,16 +22,47 @@ export declare const MARKET_ROUTES: {
     readonly setSurface: "/api/agent-plugins/set-surface";
     readonly mcpOverrides: "/api/agent-plugins/mcp-overrides";
     readonly setMcpOverride: "/api/agent-plugins/set-mcp-override";
+    readonly mcpRetry: "/api/agent-plugins/mcp-retry";
+    readonly mcpReauthorize: "/api/agent-plugins/mcp-reauthorize";
+    readonly mcpBackend: "/api/agent-plugins/mcp-backend";
+    readonly setMcpBackend: "/api/agent-plugins/set-mcp-backend";
 };
+/** The MCP mount backend state reported to the settings page. */
+export interface McpBackendPayload {
+    backend: 'builtin' | 'host';
+    /** Whether the host `dsh-mcp-client` resolves from the plugin context. */
+    hostClient: {
+        available: boolean;
+        version?: string;
+    };
+    /** Download region: the persisted setting and its locale-resolved route. */
+    downloadRegion: {
+        setting: 'auto' | 'global' | 'china';
+        effective: 'global' | 'china';
+    };
+}
+/** One unmanaged `.sources/` checkout the user can adopt as a source. */
+export interface UnmanagedSource {
+    id: string;
+    /** The checkout's `origin` remote URL; absent for non-git directories. */
+    url?: string;
+}
 /** A configured source row returned to the market client. */
 export interface SourceOverview {
     id: string;
     url: string;
     branch?: string;
     local?: boolean;
+    /** Acquisition kind (`git` / `local` / `archive`); `local` mirrors the legacy flag. */
+    kind: string;
+    /** The checkout pre-existed (manually cloned or adopted); never deleted on removal. */
+    adopted?: boolean;
     cloned: boolean;
     lockCommit?: string;
     error?: string;
+    /** Scanner diagnostics for this source (dropped entries, fallbacks taken);
+     *  absent when the scan completed with no notes. */
+    scanNotes?: string[];
     suiteIds: string[];
 }
 /** Counts of runtime surfaces displayed on a suite card. */
@@ -47,6 +81,7 @@ export interface SuiteSurfaceToggles {
     hooks: boolean;
     commands: boolean;
     agents: boolean;
+    lsp: boolean;
 }
 /** One server's persisted MCP override (wire shape mirrors runtime types). */
 export type McpServerOverrideWire = {
@@ -90,6 +125,8 @@ export interface OverviewPayload {
         user: string;
         data: string;
     };
+    /** Unmanaged `.sources/` checkouts (manual clones) available for adoption. */
+    unmanaged?: UnmanagedSource[];
 }
 /** Host-side progress of the source mutation currently in flight. */
 export interface SourceProgress {
@@ -119,6 +156,21 @@ export interface LspPreview {
     name: string;
     content: string;
 }
+/** One inline-declared LSP server in a suite detail response. */
+export interface LspServerPreview {
+    /** Server key from the declaring `lspServers` table. */
+    key: string;
+    command: string;
+    args: string[];
+    /** Lowercase leading-dot extension → LSP language id. */
+    extensions: Record<string, string>;
+    env?: Record<string, string>;
+}
+/** The suite's LSP surface: inline-declared servers plus directory definition files. */
+export interface LspSurfaceDetail {
+    servers: LspServerPreview[];
+    raw: LspPreview[];
+}
 /** One flattened hook entry in a suite detail response. */
 export interface HookPreview {
     event: string;
@@ -135,6 +187,8 @@ export interface McpServerDetail {
     env?: Record<string, string>;
     cwd?: string;
     headers?: Record<string, string>;
+    /** External credential references used by env/header/argument placeholders. */
+    credentialRefs: string[];
 }
 /** Full suite detail response served by the detail modal. */
 export interface SuiteDetail {
@@ -162,7 +216,7 @@ export interface SuiteDetail {
     };
     commands: MarkdownPreview[];
     agents: MarkdownPreview[];
-    lsp: LspPreview[];
+    lsp: LspSurfaceDetail;
     errors: string[];
     mcpErrors: string[];
 }

package/lib/types/contracts/mcp-status.d.ts

@@ -6,8 +6,8 @@ export interface McpStatusTool {
 }
 /** Whether an MCP row comes from a suite or direct host observation. */
 export type McpStatusKind = 'plugin' | 'direct';
-/** Operational state rendered for an MCP row. */
-export type McpStatusState = 'connected' | 'degraded' | 'failed' | 'disabled';
+/** Operational state rendered for an MCP row. `foreign` = mounted by another MCP client (informational). */
+export type McpStatusState = 'connected' | 'degraded' | 'failed' | 'needs-credentials' | 'orphaned' | 'disabled' | 'foreign';
 /** One MCP service row for the status surface. */
 export interface McpStatusEntry {
     id: string;
@@ -22,6 +22,15 @@ export interface McpStatusEntry {
     config?: Record<string, unknown>;
     tools: McpStatusTool[];
     reason?: string;
+    /** Mount-path classification when a diagnostic produced this row. */
+    code?: 'unsupported-transport' | 'missing-credential' | 'credential-error' | 'unmount-failed' | 'mount-failed' | 'foreign-mount';
+    /** Environment-variable credential references required by this server. */
+    credentialRefs?: string[];
+    /** Whether this server advertised zero tools at observation time. Zero-tool
+     *  servers are legitimate, so the panel never treats `degraded` as broken. */
+    advertisedTools?: boolean;
+    /** Whether a failed server will be retried automatically. */
+    retryable?: boolean;
 }
 /** The MCP status response returned by the host. */
 export interface McpStatusPayload {
@@ -32,7 +41,10 @@ export interface McpStatusPayload {
         connected: number;
         degraded: number;
         failed: number;
+        needsCredentials: number;
+        orphaned: number;
         disabled: number;
+        foreign: number;
     };
     directObservationOnly: boolean;
 }

package/lib/types/index.d.ts

@@ -3,14 +3,15 @@
  *
  * 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 `dsh-mcp-client` mounts, 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.
+ * 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). The MCP client package is
- * optional at runtime: without it, suites still load their skills and the
- * manager reports a per-server mount failure.
+ * 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 } from '@deepseek-ai/cordis';
 import type { SourceRef } from './model/types.js';
@@ -20,9 +21,24 @@ export declare const inject: string[];
 export interface Config {
     /** User-dimension suite root; defaults to `~/.dsh/agent-plugins` (`$DSH_HOME/agent-plugins`). */
     userRoot?: string;
-    /** Per-suite data root backing `${PLUGIN_DATA}`; defaults to `~/.dsh/agent-plugins-data`. */
+    /** Per-suite data root backing `${PLUGIN_DATA}` and MCP overrides; defaults to `<userRoot>/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;
+    };
 }
 export declare function apply(ctx: Context, config?: Config): void;

package/lib/types/model/types.d.ts

@@ -7,17 +7,33 @@
  * Codex `.codex-plugin/plugin.json`). Discovery maps every layout onto this
  * internal shape; runtime injection consumes only the internal shape.
  */
+/** How a source's content is acquired. */
+export type SourceKind = 'git' | 'local' | 'archive';
 /** One configured repository source. */
 export interface SourceRef {
     /** Stable local id; `[a-z0-9][a-z0-9-]*`, unique across sources. */
     id: string;
-    /** Git URL to clone, or a local directory path when `local` is set. */
+    /** Git URL, archive (zip / tar.gz) URL, or a local directory path. */
     url: string;
     /** Optional branch to pin (git sources only). */
     branch?: string;
-    /** Read the source directory directly instead of cloning it. */
+    /** Read the source directory directly instead of cloning it (legacy flag; `kind: 'local'`). */
     local?: boolean;
+    /** Acquisition kind; inferred from the URL shape when omitted. */
+    kind?: SourceKind;
+    /** Expected SHA-256 of an archive download (archive sources only). */
+    sha256?: string;
+    /** The checkout pre-existed (manually cloned or adopted); never deleted on source removal. */
+    adopted?: boolean;
 }
+/** Whether a URL points at a downloadable archive. */
+export declare function isArchiveUrl(url: string): boolean;
+/**
+ * Effective acquisition kind of a source: the explicit `kind` wins, the
+ * legacy `local` flag maps to `'local'`, archive-shaped URLs infer
+ * `'archive'`, and everything else stays `'git'`.
+ */
+export declare function resolveSourceKind(source: Pick<SourceRef, 'url' | 'local' | 'kind'>): SourceKind;
 /** The manifest layout a suite root was discovered under. */
 export type SuiteLayoutKind = 'agent-plugin-v1' | 'universal' | 'claude-code' | 'cursor' | 'kimi' | 'codex' | 'skill-collection' | 'remote' | 'project-native';
 /** Normalized suite manifest fields. */
@@ -74,11 +90,21 @@ export interface McpServerStreamableHttp {
     type: 'streamable-http';
     url: string;
     headers?: Record<string, string>;
+    /** Opt in to OAuth 2.1 authorization for servers that answer `401` with a challenge (on by default; `enabled: false` opts out). */
+    auth?: {
+        enabled: boolean;
+        scope?: string;
+    };
 }
 export interface McpServerSse {
     type: 'sse';
     url: string;
     headers?: Record<string, string>;
+    /** OAuth 2.1 authorization, mirroring the streamable-http semantics. */
+    auth?: {
+        enabled: boolean;
+        scope?: string;
+    };
 }
 export type McpServer = McpServerStdio | McpServerStreamableHttp | McpServerSse;
 /** Parsed and validated `mcp.json` content. */
@@ -86,6 +112,27 @@ export interface McpSuiteConfig {
     schema: string;
     servers: Record<string, McpServer>;
 }
+/** One normalized inline LSP server declaration (`lspServers` table entry). */
+export interface LspServerSpec {
+    /** Server key from the declaring table (e.g. `typescript`). */
+    key: string;
+    /** Executable to spawn (resolved on PATH by the LSP host). */
+    command: string;
+    /** Arguments passed to the executable. Default `[]`. */
+    args: string[];
+    /** Lowercase leading-dot extension → LSP language id. */
+    extensionToLanguage: Record<string, string>;
+    /** Extra env vars merged over the ambient env. */
+    env?: Record<string, string>;
+    /** Static `initialize` options forwarded to the server. */
+    initializationOptions?: unknown;
+    /** Static answer to every `workspace/configuration` item. */
+    configuration?: unknown;
+}
+/** Parsed inline `lspServers` declarations of one suite. */
+export interface LspSuiteConfig {
+    servers: Record<string, LspServerSpec>;
+}
 /** Install dimension of a suite. */
 export type SuiteDimension = 'user' | 'project';
 /** One discovered suite with runtime-relevant fields resolved. */
@@ -97,6 +144,8 @@ export interface Suite {
     skills: SuiteSkill[];
     /** Validated mcp.json content; absent when the file is missing or invalid. */
     mcp?: McpSuiteConfig;
+    /** Parsed inline `lspServers` declarations; absent when the suite declares none. */
+    lsp?: LspSuiteConfig;
     surfaces: SuiteSurfaceCounts;
     dimension: SuiteDimension;
     enabled: boolean;
@@ -114,7 +163,7 @@ export interface Suite {
     errors: string[];
 }
 /** Runtime surfaces that can be selectively enabled per installed suite. */
-export type SuiteSurfaceKey = 'skills' | 'mcp' | 'hooks' | 'commands' | 'agents';
+export type SuiteSurfaceKey = 'skills' | 'mcp' | 'hooks' | 'commands' | 'agents' | 'lsp';
 /** Per-surface user overrides; absent keys default to enabled. */
 export type SurfaceOverrides = Partial<Record<SuiteSurfaceKey, boolean>>;
 /** The full set of toggleable surfaces, in display order. */

package/lib/types/runtime/lsp-direct-config.d.ts

@@ -0,0 +1,12 @@
+import type { LspServerSpec } from '../model/types.js';
+/** The direct LSP server configuration file path. */
+export declare function lspServersPath(dataRoot: string): string;
+/** Load the user-configured LSP servers; unreadable or invalid files yield an empty table. */
+export declare function loadLspServers(dataRoot: string): Promise<{
+    servers: Record<string, LspServerSpec>;
+    errors: string[];
+}>;
+/** Validate and persist the user-configured LSP servers; returns normalized specs. */
+export declare function saveLspServers(dataRoot: string, raw: unknown): Promise<{
+    servers: Record<string, LspServerSpec>;
+}>;

package/lib/types/runtime/lsp-mounts.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Runtime LSP mounts: one live `dsh-lsp-stdio` child plugin per enabled
+ * 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
+ * rows that appeared. The host LSP package is optional at runtime — without
+ * it, suites keep every other surface and the manager reports a one-line
+ * `host-missing` diagnostic that does not enter the retry schedule (a missing
+ * package is not a transient failure). Mount failures that can resolve after
+ * user action (installing the language server executable) do retry.
+ *
+ * Provider identity: one `${suiteId}/${serverKey}` provider id per server, so
+ * two suites declaring the same server key mount independently. Extension
+ * ownership in `ctx.lsp` is exclusive by design; when two enabled suites
+ * claim the same extension the later mount fails with `seam-conflict` and the
+ * user resolves it through per-suite surface toggles.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Suite } from '../model/types.js';
+export interface LspMountDiagnostic {
+    suiteId: string;
+    serverKey: string;
+    reason: string;
+    code?: 'mount-failed' | 'unmount-failed' | 'seam-conflict' | 'host-missing';
+}
+/** One dsh-lsp-stdio server configuration row (its Config.servers entry). */
+export interface LspStdioServerConfig {
+    command: string;
+    args: string[];
+    extensionToLanguage: Record<string, string>;
+    env?: Record<string, string>;
+    initializationOptions?: unknown;
+    configuration?: unknown;
+}
+/** Build one dsh-lsp-stdio Config.servers entry from a normalized spec. */
+export declare function toLspServerConfig(spec: {
+    command: string;
+    args: string[];
+    extensionToLanguage: Record<string, string>;
+    env?: Record<string, string>;
+    initializationOptions?: unknown;
+    configuration?: unknown;
+}): LspStdioServerConfig;
+/** Minimal structural shape of the dynamically imported `dsh-lsp-stdio` module. */
+interface LspStdioModule {
+    default?: unknown;
+}
+export declare class LspMountRegistry {
+    private readonly ctx;
+    private readonly live;
+    /** Serialize mount and unmount passes so a disable cannot race an in-flight spawn. */
+    private reconcileQueue;
+    /** Pending retry timers keyed by mount key, so a teardown can cancel them. */
+    private readonly retries;
+    /** Attempt count per mount key; reset whenever a retry succeeds. */
+    private readonly attempts;
+    /** Snapshot of the last reconciled suite set, replayed by retry passes. */
+    private lastEnabled;
+    /** Host module loader; overridable for tests. */
+    private loadHost;
+    /** Latest diagnostic per suite id; cleared when its suite mounts or leaves the wanted set. */
+    private readonly lastDiagnostics;
+    /** Direct (user-configured) server provider; defaults to none. */
+    private directProvider;
+    constructor(ctx: Context, loadHost?: () => Promise<LspStdioModule | undefined>);
+    /** Queue one reconciliation behind any in-flight mount/unmount pass. */
+    reconcile(enabledSuites: Suite[]): Promise<LspMountDiagnostic[]>;
+    /** Mount/unmount LSP servers to match the enabled suites plus direct config exactly. */
+    private reconcileNow;
+    /** Install the direct (user-configured) server provider used at reconcile time. */
+    setDirectProvider(provider: () => Promise<Record<string, import('../model/types.js').LspServerSpec>>): void;
+    /** The latest mount diagnostic per suite, for the LSP status surface. */
+    diagnosticsSnapshot(): Map<string, LspMountDiagnostic>;
+    /** Whether at least one suite mount is live. */
+    hasLiveMounts(): boolean;
+    /** Mount one suite's full server table as a single `dsh-lsp-stdio` instance. */
+    private mountWith;
+    private unmount;
+    /**
+     * Schedule a delayed re-attempt for a mount that still is not live. A
+     * `host-missing` failure passes no diagnostic and is never retried; the
+     * schedule is bounded and resets with every reconcile pass.
+     */
+    private scheduleRetry;
+    /** Dispose every live mount after queued reconciliation passes settle. */
+    disposeAll(): Promise<void>;
+}
+export {};

package/lib/types/runtime/lsp-status.d.ts

@@ -0,0 +1,30 @@
+/**
+ * LSP status aggregation: declared language servers of enabled+installed
+ * suites and the user's direct configuration, merged with the mount
+ * registry's latest diagnostics into rows for the status surface.
+ *
+ * The DSH `ctx.lsp` seam exposes no provider snapshot and no process probe,
+ * so a row's state is a declaration-and-diagnostic judgment: a suite whose
+ * mount succeeded yields `mounted` (the seam guarantees registration), a
+ * stored diagnostic yields its own state, and a declaration with neither
+ * mounts nor diagnostics means the host packages are absent (`host-missing`).
+ * 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 './lsp-mounts.js';
+import type { LspServerSpec, Suite } from '../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). */
+export interface LspMountStatusSource {
+    diagnosticsSnapshot(): Map<string, LspMountDiagnostic>;
+    hasLiveMounts(): boolean;
+}
+/** The direct servers table the aggregator merges in (structural, for tests). */
+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;