codetrellis 0.0.0-stage → 0.2.0

package/src/backend/mcp/server.js

@@ -0,0 +1,813 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  bindingSettled: () => bindingSettled,
+  enumerateRegisteredTools: () => enumerateRegisteredTools,
+  getMcpConfig: () => getMcpConfig,
+  getMcpSetup: () => getMcpSetup,
+  getMcpStatus: () => getMcpStatus,
+  listRegisteredToolArgs: () => listRegisteredToolArgs,
+  listRegisteredTools: () => listRegisteredTools,
+  setElectronScreenshotCapture: () => setElectronScreenshotCapture,
+  startMcpServer: () => startMcpServer,
+  stopMcpServer: () => stopMcpServer
+});
+module.exports = __toCommonJS(server_exports);
+var _lazy____services_stuck_sensor_service = __toESM(require("../services/stuck-sensor-service"));
+var import_capability_token = require("../services/capability-token");
+var _lazy____server = __toESM(require("../server"));
+var import_node_http = __toESM(require("node:http"));
+var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
+var import_sse = require("@modelcontextprotocol/sdk/server/sse.js");
+var import_database = require("../services/database");
+var import_server = require("../server");
+var import_diff_engine = require("../services/diff-engine");
+var planService = __toESM(require("../services/plan-service"));
+var commentService = __toESM(require("../services/comment-service"));
+var sessionService = __toESM(require("../services/session-service"));
+var import_binding_headers = require("./binding-headers");
+var import_folder_requests = require("../services/folder-requests");
+var import_awareness_notices = require("../services/awareness-notices");
+var import_awareness_replies = require("../services/awareness-replies");
+var import_spec_proposals_service = require("../services/spec-proposals-service");
+var import_planned_overlap_actions = require("../services/planned-overlap-actions");
+var import_workstream_binding = require("../services/workstream-binding");
+var import_workstream_service = require("../services/workstream-service");
+var import_node_url = require("node:url");
+var budgetService = __toESM(require("../services/budget-service"));
+var taskAttachmentsService = __toESM(require("../services/task-attachments-service"));
+var planItemService = __toESM(require("../services/plan-item-service"));
+var import_skill_model = require("../services/skill-model");
+var import_skill_arrival_service = require("../services/skill-arrival-service");
+var planEventService = __toESM(require("../services/plan-event-service"));
+var planChangesService = __toESM(require("../services/plan-changes-service"));
+var planFileService = __toESM(require("../services/plan-file-service"));
+var externalRefsService = __toESM(require("../services/external-refs-service"));
+var externalPointerService = __toESM(require("../services/external-pointer-service"));
+var systemDocsService = __toESM(require("../services/system-docs-service"));
+var terminalService = __toESM(require("../services/terminal-service"));
+var planImportService = __toESM(require("../services/plan-import-service"));
+var presenceService = __toESM(require("../services/presence-service"));
+var projectConfigService = __toESM(require("../services/project-config-service"));
+var import_criteria_service = require("../services/criteria-service");
+var import_criterion_loop_service = require("../services/criterion-loop-service");
+var import_artefact_service = require("../services/artefact-service");
+var import_artefact_watcher = require("../services/artefact-watcher");
+var import_brief_service = require("../services/brief-service");
+var import_reader_host = require("../services/material-reader/reader-host");
+var import_plan_templates_service = require("../services/plan-templates-service");
+var import_plan_templates = require("../services/plan-templates");
+var import_plan_template_publish_service = require("../services/plan-template-publish-service");
+var import_deviation_service = require("../services/deviation-service");
+var import_trellis_service = require("../services/trellis-service");
+var import_persistence = require("../services/persistence");
+var import_settings_service = require("../services/settings-service");
+var import_mcp_capabilities = require("../services/mcp-capabilities");
+var import_peer_capabilities = require("../services/peer-capabilities");
+var import_logger = require("../services/logger");
+var import_cross_system_service = require("../services/cross-system-service");
+var import_recent_projects_service = require("../services/recent-projects-service");
+var import_skill_guide = require("./skill-guide");
+var import_client_identity = require("./client-identity");
+var import_agent_event_log = require("../services/agent-event-log");
+var import_breakpoint_service = require("../services/breakpoint-service");
+var import_code_breakpoints = require("../services/code-breakpoints");
+var import_signal_breakpoints = require("../services/signal-breakpoints");
+var import_files = require("./connector/files");
+var import_command = require("./connector/command");
+var import_node_fs = __toESM(require("node:fs"));
+var import_reference_service = require("../services/reference-service");
+var import_architecture_tools = require("./tools/architecture-tools");
+var import_terminal_tools = require("./tools/terminal-tools");
+var import_graph_tools = require("./tools/graph-tools");
+var import_drift_tools = require("./tools/drift-tools");
+var import_ui_tools = require("./tools/ui-tools");
+var import_session_tools = require("./tools/session-tools");
+var import_plan_tools = require("./tools/plan-tools");
+var import_plan_item_tools = require("./tools/plan-item-tools");
+var import_presence_tools = require("./tools/presence-tools");
+var import_mobile_tools = require("./tools/mobile-tools");
+var import_project_config_tools = require("./tools/project-config-tools");
+var import_git_tools = require("./tools/git-tools");
+var import_channel_tools = require("./tools/channel-tools");
+var import_system_docs_tools = require("./tools/system-docs-tools");
+var import_governance_tools = require("./tools/governance-tools");
+var import_budget_tools = require("./tools/budget-tools");
+var import_intake_tools = require("./tools/intake-tools");
+var import_review_tools = require("./tools/review-tools");
+var import_contribution_tools = require("./tools/contribution-tools");
+var import_audio_tools = require("./tools/audio-tools");
+var import_peer_tools = require("./tools/peer-tools");
+var import_awareness_tools = require("./tools/awareness-tools");
+var import_test_tools = require("./tools/test-tools");
+var import_resources = require("./resources");
+const DEFAULT_MCP_PORT = 19432;
+const MAX_PORT_ATTEMPTS = 10;
+const MAX_MCP_CONNECTIONS = 20;
+const connectedServers = /* @__PURE__ */ new Map();
+let httpServer = null;
+let boundPort = DEFAULT_MCP_PORT;
+const connectedTransports = /* @__PURE__ */ new Map();
+const pendingResponses = /* @__PURE__ */ new Map();
+globalThis.__screenshotResolve = (nonce, data) => {
+  const pending = pendingResponses.get(nonce);
+  if (pending) {
+    clearTimeout(pending.timer);
+    pendingResponses.delete(nonce);
+    pending.resolve(data);
+  }
+};
+globalThis.__presenceResolve = (nonce, data) => {
+  const pending = pendingResponses.get(nonce);
+  if (!pending) return false;
+  clearTimeout(pending.timer);
+  pendingResponses.delete(nonce);
+  pending.resolve(data);
+  return true;
+};
+let electronScreenshotCapture;
+const pendingBindings = /* @__PURE__ */ new Map();
+function bindingSettled(sessionId, maxMs = 2e3) {
+  const pending = pendingBindings.get(sessionId);
+  if (!pending) return Promise.resolve();
+  let timer;
+  const giveUp = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      if (pendingBindings.get(sessionId) === pending) pendingBindings.delete(sessionId);
+      resolve();
+    }, maxMs);
+  });
+  return Promise.race([pending, giveUp]).finally(() => clearTimeout(timer));
+}
+function setElectronScreenshotCapture(captureFn) {
+  electronScreenshotCapture = captureFn;
+}
+function broadcastToolEvent(payload) {
+  let workstreamRoot;
+  try {
+    if (payload.sessionId) {
+      workstreamRoot = sessionService.getActiveSessions().find((s) => s.sessionId === payload.sessionId)?.workstreamRoot ?? void 0;
+    }
+  } catch {
+  }
+  (0, import_server.broadcast)("agent-event", {
+    id: (0, import_agent_event_log.eventId)("mcp-tool"),
+    timestamp: Date.now(),
+    source: "mcp",
+    type: payload.phase === "error" ? "tool_error" : "tool_call",
+    payload: workstreamRoot ? { ...payload, workstreamRoot } : payload
+  });
+  try {
+    const { recordToolCall } = _lazy____services_stuck_sensor_service;
+    recordToolCall({
+      tool: payload.tool,
+      args: payload.args,
+      phase: payload.phase,
+      sessionId: payload.sessionId,
+      error: payload.error
+    });
+  } catch {
+  }
+  try {
+    if (payload.sessionId) {
+      const session = sessionService.getActiveSessions().find((s) => s.sessionId === payload.sessionId);
+      budgetService.recordActivity({
+        sessionId: payload.sessionId,
+        planUid: session?.activePlanUid ?? null,
+        agentType: payload.agentType,
+        agentModel: payload.agentModel
+      });
+    }
+  } catch {
+  }
+}
+function summarizeArgs(args) {
+  if (args == null) return "";
+  try {
+    const json = JSON.stringify(args);
+    return json.length > 240 ? json.slice(0, 240) + "\u2026" : json;
+  } catch {
+    return "[unserializable]";
+  }
+}
+function inferAgentFromSession(sessionId) {
+  if (!sessionId) return { type: "mcp-agent", model: null };
+  const sessions = sessionService.getActiveSessions();
+  const match = sessions.find((s) => s.sessionId === sessionId);
+  if (!match) return { type: "mcp-agent", model: null };
+  return { type: match.agentType ?? "mcp-agent", model: match.model ?? null };
+}
+function buildToolDeps(sessionId) {
+  return {
+    broadcast: import_server.broadcast,
+    pendingResponses,
+    sessionId,
+    // Service modules
+    planService,
+    // Items as an agent reads them: a skill's `link` location is for people only (Phase 32 C1).
+    // …and a skill that arrived in a plan file stays out until a person accepts it (C1.4).
+    planItemService: (0, import_skill_model.agentView)(planItemService, (itemUid, skill) => (0, import_skill_arrival_service.pendingArrivals)(itemUid).has(skill)),
+    commentService,
+    sessionService,
+    taskAttachmentsService,
+    planEventService,
+    planFileService,
+    planChangesService,
+    externalRefsService,
+    externalPointerService,
+    systemDocsService,
+    terminalService,
+    planImportService,
+    presenceService,
+    projectConfigService,
+    // An agent's view of criteria only — see ToolDeps.criteriaService.
+    criteriaService: { listCriteria: import_criteria_service.listCriteria, getCriterion: import_criteria_service.getCriterion, addCriterionAsAgent: import_criteria_service.addCriterionAsAgent, CriterionError: import_criteria_service.CriterionError },
+    criterionLoop: { checkCriterion: import_criterion_loop_service.checkCriterion, submitChecked: import_criterion_loop_service.submitChecked, getWorklist: import_criterion_loop_service.getWorklist, runCheckRun: import_criterion_loop_service.runCheckRun, testsOlderThanCode: import_criterion_loop_service.testsOlderThanCode },
+    artefactService: { recordArtefact: import_artefact_service.recordArtefact, refreshArtefactHashes: import_artefact_service.refreshArtefactHashes, listArtefacts: import_artefact_service.listArtefacts, getArtefact: import_artefact_service.getArtefact, ArtefactError: import_artefact_service.ArtefactError },
+    startArtefactWatching: import_artefact_watcher.startArtefactWatching,
+    briefService: { getBrief: import_brief_service.getBrief, listMaterials: import_brief_service.listMaterials, skillsBlock: import_brief_service.skillsBlock },
+    readMaterial: import_reader_host.readMaterial,
+    // Specific functions
+    applyTemplate: import_plan_templates_service.applyTemplate,
+    listTemplates: import_plan_templates.listTemplates,
+    publishPlanAsTemplate: import_plan_template_publish_service.publishPlanAsTemplate,
+    getDeviations: import_deviation_service.getDeviations,
+    resolveDeviation: import_deviation_service.resolveDeviation,
+    reconcileDeviations: import_deviation_service.reconcileDeviations,
+    DeviationError: import_deviation_service.DeviationError,
+    detectDeviations: import_deviation_service.detectDeviations,
+    captureCurrentTrellis: import_trellis_service.captureCurrentTrellis,
+    listSnapshots: import_trellis_service.listSnapshots,
+    computeTrellisDiff: import_trellis_service.computeTrellisDiff,
+    saveNow: import_persistence.saveNow,
+    exportDatabase: import_database.exportDatabase,
+    searchSymbols: import_database.searchSymbols,
+    getDependencyEdges: import_database.getDependencyEdges,
+    getFileDependencies: import_database.getFileDependencies,
+    getDbStats: import_database.getDbStats,
+    getDb: import_database.getDb,
+    listCrossSystemEdges: import_cross_system_service.listCrossSystemEdges,
+    getCrossSystemStats: import_cross_system_service.getCrossSystemStats,
+    listRecentProjects: import_recent_projects_service.listRecentProjects,
+    removeRecentProject: import_recent_projects_service.removeRecentProject,
+    setRecentProjectPinned: import_recent_projects_service.setRecentProjectPinned,
+    setProjectAlias: import_recent_projects_service.setProjectAlias,
+    refreshProjectOriginUrl: import_recent_projects_service.refreshProjectOriginUrl,
+    getRecentProject: import_recent_projects_service.getRecentProject,
+    findRecentProjectByOriginUrl: import_recent_projects_service.findRecentProjectByOriginUrl,
+    getSettings: import_settings_service.getSettings,
+    updateSettings: import_settings_service.updateSettings,
+    tailLog: import_logger.tailLog,
+    getCurrentLogPath: import_logger.getCurrentLogPath,
+    getLogDir: import_logger.getLogDir,
+    getBoundBackendPort: import_server.getBoundBackendPort,
+    scanProject: import_server.scanProject,
+    getActiveProjectPath: import_server.getActiveProjectPath,
+    pinBaseline: import_server.pinBaseline,
+    BaselineError: import_server.BaselineError,
+    clearBaseline: import_diff_engine.clearBaseline,
+    buildSkillGuide: import_skill_guide.buildSkillGuide,
+    captureElectronScreenshot: electronScreenshotCapture
+  };
+}
+function mcpProjectScope() {
+  try {
+    return (0, import_settings_service.getSettings)().mcp?.projectScope === "anywhere" ? "anywhere" : "opened";
+  } catch {
+    return "opened";
+  }
+}
+function grantedMcpCapabilities() {
+  try {
+    const configured = (0, import_settings_service.getSettings)().mcp?.capabilities;
+    return Array.isArray(configured) ? configured : import_peer_capabilities.DEFAULT_GRANTS;
+  } catch {
+    return import_peer_capabilities.DEFAULT_GRANTS;
+  }
+}
+const REGISTERED_TOOLS = /* @__PURE__ */ new Set();
+function listRegisteredTools() {
+  return [...REGISTERED_TOOLS].sort();
+}
+const REGISTERED_TOOL_ARGS = /* @__PURE__ */ new Map();
+function listRegisteredToolArgs() {
+  return REGISTERED_TOOL_ARGS;
+}
+function setupMcpServerInstance(sessionId) {
+  const mcpServer = new import_mcp.McpServer(
+    { name: "codetrellis", version: "0.1.0" },
+    {
+      capabilities: {
+        tools: {},
+        resources: {}
+      },
+      instructions: "CodeTrellis provides codebase architecture analysis. Use these tools to understand how files connect, search for symbols, and report your plans."
+    }
+  );
+  const registerName = (name, schema) => {
+    REGISTERED_TOOLS.add(name);
+    REGISTERED_TOOL_ARGS.set(name, schema && typeof schema === "object" ? Object.keys(schema) : []);
+  };
+  const reached = /* @__PURE__ */ new Set();
+  const instrument = (name, handler) => async (args, extra) => {
+    const start = Date.now();
+    if (extra?.requestId !== void 0) reached.add(extra.requestId);
+    await bindingSettled(sessionId);
+    try {
+      sessionService.heartbeat(sessionId);
+    } catch {
+    }
+    const agentInfo = inferAgentFromSession(sessionId);
+    try {
+      (0, import_mcp_capabilities.assertMcpMayCall)(name, grantedMcpCapabilities());
+      args = (0, import_reference_service.resolveReferenceArgs)(args);
+      (0, import_mcp_capabilities.assertMcpProjectInScope)(name, args, mcpProjectScope());
+    } catch (err) {
+      if (err instanceof import_mcp_capabilities.McpAuthorizationError || err instanceof import_reference_service.AmbiguousReferenceError) {
+        console.warn(`[MCP]${err instanceof import_mcp_capabilities.McpAuthorizationError ? "[Authz] REFUSED" : " Ambiguous reference in"} ${name} \u2014 ${err.message}`);
+        broadcastToolEvent({
+          tool: name,
+          args: summarizeArgs(args),
+          phase: "error",
+          durationMs: 0,
+          sessionId,
+          agentType: agentInfo.type,
+          agentModel: agentInfo.model,
+          error: err.message
+        });
+      }
+      throw err;
+    }
+    try {
+      const result = await (0, import_agent_event_log.withEventContext)({ sessionId, agentType: agentInfo.type }, async () => {
+        const attempt = (0, import_signal_breakpoints.attemptOf)(name, args);
+        const bySignal = attempt ? (0, import_signal_breakpoints.enforceSignalsForSession)((0, import_server.getActiveProjectPath)(), sessionId, attempt) : { kind: "pass" };
+        if (bySignal.kind === "paused" || bySignal.kind === "stop") return (0, import_signal_breakpoints.signalHeldResult)(bySignal);
+        const held = (0, import_breakpoint_service.enforce)(name, args, { agent: agentInfo.type ?? "mcp-agent", sessionId });
+        if (held.kind === "paused") return (0, import_breakpoint_service.pausedResult)(held.hit);
+        if (held.kind === "stop") return (0, import_breakpoint_service.stoppedResult)(held.hit);
+        const out = await handler(args, extra);
+        const steers = [
+          bySignal.kind === "continue" && bySignal.steer ? (0, import_signal_breakpoints.signalSteerText)(bySignal.hit) : null,
+          held.kind === "continue" ? (0, import_breakpoint_service.steerText)(held.hit) : null
+        ].filter((x) => !!x);
+        if (steers.length && out && !out.isError && Array.isArray(out.content)) for (const text of steers) out.content.push({ type: "text", text });
+        return out;
+      });
+      if (result && !result.isError && Array.isArray(result.content)) {
+        const notice = (0, import_awareness_notices.noticeFor)(sessionId, name, (0, import_server.getActiveProjectPath)());
+        if (notice) result.content.push({ type: "text", text: notice });
+        const reply = (0, import_awareness_replies.replyNoticeFor)(sessionId, (0, import_server.getActiveProjectPath)());
+        if (reply) result.content.push({ type: "text", text: reply });
+        const breach = await (0, import_code_breakpoints.breachNoticeFor)(sessionId, (0, import_server.getActiveProjectPath)());
+        if (breach) result.content.push({ type: "text", text: breach });
+        const proposal = (0, import_spec_proposals_service.proposalNoticeFor)(sessionId, agentInfo.type ?? null, Date.now(), (itemUids) => (0, import_server.broadcast)("spec-proposal-told", { itemUids }));
+        if (proposal) result.content.push({ type: "text", text: proposal });
+        const planned = (0, import_planned_overlap_actions.plannedOverlapNoticeFor)(sessionId);
+        if (planned) result.content.push({ type: "text", text: planned });
+      }
+      const summary = result?._meta?.summary;
+      broadcastToolEvent({
+        tool: name,
+        args: summarizeArgs(args),
+        phase: "complete",
+        durationMs: Date.now() - start,
+        sessionId,
+        agentType: agentInfo.type,
+        agentModel: agentInfo.model,
+        ...typeof summary === "string" && !result?.isError ? { summary: summary.slice(0, 200) } : {}
+      });
+      return result;
+    } catch (err) {
+      broadcastToolEvent({
+        tool: name,
+        args: summarizeArgs(args),
+        phase: "error",
+        durationMs: Date.now() - start,
+        sessionId,
+        agentType: agentInfo.type,
+        agentModel: agentInfo.model,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      throw err;
+    }
+  };
+  const originalSetRequestHandler = mcpServer.server.setRequestHandler.bind(mcpServer.server);
+  mcpServer.server.setRequestHandler = (schema, handler) => {
+    const method = schema?.shape?.method?.value ?? schema?.shape?.method?._def?.value;
+    if (method !== "tools/call") return originalSetRequestHandler(schema, handler);
+    return originalSetRequestHandler(schema, async (request, extra) => {
+      const start = Date.now();
+      const id = extra?.requestId;
+      try {
+        const result = await handler(request, extra);
+        if (result?.isError && !reached.has(id)) {
+          const agentInfo = inferAgentFromSession(sessionId);
+          const text = Array.isArray(result.content) ? result.content.map((c) => typeof c?.text === "string" ? c.text : "").join(" ") : "";
+          broadcastToolEvent({
+            tool: String(request?.params?.name ?? "unknown"),
+            args: summarizeArgs(request?.params?.arguments ?? {}),
+            phase: "error",
+            durationMs: Date.now() - start,
+            sessionId,
+            agentType: agentInfo.type,
+            agentModel: agentInfo.model,
+            error: text.slice(0, 1e3) || "Refused by the MCP server before the tool ran."
+          });
+        }
+        return result;
+      } finally {
+        reached.delete(id);
+      }
+    });
+  };
+  const originalRegisterTool = mcpServer.registerTool.bind(mcpServer);
+  mcpServer.registerTool = (name, config, handler) => {
+    registerName(name, config?.inputSchema);
+    return originalRegisterTool(name, config, instrument(name, handler));
+  };
+  const originalTool = mcpServer.tool.bind(mcpServer);
+  mcpServer.tool = (...args) => {
+    const name = args[0];
+    const last = args.length - 1;
+    registerName(name, args.slice(1, last).find((a) => a && typeof a === "object" && !Array.isArray(a)));
+    const next = [...args];
+    next[last] = instrument(name, args[last]);
+    return originalTool(...next);
+  };
+  const deps = buildToolDeps(sessionId);
+  (0, import_architecture_tools.register)(mcpServer, deps);
+  (0, import_terminal_tools.register)(mcpServer, deps);
+  (0, import_graph_tools.register)(mcpServer, deps);
+  (0, import_drift_tools.register)(mcpServer, deps);
+  (0, import_ui_tools.register)(mcpServer, deps);
+  (0, import_session_tools.register)(mcpServer, deps);
+  (0, import_plan_tools.register)(mcpServer, deps);
+  (0, import_plan_item_tools.register)(mcpServer, deps);
+  (0, import_presence_tools.register)(mcpServer, deps);
+  (0, import_mobile_tools.register)(mcpServer, deps);
+  (0, import_project_config_tools.register)(mcpServer, deps);
+  (0, import_git_tools.register)(mcpServer, deps);
+  (0, import_channel_tools.register)(mcpServer, deps);
+  (0, import_system_docs_tools.register)(mcpServer, deps);
+  (0, import_governance_tools.register)(mcpServer, deps);
+  (0, import_test_tools.register)(mcpServer, deps);
+  (0, import_budget_tools.register)(mcpServer, deps);
+  (0, import_intake_tools.register)(mcpServer, deps);
+  (0, import_review_tools.register)(mcpServer, deps);
+  (0, import_contribution_tools.registerContributionTools)(mcpServer);
+  (0, import_audio_tools.registerAudioTools)(mcpServer);
+  (0, import_peer_tools.registerPeerTools)(mcpServer, deps);
+  (0, import_awareness_tools.register)(mcpServer, deps);
+  (0, import_resources.register)(mcpServer, deps);
+  return mcpServer;
+}
+function enumerateRegisteredTools() {
+  setupMcpServerInstance("tool-coverage-probe");
+  return listRegisteredTools();
+}
+async function startMcpServer() {
+  if (httpServer) return;
+  const app = import_node_http.default.createServer(async (req, res) => {
+    const hostHeader = (req.headers.host || "").toString().replace(/:\d+$/, "").toLowerCase();
+    if (hostHeader && !["127.0.0.1", "localhost", "[::1]", "::1"].includes(hostHeader)) {
+      res.writeHead(403, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error: "Host not allowed" }));
+      return;
+    }
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", `Content-Type, Authorization, ${import_capability_token.TOKEN_HEADER}`);
+    res.setHeader("Vary", "Origin");
+    if (req.method === "OPTIONS") {
+      res.writeHead(403);
+      res.end();
+      return;
+    }
+    const presented = (0, import_capability_token.extractToken)(
+      req.headers,
+      req.url
+    );
+    if (!(0, import_capability_token.verifyCapabilityToken)(presented)) {
+      res.writeHead(401, { "Content-Type": "application/json" });
+      res.end(
+        JSON.stringify({
+          error: "Missing or invalid capability token",
+          hint: `Send the token from ${(0, import_capability_token.getTokenFilePath)()} as the ${import_capability_token.TOKEN_HEADER} header, an Authorization: Bearer value, or the ct_token query parameter.`
+        })
+      );
+      return;
+    }
+    const pathname = (() => {
+      try {
+        return new URL(req.url ?? "/", "http://127.0.0.1").pathname;
+      } catch {
+        return req.url ?? "/";
+      }
+    })();
+    if (pathname === "/sse" && req.method === "GET") {
+      if (connectedTransports.size >= MAX_MCP_CONNECTIONS) {
+        console.warn(`[MCP] Connection limit reached (${MAX_MCP_CONNECTIONS}), rejecting new SSE client`);
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Too many MCP connections" }));
+        return;
+      }
+      const messagesEndpoint = `/messages?ct_token=${encodeURIComponent((0, import_capability_token.getCapabilityToken)())}`;
+      const transport = new import_sse.SSEServerTransport(messagesEndpoint, res);
+      const sessionId = transport.sessionId;
+      connectedTransports.set(sessionId, transport);
+      const mcpServer = setupMcpServerInstance(sessionId);
+      connectedServers.set(sessionId, mcpServer);
+      const inferredAgentType = req.headers["user-agent"]?.toString().split(" ")[0]?.toLowerCase().includes("claude") ? "claude-code" : "mcp-client";
+      sessionService.registerSession(sessionId, inferredAgentType);
+      const hint = (0, import_binding_headers.readBindingHeaders)(req.headers);
+      let bound = false;
+      try {
+        const root = (0, import_workstream_binding.matchWorkstreamRoot)(hint.cwd, (0, import_workstream_binding.candidateWorkstreamRoots)());
+        const terminal = hint.hostTerminal && terminalService.getTerminal(hint.hostTerminal) ? hint.hostTerminal : null;
+        if (root || terminal) sessionService.bindSession(sessionId, root, terminal);
+        bound = root !== null;
+        if (root) setImmediate(() => {
+          (0, import_workstream_service.discoverAround)(root).catch(() => {
+          });
+        });
+        if (!bound && hint.cwd && (0, import_server.getActiveProjectPath)()) {
+          (0, import_folder_requests.recordFolderRequest)({ folder: hint.cwd, sessionId, agentType: inferredAgentType });
+        }
+      } catch {
+      }
+      mcpServer.server.oninitialized = () => {
+        if (!bound && mcpServer.server.getClientCapabilities()?.roots) {
+          const lookup = mcpServer.server.listRoots().then(({ roots }) => {
+            const folders = roots.flatMap((r) => {
+              try {
+                return r.uri.startsWith("file:") ? [(0, import_node_url.fileURLToPath)(r.uri)] : [];
+              } catch {
+                return [];
+              }
+            });
+            const root = (0, import_workstream_binding.firstWorkstreamRoot)(folders);
+            if (!root) return;
+            sessionService.bindSession(sessionId, root);
+            (0, import_server.broadcast)("mcp-session-changed", { reason: "bound", sessionId });
+            setImmediate(() => {
+              (0, import_workstream_service.discoverAround)(root).catch(() => {
+              });
+            });
+          }).catch(() => {
+          }).finally(() => {
+            if (pendingBindings.get(sessionId) === lookup) pendingBindings.delete(sessionId);
+          });
+          pendingBindings.set(sessionId, lookup);
+        }
+        const claimed = (0, import_client_identity.agentTypeFromClientInfo)(mcpServer.server.getClientVersion()?.name);
+        if (!claimed || claimed === inferredAgentType) return;
+        try {
+          if (sessionService.retypeSession(sessionId, inferredAgentType, claimed)) {
+            console.log(`[MCP] Client ${sessionId} identified as ${claimed}`);
+            (0, import_server.broadcast)("mcp-session-changed", { reason: "identified", sessionId });
+          }
+        } catch {
+        }
+      };
+      const keepAlive = setInterval(() => {
+        try {
+          sessionService.heartbeat(sessionId);
+        } catch {
+        }
+      }, 3e4);
+      if (typeof keepAlive.unref === "function") keepAlive.unref();
+      res.on("close", () => {
+        clearInterval(keepAlive);
+        connectedTransports.delete(sessionId);
+        const sessionServer = connectedServers.get(sessionId);
+        if (sessionServer) {
+          sessionServer.close().catch(() => {
+          });
+          connectedServers.delete(sessionId);
+        }
+        sessionService.disconnectSession(sessionId);
+        console.log(`[MCP] Client disconnected: ${sessionId}`);
+        (0, import_server.broadcast)("agent-event", {
+          id: (0, import_agent_event_log.eventId)("mcp-disconnect"),
+          timestamp: Date.now(),
+          source: "mcp",
+          type: "session_end",
+          payload: { sessionId }
+        });
+        (0, import_server.broadcast)("mcp-session-changed", { reason: "disconnect" });
+      });
+      console.log(`[MCP] Client connected: ${sessionId} (${inferredAgentType})`);
+      (0, import_server.broadcast)("agent-event", {
+        id: (0, import_agent_event_log.eventId)("mcp-connect"),
+        timestamp: Date.now(),
+        source: "mcp",
+        type: "session_start",
+        payload: { sessionId, source: "mcp", agentType: inferredAgentType }
+      });
+      (0, import_server.broadcast)("mcp-session-changed", { reason: "connect" });
+      await mcpServer.connect(transport);
+      return;
+    }
+    if (pathname.startsWith("/messages") && req.method === "POST") {
+      const sessionId = new URL(req.url ?? "/", `http://localhost:${boundPort}`).searchParams.get("sessionId");
+      if (!sessionId || !connectedTransports.has(sessionId)) {
+        res.writeHead(404);
+        res.end("Session not found");
+        return;
+      }
+      const transport = connectedTransports.get(sessionId);
+      await transport.handlePostMessage(req, res);
+      return;
+    }
+    if (pathname === "/" || pathname === "/health") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({
+        name: "codetrellis-mcp",
+        version: "0.1.0",
+        connectedClients: connectedTransports.size
+      }));
+      return;
+    }
+    res.writeHead(404);
+    res.end("Not found");
+  });
+  httpServer = app;
+  const settings = (0, import_settings_service.getSettings)();
+  const envPort = process.env.CODETRELLIS_MCP_PORT;
+  const requestedPort = envPort ? Number(envPort) : settings.mcp.port ?? DEFAULT_MCP_PORT;
+  const autodetect = settings.mcp.autodetectOnCollision !== false && !envPort;
+  return new Promise((resolve, reject) => {
+    const tryPort = (candidate, attemptsLeft) => {
+      const onListening = () => {
+        app.removeListener("error", onError);
+        boundPort = candidate;
+        console.log(`[MCP] Server running on http://127.0.0.1:${boundPort}${candidate !== requestedPort ? ` (requested ${requestedPort}, autodetected)` : ""}`);
+        try {
+          (0, import_capability_token.getCapabilityToken)();
+          (0, import_files.writeEndpointFile)((0, import_persistence.getDataDir)(), {
+            url: `http://127.0.0.1:${boundPort}/sse`,
+            pid: process.pid,
+            startedAt: Date.now()
+          });
+        } catch (err) {
+          console.warn("[MCP] Could not write the endpoint file:", err);
+        }
+        try {
+          const { broadcast: bc } = _lazy____server;
+          bc("mcp-port-changed", { port: boundPort, requested: requestedPort });
+        } catch {
+        }
+        resolve();
+      };
+      const onError = (err) => {
+        app.removeListener("listening", onListening);
+        if (err.code === "EADDRINUSE" && autodetect && attemptsLeft > 0) {
+          console.warn(`[MCP] Port ${candidate} in use; trying ${candidate + 1}\u2026`);
+          tryPort(candidate + 1, attemptsLeft - 1);
+        } else {
+          reject(err);
+        }
+      };
+      app.once("listening", onListening);
+      app.once("error", onError);
+      app.listen(candidate, "127.0.0.1");
+    };
+    tryPort(requestedPort, autodetect ? MAX_PORT_ATTEMPTS : 0);
+  });
+}
+function getMcpStatus() {
+  return {
+    running: httpServer !== null,
+    port: boundPort,
+    connectedAgents: connectedTransports.size
+  };
+}
+function getMcpConfig() {
+  return {
+    codetrellis: {
+      type: "sse",
+      url: `http://127.0.0.1:${boundPort}/sse`,
+      headers: { [import_capability_token.TOKEN_HEADER]: (0, import_capability_token.getCapabilityToken)() }
+    }
+  };
+}
+function currentConnector() {
+  const cmd = (0, import_command.resolveConnectorCommand)({
+    execPath: process.execPath,
+    electronVersion: process.versions.electron,
+    resourcesPath: process.resourcesPath,
+    cwd: process.cwd(),
+    dataDir: (0, import_persistence.getDataDir)(),
+    exists: (p) => import_node_fs.default.existsSync(p),
+    env: {
+      APPIMAGE: process.env.APPIMAGE,
+      APPDIR: process.env.APPDIR,
+      PORTABLE_EXECUTABLE_FILE: process.env.PORTABLE_EXECUTABLE_FILE
+    }
+  });
+  if (!cmd) return null;
+  return {
+    ...cmd,
+    config: (0, import_command.connectorConfig)(cmd),
+    claudeCodeCommand: (0, import_command.claudeCodeConnectorCommand)(cmd)
+  };
+}
+function getMcpSetup() {
+  const url = `http://127.0.0.1:${boundPort}/sse`;
+  const tokenFile = (0, import_capability_token.getTokenFilePath)();
+  const token = (0, import_capability_token.getCapabilityToken)();
+  const connector = currentConnector();
+  const direct = [
+    `- Transport: SSE. URL: ${url}`,
+    `- It requires a credential. Every request must carry the header \`${import_capability_token.TOKEN_HEADER}: <token>\` (\`Authorization: Bearer <token>\` also works). If your MCP client cannot send headers, append \`?${import_capability_token.TOKEN_QUERY_PARAM}=<token>\` to the URL instead.`,
+    `- Read the token from the file ${tokenFile} (readable only by this user). Do not ask me to paste it.`,
+    '- The token changes every time CodeTrellis starts. If a request is refused with HTTP 401 "Missing or invalid capability token", re-read the file and update the config. Do not retry with the old value.',
+    "- Name the server `codetrellis`. In Claude Code: `claude mcp add --transport sse codetrellis " + url + ' --header "' + import_capability_token.TOKEN_HEADER + ': <token>"`.'
+  ];
+  const agentPrompt = connector ? [
+    "Connect yourself to the CodeTrellis MCP server running on this machine.",
+    "",
+    "Use the CodeTrellis connector, a local stdio MCP server. It reads its credential itself on every connect, so the config needs no token and keeps working when CodeTrellis restarts.",
+    ...connector.caveat ? ["", connector.caveat] : [],
+    "",
+    `- Name: \`codetrellis\`. Transport: stdio. Command: \`${connector.command}\``,
+    `- Arguments: ${connector.args.map((a) => `\`${a}\``).join(" ")}`,
+    ...Object.keys(connector.env).length > 0 ? [`- Environment: ${Object.entries(connector.env).map(([k, v]) => `\`${k}=${v}\``).join(" ")}`] : [],
+    `- In Claude Code, run: \`${connector.claudeCodeCommand}\``,
+    "- Replace any existing `codetrellis` entry that points at a URL: that kind stops working whenever CodeTrellis restarts.",
+    "",
+    "Only if your client cannot launch a stdio server, connect directly instead:",
+    ...direct,
+    "",
+    "- Once connected, call `register_session`, then `get_app_guide`."
+  ].join("\n") : [
+    "Connect yourself to the CodeTrellis MCP server running on this machine.",
+    "",
+    ...direct,
+    "- Once connected, call `register_session`, then `get_app_guide`."
+  ].join("\n");
+  return {
+    connector,
+    config: getMcpConfig(),
+    url,
+    header: import_capability_token.TOKEN_HEADER,
+    queryParam: import_capability_token.TOKEN_QUERY_PARAM,
+    tokenFile,
+    claudeCodeCommand: `claude mcp add --transport sse codetrellis ${url} --header "${import_capability_token.TOKEN_HEADER}: ${token}"`,
+    agentPrompt
+  };
+}
+async function stopMcpServer() {
+  if (httpServer) {
+    httpServer.close();
+    httpServer = null;
+    try {
+      (0, import_files.removeEndpointFile)((0, import_persistence.getDataDir)(), process.pid);
+    } catch {
+    }
+  }
+  await Promise.allSettled(
+    Array.from(connectedServers.values()).map((s) => s.close())
+  );
+  connectedServers.clear();
+  connectedTransports.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindingSettled,
+  enumerateRegisteredTools,
+  getMcpConfig,
+  getMcpSetup,
+  getMcpStatus,
+  listRegisteredToolArgs,
+  listRegisteredTools,
+  setElectronScreenshotCapture,
+  startMcpServer,
+  stopMcpServer
+});