@documentation-robotics/cli 0.1.12 → 0.2.0

package/dist/integrations/claude_code/docs/MCP_SERVER.md

@@ -0,0 +1,55 @@
+---
+title: DR MCP Server
+description: Configure an MCP client to connect to the Documentation Robotics MCP server
+---
+
+# Documentation Robotics MCP Server
+
+`dr mcp` runs the CLI as a [Model Context Protocol](https://modelcontextprotocol.io/) server over stdio, exposing model tools (list/show/search/add/update/delete/validate/export/trace elements, changesets, chat, annotations) to any MCP-aware AI client — Claude Code included.
+
+Annotation tools (`annotation_list`, `annotation_get`, `annotation_create`, `annotation_update`, `annotation_delete`, `annotation_reply`) mirror the capabilities of the REST server's `/api/annotations/*` endpoints. Unlike the REST server's in-memory, per-process annotation store, the MCP tools persist annotations to `documentation-robotics/annotations/` on disk, so they survive across MCP sessions.
+
+## Configuring Claude Code
+
+Add an entry to your project's `.mcp.json` (or the equivalent global MCP config):
+
+```json
+{
+  "mcpServers": {
+    "documentation-robotics": {
+      "command": "dr",
+      "args": ["mcp"],
+      "env": {
+        "DR_MCP_API_KEY": "<key printed by dr mcp>"
+      }
+    }
+  }
+}
+```
+
+Other MCP clients follow the same shape: a `command`/`args` pair that launches `dr mcp`, plus `DR_MCP_API_KEY` in `env`.
+
+## Getting the API key
+
+Run `dr mcp` once from a terminal — it generates an API key on first launch (prompting for a storage path interactively, defaulting to `~/.dr-mcp-key` otherwise) and prints it to stderr on every launch:
+
+```
+$ dr mcp
+Generated new MCP API key, stored at /home/you/.dr-mcp-key
+MCP API key: dr-mcp-<random>
+Documentation Robotics MCP server ready (stdio)
+```
+
+Copy that key into the client config's `DR_MCP_API_KEY`. The server rejects the connection if the key is missing or doesn't match.
+
+## Rotating the key
+
+If a key leaks or you just want a fresh one, run:
+
+```bash
+dr mcp --regenerate-key
+```
+
+This overwrites the key at its existing storage path, updates `~/.dr-config.yaml`, and prints the new key — no manual deletion of files required. Update `DR_MCP_API_KEY` in every client config after rotating.
+
+See [cli/README.md](../../../cli/README.md#mcp-server) for the full command reference.

package/dist/integrations/claude_code/docs/README.md

@@ -69,6 +69,10 @@ The comprehensive manual walkthrough covering every step from fresh project thro
 
 - **[dr-init.md](../commands/dr-init.md)** — Initialize new models
 
+### MCP Integration
+
+- **[MCP_SERVER.md](MCP_SERVER.md)** — Configure an MCP client (Claude Code or otherwise) to connect to `dr mcp`, including the API key setup and rotation
+
 ### Skills & Agents
 
 - **[dr-codebase-memory/SKILL.md](../skills/dr_codebase_memory/SKILL.md)** — Codebase memory and context management

package/dist/mcp/api-key-manager.js

@@ -0,0 +1,98 @@
+import { randomBytes, timingSafeEqual } from "node:crypto";
+import { existsSync } from "node:fs";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { DRConfigParseError, loadDRConfig, saveDRConfig } from "../config.js";
+const KEY_FILE_MODE = 384;
+function getDefaultApiKeyPath() {
+  return join(homedir(), ".dr-mcp-key");
+}
+class ApiKeyManager {
+  defaultKeyPath;
+  /**
+   * @param defaultKeyPath Path offered as the default storage location when no
+   *   key is yet configured. Defaults to `getDefaultApiKeyPath()`; overridable
+   *   for tests so they never touch the real home directory.
+   */
+  constructor(defaultKeyPath = getDefaultApiKeyPath()) {
+    this.defaultKeyPath = defaultKeyPath;
+  }
+  /** Generate a new random API key. */
+  generate() {
+    return `dr-mcp-${randomBytes(32).toString("base64url")}`;
+  }
+  /** Read a previously stored key from disk. */
+  async load(path) {
+    const key = (await readFile(path, "utf-8")).trim();
+    if (!key)
+      throw new Error(`API key file at ${path} is empty or corrupt. Delete it and re-run to generate a new key, or restore a valid key file.`);
+    return key;
+  }
+  /** Write a key to disk with owner-only permissions. */
+  async store(path, key) {
+    await mkdir(dirname(path), { recursive: !0 }), await writeFile(path, `${key}
+`, { mode: KEY_FILE_MODE }), await chmod(path, KEY_FILE_MODE);
+  }
+  /** Constant-time comparison of a client-provided key against the expected key. */
+  validate(provided, expected) {
+    if (!provided)
+      return !1;
+    const providedBuf = Buffer.from(provided), expectedBuf = Buffer.from(expected);
+    return providedBuf.length !== expectedBuf.length ? !1 : timingSafeEqual(providedBuf, expectedBuf);
+  }
+  /**
+   * Load the DR config, refusing to proceed if the file exists but is
+   * corrupted. Without this, a corrupted config looks identical to "no key
+   * configured yet", which would cause `ensureKey`/`rotate` to silently
+   * generate a new key and overwrite `mcp.api_key_path` — orphaning any
+   * valid key already on disk and breaking every MCP client configured with
+   * the old one.
+   */
+  async loadConfigOrThrow() {
+    try {
+      return await loadDRConfig({ strict: !0 });
+    } catch (error) {
+      throw error instanceof DRConfigParseError ? new Error(`Cannot determine the configured MCP API key path: ${error.configPath} is corrupted. Fix or remove this file before continuing \u2014 proceeding could orphan an existing key and break already-configured MCP clients.`, { cause: error }) : error;
+    }
+  }
+  /**
+   * Resolve the API key to use for this session: load it from the previously
+   * configured path, or generate+store a new one on first use.
+   *
+   * @param promptForPath Called only when no key is yet configured, to ask the
+   *   user where to store it. When omitted (e.g. non-interactive launches),
+   *   `defaultKeyPath` is used without prompting.
+   */
+  async ensureKey(promptForPath) {
+    const config = await this.loadConfigOrThrow(), existingPath = config.mcp?.api_key_path;
+    if (existingPath && existsSync(existingPath))
+      return { key: await this.load(existingPath), path: existingPath, isNew: !1 };
+    const chosenPath = promptForPath ? await promptForPath(this.defaultKeyPath) : this.defaultKeyPath, key = this.generate();
+    return await this.store(chosenPath, key), await saveDRConfig({
+      ...config,
+      mcp: { ...config.mcp, api_key_path: chosenPath }
+    }), { key, path: chosenPath, isNew: !0 };
+  }
+  /**
+   * Force-generate a new API key, overwriting whatever is at the configured
+   * (or default) storage path, regardless of whether a key already exists
+   * there. Unlike `ensureKey`, this always writes a fresh key.
+   *
+   * @param promptForPath Called only when no storage path is yet configured,
+   *   to ask the user where to store it. When omitted, `defaultKeyPath` is
+   *   used without prompting.
+   */
+  async rotate(promptForPath) {
+    const config = await this.loadConfigOrThrow(), path = config.mcp?.api_key_path ?? (promptForPath ? await promptForPath(this.defaultKeyPath) : this.defaultKeyPath), key = this.generate();
+    return await this.store(path, key), await saveDRConfig({
+      ...config,
+      mcp: { ...config.mcp, api_key_path: path }
+    }), { key, path };
+  }
+}
+export {
+  ApiKeyManager,
+  getDefaultApiKeyPath
+};
+//# sourceMappingURL=api-key-manager.js.map

package/dist/mcp/api-key-manager.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/api-key-manager.ts"],
+  "sourcesContent": ["/**\n * MCP API key lifecycle management\n *\n * The API key is a per-installation shared secret that authenticates MCP client\n * connections to `dr mcp` (see cli/src/commands/mcp.ts). It is generated once,\n * stored on disk at a user-chosen location, and its path is recorded under\n * `mcp.api_key_path` in ~/.dr-config.yaml so subsequent launches can find it\n * without re-prompting.\n */\n\nimport { randomBytes, timingSafeEqual } from \"node:crypto\";\nimport { existsSync } from \"node:fs\";\nimport { chmod, mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\nimport { DRConfig, DRConfigParseError, loadDRConfig, saveDRConfig } from \"../config.js\";\n\n/** Owner read/write only \u2014 the key file must not be group/world readable. */\nconst KEY_FILE_MODE = 0o600;\n\n/**\n * Default location for a newly generated API key. Resolved lazily (rather than\n * cached at module load) so it always reflects the current home directory \u2014\n * relevant for tests that override HOME.\n */\nexport function getDefaultApiKeyPath(): string {\n  return join(homedir(), \".dr-mcp-key\");\n}\n\nexport interface EnsureKeyResult {\n  key: string;\n  path: string;\n  /** True when a new key was generated on this call (vs. loaded from an existing path). */\n  isNew: boolean;\n}\n\nexport interface RotateKeyResult {\n  key: string;\n  path: string;\n}\n\n/** Prompts the user for a storage path, given the default path to offer. */\nexport type ApiKeyStoragePrompt = (defaultPath: string) => Promise<string>;\n\nexport class ApiKeyManager {\n  /**\n   * @param defaultKeyPath Path offered as the default storage location when no\n   *   key is yet configured. Defaults to `getDefaultApiKeyPath()`; overridable\n   *   for tests so they never touch the real home directory.\n   */\n  constructor(private readonly defaultKeyPath: string = getDefaultApiKeyPath()) {}\n\n  /** Generate a new random API key. */\n  generate(): string {\n    return `dr-mcp-${randomBytes(32).toString(\"base64url\")}`;\n  }\n\n  /** Read a previously stored key from disk. */\n  async load(path: string): Promise<string> {\n    const content = await readFile(path, \"utf-8\");\n    const key = content.trim();\n\n    if (!key) {\n      throw new Error(\n        `API key file at ${path} is empty or corrupt. ` +\n          \"Delete it and re-run to generate a new key, or restore a valid key file.\"\n      );\n    }\n\n    return key;\n  }\n\n  /** Write a key to disk with owner-only permissions. */\n  async store(path: string, key: string): Promise<void> {\n    await mkdir(dirname(path), { recursive: true });\n    await writeFile(path, `${key}\\n`, { mode: KEY_FILE_MODE });\n    // writeFile's mode is only applied when creating a new file; force it\n    // in case the file already existed with different permissions.\n    await chmod(path, KEY_FILE_MODE);\n  }\n\n  /** Constant-time comparison of a client-provided key against the expected key. */\n  validate(provided: string | undefined | null, expected: string): boolean {\n    if (!provided) return false;\n\n    const providedBuf = Buffer.from(provided);\n    const expectedBuf = Buffer.from(expected);\n    if (providedBuf.length !== expectedBuf.length) return false;\n\n    return timingSafeEqual(providedBuf, expectedBuf);\n  }\n\n  /**\n   * Load the DR config, refusing to proceed if the file exists but is\n   * corrupted. Without this, a corrupted config looks identical to \"no key\n   * configured yet\", which would cause `ensureKey`/`rotate` to silently\n   * generate a new key and overwrite `mcp.api_key_path` \u2014 orphaning any\n   * valid key already on disk and breaking every MCP client configured with\n   * the old one.\n   */\n  private async loadConfigOrThrow(): Promise<DRConfig> {\n    try {\n      return await loadDRConfig({ strict: true });\n    } catch (error) {\n      if (error instanceof DRConfigParseError) {\n        throw new Error(\n          `Cannot determine the configured MCP API key path: ${error.configPath} is corrupted. ` +\n            \"Fix or remove this file before continuing \u2014 proceeding could orphan an existing key \" +\n            \"and break already-configured MCP clients.\",\n          { cause: error }\n        );\n      }\n      throw error;\n    }\n  }\n\n  /**\n   * Resolve the API key to use for this session: load it from the previously\n   * configured path, or generate+store a new one on first use.\n   *\n   * @param promptForPath Called only when no key is yet configured, to ask the\n   *   user where to store it. When omitted (e.g. non-interactive launches),\n   *   `defaultKeyPath` is used without prompting.\n   */\n  async ensureKey(promptForPath?: ApiKeyStoragePrompt): Promise<EnsureKeyResult> {\n    const config = await this.loadConfigOrThrow();\n    const existingPath = config.mcp?.api_key_path;\n\n    if (existingPath && existsSync(existingPath)) {\n      const key = await this.load(existingPath);\n      return { key, path: existingPath, isNew: false };\n    }\n\n    const chosenPath = promptForPath\n      ? await promptForPath(this.defaultKeyPath)\n      : this.defaultKeyPath;\n\n    const key = this.generate();\n    await this.store(chosenPath, key);\n    await saveDRConfig({\n      ...config,\n      mcp: { ...config.mcp, api_key_path: chosenPath },\n    });\n\n    return { key, path: chosenPath, isNew: true };\n  }\n\n  /**\n   * Force-generate a new API key, overwriting whatever is at the configured\n   * (or default) storage path, regardless of whether a key already exists\n   * there. Unlike `ensureKey`, this always writes a fresh key.\n   *\n   * @param promptForPath Called only when no storage path is yet configured,\n   *   to ask the user where to store it. When omitted, `defaultKeyPath` is\n   *   used without prompting.\n   */\n  async rotate(promptForPath?: ApiKeyStoragePrompt): Promise<RotateKeyResult> {\n    const config = await this.loadConfigOrThrow();\n    const path =\n      config.mcp?.api_key_path ??\n      (promptForPath ? await promptForPath(this.defaultKeyPath) : this.defaultKeyPath);\n\n    const key = this.generate();\n    await this.store(path, key);\n    await saveDRConfig({\n      ...config,\n      mcp: { ...config.mcp, api_key_path: path },\n    });\n\n    return { key, path };\n  }\n}\n"],
+  "mappings": "AAUA,SAAS,aAAa,uBAAuB;AAC7C,SAAS,kBAAkB;AAC3B,SAAS,OAAO,OAAO,UAAU,iBAAiB;AAClD,SAAS,eAAe;AACxB,SAAS,SAAS,YAAY;AAC9B,SAAmB,oBAAoB,cAAc,oBAAoB;AAGzE,MAAM,gBAAgB;AAOhB,SAAU,uBAAoB;AAClC,SAAO,KAAK,QAAO,GAAI,aAAa;AACtC;AAiBM,MAAO,cAAa;EAMK;;;;;;EAA7B,YAA6B,iBAAyB,qBAAoB,GAAE;AAA/C,SAAA,iBAAA;EAAkD;;EAG/E,WAAQ;AACN,WAAO,UAAU,YAAY,EAAE,EAAE,SAAS,WAAW,CAAC;EACxD;;EAGA,MAAM,KAAK,MAAY;AAErB,UAAM,OADU,MAAM,SAAS,MAAM,OAAO,GACxB,KAAI;AAExB,QAAI,CAAC;AACH,YAAM,IAAI,MACR,mBAAmB,IAAI,gGACqD;AAIhF,WAAO;EACT;;EAGA,MAAM,MAAM,MAAc,KAAW;AACnC,UAAM,MAAM,QAAQ,IAAI,GAAG,EAAE,WAAW,GAAI,CAAE,GAC9C,MAAM,UAAU,MAAM,GAAG,GAAG;GAAM,EAAE,MAAM,cAAa,CAAE,GAGzD,MAAM,MAAM,MAAM,aAAa;EACjC;;EAGA,SAAS,UAAqC,UAAgB;AAC5D,QAAI,CAAC;AAAU,aAAO;AAEtB,UAAM,cAAc,OAAO,KAAK,QAAQ,GAClC,cAAc,OAAO,KAAK,QAAQ;AACxC,WAAI,YAAY,WAAW,YAAY,SAAe,KAE/C,gBAAgB,aAAa,WAAW;EACjD;;;;;;;;;EAUQ,MAAM,oBAAiB;AAC7B,QAAI;AACF,aAAO,MAAM,aAAa,EAAE,QAAQ,GAAI,CAAE;IAC5C,SAAS,OAAO;AACd,YAAI,iBAAiB,qBACb,IAAI,MACR,qDAAqD,MAAM,UAAU,qJAGrE,EAAE,OAAO,MAAK,CAAE,IAGd;IACR;EACF;;;;;;;;;EAUA,MAAM,UAAU,eAAmC;AACjD,UAAM,SAAS,MAAM,KAAK,kBAAiB,GACrC,eAAe,OAAO,KAAK;AAEjC,QAAI,gBAAgB,WAAW,YAAY;AAEzC,aAAO,EAAE,KADG,MAAM,KAAK,KAAK,YAAY,GAC1B,MAAM,cAAc,OAAO,GAAK;AAGhD,UAAM,aAAa,gBACf,MAAM,cAAc,KAAK,cAAc,IACvC,KAAK,gBAEH,MAAM,KAAK,SAAQ;AACzB,iBAAM,KAAK,MAAM,YAAY,GAAG,GAChC,MAAM,aAAa;MACjB,GAAG;MACH,KAAK,EAAE,GAAG,OAAO,KAAK,cAAc,WAAU;KAC/C,GAEM,EAAE,KAAK,MAAM,YAAY,OAAO,GAAI;EAC7C;;;;;;;;;;EAWA,MAAM,OAAO,eAAmC;AAC9C,UAAM,SAAS,MAAM,KAAK,kBAAiB,GACrC,OACJ,OAAO,KAAK,iBACX,gBAAgB,MAAM,cAAc,KAAK,cAAc,IAAI,KAAK,iBAE7D,MAAM,KAAK,SAAQ;AACzB,iBAAM,KAAK,MAAM,MAAM,GAAG,GAC1B,MAAM,aAAa;MACjB,GAAG;MACH,KAAK,EAAE,GAAG,OAAO,KAAK,cAAc,KAAI;KACzC,GAEM,EAAE,KAAK,KAAI;EACpB;;",
+  "names": []
+}

package/dist/mcp/http-transport.js

@@ -0,0 +1,176 @@
+import { randomUUID } from "node:crypto";
+import express from "express";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { isInitializeRequest } from "@modelcontextprotocol/sdk/types.js";
+function createBearerAuthMiddleware(keyManager, expectedKey) {
+  return (req, res, next) => {
+    const match = (req.get("Authorization") || "").match(/^Bearer\s+(.+)$/), providedKey = match ? match[1] : void 0;
+    if (!keyManager.validate(providedKey, expectedKey)) {
+      res.status(401).json({ error: "Unauthorized" });
+      return;
+    }
+    next();
+  };
+}
+async function createMcpHttpApp(keyManager, apiKey, createServer, host = "127.0.0.1") {
+  const app = createMcpExpressApp({ host });
+  app.__mcp_sessions = /* @__PURE__ */ new Map();
+  const sessions = app.__mcp_sessions;
+  return app.use(express.raw({ type: "application/octet-stream" })), app.use("/mcp", createBearerAuthMiddleware(keyManager, apiKey)), app.post("/mcp", async (req, res) => {
+    try {
+      const requestedSessionId = req.headers["mcp-session-id"];
+      if (requestedSessionId && sessions.has(requestedSessionId)) {
+        const sessionData = sessions.get(requestedSessionId);
+        if (sessionData) {
+          try {
+            await sessionData.transport.handleRequest(req, res, req.body);
+          } catch (error) {
+            const errorMsg = error instanceof Error ? error.message : "unknown error";
+            process.stderr.write(`[mcp:http] POST handleRequest error: ${errorMsg}
+`), res.headersSent || res.status(500).json({ error: "Internal server error" });
+          }
+          return;
+        }
+      }
+      if (!isInitializeRequest(req.body)) {
+        res.status(400).json({ jsonrpc: "2.0", error: { code: -32600, message: "Invalid Request: initialize required for new session" }, id: null });
+        return;
+      }
+      let server = null, transport = null;
+      try {
+        server = await createServer(), transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: () => randomUUID()
+        }), transport.onclose = async () => {
+          if (transport && transport.sessionId) {
+            const sessionId2 = transport.sessionId, sessionData = sessions.get(sessionId2);
+            if (sessionData) {
+              sessions.delete(sessionId2);
+              try {
+                await sessionData.server.close();
+              } catch (closeError) {
+                process.stderr.write(`[mcp:http] Error closing server in onclose handler: ${closeError instanceof Error ? closeError.message : "unknown error"}
+`);
+              }
+            }
+          }
+        }, await server.connect(transport), await transport.handleRequest(req, res, req.body);
+        const sessionId = transport.sessionId;
+        sessionId && !sessions.has(sessionId) && sessions.set(sessionId, { server, transport });
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : "unknown error";
+        if (process.stderr.write(`[mcp:http] POST setup error: ${errorMsg}
+`), transport)
+          try {
+            await transport.close();
+          } catch (closeError) {
+            process.stderr.write(`[mcp:http] Error closing transport during cleanup: ${closeError instanceof Error ? closeError.message : "unknown error"}
+`);
+          }
+        if (server)
+          try {
+            await server.close();
+          } catch (closeError) {
+            process.stderr.write(`[mcp:http] Error closing server during cleanup: ${closeError instanceof Error ? closeError.message : "unknown error"}
+`);
+          }
+        res.headersSent || res.status(500).json({ error: "Internal server error" });
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "unknown error";
+      process.stderr.write(`[mcp:http] POST outer error: ${errorMsg}
+`), res.headersSent || res.status(500).json({ error: "Internal server error" });
+    }
+  }), app.get("/mcp", async (req, res) => {
+    try {
+      const sessionId = req.headers["mcp-session-id"];
+      if (!sessionId || !sessions.has(sessionId)) {
+        res.status(400).json({ error: "Invalid or missing session ID" });
+        return;
+      }
+      const sessionData = sessions.get(sessionId);
+      if (!sessionData) {
+        res.status(400).json({ error: "Session not found" });
+        return;
+      }
+      await sessionData.transport.handleRequest(req, res);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "unknown error";
+      process.stderr.write(`[mcp:http] GET handleRequest error: ${errorMsg}
+`), res.headersSent || res.status(500).json({ error: "Internal server error" });
+    }
+  }), app.delete("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    if (!sessionId || !sessions.has(sessionId)) {
+      res.status(400).json({ error: "Invalid or missing session ID" });
+      return;
+    }
+    const sessionData = sessions.get(sessionId);
+    if (!sessionData) {
+      res.status(400).json({ error: "Session not found" });
+      return;
+    }
+    try {
+      await sessionData.transport.handleRequest(req, res);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "unknown error";
+      process.stderr.write(`[mcp:http] DELETE handleRequest error: ${errorMsg}
+`), res.headersSent || res.status(500).json({ error: "Internal server error" });
+    } finally {
+      if (sessions.has(sessionId)) {
+        sessions.delete(sessionId);
+        try {
+          await sessionData.server.close();
+        } catch (closeError) {
+          process.stderr.write(`[mcp:http] Error closing server in DELETE handler: ${closeError instanceof Error ? closeError.message : "unknown error"}
+`);
+        }
+        try {
+          await sessionData.transport.close();
+        } catch (closeError) {
+          process.stderr.write(`[mcp:http] Error closing transport in DELETE handler: ${closeError instanceof Error ? closeError.message : "unknown error"}
+`);
+        }
+      }
+    }
+  }), app;
+}
+async function startHttpServer(app, host, port) {
+  return new Promise((resolve, reject) => {
+    const server = app.listen(port, host, () => {
+      resolve(server);
+    });
+    server.once("error", reject);
+  });
+}
+async function closeHttpServer(server, app) {
+  const sessions = app?.__mcp_sessions;
+  if (sessions)
+    for (const [sessionId, { server: mcpServer, transport }] of sessions.entries()) {
+      try {
+        await mcpServer.close();
+      } catch (error) {
+        process.stderr.write(`[mcp] Error closing server for session ${sessionId}: ${error instanceof Error ? error.message : "unknown error"}
+`);
+      }
+      sessions.delete(sessionId);
+      try {
+        await transport.close();
+      } catch (error) {
+        process.stderr.write(`[mcp] Error closing transport for session ${sessionId}: ${error instanceof Error ? error.message : "unknown error"}
+`);
+      }
+    }
+  return new Promise((resolve, reject) => {
+    server.close((error) => {
+      error ? reject(error) : resolve();
+    });
+  });
+}
+export {
+  closeHttpServer,
+  createBearerAuthMiddleware,
+  createMcpHttpApp,
+  startHttpServer
+};
+//# sourceMappingURL=http-transport.js.map

