@aprovan/mcp-app-server 0.1.0-dev.4d82df8

package/dist/server.js

@@ -0,0 +1,1511 @@
+// src/server.ts
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+import { fileURLToPath } from "url";
+import express from "express";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import cors from "cors";
+
+// src/logger.ts
+var CURRENT_LEVEL = process.env["LOG_LEVEL"] ?? "info";
+var LEVEL_RANK = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+function shouldLog(level) {
+  return LEVEL_RANK[level] >= LEVEL_RANK[CURRENT_LEVEL];
+}
+function formatMessage(tag, ...args) {
+  return [`[${tag}]`, ...args];
+}
+function log(tag, ...args) {
+  if (shouldLog("info")) {
+    console.error(...formatMessage(tag, ...args));
+  }
+}
+function warn(tag, ...args) {
+  if (shouldLog("warn")) {
+    console.error(...formatMessage(tag, ...args));
+  }
+}
+function error(tag, ...args) {
+  if (shouldLog("error")) {
+    console.error(...formatMessage(tag, ...args));
+  }
+}
+
+// src/live-update.ts
+var RING_BUFFER_MAX = 100;
+var streamBuffers = /* @__PURE__ */ new Map();
+var globalSeq = 0;
+function getOrCreateBuffer(stream) {
+  let buf = streamBuffers.get(stream);
+  if (!buf) {
+    buf = [];
+    streamBuffers.set(stream, buf);
+  }
+  return buf;
+}
+function getEvents(stream, afterSeq) {
+  const buf = streamBuffers.get(stream);
+  if (!buf) return [];
+  return buf.filter((e) => e.seq > afterSeq);
+}
+function appendEvent(stream, data) {
+  const buf = getOrCreateBuffer(stream);
+  const event = {
+    seq: ++globalSeq,
+    data,
+    timestamp: Date.now()
+  };
+  buf.push(event);
+  if (buf.length > RING_BUFFER_MAX) {
+    buf.shift();
+  }
+  return event;
+}
+var sessions = /* @__PURE__ */ new Map();
+function registerSession(sessionId, server) {
+  if (!sessions.has(sessionId)) {
+    sessions.set(sessionId, { server, streams: /* @__PURE__ */ new Set() });
+  }
+}
+function unregisterSession(sessionId) {
+  sessions.delete(sessionId);
+}
+function subscribeSession(sessionId, stream) {
+  const entry = sessions.get(sessionId);
+  if (entry) {
+    entry.streams.add(stream);
+  }
+}
+async function pushStreamUpdate(stream, data) {
+  const event = appendEvent(stream, data);
+  const pushPromises = [];
+  for (const [, entry] of sessions) {
+    if (entry.streams.has(stream)) {
+      const notifyPromise = entry.server.server.notification({ method: "notifications/tools/list_changed" }).catch((err) => {
+        warn("live-update", "Failed to notify session:", err);
+      });
+      pushPromises.push(notifyPromise);
+    }
+  }
+  await Promise.all(pushPromises);
+  return event.seq;
+}
+function currentSeq() {
+  return globalSeq;
+}
+
+// src/registry-backend.ts
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+function parseRegistryToolName(mcpName) {
+  const idx = mcpName.indexOf("__");
+  if (idx === -1) {
+    return { namespace: mcpName, procedure: "call" };
+  }
+  return {
+    namespace: mcpName.slice(0, idx),
+    procedure: mcpName.slice(idx + 2)
+  };
+}
+async function loadRegistryToolInfos(client) {
+  const listResult = await client.callTool({
+    name: "list_tools",
+    arguments: {}
+  });
+  const listText = listResult.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+  let toolNames;
+  try {
+    toolNames = JSON.parse(listText);
+  } catch {
+    warn("registry-backend", "Failed to parse tool list response from Registry");
+    return [];
+  }
+  if (!Array.isArray(toolNames)) {
+    warn("registry-backend", "Unexpected tool list format from Registry (expected array)");
+    return [];
+  }
+  const mcpNames = toolNames.filter((n) => typeof n === "string");
+  const CHUNK_SIZE = 20;
+  const toolInfos = [];
+  for (let i = 0; i < mcpNames.length; i += CHUNK_SIZE) {
+    const chunk = mcpNames.slice(i, i + CHUNK_SIZE);
+    const results = await Promise.all(
+      chunk.map(async (mcpName) => {
+        try {
+          const infoResult = await client.callTool({
+            name: "tool_info",
+            arguments: { tool_name: mcpName }
+          });
+          const infoText = infoResult.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+          const raw = JSON.parse(infoText);
+          const { namespace, procedure } = parseRegistryToolName(mcpName);
+          return {
+            name: `${namespace}.${procedure}`,
+            namespace,
+            procedure,
+            description: raw.description ?? `Call ${namespace}.${procedure}`,
+            parameters: raw.inputSchema
+          };
+        } catch (err) {
+          warn("registry-backend", `Failed to fetch tool info for '${mcpName}': ${err}`);
+          return null;
+        }
+      })
+    );
+    for (const info of results) {
+      if (info !== null) {
+        toolInfos.push(info);
+      }
+    }
+  }
+  const providerCount = new Set(toolInfos.map((t) => t.namespace)).size;
+  log(
+    "registry-backend",
+    `Loaded ${toolInfos.length} tools from ${providerCount} provider(s)`
+  );
+  return toolInfos;
+}
+async function createRegistryBackend(options) {
+  const inheritedEnv = {};
+  for (const [k, v] of Object.entries(process.env)) {
+    if (v !== void 0) inheritedEnv[k] = v;
+  }
+  const env = {
+    ...inheritedEnv,
+    UTDK_PROVIDERS: options.providers,
+    ...options.env
+  };
+  const transport = new StdioClientTransport({
+    command: options.command,
+    args: options.args ?? [],
+    env,
+    // Route Registry stderr to the parent so operators can see provider logs.
+    stderr: "inherit"
+  });
+  const client = new Client({
+    name: "patchwork-mcp-app-server",
+    version: "0.1.0"
+  });
+  await client.connect(transport);
+  const toolInfos = await loadRegistryToolInfos(client);
+  const backend = {
+    /**
+     * Execute a Registry-backed service tool.
+     *
+     * The call is forwarded as a Registry `call_tool` meta-tool invocation:
+     *   namespace + "__" + procedure → Registry MCP tool name
+     *
+     * The first element of `args` is treated as the tool's argument object.
+     */
+    async call(namespace, procedure, args) {
+      const toolName = `${namespace}__${procedure}`;
+      const toolArgs = typeof args[0] === "object" && args[0] !== null ? args[0] : {};
+      const result = await client.callTool({
+        name: "call_tool",
+        arguments: {
+          tool_name: toolName,
+          arguments: toolArgs
+        }
+      });
+      if (result.isError) {
+        const message = result.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+        throw new Error(message || `Registry call failed for '${toolName}'`);
+      }
+      const textContent = result.content.find(
+        (c) => c.type === "text"
+      );
+      if (textContent) {
+        try {
+          return JSON.parse(textContent.text);
+        } catch {
+          return textContent.text;
+        }
+      }
+      return result;
+    },
+    getToolInfos() {
+      return toolInfos;
+    },
+    async close() {
+      await client.close();
+    }
+  };
+  return backend;
+}
+
+// src/index.ts
+import {
+  createProjectFromFiles,
+  createSingleFileProject
+} from "@aprovan/patchwork-compiler";
+import {
+  registerAppTool,
+  RESOURCE_MIME_TYPE
+} from "@modelcontextprotocol/ext-apps/server";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+
+// src/services.ts
+import { z } from "zod";
+var TOOL_SEPARATOR = "__";
+function toMcpToolName(namespace, procedure) {
+  return `${namespace}${TOOL_SEPARATOR}${procedure}`;
+}
+function jsonSchemaToZodShape(schema) {
+  const properties = schema?.["properties"] ?? {};
+  const required = new Set(schema?.["required"] ?? []);
+  const shape = {};
+  for (const [key, prop] of Object.entries(properties)) {
+    let field;
+    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;
+}
+var ServiceBridge = class {
+  backend;
+  tools = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.backend = config.backend;
+    for (const tool of config.tools) {
+      this.tools.set(tool.name, tool);
+    }
+  }
+  registerTools(server) {
+    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",
+                  text: typeof result === "string" ? result : JSON.stringify(result)
+                }
+              ]
+            };
+          } catch (error2) {
+            const message = error2 instanceof Error ? error2.message : String(error2);
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Service call failed: ${message}`
+                }
+              ],
+              isError: true
+            };
+          }
+        }
+      );
+    }
+  }
+  registerSearchServices(server) {
+    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"];
+        const namespace = args?.["namespace"];
+        const toolName = args?.["tool_name"];
+        const limit = args?.["limit"] ?? 10;
+        if (toolName) {
+          const dotName = toolName.replace(/__/g, ".");
+          const info = this.tools.get(toolName) ?? this.tools.get(dotName);
+          if (!info) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: JSON.stringify({
+                    success: false,
+                    error: `Tool '${toolName}' not found`
+                  })
+                }
+              ]
+            };
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                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",
+              text: JSON.stringify({
+                success: true,
+                count: results.length,
+                tools: results,
+                namespaces: this.getNamespaces()
+              })
+            }
+          ]
+        };
+      }
+    );
+    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"];
+        const procedure = params?.["procedure"];
+        const args = params?.["args"] ?? {};
+        if (!namespace || !procedure) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: "namespace and procedure are required"
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+        const toolKey = `${namespace}.${procedure}`;
+        const info = this.tools.get(toolKey);
+        if (!info) {
+          return {
+            content: [
+              {
+                type: "text",
+                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",
+                text: typeof result === "string" ? result : JSON.stringify(result)
+              }
+            ]
+          };
+        } catch (error2) {
+          const message = error2 instanceof Error ? error2.message : String(error2);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  error: `Service call failed: ${message}`
+                })
+              }
+            ],
+            isError: true
+          };
+        }
+      }
+    );
+  }
+  getNamespaces() {
+    const namespaces = /* @__PURE__ */ new Set();
+    for (const info of this.tools.values()) {
+      namespaces.add(info.namespace);
+    }
+    return Array.from(namespaces);
+  }
+  getToolInfos() {
+    return Array.from(this.tools.values());
+  }
+  has(namespace, procedure) {
+    return this.tools.has(`${namespace}.${procedure}`);
+  }
+};
+
+// src/widget-store/store.ts
+import { join as join2, resolve } from "path";
+import { homedir } from "os";
+
+// src/widget-store/local-backend.ts
+import { readFile, writeFile, unlink, stat, mkdir, readdir, rm, access } from "fs/promises";
+import { join, dirname, normalize } from "path";
+function createDirEntry(name, isDir) {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function createFileStats(size, mtime, isDir) {
+  return {
+    size,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+var LocalFileBackend = class {
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  basePath;
+  resolve(path) {
+    return join(this.basePath, normalize(path));
+  }
+  async readFile(path) {
+    return readFile(this.resolve(path), "utf-8");
+  }
+  async writeFile(path, content) {
+    const fullPath = this.resolve(path);
+    await mkdir(dirname(fullPath), { recursive: true });
+    await writeFile(fullPath, content, "utf-8");
+  }
+  async unlink(path) {
+    await unlink(this.resolve(path));
+  }
+  async stat(path) {
+    const fullPath = this.resolve(path);
+    const s = await stat(fullPath);
+    return createFileStats(s.size, s.mtime, s.isDirectory());
+  }
+  async mkdir(path, options) {
+    await mkdir(this.resolve(path), options);
+  }
+  async readdir(path) {
+    const fullPath = this.resolve(path);
+    const entries = await readdir(fullPath, { withFileTypes: true });
+    return entries.map(
+      (e) => createDirEntry(e.name, e.isDirectory())
+    );
+  }
+  async rmdir(path, options) {
+    if (options?.recursive) {
+      await rm(this.resolve(path), { recursive: true, force: true });
+    } else {
+      await rm(this.resolve(path), { force: true });
+    }
+  }
+  async exists(path) {
+    try {
+      await access(this.resolve(path));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// src/widget-store/store.ts
+var WIDGETS_PREFIX = "widgets";
+var FILES_SUBDIR = "files";
+var RESOURCE_URI_PREFIX = "ui://widgets/";
+function getDefaultStorageDir() {
+  return process.env["WIDGET_STORE_PATH"] ?? join2(homedir(), ".patchwork", "widget-store");
+}
+var WidgetStore = class {
+  provider;
+  storageDir;
+  constructor(options = {}) {
+    this.storageDir = resolve(options.storageDir ?? getDefaultStorageDir());
+    this.provider = options.backend ?? new LocalFileBackend(this.storageDir);
+  }
+  fullPath(virtualPath) {
+    return join2(WIDGETS_PREFIX, virtualPath);
+  }
+  async readFilesRecursive(dir, base = "") {
+    const files = [];
+    let entries;
+    try {
+      entries = await this.provider.readdir(dir);
+    } catch {
+      return files;
+    }
+    for (const entry of entries) {
+      const childDir = join2(dir, entry.name);
+      const relPath = base ? `${base}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        files.push(...await this.readFilesRecursive(childDir, relPath));
+      } else {
+        const content = await this.provider.readFile(childDir);
+        files.push({ path: relPath, content });
+      }
+    }
+    return files;
+  }
+  async saveWidget(hash, files, manifest, entry) {
+    const widgetDir = `${manifest.name}/${hash}`;
+    const createdAt = Date.now();
+    await Promise.all(
+      files.map(
+        (file) => this.provider.writeFile(
+          this.fullPath(`${widgetDir}/${FILES_SUBDIR}/${file.path}`),
+          file.content
+        )
+      )
+    );
+    const storedManifest = { ...manifest, entry, createdAt };
+    await this.provider.writeFile(
+      this.fullPath(`${widgetDir}/manifest.json`),
+      JSON.stringify(storedManifest)
+    );
+    return {
+      path: this.fullPath(widgetDir),
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      files,
+      entry,
+      manifest,
+      createdAt
+    };
+  }
+  async getWidget(name, hash) {
+    const widgetDir = `${name}/${hash}`;
+    const manifestVirtualPath = this.fullPath(`${widgetDir}/manifest.json`);
+    const exists = await this.provider.exists(manifestVirtualPath);
+    if (!exists) return null;
+    const files = await this.readFilesRecursive(this.fullPath(`${widgetDir}/${FILES_SUBDIR}`));
+    let manifest;
+    let entry = files[0]?.path ?? "main.tsx";
+    let createdAt = Date.now();
+    try {
+      const raw = await this.provider.readFile(manifestVirtualPath);
+      const parsed = JSON.parse(raw);
+      manifest = {
+        name: parsed.name ?? name,
+        version: parsed.version ?? "0.1.0",
+        platform: parsed.platform ?? "browser",
+        image: parsed.image ?? "@aprovan/patchwork-image-shadcn",
+        description: parsed.description,
+        services: parsed.services
+      };
+      if (parsed.entry) entry = parsed.entry;
+      if (typeof parsed.createdAt === "number") createdAt = parsed.createdAt;
+    } catch {
+      manifest = {
+        name,
+        version: "0.1.0",
+        platform: "browser",
+        image: "@aprovan/patchwork-image-shadcn"
+      };
+    }
+    return {
+      path: this.fullPath(widgetDir),
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      files,
+      entry,
+      manifest,
+      createdAt
+    };
+  }
+  async listWidgets() {
+    const results = [];
+    const rootPath = this.fullPath("");
+    try {
+      const names = await this.provider.readdir(rootPath);
+      for (const nameEntry of names) {
+        if (!nameEntry.isDirectory()) continue;
+        const name = nameEntry.name;
+        try {
+          const hashes = await this.provider.readdir(join2(rootPath, name));
+          for (const hashEntry of hashes) {
+            if (!hashEntry.isDirectory()) continue;
+            const hash = hashEntry.name;
+            const manifestVirtualPath = this.fullPath(`${name}/${hash}/manifest.json`);
+            let manifest = {};
+            try {
+              const raw = await this.provider.readFile(manifestVirtualPath);
+              manifest = JSON.parse(raw);
+            } catch {
+              continue;
+            }
+            results.push({
+              path: this.fullPath(`${name}/${hash}`),
+              resourceUri: `${RESOURCE_URI_PREFIX}${name}/${hash}/view.html`,
+              name: manifest.name ?? name,
+              version: manifest.version ?? "0.1.0",
+              description: manifest.description,
+              services: manifest.services,
+              entry: manifest.entry,
+              createdAt: manifest.createdAt ?? 0
+            });
+          }
+        } catch {
+          continue;
+        }
+      }
+    } catch {
+      return results;
+    }
+    return results.sort((a, b) => b.createdAt - a.createdAt);
+  }
+  async deleteWidget(name, hash) {
+    const widgetDir = this.fullPath(`${name}/${hash}`);
+    const exists = await this.provider.exists(widgetDir);
+    if (!exists) return false;
+    await this.provider.rmdir(widgetDir, { recursive: true });
+    return true;
+  }
+  async hasWidget(name, hash) {
+    return this.provider.exists(this.fullPath(`${name}/${hash}/manifest.json`));
+  }
+  resourceUriFor(name, hash) {
+    return `${RESOURCE_URI_PREFIX}${name}/${hash}/view.html`;
+  }
+  async loadAll() {
+    const infos = await this.listWidgets();
+    const widgets = [];
+    for (const info of infos) {
+      const uriPath = info.resourceUri.replace(RESOURCE_URI_PREFIX, "").replace(/\/view\.html$/, "");
+      const parts = uriPath.split("/");
+      const name = parts[0];
+      const hash = parts[1];
+      if (!name || !hash) continue;
+      const widget = await this.getWidget(name, hash);
+      if (widget) widgets.push(widget);
+    }
+    return widgets;
+  }
+};
+var _instance = null;
+function getWidgetStore(options) {
+  if (!_instance) {
+    _instance = new WidgetStore(options);
+  }
+  return _instance;
+}
+
+// src/index.ts
+var DEFAULT_WIDGET_PORT = Number(process.env["WIDGET_PORT"] ?? 3002);
+var DEFAULT_WIDGET_HOST = process.env["WIDGET_HOST"] ?? "localhost";
+var DEFAULT_WIDGET_BASE_URL = `http://${DEFAULT_WIDGET_HOST}:${DEFAULT_WIDGET_PORT}`;
+function generateResourceHtml(shellUrl, runtimeUrl, widget, inputs) {
+  const config = JSON.stringify({
+    runtime: runtimeUrl,
+    widget: `${widget.name}/${widget.hash}`,
+    inputs
+  });
+  const configB64 = Buffer.from(config, "utf-8").toString("base64");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${widget.name}</title>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { width: 100%; }
+    #pw-root { width: 100%; }
+  </style>
+</head>
+<body>
+  <div id="pw-root"></div>
+  <script src="${shellUrl}" data-config="${configB64}"></script>
+</body>
+</html>`;
+}
+function hashFiles(files, manifest) {
+  const input = JSON.stringify({
+    name: manifest.name,
+    image: manifest.image,
+    files: files.map((f) => [f.path, f.content])
+  });
+  let hash = 0;
+  for (let i = 0; i < input.length; i++) {
+    hash = (hash << 5) - hash + input.charCodeAt(i) | 0;
+  }
+  return Math.abs(hash).toString(16).padStart(8, "0");
+}
+var MANIFEST_DEFAULTS = {
+  name: "widget",
+  version: "0.1.0",
+  platform: "browser",
+  image: "@aprovan/patchwork-image-shadcn"
+};
+function buildCspConfig(widgetBaseUrl) {
+  try {
+    const url = new URL(widgetBaseUrl);
+    const origin = url.port ? `${url.protocol}//${url.hostname}:${url.port}` : `${url.protocol}//${url.hostname}`;
+    return { frameDomains: [origin], resourceDomains: [origin] };
+  } catch {
+    return void 0;
+  }
+}
+function buildManifest(input) {
+  return {
+    name: input?.["name"] ?? MANIFEST_DEFAULTS.name,
+    version: input?.["version"] ?? MANIFEST_DEFAULTS.version,
+    platform: "browser",
+    image: input?.["image"] ?? MANIFEST_DEFAULTS.image,
+    services: input?.["services"]
+  };
+}
+var DEFAULT_WIDGET_SOURCE = "export default function Widget() { return <div>Hello Patchwork</div>; }";
+function buildProject(name, source, files, entry) {
+  if (files && files.length > 0) {
+    const virtualFiles = files.map((f) => ({
+      path: f.path,
+      content: f.content
+    }));
+    const project = createProjectFromFiles(virtualFiles, name);
+    if (entry) project.entry = entry;
+    return project;
+  }
+  return createSingleFileProject(source ?? DEFAULT_WIDGET_SOURCE, entry ?? "main.tsx", name);
+}
+function createMcpAppServer(options = {}) {
+  const server = new McpServer({
+    name: "patchwork-mcp-app-server",
+    version: "0.1.0"
+  });
+  const serviceBridge = options.services ? new ServiceBridge(options.services) : null;
+  const widgetBaseUrl = options.widgetBaseUrl ?? DEFAULT_WIDGET_BASE_URL;
+  const runtimeUrl = `${widgetBaseUrl}/runtime/`;
+  const shellUrl = `${widgetBaseUrl}/shell/shell.js`;
+  const directUrl = (name, hash) => `${runtimeUrl}?widget=${encodeURIComponent(name)}/${encodeURIComponent(hash)}`;
+  const store = getWidgetStore();
+  const renderResource = (ref, inputs) => {
+    const csp = buildCspConfig(widgetBaseUrl);
+    return {
+      type: "resource",
+      resource: {
+        uri: store.resourceUriFor(ref.name, ref.hash),
+        mimeType: RESOURCE_MIME_TYPE,
+        text: generateResourceHtml(shellUrl, runtimeUrl, ref, inputs),
+        ...csp ? { _meta: { ui: { csp } } } : {}
+      }
+    };
+  };
+  registerAppTool(
+    server,
+    "save_widget",
+    {
+      description: "Save a JSX/TSX widget's raw source files for reuse and render it as an MCP App resource. Pass source code for a single-file widget, or a files array for a multi-file project. The widget is stored uncompiled and compiled in the browser by the shared Patchwork runtime when rendered \u2014 pass `inputs` to supply startup props to the widget.",
+      inputSchema: {
+        source: z2.string().optional().describe(
+          "JSX/TSX source code for a single-file widget. Must export a default React component."
+        ),
+        files: z2.array(
+          z2.object({
+            path: z2.string().describe("File path relative to project root (e.g. 'main.tsx')"),
+            content: z2.string().describe("File contents")
+          })
+        ).optional().describe(
+          "Array of files for a multi-file widget project. At least one file should be the entry point (main.tsx or index.tsx)."
+        ),
+        entry: z2.string().optional().describe("Entry point file path. Defaults to auto-detection (main.tsx, index.tsx)."),
+        name: z2.string().optional().describe("Widget name for the manifest. Defaults to 'widget'."),
+        image: z2.string().optional().describe(
+          "Patchwork image package to use. Defaults to '@aprovan/patchwork-image-shadcn'."
+        ),
+        services: z2.array(z2.string()).optional().describe(
+          "Service namespaces the widget calls (e.g., ['weather', 'stripe']). A proxy shim is injected so widget code can call namespace.procedure(args) directly."
+        ),
+        inputs: z2.record(z2.unknown()).optional().describe("Startup props passed to the widget's default export when it is rendered.")
+      },
+      _meta: {
+        ui: { resourceUri: "ui://widgets/{name}/{hash}/view.html" }
+      }
+    },
+    async (args) => {
+      const source = args?.["source"];
+      const files = args?.["files"];
+      const entry = args?.["entry"];
+      const requestedServices = args?.["services"];
+      const inputs = args?.["inputs"] ?? {};
+      const manifestInput = {};
+      if (args?.["name"]) manifestInput["name"] = args["name"];
+      if (args?.["image"]) manifestInput["image"] = args["image"];
+      let services = requestedServices ?? [];
+      if (services.length > 0 && serviceBridge) {
+        const availableNamespaces = serviceBridge.getNamespaces();
+        const unavailable = services.filter((ns) => !availableNamespaces.includes(ns));
+        if (unavailable.length > 0) {
+          warn(
+            "mcp-app-server",
+            `Requested services not available: ${unavailable.join(", ")}. Available: ${availableNamespaces.join(", ")}`
+          );
+        }
+        services = services.filter((ns) => availableNamespaces.includes(ns));
+      }
+      if (services.length > 0) manifestInput["services"] = services;
+      const manifest = buildManifest(manifestInput);
+      const project = buildProject(manifest.name, source, files, entry);
+      const projectFiles = Array.from(project.files.values());
+      try {
+        const hash = hashFiles(projectFiles, manifest);
+        await store.saveWidget(hash, projectFiles, manifest, project.entry);
+        const ref = { name: manifest.name, hash, entry: project.entry };
+        return {
+          content: [
+            renderResource(ref, inputs),
+            {
+              type: "text",
+              text: `Widget "${manifest.name}" saved. Hash: ${hash}
+Compiled in-browser at: ${directUrl(manifest.name, hash)}`
+            }
+          ]
+        };
+      } catch (error2) {
+        const message = error2 instanceof Error ? error2.message : String(error2);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to save widget: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  if (serviceBridge) {
+    serviceBridge.registerSearchServices(server);
+  }
+  registerAppTool(
+    server,
+    "list_widgets",
+    {
+      description: "List all persisted widgets in the VFS widget store. Returns each widget's name, version, description, path, and resource URI.",
+      _meta: { ui: { resourceUri: "ui://widgets/list" } }
+    },
+    async () => {
+      const widgets = await store.listWidgets();
+      if (widgets.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "No widgets stored in the VFS widget store."
+            }
+          ]
+        };
+      }
+      const lines = widgets.map((w) => {
+        const parts = [`- **${w.name}** (v${w.version})`];
+        if (w.description) parts.push(`  ${w.description}`);
+        parts.push(`  Path: ${w.path}`);
+        parts.push(`  URI: ${w.resourceUri}`);
+        if (w.entry) parts.push(`  Entry: ${w.entry}`);
+        if (w.services && w.services.length > 0) parts.push(`  Services: ${w.services.join(", ")}`);
+        return parts.join("\n");
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Stored widgets (${widgets.length}):
+
+${lines.join("\n\n")}`
+          }
+        ]
+      };
+    }
+  );
+  registerAppTool(
+    server,
+    "render_widget",
+    {
+      description: "Render a persisted widget by its name and hash. Serves the saved widget as an MCP App resource that compiles in the browser, optionally supplying startup props via `inputs`.",
+      inputSchema: {
+        name: z2.string().describe("Widget name (as stored in the VFS widget store)."),
+        hash: z2.string().optional().describe(
+          "Widget content hash. If omitted, renders the most recent version of the named widget."
+        ),
+        inputs: z2.record(z2.unknown()).optional().describe("Startup props passed to the widget's default export when it is rendered.")
+      },
+      _meta: {
+        ui: { resourceUri: "ui://widgets/{name}/{hash}/view.html" }
+      }
+    },
+    async (args) => {
+      const name = args?.["name"];
+      const hashInput = args?.["hash"];
+      const inputs = args?.["inputs"] ?? {};
+      if (!name) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: "Widget name is required."
+            }
+          ],
+          isError: true
+        };
+      }
+      let hash = hashInput;
+      if (!hash) {
+        const widgets = await store.listWidgets();
+        const match = widgets.find((w) => w.name === name);
+        if (!match) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `No stored widget found with name "${name}".`
+              }
+            ],
+            isError: true
+          };
+        }
+        const resourcePath = match.resourceUri.replace("ui://widgets/", "").replace("/view.html", "");
+        const parts = resourcePath.split("/");
+        hash = parts[1] ?? parts[0] ?? "";
+      }
+      if (!hash) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Could not determine hash for widget "${name}".`
+            }
+          ],
+          isError: true
+        };
+      }
+      const widget = await store.getWidget(name, hash);
+      if (!widget) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Widget "${name}" with hash "${hash}" not found in the VFS store.`
+            }
+          ],
+          isError: true
+        };
+      }
+      const ref = { name, hash, entry: widget.entry };
+      return {
+        content: [
+          renderResource(ref, inputs),
+          {
+            type: "text",
+            text: `Rendered widget "${name}" (hash: ${hash}).
+Compiled in-browser at: ${directUrl(name, hash)}`
+          }
+        ]
+      };
+    }
+  );
+  registerLiveUpdateTools(server);
+  return server;
+}
+function registerLiveUpdateTools(server) {
+  server.registerTool(
+    "subscribe_stream",
+    {
+      description: "Subscribe this widget session to a named data stream. The server will send `notifications/tools/list_changed` whenever new events arrive; the widget should then call `poll_updates` to fetch them. Returns the current sequence number so the widget knows where to start polling.",
+      inputSchema: {
+        stream: z2.string().describe("Name of the data stream to subscribe to."),
+        session_id: z2.string().optional().describe(
+          "MCP session ID. Widgets should pass the value returned in the Mcp-Session-Id response header during initialization."
+        )
+      }
+    },
+    (args, extra) => {
+      const stream = args["stream"];
+      const sessionId = args["session_id"] ?? extra["sessionId"];
+      if (sessionId) {
+        subscribeSession(sessionId, stream);
+      }
+      const seq = currentSeq();
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, stream, seq })
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "poll_updates",
+    {
+      description: "Fetch buffered events for a data stream that arrived after the given sequence number. Call this after receiving a `notifications/tools/list_changed` notification (which the server sends when new data is available). Pass the highest `seq` value from the last successful poll to avoid duplicates.",
+      inputSchema: {
+        stream: z2.string().describe("Name of the data stream to poll."),
+        after_seq: z2.number().int().default(0).describe(
+          "Return only events with seq > after_seq. Pass 0 to retrieve all buffered events."
+        )
+      }
+    },
+    (args) => {
+      const stream = args["stream"];
+      const afterSeq = args["after_seq"] ?? 0;
+      const events = getEvents(stream, afterSeq);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, stream, events })
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "push_update",
+    {
+      description: "Push a data update onto a named stream, broadcasting it to all subscribed widget sessions. Subscribing widgets will receive a `notifications/tools/list_changed` signal and then call `poll_updates` to retrieve the new data. Use this tool from server-side code or as an LLM tool to drive real-time widget updates.",
+      inputSchema: {
+        stream: z2.string().describe("Name of the data stream to push to."),
+        data: z2.record(z2.unknown()).describe("Arbitrary JSON-serialisable payload to push to subscribers.")
+      }
+    },
+    async (args) => {
+      const stream = args["stream"];
+      const data = args["data"];
+      const seq = await pushStreamUpdate(stream, data);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: true, stream, seq })
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tunnel.ts
+import { spawn } from "child_process";
+var tunnelProcess = null;
+var tunnelUrl = null;
+async function waitForTunnelLive(url, timeoutMs = 3e4) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try {
+      const res = await fetch(`${url}/health`, { signal: AbortSignal.timeout(5e3) });
+      if (res.ok) return true;
+    } catch {
+    }
+    await new Promise((r) => setTimeout(r, 1e3));
+  }
+  return false;
+}
+async function startTunnel(port) {
+  if (tunnelUrl) return tunnelUrl;
+  const detectedUrl = await new Promise((resolve2, reject) => {
+    const args = ["tunnel", "--url", `http://localhost:${port}`];
+    log("tunnel", `Starting cloudflared tunnel for port ${port}...`);
+    tunnelProcess = spawn("cloudflared", args, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let resolved = false;
+    const timeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        reject(new Error("Tunnel startup timed out after 30s"));
+      }
+    }, 3e4);
+    const handleOutput = (data) => {
+      const text = data.toString();
+      const urlMatch = text.match(/https:\/\/[^\s]+\.trycloudflare\.com\/?/);
+      if (urlMatch && !resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        resolve2(urlMatch[0].replace(/\/$/, ""));
+      }
+    };
+    tunnelProcess.stdout?.on("data", handleOutput);
+    tunnelProcess.stderr?.on("data", handleOutput);
+    tunnelProcess.on("error", (err) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        error("tunnel", "Failed to start cloudflared:", err);
+        reject(err);
+      }
+    });
+    tunnelProcess.on("exit", (code) => {
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        reject(new Error(`cloudflared exited with code ${code}`));
+      }
+      tunnelProcess = null;
+      tunnelUrl = null;
+    });
+  });
+  log("tunnel", `Tunnel hostname detected (${detectedUrl}); verifying reachability...`);
+  const live = await waitForTunnelLive(detectedUrl);
+  if (!live) {
+    error(
+      "tunnel",
+      `Tunnel ${detectedUrl} did not become reachable within 30s \u2014 publishing anyway, but widgets may fail to load until the edge route propagates.`
+    );
+  } else {
+    log("tunnel", `Tunnel verified reachable: ${detectedUrl}`);
+  }
+  tunnelUrl = detectedUrl;
+  return tunnelUrl;
+}
+function stopTunnel() {
+  if (tunnelProcess) {
+    tunnelProcess.kill();
+    tunnelProcess = null;
+    tunnelUrl = null;
+  }
+}
+
+// src/server.ts
+var PORT = Number(process.env["PORT"] ?? 3e3);
+var WIDGET_PORT = Number(process.env["WIDGET_PORT"] ?? 3002);
+var HOST = process.env["HOST"] ?? "0.0.0.0";
+var TRANSPORT = process.env["TRANSPORT"] ?? (process.argv.includes("--stdio") ? "stdio" : "http");
+var WIDGET_TUNNEL = process.env["WIDGET_TUNNEL"] === "true" || process.argv.includes("--tunnel");
+var WIDGET_STATE_FILE = join3(tmpdir(), `patchwork-widget-${WIDGET_PORT}.json`);
+function readWidgetHostState() {
+  try {
+    return JSON.parse(readFileSync(WIDGET_STATE_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function publishWidgetHostState(baseUrl) {
+  try {
+    const state = { 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) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    return err.code === "EPERM";
+  }
+}
+async function awaitPublishedWidgetBaseUrl(timeoutMs = 35e3) {
+  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;
+}
+function resolveDistDir(name) {
+  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];
+}
+function resolveRuntimeDir() {
+  return resolveDistDir("runtime");
+}
+function resolveShellDir() {
+  return resolveDistDir("shell");
+}
+async function setupRegistryBackend() {
+  const REGISTRY_PROVIDERS = process.env["REGISTRY_PROVIDERS"];
+  if (!REGISTRY_PROVIDERS) {
+    return { registryBackend: null, serverOptions: {} };
+  }
+  const command = process.env["REGISTRY_COMMAND"] ?? "npx";
+  const extraArgs = process.env["REGISTRY_ARGS"]?.split(" ").filter(Boolean) ?? [];
+  const args = ["@utdk/mcp", ...extraArgs];
+  log("mcp-app-server", `Connecting to Registry MCP server (providers: ${REGISTRY_PROVIDERS})...`);
+  try {
+    const registryBackend = await createRegistryBackend({
+      command,
+      args,
+      providers: REGISTRY_PROVIDERS
+    });
+    const toolInfos = registryBackend.getToolInfos();
+    const namespaces = [...new Set(toolInfos.map((t) => t.namespace))];
+    log(
+      "mcp-app-server",
+      `Registry ready: ${toolInfos.length} tools across namespaces: ${namespaces.join(", ")}`
+    );
+    return {
+      registryBackend,
+      serverOptions: {
+        services: {
+          backend: registryBackend,
+          tools: toolInfos
+        }
+      }
+    };
+  } catch (err) {
+    error("mcp-app-server", "Failed to connect to Registry MCP server:", err);
+    error("mcp-app-server", "Starting without Registry service backend.");
+    return { registryBackend: null, serverOptions: {} };
+  }
+}
+function handleExistingSession(existing, req, res) {
+  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, sessionStore, req, res) {
+  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, serverOptions) {
+  const sessionStore = /* @__PURE__ */ new Map();
+  app.all("/mcp", async (req, res) => {
+    const sessionId = req.headers["mcp-session-id"];
+    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) {
+  const shutdown = () => {
+    if (registryBackend) {
+      registryBackend.close().catch(() => {
+      });
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+async function startServer() {
+  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    \u2014 MCP Streamable HTTP endpoint (stateful sessions)`);
+    log("mcp-app-server", `  GET  /health \u2014 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() {
+  const widgetApp = express();
+  widgetApp.use(cors());
+  const store = getWidgetStore();
+  widgetApp.use("/shell", express.static(resolveShellDir()));
+  widgetApp.use("/runtime", express.static(resolveRuntimeDir()));
+  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" });
+    }
+  });
+  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" });
+  });
+  const isOwner = await new Promise((resolve2) => {
+    const httpServer = widgetApp.listen(WIDGET_PORT, HOST, () => {
+      log("mcp-app-server", `Widget server listening on http://${HOST}:${WIDGET_PORT}`);
+      resolve2(true);
+    });
+    httpServer.on("error", (err) => {
+      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);
+      }
+      resolve2(false);
+    });
+  });
+  if (!isOwner) {
+    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}`;
+  }
+  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() {
+  const { registryBackend, serverOptions } = await setupRegistryBackend();
+  log("mcp-app-server", "Starting MCP App Server in stdio mode...");
+  const widgetBaseUrl = await startWidgetServer();
+  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() {
+  if (TRANSPORT === "stdio") {
+    await startStdioServer();
+  } else {
+    await startServer();
+  }
+}
+main().catch((err) => {
+  error("mcp-app-server", "Fatal startup error:", err);
+  process.exit(1);
+});
+export {
+  resolveRuntimeDir,
+  resolveShellDir
+};
+//# sourceMappingURL=server.js.map