dsh-mcp-panel 0.2.0

package/lib/types/config.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Plugin configuration and its explicit resolve step. `resolveConfig` re-judges
+ * every default and bound so programmatic construction that bypasses
+ * Schemastery normalization still fails loud instead of running with hidden
+ * defaults (the explicit-resolve contract).
+ *
+ * @module dsh-mcp-panel/config
+ */
+import z from '@deepseek-ai/schemastery';
+/** Default per-probe timeout in milliseconds. */
+export declare const DEFAULT_PROBE_TIMEOUT_MS = 10000;
+/** Ceiling for a single probe timeout: a probe is a one-shot HTTP call. */
+export declare const MAX_PROBE_TIMEOUT_MS = 300000;
+/** Default cap on probe records shown in the panel. */
+export declare const DEFAULT_MAX_PROBES = 10;
+/** Ceiling on the suggested panel refresh interval (1 hour). */
+export declare const MAX_REFRESH_INTERVAL_MS = 3600000;
+/** Languages the `/mcp` command renders in (mirrors the five-language READMEs). */
+export type OutputLanguage = 'en' | 'zh' | 'es' | 'pt' | 'hi';
+/** Configuration for the MCP management panel. */
+export interface Config {
+    /** Register the optional `mcp_probe` connectivity tool (default true). */
+    probeEnabled?: boolean;
+    /** Per-probe timeout in milliseconds (default 10000). */
+    probeTimeoutMs?: number;
+    /** Cap on probe records shown in the panel (default 10). */
+    maxProbes?: number;
+    /** Suggested panel refresh interval in ms; 0 = on demand only (default 0). */
+    refreshIntervalMs?: number;
+    /** Output language of the `/mcp` command (default en). */
+    outputLanguage?: OutputLanguage;
+    /** Periodically probe streamable-http servers in the background (default false). */
+    passiveProbeEnabled?: boolean;
+    /** Passive probe interval in milliseconds (default 60000). */
+    passiveProbeIntervalMs?: number;
+}
+/** Fully resolved configuration captured at plugin load. */
+export interface ResolvedConfig {
+    /** Whether the `mcp_probe` tool is registered. */
+    probeEnabled: boolean;
+    /** Per-probe timeout in milliseconds. */
+    probeTimeoutMs: number;
+    /** Cap on probe records shown in the panel. */
+    maxProbes: number;
+    /** Suggested panel refresh interval in ms (0 = on demand). */
+    refreshIntervalMs: number;
+    /** Output language of the `/mcp` command. */
+    outputLanguage: OutputLanguage;
+    /** Whether the passive probe loop runs. */
+    passiveProbeEnabled: boolean;
+    /** Passive probe interval in milliseconds. */
+    passiveProbeIntervalMs: number;
+}
+/** Schemastery schema for loader-validated configuration. */
+export declare const Config: z<Config>;
+/**
+ * Resolve raw config to the runtime policy, re-validating defaults and bounds.
+ *
+ * @param config - raw loader config; `undefined` for a bare row.
+ * @returns the frozen resolved config.
+ */
+export declare function resolveConfig(config: Config | undefined): ResolvedConfig;
+//# sourceMappingURL=config.d.ts.map

package/lib/types/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,CAAC,MAAM,0BAA0B,CAAA;AAExC,iDAAiD;AACjD,eAAO,MAAM,wBAAwB,QAAS,CAAA;AAE9C,2EAA2E;AAC3E,eAAO,MAAM,oBAAoB,SAAU,CAAA;AAE3C,uDAAuD;AACvD,eAAO,MAAM,kBAAkB,KAAK,CAAA;AAEpC,gEAAgE;AAChE,eAAO,MAAM,uBAAuB,UAAY,CAAA;AAEhD,mFAAmF;AACnF,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAE7D,kDAAkD;AAClD,MAAM,WAAW,MAAM;IACrB,0EAA0E;IAC1E,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,yDAAyD;IACzD,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,8EAA8E;IAC9E,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,cAAc,CAAA;IAC/B,oFAAoF;IACpF,mBAAmB,CAAC,EAAE,OAAO,CAAA;IAC7B,8DAA8D;IAC9D,sBAAsB,CAAC,EAAE,MAAM,CAAA;CAChC;AAED,4DAA4D;AAC5D,MAAM,WAAW,cAAc;IAC7B,kDAAkD;IAClD,YAAY,EAAE,OAAO,CAAA;IACrB,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAA;IACtB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,iBAAiB,EAAE,MAAM,CAAA;IACzB,6CAA6C;IAC7C,cAAc,EAAE,cAAc,CAAA;IAC9B,2CAA2C;IAC3C,mBAAmB,EAAE,OAAO,CAAA;IAC5B,8CAA8C;IAC9C,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAED,6DAA6D;AAC7D,eAAO,MAAM,MAAM,EAAE,CAAC,CAAC,MAAM,CAQ3B,CAAA;AAEF;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,cAAc,CA8BxE"}

