mountly-mcp 0.0.0 → 3.1.0

package/dist/chunk-NLQDVNZP.js

@@ -0,0 +1,115 @@
+// src/react/context.ts
+import { createContext } from "react";
+var McpContext = createContext(null);
+McpContext.displayName = "McpContext";
+
+// src/react/hooks.ts
+import { useContext } from "react";
+import {
+  useAutoResize as useAutoResizeBase,
+  useDocumentTheme as useDocumentThemeBase,
+  useHostFonts as useHostFontsBase,
+  useHostStyleVariables as useHostStyleVariablesBase,
+  useHostStyles as useHostStylesBase
+} from "@modelcontextprotocol/ext-apps/react";
+function useEnsuredContext() {
+  const ctx = useContext(McpContext);
+  if (!ctx) {
+    throw new Error(
+      "mountly-mcp/react: useMcpHost/useToolInput/etc must be used inside a widget wrapped with createMcpWidget()."
+    );
+  }
+  return ctx;
+}
+function useMcpHost() {
+  return useEnsuredContext().app;
+}
+function useToolInput() {
+  return useEnsuredContext().toolInput;
+}
+function useToolInputPartial() {
+  return useEnsuredContext().toolInputPartial;
+}
+function useToolResult() {
+  return useEnsuredContext().toolResult;
+}
+function useHostContext() {
+  return useEnsuredContext().hostContext;
+}
+function useDisplayMode() {
+  return useHostContext()?.displayMode;
+}
+function useRequestDisplayMode() {
+  const { app, hostContext } = useEnsuredContext();
+  return async (mode) => {
+    const available = hostContext?.availableDisplayModes;
+    if (available && !available.includes(mode)) return hostContext?.displayMode;
+    const result = await app.requestDisplayMode({ mode });
+    return result.mode;
+  };
+}
+function useHostStyleVariables() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostStyleVariablesBase(app, hostContext ?? null);
+}
+function useHostFonts() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostFontsBase(app, hostContext ?? null);
+}
+function useHostStyles() {
+  const { app, hostContext } = useEnsuredContext();
+  useHostStylesBase(app, hostContext ?? null);
+}
+function useDocumentTheme() {
+  return useDocumentThemeBase();
+}
+function useUpdateModelContext() {
+  const { app } = useEnsuredContext();
+  return async (params) => {
+    await app.updateModelContext(params);
+  };
+}
+function useAutoResize(...args) {
+  return useAutoResizeBase(...args);
+}
+
+// src/react/create-widget.ts
+import { createElement } from "react";
+import { createWidget } from "mountly-react";
+function createMcpWidget(Component, options) {
+  const Wrapped = (props) => {
+    const { mcp, toolInput, toolInputPartial, toolResult, hostContext, ...rest } = props;
+    const value = {
+      app: mcp,
+      toolInput,
+      toolInputPartial,
+      toolResult,
+      hostContext
+    };
+    return createElement(
+      McpContext.Provider,
+      { value },
+      createElement(Component, rest)
+    );
+  };
+  return createWidget(Wrapped, options);
+}
+
+export {
+  McpContext,
+  useMcpHost,
+  useToolInput,
+  useToolInputPartial,
+  useToolResult,
+  useHostContext,
+  useDisplayMode,
+  useRequestDisplayMode,
+  useHostStyleVariables,
+  useHostFonts,
+  useHostStyles,
+  useDocumentTheme,
+  useUpdateModelContext,
+  useAutoResize,
+  createMcpWidget
+};
+//# sourceMappingURL=chunk-NLQDVNZP.js.map

