mrplex 0.0.1

package/dist/mcp/server.d.ts

@@ -0,0 +1,60 @@
+/**
+ * MCP surface — design §6.2, noauth plan §4.
+ *
+ * Protocol-true MCP via `@modelcontextprotocol/sdk`. Streamable HTTP runs
+ * **stateless**: no server-side session store. There is no per-request auth —
+ * mrplex trusts its caller (design §8). Each request's CallContext is read from
+ * the `X-Mrplex-*` headers, which a fronting shell injects (a proxy can set
+ * headers but not rewrite tool arguments — so headers are the injection path).
+ *
+ * STDIO binds one launch-time CallContext for the whole session (no per-request
+ * header channel); `--author` / `--scope` launch flags pin it (noauth plan §4).
+ *
+ * We use the lower-level `Server` class (not `McpServer`) so tool schemas
+ * can be plain JSON Schema — no Zod runtime dependency (tools.ts).
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { Server as McpLowLevelServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import type { CallContext } from "../kernel/context.js";
+import type { Kernel } from "../kernel/kernel.js";
+import { type ContextForRequest, type KernelForRequest } from "../server/headers.js";
+import type { Storage } from "../storage/types.js";
+export type McpConfig = {
+    kernel: Kernel;
+    storage: Storage;
+    /**
+     * How each request becomes a CallContext. Defaults to reading the
+     * `X-Mrplex-*` headers; an authenticating shell substitutes an
+     * entitlement-derived context here.
+     */
+    contextForRequest?: ContextForRequest;
+    /**
+     * How each request obtains its Kernel. Defaults to the shared `kernel`; an
+     * authenticating shell returns a per-principal guarded kernel (and may throw
+     * to reject the request before the SDK parses the frame).
+     */
+    kernelForRequest?: KernelForRequest;
+};
+export type McpMount = {
+    handle: (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    close: () => Promise<void>;
+};
+/**
+ * Mount an MCP surface as a Streamable-HTTP request handler.
+ *
+ * We create a fresh Server + StreamableHTTPServerTransport pair PER REQUEST.
+ * That's the SDK's supported "stateless" mode: session-less, so state
+ * cannot accumulate between calls, and multi-instance deployments (§7.1)
+ * work without a shared session store.
+ */
+export declare function mountMcpStreamableHttp(config: McpConfig): Promise<McpMount>;
+export type StdioMount = {
+    server: McpLowLevelServer;
+    transport: StdioServerTransport;
+    close: () => Promise<void>;
+};
+export declare function startMcpStdio(config: {
+    kernel: Kernel;
+    context?: CallContext;
+}): Promise<StdioMount>;

package/dist/mcp/server.js

@@ -0,0 +1,170 @@
+/**
+ * MCP surface — design §6.2, noauth plan §4.
+ *
+ * Protocol-true MCP via `@modelcontextprotocol/sdk`. Streamable HTTP runs
+ * **stateless**: no server-side session store. There is no per-request auth —
+ * mrplex trusts its caller (design §8). Each request's CallContext is read from
+ * the `X-Mrplex-*` headers, which a fronting shell injects (a proxy can set
+ * headers but not rewrite tool arguments — so headers are the injection path).
+ *
+ * STDIO binds one launch-time CallContext for the whole session (no per-request
+ * header channel); `--author` / `--scope` launch flags pin it (noauth plan §4).
+ *
+ * We use the lower-level `Server` class (not `McpServer`) so tool schemas
+ * can be plain JSON Schema — no Zod runtime dependency (tools.ts).
+ */
+import { Server as McpLowLevelServer } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { KernelError } from "../kernel/errors.js";
+import { VERSION } from "../version.js";
+import { contextFromHeaders, } from "../server/headers.js";
+import { httpErrorForThrowable } from "../server/http-error.js";
+import { TOOL_REGISTRY, toolByName } from "./tools.js";
+/**
+ * Mount an MCP surface as a Streamable-HTTP request handler.
+ *
+ * We create a fresh Server + StreamableHTTPServerTransport pair PER REQUEST.
+ * That's the SDK's supported "stateless" mode: session-less, so state
+ * cannot accumulate between calls, and multi-instance deployments (§7.1)
+ * work without a shared session store.
+ */
+export async function mountMcpStreamableHttp(config) {
+    const { kernel } = config;
+    const contextForRequest = config.contextForRequest ?? contextFromHeaders;
+    const kernelForRequest = config.kernelForRequest ?? (() => kernel);
+    async function handle(req, res) {
+        // Resolve the per-request kernel and CallContext before the SDK parses the
+        // frame. Either step may throw: the shell's `kernelForRequest` rejects an
+        // unauthenticated caller (HttpResponseError → its own status), and a
+        // malformed X-Mrplex-Scope is a KernelError "filter_invalid" → 400. A bad
+        // credential or claim is a loud error, never a silent full-access fallback.
+        let reqKernel;
+        let ctx;
+        try {
+            reqKernel = await kernelForRequest(req);
+            ctx = await contextForRequest(req);
+        }
+        catch (err) {
+            const { status, body } = httpErrorForThrowable(err);
+            // A generic 500 body from a non-kernel throwable is opaque here; keep the
+            // MCP-friendly filter_invalid shape for the malformed-input case.
+            const payload = err instanceof KernelError ? { code: err.code, data: err.data } : body;
+            res.statusCode = err instanceof KernelError ? 400 : status;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(payload));
+            return;
+        }
+        const server = buildMcpServer(reqKernel, () => ctx);
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined, // stateless per m3-plan decision 3
+            enableJsonResponse: true,
+        });
+        res.on("close", () => {
+            // Best-effort — SDK also cleans up on its own.
+            transport.close().catch(() => { });
+            server.close().catch(() => { });
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res);
+    }
+    async function close() {
+        // Per-request instances handle their own close; nothing global to tear down.
+    }
+    return { handle, close };
+}
+/**
+ * Server-level instructions surfaced to clients at `initialize`. Cross-tool
+ * conventions live here; per-tool details belong in tool descriptions
+ * (tools.ts) and the `query_syntax` reference. Clients vary in whether they
+ * show these to the model — don't put anything here that isn't ALSO
+ * discoverable through a tool description or an error message.
+ */
+const SERVER_INSTRUCTIONS = `mrplex is a queryable, versioned store for Markdown documents with YAML frontmatter, organized into repos.
+
+Conventions:
+- Reads (docs_get / docs_get_version) return frontmatter_raw with server-injected \`$version: <version_id>\` then \`$content_hash: <sha256>\` lines (unless raw: true). Pass that frontmatter_raw back to docs_put unchanged and prev_version_id may be omitted — the embedded $version supplies it. \`$\`-prefixed frontmatter keys are server-owned and are stripped from writes.
+- Writes use optimistic concurrency: docs_put / docs_delete need the previous version id; a \`stale_prev\` error means someone else wrote first — re-read (docs_get) and retry against the new version.
+- When writing frontmatter, provide exactly one of \`frontmatter\` (JSON object) or \`frontmatter_raw\` (verbatim YAML).
+- \`query\` searches current documents and returns lean projected hits, not full documents. Default \`select\` is ["$path"] — each hit is only \`{ "$path": "…" }\` (no body, no frontmatter, no version id). Pass \`select\` to project more (\`$body\`, \`$repo\`, \`$version_id\`, \`$content_hash\`, \`$semantic_score\`, frontmatter keys, …). \`semantic\` activates embedding-based retrieval; add \`$semantic_score\` to \`select\` for cosine similarity (1 = identical). Call \`docs_get\` (one path) or \`docs_get_many\` (batch) to recover whole documents. The filter is CEL with \`$\`-prefixed intrinsics ($path, $updated_at, $body, $content_hash) and link-graph predicates ($in, $has, $backlinks(), $links()). Call the \`query_syntax\` tool for the full language reference before writing a non-trivial filter.
+- Tool failures return an in-band error (isError: true) with a JSON object { code, data } in the text content: e.g. filter_invalid (bad query — data.reason explains, data.hint says what to consult), stale_prev (concurrency conflict), doc_not_found, semantic_unavailable (no embedding hook configured). Codes are stable; reasons are prose. Error results carry no structuredContent (tool outputSchema describes success shapes only).`;
+/**
+ * Build a low-level MCP Server with tools/list + tools/call handlers wired
+ * up. The `getContext` closure supplies the session's CallContext at call time.
+ */
+function buildMcpServer(kernel, getContext) {
+    const server = new McpLowLevelServer({ name: "mrplex", version: VERSION }, { capabilities: { tools: {} }, instructions: SERVER_INSTRUCTIONS });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: TOOL_REGISTRY.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema,
+            ...(t.outputSchema !== undefined && { outputSchema: t.outputSchema }),
+        })),
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => {
+        const name = req.params.name;
+        const args = (req.params.arguments ?? {});
+        const tool = toolByName(name);
+        if (!tool) {
+            // Use filter_invalid (a real KernelErrorCode) rather than a fabricated
+            // "internal_error" — clients that rehydrate KernelError from the
+            // in-band payload should always see codes from the stable catalog.
+            return toolError({
+                code: "filter_invalid",
+                data: { reason: `unknown tool: ${name}` },
+            });
+        }
+        try {
+            const result = await tool.handler(kernel, getContext(), args);
+            return {
+                content: [{ type: "text", text: result.text }],
+                structuredContent: result.structured,
+            };
+        }
+        catch (err) {
+            if (err instanceof KernelError) {
+                return toolError({ code: err.code, data: err.data });
+            }
+            // Non-kernel throwable — surface as filter_invalid too, since a real
+            // internal server error would 500 at the transport, not in-band.
+            return toolError({
+                code: "filter_invalid",
+                data: { reason: err.message ?? String(err) },
+            });
+        }
+    });
+    return server;
+}
+/**
+ * Package a KernelError as an in-band tool error per §6.2 / m3-plan
+ * decision. `isError: true` with the JSON `{ code, data }` payload in the
+ * text content — and deliberately NO structuredContent: tools declare
+ * `outputSchema` for their success shapes, and spec-conformant clients
+ * (the SDK included) validate any structuredContent present against it
+ * even on error results. Error consumers parse the text channel
+ * (client/remote-mcp.ts does exactly that).
+ */
+function toolError(payload) {
+    const text = JSON.stringify(payload);
+    return {
+        isError: true,
+        content: [{ type: "text", text }],
+    };
+}
+export async function startMcpStdio(config) {
+    const ctx = config.context ?? {};
+    const server = buildMcpServer(config.kernel, () => ctx);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    return {
+        server,
+        transport,
+        close: async () => {
+            await transport.close().catch(() => { });
+            await server.close().catch(() => { });
+        },
+    };
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"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"}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,93 @@
+/**
+ * MCP tool registry — design §6.2.
+ *
+ * Tools mirror the kernel one-to-one. Each entry names the tool, describes it,
+ * carries a JSON Schema for the input, and delegates to a kernel call with the
+ * session's CallContext. No-auth (noauth plan): the user and token tools are
+ * gone; write tools gain an optional `author` and the query tool an optional
+ * `scope` — both overridden by the X-Mrplex-* request headers when present.
+ *
+ * Results shape:
+ *   • On success: { structured, text } — structured is the wire type,
+ *     text is a compact human rendering (render.ts).
+ *   • On kernel error: throws; the SDK wiring in server.ts converts to an
+ *     in-band tool error ({ code, data }) per §6.2.
+ */
+import { type CallContext } from "../kernel/context.js";
+import type { Kernel } from "../kernel/kernel.js";
+/**
+ * A tool's structured payload is always a JSON object — MCP's
+ * `structuredContent` field is a record per the spec (and the SDK enforces
+ * it). List-shaped results are wrapped in `{ items: [...] }`; single-object
+ * results pass through.
+ */
+export type ToolResult = {
+    structured: Record<string, unknown>;
+    text: string;
+};
+/**
+ * The session context carries the header-injected author/scope (see
+ * mcp/server.ts). Handlers merge in tool-arg author/scope only where the
+ * header left a gap — headers beat tool args (noauth plan decision 8).
+ */
+export type ToolHandler = (kernel: Kernel, ctx: CallContext, args: Record<string, unknown>) => ToolResult | Promise<ToolResult>;
+export type ToolEntry = {
+    name: string;
+    description: string;
+    inputSchema: JsonSchema;
+    /**
+     * Success-result shape of `structuredContent` (MCP `outputSchema`).
+     * In-band tool errors carry no structuredContent (server.ts toolError),
+     * so this describes success results only — per spec, error results are
+     * exempt from output-schema conformance.
+     */
+    outputSchema?: JsonSchema;
+    handler: ToolHandler;
+};
+type JsonSchema = {
+    type: "object";
+    description?: string;
+    properties: Record<string, JsonSchemaProp>;
+    required?: string[];
+    additionalProperties?: false;
+};
+type JsonSchemaProp = {
+    type: "string";
+    description?: string;
+    enum?: string[];
+} | {
+    type: "number";
+    description?: string;
+} | {
+    type: "integer";
+    description?: string;
+    minimum?: number;
+} | {
+    type: "boolean";
+    description?: string;
+} | {
+    type: "null";
+    description?: string;
+} | {
+    type: "array";
+    description?: string;
+    items: JsonSchemaProp;
+} | {
+    type: "object";
+    description?: string;
+    properties?: Record<string, JsonSchemaProp>;
+    required?: string[];
+    additionalProperties?: boolean | JsonSchemaProp;
+} | {
+    oneOf: JsonSchemaProp[];
+    description?: string;
+} | {
+    anyOf: JsonSchemaProp[];
+    description?: string;
+} | {
+    description?: string;
+};
+export declare const TOOL_REGISTRY: ToolEntry[];
+/** Convenient lookup by name. */
+export declare function toolByName(name: string): ToolEntry | undefined;
+export {};