package/lib/types/grouping.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Enumeration of model-facing MCP tools from the ToolRuntime schema list,
+ * grouped by server namespace. The official bridge registers every MCP tool
+ * under `mcp__<serverName>__<rawName>` (normalized deterministically), so a
+ * prefix match against the configured server names is exact; leftover
+ * `mcp__`-prefixed registrations from foreign plugins are preserved in
+ * separate unconfigured groups instead of being mis-attributed or dropped.
+ *
+ * Pure functions of the schema snapshot — no registry reads.
+ *
+ * @module dsh-mcp-panel/grouping
+ */
+import type { McpToolView } from './wire.ts';
+/** The `mcp__` namespace prefix every bridged MCP tool name starts with. */
+export declare const MCP_TOOL_PREFIX = "mcp__";
+/** One tool group: a server namespace with its model-visible tools. */
+export interface McpToolGroup {
+    /** Server namespace (`mcp__<serverName>__…`); the best-effort segment for leftovers. */
+    serverName: string;
+    /** True when `serverName` is a configured mcp-client namespace. */
+    configured: boolean;
+    /** Model-visible tools under that namespace, sorted by public name. */
+    tools: readonly McpToolView[];
+}
+/** The schema face this module reads; the ToolRuntime snapshot satisfies it. */
+export interface ToolSchemaFace {
+    /** Registered public tool name. */
+    readonly name: string;
+    /** One-line model-facing description; may be absent on hostile or partial input. */
+    readonly description?: string;
+}
+/**
+ * Split one registered tool schema list into per-server groups.
+ *
+ * @param schemas - the `ctx.tools.schemas()` snapshot (or any subset).
+ * @param configuredNames - server namespaces from the loader's mcp-client rows.
+ * @returns one group per configured namespace (even with zero tools) plus one
+ *   group per unmatched `mcp__` namespace, sorted by server name.
+ */
+export declare function groupMcpTools(schemas: readonly ToolSchemaFace[], configuredNames: readonly string[]): McpToolGroup[];
+/**
+ * Count the tools registered under one configured server namespace.
+ *
+ * @param schemas - the `ctx.tools.schemas()` snapshot.
+ * @param serverName - the configured namespace.
+ * @returns the number of matching registrations.
+ */
+export declare function countServerTools(schemas: readonly ToolSchemaFace[], serverName: string): number;
+//# sourceMappingURL=grouping.d.ts.map

package/lib/types/grouping.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grouping.d.ts","sourceRoot":"","sources":["../../src/grouping.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAE5C,4EAA4E;AAC5E,eAAO,MAAM,eAAe,UAAU,CAAA;AAStC,uEAAuE;AACvE,MAAM,WAAW,YAAY;IAC3B,wFAAwF;IACxF,UAAU,EAAE,MAAM,CAAA;IAClB,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAA;IACnB,uEAAuE;IACvE,KAAK,EAAE,SAAS,WAAW,EAAE,CAAA;CAC9B;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,mCAAmC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oFAAoF;IACpF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,cAAc,EAAE,EAClC,eAAe,EAAE,SAAS,MAAM,EAAE,GACjC,YAAY,EAAE,CAwBhB;AAgBD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAO/F"}