package/dist/mcp/http-transport.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/http-transport.ts"],
+  "sourcesContent": ["/**\n * HTTP transport implementation for MCP server\n *\n * Provides an Express-based HTTP server exposing the MCP protocol over a /mcp endpoint\n * with per-session server/transport handling and bearer token authentication.\n */\n\nimport { Server as HttpServer } from \"http\";\nimport { randomUUID } from \"node:crypto\";\nimport express, { Express, Request, Response, NextFunction } from \"express\";\nimport { createMcpExpressApp } from \"@modelcontextprotocol/sdk/server/express.js\";\nimport { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { StreamableHTTPServerTransport } from \"@modelcontextprotocol/sdk/server/streamableHttp.js\";\nimport { isInitializeRequest } from \"@modelcontextprotocol/sdk/types.js\";\nimport { ApiKeyManager } from \"./api-key-manager.js\";\n\ninterface SessionData {\n  server: McpServer;\n  transport: StreamableHTTPServerTransport;\n}\n\nexport interface HttpTransportApp extends Express {\n  __mcp_sessions?: Map<string, SessionData>;\n}\n\n/**\n * Middleware to validate bearer token authentication.\n * Extracts and validates the Authorization header, rejecting with 401 if invalid.\n */\nexport function createBearerAuthMiddleware(keyManager: ApiKeyManager, expectedKey: string) {\n  return (req: Request, res: Response, next: NextFunction): void => {\n    const authHeader = req.get(\"Authorization\") || \"\";\n    const match = authHeader.match(/^Bearer\\s+(.+)$/);\n    const providedKey = match ? match[1] : undefined;\n\n    if (!keyManager.validate(providedKey, expectedKey)) {\n      res.status(401).json({ error: \"Unauthorized\" });\n      return;\n    }\n\n    next();\n  };\n}\n\n/**\n * Create an Express application configured for MCP HTTP transport.\n *\n * @param keyManager API key manager for authentication\n * @param apiKey The API key to authenticate requests\n * @param createServer Async function to create a configured MCP server\n * @param host Host address the server will bind to (used for DNS rebinding protection)\n */\nexport async function createMcpHttpApp(\n  keyManager: ApiKeyManager,\n  apiKey: string,\n  createServer: () => Promise<McpServer>,\n  host: string = \"127.0.0.1\"\n): Promise<HttpTransportApp> {\n  const app = createMcpExpressApp({ host }) as HttpTransportApp;\n  app.__mcp_sessions = new Map<string, SessionData>();\n  const sessions = app.__mcp_sessions;\n\n  // Middleware\n  app.use(express.raw({ type: \"application/octet-stream\" }));\n\n  // Apply bearer token authentication to all MCP endpoints\n  app.use(\"/mcp\", createBearerAuthMiddleware(keyManager, apiKey));\n\n  // Handle POST requests for MCP protocol\n  app.post(\"/mcp\", async (req: Request, res: Response) => {\n    try {\n      // Extract session ID from request headers if provided\n      const requestedSessionId = req.headers[\"mcp-session-id\"] as string | undefined;\n\n      // Check if this is a continuation of an existing session\n      if (requestedSessionId && sessions.has(requestedSessionId)) {\n        // Reuse existing session\n        const sessionData = sessions.get(requestedSessionId);\n        if (sessionData) {\n          try {\n            await sessionData.transport.handleRequest(req, res, req.body);\n          } catch (error) {\n            const errorMsg = error instanceof Error ? error.message : \"unknown error\";\n            process.stderr.write(`[mcp:http] POST handleRequest error: ${errorMsg}\\n`);\n            if (!res.headersSent) {\n              res.status(500).json({ error: \"Internal server error\" });\n            }\n          }\n          return;\n        }\n      }\n\n      // Only create a new session for initialize requests\n      if (!isInitializeRequest(req.body)) {\n        res.status(400).json({ jsonrpc: \"2.0\", error: { code: -32600, message: \"Invalid Request: initialize required for new session\" }, id: null });\n        return;\n      }\n\n      // Create a new session\n      let server: McpServer | null = null;\n      let transport: StreamableHTTPServerTransport | null = null;\n\n      try {\n        server = await createServer();\n        transport = new StreamableHTTPServerTransport({\n          sessionIdGenerator: () => randomUUID(),\n        });\n\n        // Register onclose handler to clean up session when transport closes\n        transport.onclose = async () => {\n          if (transport && transport.sessionId) {\n            const sessionId = transport.sessionId;\n            const sessionData = sessions.get(sessionId);\n            if (sessionData) {\n              sessions.delete(sessionId);\n              // Close server to release resources\n              try {\n                await sessionData.server.close();\n              } catch (closeError) {\n                process.stderr.write(\n                  `[mcp:http] Error closing server in onclose handler: ${\n                    closeError instanceof Error ? closeError.message : \"unknown error\"\n                  }\\n`\n                );\n              }\n            }\n          }\n        };\n\n        // Connect server to transport before handling the request\n        await server.connect(transport);\n\n        // Handle the request through the streamable HTTP transport\n        await transport.handleRequest(req, res, req.body);\n\n        // Store session data for later cleanup after handleRequest completes and sessionId is set\n        const sessionId = transport.sessionId;\n        if (sessionId && !sessions.has(sessionId)) {\n          sessions.set(sessionId, { server, transport });\n        }\n      } catch (error) {\n        const errorMsg = error instanceof Error ? error.message : \"unknown error\";\n        process.stderr.write(`[mcp:http] POST setup error: ${errorMsg}\\n`);\n\n        // Clean up resources on setup failure\n        if (transport) {\n          try {\n            await transport.close();\n          } catch (closeError) {\n            process.stderr.write(\n              `[mcp:http] Error closing transport during cleanup: ${\n                closeError instanceof Error ? closeError.message : \"unknown error\"\n              }\\n`\n            );\n          }\n        }\n        if (server) {\n          try {\n            await server.close();\n          } catch (closeError) {\n            process.stderr.write(\n              `[mcp:http] Error closing server during cleanup: ${\n                closeError instanceof Error ? closeError.message : \"unknown error\"\n              }\\n`\n            );\n          }\n        }\n\n        if (!res.headersSent) {\n          res.status(500).json({ error: \"Internal server error\" });\n        }\n      }\n    } catch (error) {\n      const errorMsg = error instanceof Error ? error.message : \"unknown error\";\n      process.stderr.write(`[mcp:http] POST outer error: ${errorMsg}\\n`);\n      if (!res.headersSent) {\n        res.status(500).json({ error: \"Internal server error\" });\n      }\n    }\n  });\n\n  // Handle GET requests for SSE streams\n  app.get(\"/mcp\", async (req: Request, res: Response) => {\n    try {\n      const sessionId = req.headers[\"mcp-session-id\"] as string | undefined;\n\n      if (!sessionId || !sessions.has(sessionId)) {\n        res.status(400).json({ error: \"Invalid or missing session ID\" });\n        return;\n      }\n\n      const sessionData = sessions.get(sessionId);\n      if (!sessionData) {\n        res.status(400).json({ error: \"Session not found\" });\n        return;\n      }\n\n      // Reuse the existing transport for this session\n      await sessionData.transport.handleRequest(req, res);\n    } catch (error) {\n      const errorMsg = error instanceof Error ? error.message : \"unknown error\";\n      process.stderr.write(`[mcp:http] GET handleRequest error: ${errorMsg}\\n`);\n      if (!res.headersSent) {\n        res.status(500).json({ error: \"Internal server error\" });\n      }\n    }\n  });\n\n  // Handle DELETE requests for session termination\n  app.delete(\"/mcp\", async (req: Request, res: Response) => {\n    const sessionId = req.headers[\"mcp-session-id\"] as string | undefined;\n\n    if (!sessionId || !sessions.has(sessionId)) {\n      res.status(400).json({ error: \"Invalid or missing session ID\" });\n      return;\n    }\n\n    const sessionData = sessions.get(sessionId);\n    if (!sessionData) {\n      res.status(400).json({ error: \"Session not found\" });\n      return;\n    }\n\n    try {\n      // Handle the DELETE request through the transport\n      await sessionData.transport.handleRequest(req, res);\n    } catch (error) {\n      const errorMsg = error instanceof Error ? error.message : \"unknown error\";\n      process.stderr.write(`[mcp:http] DELETE handleRequest error: ${errorMsg}\\n`);\n      if (!res.headersSent) {\n        res.status(500).json({ error: \"Internal server error\" });\n      }\n    } finally {\n      // Always clean up the session, even if handleRequest throws\n      if (sessions.has(sessionId)) {\n        sessions.delete(sessionId);\n        // Close server to release resources\n        try {\n          await sessionData.server.close();\n        } catch (closeError) {\n          process.stderr.write(\n            `[mcp:http] Error closing server in DELETE handler: ${\n              closeError instanceof Error ? closeError.message : \"unknown error\"\n            }\\n`\n          );\n        }\n        // Close transport to release resources\n        try {\n          await sessionData.transport.close();\n        } catch (closeError) {\n          process.stderr.write(\n            `[mcp:http] Error closing transport in DELETE handler: ${\n              closeError instanceof Error ? closeError.message : \"unknown error\"\n            }\\n`\n          );\n        }\n      }\n    }\n  });\n\n  return app;\n}\n\n/**\n * Start the HTTP server and return the listening HttpServer instance.\n *\n * @param app Express application\n * @param host Host address to bind to\n * @param port Port to bind to\n * @returns HttpServer instance when listening\n */\nexport async function startHttpServer(\n  app: Express,\n  host: string,\n  port: number\n): Promise<HttpServer> {\n  return new Promise((resolve, reject) => {\n    const server = app.listen(port, host, () => {\n      resolve(server);\n    });\n\n    server.once(\"error\", reject);\n  });\n}\n\n/**\n * Gracefully close all active sessions and the HTTP server.\n *\n * @param server HttpServer instance\n * @param app Express application (used to access instance-scoped sessions)\n */\nexport async function closeHttpServer(\n  server: HttpServer,\n  app?: HttpTransportApp\n): Promise<void> {\n  const sessions = app?.__mcp_sessions;\n\n  if (sessions) {\n    // Close all active sessions\n    for (const [sessionId, { server: mcpServer, transport }] of sessions.entries()) {\n      try {\n        // Close the server to release resources\n        await mcpServer.close();\n      } catch (error) {\n        process.stderr.write(\n          `[mcp] Error closing server for session ${sessionId}: ${\n            error instanceof Error ? error.message : \"unknown error\"\n          }\\n`\n        );\n      }\n      // Remove from sessions map BEFORE closing transport to prevent the onclose handler\n      // from finding the session and trying to close the server again\n      sessions.delete(sessionId);\n      try {\n        // Close the transport\n        await transport.close();\n      } catch (error) {\n        process.stderr.write(\n          `[mcp] Error closing transport for session ${sessionId}: ${\n            error instanceof Error ? error.message : \"unknown error\"\n          }\\n`\n        );\n      }\n    }\n  }\n\n  // Close the HTTP server\n  return new Promise((resolve, reject) => {\n    server.close((error) => {\n      if (error) {\n        reject(error);\n      } else {\n        resolve();\n      }\n    });\n  });\n}\n"],
+  "mappings": "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",
+  "names": ["sessionId"]
+}

