specrails-desktop 2.16.0 → 2.17.0

package/docs/mcp.md

@@ -0,0 +1,249 @@
+# The Specrails MCP server
+
+Specrails Desktop can expose itself to **any MCP client** — Claude Desktop,
+Claude Code, Cursor, or your own agent — as a local
+[Model Context Protocol](https://modelcontextprotocol.io) server. Turn it on
+and an external LLM can drive the whole dashboard: list your projects, read and
+create specs, launch the AI pipeline, watch jobs settle, inspect analytics, and
+more — through ~18 well-described tools instead of clicking around the UI.
+
+> **Just want to get going?** Open **Settings ▸ MCP**, flip **Enable MCP** on,
+> click **Copy client config**, and paste it into your MCP client. By default
+> only **read** actions are allowed; turn on the **Write** / **AI-spawn** /
+> **Destructive** tiers when you want the agent to actually change things or
+> spend money. Everything below is detail for when you need it.
+
+This is the **app talking to an outside agent** — the opposite direction from
+the [Serena plugin](running-pipelines.md#plugins) or
+`codex mcp add`, where Specrails *consumes* an MCP server. Here Specrails *is*
+the server.
+
+The MCP server is **off by default** and entirely local: it listens only on
+loopback (`127.0.0.1`), is authenticated by a token separate from the app's
+master token, and serves nothing until you explicitly enable it in Settings.
+
+## What the MCP exposes
+
+When enabled, the server registers a compact catalog of **domain-facade tools**
+plus a few **meta tools**, a set of read-only **resources**, and a self-contained
+**guide** an LLM can read to learn the platform with no prior knowledge.
+
+### Tools (~18)
+
+Each domain is a single tool with an `action` enum, rather than dozens of
+narrow tools — so the catalog stays small and an agent discovers actions by
+reading one description. The tools are:
+
+| Tool | What it covers |
+|---|---|
+| `specrails_projects` | List / resolve projects; unregister (destructive) |
+| `specrails_specs` | The spec/ticket backlog: list, get, create, update, delete, drafts, AI generate, AI-edit, Contract Refine, SMASH, per-ticket spend |
+| `specrails_rails` | Assign tickets to a rail, configure it, and launch the pipeline |
+| `specrails_jobs` | Inspect, stream, and stop pipeline jobs |
+| `specrails_chat` | Explore / sidebar chat conversations and turns |
+| `specrails_agents` | Agent profiles and the agents catalog (Claude-only features) |
+| `specrails_plugins` | The per-project plugin marketplace (install / verify / uninstall) |
+| `specrails_jira` | The Jira integration (connect, sync, outbox) |
+| `specrails_loops` | Saved loop workflows |
+| `specrails_code` | The read-only code explorer (tree, file, summaries, provenance) |
+| `specrails_setup` | Add-project setup wizard surface |
+| `specrails_analytics` | Per-project spending analytics + budget |
+| `specrails_settings` | App-level settings |
+| `specrails_watch` | Await the real result of an async (cost-incurring) action |
+| `specrails_guide` | Returns the platform guide — read this first |
+| `specrails_search` | Find the right tool/action for an intent |
+| `specrails_describe` | Full description + input schema for a named tool |
+| `specrails_select_project` | Set an active project so later calls can omit `projectId` |
+
+Almost every domain tool is **project-scoped** and takes a `projectId`. Calling
+`specrails_select_project` first lets later calls omit it.
+
+### Resources
+
+Read-only state is also exposed as MCP **resources** so a client can fetch it
+without a tool call:
+
+- `specrails://guide` — the platform guide (concepts, workflow, invariants).
+- `specrails://projects` — all registered projects.
+- `specrails://projects/{projectId}` — a single project.
+
+### Async results — `specrails_watch`
+
+Cost-incurring and streaming actions (launch a rail, generate a spec, send a
+chat turn, AI-edit, Contract Refine, SMASH) **return immediately** with a
+reference (a `jobId` / `requestId`) and emit their **real** result over the
+app's WebSocket bus. An agent gets the actual outcome by calling
+`specrails_watch` with that reference; it waits for the operation to settle and
+returns the final result. Don't assume success from the acceptance alone — this
+is spelled out in `specrails_guide`.
+
+## The four permission tiers
+
+Every tool declares one tier. The server refuses any tool whose tier is not
+enabled, and the refusal **names the tier the user must turn on** so the agent
+can relay it rather than retrying blindly. The tiers are **opt-in and
+cumulative** — read is always on, the rest are off until you enable them in
+**Settings ▸ MCP**:
+
+| Tier | Default | What it allows |
+|---|---|---|
+| **Read** | Always on | Queries + resources (list specs, read analytics, inspect jobs) |
+| **Write** | Off | Mutating but non-destructive, non-spawn: create/edit specs, change settings, configure a rail |
+| **AI-spawn** | Off | Actions that spawn an AI CLI and **cost money**: launch a rail, generate a spec, send a chat turn |
+| **Destructive** | Off | Delete data, kill processes, or mutate an external system (e.g. unregister a project, `smash_undo`, Jira writes) |
+
+The split is deliberate: a client you only half-trust can be left read-only;
+**destructive and cost-incurring actions are opt-in** and never happen by
+accident. A tool's tier is dynamic per action — e.g. `specrails_specs(list)` is
+read while `specrails_specs(delete)` is destructive — so the same tool exposes
+different actions at different trust levels.
+
+## Enabling it
+
+1. Open the app and go to **Settings ▸ MCP**.
+2. Toggle **Enable MCP**. This boots the embedded transport immediately — no
+   app restart. (Behind the scenes it persists `mcp_enabled` and starts serving
+   `/api/mcp`.)
+3. Enable the permission tiers you want (**Write** / **AI-spawn** /
+   **Destructive**). Leave them off to keep the agent read-only.
+4. Click **Copy client config** to grab a ready-to-paste configuration, or
+   **Copy token** if your client needs the raw token (for the direct-HTTP path
+   below).
+
+Toggling the enable switch off again tears down all open MCP sessions
+immediately.
+
+## Connecting a client
+
+There are two ways to connect, and **the stdio bridge is the recommended,
+universal one.**
+
+### Option A — the stdio bridge `specrails-mcp` (recommended)
+
+Most MCP clients (Claude Desktop, Claude Code, Cursor) speak MCP over **stdio**:
+they launch a command and talk to it on stdin/stdout. Specrails ships a tiny
+relay, **`specrails-mcp`**, bundled with the app. It transparently forwards MCP
+stdio from your client to the embedded HTTP server on loopback — and it reads
+the scoped token from `~/.specrails/mcp.token` **locally**, so the token never
+appears in your client's config file.
+
+A typical client config looks like:
+
+```json
+{
+  "mcpServers": {
+    "specrails": {
+      "command": "specrails-mcp"
+    }
+  }
+}
+```
+
+Use the exact command/path from the panel's **Copy client config** button — it
+fills in the path to the bundled bridge for your platform. No token, no URL, no
+port to manage; the bridge handles all of it. If the Specrails app isn't
+running, the bridge replies with a clear *"Specrails app is not running. Start
+the Specrails Desktop app, then retry."* rather than a cryptic connection error.
+
+### Option B — the direct HTTP URL (remote-HTTP clients)
+
+Clients that speak MCP's **streamable-HTTP** transport directly can skip the
+bridge and connect to:
+
+```
+http://127.0.0.1:4200/api/mcp
+```
+
+with the scoped token as a bearer header:
+
+```
+Authorization: Bearer <your mcp token>
+```
+
+Get the token from **Settings ▸ MCP ▸ Copy token** (or read
+`~/.specrails/mcp.token`). The endpoint is **loopback-only** — it rejects any
+request that doesn't originate from `127.0.0.1`, so this path is for local
+HTTP-capable clients, not for exposing Specrails on a network. (`4200` is the
+default app port; if you've changed it, the panel's config reflects the real
+one.)
+
+## Security model
+
+- **A scoped token, not the master token.** The MCP surface is authenticated by
+  its own token at `~/.specrails/mcp.token` (mode `0600`), completely separate
+  from the app's all-powerful master token (`~/.specrails/desktop.token`). The
+  master token grants terminals (shell), arbitrary AI-CLI spawns, and project
+  admin; handing that to a third-party MCP client would be a security smell. The
+  scoped token only reaches the four tiered surfaces above. You can rotate it
+  any time with **Regenerate token** in Settings — the old token stops working
+  immediately.
+- **Loopback only.** Both the transport (`/api/mcp`) and the admin control plane
+  (`/api/mcp-admin`) require the request to come from `127.0.0.1`. There is no
+  network ingress; an MCP client must run on the same machine.
+- **Tiers, not blanket access.** Even with a valid token, an agent can only do
+  what the enabled tiers allow (read by default). High-risk actions stay opt-in.
+- **The app must be running.** The MCP server is embedded in the desktop app's
+  process — there is no standalone daemon. The Tauri shell keeps it alive even
+  when you close the main window: closing the window **minimizes to the system
+  tray / menu bar** and leaves the embedded server running, so your MCP client
+  stays connected. The server stops only when you choose **Exit** from the tray
+  menu (or the OS truly quits the app). If the app isn't running, the bridge
+  tells you to start it.
+
+## v1 limitations — what is *not* exposed
+
+The tool catalog deliberately leaves the highest-risk execution vectors out of
+v1. None of these are reachable over MCP:
+
+- **Terminal shell execution.** The built-in terminal panel runs arbitrary
+  shell commands; the MCP surface does **not** expose it. An agent cannot run
+  shell on your machine through Specrails.
+- **Browser capture.** No browser navigation / screenshot / capture tool.
+- **In-app file write.** The code explorer is **read-only** over MCP — there is
+  no source-file overwrite tool (`code_write_file`). An agent can read files and
+  AI-generated summaries, but cannot edit your code directly through MCP. (AI
+  *rails* still write code — that's the pipeline, gated behind the AI-spawn
+  tier — but there is no direct file-overwrite tool.)
+- **The prerequisite installer.** The `uv`/remote-script prerequisite installer
+  is not exposed, so an agent cannot trigger remote-script installs.
+- The global Claude marketplace / `~/.claude/settings.json` mutation is also
+  out of scope.
+
+These boundaries are intentional and may be revisited in a later version.
+
+## Troubleshooting
+
+**My client can't connect / "app is not running"** — start the Specrails
+Desktop app. The MCP server is embedded in the app process; it isn't a separate
+daemon. If the window is hidden, the app is still running in the tray/menu bar —
+look for the Specrails icon there. Only the tray **Exit** stops the server.
+
+**Every tool is refused with a "permission tier" message** — the action needs a
+tier you haven't enabled. Open **Settings ▸ MCP** and turn on **Write** /
+**AI-spawn** / **Destructive** as appropriate. Read-only actions work with no
+extra tiers.
+
+**`401 Unauthorized: invalid MCP token`** (direct-HTTP path) — the bearer token
+is wrong or stale. Re-copy it from **Settings ▸ MCP ▸ Copy token**, or
+**Regenerate token** and update your client. The stdio bridge avoids this
+entirely (it reads the token locally).
+
+**The agent assumed a rail succeeded but it didn't** — cost-incurring actions
+return a reference, not a result. The agent must call `specrails_watch` with the
+returned `jobId`/`requestId` to get the real outcome. This is documented in
+`specrails_guide`; point the agent at it.
+
+**Connection refused on `:4200`** — that's the default app port. If you changed
+the port in Settings, use the URL from **Copy client config**, which reflects
+the real port. The bridge resolves the port automatically.
+
+## See also
+
+- [Running pipelines](running-pipelines.md) — what rails, jobs, and the
+  pipeline an MCP client drives actually do.
+- [Creating specs](creating-specs.md) — specs, drafts, SMASH, and Contract
+  Refine, all reachable via `specrails_specs`.
+- [Tracking cost](tracking-cost.md) — the analytics an agent reads via
+  `specrails_analytics`.
+- [Customising the app](customizing.md) — other settings, including the budget
+  the AI-spawn tier respects.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "specrails-desktop",
-  "version": "2.16.0",
+  "version": "2.17.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -24,15 +24,16 @@
     "dev:server": "tsx watch server/index.ts",
     "dev:client": "cd client && npm run dev",
     "dev:desktop": "tauri dev",
-    "build:server": "node -e \"require('fs').rmSync('server/dist',{recursive:true,force:true})\" && tsc --project tsconfig.json",
+    "build:server": "node -e \"require('fs').rmSync('server/dist',{recursive:true,force:true})\" && tsc --project tsconfig.build.json --noCheck",
     "build:cli": "tsc --project tsconfig.cli.json",
     "build": "npm run build:server && cd client && npm run build && cd .. && npm run build:cli",
     "build:sidecar": "node scripts/build-sidecar.mjs",
-    "build:desktop": "npm run build:server && cd client && npm run build && cd .. && npm run build:sidecar && tauri build",
+    "build:mcp-bridge": "node scripts/build-mcp-bridge.mjs",
+    "build:desktop": "npm run build:server && cd client && npm run build && cd .. && npm run build:sidecar && npm run build:mcp-bridge && tauri build",
     "assemble-runtimes": "node scripts/assemble-runtimes-local.mjs",
     "build:desktop:local": "npm run assemble-runtimes && npm run build:desktop",
     "generate-icons": "tauri icon src-tauri/icons/icon.svg",
-    "typecheck": "tsc --noEmit && tsc -p tsconfig.cli.json --noEmit && cd client && tsc --noEmit",
+    "typecheck": "tsc --noEmit && tsc -p tsconfig.cli.json --noEmit && tsc -p mcp-bridge/tsconfig.json --noEmit && cd client && tsc --noEmit",
     "check-core-compat": "tsx scripts/check-core-compat.ts",
     "test": "vitest run && tsx scripts/check-core-compat.ts",
     "test:watch": "vitest",
@@ -42,6 +43,7 @@
     "ci": "npm run typecheck && npm run check-core-compat && npm run test:coverage && cd client && npm run test:coverage"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "@tailwindcss/typography": "^0.5.19",
     "ajv": "^8.17.1",
     "better-sqlite3": "^12.8.0",
@@ -57,7 +59,8 @@
     "selfsigned": "^5.5.0",
     "tree-kill": "^1.2.2",
     "werift": "^0.23.0",
-    "ws": "^8.16.0"
+    "ws": "^8.16.0",
+    "zod": "^3.25.76"
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2.0.0",

package/server/dist/index.js

@@ -23,6 +23,7 @@ const terminal_manager_1 = require("./terminal-manager");
 const terminal_shell_integration_1 = require("./terminal-shell-integration");
 const feature_flags_1 = require("./feature-flags");
 const mobile_1 = require("./mobile");
+const mcp_1 = require("./mcp");
 const browser_playwright_1 = require("./browser-playwright");
 const telemetry_receiver_1 = require("./telemetry-receiver");
 const telemetry_compactor_1 = require("./telemetry-compactor");
@@ -150,6 +151,20 @@ app.use(corsMiddleware);
 // 12mb limit FIRST — once it sets req._body the global parser below no-ops for
 // these paths. (The actual /otlp router still requires loopback.)
 app.use('/otlp', express_1.default.json({ limit: '12mb' }));
+// ─── MCP streamable-HTTP transport (design D1) ───────────────────────────────
+// Mounted BEFORE the global express.json so it claims `/api/mcp` with a larger
+// body limit (req._body makes the global parser no-op for this path), and
+// BEFORE `app.use('/api', requireAuth)` so it uses the SCOPED mcp token via
+// requireMcpAuth rather than inheriting the all-powerful master token. The
+// dispatcher delegates to the McpServerManager constructed during Super-mode
+// bootstrap (lazily referenced — it exists by request time).
+app.use('/api/mcp', express_1.default.json({ limit: '4mb' }), auth_1.requireLoopback, mcp_1.requireMcpAuth, (req, res) => {
+    if (_mcpManager) {
+        void _mcpManager.handleHttp(req, res);
+        return;
+    }
+    res.status(503).json({ jsonrpc: '2.0', error: { code: -32000, message: 'MCP transport not ready' }, id: null });
+});
 app.use(express_1.default.json({ limit: '1mb' }));
 const server = http_1.default.createServer(app);
 const wsServerOptions = {
@@ -219,6 +234,7 @@ let _getProjectCount = () => 0;
 let _registry = null;
 /** The mobile companion gateway (off by default); torn down on shutdown. */
 let _mobileGateway = null;
+let _mcpManager = null;
 server.on('upgrade', (request, socket, head) => {
     const urlStr = request.url ?? '/';
     const auth = authorizeUpgrade(request);
@@ -507,6 +523,19 @@ function applyPtyWsRateLimiting(ws) {
     if (mobileGateway.isEnabledSetting()) {
         mobileGateway.start().catch((err) => console.error('[mobile-gateway] boot start failed:', err));
     }
+    // ─── Embedded MCP server (the /api/mcp transport mounted above) ─────────────
+    const mcpManager = new mcp_1.McpServerManager({ registry, broadcast, desktopPort: port, version: PKG_VERSION });
+    _mcpManager = mcpManager;
+    // Loopback + master-token control plane for the Settings ▸ MCP panel.
+    app.use('/api/mcp-admin', auth_1.requireLoopback, (0, mcp_1.createMcpAdminRouter)({
+        manager: mcpManager,
+        desktopDb: registry.desktopDb,
+        desktopPort: port,
+        broadcast,
+    }));
+    if (mcpManager.isEnabledSetting()) {
+        mcpManager.start().catch((err) => console.error('[mcp] boot start failed:', err));
+    }
     // App-level routes. CRITICAL mount order: the desktop router is mounted at
     // '/api' BEFORE the project router below so its exact routes (e.g.
     // GET /api/projects, DELETE /api/projects/:id) are handled here, while
@@ -611,6 +640,7 @@ async function shutdown() {
     catch { /* ignore */ }
     try {
         await _mobileGateway?.stop();
+        await _mcpManager?.stop();
     }
     catch { /* ignore */ }
     try {

package/server/dist/mcp/guide.js

@@ -0,0 +1,82 @@
+"use strict";
+// The platform guide returned by the `specrails_guide` meta tool and the
+// `specrails://guide` resource. This is what lets an external LLM "understand
+// the platform" without prior knowledge. It is intentionally English (the LLM
+// consumes it); human-facing onboarding docs are localized separately.
+//
+// Keep this BYTE-STABLE where possible (no timestamps / live data) so MCP
+// clients that cache resources stay valid.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPECRAILS_GUIDE = void 0;
+exports.SPECRAILS_GUIDE = `# Specrails Desktop — Agent Guide
+
+You are operating Specrails Desktop through its MCP server. Specrails is a local
+dashboard + pipeline runner that manages multiple software projects and drives AI
+coding agents (Claude Code, Codex, Gemini) to implement specs.
+
+## Core concepts
+
+- **Project**: a registered repository. Almost every tool is project-scoped and
+  takes a \`projectId\`. Use \`specrails_select_project\` to set an active project so
+  you can omit \`projectId\` on later calls; pass an explicit \`projectId\` to override.
+- **Spec / ticket**: a unit of work in a project's backlog. Statuses: \`draft\`,
+  \`todo\`, \`in_progress\`, \`done\`, \`cancelled\`. Priorities: \`critical\`, \`high\`,
+  \`medium\`, \`low\`. INVARIANT: priority may be null ONLY when status is \`draft\`.
+- **Rail**: a launch slot that runs the AI pipeline over one or more assigned
+  tickets. Modes: \`implement\`, \`batch-implement\`, \`ultracode\`, \`loop\`. Launching a
+  rail spawns AI CLI processes that write code, run tests and commit — it costs
+  money and runs for minutes.
+- **Job**: one spawned pipeline run. Jobs stream logs/events over the WebSocket
+  and settle (completed/failed/canceled). Cost is authoritative for Claude and
+  estimated for Codex/Gemini.
+- **Profile**: a per-project agent configuration (which agents, which models,
+  routing). Profiles are CLAUDE-ONLY; they are ignored for Codex/Gemini rails.
+- **Provider / engine**: claude, codex, or gemini. A project installs one or
+  more. A requested provider must be one of the project's installed providers.
+- **Loop**: a saved, app-driven workflow graph runnable on a rail in \`loop\` mode.
+- **Plugin**: an MCP-based integration installed per project (e.g. serena).
+
+## Async results (IMPORTANT)
+
+Cost-incurring / streaming actions (launch a rail, generate a spec, send a chat
+turn, refine an agent, SMASH) return immediately with a reference (jobId /
+requestId) and emit their REAL result over the WebSocket bus. To get the actual
+outcome, call \`specrails_watch\` with the returned reference; it waits for the
+operation to settle and returns the final result. Do not assume success from the
+acceptance alone.
+
+## Permission tiers
+
+The server enforces four opt-in tiers, configured by the user in Settings ▸ MCP:
+- **Read** (always on): queries + resources.
+- **Write**: create/edit specs, settings, rail config.
+- **AI-spawn**: actions that spawn an AI CLI and cost money.
+- **Destructive**: delete data, kill processes, mutate external systems.
+
+If a tool is refused, the error names the tier the user must enable. Relay that
+to the user rather than retrying blindly.
+
+## Claude-only features
+
+Agent profiles, Contract Refine, and SMASH are Claude-only. They are unavailable
+(and rejected) on projects whose selected provider is Codex or Gemini.
+
+## Typical workflow
+
+1. \`specrails_projects(list)\` → pick a project; \`specrails_select_project\`.
+2. \`specrails_specs(list)\` → inspect the backlog. To ADD a spec from a user
+   request, use \`specrails_specs(action:'create')\` — it routes through **Quick
+   Add Spec**: the specrails agent generates a structured spec with AI from the
+   request, exactly like the app's "Add Spec" button (so MCP-created specs are
+   indistinguishable from UI-created ones). It is async — watch the returned ref
+   with \`specrails_watch\`. Use \`from_prompt\` only to store a finished spec verbatim.
+3. \`specrails_rails(set_tickets)\` then \`specrails_rails(launch)\` → run the pipeline;
+   \`specrails_watch\` the returned jobId.
+4. \`specrails_analytics(spending)\` → review cost.
+
+## Resources
+
+Read-only state is also exposed as MCP resources: \`specrails://projects\`,
+\`specrails://projects/{id}/tickets\`, \`specrails://projects/{id}/rails\`,
+\`specrails://projects/{id}/analytics\`, and \`specrails://guide\` (this document).
+`;

package/server/dist/mcp/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildToolSpecs = exports.TIER_SETTING_KEY = exports.MCP_ENABLED_KEY = exports.MCP_TIERS = exports.isTierEnabled = exports.isMcpEnabled = exports._resetMcpTokenForTest = exports.loadOrGenerateMcpToken = exports.regenerateMcpToken = exports.getMcpToken = exports.requireMcpAuth = exports.createMcpAdminRouter = exports.McpServerManager = void 0;
+var mcp_server_1 = require("./mcp-server");
+Object.defineProperty(exports, "McpServerManager", { enumerable: true, get: function () { return mcp_server_1.McpServerManager; } });
+var mcp_admin_router_1 = require("./mcp-admin-router");
+Object.defineProperty(exports, "createMcpAdminRouter", { enumerable: true, get: function () { return mcp_admin_router_1.createMcpAdminRouter; } });
+var mcp_token_1 = require("./mcp-token");
+Object.defineProperty(exports, "requireMcpAuth", { enumerable: true, get: function () { return mcp_token_1.requireMcpAuth; } });
+Object.defineProperty(exports, "getMcpToken", { enumerable: true, get: function () { return mcp_token_1.getMcpToken; } });
+Object.defineProperty(exports, "regenerateMcpToken", { enumerable: true, get: function () { return mcp_token_1.regenerateMcpToken; } });
+Object.defineProperty(exports, "loadOrGenerateMcpToken", { enumerable: true, get: function () { return mcp_token_1.loadOrGenerateMcpToken; } });
+Object.defineProperty(exports, "_resetMcpTokenForTest", { enumerable: true, get: function () { return mcp_token_1._resetMcpTokenForTest; } });
+var mcp_tiers_1 = require("./mcp-tiers");
+Object.defineProperty(exports, "isMcpEnabled", { enumerable: true, get: function () { return mcp_tiers_1.isMcpEnabled; } });
+Object.defineProperty(exports, "isTierEnabled", { enumerable: true, get: function () { return mcp_tiers_1.isTierEnabled; } });
+Object.defineProperty(exports, "MCP_TIERS", { enumerable: true, get: function () { return mcp_tiers_1.MCP_TIERS; } });
+Object.defineProperty(exports, "MCP_ENABLED_KEY", { enumerable: true, get: function () { return mcp_tiers_1.MCP_ENABLED_KEY; } });
+Object.defineProperty(exports, "TIER_SETTING_KEY", { enumerable: true, get: function () { return mcp_tiers_1.TIER_SETTING_KEY; } });
+var catalog_1 = require("./tools/catalog");
+Object.defineProperty(exports, "buildToolSpecs", { enumerable: true, get: function () { return catalog_1.buildToolSpecs; } });

package/server/dist/mcp/mcp-admin-router.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpAdminRouter = createMcpAdminRouter;
+const express_1 = require("express");
+const mcp_token_1 = require("./mcp-token");
+const desktop_db_1 = require("../desktop-db");
+const mcp_tiers_1 = require("./mcp-tiers");
+function tierState(db) {
+    return {
+        write: (0, mcp_tiers_1.isTierEnabled)(db, 'write'),
+        aiSpawn: (0, mcp_tiers_1.isTierEnabled)(db, 'ai-spawn'),
+        destructive: (0, mcp_tiers_1.isTierEnabled)(db, 'destructive'),
+    };
+}
+function redact(token) {
+    return token.length > 4 ? `…${token.slice(-4)}` : '…';
+}
+function createMcpAdminRouter(deps) {
+    const router = (0, express_1.Router)();
+    const { manager, desktopDb, desktopPort } = deps;
+    router.get('/status', (_req, res) => {
+        res.json({ ...manager.status(), tiers: tierState(desktopDb), tokenHint: redact((0, mcp_token_1.getMcpToken)()) });
+    });
+    router.post('/enable', async (_req, res) => {
+        try {
+            res.json(await manager.setEnabled(true));
+        }
+        catch (err) {
+            res.status(409).json({ error: err instanceof Error ? err.message : 'Failed to enable MCP' });
+        }
+    });
+    router.post('/disable', async (_req, res) => {
+        res.json(await manager.setEnabled(false));
+    });
+    // Update the opt-in permission tiers (read is always on, not settable here).
+    router.patch('/tiers', (req, res) => {
+        const body = (req.body ?? {});
+        const fields = [
+            ['write', 'write'],
+            ['aiSpawn', 'ai-spawn'],
+            ['destructive', 'destructive'],
+        ];
+        for (const [bodyKey, tier] of fields) {
+            if (bodyKey in body) {
+                if (typeof body[bodyKey] !== 'boolean') {
+                    res.status(400).json({ error: `${bodyKey} must be a boolean` });
+                    return;
+                }
+                (0, desktop_db_1.setDesktopSetting)(desktopDb, mcp_tiers_1.TIER_SETTING_KEY[tier], body[bodyKey] ? 'true' : 'false');
+            }
+        }
+        res.json({ ok: true, tiers: tierState(desktopDb) });
+    });
+    // The full token — deliberately a separate loopback-only action so it never
+    // leaks through a general settings payload. Used by the panel's copy button.
+    router.get('/token', (_req, res) => {
+        res.json({ token: (0, mcp_token_1.getMcpToken)() });
+    });
+    router.post('/regenerate-token', (_req, res) => {
+        res.json({ token: (0, mcp_token_1.regenerateMcpToken)() });
+    });
+    // Connection info for the panel to render a ready-to-paste client config.
+    router.get('/config', (_req, res) => {
+        res.json({
+            httpUrl: `http://127.0.0.1:${desktopPort}/api/mcp`,
+            bridgeCommand: 'specrails-mcp',
+            hasToken: true,
+        });
+    });
+    return router;
+}