package/lib/types/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `dsh-mcp-panel` — read-only runtime management panel for the official
+ * DeepSeek Harness MCP client (`@deepseek-ai/dsh-mcp-client`).
+ *
+ * Host half: mounts the `mcpPanel` Remote service (loader rows + tool
+ * registry + upstream `mcp/status` observations), registers the `/mcp`
+ * command where a command registry exists, and optionally registers the
+ * `mcp_probe` background-job tool where a job registry exists. The panel
+ * never edits configuration files and never fabricates connection state:
+ * without the proposed upstream status seam every connection field reads
+ * `unknown` with `statusSource: 'derived'`.
+ *
+ * Function plugin — no default export (the Loader unwraps
+ * `exports.default ?? exports`).
+ *
+ * @module dsh-mcp-panel
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { Config } from './config.ts';
+export declare const name = "mcp-panel";
+/** Hard services: the facts the panel reads. `commands`/`jobs` are optional children. */
+export declare const inject: string[];
+export { Config, resolveConfig } from './config.ts';
+export { McpPanelService } from './service.ts';
+export { mcpCommand, parseMcpArgs, renderList, renderPatchSuggestion, renderServer, renderTools } from './command.ts';
+export { groupMcpTools, countServerTools } from './grouping.ts';
+export { aggregateServerView, aggregateSnapshot, deriveTarget, serverNameOf } from './aggregate.ts';
+export { sanitizeError, sanitizeText, sanitizeUrl } from './sanitize.ts';
+export { probeEndpoint, probeJob, mcpProbeTool } from './probe.ts';
+export { MCP_STATUS_EVENT, type McpStatusPayload, type McpStatusQuery, type McpServerStatus } from './upstream.ts';
+export type * from './wire.ts';
+/**
+ * Mount the panel: the snapshot service, the upstream status seam consumer,
+ * the `/mcp` command (when commands exist), and the probe tool (when enabled
+ * and a job registry exists).
+ *
+ * @param ctx - context carrying tools + loader.
+ * @param config - raw loader config; defaults applied through {@link resolveConfig}.
+ */
+export declare function apply(ctx: Context, config: Config): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAIlD,OAAO,EAAE,MAAM,EAAiB,MAAM,aAAa,CAAA;AAMnD,eAAO,MAAM,IAAI,cAAc,CAAA;AAE/B,yFAAyF;AACzF,eAAO,MAAM,MAAM,UAAsB,CAAA;AAEzC,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,qBAAqB,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACrH,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAC/D,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AACnG,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AACxE,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAClE,OAAO,EAAE,gBAAgB,EAAE,KAAK,gBAAgB,EAAE,KAAK,cAAc,EAAE,KAAK,eAAe,EAAE,MAAM,eAAe,CAAA;AAClH,mBAAmB,WAAW,CAAA;AAE9B;;;;;;;GAOG;AACH,wBAAsB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCvE"}

package/lib/types/probe.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The optional `mcp_probe` tool: a one-shot connectivity probe of one
+ * configured Streamable HTTP endpoint, executed as an UNOWNED background job.
+ * Probe results are panel-only — the tool returns just the job id and a
+ * pointer to the settings tab, the job carries no owner (so no completion
+ * notice is injected into the model), and the panel reads the sanitized
+ * snapshot back through `mcpPanel/status`.
+ *
+ * @module dsh-mcp-panel/probe
+ */
+import type { JobHooks, JobRegistry } from '@deepseek-ai/dsh-jobs';
+import type { ToolDefinition } from '@deepseek-ai/dsh-tools';
+import type { McpPanelService } from './service.ts';
+/** Producer kind; also the job-id prefix. */
+export declare const PROBE_KIND = "mcp-probe";
+declare module '@deepseek-ai/dsh-jobs' {
+    interface JobKindMap {
+        /** One-shot Streamable HTTP connectivity probe (panel-only results). */
+        'mcp-probe': 'mcp-probe';
+    }
+}
+/** MCP clientInfo facts; protocol constants, not configuration. Exported so the
+ * version-consistency tripwire (`tests/version.spec.ts`) can assert the
+ * advertised version tracks the package version. */
+export declare const PROBE_CLIENT_INFO: {
+    name: string;
+    version: string;
+};
+/** One settled probe: outcome status plus a sanitized one-line detail. */
+export interface ProbeOutcome {
+    /** How the job ended. */
+    status: 'completed' | 'failed';
+    /** Sanitized one-line detail (HTTP status, latency, server info, or error). */
+    detail: string;
+}
+/**
+ * POST one MCP `initialize` request and describe the outcome in one sanitized
+ * line. Never sends or echoes credentials: the configured headers are used
+ * for the request itself (exactly as the bridge would) and never rendered.
+ *
+ * @param url - endpoint URL (already parsed by the caller).
+ * @param headers - the configured request headers; used, never displayed.
+ * @param timeoutMs - probe deadline.
+ * @param signal - caller-owned abort (job kill or timeout).
+ * @returns the settled probe outcome.
+ */
+export declare function probeEndpoint(url: string, headers: Readonly<Record<string, string>>, timeoutMs: number, signal: AbortSignal): Promise<ProbeOutcome>;
+/**
+ * Create the background-job hooks for one probe: cancel aborts the fetch, the
+ * outcome settles `done` with sanitized detail only.
+ *
+ * @param url - endpoint URL.
+ * @param headers - configured headers (used, never rendered).
+ * @param timeoutMs - probe deadline.
+ * @returns the registry hooks.
+ */
+export declare function probeJob(url: string, headers: Readonly<Record<string, string>>, timeoutMs: number): JobHooks;
+/**
+ * Build the `mcp_probe` tool definition.
+ *
+ * @param service - panel service (server lookup + snapshot for panel display).
+ * @param jobs - background-job registry the probe runs on.
+ * @param timeoutMs - per-probe deadline.
+ * @returns the registration-ready definition.
+ */
+export declare function mcpProbeTool(service: McpPanelService, jobs: JobRegistry, timeoutMs: number): ToolDefinition;
+//# sourceMappingURL=probe.d.ts.map