package/dist/mcp/resource-registry.js

@@ -0,0 +1,97 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { AnnotationStore } from "../core/annotation-store.js";
+import { CANONICAL_LAYER_NAMES } from "../core/layers.js";
+import { getErrorMessage } from "../utils/errors.js";
+import { loadModel } from "./tools/shared.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url)), BUNDLED_SCHEMAS_DIR = path.join(__dirname, "../schemas/bundled");
+async function readBundledSchema(fileName) {
+  try {
+    return await fs.readFile(path.join(BUNDLED_SCHEMAS_DIR, fileName), "utf-8");
+  } catch (error) {
+    throw error instanceof Error && "code" in error && error.code === "ENOENT" ? new Error(`Bundled schema "${fileName}" is missing from ${BUNDLED_SCHEMAS_DIR}. This usually means the CLI build is incomplete or corrupted \u2014 run "npm run build" in cli/ to regenerate it.`) : error;
+  }
+}
+class McpResourceRegistry {
+  /** Registers every spec/model resource onto the given MCP server instance. */
+  async registerAll(server) {
+    const { ResourceTemplate } = await import("@modelcontextprotocol/sdk/server/mcp.js");
+    server.registerResource("spec-manifest", "dr://spec/manifest", {
+      title: "Specification manifest",
+      description: "Index of all 12 architecture layers in the compiled specification.",
+      mimeType: "application/json"
+    }, async (uri) => {
+      const text = await readBundledSchema("manifest.json");
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text }] };
+    }), server.registerResource("spec-base", "dr://spec/base", {
+      title: "Base specification schemas",
+      description: "Base schemas and predicates shared across all layers.",
+      mimeType: "application/json"
+    }, async (uri) => {
+      const text = await readBundledSchema("base.json");
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text }] };
+    }), server.registerResource("spec-layer", new ResourceTemplate("dr://spec/layer/{name}", {
+      list: async () => ({
+        resources: CANONICAL_LAYER_NAMES.map((name) => ({
+          name: `spec-layer-${name}`,
+          uri: `dr://spec/layer/${name}`,
+          title: `${name} layer schemas`,
+          mimeType: "application/json"
+        }))
+      })
+    }), {
+      title: "Layer specification schemas",
+      description: "Node and relationship schemas for a single architecture layer.",
+      mimeType: "application/json"
+    }, async (uri, variables) => {
+      const name = String(variables.name);
+      if (!CANONICAL_LAYER_NAMES.includes(name))
+        throw new Error(`Unknown spec layer "${name}". Valid layers: ${CANONICAL_LAYER_NAMES.join(", ")}`);
+      const text = await readBundledSchema(`${name}.json`);
+      return { contents: [{ uri: uri.href, mimeType: "application/json", text }] };
+    }), server.registerResource("model-manifest", "dr://model/manifest", {
+      title: "Model manifest",
+      description: "Metadata and layer summary for the current architecture model.",
+      mimeType: "application/json"
+    }, async (uri) => {
+      try {
+        const model = await loadModel(), manifest = {
+          name: model.manifest.name,
+          version: model.manifest.version,
+          specVersion: model.manifest.specVersion,
+          description: model.manifest.description,
+          author: model.manifest.author,
+          created: model.manifest.created,
+          modified: model.manifest.modified,
+          layers: model.getLayerNames()
+        };
+        return {
+          contents: [{ uri: uri.href, mimeType: "application/json", text: JSON.stringify(manifest, null, 2) }]
+        };
+      } catch (error) {
+        throw new Error(`Failed to load model manifest: ${getErrorMessage(error)}`);
+      }
+    }), server.registerResource("model-annotations", "dr://model/annotations", {
+      title: "Model annotations",
+      description: "All annotations on elements in the current architecture model.",
+      mimeType: "application/json"
+    }, async (uri) => {
+      try {
+        const model = await loadModel(), annotations = await new AnnotationStore(model.rootPath).list();
+        return {
+          contents: [
+            { uri: uri.href, mimeType: "application/json", text: JSON.stringify({ annotations }, null, 2) }
+          ]
+        };
+      } catch (error) {
+        throw new Error(`Failed to load model annotations: ${getErrorMessage(error)}`);
+      }
+    });
+  }
+}
+export {
+  McpResourceRegistry,
+  readBundledSchema
+};
+//# sourceMappingURL=resource-registry.js.map

