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

package/dist/index.js

@@ -0,0 +1,990 @@
+// 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/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 warn(tag, ...args) {
+  if (shouldLog("warn")) {
+    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 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/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()
+              })
+            }
+          ]
+        };
+      }
+    );
+    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 (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          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;
+}
+function resetWidgetStore() {
+  _instance = null;
+}
+
+// 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 (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        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 })
+          }
+        ]
+      };
+    }
+  );
+}
+export {
+  WidgetStore,
+  createMcpAppServer,
+  getWidgetStore,
+  pushStreamUpdate,
+  resetWidgetStore
+};
+//# sourceMappingURL=index.js.map