package/lib/types/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../../src/probe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAc,WAAW,EAAE,MAAM,uBAAuB,CAAA;AAC9E,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAA;AAG5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,cAAc,CAAA;AAEnD,6CAA6C;AAC7C,eAAO,MAAM,UAAU,cAAc,CAAA;AAErC,OAAO,QAAQ,uBAAuB,CAAC;IACrC,UAAU,UAAU;QAClB,wEAAwE;QACxE,WAAW,EAAE,WAAW,CAAA;KACzB;CACF;AAKD;;oDAEoD;AACpD,eAAO,MAAM,iBAAiB;;;CAA8C,CAAA;AAE5E,0EAA0E;AAC1E,MAAM,WAAW,YAAY;IAC3B,yBAAyB;IACzB,MAAM,EAAE,WAAW,GAAG,QAAQ,CAAA;IAC9B,+EAA+E;IAC/E,MAAM,EAAE,MAAM,CAAA;CACf;AAUD;;;;;;;;;;GAUG;AACH,wBAAsB,aAAa,CACjC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EACzC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,WAAW,GAClB,OAAO,CAAC,YAAY,CAAC,CA4CvB;AAED;;;;;;;;GAQG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAAE,SAAS,EAAE,MAAM,GAAG,QAAQ,CAW5G;AAUD;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,cAAc,CA8C3G"}

package/lib/types/sanitize.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Display sanitization for MCP panel surfaces. Everything the panel shows —
+ * the `/mcp` command output, the web settings tab, probe job details — passes
+ * through these pure functions so URL query-string credentials, userinfo
+ * passwords, header values, and bearer tokens never reach a display.
+ *
+ * The panel never shows configured `headers` at all (they are dropped at
+ * snapshot assembly); this module redacts what can still leak through target
+ * URLs and error text.
+ *
+ * @module dsh-mcp-panel/sanitize
+ */
+/** Replacement for every redacted credential value. */
+export declare const REDACTED = "***";
+/**
+ * Redact a URL for display: userinfo password, credential query values, and
+ * credential fragment pairs. Query keys are read through `URLSearchParams`,
+ * so percent-encoded key names are decoded before matching. Unparseable
+ * inputs fall back to pattern redaction (whole userinfo, credential query
+ * pairs, credential fragment pairs) instead of throwing.
+ *
+ * @param url - candidate URL text.
+ * @returns display-safe URL text.
+ */
+export declare function sanitizeUrl(url: string): string;
+/**
+ * Redact credential-shaped fragments from free text: header lines, bearer
+ * tokens, raw JWTs, embedded query pairs, and quoted token values.
+ *
+ * @param text - candidate display text.
+ * @returns display-safe text.
+ */
+export declare function sanitizeText(text: string): string;
+/**
+ * Stringify an arbitrary thrown value safely and redact it for display.
+ * Never throws: unrenderable values degrade to a fixed marker.
+ *
+ * @param error - thrown value from a connection attempt, probe, or sync.
+ * @returns display-safe error text.
+ */
+export declare function sanitizeError(error: unknown): string;
+//# sourceMappingURL=sanitize.d.ts.map

