@unbrained/pm-cli 2026.8.24 → 2026.8.26

package/dist/mcp/legacy-adapter.d.ts

@@ -0,0 +1,50 @@
+/**
+ * @module mcp/legacy-adapter
+ *
+ * Isolates the bounded MCP 2025-06-18 stdio compatibility surface from the
+ * canonical stateless dispatcher. No modern transport imports policy from it.
+ */
+import { type AgentClientInfo } from "../sdk/runtime-primitives.js";
+import { type PmMcpImplementation, type PmMcpServerCapabilities } from "../sdk/mcp/protocol.js";
+/** Minimal request shape consumed by the compatibility adapter. */
+export interface LegacyMcpRequest {
+    /** Legacy method name. */
+    method?: string;
+    /** Legacy method parameters. */
+    params?: Record<string, unknown>;
+}
+/** Host callbacks keep this adapter separate from canonical SDK policy. */
+export interface LegacyMcpAdapterOptions {
+    /** Immutable server identity. */
+    serverInfo: PmMcpImplementation;
+    /** Compatibility-era capabilities. */
+    capabilities: PmMcpServerCapabilities;
+    /** Model-facing usage instructions. */
+    instructions: string;
+    /** Parse bounded historical client identity. */
+    parseClientInfo: (value: unknown) => AgentClientInfo | undefined;
+    /** Resolve legacy tool definitions. */
+    listTools: (params: Record<string, unknown> | undefined) => Promise<Record<string, unknown>>;
+    /** Execute one legacy tool call. */
+    callTool: (params: Record<string, unknown> | undefined, clientInfo: AgentClientInfo | undefined) => Promise<Record<string, unknown>>;
+    /** List legacy resources. */
+    listResources: () => Record<string, unknown>;
+    /** Read one legacy resource. */
+    readResource: (params: Record<string, unknown> | undefined) => Promise<Record<string, unknown>>;
+    /** List legacy prompts. */
+    listPrompts: () => Record<string, unknown>;
+    /** Render one legacy prompt. */
+    getPrompt: (params: Record<string, unknown> | undefined) => Record<string, unknown>;
+}
+/** Explicit compatibility adapter with no cross-process or modern-session role. */
+export declare class LegacyMcpAdapter {
+    #private;
+    /** Create one process-local legacy stdio adapter. */
+    constructor(options: LegacyMcpAdapterOptions);
+    /** Read the bounded identity most recently supplied to legacy initialize. */
+    getClientInfo(): AgentClientInfo | undefined;
+    /** Validate and answer the historical initialize handshake. */
+    initialize(params: Record<string, unknown> | undefined): Record<string, unknown>;
+    /** Dispatch one unversioned request through the finite legacy method set. */
+    dispatch(request: LegacyMcpRequest): Promise<Record<string, unknown>>;
+}

package/dist/mcp/legacy-adapter.js