package/dist/chunk-NLQDVNZP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/react/context.ts","../src/react/hooks.ts","../src/react/create-widget.ts"],"sourcesContent":["import { createContext } from \"react\";\nimport type {\n  App,\n  McpUiHostContext,\n  McpUiToolInputNotification,\n  McpUiToolInputPartialNotification,\n  McpUiToolResultNotification,\n} from \"@modelcontextprotocol/ext-apps\";\n\n/**\n * Shared per-widget context. The bridge populates this on each mount/update,\n * so consumers can synchronously read the initial values (no event subscription\n * race) and the React tree re-renders when the bridge calls `update()`.\n */\nexport interface McpContextValue {\n  app: App;\n  toolInput?: McpUiToolInputNotification[\"params\"];\n  toolInputPartial?: McpUiToolInputPartialNotification[\"params\"];\n  toolResult?: McpUiToolResultNotification[\"params\"];\n  hostContext?: McpUiHostContext;\n}\n\nexport const McpContext = createContext<McpContextValue | null>(null);\nMcpContext.displayName = \"McpContext\";\n","import { useContext } from \"react\";\nimport {\n  useAutoResize as useAutoResizeBase,\n  useDocumentTheme as useDocumentThemeBase,\n  useHostFonts as useHostFontsBase,\n  useHostStyleVariables as useHostStyleVariablesBase,\n  useHostStyles as useHostStylesBase,\n} from \"@modelcontextprotocol/ext-apps/react\";\nimport type {\n  App,\n  McpUiDisplayMode,\n  McpUiHostContext,\n  McpUiUpdateModelContextRequest,\n} from \"@modelcontextprotocol/ext-apps\";\nimport { McpContext } from \"./context.js\";\n\nfunction useEnsuredContext() {\n  const ctx = useContext(McpContext);\n  if (!ctx) {\n    throw new Error(\n      \"mountly-mcp/react: useMcpHost/useToolInput/etc must be used inside a widget wrapped with createMcpWidget().\",\n    );\n  }\n  return ctx;\n}\n\n/** The view-side ext-apps App. Use this to call server tools, send messages, open links, etc. */\nexport function useMcpHost(): App {\n  return useEnsuredContext().app;\n}\n\n/** Complete notification params; read the tool arguments from `.arguments`. */\nexport function useToolInput<T = unknown>(): T | undefined {\n  return useEnsuredContext().toolInput as T | undefined;\n}\n\n/**\n * Streaming tool arguments (`ui/notifications/tool-input-partial`), present only\n * when the bridge runs with `streamToolInput`. Best-effort recovered JSON —\n * fields may be missing or change between notifications, so render loading\n * states from it, never critical operations. Undefined once the complete\n * {@link useToolInput} arrives.\n */\nexport function useToolInputPartial<T = unknown>(): Partial<T> | undefined {\n  return useEnsuredContext().toolInputPartial as Partial<T> | undefined;\n}\n\n/** Complete MCP tool result; structured data is available at `.structuredContent`. */\nexport function useToolResult<T = unknown>(): T | undefined {\n  return useEnsuredContext().toolResult as T | undefined;\n}\n\n/** Latest host context snapshot (theme, styles, displayMode, container dimensions, etc.). */\nexport function useHostContext(): McpUiHostContext | undefined {\n  return useEnsuredContext().hostContext;\n}\n\n/** Current display mode reported by the host. */\nexport function useDisplayMode(): McpUiDisplayMode | undefined {\n  return useHostContext()?.displayMode;\n}\n\n/**\n * Request a display mode change, resolving to the mode the host actually\n * applied — which the spec allows to differ from the one asked for.\n *\n * Modes the host didn't list in `availableDisplayModes` are never requested\n * (the spec requires views to check first); the current mode comes back\n * unchanged instead.\n */\nexport function useRequestDisplayMode(): (\n  mode: McpUiDisplayMode,\n) => Promise<McpUiDisplayMode | undefined> {\n  const { app, hostContext } = useEnsuredContext();\n  return async (mode) => {\n    const available = hostContext?.availableDisplayModes;\n    if (available && !available.includes(mode)) return hostContext?.displayMode;\n    const result = await app.requestDisplayMode({ mode });\n    return result.mode;\n  };\n}\n\n/** Apply host CSS variables (and react to host-context changes). */\nexport function useHostStyleVariables(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostStyleVariablesBase(app, hostContext ?? null);\n}\n\n/** Apply host-provided `@font-face`/`@import` rules. */\nexport function useHostFonts(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostFontsBase(app, hostContext ?? null);\n}\n\n/** One-shot helper: apply both host style variables and host fonts. */\nexport function useHostStyles(): void {\n  const { app, hostContext } = useEnsuredContext();\n  useHostStylesBase(app, hostContext ?? null);\n}\n\n/** Track the document theme reactively. */\nexport function useDocumentTheme() {\n  return useDocumentThemeBase();\n}\n\n/**\n * Return a function that calls `app.updateModelContext(params)`.\n *\n * Context updates are available to the model in future turns without\n * triggering an immediate response. Only the last update is kept.\n */\nexport function useUpdateModelContext(): (\n  params: McpUiUpdateModelContextRequest[\"params\"],\n) => Promise<void> {\n  const { app } = useEnsuredContext();\n  return async (params) => {\n    await app.updateModelContext(params);\n  };\n}\n\n/** Manually control auto-resize (rarely needed — the bridge calls setupSizeChangedNotifications by default). */\nexport function useAutoResize(...args: Parameters<typeof useAutoResizeBase>) {\n  return useAutoResizeBase(...args);\n}\n","import { createElement, type ComponentType } from \"react\";\nimport { createWidget } from \"mountly-react\";\nimport type { AdapterOptions, WidgetModule } from \"mountly/adapter\";\nimport type { McpWidgetProps } from \"../index.js\";\nimport { McpContext, type McpContextValue } from \"./context.js\";\n\n/**\n * Wraps a React component as a mountly `WidgetModule` driven by the\n * mountly-mcp bridge. The bridge passes spec-defined props\n * (`mcp` / `toolInput` / `toolResult` / `hostContext`) on each `mount` /\n * `update`. The wrapper consumes those bridge props and exposes them through\n * `useMcpHost()` and the other hooks from `mountly-mcp/react`; the wrapped\n * component's own props remain unchanged.\n */\nexport function createMcpWidget<P extends object>(\n  Component: ComponentType<P>,\n  options?: AdapterOptions,\n): WidgetModule {\n  const Wrapped = (props: P & McpWidgetProps) => {\n    const { mcp, toolInput, toolInputPartial, toolResult, hostContext, ...rest } =\n      props as McpWidgetProps & P;\n    const value: McpContextValue = {\n      app: mcp,\n      toolInput,\n      toolInputPartial,\n      toolResult,\n      hostContext,\n    };\n    return createElement(\n      McpContext.Provider,\n      { value },\n      createElement(Component as ComponentType, rest as P),\n    );\n  };\n  return createWidget(Wrapped as ComponentType<P & McpWidgetProps>, options);\n}\n"],"mappings":";AAAA,SAAS,qBAAqB;AAsBvB,IAAM,aAAa,cAAsC,IAAI;AACpE,WAAW,cAAc;;;ACvBzB,SAAS,kBAAkB;AAC3B;AAAA,EACE,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,gBAAgB;AAAA,EAChB,yBAAyB;AAAA,EACzB,iBAAiB;AAAA,OACZ;AASP,SAAS,oBAAoB;AAC3B,QAAM,MAAM,WAAW,UAAU;AACjC,MAAI,CAAC,KAAK;AACR,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACA,SAAO;AACT;AAGO,SAAS,aAAkB;AAChC,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,eAA2C;AACzD,SAAO,kBAAkB,EAAE;AAC7B;AASO,SAAS,sBAA2D;AACzE,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,gBAA4C;AAC1D,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,iBAA+C;AAC7D,SAAO,kBAAkB,EAAE;AAC7B;AAGO,SAAS,iBAA+C;AAC7D,SAAO,eAAe,GAAG;AAC3B;AAUO,SAAS,wBAE2B;AACzC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,SAAO,OAAO,SAAS;AACrB,UAAM,YAAY,aAAa;AAC/B,QAAI,aAAa,CAAC,UAAU,SAAS,IAAI,EAAG,QAAO,aAAa;AAChE,UAAM,SAAS,MAAM,IAAI,mBAAmB,EAAE,KAAK,CAAC;AACpD,WAAO,OAAO;AAAA,EAChB;AACF;AAGO,SAAS,wBAA8B;AAC5C,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,4BAA0B,KAAK,eAAe,IAAI;AACpD;AAGO,SAAS,eAAqB;AACnC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,mBAAiB,KAAK,eAAe,IAAI;AAC3C;AAGO,SAAS,gBAAsB;AACpC,QAAM,EAAE,KAAK,YAAY,IAAI,kBAAkB;AAC/C,oBAAkB,KAAK,eAAe,IAAI;AAC5C;AAGO,SAAS,mBAAmB;AACjC,SAAO,qBAAqB;AAC9B;AAQO,SAAS,wBAEG;AACjB,QAAM,EAAE,IAAI,IAAI,kBAAkB;AAClC,SAAO,OAAO,WAAW;AACvB,UAAM,IAAI,mBAAmB,MAAM;AAAA,EACrC;AACF;AAGO,SAAS,iBAAiB,MAA4C;AAC3E,SAAO,kBAAkB,GAAG,IAAI;AAClC;;;AC3HA,SAAS,qBAAyC;AAClD,SAAS,oBAAoB;AAatB,SAAS,gBACd,WACA,SACc;AACd,QAAM,UAAU,CAAC,UAA8B;AAC7C,UAAM,EAAE,KAAK,WAAW,kBAAkB,YAAY,aAAa,GAAG,KAAK,IACzE;AACF,UAAM,QAAyB;AAAA,MAC7B,KAAK;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,IACF;AACA,WAAO;AAAA,MACL,WAAW;AAAA,MACX,EAAE,MAAM;AAAA,MACR,cAAc,WAA4B,IAAS;AAAA,IACrD;AAAA,EACF;AACA,SAAO,aAAa,SAA8C,OAAO;AAC3E;","names":[]}