package/lib/types/sanitize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sanitize.d.ts","sourceRoot":"","sources":["../../src/sanitize.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,uDAAuD;AACvD,eAAO,MAAM,QAAQ,QAAQ,CAAA;AAmC7B;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAgB/C;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAajD;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAQpD"}

package/lib/types/service.d.ts

@@ -0,0 +1,107 @@
+/**
+ * The panel's host service: assembles the read-only MCP snapshot and serves
+ * it under the `mcpPanel` Typert Remote namespace (`mcpPanel/status`).
+ *
+ * Data sources, all read-only:
+ * - `ctx.loader` — mcp-client rows (raw config, effective disabled, fiber phase).
+ * - `ctx.tools.schemas()` — registered `mcp__<server>__` tool names + descriptions.
+ * - the proposed upstream `mcp/status` seam — observed via {@link observe}.
+ * - `ctx.jobs` — unowned `mcp-probe` background jobs (panel-only results).
+ *
+ * Connection status is reported honestly: without upstream observations the
+ * view reads `unknown` with `statusSource: 'derived'`; the panel never infers
+ * a connection state from tool-registry presence.
+ *
+ * @module dsh-mcp-panel/service
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
+import type { McpServerStatus } from './upstream.ts';
+import type { McpPanelSnapshot, ProbeStarted } from './wire.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        /** Read-only MCP management snapshot service (this package). */
+        mcpPanel: McpPanelService;
+    }
+}
+/** Service-level runtime settings; the plugin passes its resolved config in. */
+export interface McpPanelServiceConfig {
+    /** Per-probe timeout in milliseconds. */
+    probeTimeoutMs: number;
+    /** Cap on probe records shown in the panel. */
+    maxProbes: number;
+    /** Suggested panel refresh interval in ms (0 = on demand). */
+    refreshIntervalMs: number;
+    /** Whether the passive probe loop runs. */
+    passiveProbeEnabled: boolean;
+    /** Passive probe interval in milliseconds. */
+    passiveProbeIntervalMs: number;
+}
+/** Read-only MCP management snapshot service, exported over the `mcpPanel` Remote namespace. */
+export declare class McpPanelService extends TypertRemoteService {
+    private readonly config;
+    static inject: string[];
+    /** Latest upstream payload per server namespace. */
+    private readonly statuses;
+    /** Cumulative reconnect attempts observed per server namespace. */
+    private readonly reconnects;
+    /** Epoch ms of the latest upstream event receipt per server namespace. */
+    private readonly observedAt;
+    /** Latest passive-probe reachability per server namespace. */
+    private readonly probeStates;
+    /** Passive-probe loop guard: one sweep at a time. */
+    private passiveRunning;
+    /**
+     * @param ctx - context carrying the loader and tool registry.
+     * @param config - resolved runtime settings; defaults apply for direct construction.
+     */
+    constructor(ctx: Context, config?: McpPanelServiceConfig);
+    /**
+     * Record one upstream `mcp/status` payload (event or query-seed). A
+     * `connecting` payload with a positive attempt counts one reconnect.
+     *
+     * @param payload - post-transition status facts.
+     */
+    observe(payload: McpServerStatus): void;
+    /**
+     * Assemble the current snapshot. Read-only: touches no configuration file
+     * and mutates no registry. Exported on the wire by the `mcpPanel/status`
+     * invocation descriptor in `./wire.ts` (registered through the package's
+     * `./typert` manifest) — no method decorator, so the built bundle stays
+     * plain ESM.
+     *
+     * @returns the wire snapshot (validated by the strict Typert codec on both faces).
+     */
+    status(): McpPanelSnapshot;
+    /**
+     * Start a one-shot connectivity probe of one configured streamable-http
+     * server as an UNOWNED background job — panel-only, like the `mcp_probe`
+     * tool, but callable from the settings tab. Exported on the wire by the
+     * `mcpPanel/probe` invocation descriptor.
+     *
+     * @param serverName - configured namespace.
+     * @returns the started job id and where the result lands.
+     */
+    probe(serverName: string): ProbeStarted;
+    /** One passive-probe sweep over every configured streamable-http server. */
+    private runPassiveProbes;
+    /**
+     * Resolve one server's raw endpoint for the probe tool. Credentials stay
+     * inside this return value and are used for the request only — they never
+     * reach a snapshot, a log, or a display.
+     *
+     * @param serverName - configured namespace.
+     * @returns the raw URL + configured headers, or `undefined` when the server
+     *   is not a configured streamable-http row.
+     */
+    rawEndpoint(serverName: string): {
+        url: string;
+        headers: Record<string, string>;
+    } | undefined;
+    /** Unowned `mcp-probe` background jobs, newest first, sanitized for display. */
+    private probeViews;
+    /** Absolute path of the profile patch layer the suggestions name, or null. */
+    private patchFile;
+}
+export default McpPanelService;
+//# sourceMappingURL=service.d.ts.map