@@ -0,0 +1,64 @@
+/**
+ * @module mcp/legacy-adapter
+ *
+ * Isolates the bounded MCP 2025-06-18 stdio compatibility surface from the
+ * canonical stateless dispatcher. No modern transport imports policy from it.
+ */
+
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6a1d9bca-7dac-5537-9930-a12d8049c8b8")}catch(e){}}();
+import { PmCliError } from "../sdk/runtime-primitives.js";
+import { PM_MCP_ERROR_CODES, PM_MCP_LEGACY_PROTOCOL_VERSIONS, PM_MCP_PROTOCOL_VERSION, PmMcpProtocolError, } from "../sdk/mcp/protocol.js";
+/** Explicit compatibility adapter with no cross-process or modern-session role. */
+export class LegacyMcpAdapter {
+    #options;
+    #clientInfo;
+    /** Create one process-local legacy stdio adapter. */
+    constructor(options) {
+        this.#options = options;
+    }
+    /** Read the bounded identity most recently supplied to legacy initialize. */
+    getClientInfo() {
+        return this.#clientInfo ? structuredClone(this.#clientInfo) : undefined;
+    }
+    /** Validate and answer the historical initialize handshake. */
+    initialize(params) {
+        const requestedVersion = params?.protocolVersion;
+        if (typeof requestedVersion === "string" &&
+            !PM_MCP_LEGACY_PROTOCOL_VERSIONS.includes(requestedVersion)) {
+            throw new PmMcpProtocolError("Unsupported legacy MCP protocol version", PM_MCP_ERROR_CODES.unsupportedProtocolVersion, {
+                supported: [...PM_MCP_LEGACY_PROTOCOL_VERSIONS],
+                requested: requestedVersion,
+                modern: PM_MCP_PROTOCOL_VERSION,
+            });
+        }
+        this.#clientInfo = this.#options.parseClientInfo(params?.clientInfo);
+        return {
+            protocolVersion: PM_MCP_LEGACY_PROTOCOL_VERSIONS[0],
+            capabilities: structuredClone(this.#options.capabilities),
+            serverInfo: { ...this.#options.serverInfo },
+            instructions: this.#options.instructions,
+        };
+    }
+    /** Dispatch one unversioned request through the finite legacy method set. */
+    async dispatch(request) {
+        if (request.method === "ping")
+            return {};
+        if (request.method === "tools/list")
+            return this.#options.listTools(request.params);
+        if (request.method === "tools/call") {
+            return this.#options.callTool(request.params, this.#clientInfo);
+        }
+        if (request.method === "resources/list")
+            return this.#options.listResources();
+        if (request.method === "resources/read") {
+            return this.#options.readResource(request.params);
+        }
+        if (request.method === "prompts/list")
+            return this.#options.listPrompts();
+        if (request.method === "prompts/get")
+            return this.#options.getPrompt(request.params);
+        throw new PmCliError(`Unsupported MCP method: ${request.method ?? "(missing)"}`, 64);
+    }
+}
+//# sourceMappingURL=legacy-adapter.js.map
+//# debugId=6a1d9bca-7dac-5537-9930-a12d8049c8b8

package/dist/mcp/server.d.ts

@@ -1,12 +1,22 @@
 #!/usr/bin/env node
+import { type AgentClientInfo } from "../sdk/runtime-primitives.js";
 import { readRequiredString, type PmActionInput } from "../sdk/runtime.js";
-interface JsonRpcRequest {
+import { PmMcpProtocolError, resolveMcpRequestContext, type PmMcpRequestContext } from "../sdk/mcp/protocol.js";
+import { PmMcpInputRequiredError } from "../sdk/mcp/interactions.js";
+import { type PmMcpSubscriptionId, type PmMcpSubscriptionSink } from "../sdk/mcp/subscriptions.js";
+/** JSON-RPC request shape accepted by pm MCP transport adapters. */
+export interface JsonRpcRequest {
+    /** JSON-RPC revision marker when supplied by the transport. */
     jsonrpc?: string;
+    /** Correlation identifier omitted only for notifications. */
     id?: string | number | null;
+    /** Protocol operation selected by the caller. */
     method?: string;
+    /** Operation inputs including request-local MCP metadata. */
     params?: Record<string, unknown>;
 }
 declare function runMcpAction(args: PmActionInput): Promise<unknown>;
+type PmMcpTransportSubscriptionKey = PmMcpSubscriptionId | symbol;
 declare function nearestDeclaredKey(unexpected: string, declared: string[]): string | undefined;
 declare function detectUnexpectedTopLevelKeys(toolName: string, args: Record<string, unknown>, toolDeclaredKeys?: Map<string, string[]>): string[];
 declare function collectMutationGuardWarnings(toolName: string, action: string | undefined, args: Record<string, unknown>): Promise<string[]>;
@@ -15,6 +25,26 @@ declare function resultContent(result: unknown, warnings?: string[], tokenAccoun
 declare function errorContent(error: unknown): Record<string, unknown>;
 /** Retain at most 32 own, valid provenance values without cloning unbounded input. */
 declare function boundMcpClientProvenance(value: unknown): Record<string, string>;
+declare function emitMcpChangeNotifications(action: string | undefined): Promise<void>;
+/** Open one modern subscription through a concrete transport-owned sink. */
+export declare function openMcpSubscription(input: {
+    request: JsonRpcRequest;
+    key?: PmMcpTransportSubscriptionKey;
+    sink: PmMcpSubscriptionSink;
+}): Promise<void>;
+/** Gracefully close one active subscription by its request identifier. */
+export declare function closeMcpSubscription(id: PmMcpSubscriptionId, key?: PmMcpTransportSubscriptionKey): Record<string, unknown> | undefined;
+declare function closeStdioMcpSubscriptions(): Array<{
+    id: PmMcpSubscriptionId;
+    result: Record<string, unknown>;
+}>;
+/** Resolve the current workspace-enriched tool schema for HTTP header checks. */
+export declare function resolveMcpToolSchemaForRequest(request: JsonRpcRequest): Promise<unknown>;
+/** Preserve MCP tool-result error semantics for non-protocol adapter failures. */
+export declare function buildMcpToolCallErrorResult(request: JsonRpcRequest, error: unknown): Record<string, unknown> | undefined;
+declare function mcpTaskPrincipal(requestContext: PmMcpRequestContext): string;
+declare function shouldCreateMcpTask(params: Record<string, unknown> | undefined, requestContext: PmMcpRequestContext): boolean;
+declare function settleMcpTaskExecution(taskId: string, execution: Promise<void>): Promise<void>;
 /** Dispatch one MCP request under supported process-level reproducibility settings. */
 export declare function handleRequest(request: JsonRpcRequest): Promise<Record<string, unknown> | undefined>;
 declare function writeError(id: JsonRpcRequest["id"], error: unknown): void;
@@ -27,24 +57,27 @@ export declare function isInvokedAsMcpMainModule(argvPath: string | undefined, m
 /** Public contract for test only, shared by SDK and presentation-layer consumers. */
 export declare const _testOnly: {
     boundMcpClientProvenance: typeof boundMcpClientProvenance;
+    createMcpInputRequiredError: (input: ConstructorParameters<typeof PmMcpInputRequiredError>[0]) => PmMcpInputRequiredError;
+    createMcpProtocolError: (message: string, code: number, data?: Record<string, unknown> | undefined) => PmMcpProtocolError;
     readonly closeManyOptionsFromFlat: typeof import("../sdk/runtime-input.js").closeManyOptionsFromFlat;
     detectUnexpectedOptionKeys: typeof detectUnexpectedOptionKeys;
     detectUnexpectedTopLevelKeys: typeof detectUnexpectedTopLevelKeys;
     collectMutationGuardWarnings: typeof collectMutationGuardWarnings;
+    closeStdioMcpSubscriptions: typeof closeStdioMcpSubscriptions;
     errorContent: typeof errorContent;
-    getMcpClientInfo: () => {
-        name: string;
-        version?: string;
-        model?: string;
-        session?: string;
-        provenance?: Readonly<Record<string, string | undefined>>;
-        episode?: import("../sdk/runtime-primitives.js").AgentEpisodeIdentity;
-    } | undefined;
+    emitMcpChangeNotifications: typeof emitMcpChangeNotifications;
+    expireMcpSubscriptionRecord: (id: PmMcpSubscriptionId, key?: PmMcpTransportSubscriptionKey) => Record<string, unknown> | undefined;
+    getMcpClientInfo: () => AgentClientInfo | undefined;
     readonly extensionOptionsFromArgs: typeof import("../sdk/runtime-input.js").extensionOptionsFromArgs;
     readonly globalOptions: typeof import("../sdk/runtime-input.js").actionGlobalOptions;
     readonly mutationListOptions: typeof import("../sdk/runtime-input.js").mutationListOptions;
     nearestDeclaredKey: typeof nearestDeclaredKey;
+    mcpTaskPrincipal: typeof mcpTaskPrincipal;
     resultContent: typeof resultContent;
+    resolveMcpRequestContext: typeof resolveMcpRequestContext;
+    shouldCreateMcpTask: typeof shouldCreateMcpTask;
+    settleMcpTaskExecution: typeof settleMcpTaskExecution;
+    subscriptionCount: () => number;
     readonly normalizeActionName: typeof import("../sdk/runtime-input.js").normalizeActionName;
     readonly normalizeCommandPath: typeof import("../sdk/runtime-input.js").normalizeCommandPath;
     readonly normalizeMcpOptionsArrays: typeof import("../sdk/runtime-input.js").normalizeMcpOptionsArrays;