package/dist/chunk-SNWNF2XI.js

@@ -0,0 +1,171 @@
+import {
+  MCP_ERROR_CODES
+} from "./chunk-DQLQOMDM.js";
+
+// src/bridge/index.ts
+import {
+  App,
+  PostMessageTransport
+} from "@modelcontextprotocol/ext-apps";
+function renderErrorBoundary(container, code, message) {
+  container.setAttribute("data-mountly-mcp-state", "error");
+  const doc = container.ownerDocument;
+  if (!doc) return;
+  const errorDiv = doc.createElement("div");
+  errorDiv.setAttribute("data-mountly-mcp-error", code);
+  if (message !== void 0) errorDiv.textContent = message;
+  container.innerHTML = "";
+  container.appendChild(errorDiv);
+}
+function runBridge(options) {
+  const {
+    widget,
+    container,
+    awaitToolResult = true,
+    streamToolInput = false,
+    availableDisplayModes = ["inline"],
+    appInfo = { name: "mountly-mcp", version: "0.0.0" }
+  } = options;
+  const appCapabilities = {
+    availableDisplayModes: [...availableDisplayModes]
+  };
+  const app = options.app ?? new App(appInfo, appCapabilities);
+  let toolInput;
+  let toolInputPartial;
+  let toolResult;
+  let mounted = false;
+  let stopped = false;
+  let pending = Promise.resolve();
+  function currentProps() {
+    return {
+      mcp: app,
+      toolInput,
+      toolInputPartial,
+      toolResult,
+      hostContext: app.getHostContext()
+    };
+  }
+  function notifyError(code, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    try {
+      void app.sendLog({ level: "error", data: { code, message } }).catch(() => void 0);
+    } catch {
+    }
+    renderErrorBoundary(container, code, message);
+  }
+  function renderWith(props) {
+    pending = pending.then(async () => {
+      if (stopped) return;
+      try {
+        if (!mounted) {
+          const r = widget.mount(container, props);
+          if (r instanceof Promise) await r;
+          mounted = true;
+          container.setAttribute("data-mountly-mcp-state", "mounted");
+        } else if (widget.update) {
+          const r = widget.update(container, props);
+          if (r instanceof Promise) await r;
+        } else {
+          await widget.unmount(container);
+          mounted = false;
+          const r = widget.mount(container, props);
+          if (r instanceof Promise) await r;
+          mounted = true;
+        }
+      } catch (error) {
+        notifyError(MCP_ERROR_CODES.WIDGET_MOUNT_THREW, error);
+      }
+    });
+    return pending;
+  }
+  async function unmountWidget() {
+    await pending;
+    if (!mounted) return;
+    mounted = false;
+    await widget.unmount(container);
+  }
+  const handleToolInput = (params) => {
+    toolInput = params;
+    toolInputPartial = void 0;
+    if (!awaitToolResult) return;
+    if (mounted || toolResult !== void 0) void renderWith(currentProps());
+  };
+  const handleToolInputPartial = (params) => {
+    if (!streamToolInput) return;
+    toolInputPartial = params;
+    void renderWith(currentProps());
+  };
+  const handleToolResult = (params) => {
+    toolResult = params;
+    void renderWith(currentProps());
+  };
+  const handleToolCancelled = () => {
+    void renderWith(currentProps());
+  };
+  const handleHostContextChanged = () => {
+    if (mounted) void renderWith(currentProps());
+  };
+  app.addEventListener("toolinput", handleToolInput);
+  app.addEventListener("toolinputpartial", handleToolInputPartial);
+  app.addEventListener("toolresult", handleToolResult);
+  app.addEventListener("toolcancelled", handleToolCancelled);
+  app.addEventListener("hostcontextchanged", handleHostContextChanged);
+  const previousTeardown = app.onteardown;
+  const bridgeTeardown = async (params, extra) => {
+    stopped = true;
+    detachTeardown();
+    detachAppHandlers();
+    await unmountWidget();
+    return await previousTeardown?.(params, extra) ?? {};
+  };
+  app.onteardown = bridgeTeardown;
+  function detachAppHandlers() {
+    app.removeEventListener("toolinput", handleToolInput);
+    app.removeEventListener("toolinputpartial", handleToolInputPartial);
+    app.removeEventListener("toolresult", handleToolResult);
+    app.removeEventListener("toolcancelled", handleToolCancelled);
+    app.removeEventListener("hostcontextchanged", handleHostContextChanged);
+    if (app.onteardown === bridgeTeardown) app.onteardown = previousTeardown;
+  }
+  const ready = (async () => {
+    try {
+      if (!options.app) {
+        await app.connect();
+      }
+      if (!awaitToolResult) {
+        await renderWith(currentProps());
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      const code = /timeout/i.test(message) ? MCP_ERROR_CODES.INITIALIZE_TIMEOUT : MCP_ERROR_CODES.INITIALIZE_FAILED;
+      notifyError(code, error);
+      throw error;
+    }
+  })();
+  let detachTeardown = () => void 0;
+  function stopBridge() {
+    if (stopped) return;
+    stopped = true;
+    detachTeardown();
+    detachAppHandlers();
+    void unmountWidget();
+    if (!options.app) void app.close().catch(() => void 0);
+  }
+  detachTeardown = options.onTeardown?.(stopBridge) ?? (typeof window !== "undefined" ? (() => {
+    const h = () => stopBridge();
+    window.addEventListener("beforeunload", h);
+    return () => window.removeEventListener("beforeunload", h);
+  })() : () => void 0);
+  return {
+    ready,
+    app,
+    stop: stopBridge
+  };
+}
+
+export {
+  App,
+  PostMessageTransport,
+  runBridge
+};
+//# sourceMappingURL=chunk-SNWNF2XI.js.map

package/dist/chunk-SNWNF2XI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bridge/index.ts"],"sourcesContent":["/**\n * View-side bridge that turns an MCP Apps `App` into a mountly `WidgetModule`\n * lifecycle. The full spec handshake — `ui/initialize`,\n * `ui/notifications/initialized`, `ui/notifications/tool-input(-partial)`,\n * `ui/notifications/tool-result`, `ui/notifications/tool-cancelled`,\n * `ui/notifications/host-context-changed`, `ui/resource-teardown`,\n * `ui/notifications/size-changed` — is delegated to ext-apps's `App`.\n */\nimport {\n  App,\n  PostMessageTransport,\n  type McpUiAppCapabilities,\n  type McpUiDisplayMode,\n  type McpUiToolInputNotification,\n  type McpUiToolInputPartialNotification,\n  type McpUiToolResultNotification,\n} from \"@modelcontextprotocol/ext-apps\";\nimport type { WidgetModule } from \"mountly/adapter\";\nimport { MCP_ERROR_CODES } from \"../schema.js\";\nimport type { McpWidgetProps } from \"../types.js\";\n\nexport interface RunBridgeOptions {\n  /** Pre-constructed App (used by jsdom tests); otherwise one is created here. */\n  app?: App;\n  widget: WidgetModule;\n  container: Element;\n  /**\n   * If true (default), mount is deferred until the first tool-result arrives;\n   * the widget renders against `{ toolInput, toolResult, hostContext, mcp }`\n   * props on each notification.\n   *\n   * If false, mount fires immediately after `ui/initialize` with `{ mcp }`\n   * only — for \"stateless\" views that drive themselves via `mcp.callServerTool`.\n   */\n  awaitToolResult?: boolean;\n  /**\n   * Render progressive states from `ui/notifications/tool-input-partial`.\n   *\n   * Off by default — the spec lets views ignore partials, and they carry\n   * best-effort recovered JSON that MUST NOT drive critical operations. When\n   * on, partials arrive as `toolInputPartial` (mounting the widget early if\n   * needed) and are cleared once the complete `tool-input` lands.\n   */\n  streamToolInput?: boolean;\n  /** Display modes this view supports. Declared to the host during `ui/initialize`. */\n  availableDisplayModes?: ReadonlyArray<McpUiDisplayMode>;\n  /** App identity sent during `ui/initialize`. */\n  appInfo?: { name: string; version: string };\n  /** Override for tests; defaults to `window.addEventListener('beforeunload', ...)`. */\n  onTeardown?: (handler: () => void) => () => void;\n}\n\nexport interface RunningBridge {\n  /** Resolves once `ui/initialize` handshake completes and the first mount (or deferred mount) is wired. */\n  ready: Promise<void>;\n  /** The underlying App; exposed for hosts that want to drive the view directly. */\n  app: App;\n  /** Synchronously triggers teardown. */\n  stop(): void;\n}\n\n/**\n * `data-mountly-mcp-state` is the View's machine-readable outcome, read by\n * `verify --render`. It only ever moves forward — `mounted` once the widget\n * has mounted, `error` if the boundary replaced it — so a state written here\n * can never be clobbered by a later lifecycle step.\n */\nfunction renderErrorBoundary(container: Element, code: string, message?: string): void {\n  container.setAttribute(\"data-mountly-mcp-state\", \"error\");\n  const doc = container.ownerDocument;\n  if (!doc) return;\n  const errorDiv = doc.createElement(\"div\");\n  errorDiv.setAttribute(\"data-mountly-mcp-error\", code);\n  if (message !== undefined) errorDiv.textContent = message;\n  container.innerHTML = \"\";\n  container.appendChild(errorDiv);\n}\n\nexport function runBridge(options: RunBridgeOptions): RunningBridge {\n  const {\n    widget,\n    container,\n    awaitToolResult = true,\n    streamToolInput = false,\n    availableDisplayModes = [\"inline\"],\n    appInfo = { name: \"mountly-mcp\", version: \"0.0.0\" },\n  } = options;\n\n  const appCapabilities: McpUiAppCapabilities = {\n    availableDisplayModes: [...availableDisplayModes],\n  };\n\n  const app = options.app ?? new App(appInfo, appCapabilities);\n\n  let toolInput: McpUiToolInputNotification[\"params\"] | undefined;\n  let toolInputPartial: McpUiToolInputPartialNotification[\"params\"] | undefined;\n  let toolResult: McpUiToolResultNotification[\"params\"] | undefined;\n  let mounted = false;\n  let stopped = false;\n  let pending: Promise<void> = Promise.resolve();\n\n  function currentProps(): McpWidgetProps {\n    return {\n      mcp: app,\n      toolInput,\n      toolInputPartial,\n      toolResult,\n      hostContext: app.getHostContext(),\n    };\n  }\n\n  function notifyError(code: string, error: unknown): void {\n    const message = error instanceof Error ? error.message : String(error);\n    try {\n      void app.sendLog({ level: \"error\", data: { code, message } }).catch(() => undefined);\n    } catch {\n      // ignore — log channel may not be ready\n    }\n    renderErrorBoundary(container, code, message);\n  }\n\n  function renderWith(props: McpWidgetProps): Promise<void> {\n    pending = pending.then(async () => {\n      if (stopped) return;\n      try {\n        if (!mounted) {\n          const r = widget.mount(container, props);\n          if (r instanceof Promise) await r;\n          mounted = true;\n          container.setAttribute(\"data-mountly-mcp-state\", \"mounted\");\n        } else if (widget.update) {\n          const r = widget.update(container, props);\n          if (r instanceof Promise) await r;\n        } else {\n          await widget.unmount(container);\n          mounted = false;\n          const r = widget.mount(container, props);\n          if (r instanceof Promise) await r;\n          mounted = true;\n        }\n      } catch (error) {\n        notifyError(MCP_ERROR_CODES.WIDGET_MOUNT_THREW, error);\n      }\n    });\n    return pending;\n  }\n\n  async function unmountWidget(): Promise<void> {\n    await pending;\n    if (!mounted) return;\n    mounted = false;\n    await widget.unmount(container);\n  }\n\n  // Event handlers MUST be registered before connect() — ext-apps will refuse\n  // to attach handlers retroactively after the initialize handshake completes.\n  const handleToolInput = (params: McpUiToolInputNotification[\"params\"]) => {\n    toolInput = params;\n    toolInputPartial = undefined;\n    if (!awaitToolResult) return;\n    if (mounted || toolResult !== undefined) void renderWith(currentProps());\n  };\n\n  const handleToolInputPartial = (params: McpUiToolInputPartialNotification[\"params\"]) => {\n    // Views MAY ignore partial input per spec; opt in with `streamToolInput`.\n    // Consumers wanting finer control can subscribe via app.addEventListener.\n    if (!streamToolInput) return;\n    toolInputPartial = params;\n    void renderWith(currentProps());\n  };\n\n  const handleToolResult = (params: McpUiToolResultNotification[\"params\"]) => {\n    toolResult = params;\n    void renderWith(currentProps());\n  };\n\n  const handleToolCancelled = () => {\n    void renderWith(currentProps());\n  };\n\n  const handleHostContextChanged = () => {\n    if (mounted) void renderWith(currentProps());\n  };\n\n  app.addEventListener(\"toolinput\", handleToolInput);\n  app.addEventListener(\"toolinputpartial\", handleToolInputPartial);\n  app.addEventListener(\"toolresult\", handleToolResult);\n  app.addEventListener(\"toolcancelled\", handleToolCancelled);\n  app.addEventListener(\"hostcontextchanged\", handleHostContextChanged);\n\n  const previousTeardown = app.onteardown;\n  const bridgeTeardown: NonNullable<typeof app.onteardown> = async (params, extra) => {\n    stopped = true;\n    detachTeardown();\n    detachAppHandlers();\n    await unmountWidget();\n    return (await previousTeardown?.(params, extra)) ?? {};\n  };\n  app.onteardown = bridgeTeardown;\n\n  function detachAppHandlers(): void {\n    app.removeEventListener(\"toolinput\", handleToolInput);\n    app.removeEventListener(\"toolinputpartial\", handleToolInputPartial);\n    app.removeEventListener(\"toolresult\", handleToolResult);\n    app.removeEventListener(\"toolcancelled\", handleToolCancelled);\n    app.removeEventListener(\"hostcontextchanged\", handleHostContextChanged);\n    if (app.onteardown === bridgeTeardown) app.onteardown = previousTeardown;\n  }\n\n  const ready = (async () => {\n    try {\n      if (!options.app) {\n        // App.connect() defaults to PostMessageTransport(window.parent, window.parent)\n        // and owns automatic resize setup.\n        await app.connect();\n      }\n\n      if (!awaitToolResult) {\n        await renderWith(currentProps());\n      }\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      const code = /timeout/i.test(message)\n        ? MCP_ERROR_CODES.INITIALIZE_TIMEOUT\n        : MCP_ERROR_CODES.INITIALIZE_FAILED;\n      notifyError(code, error);\n      throw error;\n    }\n  })();\n\n  let detachTeardown: () => void = () => undefined;\n\n  function stopBridge(): void {\n    if (stopped) return;\n    stopped = true;\n    detachTeardown();\n    detachAppHandlers();\n    void unmountWidget();\n    if (!options.app) void app.close().catch(() => undefined);\n  }\n\n  detachTeardown =\n    options.onTeardown?.(stopBridge) ??\n    (typeof window !== \"undefined\"\n      ? (() => {\n          const h = () => stopBridge();\n          window.addEventListener(\"beforeunload\", h);\n          return () => window.removeEventListener(\"beforeunload\", h);\n        })()\n      : () => undefined);\n\n  return {\n    ready,\n    app,\n    stop: stopBridge,\n  };\n}\n\nexport { App, PostMessageTransport };\nexport type {\n  McpUiAppCapabilities,\n  McpUiHostCapabilities,\n  McpUiHostContext,\n  McpUiToolInputNotification,\n  McpUiToolInputPartialNotification,\n  McpUiToolResultNotification,\n  McpUiToolCancelledNotification,\n  McpUiHostContextChangedNotification,\n} from \"@modelcontextprotocol/ext-apps\";\n"],"mappings":"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","names":[]}