package/lib/types/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../src/service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAA;AAetE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,KAAK,EAAiB,gBAAgB,EAAgB,YAAY,EAAE,MAAM,WAAW,CAAA;AAE5F,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,OAAO;QACf,gEAAgE;QAChE,QAAQ,EAAE,eAAe,CAAA;KAC1B;CACF;AAqBD,gFAAgF;AAChF,MAAM,WAAW,qBAAqB;IACpC,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAA;IACtB,+CAA+C;IAC/C,SAAS,EAAE,MAAM,CAAA;IACjB,8DAA8D;IAC9D,iBAAiB,EAAE,MAAM,CAAA;IACzB,2CAA2C;IAC3C,mBAAmB,EAAE,OAAO,CAAA;IAC5B,8CAA8C;IAC9C,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAWD,gGAAgG;AAChG,qBAAa,eAAgB,SAAQ,mBAAmB;IAkB5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IAjBjD,MAAM,CAAC,MAAM,WAAsB;IAEnC,oDAAoD;IACpD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAqC;IAC9D,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,0EAA0E;IAC1E,OAAO,CAAC,QAAQ,CAAC,UAAU,CAA4B;IACvD,8DAA8D;IAC9D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA+E;IAC3G,qDAAqD;IACrD,OAAO,CAAC,cAAc,CAAQ;IAE9B;;;OAGG;gBACS,GAAG,EAAE,OAAO,EAAmB,MAAM,GAAE,qBAA8C;IAUjG;;;;;OAKG;IACH,OAAO,CAAC,OAAO,EAAE,eAAe,GAAG,IAAI;IASvC;;;;;;;;OAQG;IACH,MAAM,IAAI,gBAAgB;IA+B1B;;;;;;;;OAQG;IACH,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,YAAY;IAqBvC,4EAA4E;YAC9D,gBAAgB;IAiB9B;;;;;;;;OAQG;IACH,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAAE,GAAG,SAAS;IAsB7F,gFAAgF;IAChF,OAAO,CAAC,UAAU;IAkBlB,8EAA8E;IAC9E,OAAO,CAAC,SAAS;CAMlB;AAED,eAAe,eAAe,CAAA"}

package/lib/types/typert.host.d.ts

