@aprovan/patchwork-mcp 0.1.0-dev.030eb3d

package/src/server.ts

@@ -0,0 +1,399 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import cors from "cors";
+import express from "express";
+import { registerSession, unregisterSession } from "./live-update.js";
+import { log, error } from "./logger.js";
+import { createRegistryBackend, type RegistryBackend } from "./registry-backend.js";
+import { startTunnel, stopTunnel } from "./tunnel.js";
+import { getWidgetStore } from "./widget-store/index.js";
+import { createMcpAppServer, type McpAppServerOptions } from "./index.js";
+import type { Request, Response } from "express";
+
+const PORT = Number(process.env["PORT"] ?? 3000);
+const WIDGET_PORT = Number(process.env["WIDGET_PORT"] ?? 3002);
+const HOST = process.env["HOST"] ?? "0.0.0.0";
+const TRANSPORT = process.env["TRANSPORT"] ?? (process.argv.includes("--stdio") ? "stdio" : "http");
+const WIDGET_TUNNEL = process.env["WIDGET_TUNNEL"] === "true" || process.argv.includes("--tunnel");
+
+type SessionEntry = {
+  server: ReturnType<typeof createMcpAppServer>;
+  transport: StreamableHTTPServerTransport;
+};
+
+/**
+ * Cross-process coordination for the shared widget host.
+ *
+ * Every stdio spawn of this server (Claude Desktop respawns it freely) would
+ * otherwise start its own widget server and its own cloudflared quick tunnel.
+ * Only one can bind {@link WIDGET_PORT}; the rest orphan extra tunnels and, worse,
+ * each render returns a *different* hostname — and any instance whose ephemeral
+ * tunnel has dropped serves a dead URL (Cloudflare 1033) into the widget HTML.
+ *
+ * We elect a single owner via the port bind: whoever binds the port establishes
+ * (and verifies) the tunnel and publishes its base URL to a temp file keyed by
+ * port; every other instance reuses that URL instead of starting a tunnel.
+ */
+interface WidgetHostState {
+  baseUrl: string;
+  pid: number;
+  updatedAt: number;
+}
+
+const WIDGET_STATE_FILE = join(tmpdir(), `patchwork-widget-${WIDGET_PORT}.json`);
+
+function readWidgetHostState(): WidgetHostState | null {
+  try {
+    return JSON.parse(readFileSync(WIDGET_STATE_FILE, "utf8")) as WidgetHostState;
+  } catch {
+    return null;
+  }
+}
+
+function publishWidgetHostState(baseUrl: string): void {
+  try {
+    const state: WidgetHostState = { baseUrl, pid: process.pid, updatedAt: Date.now() };
+    writeFileSync(WIDGET_STATE_FILE, JSON.stringify(state));
+  } catch (err) {
+    error("mcp-app-server", "Failed to publish widget host state:", err);
+  }
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    // ESRCH = no such process; EPERM = exists but not ours (still alive).
+    return (err as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/**
+ * Wait for the owning instance to publish its (verified) base URL. Only adopt
+ * state whose owning pid is still alive, so a non-owner never reuses a dead
+ * previous owner's (now-1033) hostname.
+ */
+async function awaitPublishedWidgetBaseUrl(timeoutMs = 35000): Promise<string | null> {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const state = readWidgetHostState();
+    if (state?.baseUrl && isProcessAlive(state.pid)) return state.baseUrl;
+    await new Promise((r) => setTimeout(r, 500));
+  }
+  return null;
+}
+
+/** Locate a built browser bundle dir (dist/<name>) from either dist or src. */
+function resolveDistDir(name: string): string {
+  const candidates = [
+    fileURLToPath(new URL(`./${name}`, import.meta.url)), // built: dist/<name>
+    fileURLToPath(new URL(`../dist/${name}`, import.meta.url)), // dev via tsx: src → dist
+  ];
+  return candidates.find((dir) => existsSync(dir)) ?? candidates[0]!;
+}
+
+/** Locate the built runtime bundle (dist/runtime). */
+export function resolveRuntimeDir(): string {
+  return resolveDistDir("runtime");
+}
+
+/** Locate the built MCP App shell bundle (dist/shell). */
+export function resolveShellDir(): string {
+  return resolveDistDir("shell");
+}
+
+async function setupRegistryBackend(): Promise<{
+  registryBackend: RegistryBackend | null;
+  serverOptions: McpAppServerOptions;
+}> {
+  const toolboxUrl = process.env["TOOLBOX_MCP_URL"];
+
+  if (!toolboxUrl) {
+    return { registryBackend: null, serverOptions: {} };
+  }
+
+  log("patchwork-mcp", `Connecting to toolbox at ${toolboxUrl}`);
+
+  try {
+    const registryBackend = await createRegistryBackend({
+      name: "toolbox",
+      url: toolboxUrl,
+      headers: process.env["APROVAN_WORKSPACE_ID"]
+        ? { "X-Aprovan-Workspace": process.env["APROVAN_WORKSPACE_ID"] }
+        : undefined,
+      auth: process.env["TOOLBOX_TOKEN"]
+        ? { type: "bearer", token: process.env["TOOLBOX_TOKEN"] }
+        : { type: "none" },
+    });
+
+    const toolInfos = registryBackend.getToolInfos();
+    const namespaces = [...new Set(toolInfos.map((t) => t.namespace))];
+    log(
+      "patchwork-mcp",
+      `Registry ready: ${toolInfos.length} tools across namespaces: ${namespaces.join(", ")}`
+    );
+
+    return {
+      registryBackend,
+      serverOptions: {
+        services: {
+          backend: registryBackend,
+          tools: toolInfos,
+        },
+      },
+    };
+  } catch (err) {
+    error("patchwork-mcp", "Failed to connect to toolbox:", err);
+    error("patchwork-mcp", "Starting without toolbox services.");
+    return { registryBackend: null, serverOptions: {} };
+  }
+}
+
+function handleExistingSession(existing: SessionEntry, req: Request, res: Response): void {
+  try {
+    existing.transport.handleRequest(req, res, req.body);
+  } catch (err) {
+    error("mcp", "session request error", err);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Internal server error" });
+    }
+  }
+}
+
+async function createNewSession(
+  serverOptions: McpAppServerOptions,
+  sessionStore: Map<string, SessionEntry>,
+  req: Request,
+  res: Response
+): Promise<void> {
+  const mcpServer = createMcpAppServer(serverOptions);
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID(),
+    onsessioninitialized: (id) => {
+      sessionStore.set(id, { server: mcpServer, transport });
+      registerSession(id, mcpServer);
+    },
+    onsessionclosed: (id) => {
+      sessionStore.delete(id);
+      unregisterSession(id);
+    },
+  });
+
+  res.on("close", () => {
+    const id = transport.sessionId;
+    if (id && !sessionStore.has(id)) {
+      void mcpServer.close();
+    }
+  });
+
+  try {
+    await mcpServer.connect(transport);
+    await transport.handleRequest(req, res, req.body);
+  } catch (err) {
+    error("mcp", "new session error", err);
+    if (!res.headersSent) {
+      res.status(500).json({ error: "Internal server error" });
+    }
+  }
+}
+
+function registerMcpEndpoint(
+  app: ReturnType<typeof createMcpExpressApp>,
+  serverOptions: McpAppServerOptions
+): Map<string, SessionEntry> {
+  const sessionStore = new Map<string, SessionEntry>();
+
+  app.all("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"] as string | undefined;
+
+    if (sessionId) {
+      const existing = sessionStore.get(sessionId);
+      if (existing) {
+        handleExistingSession(existing, req, res);
+        return;
+      }
+    }
+
+    await createNewSession(serverOptions, sessionStore, req, res);
+  });
+
+  return sessionStore;
+}
+
+function registerShutdownHandlers(registryBackend: RegistryBackend | null): void {
+  const shutdown = () => {
+    if (registryBackend) {
+      registryBackend.close().catch(() => {
+        /* ignore close errors on exit */
+      });
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+
+async function startServer(): Promise<void> {
+  const { registryBackend, serverOptions } = await setupRegistryBackend();
+
+  const app = createMcpExpressApp({ host: HOST });
+  app.use(cors());
+
+  registerMcpEndpoint(app, serverOptions);
+
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", service: "patchwork-mcp-app-server" });
+  });
+
+  app.listen(PORT, HOST, () => {
+    log("mcp-app-server", `MCP App Server listening on http://${HOST}:${PORT}`);
+    log("mcp-app-server", `  POST /mcp    — MCP Streamable HTTP endpoint (stateful sessions)`);
+    log("mcp-app-server", `  GET  /health — health check`);
+    log("mcp-app-server", "");
+    log("mcp-app-server", "To expose locally via cloudflared:");
+    log("mcp-app-server", `  cloudflared tunnel --url http://localhost:${PORT}`);
+  });
+
+  registerShutdownHandlers(registryBackend);
+}
+
+async function startWidgetServer(): Promise<string> {
+  const widgetApp = express();
+  widgetApp.use(cors());
+
+  const store = getWidgetStore();
+
+  // Serve the MCP App shell (resource document's external script) and the shared
+  // browser runtime bundle (compiles widgets in-browser). Both resolve to dist
+  // whether running built (dist/server.js) or via tsx (src).
+  widgetApp.use("/shell", express.static(resolveShellDir()));
+  widgetApp.use("/runtime", express.static(resolveRuntimeDir()));
+
+  // Raw widget source files — fetched by the runtime and compiled in-browser.
+  widgetApp.get("/widget/:name/:hash/files", async (req, res) => {
+    const { name, hash } = req.params;
+    try {
+      const widget = await store.getWidget(name, hash);
+      if (!widget) {
+        res.status(404).json({ error: "Widget not found" });
+        return;
+      }
+      res.json({ files: widget.files, entry: widget.entry, manifest: widget.manifest });
+    } catch (err) {
+      error("widget-server", "Error serving widget files:", err);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  });
+
+  // Convenience redirect: /widget/:name/:hash → runtime host with the widget preselected.
+  widgetApp.get("/widget/:name/:hash", (req, res) => {
+    const { name, hash } = req.params;
+    res.redirect(
+      302,
+      `/runtime/?widget=${encodeURIComponent(name)}/${encodeURIComponent(hash)}`,
+    );
+  });
+
+  widgetApp.get("/health", (_req, res) => {
+    res.json({ status: "ok", service: "patchwork-widget-server" });
+  });
+
+  // Elect the widget-host owner via the port bind. A failed bind (EADDRINUSE)
+  // means another instance already owns the widget server + tunnel.
+  const isOwner = await new Promise<boolean>((resolve) => {
+    const httpServer = widgetApp.listen(WIDGET_PORT, HOST, () => {
+      log("mcp-app-server", `Widget server listening on http://${HOST}:${WIDGET_PORT}`);
+      resolve(true);
+    });
+    httpServer.on("error", (err: NodeJS.ErrnoException) => {
+      if (err.code === "EADDRINUSE") {
+        log(
+          "mcp-app-server",
+          `Widget port ${WIDGET_PORT} already owned by another instance; reusing its widget host.`,
+        );
+      } else {
+        error("mcp-app-server", "Widget server failed to bind:", err);
+      }
+      resolve(false);
+    });
+  });
+
+  if (!isOwner) {
+    // Reuse the owner's verified, published base URL so every instance hands out
+    // the same live hostname instead of orphaning another (possibly dead) tunnel.
+    const shared = await awaitPublishedWidgetBaseUrl();
+    if (shared) {
+      log("mcp-app-server", `Reusing shared widget host: ${shared}`);
+      return shared;
+    }
+    error(
+      "mcp-app-server",
+      "Owner instance never published a base URL; falling back to localhost (widgets may not load in remote hosts).",
+    );
+    return `http://localhost:${WIDGET_PORT}`;
+  }
+
+  // We own the widget server. Establish (and verify) the tunnel, then publish
+  // the base URL for sibling instances.
+  let widgetBaseUrl = `http://localhost:${WIDGET_PORT}`;
+
+  if (WIDGET_TUNNEL) {
+    try {
+      widgetBaseUrl = await startTunnel(WIDGET_PORT);
+      log("mcp-app-server", `Widgets accessible at: ${widgetBaseUrl}`);
+    } catch (err) {
+      error("mcp-app-server", "Failed to start tunnel, using localhost:", err);
+    }
+  }
+
+  publishWidgetHostState(widgetBaseUrl);
+  return widgetBaseUrl;
+}
+
+async function startStdioServer(): Promise<void> {
+  const { registryBackend, serverOptions } = await setupRegistryBackend();
+
+  log("mcp-app-server", "Starting MCP App Server in stdio mode...");
+
+  // Start widget server and optionally tunnel
+  const widgetBaseUrl = await startWidgetServer();
+
+  // Create MCP server with widget base URL
+  const mcpServer = createMcpAppServer({
+    ...serverOptions,
+    widgetBaseUrl,
+  });
+  const transport = new StdioServerTransport();
+
+  await mcpServer.connect(transport);
+
+  const shutdown = () => {
+    stopTunnel();
+    if (registryBackend) {
+      registryBackend.close().catch(() => {});
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+
+async function main(): Promise<void> {
+  if (TRANSPORT === "stdio") {
+    await startStdioServer();
+  } else {
+    await startServer();
+  }
+}
+
+main().catch((err: unknown) => {
+  error("mcp-app-server", "Fatal startup error:", err);
+  process.exit(1);
+});

package/src/services.ts

@@ -0,0 +1,307 @@
+import { type McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+export interface ServiceBackend {
+  call(namespace: string, procedure: string, args: unknown[]): Promise<unknown>;
+}
+
+export interface ServiceToolInfo {
+  name: string;
+  namespace: string;
+  procedure: string;
+  description?: string;
+  parameters?: Record<string, unknown>;
+}
+
+export interface ServiceBridgeConfig {
+  backend: ServiceBackend;
+  tools: ServiceToolInfo[];
+}
+
+const TOOL_SEPARATOR = "__";
+
+function toMcpToolName(namespace: string, procedure: string): string {
+  return `${namespace}${TOOL_SEPARATOR}${procedure}`;
+}
+
+function jsonSchemaToZodShape(schema?: Record<string, unknown>): Record<string, z.ZodTypeAny> {
+  const properties = (schema?.["properties"] ?? {}) as Record<
+    string,
+    { type?: string; description?: string }
+  >;
+  const required = new Set((schema?.["required"] ?? []) as string[]);
+
+  const shape: Record<string, z.ZodTypeAny> = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    let field: z.ZodTypeAny;
+    switch (prop.type) {
+      case "number":
+      case "integer":
+        field = z.number();
+        break;
+      case "boolean":
+        field = z.boolean();
+        break;
+      case "array":
+        field = z.array(z.unknown());
+        break;
+      case "object":
+        field = z.record(z.unknown());
+        break;
+      default:
+        field = z.string();
+        break;
+    }
+    if (prop.description) {
+      field = field.describe(prop.description);
+    }
+    if (!required.has(key)) {
+      field = field.optional();
+    }
+    shape[key] = field;
+  }
+
+  return shape;
+}
+
+export class ServiceBridge {
+  private backend: ServiceBackend;
+  private tools: Map<string, ServiceToolInfo> = new Map();
+
+  constructor(config: ServiceBridgeConfig) {
+    this.backend = config.backend;
+    for (const tool of config.tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+
+  registerTools(server: McpServer): void {
+    for (const [, info] of this.tools) {
+      const mcpToolName = toMcpToolName(info.namespace, info.procedure);
+      const inputShape = jsonSchemaToZodShape(info.parameters);
+
+      server.registerTool(
+        mcpToolName,
+        {
+          description: info.description ?? `Call ${info.namespace}.${info.procedure}`,
+          inputSchema: inputShape,
+        },
+        async (args) => {
+          try {
+            const result = await this.backend.call(info.namespace, info.procedure, [args ?? {}]);
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: typeof result === "string" ? result : JSON.stringify(result),
+                },
+              ],
+            };
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `Service call failed: ${message}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+        }
+      );
+    }
+  }
+
+  registerSearchServices(server: McpServer): void {
+    server.registerTool(
+      "search_services",
+      {
+        description:
+          "Search for available service tools that widgets can call. " +
+          "Returns matching services with their namespaces, procedures, and parameter schemas.",
+        inputSchema: {
+          query: z
+            .string()
+            .optional()
+            .describe(
+              'Natural language description of what you want to do (e.g., "get weather forecast")'
+            ),
+          namespace: z
+            .string()
+            .optional()
+            .describe('Filter results to a specific service namespace (e.g., "weather")'),
+          tool_name: z
+            .string()
+            .optional()
+            .describe("Get detailed info about a specific tool by name"),
+          limit: z.number().optional().describe("Maximum number of results to return"),
+        },
+      },
+      async (args) => {
+        const query = args?.["query"] as string | undefined;
+        const namespace = args?.["namespace"] as string | undefined;
+        const toolName = args?.["tool_name"] as string | undefined;
+        const limit = (args?.["limit"] as number) ?? 10;
+
+        if (toolName) {
+          const dotName = toolName.replace(/__/g, ".");
+          const info = this.tools.get(toolName) ?? this.tools.get(dotName);
+          if (!info) {
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: JSON.stringify({
+                    success: false,
+                    error: `Tool '${toolName}' not found`,
+                  }),
+                },
+              ],
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({ success: true, tool: info }),
+              },
+            ],
+          };
+        }
+
+        let results = Array.from(this.tools.values());
+
+        if (namespace) {
+          results = results.filter((info) => info.namespace === namespace);
+        }
+
+        if (query) {
+          const queryLower = query.toLowerCase();
+          const keywords = queryLower.split(/\s+/).filter(Boolean);
+          results = results
+            .map((info) => {
+              const searchText =
+                `${info.name} ${info.namespace} ${info.procedure} ${info.description ?? ""}`.toLowerCase();
+              const matchCount = keywords.filter((kw) => searchText.includes(kw)).length;
+              return { info, score: matchCount / keywords.length };
+            })
+            .filter(({ score }) => score > 0)
+            .sort((a, b) => b.score - a.score)
+            .map(({ info }) => info);
+        }
+
+        results = results.slice(0, limit);
+
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: JSON.stringify({
+                success: true,
+                count: results.length,
+                tools: results,
+                namespaces: this.getNamespaces(),
+              }),
+            },
+          ],
+        };
+      }
+    );
+
+    // call_service: Execute any service by namespace/procedure
+    server.registerTool(
+      "call_service",
+      {
+        description:
+          "Call a service tool by namespace and procedure. Use search_services to discover available tools first.",
+        inputSchema: {
+          namespace: z.string().describe('Service namespace (e.g., "github", "stripe")'),
+          procedure: z.string().describe('Procedure name (e.g., "repos_list", "customers_create")'),
+          args: z.record(z.unknown()).optional().describe("Arguments to pass to the procedure"),
+        },
+      },
+      async (params) => {
+        const namespace = params?.["namespace"] as string;
+        const procedure = params?.["procedure"] as string;
+        const args = (params?.["args"] ?? {}) as Record<string, unknown>;
+
+        if (!namespace || !procedure) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error: "namespace and procedure are required",
+                }),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        // Look up tool info for validation
+        const toolKey = `${namespace}.${procedure}`;
+        const info = this.tools.get(toolKey);
+        if (!info) {
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error: `Tool '${namespace}.${procedure}' not found. Use search_services to discover available tools.`,
+                }),
+              },
+            ],
+            isError: true,
+          };
+        }
+
+        try {
+          const result = await this.backend.call(namespace, procedure, [args]);
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: typeof result === "string" ? result : JSON.stringify(result),
+              },
+            ],
+          };
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: JSON.stringify({
+                  success: false,
+                  error: `Service call failed: ${message}`,
+                }),
+              },
+            ],
+            isError: true,
+          };
+        }
+      }
+    );
+  }
+
+  getNamespaces(): string[] {
+    const namespaces = new Set<string>();
+    for (const info of this.tools.values()) {
+      namespaces.add(info.namespace);
+    }
+    return Array.from(namespaces);
+  }
+
+  getToolInfos(): ServiceToolInfo[] {
+    return Array.from(this.tools.values());
+  }
+
+  has(namespace: string, procedure: string): boolean {
+    return this.tools.has(`${namespace}.${procedure}`);
+  }
+}