npm - @ggui-ai/mcp-server - Versions diffs - 0.1.0-rc.1 - Mend

@ggui-ai/mcp-server 0.1.0-rc.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (141) hide show

package/LICENSE +201 -0
package/README.md +48 -0
package/dist/admin-blueprints-transport.d.ts +114 -0
package/dist/admin-blueprints-transport.d.ts.map +1 -0
package/dist/admin-blueprints-transport.js +118 -0
package/dist/admin-oauth-providers-transport.d.ts +40 -0
package/dist/admin-oauth-providers-transport.d.ts.map +1 -0
package/dist/admin-oauth-providers-transport.js +263 -0
package/dist/auth.d.ts +39 -0
package/dist/auth.d.ts.map +1 -0
package/dist/auth.js +75 -0
package/dist/build-mcp.d.ts +128 -0
package/dist/build-mcp.d.ts.map +1 -0
package/dist/build-mcp.js +113 -0
package/dist/code-store-fs.d.ts +19 -0
package/dist/code-store-fs.d.ts.map +1 -0
package/dist/code-store-fs.js +98 -0
package/dist/console-auth.d.ts +139 -0
package/dist/console-auth.d.ts.map +1 -0
package/dist/console-auth.js +102 -0
package/dist/console-cache.d.ts +78 -0
package/dist/console-cache.d.ts.map +1 -0
package/dist/console-cache.js +105 -0
package/dist/console-headers.d.ts +124 -0
package/dist/console-headers.d.ts.map +1 -0
package/dist/console-headers.js +49 -0
package/dist/console-llm-trace.d.ts +66 -0
package/dist/console-llm-trace.d.ts.map +1 -0
package/dist/console-llm-trace.js +105 -0
package/dist/console-payloads.d.ts +67 -0
package/dist/console-payloads.d.ts.map +1 -0
package/dist/console-payloads.js +105 -0
package/dist/console-theme-routes.d.ts +111 -0
package/dist/console-theme-routes.d.ts.map +1 -0
package/dist/console-theme-routes.js +202 -0
package/dist/console-timeline.d.ts +45 -0
package/dist/console-timeline.d.ts.map +1 -0
package/dist/console-timeline.js +169 -0
package/dist/console-validator.d.ts +67 -0
package/dist/console-validator.d.ts.map +1 -0
package/dist/console-validator.js +105 -0
package/dist/console-welcome.d.ts +7 -0
package/dist/console-welcome.d.ts.map +1 -0
package/dist/console-welcome.js +221 -0
package/dist/csrf-middleware.d.ts +55 -0
package/dist/csrf-middleware.d.ts.map +1 -0
package/dist/csrf-middleware.js +138 -0
package/dist/email-login.d.ts +174 -0
package/dist/email-login.d.ts.map +1 -0
package/dist/email-login.js +254 -0
package/dist/email-resend.d.ts +29 -0
package/dist/email-resend.d.ts.map +1 -0
package/dist/email-resend.js +71 -0
package/dist/email-sender-from-env.d.ts +34 -0
package/dist/email-sender-from-env.d.ts.map +1 -0
package/dist/email-sender-from-env.js +112 -0
package/dist/email-smtp.d.ts +42 -0
package/dist/email-smtp.d.ts.map +1 -0
package/dist/email-smtp.js +81 -0
package/dist/index.d.ts +102 -0
package/dist/index.d.ts.map +1 -0
package/dist/index.js +122 -0
package/dist/instructions-presets.d.ts +112 -0
package/dist/instructions-presets.d.ts.map +1 -0
package/dist/instructions-presets.js +195 -0
package/dist/llm-backed-negotiator.d.ts +178 -0
package/dist/llm-backed-negotiator.d.ts.map +1 -0
package/dist/llm-backed-negotiator.js +579 -0
package/dist/logger.d.ts +23 -0
package/dist/logger.d.ts.map +1 -0
package/dist/logger.js +41 -0
package/dist/mcp-apps-inbound.d.ts +86 -0
package/dist/mcp-apps-inbound.d.ts.map +1 -0
package/dist/mcp-apps-inbound.js +278 -0
package/dist/mcp-apps-outbound.d.ts +448 -0
package/dist/mcp-apps-outbound.d.ts.map +1 -0
package/dist/mcp-apps-outbound.js +1163 -0
package/dist/mcp-mounts.d.ts +239 -0
package/dist/mcp-mounts.d.ts.map +1 -0
package/dist/mcp-mounts.js +222 -0
package/dist/oauth-login-types.d.ts +160 -0
package/dist/oauth-login-types.d.ts.map +1 -0
package/dist/oauth-login-types.js +9 -0
package/dist/oauth-login.d.ts +77 -0
package/dist/oauth-login.d.ts.map +1 -0
package/dist/oauth-login.js +455 -0
package/dist/oauth-providers/github.d.ts +17 -0
package/dist/oauth-providers/github.d.ts.map +1 -0
package/dist/oauth-providers/github.js +89 -0
package/dist/oauth-providers/google.d.ts +18 -0
package/dist/oauth-providers/google.d.ts.map +1 -0
package/dist/oauth-providers/google.js +59 -0
package/dist/oauth-providers-store.d.ts +32 -0
package/dist/oauth-providers-store.d.ts.map +1 -0
package/dist/oauth-providers-store.js +291 -0
package/dist/oauth.d.ts +347 -0
package/dist/oauth.d.ts.map +1 -0
package/dist/oauth.js +686 -0
package/dist/pairing-transport.d.ts +99 -0
package/dist/pairing-transport.d.ts.map +1 -0
package/dist/pairing-transport.js +223 -0
package/dist/rate-limit-middleware.d.ts +36 -0
package/dist/rate-limit-middleware.d.ts.map +1 -0
package/dist/rate-limit-middleware.js +57 -0
package/dist/render-gate.d.ts +87 -0
package/dist/render-gate.d.ts.map +1 -0
package/dist/render-gate.js +77 -0
package/dist/render-rate-limit.d.ts +59 -0
package/dist/render-rate-limit.d.ts.map +1 -0
package/dist/render-rate-limit.js +73 -0
package/dist/render-signing.d.ts +98 -0
package/dist/render-signing.d.ts.map +1 -0
package/dist/render-signing.js +113 -0
package/dist/request-context.d.ts +113 -0
package/dist/request-context.d.ts.map +1 -0
package/dist/request-context.js +154 -0
package/dist/reserved-validators.d.ts +22 -0
package/dist/reserved-validators.d.ts.map +1 -0
package/dist/reserved-validators.js +101 -0
package/dist/schema-compat.d.ts +167 -0
package/dist/schema-compat.d.ts.map +1 -0
package/dist/schema-compat.js +187 -0
package/dist/security-headers-middleware.d.ts +38 -0
package/dist/security-headers-middleware.d.ts.map +1 -0
package/dist/security-headers-middleware.js +30 -0
package/dist/server.d.ts +2060 -0
package/dist/server.d.ts.map +1 -0
package/dist/server.js +6338 -0
package/dist/session-channel.d.ts +651 -0
package/dist/session-channel.d.ts.map +1 -0
package/dist/session-channel.js +1756 -0
package/dist/storage.d.ts +89 -0
package/dist/storage.d.ts.map +1 -0
package/dist/storage.js +171 -0
package/dist/thread-transport.d.ts +118 -0
package/dist/thread-transport.d.ts.map +1 -0
package/dist/thread-transport.js +478 -0
package/dist/user-session-auth.d.ts +167 -0
package/dist/user-session-auth.d.ts.map +1 -0
package/dist/user-session-auth.js +148 -0
package/package.json +76 -0