@@ -0,0 +1,110 @@
+/**
+ * The hand-written Typert HOST manifest for `dsh-mcp-panel`, exported as
+ * `./typert` so the harness's typert-loader registers the `mcpPanel` status
+ * and probe invocations automatically when this plugin mounts. Same shape as
+ * a generator output (validated by the loader): package face, empty model and
+ * schemas, and the canonical invocation list shared with the client Remote
+ * contribution (`src/wire.ts`).
+ *
+ * @module dsh-mcp-panel/typert
+ */
+/** Host Typert manifest (validated by `@deepseek-ai/dsh-typert-loader`). */
+export declare const TYPERT: Readonly<{
+    package: "dsh-mcp-panel";
+    face: "host";
+    schemas: readonly never[];
+    invocations: readonly (Readonly<{
+        readonly id: "dsh-mcp-panel#mcpPanel/status";
+        readonly service: "mcpPanel";
+        readonly namespace: "mcpPanel";
+        readonly method: "status";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly never[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-mcp-panel/types#McpPanelSnapshot";
+            schema: import("zod").ZodObject<{
+                observed: import("zod").ZodBoolean;
+                patchFile: import("zod").ZodNullable<import("zod").ZodString>;
+                refreshIntervalMs: import("zod").ZodNumber;
+                servers: import("zod").ZodArray<import("zod").ZodObject<{
+                    serverName: import("zod").ZodString;
+                    entryId: import("zod").ZodString;
+                    transport: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"stdio">, import("zod").ZodLiteral<"streamable-http">, import("zod").ZodLiteral<"unknown">]>;
+                    target: import("zod").ZodString;
+                    enabled: import("zod").ZodBoolean;
+                    fiberPhase: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"pending">, import("zod").ZodLiteral<"loading">, import("zod").ZodLiteral<"active">, import("zod").ZodLiteral<"failed">, import("zod").ZodLiteral<"unloading">, import("zod").ZodNull]>;
+                    configuredNote: import("zod").ZodNullable<import("zod").ZodString>;
+                    toolCount: import("zod").ZodNumber;
+                    tools: import("zod").ZodArray<import("zod").ZodObject<{
+                        name: import("zod").ZodString;
+                        description: import("zod").ZodString;
+                    }, import("zod/v4/core").$strip>>;
+                    phase: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"connecting">, import("zod").ZodLiteral<"connected">, import("zod").ZodLiteral<"waiting">, import("zod").ZodLiteral<"exhausted">, import("zod").ZodLiteral<"disposed">, import("zod").ZodLiteral<"unknown">]>;
+                    attempt: import("zod").ZodNumber;
+                    maxAttempts: import("zod").ZodNumber;
+                    delayMs: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    reconnectCount: import("zod").ZodNumber;
+                    lastError: import("zod").ZodNullable<import("zod").ZodString>;
+                    connectedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    observedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    probeState: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"reachable">, import("zod").ZodLiteral<"unreachable">, import("zod").ZodNull]>;
+                    probeCheckedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    statusSource: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"upstream-event">, import("zod").ZodLiteral<"derived">]>;
+                }, import("zod/v4/core").$strip>>;
+                probes: import("zod").ZodArray<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    serverName: import("zod").ZodString;
+                    status: import("zod").ZodUnion<readonly [import("zod").ZodLiteral<"running">, import("zod").ZodLiteral<"stopping">, import("zod").ZodLiteral<"completed">, import("zod").ZodLiteral<"killed">, import("zod").ZodLiteral<"failed">]>;
+                    startedAt: import("zod").ZodNumber;
+                    finishedAt: import("zod").ZodNullable<import("zod").ZodNumber>;
+                    detail: import("zod").ZodNullable<import("zod").ZodString>;
+                }, import("zod/v4/core").$strip>>;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }> | Readonly<{
+        readonly id: "dsh-mcp-panel#mcpPanel/probe";
+        readonly service: "mcpPanel";
+        readonly namespace: "mcpPanel";
+        readonly method: "probe";
+        readonly invocation: Readonly<{
+            kind: "direct";
+        }>;
+        readonly parameters: readonly Readonly<{
+            name: string;
+            wire: string;
+            source: "json";
+            codec: Readonly<{
+                mode: "strict";
+                typeSymbol: "dsh-mcp-panel/types#ProbeRequestServerName";
+                schema: import("zod").ZodString;
+            }>;
+        }>[];
+        readonly result: Readonly<{
+            mode: "strict";
+            typeSymbol: "dsh-mcp-panel/types#ProbeStarted";
+            schema: import("zod").ZodObject<{
+                jobId: import("zod").ZodString;
+                note: import("zod").ZodString;
+            }, import("zod/v4/core").$strip>;
+        }>;
+        readonly sourceLocation: Readonly<{
+            file: "src/wire.ts";
+            line: 1;
+            column: 1;
+        }>;
+    }>)[];
+    model: Readonly<{
+        services: readonly never[];
+        events: readonly never[];
+        objects: readonly never[];
+    }>;
+}>;
+//# sourceMappingURL=typert.host.d.ts.map

package/lib/types/typert.host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typert.host.d.ts","sourceRoot":"","sources":["../../src/typert.host.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,4EAA4E;AAC5E,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUjB,CAAA"}

