dsh-agent-plugins-market 0.5.2 → 0.6.0

package/lib/types/runtime/mcp-client/tools.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Tool bridge: discovers MCP tools, registers them on the harness ToolRuntime
+ * under deterministic server-qualified public names, and handles re-sync when
+ * the server's tool list changes.
+ *
+ * Naming contract (mirrored from the harness `dsh-mcp-client` naming
+ * invariants): every MCP tool has the stable identity `(serverName, rawName)`;
+ * the model-facing public name is `mcp__<serverName>__<rawName>`, normalized
+ * to the DeepSeek function-name constraints. The raw name is only ever sent on
+ * the wire (`tools/call`); the public name is never parsed to recover it.
+ *
+ * The host contract below (`ToolDefinition`, `ToolExecution`,
+ * `ToolExecutionResult`) is a structural mirror of `@deepseek-ai/dsh-tools`
+ * rc.2's registration surface — the runtime accepts the same object shape the
+ * upstream bridge registers, so the model-facing behavior is identical.
+ *
+ * @module runtime/mcp-client/tools
+ */
+import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import type { ContentBlock } from '@deepseek-ai/dsh-llm';
+import type { JsonSchemaNode } from './json-schema-subset.js';
+/** Lossless JSON value vocabulary the bridge exchanges with the registry. */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/** Canonical MCP result exposed to Code Mode without discarding protocol blocks. */
+export type McpResult<Structured extends JsonValue = JsonValue> = {
+    content: JsonValue[];
+    structuredContent?: Structured;
+};
+/** The agent on whose behalf a tool call runs (structural mirror). */
+interface ToolExecutionAgent {
+    session?: {
+        requestHeader?: () => {
+            config?: {
+                provider?: string;
+                model?: string;
+            };
+        } | undefined;
+    };
+    options?: {
+        provider?: string;
+        model?: string;
+    };
+} /** Execution identity handed to a tool body (structural mirror). */
+export interface ToolExecution {
+    /** Caller-owned cancellation for this invocation. */
+    readonly signal: AbortSignal;
+    /** The calling agent, when the call came from one. */
+    readonly agent?: ToolExecutionAgent;
+}
+/** A settled tool outcome (structural mirror). */
+export interface ToolExecutionResult {
+    readonly value: JsonValue;
+    readonly content: ContentBlock[];
+    readonly isError: boolean;
+}
+/** One registered tool (structural mirror of the host registration shape). */
+export interface ToolDefinition {
+    readonly name: string;
+    readonly description: string;
+    readonly parameters: Record<string, unknown>;
+    readonly output: {
+        readonly schema: JsonSchemaNode;
+        render(args: unknown, value: JsonValue): ContentBlock[];
+    };
+    execute(args: unknown, exec: ToolExecution): Promise<unknown>;
+    finalizeContent?(exec: Readonly<ToolExecution>, result: Readonly<ToolExecutionResult>): ContentBlock[] | undefined;
+}
+/**
+ * The host surface the bridge needs: a tool registry, a logger, and the two
+ * optional services image projection consults. Structural — the cordis
+ * context is adapted onto this shape by the bridge shell.
+ */
+export interface ToolHost {
+    readonly logger: {
+        error(message: string): void;
+        warn(message: string): void;
+        info(message: string): void;
+    };
+    readonly tools: {
+        register(definition: ToolDefinition): () => void;
+    };
+    /** Optional service lookup; image projection degrades when absent. */
+    getService?(name: 'attachments' | 'llm'): unknown;
+}
+/** Resolved options relevant to tool bridging. */
+export interface ToolBridgeOptions {
+    /** Whether a registry conflict is contained or rejects this synchronization. */
+    registrationFailure: 'contain' | 'throw';
+    serverName: string;
+    toolCallTimeoutMs: number;
+}
+/** State for one sync generation: the current set of disposers keyed by public name. */
+export type ToolDisposers = Map<string, () => void>;
+/**
+ * Derive the model-facing public name for one MCP tool.
+ *
+ * Deterministic pure function of `(serverName, rawName)`: the clean case is
+ * `mcp__<serverName>__<rawName>` verbatim. When character replacement or
+ * truncation to the DeepSeek function-name contract (64 chars,
+ * `[A-Za-z0-9_-]`) changes the name, a 12-hex-char SHA-256 hash of the
+ * identity is appended so distinct MCP identities never collapse into the
+ * same public name.
+ *
+ * @param serverName - Stable local namespace from bridge config.
+ * @param rawName - The MCP server's own tool name.
+ * @returns The globally unique, model-facing ToolRuntime name.
+ */
+export declare function publicToolName(serverName: string, rawName: string): string;
+/**
+ * Sync the MCP server's tool list into the harness ToolRuntime.
+ *
+ * Two phases keep the swap safe:
+ *
+ * 1. Fetch: drain uncached `tools/list` pagination and build the full next
+ *    generation of `ToolDefinition`s under public names. Any failure here
+ *    (network error, duplicate raw name in the server's list) rejects and
+ *    leaves the previous generation registered untouched.
+ * 2. Swap: dispose the previous generation, register the new one. A registry
+ *    conflict here can only mean a foreign registration squats on this
+ *    server's `mcp__<serverName>__` namespace — the partial generation is
+ *    rolled back (zero tools from this server) and logged. Initial strict
+ *    synchronization may propagate the conflict so its parent transaction
+ *    rejects; ordinary clients and later re-syncs return an empty map.
+ *
+ * @param client - Connected MCP Client instance used to list and call tools.
+ * @param host - The bridge host providing the tool registry and logger.
+ * @param opts - Bridge options: server namespace and per-call timeout.
+ * @param previous - Disposer map from the prior sync generation; disposed
+ *   during the swap phase (only after the fetch phase succeeded).
+ * @returns A map of registered public tool names to their unregister
+ *   disposers — the exact set of live registrations owned by this server.
+ */
+export declare function syncTools(client: Client, host: ToolHost, opts: ToolBridgeOptions, previous: ToolDisposers): Promise<ToolDisposers>;
+export {};