package/dist/mcp-apps-outbound.d.ts ADDED Viewed

@@ -0,0 +1,448 @@
+/**
+ * MCP Apps outbound wiring — the server-side half of the
+ * `ggui_push -> ui://ggui/session -> iframe -> live channel` delivery path.
+ *
+ * Responsibilities of this module (and nothing else):
+ *
+ *   1. Advertise the `io.modelcontextprotocol/ui` capability on every
+ *      fresh `McpServer` instance so MCP Apps hosts know the server
+ *      speaks the UI extension.
+ *   2. Register `ui://ggui/session` as a static resource servable via
+ *      MCP `resources/read`. The resource body is the thin-shell HTML
+ *      hosts sandbox-render when they see `_meta.ui.resourceUri` on a
+ *      `ggui_push` result.
+ *
+ * Boundary discipline:
+ *
+ *   - This module imports from `@ggui-ai/protocol/integrations/mcp-apps`
+ *     (the subpath). It does NOT expose MCP-Apps-specific shapes back
+ *     into `build-mcp.ts`, `server.ts`, or the blueprint handlers.
+ *   - Capability advertisement and resource registration are the ONLY
+ *     server-wide concerns here. Bootstrap-token mint + live-channel
+ *     bootstrap-auth live in separate slices of the same overall
+ *     outbound path.
+ *
+ * Why the shell body lives here:
+ *
+ *   The thin shell is static content; it depends on nothing except the
+ *   MIME constant and the HTML. Keeping it next to the registration
+ *   means a future refactor of the shell edits one file. The
+ *   `@ggui-ai/react` package does NOT ship the shell as a separate
+ *   build target — per the design lock, the shell is served by the
+ *   same `@ggui-ai/mcp-server` instance that mints the bootstrap.
+ */
+import { type McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { SessionStore, VectorStore } from '@ggui-ai/mcp-server-core';
+import { type GguiBootstrapMeta } from '@ggui-ai/protocol/integrations/mcp-apps';
+export declare const GGUI_SESSION_SHELL_HTML = "<!doctype html>\n<html lang=\"en\" style=\"height:100%\"><head><meta charset=\"utf-8\"><title>ggui session</title></head>\n<body style=\"margin:0;height:100%;min-height:480px\"><div id=\"ggui-root\" data-ggui-shell=\"thin\" style=\"height:100%;min-height:480px\"></div>\n<script>\n(function(){'use strict';\n// MCP Apps shell. Speaks the canonical postMessage protocol from\n// @modelcontextprotocol/ext-apps:\n//   1. iframe -> host: ui/initialize\n//   2. iframe -> host: ui/notifications/initialized\n//   3. host -> iframe: ui/notifications/tool-result (per CallToolResult)\n// On tool-result, derive base URL + shortCode from structuredContent,\n// fetch JSON bootstrap (componentCode + ids + runtimeUrl), set\n// window.__GGUI_BOOTSTRAP__, fetch runtime as blob, inject as script.\n// Runtime auto-mounts inline. No nested iframe (claudemcpcontent.com\n// CSP frame-src forbids cross-origin frames). State machine matches\n// buildSelfContainedShell so the same runtime mounts both paths.\nvar rpcId=1,pending={};\nvar rootEl=document.getElementById('ggui-root');\nrootEl.style.cssText='display:flex;flex-direction:column;height:100%;min-height:300px;margin:0';\nvar mounted=false;\nfunction setOverlay(text){\n  if(mounted)return;\n  rootEl.innerHTML='<div style=\"font:14px system-ui,sans-serif;padding:24px;color:#666\">'+text+'</div>';\n}\nfunction postNotification(method,params){\n  try{window.parent.postMessage({jsonrpc:'2.0',method:method,params:params||{}},'*');}catch(e){}\n}\nfunction postRpc(method,params){\n  return new Promise(function(res,rej){\n    var id=rpcId++;pending[id]={res:res,rej:rej};\n    try{window.parent.postMessage({jsonrpc:'2.0',id:id,method:method,params:params||{}},'*');}\n    catch(e){delete pending[id];rej(e);}\n  });\n}\nfunction readToolResult(p){\n  if(!p)return null;\n  var sc=p.structuredContent;\n  if(sc&&typeof sc.url==='string'&&typeof sc.shortCode==='string'){\n    return {url:sc.url,shortCode:sc.shortCode};\n  }\n  if(Array.isArray(p.content)){\n    for(var i=0;i<p.content.length;i++){\n      var c=p.content[i];\n      if(c&&c.type==='text'&&typeof c.text==='string'){\n        try{var j=JSON.parse(c.text);\n          if(j&&typeof j.url==='string'&&typeof j.shortCode==='string'){\n            return {url:j.url,shortCode:j.shortCode};\n          }\n        }catch(e){}\n      }\n    }\n  }\n  return null;\n}\nfunction deriveBase(url){\n  try{var u=new URL(url);return u.origin;}catch(e){return null;}\n}\nfunction postBootstrapFailed(reason,message){\n  // Surface every shell-layer bootstrap-failure path as a typed\n  // RendererBootFailedMessage envelope so hosts pinning the C9\n  // error pane (McpAppIframe onError, IframeErrorPane) see the\n  // failure instead of staring at the inert overlay until the test\n  // times out. Reason codes match BootstrapFailureReason.\n  try{window.parent.postMessage({type:'ggui:bootstrap-failed',reason:reason,message:message},'*');}catch(e){}\n}\nasync function mountFromBootstrap(bootstrap){\n  if(mounted)return;\n  // runtimeUrl is the only load-bearing field at the shell layer \u2014\n  // it tells us which iframe-runtime bundle to fetch. componentCode\n  // is OPTIONAL: present in self-contained-mode bootstraps (the\n  // runtime renders the inlined code without WS), absent in\n  // GguiBootstrapMeta-shaped bootstraps (the runtime opens the WS\n  // subscription via wsUrl+token to receive the stack). Either is\n  // valid; the runtime decides at boot time. Rejecting on missing\n  // componentCode silently breaks every Path B GguiBootstrapMeta\n  // delivery, which is the whole point of the inline-bootstrap path.\n  if(!bootstrap||typeof bootstrap.runtimeUrl!=='string'){\n    setOverlay('Bootstrap payload malformed.');\n    postBootstrapFailed('BOOTSTRAP_MALFORMED','Bootstrap payload malformed.');\n    return;\n  }\n  setOverlay('Loading UI\u2026');\n  window.__GGUI_BOOTSTRAP__=bootstrap;\n  // Load the runtime bundle via a direct cross-origin script tag\n  // (governed by CSP script-src) instead of fetch + Blob (governed by\n  // CSP connect-src). claude.ai's claudemcpcontent.com iframe CSP\n  // forbids cross-origin connect-src so fetch throws TypeError\n  // 'Failed to fetch', but allows cross-origin script-src when the\n  // bundle responds with the right CORS headers (the iframe-runtime\n  // mount sets them). The self-contained shell already uses this\n  // pattern; legacy postMessage shell now matches it.\n  try{\n    var s=document.createElement('script');\n    s.type='module';\n    // crossorigin=anonymous opts into CORS-mode error reporting.\n    // Without it, cross-origin script tags get a sanitized\n    // \"script error\" with no details, masking the real cause\n    // (CSP block, CORS reject, module-evaluation throw). With it,\n    // the error event surfaces the actual message in the iframe\n    // console -- the bundle ships ACAO=* so credentialed mode is\n    // unnecessary.\n    s.crossOrigin='anonymous';\n    s.src=bootstrap.runtimeUrl;\n    s.onload=function(){mounted=true;};\n    s.onerror=function(e){\n      var msg='Runtime bundle failed to load: '+(e&&e.message||'script error');\n      setOverlay(msg);\n      postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n    };\n    rootEl.innerHTML='';\n    document.body.appendChild(s);\n  }catch(e){\n    var msg='Runtime bundle failed to load: '+(e&&e.message||e);\n    setOverlay(msg);\n    postBootstrapFailed('BUNDLE_FETCH_FAILED',msg);\n  }\n}\nasync function mount(toolResult){\n  if(mounted)return;\n  var base=deriveBase(toolResult.url);\n  if(!base){setOverlay('Invalid URL in tool result.');return;}\n  setOverlay('Loading UI\u2026');\n  var bootstrap;\n  try{\n    var bRes=await fetch(base+'/api/bootstrap/'+encodeURIComponent(toolResult.shortCode),{\n      cache:'no-store',\n      headers:{accept:'application/json'},\n    });\n    if(!bRes.ok){setOverlay('Bootstrap fetch failed: HTTP '+bRes.status);return;}\n    bootstrap=await bRes.json();\n  }catch(e){setOverlay('Bootstrap fetch error: '+(e&&e.message||e));return;}\n  return mountFromBootstrap(bootstrap);\n}\nfunction readBootstrapFromInitResult(result){\n  if(!result||typeof result!=='object')return null;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return null;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return null;\n  var ggui=meta.ggui;\n  if(!ggui||typeof ggui!=='object')return null;\n  var b=ggui.bootstrap;\n  if(!b||typeof b!=='object')return null;\n  // Same loosening as mountFromBootstrap: only runtimeUrl is required\n  // here. GguiBootstrapMeta forwarded by first-party McpAppIframe\n  // hosts omits componentCode by design (the runtime fetches the\n  // stack via\n  // wsUrl+token). Requiring componentCode at the shell layer turned\n  // every Path B inline-bootstrap delivery into a silent reject.\n  if(typeof b.runtimeUrl!=='string')return null;\n  return b;\n}\nfunction hasGguiMetaPlaceholder(result){\n  // Detect the protocol-violation case where the host signaled\n  // \"I tried to deliver bootstrap\" (toolOutput._meta.ggui exists)\n  // but the bootstrap field itself is absent or malformed. In that\n  // shape, we fail-fast with BOOTSTRAP_META_MISSING rather than\n  // sitting in the Path-A waiting state forever.\n  if(!result||typeof result!=='object')return false;\n  var toolOutput=result.toolOutput;\n  if(!toolOutput||typeof toolOutput!=='object')return false;\n  var meta=toolOutput._meta;\n  if(!meta||typeof meta!=='object')return false;\n  var ggui=meta.ggui;\n  return !!ggui&&typeof ggui==='object';\n}\nfunction readBootstrapFromCallToolResult(params){\n  // MCP Apps spec (specification/2026-01-26/apps.mdx:1145-1155):\n  //   ui/notifications/tool-result\n  //   params: CallToolResult  // Standard MCP type\n  // So params IS the CallToolResult and _meta lives at the top\n  // level (NOT under params.toolOutput, which is where the\n  // first-party McpAppIframe convention wraps it). Spec-compliant\n  // hosts (Claude Desktop, claude.ai Connector, Claude Code) deliver\n  // bootstrap material here.\n  if(!params||typeof params!=='object')return null;\n  var meta=params._meta;\n  if(!meta||typeof meta!=='object')return null;\n  var ggui=meta.ggui;\n  if(!ggui||typeof ggui!=='object')return null;\n  var b=ggui.bootstrap;\n  if(!b||typeof b!=='object')return null;\n  // Same loosening as readBootstrapFromInitResult / mountFromBootstrap:\n  // only runtimeUrl is required at the shell layer. componentCode is\n  // optional (absent for GguiBootstrapMeta-shaped bootstraps that\n  // open WS via wsUrl+token).\n  if(typeof b.runtimeUrl!=='string')return null;\n  return b;\n}\nwindow.addEventListener('message',function(ev){\n  var m=ev&&ev.data;\n  if(!m||m.jsonrpc!=='2.0')return;\n  if(m.id!=null&&pending[m.id]){\n    var p=pending[m.id];delete pending[m.id];\n    if(m.error)p.rej(m.error);else p.res(m.result);\n    return;\n  }\n  if(m.method==='ui/notifications/tool-result'){\n    // Spec-compliant hosts: m.params IS the CallToolResult; _meta is\n    // at the top level. Try this FIRST so Claude Desktop / claude.ai\n    // Connector / Claude Code land here.\n    var specB=readBootstrapFromCallToolResult(m.params);\n    if(specB){mountFromBootstrap(specB);return;}\n    // First-party McpAppIframe convention: bootstrap nested under\n    // params.toolOutput._meta. First-party hosts (Studio, Portal,\n    // console) use this shape for both init-response and post-init\n    // notification.\n    var bb=readBootstrapFromInitResult(m.params);\n    if(bb){mountFromBootstrap(bb);return;}\n    // Path A (last-resort fallback): host posts structuredContent.\n    // {url, shortCode}; shell fetches /api/bootstrap/<shortCode>\n    // over HTTP. The OSS server doesn't mount that endpoint, so this\n    // path is effectively dead unless a hosted operator wires it.\n    var tr=readToolResult(m.params);\n    if(tr)mount(tr);\n  }\n});\nsetOverlay('Initializing\u2026');\nvar initTimer=setTimeout(function(){\n  setOverlay('Host did not respond to ui/initialize within 3s.');\n},3000);\npostRpc('ui/initialize',{\n  appCapabilities:{},\n  appInfo:{name:'ggui-session',version:'1.0.0'},\n  protocolVersion:'2026-01-26'\n}).then(function(result){\n  clearTimeout(initTimer);\n  postNotification('ui/notifications/initialized',{});\n  // Path B: bootstrap inline in ui/initialize result. Hosts using\n  // <McpAppIframe>'s first-party dispatch deliver bootstrap meta here\n  // and never send a separate ui/notifications/tool-result.\n  var b=readBootstrapFromInitResult(result);\n  if(b){mountFromBootstrap(b);return;}\n  // Protocol-violation surface: host signalled an attempt\n  // (toolOutput._meta.ggui exists) but bootstrap is missing or\n  // malformed. Fail fast so hosts pinning a typed error envelope\n  // don't sit on the Path-A waiting overlay forever. Only fires\n  // when the meta placeholder is present \u2014 a fully absent _meta.ggui\n  // still falls through to Path A waiting.\n  if(hasGguiMetaPlaceholder(result)){\n    var msg='ui/initialize result missing _meta.ggui.bootstrap or runtimeUrl';\n    setOverlay(msg);\n    postBootstrapFailed('BOOTSTRAP_META_MISSING',msg);\n    return;\n  }\n  // Path A: wait for the host to send ui/notifications/tool-result\n  // with structuredContent.{url, shortCode}. MCP Apps hosts that don't\n  // implement the reading-B inline-bootstrap convention land here.\n  setOverlay('Waiting for tool result\u2026');\n}).catch(function(e){\n  clearTimeout(initTimer);\n  setOverlay('ui/initialize failed: '+(e&&e.message||JSON.stringify(e)));\n});\n})();\n</script></body></html>";
+/**
+ * CSP `script-src` source expression that authorises the inline
+ * `<script>` block of {@link GGUI_SESSION_SHELL_HTML} when it executes
+ * inside an iframe whose CSP is inherited from a parent host.
+ *
+ * # Why this exists
+ *
+ * The console's `<McpAppIframe>` mounts the production shell via
+ * `srcdoc`. The `about:srcdoc` iframe inherits the parent console
+ * SPA's CSP, which intentionally forbids `'unsafe-inline'` for
+ * `script-src` (`packages/mcp-server/src/console-headers.ts` —
+ * "If a future slice needs inline bootstrapping, add a nonce —
+ * NEVER `'unsafe-inline'` for scripts."). Without an authorising
+ * source expression for this exact script body, the inline shell
+ * is blocked at parse time and the renderer is never fetched. The
+ * lifecycle protocol never advances past `mounting`; specs pinning
+ * `data-ggui-mcp-app-iframe-lifecycle="code-ready"` time out.
+ *
+ * Hash CSP is the right shape here: the shell body is **static**
+ * and known at build time, and a hash binds the policy to the
+ * exact bytes — narrower than `'unsafe-inline'`, narrower than a
+ * runtime-generated nonce. If the shell body changes, the hash
+ * changes; the drift test in `mcp-apps-outbound.test.ts` catches
+ * a stale value.
+ *
+ * # Where it gets used
+ *
+ * `console-headers.ts::DEVTOOL_CSP` appends this expression to its
+ * `script-src` directive. Hosted closed-runtime session-resource
+ * endpoints have their own CSP and serve the same shell — that path
+ * needs the same expression added; tracked separately.
+ *
+ * # What an MCP Apps host (Claude Desktop etc.) does
+ *
+ * Production hosts set their own CSP on the iframe document — that
+ * surface is opaque to ggui. This expression is for the FIRST-PARTY
+ * path where the host is `<McpAppIframe>` and the parent SPA owns
+ * the CSP it inherits.
+ */
+export declare const GGUI_SESSION_SHELL_SCRIPT_HASH: string;
+export declare function registerGguiSessionResource(server: McpServer, shellHtml?: string, publicBaseUrl?: string): void;
+/**
+ * Advertise the `io.modelcontextprotocol/ui` extension capability on
+ * an `McpServer`'s underlying `Server`. Idempotent - calling twice on
+ * the same server leaves the capability advertised once.
+ *
+ * We use the `experimental` capability slot (present in every MCP SDK
+ * release) rather than `extensions` (post-1.x addition) for broadest
+ * client compat. The capability *name* is what matters to hosts; the
+ * container field is a pragmatic choice we can migrate if the spec
+ * settles on `extensions` later.
+ */
+export declare function advertiseMcpAppsUiCapability(server: McpServer): void;
+/**
+ * Inputs to {@link buildSelfContainedShell}.
+ *
+ * @public
+ */
+export interface SelfContainedShellInputs {
+    /** Session id whose top-of-stack render is being inlined. */
+    readonly sessionId: string;
+    /** App / tenant id the session is scoped to. */
+    readonly appId: string;
+    /**
+     * Content-addressable URL the iframe fetches the compiled ES module
+     * from. Mutually exclusive with {@link systemKind} — exactly one MUST
+     * be set. The runtime resolves the URL with `import(codeUrl)` at boot;
+     * the response is `Cache-Control: immutable` so subsequent loads of
+     * the same compiled bundle hit the browser cache.
+     */
+    readonly codeUrl?: string;
+    /**
+     * Hex-encoded sha256 of the bytes served at {@link codeUrl}. Paired
+     * with codeUrl (present together, absent together) — surfaces the
+     * integrity signal alongside the URL so consumers can dedup across
+     * pushes without re-parsing.
+     */
+    readonly codeHash?: string;
+    /**
+     * System-card kind identifier, mapped at runtime against the
+     * built-in `SYSTEM_CARD_REGISTRY`. Mutually exclusive with
+     * {@link codeUrl}.
+     */
+    readonly systemKind?: string;
+    /**
+     * Absolute URL of the iframe-runtime bundle the shell loads via
+     * `<script type="module" src=...>`. MUST be absolute (or root-
+     * relative resolvable from the host's iframe origin) — `srcdoc`
+     * iframes have `about:srcdoc` as their URL so a bare relative path
+     * cannot resolve. Also inlined on the `__GGUI_BOOTSTRAP__` global so
+     * the iframe-runtime's bootstrap validator (which requires
+     * `runtimeUrl` across all modes) accepts the envelope.
+     */
+    readonly runtimeUrl: string;
+    /** Optional stack-item id forwarded to the renderer for parity
+     *  with single-item-mode bootstrap selectors. */
+    readonly stackItemId?: string;
+    /**
+     * Canvas-mode flag. When `true`, the
+     * bootstrap is built as session-scoped (no stackItemId, no
+     * codeUrl/systemKind — live-mode trio MUST be supplied) and the
+     * iframe-runtime mounts {@link CanvasShell} instead of a single
+     * stack item. Mutually exclusive with {@link stackItemId}.
+     */
+    readonly canvasMode?: boolean;
+    /** Optional theme id forwarded to the renderer. */
+    readonly themeId?: string;
+    /**
+     * Optional color mode (`'light'` | `'dark'`) forwarded to the
+     * renderer. The runtime resolves the dark variant of {@link themeId}
+     * via `getTheme(id, 'dark')` when this is set; absent / unknown
+     * value falls back to `'light'`. Sourced from
+     * `LoadedTheme.mode` for preset/file forms; default-source themes
+     * omit this field entirely.
+     */
+    readonly themeMode?: 'light' | 'dark';
+    /**
+     * Optional pre-serialized props (must be a JSON string) forwarded
+     * to the renderer. Server inlines the string verbatim — the
+     * renderer parses + narrows to `Record<string, unknown>` at boot.
+     */
+    readonly propsJson?: string;
+    /**
+     * Names of same-server tools whose `_meta.ui.visibility` includes
+     * `"app"`, mirrored from {@link GguiBootstrapMeta.appCallableTools}.
+     * Forwarded to the iframe-runtime so its dispatch closure can choose
+     * Pattern α (direct `tools/call`) over Pattern β (3-message bridge)
+     * per wired action — even on the self-contained `/r/<shortCode>`
+     * path where there's no `ui/initialize` round-trip to deliver the
+     * field.
+     *
+     * Empty / absent → no fallout: the runtime's dispatch routes every
+     * action through Pattern β.
+     */
+    readonly appCallableTools?: GguiBootstrapMeta['appCallableTools'];
+    /**
+     * Per-action wired-tool mapping for the active stack item, mirrored
+     * from {@link GguiBootstrapMeta.actionNextSteps}.
+     */
+    readonly actionNextSteps?: GguiBootstrapMeta['actionNextSteps'];
+    /**
+     * Per-slot data for the active stack item's `contextSpec`, mirrored
+     * from {@link GguiBootstrapMeta.contextSlots}. The runtime
+     * synthesizes one `React.createContext(default)` per entry at boot.
+     * Without this field, contextSpec UIs render with un-seeded
+     * Providers.
+     */
+    readonly contextSlots?: GguiBootstrapMeta['contextSlots'];
+    /**
+     * Permissions-Policy directive list derived from the active stack
+     * item's `clientCapabilities.gadgets[*].permission`.
+     * When present (non-empty), inlined onto the bootstrap as
+     * `permissionsPolicy` so the iframe-runtime can surface the gate set
+     * to in-iframe consumers (debug overlay, permission-aware UI). The
+     * actual browser-enforced gate comes from the iframe's
+     * `Permissions-Policy` HTTP header (set on the public-render
+     * response by `/r/<shortCode>`) or the host's `allow=""` attribute
+     * (set from `_meta.ui.permissions` by McpAppIframe) — both derive
+     * from the same source. Empty / absent = no permissions requested.
+     */
+    readonly permissionsPolicy?: readonly string[];
+    /**
+     * Resolved gadget catalog the iframe runtime dynamically imports at
+     * boot. Each entry is `{hook,
+     * package?, bundleUrl?}`. The MCP-Apps `_meta.ggui.bootstrap`
+     * channel already forwards this via `push.ts`; this field is the
+     * symmetric forward for the self-contained shell so `/r/<shortCode>`
+     * and `resources/read` iframes don't render as STDLIB-only when
+     * the contract declares wrappers.
+     */
+    readonly gadgets?: GguiBootstrapMeta['gadgets'];
+    /**
+     * Precompiled, eval-free contract validators (one ESM validator-
+     * module source per `propsSpec` / `actionSpec` / `streamSpec` /
+     * `contextSpec`), mirrored from
+     * {@link GguiBootstrapMeta.compiledValidators}. The renderer iframe's
+     * strict CSP (no `'unsafe-eval'`) blocks runtime `ajv.compile()`, so
+     * the iframe loads these precompiled modules via `blob:` import
+     * instead. Symmetric forward for the self-contained shell so
+     * `/r/<shortCode>` and `resources/read` iframes validate wire
+     * traffic exactly as the MCP-Apps postMessage path does.
+     */
+    readonly compiledValidators?: GguiBootstrapMeta['compiledValidators'];
+    /**
+     * Server-filtered public env values that declared wrappers'
+     * `requires` cover (minimum-disclosure subset of `App.publicEnv`).
+     * Symmetric with the `_meta.ggui.bootstrap` channel — every
+     * transport that produces a `GguiBootstrapMeta` envelope MUST
+     * forward this field so wrappers' `getPublicEnv()` reads land.
+     */
+    readonly publicEnv?: GguiBootstrapMeta['publicEnv'];
+    /**
+     * Live-mode WebSocket URL the iframe-runtime opens to receive
+     * `props_update` / `stack_*` frames. When set alongside `token` +
+     * `expiresAt`, the parser admits the bootstrap as live-mode; when
+     * absent, the shell renders the static stack item but receives no
+     * push updates after mount (the bug `/r/<shortCode>` exhibited before
+     * we threaded the bootstrap minter through this route).
+     */
+    readonly wsUrl?: string;
+    /**
+     * Single-use bootstrap token authorising the WS subscribe. Paired
+     * with {@link wsUrl} — half-live envelopes (one without the other)
+     * are rejected as MALFORMED by `parseBootstrap`. Server-minted via
+     * the same `mintBootstrap` minter the JSON `/api/bootstrap/<shortCode>`
+     * route uses, so both transports share replay-cache state.
+     */
+    readonly token?: string;
+    /**
+     * ISO-8601 expiry of {@link token}. Past-due envelopes degrade to
+     * static-only mode at parse time; the static UI still mounts, but
+     * live updates silently no-op until a fresh push refreshes creds.
+     */
+    readonly expiresAt?: string;
+}
+/**
+ * Build the self-contained shell HTML for a given session.
+ *
+ * The returned HTML is a complete, standalone document: it inlines the
+ * compiled component (base64) + session ids in a `window.__GGUI_BOOTSTRAP__`
+ * global, then loads the iframe-runtime bundle via `<script type="module"
+ * src={runtimeUrl}>`. The runtime takes over synchronously on import,
+ * mounts the component, and the iframe paints WITHOUT any further server
+ * round-trip.
+ *
+ * Pure function — no DOM access, no I/O, no `crypto` randomness. Same
+ * inputs always produce identical bytes (modulo input ordering of the
+ * bootstrap object's optional fields), which makes the output cacheable
+ * and testable.
+ *
+ * Escapes that matter:
+ *   - HTML-entity-escapes the bootstrap JSON for `<` `>` `&` so a
+ *     malicious appId / sessionId can't break out of the script tag.
+ *   - The componentCode is base64-encoded by the caller before the JSON
+ *     stringification runs, so even a raw `</script>` sequence in the
+ *     compiled source can't break the surrounding HTML.
+ *
+ * @public
+ */
+export declare function buildSelfContainedShell(opts: SelfContainedShellInputs): string;
+/**
+ * Minimal "loading" HTML served when a per-session resource is fetched
+ * for a session whose top stack item has no componentCode yet
+ * (placeholder, generation in flight). Renders a tiny status surface
+ * so hosts that pin lifecycle selectors don't see a blank document.
+ *
+ * Hosts SHOULD re-fetch when they observe additional `ggui_push`
+ * results on the same session — the per-call `_meta.ui.resourceUri`
+ * value stays stable across pushes for a session, so re-fetching the
+ * same URI returns fresher HTML on the second try.
+ *
+ * @public
+ */
+export declare function buildSelfContainedLoadingShell(sessionId: string): string;
+/**
+ * Options for {@link registerGguiSessionResourceTemplate}.
+ *
+ * @public
+ */
+export interface GguiSessionResourceTemplateOptions {
+    /** SessionStore the template handler reads to find the topmost
+     *  stack item's componentCode. */
+    readonly sessionStore: SessionStore;
+    /** Absolute URL of the iframe-runtime bundle inlined in the shell. */
+    readonly runtimeUrl: string;
+    /**
+     * Content-addressable code-blob store. When wired alongside
+     * {@link codeBaseUrl}, the resource template hashes the top stack
+     * item's componentCode, writes it to the store, and inlines the
+     * resulting `codeUrl` into the shell bootstrap. Without these deps
+     * the resource path emits the loading shell when the top item is a
+     * compiled component (the static-component channel cannot deliver
+     * without a URL).
+     */
+    readonly codeStore?: import('@ggui-ai/mcp-server-core').CodeStore;
+    /**
+     * Base URL the code-blob route resolves to. Paired with {@link codeStore}.
+     */
+    readonly codeBaseUrl?: string;
+    /**
+     * Theme preset id resolved from `ggui.json#theme`. Without this,
+     * MCP-Apps hosts (claude.ai, Claude Desktop) that fetch the resource
+     * via `resources/read` always render the runtime's baked default
+     * theme — `ggui.json#theme: 'indigo'` would only take effect on
+     * the direct-browser `/r/<shortCode>` path, not in claude.ai.
+     */
+    readonly themeId?: string;
+    /** Theme color mode resolved from `ggui.json#theme.mode`. */
+    readonly themeMode?: 'light' | 'dark';
+    /**
+     * Per-app metadata store the resource handler reads to resolve
+     * `App.publicEnv` for the bootstrap projection.
+     * Symmetric with `/r/<shortCode>`'s lookup; wraps the same store
+     * the push gate reads. Absent ⇒ publicEnv stays empty on the
+     * resource-served bootstrap (wrappers calling `getPublicEnv` throw
+     * at hook-mount with a clear "not provided" message).
+     */
+    readonly appMetadataStore?: import('@ggui-ai/mcp-server-core').AppMetadataStore;
+    /**
+     * Vector store backing the blueprint registry. When wired alongside
+     * `defaultAppIdFallback`, the resource handler runs a registry-only
+     * rehydrate fallback for the two-segment URI shape
+     * (`ui://ggui/session/{sessionId}/{blueprintKey}`): if the session is
+     * gone but the blueprint registry still holds the entry, return the
+     * static initial render (default props + default context) instead of
+     * the dead "Generating UI…" loading shell. Single-tenant OSS sees
+     * meaningful improvement; multi-tenant deployments leave both options
+     * undefined to keep the loading-shell behavior on session miss.
+     */
+    readonly vectorStore?: VectorStore;
+    /**
+     * App-id used for blueprint-registry scoping when the session has
+     * been evicted. The registry is per-`appId`, but a missing session
+     * has no way to derive its tenant — multi-tenant deployments leave
+     * this undefined to fail-safe back to the loading shell. Single-
+     * tenant OSS sets `'builder'` (the universal-MCP default identity)
+     * and rehydrate works across session expiry / process restart.
+     */
+    readonly defaultAppIdFallback?: string;
+    /**
+     * Bootstrap minter for canvas-mode
+     * sessions. Supplied by the deployment (cloud wires it to the
+     * AppSync-bound minter; OSS wires it to the in-process minter
+     * already used by /api/bootstrap/<shortCode>).
+     *
+     * When the resource handler observes `session.mcpAppsMode ===
+     * 'canvas'`, it calls this to obtain `wsUrl` + `token` + `expiresAt`
+     * and inlines them on the canvas shell's bootstrap. Without this
+     * dep wired, the handler falls back to the legacy single-item path
+     * (no canvas).
+     *
+     * Returning `null` / throwing here degrades to the legacy path
+     * silently — the caller has no way to deliver a working canvas
+     * without WS credentials, but pinning a stackItem render is
+     * strictly better than serving a dead-loading shell.
+     */
+    readonly mintBootstrap?: (sessionId: string, appId: string) => Promise<{
+        readonly wsUrl: string;
+        readonly token: string;
+        readonly expiresAt: string;
+    } | null>;
+    /**
+     * Operator-supplied public origin. When present, every
+     * `resources/read` response from this template carries
+     * `_meta.ui.csp.{connectDomains,resourceDomains}` so claude.ai's
+     * cross-origin iframe CSP allows the runtime bundle, codeUrl
+     * fetches, and the live-channel WebSocket. Symmetric with the
+     * declaration on the static `ui://ggui/session` resource. Absent ⇒
+     * `_meta.ui.csp` omitted and the host's default CSP applies
+     * (`connect-src 'none'` in claude.ai — runtime bundle fails to
+     * load with a generic "script error").
+     */
+    readonly publicBaseUrl?: string;
+}
+/**
+ * Register a `ui://ggui/session/{sessionId}` resource template. Each
+ * `resources/read` request is resolved by looking up the session in the
+ * store, picking the topmost component stack item, and returning the
+ * self-contained shell with that componentCode inlined.
+ *
+ * Per-call `_meta.ui.resourceUri` (stamped by `ggui_push.resultMeta`)
+ * pins the URI to a specific sessionId; hosts fetch THAT URI rather
+ * than the static `ui://ggui/session` one. Both registrations co-exist:
+ * legacy postMessage shell at the static URI, self-contained shell at
+ * the templated URI.
+ *
+ * Failure modes:
+ *   - Session not found → loading shell (host re-fetches; absent
+ *     session is a transient state immediately after `ggui_push`).
+ *   - Session found, no componentCode yet → loading shell.
+ *   - Session found, componentCode present → self-contained shell.
+ *
+ * Returns nothing; mutates the server in place.
+ *
+ * @public
+ */
+export declare function registerGguiSessionResourceTemplate(server: McpServer, opts: GguiSessionResourceTemplateOptions): void;
+/**
+ * Apply the full MCP Apps outbound wiring to a fresh `McpServer` - both
+ * the capability advertisement and the `ui://ggui/session` resource. The
+ * single entry-point `build-mcp.ts` calls so request-path wiring stays
+ * one line.
+ *
+ * When `selfContained` is supplied, ALSO registers the per-session
+ * `ui://ggui/session/{sessionId}` resource template that serves the
+ * self-contained shell (the path third-party MCP Apps hosts use). The
+ * legacy static URI registration is unconditional — first-party hosts
+ * (Studio, Portal, console) still rely on the postMessage path.
+ */
+export declare function installMcpAppsOutbound(server: McpServer, opts?: {
+    readonly shellHtml?: string;
+    /**
+     * Per-session self-contained shell registration. When supplied,
+     * `ui://ggui/session/{sessionId}` becomes a readable resource
+     * template whose body inlines the compiled componentCode from the
+     * session's topmost stack item. Absent → only the legacy
+     * postMessage shell is registered.
+     */
+    readonly selfContained?: GguiSessionResourceTemplateOptions;
+    /**
+     * Public origin the server is reachable at — forwarded to
+     * `registerGguiSessionResource` so the static `ui://ggui/session`
+     * resource carries `_meta.ui.csp.{connectDomains,resourceDomains}`
+     * authorising the iframe to fetch the runtime bundle and open a
+     * WebSocket. Omit when running same-origin behind a first-party
+     * host (Studio/Portal/console) — the parent SPA owns the CSP
+     * there via `<McpAppIframe>`.
+     */
+    readonly publicBaseUrl?: string;
+}): void;
+//# sourceMappingURL=mcp-apps-outbound.d.ts.map

package/dist/mcp-apps-outbound.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"mcp-apps-outbound.d.ts","sourceRoot":"","sources":["../src/mcp-apps-outbound.ts"],"names":[],"mappings":"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"}