@aprovan/mcp-app-server 0.1.0-dev.c1ac1dc

package/dist/server.js

@@ -0,0 +1,1841 @@
+// src/server.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import cors from "cors";
+
+// 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) => {
+        console.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 {
+    console.warn("[registry-backend] Failed to parse tool list response from Registry");
+    return [];
+  }
+  if (!Array.isArray(toolNames)) {
+    console.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) {
+          console.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;
+  console.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
+} from "@aprovan/patchwork-compiler";
+import {
+  registerAppTool,
+  registerAppResource,
+  RESOURCE_MIME_TYPE
+} from "@modelcontextprotocol/ext-apps/server";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z2 } from "zod";
+
+// src/compiler/compile.ts
+import { randomUUID } from "crypto";
+import { mkdir, writeFile, rm, readFile } from "fs/promises";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  createCompiler,
+  loadImage
+} from "@aprovan/patchwork-compiler";
+import react from "@vitejs/plugin-react";
+import { build } from "vite";
+import { viteSingleFile } from "vite-plugin-singlefile";
+
+// src/shim.ts
+var DEFAULT_EXT_APPS_VERSION = "^1.7.3";
+function generateServiceShim(options) {
+  const {
+    namespaces,
+    extAppsVersion = DEFAULT_EXT_APPS_VERSION
+  } = options;
+  if (namespaces.length === 0) return "";
+  const namespacesJson = JSON.stringify(namespaces);
+  const importUrl = `https://esm.sh/@modelcontextprotocol/ext-apps@${extAppsVersion}`;
+  return `
+import { App } from '${importUrl}';
+
+const __patchwork_app = new App({ name: 'patchwork-widget', version: '0.1.0' });
+const __patchwork_ready = __patchwork_app.connect().catch(function(err) {
+  console.error('[patchwork] Failed to connect to host:', err);
+});
+
+function __patchwork_createNamespaceProxy(namespace) {
+  return new Proxy({}, {
+    get: function(target, prop) {
+      if (typeof prop !== 'string') return undefined;
+      return function __patchwork_serviceCall(args) {
+        var toolName = namespace + '__' + prop;
+        return __patchwork_ready.then(function() {
+          return __patchwork_app.callServerTool({ name: toolName, arguments: args || {} });
+        }).then(function(result) {
+          if (result.isError) {
+            var errorMsg = result.content && result.content[0] && result.content[0].text
+              ? result.content[0].text
+              : 'Service call failed: ' + namespace + '.' + prop;
+            throw new Error(errorMsg);
+          }
+          var textContent = result.content && result.content.find(function(c) { return c.type === 'text'; });
+          if (textContent) {
+            try { return JSON.parse(textContent.text); }
+            catch (e) { return textContent.text; }
+          }
+          return result;
+        });
+      };
+    }
+  });
+}
+
+var __patchwork_namespaces = ${namespacesJson};
+for (var __i = 0; __i < __patchwork_namespaces.length; __i++) {
+  var __ns = __patchwork_namespaces[__i];
+  window[__ns] = __patchwork_createNamespaceProxy(__ns);
+}
+`;
+}
+function generateLiveUpdateShim(options = {}) {
+  const { extAppsVersion = DEFAULT_EXT_APPS_VERSION } = options;
+  const importUrl = `https://esm.sh/@modelcontextprotocol/ext-apps@${extAppsVersion}`;
+  return `
+import { App } from '${importUrl}';
+
+// Shared App instance \u2014 the service shim may have already created this.
+if (!window.__patchwork_app) {
+  window.__patchwork_app = new App({ name: 'patchwork-widget', version: '0.1.0' });
+  window.__patchwork_ready = window.__patchwork_app.connect().catch(function(err) {
+    console.error('[patchwork] Failed to connect to host:', err);
+  });
+}
+
+(function() {
+  var __app = window.__patchwork_app;
+  var __ready = window.__patchwork_ready;
+
+  // Per-stream state: { seq, callbacks }
+  var __streams = {};
+  // MCP session ID captured after connect
+  var __sessionId = null;
+
+  function __parseResult(result) {
+    if (!result || !result.content) return result;
+    var textContent = result.content.find(function(c) { return c.type === 'text'; });
+    if (textContent) {
+      try { return JSON.parse(textContent.text); }
+      catch (e) { return textContent.text; }
+    }
+    return result;
+  }
+
+  function __pollStream(stream) {
+    var state = __streams[stream];
+    if (!state) return;
+    var afterSeq = state.seq;
+    __app.callServerTool({ name: 'poll_updates', arguments: { stream: stream, after_seq: afterSeq } })
+      .then(function(result) {
+        var parsed = __parseResult(result);
+        if (!parsed || !parsed.success || !parsed.events || !parsed.events.length) return;
+        var events = parsed.events;
+        for (var i = 0; i < events.length; i++) {
+          var ev = events[i];
+          if (ev.seq > state.seq) {
+            state.seq = ev.seq;
+          }
+          for (var j = 0; j < state.callbacks.length; j++) {
+            try { state.callbacks[j](ev.data, ev.seq, stream); }
+            catch (cbErr) { console.error('[patchwork] subscribe callback error:', cbErr); }
+          }
+        }
+      })
+      .catch(function(err) {
+        console.warn('[patchwork] poll_updates failed for stream ' + stream + ':', err);
+      });
+  }
+
+  // When tools/list_changed fires, poll all subscribed streams.
+  __app.setNotificationHandler(
+    { method: 'notifications/tools/list_changed', params: {} },
+    function() {
+      var streamNames = Object.keys(__streams);
+      for (var i = 0; i < streamNames.length; i++) {
+        __pollStream(streamNames[i]);
+      }
+      return Promise.resolve();
+    }
+  );
+
+  // Expose the public patchwork API on window.
+  window.patchwork = {
+    /**
+     * Subscribe to a named data stream.
+     *
+     * @param {string} stream - Stream name (e.g. "price_feed").
+     * @param {function} callback - Called with (data, seq, stream) for each event.
+     * @returns {function} Unsubscribe function.
+     */
+    subscribe: function(stream, callback) {
+      if (!__streams[stream]) {
+        __streams[stream] = { seq: 0, callbacks: [] };
+        // Tell the server about this subscription once the App is connected.
+        __ready.then(function() {
+          var args = { stream: stream };
+          if (__sessionId) args.session_id = __sessionId;
+          return __app.callServerTool({ name: 'subscribe_stream', arguments: args });
+        }).then(function(result) {
+          var parsed = __parseResult(result);
+          if (parsed && typeof parsed.seq === 'number') {
+            // Start polling from the server's current seq.
+            if (__streams[stream]) {
+              __streams[stream].seq = parsed.seq;
+            }
+          }
+        }).catch(function(err) {
+          console.warn('[patchwork] subscribe_stream failed:', err);
+        });
+      }
+      __streams[stream].callbacks.push(callback);
+      return function unsubscribe() {
+        if (!__streams[stream]) return;
+        var idx = __streams[stream].callbacks.indexOf(callback);
+        if (idx !== -1) __streams[stream].callbacks.splice(idx, 1);
+      };
+    },
+
+    /**
+     * Push the widget's current state into the conversation context.
+     * The model will include this in its next response.
+     *
+     * @param {string|Array} content - Text string or array of MCP ContentBlock objects.
+     */
+    updateContext: function(content) {
+      return __ready.then(function() {
+        var params;
+        if (typeof content === 'string') {
+          params = { content: [{ type: 'text', text: content }] };
+        } else if (Array.isArray(content)) {
+          params = { content: content };
+        } else if (content && typeof content === 'object') {
+          params = { structuredContent: content };
+        } else {
+          params = { content: [{ type: 'text', text: String(content) }] };
+        }
+        return __app.request({ method: 'ui/update-model-context', params: params }, {});
+      });
+    },
+
+    /**
+     * Fire a client event as an MCP tool call. Use this to surface user
+     * interactions so the LLM can observe and react to them.
+     *
+     * @param {string} toolName - MCP tool name on the server.
+     * @param {object} args - Tool arguments.
+     */
+    fireEvent: function(toolName, args) {
+      return __ready.then(function() {
+        return __app.callServerTool({ name: toolName, arguments: args || {} });
+      }).then(function(result) {
+        return __parseResult(result);
+      });
+    },
+  };
+
+  // Capture the session ID from the host context on connect.
+  __ready.then(function() {
+    // The host context is available via getHostContext(); we can't get the
+    // session ID directly, but it's passed in subscribe_stream args from
+    // user code. Expose a setter so widgets can supply it explicitly.
+    window.patchwork._setSessionId = function(id) { __sessionId = id; };
+  }).catch(function() {});
+})();
+`;
+}
+
+// src/compiler/cache.ts
+import { createHash } from "crypto";
+var MAX_CACHE_SIZE = 256;
+var cache = /* @__PURE__ */ new Map();
+function computeCacheKey(source, manifest) {
+  const parts = [];
+  if (typeof source === "string") {
+    parts.push(source);
+  } else {
+    const sortedFiles = Array.from(source.files.entries()).sort(
+      ([a], [b]) => a.localeCompare(b)
+    );
+    for (const [path, file] of sortedFiles) {
+      parts.push(`${path}::${file.content}`);
+    }
+    parts.push(`entry:${source.entry}`);
+  }
+  parts.push(JSON.stringify(manifest));
+  return createHash("sha256").update(parts.join("\n")).digest("hex").slice(0, 16);
+}
+function get(hash) {
+  return cache.get(hash);
+}
+function set(hash, entry) {
+  if (cache.size >= MAX_CACHE_SIZE) {
+    const entries = Array.from(cache.entries());
+    entries.sort((a, b) => a[1].createdAt - b[1].createdAt);
+    const toRemove = entries.slice(0, Math.floor(MAX_CACHE_SIZE / 4));
+    for (const [key] of toRemove) {
+      cache.delete(key);
+    }
+  }
+  cache.set(hash, entry);
+}
+function has(hash) {
+  return cache.has(hash);
+}
+function allEntries() {
+  return Array.from(cache.entries());
+}
+
+// src/compiler/cdn-plugin.ts
+var ESM_SH_BASE = "https://esm.sh";
+var REACT_EXPORTS = [
+  "useState",
+  "useEffect",
+  "useCallback",
+  "useMemo",
+  "useRef",
+  "useContext",
+  "useReducer",
+  "useLayoutEffect",
+  "useId",
+  "createContext",
+  "createElement",
+  "cloneElement",
+  "createRef",
+  "forwardRef",
+  "lazy",
+  "memo",
+  "Fragment",
+  "Suspense",
+  "StrictMode",
+  "Component",
+  "PureComponent",
+  "Children",
+  "isValidElement"
+];
+var REACT_DOM_EXPORTS = [
+  "createPortal",
+  "flushSync",
+  "render",
+  "hydrate",
+  "unmountComponentAtNode"
+];
+function toEsmShUrl(packageName, version, subpath, deps) {
+  let url = `${ESM_SH_BASE}/${packageName}`;
+  if (version) url += `@${version}`;
+  if (subpath) url += `/${subpath}`;
+  if (deps && Object.keys(deps).length > 0) {
+    const depsStr = Object.entries(deps).map(([name, ver]) => `${name}@${ver}`).join(",");
+    url += `?deps=${depsStr}`;
+  }
+  return url;
+}
+function parseImportPath(importPath) {
+  if (importPath.startsWith("@")) {
+    const parts2 = importPath.split("/");
+    if (parts2.length >= 2) {
+      const packageName = `${parts2[0]}/${parts2[1]}`;
+      const subpath = parts2.slice(2).join("/");
+      return { packageName, subpath: subpath || void 0 };
+    }
+  }
+  const parts = importPath.split("/");
+  return { packageName: parts[0] ?? "", subpath: parts.slice(1).join("/") || void 0 };
+}
+function isBareImport(path) {
+  return !(path.startsWith(".") || path.startsWith("/") || path.startsWith("http://") || path.startsWith("https://"));
+}
+function matchAlias(importPath, aliases) {
+  for (const [pattern, target] of Object.entries(aliases)) {
+    if (pattern.endsWith("/*")) {
+      const prefix = pattern.slice(0, -2);
+      if (importPath === prefix || importPath.startsWith(prefix + "/")) {
+        return target;
+      }
+    }
+    if (importPath === pattern) {
+      return target;
+    }
+  }
+  return null;
+}
+function patchworkCdnPlugin(options) {
+  const { imageConfig } = options;
+  const globals = imageConfig.framework?.globals ?? {};
+  const deps = imageConfig.framework?.deps ?? {};
+  const aliases = imageConfig.aliases ?? {};
+  const packages = options.packages ?? {};
+  const globalsSet = new Set(Object.keys(globals));
+  return {
+    name: "patchwork-cdn",
+    enforce: "pre",
+    resolveId(source) {
+      if (!isBareImport(source)) return null;
+      const aliasTarget = matchAlias(source, aliases);
+      if (aliasTarget) {
+        const { packageName: packageName2, subpath: subpath2 } = parseImportPath(aliasTarget);
+        if (globalsSet.has(packageName2)) {
+          return `${packageName2}${subpath2 ? `/${subpath2}` : ""}`;
+        }
+        const version2 = packages[packageName2];
+        const url2 = toEsmShUrl(
+          packageName2,
+          version2,
+          subpath2,
+          Object.keys(deps).length > 0 ? deps : void 0
+        );
+        return { id: url2, external: true };
+      }
+      const { packageName, subpath } = parseImportPath(source);
+      if (globalsSet.has(packageName)) {
+        return source;
+      }
+      const version = packages[packageName];
+      const url = toEsmShUrl(
+        packageName,
+        version,
+        subpath,
+        Object.keys(deps).length > 0 ? deps : void 0
+      );
+      return { id: url, external: true };
+    },
+    load(id) {
+      const { packageName, subpath } = parseImportPath(id);
+      const globalName = globals[packageName];
+      if (!globalName) return null;
+      if (subpath) {
+        const url = toEsmShUrl(
+          packageName,
+          packages[packageName],
+          subpath,
+          Object.keys(deps).length > 0 ? deps : void 0
+        );
+        return `export * from '${url}'; export { default } from '${url}';`;
+      }
+      const commonExports = packageName === "react" ? REACT_EXPORTS : packageName === "react-dom" ? REACT_DOM_EXPORTS : [];
+      const lines = [
+        `const mod = window.${globalName};`,
+        `export default mod;`
+      ];
+      if (commonExports.length > 0) {
+        lines.push(
+          `const { ${commonExports.join(", ")} } = mod;`,
+          `export { ${commonExports.join(", ")} };`
+        );
+      }
+      return lines.join("\n");
+    }
+  };
+}
+function getPreloadScripts(imageConfig) {
+  const preload = imageConfig.framework?.preload ?? [];
+  return preload.map((url) => `<script src="${url}"></script>`);
+}
+
+// src/compiler/compile.ts
+var WIDGET_RESOURCE_PREFIX = "ui://widget/";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var COMPILE_TMP_DIR = resolve(__dirname2, "..", ".compile-tmp");
+var FALLBACK_IMAGE_CONFIG = {
+  platform: "browser",
+  esbuild: { target: "es2020", format: "esm", jsx: "automatic" },
+  framework: {
+    globals: { react: "React", "react-dom": "ReactDOM" },
+    preload: [
+      "https://esm.sh/react@18",
+      "https://esm.sh/react-dom@18/client"
+    ],
+    deps: { react: "18", "react-dom": "18" }
+  }
+};
+var loadedImage = null;
+var imageLoadPromise = null;
+async function getImageConfig() {
+  if (loadedImage) return loadedImage.config;
+  if (imageLoadPromise) return imageLoadPromise.then((img) => img.config);
+  imageLoadPromise = (async () => {
+    try {
+      loadedImage = await loadImage("@aprovan/patchwork-image-shadcn");
+      return loadedImage;
+    } catch {
+      const compiler = await createCompiler({
+        image: "@aprovan/patchwork-image-shadcn",
+        proxyUrl: ""
+      });
+      await compiler.preloadImage("@aprovan/patchwork-image-shadcn");
+      const registry = compiler.registry;
+      const img = registry?.get("@aprovan/patchwork-image-shadcn");
+      if (img) {
+        loadedImage = img;
+        return img;
+      }
+      return { config: FALLBACK_IMAGE_CONFIG };
+    }
+  })();
+  return imageLoadPromise.then((img) => img.config);
+}
+function generateHtmlEntry(preloads, cssVars) {
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  ${preloads.join("\n  ")}
+  <script src="https://cdn.tailwindcss.com"></script>
+  <script>
+    window.tailwind = window.tailwind || {};
+    window.tailwind.config = {
+      darkMode: "class",
+      theme: {
+        extend: {
+          colors: {
+            border: "hsl(var(--border))",
+            input: "hsl(var(--input))",
+            ring: "hsl(var(--ring))",
+            background: "hsl(var(--background))",
+            foreground: "hsl(var(--foreground))",
+            primary: { DEFAULT: "hsl(var(--primary))", foreground: "hsl(var(--primary-foreground))" },
+            secondary: { DEFAULT: "hsl(var(--secondary))", foreground: "hsl(var(--secondary-foreground))" },
+            destructive: { DEFAULT: "hsl(var(--destructive))", foreground: "hsl(var(--destructive-foreground))" },
+            muted: { DEFAULT: "hsl(var(--muted))", foreground: "hsl(var(--muted-foreground))" },
+            accent: { DEFAULT: "hsl(var(--accent))", foreground: "hsl(var(--accent-foreground))" },
+            popover: { DEFAULT: "hsl(var(--popover))", foreground: "hsl(var(--popover-foreground))" },
+            card: { DEFAULT: "hsl(var(--card))", foreground: "hsl(var(--card-foreground))" },
+          },
+          borderRadius: { lg: "var(--radius)", md: "calc(var(--radius) - 2px)", sm: "calc(var(--radius) - 4px)" },
+        },
+      },
+    };
+  </script>
+  <style>
+    :root {
+      ${cssVars}
+    }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+  <script type="module" src="/src/_app.tsx"></script>
+</body>
+</html>`;
+}
+var SHADCN_CSS_VARS = `
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+    --primary: 222.2 47.4% 11.2%;
+    --primary-foreground: 210 40% 98%;
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 222.2 84% 4.9%;
+    --radius: 0.5rem;
+`.trim();
+function generateMainTsx(entryModule) {
+  return `import React from 'react';
+import { createRoot } from 'react-dom/client';
+import Widget from './${entryModule}';
+
+const rootEl = document.getElementById('root');
+if (rootEl) {
+  const root = createRoot(rootEl);
+  root.render(React.createElement(Widget));
+}
+`;
+}
+async function writeProjectFiles(projectDir, source) {
+  const srcDir = join(projectDir, "src");
+  await mkdir(srcDir, { recursive: true });
+  if (typeof source === "string") {
+    await writeFile(join(srcDir, "widget.tsx"), source, "utf-8");
+    return "widget";
+  }
+  for (const [filePath, file] of source.files) {
+    const fullPath = filePath.startsWith("src/") ? join(projectDir, filePath) : join(srcDir, filePath);
+    const dir = resolve(fullPath, "..");
+    await mkdir(dir, { recursive: true });
+    await writeFile(fullPath, file.content, "utf-8");
+  }
+  const entry = source.entry;
+  const entryName = entry.replace(/\.(tsx|ts|jsx|js)$/, "");
+  return entryName.startsWith("src/") ? entryName.slice(4) : entryName;
+}
+function injectShimIntoHtml(html, shimScript) {
+  const shimTag = `<script type="module">
+${shimScript}
+</script>`;
+  const bodyCloseIndex = html.lastIndexOf("</body>");
+  if (bodyCloseIndex === -1) return html;
+  return html.slice(0, bodyCloseIndex) + shimTag + "\n" + html.slice(bodyCloseIndex);
+}
+async function compileWidget(source, manifest, options = {}) {
+  const liveUpdates = options.liveUpdates ?? true;
+  const baseCacheKey = computeCacheKey(source, manifest);
+  let cacheKey = baseCacheKey;
+  if (options.services?.length) {
+    cacheKey += `:svc:${options.services.sort().join(",")}`;
+  }
+  if (liveUpdates) {
+    cacheKey += `:live`;
+  }
+  if (has(cacheKey)) {
+    const cached = get(cacheKey);
+    return {
+      html: cached.html,
+      hash: cacheKey,
+      resourceUri: cached.resourceUri
+    };
+  }
+  const imageConfig = await getImageConfig();
+  await mkdir(COMPILE_TMP_DIR, { recursive: true });
+  const projectDir = join(COMPILE_TMP_DIR, `build-${randomUUID()}`);
+  try {
+    await mkdir(projectDir, { recursive: true });
+    const entryModule = await writeProjectFiles(projectDir, source);
+    await writeFile(
+      join(projectDir, "src", "_app.tsx"),
+      generateMainTsx(entryModule),
+      "utf-8"
+    );
+    const preloads = getPreloadScripts(imageConfig);
+    const htmlContent = generateHtmlEntry(preloads, SHADCN_CSS_VARS);
+    await writeFile(join(projectDir, "index.html"), htmlContent, "utf-8");
+    const viteConfig = {
+      root: projectDir,
+      base: "./",
+      plugins: [
+        patchworkCdnPlugin({ imageConfig }),
+        react({
+          jsxRuntime: "classic"
+        }),
+        viteSingleFile({ useRecommendedBuildConfig: true })
+      ],
+      build: {
+        outDir: "dist",
+        emptyOutDir: true,
+        minify: false,
+        rollupOptions: {
+          input: resolve(projectDir, "index.html")
+        }
+      },
+      logLevel: "silent"
+    };
+    await build(viteConfig);
+    const outputHtml = await readFile(
+      join(projectDir, "dist", "index.html"),
+      "utf-8"
+    );
+    const shimParts = [];
+    if (liveUpdates) {
+      shimParts.push(generateLiveUpdateShim());
+    }
+    if (options.services?.length) {
+      shimParts.push(generateServiceShim({ namespaces: options.services }));
+    }
+    let finalHtml = outputHtml;
+    for (const script of shimParts) {
+      finalHtml = injectShimIntoHtml(finalHtml, script);
+    }
+    const resourceUri = `${WIDGET_RESOURCE_PREFIX}${cacheKey}/view.html`;
+    const cacheEntry = {
+      html: finalHtml,
+      manifest,
+      resourceUri,
+      createdAt: Date.now()
+    };
+    set(cacheKey, cacheEntry);
+    return { html: finalHtml, hash: cacheKey, resourceUri };
+  } finally {
+    await rm(projectDir, { recursive: true, force: true });
+  }
+}
+
+// src/hello-world.html
+var hello_world_default = '<!DOCTYPE html>\n<html lang="en">\n  <head>\n    <meta charset="utf-8" />\n    <meta name="viewport" content="width=device-width, initial-scale=1" />\n    <title>Hello World \u2014 Patchwork MCP App</title>\n    <style>\n      *,\n      *::before,\n      *::after {\n        box-sizing: border-box;\n      }\n\n      body {\n        margin: 0;\n        font-family: system-ui, -apple-system, sans-serif;\n        background: #f0f4ff;\n        display: flex;\n        align-items: center;\n        justify-content: center;\n        min-height: 100vh;\n      }\n\n      .card {\n        background: #fff;\n        border-radius: 1rem;\n        box-shadow: 0 4px 24px rgba(0, 0, 0, 0.08);\n        padding: 2.5rem 3rem;\n        text-align: center;\n        max-width: 420px;\n        width: 100%;\n      }\n\n      .wave {\n        font-size: 3rem;\n        line-height: 1;\n        margin-bottom: 1rem;\n      }\n\n      h1 {\n        margin: 0 0 0.75rem;\n        font-size: 1.75rem;\n        color: #111827;\n      }\n\n      p {\n        margin: 0;\n        color: #6b7280;\n        font-size: 0.95rem;\n        line-height: 1.6;\n      }\n\n      .badge {\n        display: inline-block;\n        margin-top: 1.5rem;\n        background: #eff6ff;\n        color: #3b82f6;\n        font-size: 0.75rem;\n        font-weight: 600;\n        letter-spacing: 0.05em;\n        text-transform: uppercase;\n        padding: 0.25rem 0.75rem;\n        border-radius: 999px;\n      }\n    </style>\n  </head>\n  <body>\n    <div class="card">\n      <div class="wave">\u{1F44B}</div>\n      <h1>Hello, world!</h1>\n      <p>\n        This widget is served by the <strong>Patchwork MCP App Server</strong>.\n        It renders inline inside Claude Desktop and Claude web via a\n        <code>StreamableHTTPServerTransport</code>.\n      </p>\n      <span class="badge">MCP App</span>\n    </div>\n  </body>\n</html>\n';
+
+// 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 (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            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()
+              })
+            }
+          ]
+        };
+      }
+    );
+  }
+  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 join3, resolve as resolve2 } from "path";
+
+// src/widget-store/local-backend.ts
+import { readFile as readFile2, writeFile as writeFile2, unlink, stat, mkdir as mkdir2, readdir, rm as rm2, access } from "fs/promises";
+import { join as join2, dirname as dirname2, normalize } from "path";
+function createDirEntry(name, isDir) {
+  return {
+    name,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+function createFileStats(size2, mtime, isDir) {
+  return {
+    size: size2,
+    mtime,
+    isFile: () => !isDir,
+    isDirectory: () => isDir
+  };
+}
+var LocalFileBackend = class {
+  constructor(basePath) {
+    this.basePath = basePath;
+  }
+  basePath;
+  resolve(path) {
+    return join2(this.basePath, normalize(path));
+  }
+  async readFile(path) {
+    return readFile2(this.resolve(path), "utf-8");
+  }
+  async writeFile(path, content) {
+    const fullPath = this.resolve(path);
+    await mkdir2(dirname2(fullPath), { recursive: true });
+    await writeFile2(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 mkdir2(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 rm2(this.resolve(path), { recursive: true, force: true });
+    } else {
+      await rm2(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 RESOURCE_URI_PREFIX = "ui://widgets/";
+var DEFAULT_STORAGE_DIR = ".widget-store";
+var WidgetStore = class {
+  provider;
+  storageDir;
+  constructor(options = {}) {
+    this.storageDir = resolve2(options.storageDir ?? DEFAULT_STORAGE_DIR);
+    this.provider = options.backend ?? new LocalFileBackend(this.storageDir);
+  }
+  fullPath(virtualPath) {
+    return join3(WIDGETS_PREFIX, virtualPath);
+  }
+  async saveWidget(hash, html, manifest, entry) {
+    const widgetDir = `${manifest.name}/${hash}`;
+    const htmlVirtualPath = this.fullPath(`${widgetDir}/view.html`);
+    const manifestVirtualPath = this.fullPath(`${widgetDir}/manifest.json`);
+    await this.provider.writeFile(htmlVirtualPath, html);
+    await this.provider.writeFile(
+      manifestVirtualPath,
+      JSON.stringify({
+        ...manifest,
+        hash,
+        entry,
+        createdAt: Date.now()
+      })
+    );
+    return {
+      path: htmlVirtualPath,
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      html,
+      manifest,
+      entry,
+      createdAt: Date.now()
+    };
+  }
+  async getWidget(name, hash) {
+    const widgetDir = `${name}/${hash}`;
+    const htmlVirtualPath = this.fullPath(`${widgetDir}/view.html`);
+    const manifestVirtualPath = this.fullPath(`${widgetDir}/manifest.json`);
+    const exists = await this.provider.exists(htmlVirtualPath);
+    if (!exists) return null;
+    const html = await this.provider.readFile(htmlVirtualPath);
+    let manifest;
+    let entry;
+    let createdAt = Date.now();
+    try {
+      const raw = await this.provider.readFile(manifestVirtualPath);
+      const parsed = JSON.parse(raw);
+      manifest = {
+        name: parsed["name"],
+        version: parsed["version"],
+        platform: parsed["platform"] ?? "browser",
+        image: parsed["image"],
+        description: parsed["description"],
+        services: parsed["services"]
+      };
+      entry = parsed["entry"];
+      createdAt = parsed["createdAt"] ?? Date.now();
+    } catch {
+      manifest = {
+        name,
+        version: "0.1.0",
+        platform: "browser",
+        image: "@aprovan/patchwork-image-shadcn"
+      };
+    }
+    return {
+      path: htmlVirtualPath,
+      resourceUri: `${RESOURCE_URI_PREFIX}${widgetDir}/view.html`,
+      html,
+      manifest,
+      entry,
+      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(join3(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}/view.html`),
+              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}/view.html`));
+  }
+  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 HELLO_WORLD_RESOURCE_URI = "ui://hello-world/view.html";
+var MANIFEST_DEFAULTS = {
+  name: "widget",
+  version: "0.1.0",
+  platform: "browser",
+  image: "@aprovan/patchwork-image-shadcn"
+};
+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"]
+  };
+}
+function buildVirtualProject(source, files, entry) {
+  if (files && files.length > 0) {
+    const virtualFiles = files.map((f) => ({
+      path: f.path,
+      content: f.content
+    }));
+    return createProjectFromFiles(virtualFiles, entry);
+  }
+  return source ?? "export default function Widget() { return <div>Hello Patchwork</div>; }";
+}
+async function registerStoredWidgetResources(server, store) {
+  const widgets = await store.loadAll();
+  for (const widget of widgets) {
+    registerAppResource(
+      server,
+      `Widget ${widget.manifest.name}`,
+      widget.resourceUri,
+      {
+        description: widget.manifest.description ?? `Persisted widget: ${widget.manifest.name}`
+      },
+      async () => ({
+        contents: [
+          {
+            uri: widget.resourceUri,
+            mimeType: RESOURCE_MIME_TYPE,
+            text: widget.html
+          }
+        ]
+      })
+    );
+  }
+}
+function registerCachedWidgetResources(server) {
+  for (const [, entry] of allEntries()) {
+    registerAppResource(
+      server,
+      `Widget ${entry.manifest.name}`,
+      entry.resourceUri,
+      {
+        description: entry.manifest.description ?? `Compiled widget: ${entry.manifest.name}`
+      },
+      async () => ({
+        contents: [
+          {
+            uri: entry.resourceUri,
+            mimeType: RESOURCE_MIME_TYPE,
+            text: entry.html
+          }
+        ]
+      })
+    );
+  }
+}
+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 store = getWidgetStore();
+  registerAppTool(
+    server,
+    "hello_world",
+    {
+      description: "Display a hello-world widget inline in the conversation. Returns a static greeting card rendered as an MCP App.",
+      _meta: { ui: { resourceUri: HELLO_WORLD_RESOURCE_URI } }
+    },
+    async () => ({
+      content: [
+        {
+          type: "text",
+          text: "Hello, world! The widget is rendered inline above."
+        }
+      ]
+    })
+  );
+  registerAppResource(
+    server,
+    "Hello World View",
+    HELLO_WORLD_RESOURCE_URI,
+    {
+      description: "Hello-world HTML widget for the Patchwork MCP App Server demo."
+    },
+    async () => ({
+      contents: [
+        {
+          uri: HELLO_WORLD_RESOURCE_URI,
+          mimeType: RESOURCE_MIME_TYPE,
+          text: hello_world_default
+        }
+      ]
+    })
+  );
+  registerAppTool(
+    server,
+    "compile_widget",
+    {
+      description: "Compile a JSX/TSX widget into a self-contained HTML page served as an MCP App resource. Pass source code for a single-file widget, or a files array for a multi-file project. The compiled widget is cached in memory and persisted to the VFS widget store.",
+      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."
+        )
+      },
+      _meta: {
+        ui: { resourceUri: "ui://widget/{hash}/view.html" }
+      }
+    },
+    async (args) => {
+      const source = args?.["source"];
+      const files = args?.["files"];
+      const entry = args?.["entry"];
+      const requestedServices = args?.["services"];
+      const manifestInput = {};
+      if (args?.["name"]) manifestInput["name"] = args["name"];
+      if (args?.["image"]) manifestInput["image"] = args["image"];
+      if (requestedServices) manifestInput["services"] = requestedServices;
+      const manifest = buildManifest(manifestInput);
+      const project = buildVirtualProject(source, files, entry);
+      let compileServices;
+      if (requestedServices && requestedServices.length > 0 && serviceBridge) {
+        const availableNamespaces = serviceBridge.getNamespaces();
+        compileServices = requestedServices.filter(
+          (ns) => availableNamespaces.includes(ns)
+        );
+        const unavailable = requestedServices.filter(
+          (ns) => !availableNamespaces.includes(ns)
+        );
+        if (unavailable.length > 0) {
+          console.warn(
+            `[mcp-app-server] Requested services not available: ${unavailable.join(", ")}. Available: ${availableNamespaces.join(", ")}`
+          );
+        }
+      }
+      try {
+        const result = await compileWidget(
+          project,
+          manifest,
+          compileServices ? { services: compileServices } : {}
+        );
+        const entryPath = typeof project === "string" ? void 0 : project.entry;
+        await store.saveWidget(result.hash, result.html, manifest, entryPath);
+        const storedUri = store.resourceUriFor(manifest.name, result.hash);
+        registerAppResource(
+          server,
+          `Widget ${manifest.name}`,
+          storedUri,
+          {
+            description: manifest.description ?? `Persisted widget: ${manifest.name}`
+          },
+          async () => ({
+            contents: [
+              {
+                uri: storedUri,
+                mimeType: RESOURCE_MIME_TYPE,
+                text: result.html
+              }
+            ]
+          })
+        );
+        registerAppResource(
+          server,
+          `Widget ${manifest.name} (cached)`,
+          result.resourceUri,
+          {
+            description: `Compiled widget: ${manifest.name}`
+          },
+          async () => ({
+            contents: [
+              {
+                uri: result.resourceUri,
+                mimeType: RESOURCE_MIME_TYPE,
+                text: result.html
+              }
+            ]
+          })
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Widget compiled and persisted. Resource URI: ${storedUri}`
+            },
+            {
+              type: "text",
+              text: `Cache key: ${result.hash}`
+            }
+          ],
+          _meta: {
+            ui: { resourceUri: result.resourceUri }
+          }
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Compilation failed: ${message}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+  );
+  if (serviceBridge) {
+    serviceBridge.registerTools(server);
+    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 compiled widget as an MCP App resource rendered inline in the conversation.",
+      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.")
+      },
+      _meta: {
+        ui: { resourceUri: "ui://widgets/{name}/{hash}/view.html" }
+      }
+    },
+    async (args) => {
+      const name = args?.["name"];
+      const hashInput = args?.["hash"];
+      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
+        };
+      }
+      registerAppResource(
+        server,
+        `Widget ${widget.manifest.name}`,
+        widget.resourceUri,
+        {
+          description: widget.manifest.description ?? `Persisted widget: ${widget.manifest.name}`
+        },
+        async () => ({
+          contents: [
+            {
+              uri: widget.resourceUri,
+              mimeType: RESOURCE_MIME_TYPE,
+              text: widget.html
+            }
+          ]
+        })
+      );
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Rendering widget "${name}" (hash: ${hash}).`
+          }
+        ],
+        _meta: {
+          ui: { resourceUri: widget.resourceUri }
+        }
+      };
+    }
+  );
+  registerCachedWidgetResources(server);
+  void registerStoredWidgetResources(server, store);
+  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/server.ts
+var PORT = Number(process.env["PORT"] ?? 3e3);
+var HOST = process.env["HOST"] ?? "0.0.0.0";
+async function startServer() {
+  const serverOptions = {};
+  const REGISTRY_PROVIDERS = process.env["REGISTRY_PROVIDERS"];
+  let registryBackend = null;
+  if (REGISTRY_PROVIDERS) {
+    const command = process.env["REGISTRY_COMMAND"] ?? "npx";
+    const extraArgs = process.env["REGISTRY_ARGS"]?.split(" ").filter(Boolean) ?? [];
+    const args = ["@utdk/mcp-server", ...extraArgs];
+    console.log(
+      `[mcp-app-server] Connecting to Registry MCP server (providers: ${REGISTRY_PROVIDERS})...`
+    );
+    try {
+      registryBackend = await createRegistryBackend({
+        command,
+        args,
+        providers: REGISTRY_PROVIDERS
+      });
+      const toolInfos = registryBackend.getToolInfos();
+      serverOptions.services = {
+        backend: registryBackend,
+        tools: toolInfos
+      };
+      const namespaces = [...new Set(toolInfos.map((t) => t.namespace))];
+      console.log(
+        `[mcp-app-server] Registry ready: ${toolInfos.length} tools across namespaces: ${namespaces.join(", ")}`
+      );
+    } catch (err) {
+      console.error("[mcp-app-server] Failed to connect to Registry MCP server:", err);
+      console.error("[mcp-app-server] Starting without Registry service backend.");
+    }
+  }
+  const app = createMcpExpressApp({ host: HOST });
+  app.use(cors());
+  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) {
+        try {
+          await existing.transport.handleRequest(req, res, req.body);
+        } catch (err) {
+          console.error("[mcp] session request error", err);
+          if (!res.headersSent) {
+            res.status(500).json({ error: "Internal server error" });
+          }
+        }
+        return;
+      }
+    }
+    const mcpServer = createMcpAppServer(serverOptions);
+    const transport = new StreamableHTTPServerTransport({
+      sessionIdGenerator: () => randomUUID2(),
+      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) {
+      console.error("[mcp] new session error", err);
+      if (!res.headersSent) {
+        res.status(500).json({ error: "Internal server error" });
+      }
+    }
+  });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", service: "patchwork-mcp-app-server" });
+  });
+  app.listen(PORT, HOST, () => {
+    console.log(`MCP App Server listening on http://${HOST}:${PORT}`);
+    console.log(`  POST /mcp    \u2014 MCP Streamable HTTP endpoint (stateful sessions)`);
+    console.log(`  GET  /health \u2014 health check`);
+    console.log();
+    console.log("To expose locally via cloudflared:");
+    console.log(`  cloudflared tunnel --url http://localhost:${PORT}`);
+  });
+  const shutdown = () => {
+    if (registryBackend) {
+      registryBackend.close().catch(() => {
+      });
+    }
+    process.exit(0);
+  };
+  process.on("SIGTERM", shutdown);
+  process.on("SIGINT", shutdown);
+}
+startServer().catch((err) => {
+  console.error("[mcp-app-server] Fatal startup error:", err);
+  process.exit(1);
+});
+//# sourceMappingURL=server.js.map