package/dist/mcp/resource-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/resource-registry.ts"],
+  "sourcesContent": ["/**\n * McpResourceRegistry \u2014 registers spec and model manifest resources onto an\n * MCP server.\n *\n * - dr://spec/manifest       \u2014 index of all 12 compiled specification layers\n * - dr://spec/base           \u2014 base schemas + predicates shared across layers\n * - dr://spec/layer/{name}   \u2014 node/relationship schemas for a single layer\n * - dr://model/manifest      \u2014 metadata and layer summary for the current model\n * - dr://model/annotations   \u2014 all annotations across the current model\n */\n\nimport { promises as fs } from \"node:fs\";\nimport path from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { AnnotationStore } from \"../core/annotation-store.js\";\nimport { CANONICAL_LAYER_NAMES } from \"../core/layers.js\";\nimport { getErrorMessage } from \"../utils/errors.js\";\nimport { loadModel } from \"./tools/shared.js\";\n\nconst __dirname = path.dirname(fileURLToPath(import.meta.url));\nconst BUNDLED_SCHEMAS_DIR = path.join(__dirname, \"../schemas/bundled\");\n\n/** Exported for direct unit testing of the ENOENT-to-actionable-error translation. */\nexport async function readBundledSchema(fileName: string): Promise<string> {\n  try {\n    return await fs.readFile(path.join(BUNDLED_SCHEMAS_DIR, fileName), \"utf-8\");\n  } catch (error) {\n    if (error instanceof Error && \"code\" in error && (error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      throw new Error(\n        `Bundled schema \"${fileName}\" is missing from ${BUNDLED_SCHEMAS_DIR}. ` +\n          `This usually means the CLI build is incomplete or corrupted \u2014 run \"npm run build\" in cli/ to regenerate it.`\n      );\n    }\n    throw error;\n  }\n}\n\nexport class McpResourceRegistry {\n  /** Registers every spec/model resource onto the given MCP server instance. */\n  async registerAll(server: McpServer): Promise<void> {\n    const { ResourceTemplate } = await import(\"@modelcontextprotocol/sdk/server/mcp.js\");\n\n    server.registerResource(\n      \"spec-manifest\",\n      \"dr://spec/manifest\",\n      {\n        title: \"Specification manifest\",\n        description: \"Index of all 12 architecture layers in the compiled specification.\",\n        mimeType: \"application/json\",\n      },\n      async (uri) => {\n        const text = await readBundledSchema(\"manifest.json\");\n        return { contents: [{ uri: uri.href, mimeType: \"application/json\", text }] };\n      }\n    );\n\n    server.registerResource(\n      \"spec-base\",\n      \"dr://spec/base\",\n      {\n        title: \"Base specification schemas\",\n        description: \"Base schemas and predicates shared across all layers.\",\n        mimeType: \"application/json\",\n      },\n      async (uri) => {\n        const text = await readBundledSchema(\"base.json\");\n        return { contents: [{ uri: uri.href, mimeType: \"application/json\", text }] };\n      }\n    );\n\n    server.registerResource(\n      \"spec-layer\",\n      new ResourceTemplate(\"dr://spec/layer/{name}\", {\n        list: async () => ({\n          resources: CANONICAL_LAYER_NAMES.map((name) => ({\n            name: `spec-layer-${name}`,\n            uri: `dr://spec/layer/${name}`,\n            title: `${name} layer schemas`,\n            mimeType: \"application/json\",\n          })),\n        }),\n      }),\n      {\n        title: \"Layer specification schemas\",\n        description: \"Node and relationship schemas for a single architecture layer.\",\n        mimeType: \"application/json\",\n      },\n      async (uri, variables) => {\n        const name = String(variables.name);\n        if (!(CANONICAL_LAYER_NAMES as readonly string[]).includes(name)) {\n          throw new Error(\n            `Unknown spec layer \"${name}\". Valid layers: ${CANONICAL_LAYER_NAMES.join(\", \")}`\n          );\n        }\n        const text = await readBundledSchema(`${name}.json`);\n        return { contents: [{ uri: uri.href, mimeType: \"application/json\", text }] };\n      }\n    );\n\n    server.registerResource(\n      \"model-manifest\",\n      \"dr://model/manifest\",\n      {\n        title: \"Model manifest\",\n        description: \"Metadata and layer summary for the current architecture model.\",\n        mimeType: \"application/json\",\n      },\n      async (uri) => {\n        try {\n          const model = await loadModel();\n          const manifest = {\n            name: model.manifest.name,\n            version: model.manifest.version,\n            specVersion: model.manifest.specVersion,\n            description: model.manifest.description,\n            author: model.manifest.author,\n            created: model.manifest.created,\n            modified: model.manifest.modified,\n            layers: model.getLayerNames(),\n          };\n          return {\n            contents: [{ uri: uri.href, mimeType: \"application/json\", text: JSON.stringify(manifest, null, 2) }],\n          };\n        } catch (error) {\n          throw new Error(`Failed to load model manifest: ${getErrorMessage(error)}`);\n        }\n      }\n    );\n\n    server.registerResource(\n      \"model-annotations\",\n      \"dr://model/annotations\",\n      {\n        title: \"Model annotations\",\n        description: \"All annotations on elements in the current architecture model.\",\n        mimeType: \"application/json\",\n      },\n      async (uri) => {\n        try {\n          const model = await loadModel();\n          const store = new AnnotationStore(model.rootPath);\n          const annotations = await store.list();\n          return {\n            contents: [\n              { uri: uri.href, mimeType: \"application/json\", text: JSON.stringify({ annotations }, null, 2) },\n            ],\n          };\n        } catch (error) {\n          throw new Error(`Failed to load model annotations: ${getErrorMessage(error)}`);\n        }\n      }\n    );\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mcp/tool-registry.js

@@ -0,0 +1,44 @@
+import { isTelemetryEnabled, startActiveSpan } from "../telemetry/index.js";
+import { annotationCreateTool, annotationDeleteTool, annotationGetTool, annotationListTool, annotationReplyTool, annotationUpdateTool, changesetListTool, changesetShowTool, chatLaunchTool, chatStatusTool, modelAddTool, modelDeleteTool, modelExportTool, modelInfoTool, modelListTool, modelReloadTool, modelSearchTool, modelShowTool, modelStatsTool, modelTraceTool, modelUpdateTool, modelValidateTool } from "./tools/index.js";
+const MODEL_TOOLS = [
+  modelListTool,
+  modelShowTool,
+  modelSearchTool,
+  modelStatsTool,
+  modelInfoTool,
+  modelTraceTool,
+  modelAddTool,
+  modelUpdateTool,
+  modelDeleteTool,
+  modelValidateTool,
+  modelExportTool,
+  modelReloadTool,
+  changesetListTool,
+  changesetShowTool,
+  chatStatusTool,
+  chatLaunchTool,
+  annotationListTool,
+  annotationGetTool,
+  annotationCreateTool,
+  annotationUpdateTool,
+  annotationDeleteTool,
+  annotationReplyTool
+];
+class McpToolRegistry {
+  /** Registers every model tool onto the given MCP server instance. */
+  registerAll(server) {
+    for (const tool of MODEL_TOOLS)
+      server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args) => startActiveSpan(`mcp.tool.${tool.name}`, async (span) => {
+        const result = await tool.handler(args);
+        if (isTelemetryEnabled && result?.isError) {
+          const firstContent = result.content?.[0], message = firstContent?.type === "text" ? firstContent.text : "Tool returned an error";
+          span.setStatus({ code: 2, message });
+        }
+        return result;
+      }, { "mcp.tool.name": tool.name }));
+  }
+}
+export {
+  McpToolRegistry
+};
+//# sourceMappingURL=tool-registry.js.map