package/dist/chunk-UECZA34Q.js

@@ -0,0 +1,52 @@
+// src/dev/connect-server.ts
+async function connectMcpServer(path) {
+  const { pathToFileURL } = await import("url");
+  const { resolve } = await import("path");
+  const mod = await import(pathToFileURL(resolve(path)).href);
+  if (mod.default === void 0) {
+    throw new Error(
+      `mountly-mcp: ${path} has no default export. Export your server (or a function returning it) as default.`
+    );
+  }
+  const value = typeof mod.default === "function" ? await mod.default() : mod.default;
+  let client;
+  if (value !== null && typeof value === "object" && "connectInProcess" in value && typeof value.connectInProcess === "function") {
+    const running = value;
+    ({ client } = await running.connectInProcess());
+  } else if (value !== null && typeof value === "object" && "connect" in value && typeof value.connect === "function") {
+    const [{ Client }, { InMemoryTransport }, { EXTENSION_ID, RESOURCE_MIME_TYPE }] = await Promise.all([
+      import("@modelcontextprotocol/sdk/client/index.js"),
+      import("@modelcontextprotocol/sdk/inMemory.js"),
+      import("@modelcontextprotocol/ext-apps/server")
+    ]);
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await value.connect(serverTransport);
+    client = new Client({ name: "mountly-mcp-dev", version: "0.0.1" }, {
+      capabilities: { extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } } }
+    });
+    await client.connect(clientTransport);
+  } else {
+    throw new TypeError(
+      `mountly-mcp: ${path} must default-export an MCP server, RunningMcpAppServer, or a function returning one`
+    );
+  }
+  return {
+    callTool: (name, args) => client.callTool({ name, arguments: args ?? {} }),
+    async toolFor(uri) {
+      const { tools } = await client.listTools();
+      const uiMeta = (tool) => tool._meta?.ui;
+      const bound = tools.filter((tool) => uiMeta(tool)?.resourceUri === uri);
+      const visible = bound.find((tool) => {
+        const visibility = uiMeta(tool)?.visibility;
+        return visibility === void 0 || visibility.includes("model");
+      });
+      return (visible ?? bound[0])?.name;
+    },
+    close: () => client.close()
+  };
+}
+
+export {
+  connectMcpServer
+};
+//# sourceMappingURL=chunk-UECZA34Q.js.map