package/lib/types/upstream.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The proposed upstream observability seam of `@deepseek-ai/dsh-mcp-client`
+ * (see `docs/upstream-proposal.md` in the deepseek-harness repository),
+ * consumed here before it ships: the typed `mcp/status` Cordis event and the
+ * `mcpStatus` query service face.
+ *
+ * Declarations merge into `@deepseek-ai/cordis`. If upstream later ships the
+ * same seam, its identical declarations merge cleanly; a conflicting
+ * signature fails this package's compile, which is the intended tripwire.
+ * At runtime the seam is feature-detected: with no upstream implementation
+ * mounted, no events arrive and `ctx.mcpStatus` is absent, so the panel falls
+ * back to derived facts and reports `statusSource: 'derived'`.
+ *
+ * @module dsh-mcp-panel/upstream
+ */
+/** Supervisor phase after one `mcp/status` transition (mirrors the proposal). */
+export type McpStatusPhase = 'connecting' | 'connected' | 'waiting' | 'exhausted' | 'disposed';
+/**
+ * App-level connection-status payload emitted on every mcp-client state
+ * transition. `error` carries raw same-process text; DISPLAY consumers must
+ * sanitize (this package's `sanitize.ts`) before rendering.
+ */
+export interface McpStatusPayload {
+    /** Stable local namespace from plugin config. */
+    serverName: string;
+    /** Supervisor phase after the transition. */
+    phase: McpStatusPhase;
+    /** Consecutive failed attempts in the current outage (0 while connected). */
+    attempt: number;
+    /** Resolved reconnect budget (`reconnect.maxAttempts`). */
+    maxAttempts: number;
+    /** Scheduled backoff delay while `waiting`. */
+    delayMs?: number;
+    /** Raw error text of the failed attempt or re-sync. */
+    error?: string;
+    /** Tools registered after the last successful sync. */
+    toolCount: number;
+    /** Epoch ms of the last successful connect; absent while down. */
+    connectedAt?: number;
+}
+/** Current per-server status snapshot; the query face of `mcp/status`. */
+export type McpServerStatus = McpStatusPayload;
+/** Structural query face of the proposed `mcpStatus` service (feature-detected). */
+export interface McpStatusQuery {
+    /** Current status of every server this process knows. */
+    list(): readonly McpServerStatus[];
+    /** Current status of one server namespace, or `undefined`. */
+    get(serverName: string): McpServerStatus | undefined;
+}
+declare module '@deepseek-ai/cordis' {
+    interface Events {
+        /**
+         * One MCP client supervisor state transition (the proposed upstream
+         * observability seam). App-level: no agent or session scope.
+         * @param payload - post-transition status facts.
+         * @mode emit
+         */
+        'mcp/status'(payload: McpStatusPayload): void;
+    }
+    interface Context {
+        /** The proposed upstream status query service; absent until upstream ships it. */
+        mcpStatus?: McpStatusQuery;
+    }
+}
+/** Exact event name, exported so consumers never hardcode the literal twice. */
+export declare const MCP_STATUS_EVENT = "mcp/status";
+//# sourceMappingURL=upstream.d.ts.map

package/lib/types/upstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.d.ts","sourceRoot":"","sources":["../../src/upstream.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,iFAAiF;AACjF,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,CAAA;AAE9F;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB,6CAA6C;IAC7C,KAAK,EAAE,cAAc,CAAA;IACrB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAA;IACf,2DAA2D;IAC3D,WAAW,EAAE,MAAM,CAAA;IACnB,+CAA+C;IAC/C,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,uDAAuD;IACvD,SAAS,EAAE,MAAM,CAAA;IACjB,kEAAkE;IAClE,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,0EAA0E;AAC1E,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAA;AAE9C,oFAAoF;AACpF,MAAM,WAAW,cAAc;IAC7B,yDAAyD;IACzD,IAAI,IAAI,SAAS,eAAe,EAAE,CAAA;IAClC,8DAA8D;IAC9D,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAAA;CACrD;AAED,OAAO,QAAQ,qBAAqB,CAAC;IACnC,UAAU,MAAM;QACd;;;;;WAKG;QACH,YAAY,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAA;KAC9C;IACD,UAAU,OAAO;QACf,kFAAkF;QAClF,SAAS,CAAC,EAAE,cAAc,CAAA;KAC3B;CACF;AAED,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,eAAe,CAAA"}