package/dist/mcp/tool-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/mcp/tool-registry.ts"],
+  "sourcesContent": ["/**\n * McpToolRegistry \u2014 registers the DR model tool surface onto an MCP server.\n *\n * Read-only tools: model_list, model_show, model_search, model_stats,\n * model_info, model_trace.\n * Mutation tools: model_add, model_update, model_delete (via MutationHandler).\n * Pipeline tools: model_validate, model_export (via the shared validator\n * pipeline and export handlers).\n * Lifecycle tools: model_reload (force a full re-read from disk).\n * Changeset tools: changeset_list, changeset_show (via StagingAreaManager).\n * Chat tools: chat_status, chat_launch (via the coding-agents chat clients).\n * Annotation tools: annotation_list, annotation_get, annotation_create,\n * annotation_update, annotation_delete, annotation_reply (via AnnotationStore),\n * mirroring the REST server's /api/annotations/* endpoints.\n */\n\nimport type { McpServer } from \"@modelcontextprotocol/sdk/server/mcp.js\";\nimport { isTelemetryEnabled, startActiveSpan } from \"../telemetry/index.js\";\nimport {\n  annotationCreateTool,\n  annotationDeleteTool,\n  annotationGetTool,\n  annotationListTool,\n  annotationReplyTool,\n  annotationUpdateTool,\n  changesetListTool,\n  changesetShowTool,\n  chatLaunchTool,\n  chatStatusTool,\n  modelAddTool,\n  modelDeleteTool,\n  modelExportTool,\n  modelInfoTool,\n  modelListTool,\n  modelReloadTool,\n  modelSearchTool,\n  modelShowTool,\n  modelStatsTool,\n  modelTraceTool,\n  modelUpdateTool,\n  modelValidateTool,\n  type McpToolDefinition,\n} from \"./tools/index.js\";\n\nconst MODEL_TOOLS: McpToolDefinition[] = [\n  modelListTool,\n  modelShowTool,\n  modelSearchTool,\n  modelStatsTool,\n  modelInfoTool,\n  modelTraceTool,\n  modelAddTool,\n  modelUpdateTool,\n  modelDeleteTool,\n  modelValidateTool,\n  modelExportTool,\n  modelReloadTool,\n  changesetListTool,\n  changesetShowTool,\n  chatStatusTool,\n  chatLaunchTool,\n  annotationListTool,\n  annotationGetTool,\n  annotationCreateTool,\n  annotationUpdateTool,\n  annotationDeleteTool,\n  annotationReplyTool,\n];\n\nexport class McpToolRegistry {\n  /** Registers every model tool onto the given MCP server instance. */\n  registerAll(server: McpServer): void {\n    for (const tool of MODEL_TOOLS) {\n      server.registerTool(\n        tool.name,\n        { description: tool.description, inputSchema: tool.inputSchema },\n        (args: Parameters<typeof tool.handler>[0]) =>\n          startActiveSpan(\n            `mcp.tool.${tool.name}`,\n            async (span) => {\n              const result = await tool.handler(args);\n              if (isTelemetryEnabled && result?.isError) {\n                const firstContent = result.content?.[0];\n                const message =\n                  firstContent?.type === \"text\" ? firstContent.text : \"Tool returned an error\";\n                span.setStatus({ code: 2, message });\n              }\n              return result;\n            },\n            { \"mcp.tool.name\": tool.name }\n          )\n      );\n    }\n  }\n}\n"],
+  "mappings": "AAiBA,SAAS,oBAAoB,uBAAuB;AACpD,SACE,sBACA,sBACA,mBACA,oBACA,qBACA,sBACA,mBACA,mBACA,gBACA,gBACA,cACA,iBACA,iBACA,eACA,eACA,iBACA,iBACA,eACA,gBACA,gBACA,iBACA,yBAEK;AAEP,MAAM,cAAmC;EACvC;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;EACA;;AAGI,MAAO,gBAAe;;EAE1B,YAAY,QAAiB;AAC3B,eAAW,QAAQ;AACjB,aAAO,aACL,KAAK,MACL,EAAE,aAAa,KAAK,aAAa,aAAa,KAAK,YAAW,GAC9D,CAAC,SACC,gBACE,YAAY,KAAK,IAAI,IACrB,OAAO,SAAQ;AACb,cAAM,SAAS,MAAM,KAAK,QAAQ,IAAI;AACtC,YAAI,sBAAsB,QAAQ,SAAS;AACzC,gBAAM,eAAe,OAAO,UAAU,CAAC,GACjC,UACJ,cAAc,SAAS,SAAS,aAAa,OAAO;AACtD,eAAK,UAAU,EAAE,MAAM,GAAG,QAAO,CAAE;QACrC;AACA,eAAO;MACT,GACA,EAAE,iBAAiB,KAAK,KAAI,CAAE,CAC/B;EAGT;;",
+  "names": []
+}