package/lib/types/runtime/mcp-client/transport.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Transport factory: creates the appropriate MCP transport based on the
+ * bridge's resolved config. Stdio spawns a child process (with credential
+ * scrubbing); Streamable HTTP connects to a URL; legacy SSE connects to a
+ * URL with the pre-Streamable-HTTP protocol pairing. Both HTTP transports
+ * carry OAuth 2.1 authorization by default, activated by the server's first
+ * `401` challenge.
+ *
+ * @module runtime/mcp-client/transport
+ */
+import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import { LoopbackOAuthClientProvider } from './oauth.js';
+import type { Config } from './config.js';
+/**
+ * Create an MCP transport from the resolved bridge config.
+ *
+ * With OAuth active (the default), the Streamable HTTP and SSE transports
+ * carry an {@link OAuthClientProvider}: the first `401` from the server
+ * starts discovery, dynamic registration, and a loopback browser
+ * authorization, and granted tokens persist through the credentials service
+ * for later processes. Transport generation identity stays with the caller —
+ * the provider binds whichever transport it hands out, so a reconnect builds
+ * a fresh generation on the same durable state.
+ *
+ * @param config - Resolved bridge config discriminated on `transport`.
+ * @param credentials - The composition's credential store, when mounted; OAuth
+ *   state persists only when it is.
+ * @param log - Diagnostic sink for the human leg of the flow.
+ * @returns The transport plus its OAuth provider, when active — the
+ *   supervisor queries the provider to hold the generation open while a
+ *   browser leg is pending.
+ */
+export declare function createTransport(config: Config, credentials?: unknown, log?: (message: string) => void): {
+    transport: Transport;
+    oauthProvider: LoopbackOAuthClientProvider | undefined;
+};

package/lib/types/runtime/mcp-config.d.ts

@@ -1,30 +1,47 @@
-import type { StdioConfig, StreamableHttpConfig } from '@deepseek-ai/dsh-mcp-client';
+import type { Config } from './mcp-client/config.js';
 import { type McpSuiteOverrides } from './mcp-overrides.js';