package/dist/chunk-UECZA34Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/dev/connect-server.ts"],"sourcesContent":["import type { McpUiToolMeta } from \"@modelcontextprotocol/ext-apps\";\n\nexport interface ConnectedMcpServer {\n  callTool: (name: string, args: unknown) => Promise<unknown>;\n  /** The model-visible tool bound to `uri` — the one a host would call. */\n  toolFor(uri: string): Promise<string | undefined>;\n  close(): Promise<void>;\n}\n\n/**\n * Connect a server module in-process for a development session.\n *\n * The module default-exports either the server or a function returning it: a\n * `RunningMcpAppServer` from `createMcpAppServer`, or a raw `McpServer`.\n */\nexport async function connectMcpServer(path: string): Promise<ConnectedMcpServer> {\n  const { pathToFileURL } = await import(\"node:url\");\n  const { resolve } = await import(\"node:path\");\n  const mod = (await import(pathToFileURL(resolve(path)).href)) as { default?: unknown };\n  if (mod.default === undefined) {\n    throw new Error(\n      `mountly-mcp: ${path} has no default export. Export your server (or a function returning it) as default.`,\n    );\n  }\n  const value = typeof mod.default === \"function\" ? await mod.default() : mod.default;\n\n  let client: import(\"@modelcontextprotocol/sdk/client/index.js\").Client;\n  if (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"connectInProcess\" in value &&\n    typeof value.connectInProcess === \"function\"\n  ) {\n    const running = value as { connectInProcess(): Promise<{ client: typeof client }> };\n    ({ client } = await running.connectInProcess());\n  } else if (\n    value !== null &&\n    typeof value === \"object\" &&\n    \"connect\" in value &&\n    typeof value.connect === \"function\"\n  ) {\n    const [{ Client }, { InMemoryTransport }, { EXTENSION_ID, RESOURCE_MIME_TYPE }] =\n      await Promise.all([\n        import(\"@modelcontextprotocol/sdk/client/index.js\"),\n        import(\"@modelcontextprotocol/sdk/inMemory.js\"),\n        import(\"@modelcontextprotocol/ext-apps/server\"),\n      ]);\n    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();\n    await (value as { connect(transport: unknown): Promise<void> }).connect(serverTransport);\n    client = new Client({ name: \"mountly-mcp-dev\", version: \"0.0.1\" }, {\n      capabilities: { extensions: { [EXTENSION_ID]: { mimeTypes: [RESOURCE_MIME_TYPE] } } },\n    } as never);\n    await client.connect(clientTransport);\n  } else {\n    throw new TypeError(\n      `mountly-mcp: ${path} must default-export an MCP server, RunningMcpAppServer, or a function returning one`,\n    );\n  }\n\n  return {\n    callTool: (name, args) =>\n      client.callTool({ name, arguments: (args ?? {}) as Record<string, unknown> }),\n    async toolFor(uri) {\n      const { tools } = await client.listTools();\n      const uiMeta = (tool: { _meta?: unknown }): McpUiToolMeta | undefined =>\n        (tool._meta as { ui?: McpUiToolMeta } | undefined)?.ui;\n      const bound = tools.filter((tool) => uiMeta(tool)?.resourceUri === uri);\n      const visible = bound.find((tool) => {\n        const visibility = uiMeta(tool)?.visibility;\n        return visibility === undefined || visibility.includes(\"model\");\n      });\n      return (visible ?? bound[0])?.name;\n    },\n    close: () => client.close(),\n  };\n}\n"],"mappings":";AAeA,eAAsB,iBAAiB,MAA2C;AAChF,QAAM,EAAE,cAAc,IAAI,MAAM,OAAO,KAAU;AACjD,QAAM,EAAE,QAAQ,IAAI,MAAM,OAAO,MAAW;AAC5C,QAAM,MAAO,MAAM,OAAO,cAAc,QAAQ,IAAI,CAAC,EAAE;AACvD,MAAI,IAAI,YAAY,QAAW;AAC7B,UAAM,IAAI;AAAA,MACR,gBAAgB,IAAI;AAAA,IACtB;AAAA,EACF;AACA,QAAM,QAAQ,OAAO,IAAI,YAAY,aAAa,MAAM,IAAI,QAAQ,IAAI,IAAI;AAE5E,MAAI;AACJ,MACE,UAAU,QACV,OAAO,UAAU,YACjB,sBAAsB,SACtB,OAAO,MAAM,qBAAqB,YAClC;AACA,UAAM,UAAU;AAChB,KAAC,EAAE,OAAO,IAAI,MAAM,QAAQ,iBAAiB;AAAA,EAC/C,WACE,UAAU,QACV,OAAO,UAAU,YACjB,aAAa,SACb,OAAO,MAAM,YAAY,YACzB;AACA,UAAM,CAAC,EAAE,OAAO,GAAG,EAAE,kBAAkB,GAAG,EAAE,cAAc,mBAAmB,CAAC,IAC5E,MAAM,QAAQ,IAAI;AAAA,MAChB,OAAO,2CAA2C;AAAA,MAClD,OAAO,uCAAuC;AAAA,MAC9C,OAAO,uCAAuC;AAAA,IAChD,CAAC;AACH,UAAM,CAAC,iBAAiB,eAAe,IAAI,kBAAkB,iBAAiB;AAC9E,UAAO,MAAyD,QAAQ,eAAe;AACvF,aAAS,IAAI,OAAO,EAAE,MAAM,mBAAmB,SAAS,QAAQ,GAAG;AAAA,MACjE,cAAc,EAAE,YAAY,EAAE,CAAC,YAAY,GAAG,EAAE,WAAW,CAAC,kBAAkB,EAAE,EAAE,EAAE;AAAA,IACtF,CAAU;AACV,UAAM,OAAO,QAAQ,eAAe;AAAA,EACtC,OAAO;AACL,UAAM,IAAI;AAAA,MACR,gBAAgB,IAAI;AAAA,IACtB;AAAA,EACF;AAEA,SAAO;AAAA,IACL,UAAU,CAAC,MAAM,SACf,OAAO,SAAS,EAAE,MAAM,WAAY,QAAQ,CAAC,EAA8B,CAAC;AAAA,IAC9E,MAAM,QAAQ,KAAK;AACjB,YAAM,EAAE,MAAM,IAAI,MAAM,OAAO,UAAU;AACzC,YAAM,SAAS,CAAC,SACb,KAAK,OAA8C;AACtD,YAAM,QAAQ,MAAM,OAAO,CAAC,SAAS,OAAO,IAAI,GAAG,gBAAgB,GAAG;AACtE,YAAM,UAAU,MAAM,KAAK,CAAC,SAAS;AACnC,cAAM,aAAa,OAAO,IAAI,GAAG;AACjC,eAAO,eAAe,UAAa,WAAW,SAAS,OAAO;AAAA,MAChE,CAAC;AACD,cAAQ,WAAW,MAAM,CAAC,IAAI;AAAA,IAChC;AAAA,IACA,OAAO,MAAM,OAAO,MAAM;AAAA,EAC5B;AACF;","names":[]}