package/dist/mcp/tools/annotation-create.js

@@ -0,0 +1,39 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { findElementLayer } from "../../utils/element-utils.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationAuthorSchema, annotationContentSchema, annotationTagsSchema, elementIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  elementId: elementIdSchema,
+  content: annotationContentSchema,
+  author: annotationAuthorSchema,
+  tags: annotationTagsSchema,
+  rootPath: rootPathSchema
+};
+async function annotationCreateHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath);
+    if (!await findElementLayer(model, args.elementId))
+      throw new CLIError(`Element ${args.elementId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "model_search" to find similar elements'
+      ]);
+    const annotation = await new AnnotationStore(model.rootPath).create({
+      elementId: args.elementId,
+      content: args.content,
+      author: args.author,
+      tags: args.tags
+    });
+    return jsonResult(annotation);
+  });
+}
+const annotationCreateTool = {
+  name: "annotation_create",
+  description: "Create a new annotation on a model element.",
+  inputSchema,
+  handler: annotationCreateHandler
+};
+export {
+  annotationCreateHandler,
+  annotationCreateTool
+};
+//# sourceMappingURL=annotation-create.js.map

package/dist/mcp/tools/annotation-create.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-create.ts"],
+  "sourcesContent": ["/**\n * annotation_create \u2014 create a new annotation on a model element. Mirrors\n * `POST /api/annotations` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport {\n  annotationAuthorSchema,\n  annotationContentSchema,\n  annotationTagsSchema,\n  elementIdSchema,\n} from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  elementId: elementIdSchema,\n  content: annotationContentSchema,\n  author: annotationAuthorSchema,\n  tags: annotationTagsSchema,\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationCreateArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationCreateHandler(args: AnnotationCreateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n\n    const layerName = await findElementLayer(model, args.elementId);\n    if (!layerName) {\n      throw new CLIError(`Element ${args.elementId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    const store = new AnnotationStore(model.rootPath);\n    const annotation = await store.create({\n      elementId: args.elementId,\n      content: args.content,\n      author: args.author,\n      tags: args.tags,\n    });\n\n    return jsonResult(annotation);\n  });\n}\n\nexport const annotationCreateTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_create\",\n  description: \"Create a new annotation on a model element.\",\n  inputSchema,\n  handler: annotationCreateHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AACjC,SAAS,UAAU,qBAAqB;AACxC,SACE,wBACA,yBACA,sBACA,uBACK;AACP,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,WAAW;EACX,SAAS;EACT,QAAQ;EACR,MAAM;EACN,UAAU;;AAKZ,eAAsB,wBAAwB,MAA0B;AACtE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ;AAG3C,QAAI,CADc,MAAM,iBAAiB,OAAO,KAAK,SAAS;AAE5D,YAAM,IAAI,SAAS,WAAW,KAAK,SAAS,cAAc,cAAc,WAAW;QACjF;OACD;AAIH,UAAM,aAAa,MADL,IAAI,gBAAgB,MAAM,QAAQ,EACjB,OAAO;MACpC,WAAW,KAAK;MAChB,SAAS,KAAK;MACd,QAAQ,KAAK;MACb,MAAM,KAAK;KACZ;AAED,WAAO,WAAW,UAAU;EAC9B,CAAC;AACH;AAEO,MAAM,uBAA8D;EACzE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}