-import type { Suite } from '../model/types.js';
+import type { McpServer, Suite } from '../model/types.js';
 export interface McpMountRequest {
     suiteId: string;
     serverKey: string;
-    config: StdioConfig | StreamableHttpConfig;
+    config: Config;
 }
+export type McpMountFailureCode = 'unsupported-transport' | 'missing-credential' | 'credential-error' | 'unmount-failed' | 'mount-failed'
+/** The derived serverName's namespace is already mounted by another MCP client — informational, not a failure. */
+ | 'foreign-mount';
 export interface McpMountFailure {
     serverKey: string;
     reason: string;
+    code?: McpMountFailureCode;
+    credentialRefs?: string[];
+}
+/** Optional DSH credential resolver used while building an in-memory mount. */
+export interface McpCredentialResolver {
+    resolve(ref: string): Promise<{
+        value: string;
+        source?: string;
+    } | undefined>;
 }
 /**
- * Build one mount request per supported mcp.json server.
+ * Build one mount request per supported mcp.json server, resolving every
+ * `${NAME}` through the credential resolver before a child process or HTTP
+ * request is created. Missing references fail closed per server instead of
+ * becoming empty strings.
+ *
  * @param overrides user-owned per-server overrides (url/headers/env/args
- *   replacement plus enable/disable); applied after source expansion, before
- *   mount. Disabled servers are omitted from the result entirely.
- * @returns mount requests plus per-server failures (unsupported transport,
- *   invalid server key, or derived serverName collision candidates are
- *   checked by the mount registry, not here).
+ *   replacement plus enable/disable); applied before mount. Disabled servers
+ *   are omitted entirely.
+ * @returns mount requests plus per-server failures. serverName collisions are
+ *   reported by the mount registry, not here.
  */
-export declare function toMcpMounts(suite: Suite, pluginDataRoot: string, overrides?: McpSuiteOverrides): {
+export declare function toMcpMounts(suite: Suite, pluginDataRoot: string, overrides?: McpSuiteOverrides, resolver?: McpCredentialResolver): Promise<{
     mounts: McpMountRequest[];
     failures: McpMountFailure[];
-};
+}>;
+/** Find external credential references used by one MCP server definition. */
+export declare function credentialRefsInServer(server: McpServer): string[];
 /**
- * Derive a stable, unique-ish `dsh-mcp-client` serverName from the suite and
+ * Derive a stable, unique-ish bridge serverName from the suite and
  * server ids: `${suiteId}__${serverKey}` sanitized, truncated to 32 chars
  * with a deterministic 12-hex suffix when the join exceeds the budget (the
  * same deterministic-hash policy the MCP client uses for long tool names).

package/lib/types/runtime/mcp-credentials.d.ts

@@ -0,0 +1,9 @@
+/** Resolve MCP `${NAME}` placeholders through the optional DSH credentials seam. */
+import type { Context } from '@deepseek-ai/cordis';
+import type { McpCredentialResolver } from './mcp-config.js';
+/**
+ * Build the resolver used at mount time. Standard DSH profiles provide
+ * `ctx.credentials`; minimal profiles retain the historical process-env
+ * fallback so MCP mounting remains backwards compatible.
+ */
+export declare function mcpCredentialResolver(ctx: Context): McpCredentialResolver;

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

@@ -1,37 +1,87 @@
 /**
- * Runtime MCP mounts: one live `dsh-mcp-client` child plugin per enabled
+ * Runtime MCP mounts: one live self-built bridge child plugin per enabled
  * suite's mcp.json server, mounted through `ctx.plugin`.
  *
  * Mounts reconcile against the enabled-suite set: reconcile() unmounts rows
  * whose suite was disabled or removed and mounts rows that appeared. A
- * missing `@deepseek-ai/dsh-mcp-client` install, a duplicate derived
- * serverName, or a load failure is contained per server — a broken third-party
- * suite must not take the host down — and reported through the manager's
- * diagnostic list.
+ * duplicate derived serverName or a load failure is contained per server — a
+ * broken third-party suite must not take the host down — and reported through
+ * the manager's diagnostic list.
  */
 import type { Context } from '@deepseek-ai/cordis';