package/dist/chunk-YJA4H6IB.js

@@ -0,0 +1,13 @@
+// src/html.ts
+function escapeInlineScript(value) {
+  return value.replace(/<\/script/gi, "<\\/script");
+}
+function serializeInlineScriptValue(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c");
+}
+
+export {
+  escapeInlineScript,
+  serializeInlineScriptValue
+};
+//# sourceMappingURL=chunk-YJA4H6IB.js.map

package/dist/chunk-YJA4H6IB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/html.ts"],"sourcesContent":["/** Keep generated JavaScript from terminating the inline script that owns it. */\nexport function escapeInlineScript(value: string): string {\n  return value.replace(/<\\/script/gi, \"<\\\\/script\");\n}\n\n/** Serialize a value so no HTML tag can begin inside an inline script. */\nexport function serializeInlineScriptValue(value: unknown): string {\n  return JSON.stringify(value).replace(/</g, \"\\\\u003c\");\n}\n"],"mappings":";AACO,SAAS,mBAAmB,OAAuB;AACxD,SAAO,MAAM,QAAQ,eAAe,YAAY;AAClD;AAGO,SAAS,2BAA2B,OAAwB;AACjE,SAAO,KAAK,UAAU,KAAK,EAAE,QAAQ,MAAM,SAAS;AACtD;","names":[]}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};