-import type { McpSuiteOverrides } from './mcp-overrides.js';
+import type { McpBackend } from './mcp-backend.js';
+import { type McpSuiteOverrides } from './mcp-overrides.js';
+import { type McpMountFailureCode } from './mcp-config.js';
 import type { Suite } from '../model/types.js';
 export interface McpMountDiagnostic {
     suiteId: string;
     serverKey: string;
     reason: string;
+    code?: McpMountFailureCode;
+    credentialRefs?: string[];
 }
 export declare class McpMountRegistry {
     private readonly ctx;
     private readonly pluginDataRoot;
     private readonly live;
     private readonly names;
+    private readonly credentialRefs;
     private overridesProvider;
+    /** Live model-facing tool names, for foreign-namespace detection before a mount. */
+    private toolNamesProvider;
+    /** The active MCP mount backend ('builtin' bridge or host client compat mode). */
+    private backendProvider;
     /** 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;
+    /**
+     * Mount keys flagged for an explicit rebuild (re-authorize): the next
+     * reconcile must tear down and remount them even when the resolved config
+     * fingerprint is unchanged — dropping a grant changes no config field.
+     */
+    private readonly forcedRemounts;
+    /** Snapshot of the last reconciled suite set, replayed by retry passes. */
+    private lastEnabled;
     constructor(ctx: Context, pluginDataRoot: string);
     /** Install the per-suite overrides provider (suiteId -> overrides). */
     setOverridesProvider(provider: () => Promise<Map<string, McpSuiteOverrides>>): void;
+    /**
+     * Install the live model-facing tool-name provider (the host registry
+     * snapshot) used to detect foreign `mcp__<serverName>__` namespaces before
+     * a mount is attempted.
+     */
+    setToolNamesProvider(provider: () => string[]): void;
+    /** Install the backend provider deciding which client mounts each server. */
+    setBackendProvider(provider: () => Promise<McpBackend>): void;
+    /** Whether the last catalog snapshot uses one credential reference. */
+    usesCredential(ref: string): boolean;
+    /**
+     * Flag one mount for an explicit rebuild on the next reconcile: used by
+     * re-authorize, which deletes a grant without changing any resolved config
+     * field, so a fingerprint-only reconcile would keep the live bridge (and
+     * its in-memory tokens) untouched.
+     */
+    forceRemount(suiteId: string, serverKey: string): void;
+    /** The mount key owning one derived serverName; undefined when not mounted here. */
+    serverOwner(serverName: string): {
+        suiteId: string;
+        serverKey: string;
+    } | undefined;
     /** Queue one reconciliation behind any in-flight mount/unmount pass. */
     reconcile(enabledSuites: Suite[]): Promise<McpMountDiagnostic[]>;
     /** Mount/unmount MCP servers to match the enabled suites exactly. */
     private reconcileNow;
+    /**
+     * Schedule a delayed re-attempt for a mount that still is not live.
+     *
+     * Mounts are retried because a remote endpoint or a credential may become
+     * available slightly after the suite is enabled. The schedule is bounded, and
+     * a server that keeps failing simply stops retrying until the next reconcile.
+     */
+    private scheduleRetry;
     /** Dispose every live mount after queued reconciliation passes settle. */
     disposeAll(): Promise<void>;
     /** Mount one precomputed request (source config merged with overrides). */

package/lib/types/runtime/mcp-overrides.d.ts

@@ -1,4 +1,6 @@
-import type { McpServerStreamableHttp, McpServerStdio } from '../model/types.js';
+import type { McpServerSse, McpServerStreamableHttp, McpServerStdio } from '../model/types.js';
+/** HTTP-shaped server sources (url + headers carriers) overrides can edit. */
+type McpServerHttp = McpServerStreamableHttp | McpServerSse;
 /** Per-server override record; absent fields pass through from the source. */
 export type McpServerOverride = {
     /** Disabled servers are not mounted at all (default enabled). */
@@ -11,6 +13,11 @@ export type McpServerOverride = {
     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;
+    };
 };
 /** Overrides for one suite, keyed by mcp.json server key. */
 export type McpSuiteOverrides = Record<string, McpServerOverride>;
@@ -26,12 +33,24 @@ export declare function saveSuiteOverrides(dataRoot: string, suiteId: string, ov
 export declare function sanitizeOverrides(raw: unknown): McpSuiteOverrides;
 /** Validate a client-supplied patch for one server into an override value. */
 export declare function sanitizeOverridePatch(patch: unknown): McpServerOverride | undefined;
+/**
+ * Merge one client patch into the override already on disk.
+ *
+ * The UI redacts secret-shaped values before rendering them, so a patch built
+ * from that redacted view must not be written verbatim — that would silently
+ * drop keys the user did not intend to change. Existing stored values are
+ * therefore preserved and only the fields the patch actually carries replace
+ * them.
+ */
+export declare function mergeOverridePatch(existing: McpServerOverride, patch: McpServerOverride): McpServerOverride;
 /**
  * Apply one server's overrides onto its source shape. Field replacement is
  * whole-map (headers/env/args), never per-key merge, so removing a key in the
  * UI actually removes it at mount time. Values pass through the ordinary
  * mount-time placeholder pipeline afterwards, so override authors may
- * reference secrets as `${NAME}` or `${NAME:-fallback}` (resolved from the
- * process environment in memory) instead of persisting them here.
+ * reference secrets as `${NAME}` or `${NAME:-fallback}` (resolved through the
+ * Host credentials service or launch environment in memory) instead of
+ * persisting them here.
  */
-export declare function applyOverride(server: McpServerStdio | McpServerStreamableHttp, override: McpServerOverride | undefined): McpServerStdio | McpServerStreamableHttp;
+export declare function applyOverride(server: McpServerStdio | McpServerHttp, override: McpServerOverride | undefined): McpServerStdio | McpServerHttp;
+export {};

package/lib/types/runtime/mcp-redaction.d.ts

@@ -0,0 +1,7 @@
+/** Redact secret-shaped MCP configuration before it crosses a status/detail boundary. */
+export declare function redactMcpConfig(value: unknown): unknown;
+export declare function redactMcpOverrides(value: Record<string, Record<string, unknown>>): Record<string, Record<string, unknown>>;
+/** Whether one map key is treated as secret-shaped. */
+export declare function isSensitiveKey(key: string): boolean;
+/** Redact credential-bearing query values from an endpoint URL. */
+export declare function redactUrl(raw: string): string;

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

@@ -1,14 +1,16 @@
+import { type McpSuiteOverrides } from './mcp-overrides.js';
 import type { McpStatusPayload } from '../contracts/mcp-status.js';
 import { inspectToolRegistry, type McpToolSnapshot } from './tool-registry-observer.js';
-import type { McpSuiteOverrides } from './mcp-overrides.js';
 import type { Suite } from '../model/types.js';
 export type { McpStatusEntry, McpStatusPayload, McpStatusKind, McpStatusState } from '../contracts/mcp-status.js';
 export { inspectToolRegistry };
 export type { McpToolSnapshot } from './tool-registry-observer.js';
-interface McpDiagnostic {
+export interface McpDiagnostic {
     suiteId: string;
     serverKey: string;
     reason: string;
+    code?: 'unsupported-transport' | 'missing-credential' | 'credential-error' | 'unmount-failed' | 'mount-failed' | 'foreign-mount';
+    credentialRefs?: string[];
 }
 /** Build status rows from discovered plugin MCP definitions and observed tool names. */
 export declare function buildMcpStatus(suites: Suite[], diagnostics: McpDiagnostic[], observed: readonly McpToolSnapshot[], overrides?: Map<string, McpSuiteOverrides>): McpStatusPayload;

package/lib/types/runtime/reconciler.d.ts

@@ -1,14 +1,15 @@
 /**
  * Runtime reconciliation for enabled suites.
  *
- * One catalog snapshot is fanned out to the existing MCP, command, and hook
- * mount adapters. The adapters remain separate because their host surfaces and
- * failure semantics differ; this module owns ordering, containment, and
+ * One catalog snapshot is fanned out to the existing MCP, command, hook, and
+ * LSP mount adapters. The adapters remain separate because their host surfaces
+ * and failure semantics differ; this module owns ordering, containment, and
  * disposal only.
  */
 import type { Context } from '@deepseek-ai/cordis';
 import { type CommandMountDiagnostic } from './commands-mounts.js';
 import { type HooksMountDiagnostic } from './hooks-mounts.js';
+import { LspMountRegistry, type LspMountDiagnostic } from './lsp-mounts.js';
 import { type McpMountDiagnostic } from './mcp-mounts.js';
 import type { Suite } from '../model/types.js';
 import { type HostTranslate } from './host-locale.js';
@@ -17,8 +18,9 @@ export interface RuntimeDiagnostics {
     mcp: McpMountDiagnostic[];
     commands: CommandMountDiagnostic[];
     hooks: HooksMountDiagnostic[];
+    lsp: LspMountDiagnostic[];
     errors: Array<{
-        surface: 'mcp' | 'commands' | 'hooks';
+        surface: 'mcp' | 'commands' | 'hooks' | 'lsp';
         reason: string;
     }>;
 }
@@ -26,9 +28,25 @@ export declare class RuntimeReconciler {
     private readonly mcp;
     private readonly commands;
     private readonly hooks;
+    private readonly lspRegistry;
     constructor(ctx: Context, dataRoot: string, t?: HostTranslate);
+    /** The LSP mount registry, consumed by the LSP status surface. */
+    get lsp(): LspMountRegistry;
     /** Install the per-suite MCP overrides provider used at mount time. */
     setMcpOverridesProvider(provider: () => Promise<Map<string, import('./mcp-overrides.js').McpSuiteOverrides>>): void;
+    /** Install the live tool-name provider used for foreign-namespace mount guards. */
+    setMcpToolNamesProvider(provider: () => string[]): void;
+    /** Install the backend provider deciding which MCP client mounts each server. */
+    setMcpBackendProvider(provider: () => Promise<import('./mcp-backend.js').McpBackend>): void;
+    /** Whether the current MCP snapshot uses one credential reference. */
+    usesCredential(ref: string): boolean;
+    /** Flag one MCP mount for an explicit rebuild on the next reconcile. */
+    forceMcpRemount(suiteId: string, serverKey: string): void;
+    /** The mount key owning one derived serverName; undefined when not mounted here. */
+    mcpServerOwner(serverName: string): {
+        suiteId: string;
+        serverKey: string;
+    } | undefined;
     /** Reconcile all runtime surfaces against one enabled-suite snapshot. */
     reconcile(enabledSuites: readonly Suite[]): Promise<RuntimeDiagnostics>;
     /** Dispose all live mounts and registrations. */

package/lib/types/runtime/regions.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Download regions for GitHub acquisition, modeled on dshmarket's regions.js:
+ * one setting answers "where are you" instead of a row of mirror toggles.
+ *
+ * The China route proxies github.com clones through a public prefix proxy —
+ * `git clone https://gh-proxy.com/https://github.com/owner/repo` — rather
+ * than rewriting the hostname, which is what lets one prefix cover clone,
+ * fetch, and release downloads without a mapping table per service. Public
+ * proxies come and go, so the route carries an environment escape hatch
+ * (`DSH_MARKET_GITHUB_PROXY`), and the region itself is a setting the user
+ * can flip at any time; sources already cloned keep their proxied origin and
+ * follow it on refresh.
+ *
+ * @module runtime/regions
+ */
+/** The persisted setting: `auto` follows the interface language. */
+export type DownloadRegionSetting = 'auto' | 'global' | 'china';
+/** The route downloads actually take. */
+export type EffectiveRegion = 'global' | 'china';
+/** Narrow an untrusted stored value to a setting; anything else reads as auto. */
+export declare function narrowDownloadRegion(value: unknown): DownloadRegionSetting;
+/**
+ * Resolve the effective region: an explicit choice wins; `auto` follows the
+ * interface language — a Chinese-language user defaults to the China route.
+ * @param setting - the persisted `downloadRegion` value.
+ * @param localePreference - the Host `locale.preference` value, when known.
+ */
+export declare function resolveRegion(setting: DownloadRegionSetting, localePreference: string | undefined): EffectiveRegion;
+/**
+ * Route a clone URL for the region. Only github.com-family https URLs are
+ * proxied — local paths and third-party hosts go through unchanged, as does
+ * everything in the global region.
+ * @param region - the effective region for this download.
+ * @param url - the clone URL.
+ * @param env - environment, carrying the `DSH_MARKET_GITHUB_PROXY` escape hatch.
+ */
+export declare function githubCloneUrl(region: EffectiveRegion, url: string, env?: NodeJS.ProcessEnv): string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-agent-plugins-market",
   "description": "The standard way to install Claude Code / Codex / Cursor / Kimi plugin marketplace suites in DeepSeek Harness (DSH) — zero conversion, zero file copying. Skills, MCP servers, hooks and slash commands are injected into your dsh sessions at runtime.",
-  "version": "0.5.2",
+  "version": "0.6.0",
   "type": "module",
   "main": "lib/index.js",
   "types": "lib/types/index.d.ts",
@@ -76,9 +76,9 @@
   ],
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-hooks-claude-code": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-mcp-client": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-skill": "^0.1.0-rc.8"
+    "@deepseek-ai/dsh-hooks-claude-code": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-mcp-client": "^0.1.2-rc.1",
+    "@deepseek-ai/dsh-skill": "^0.1.2-rc.1"
   },
   "peerDependenciesMeta": {
     "@deepseek-ai/dsh-mcp-client": {
@@ -89,16 +89,20 @@
     }
   },
   "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@modelcontextprotocol/sdk": "^1.30.0",
     "ajv": "^8.17.1",
-    "yaml": "^2.7.0"
+    "fflate": "^0.8.3",
+    "yaml": "^2.7.0",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-hooks-claude-code": "0.1.0-rc.8",
-    "@deepseek-ai/dsh-llm": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-mcp-client": "^0.1.0-rc.8",
-    "@deepseek-ai/dsh-skill": "^0.1.0-rc.8",
+    "@deepseek-ai/dsh-client-ui-primitives": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-hooks-claude-code": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-llm": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-mcp-client": "0.1.2-rc.1",
+    "@deepseek-ai/dsh-skill": "0.1.2-rc.1",
     "@eslint/js": "^9.39.5",
     "@tsdown/css": "^0.22.14",
     "@types/node": "^22.15.0",
@@ -106,7 +110,7 @@
     "@types/react-dom": "^19.2.4",
     "@vitest/coverage-v8": "^4.1.11",
     "dependency-cruiser": "^18.2.0",
-    "eslint": "^9.39.5",
+    "eslint": "^10.9.1",
     "jsdom": "^30.0.1",
     "prettier": "^3.9.6",
     "react": "^18.3.1",

package/schemas/1.0.0/mcp.schema.json

@@ -85,6 +85,9 @@
         },
         "headers": {
           "$ref": "#/$defs/headers"
+        },
+        "auth": {
+          "$ref": "#/$defs/oauth"
         }
       },
       "required": ["type", "url"],
@@ -104,11 +107,30 @@
         },
         "headers": {
           "$ref": "#/$defs/headers"
+        },
+        "auth": {
+          "$ref": "#/$defs/oauth"
         }
       },
       "required": ["type", "url"],
       "additionalProperties": false
     },
+    "oauth": {
+      "title": "OAuth 2.1 authorization",
+      "type": "object",
+      "description": "OAuth 2.1 authorization for servers that answer 401 with a challenge. The flow activates by default on the server's first 401; set enabled to false to opt out.",
+      "properties": {
+        "enabled": {
+          "type": "boolean",
+          "description": "Enable the OAuth flow (default true; set false to opt out explicitly)."
+        },
+        "scope": {
+          "type": "string",
+          "description": "Space-separated scope string requested during authorization."
+        }
+      },
+      "additionalProperties": false
+    },
     "headers": {
       "title": "HTTP headers",
       "type": "object",