/** * The two Vite plugins this package hands to app builds. * * `innerRendererPlugin` supplies `virtual:executor-inner-renderer`: the shell * renders model-written JSX inside a nested `srcDoc` iframe whose whole program * is inlined as a string. That string is the inner renderer, bundled to an IIFE * by esbuild — it cannot be a normal import, because it must exist as *source * text* to be embedded in the sandboxed frame. * * `mcpAppsShellAsset` supplies `virtual:executor-mcp-apps-shell-html`: the URL * of the BUILT, self-contained shell document, emitted into the app's client * assets. The console's artifact page loads that URL into a sandboxed iframe * and speaks the MCP-Apps protocol to it, exactly as a real MCP-Apps client * does with the `ui://executor/shell.html` resource. * * Both live here rather than in `@executor-js/vite-plugin` because that package * is on the plugin-system kill list, and because esbuild, Vite and the shell * entry are all this package's own — resolving them from here needs no * cross-package path guessing. Apps that embed the shell add both plugins to * their vite config; the standalone shell build uses the inner-renderer one * too, so there is one definition of how the inner renderer is built. */ import { createHash } from "node:crypto";import path from "node:path";import { fileURLToPath } from "node:url"; import {  MCP_APPS_SHELL_DOCUMENT_MARKER,  MCP_APPS_SHELL_STABLE_ASSET_PATH,} from "./shell-asset-path.ts"; /** The structural shape of the Vite plugin object, declared locally so this *  module imports no Vite types (apps pin their own Vite version). */export interface InnerRendererVitePlugin {  readonly name: string;  readonly enforce?: "pre";  readonly resolveId: (id: string) => string | undefined;  readonly load: (id: string) => Promise<string | undefined>;} const VIRTUAL_ID = "virtual:executor-inner-renderer";const RESOLVED_ID = `\0${VIRTUAL_ID}`; const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."); export const innerRendererEntry = (): string =>  path.resolve(packageRoot, "src/shell/inner-renderer.tsx"); /** * Bundle the inner renderer to a self-contained IIFE string. * * Exported on its own so a build script or test can produce the same bytes the * plugin serves without standing up Vite. */export const bundleInnerRenderer = async (): Promise<string> => {  const { build } = await import("esbuild");  const result = await build({    entryPoints: [innerRendererEntry()],    absWorkingDir: packageRoot,    bundle: true,    write: false,    format: "iife",    platform: "browser",    target: "es2022",    jsx: "automatic",    define: {      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV ?? "development"),    },  });   const js = result.outputFiles[0];  if (!js) {    // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: Vite plugin hooks report build failures by throwing    throw new Error("Failed to bundle the MCP-Apps inner renderer.");  }  return js.text;}; export const smokeHarnessEntry = (): string =>  path.resolve(packageRoot, "src/shell/smoke-harness.tsx"); /** * Bundle the artifact smoke-render harness to a self-contained IIFE string. * * The same trick as the inner renderer, for the same reason: this program has * to exist as SOURCE TEXT, because its destination is a QuickJS sandbox that * takes a string of code and has no module resolution of its own. React, * react-dom/server, the component barrel and the tools proxy all end up inside * it, which is exactly right — the whole point is that none of them are loaded * in the trusted host process to render a model's artifact. * * Built for `browser` rather than `node` so react-dom resolves its * `server.browser` build: that entry needs no `node:` builtins, which QuickJS * does not have. `production` is pinned regardless of the ambient NODE_ENV — * React's development build reaches for far more host surface, and the smoke * render's answer must not depend on how the host was started. */export const bundleSmokeHarness = async (): Promise<string> => {  const { build } = await import("esbuild");  const result = await build({    entryPoints: [smokeHarnessEntry()],    absWorkingDir: packageRoot,    bundle: true,    write: false,    format: "iife",    platform: "browser",    target: "es2022",    jsx: "automatic",    // NOT minified, deliberately. React builds the component stack from    // function names, and that stack is most of the value of what the model is    // told: "at ChartTooltipContent, at BarChart, at App" is a fix, "at cie, at    // Sg" is nothing. Minifying saves ~1MB of source text the sandbox parses in    // a few hundred milliseconds; the stack is worth more than that.    minify: false,    define: { "process.env.NODE_ENV": JSON.stringify("production") },  });   const js = result.outputFiles[0];  if (!js) {    // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: build helpers report failure by throwing    throw new Error("Failed to bundle the artifact smoke-render harness.");  }  return js.text;}; /** Add to an app's `plugins` array to make the shell bundleable in that app. */export const innerRendererPlugin = (): InnerRendererVitePlugin => ({  name: "executor-inner-renderer-source",  // `pre` so the virtual id resolves before any generic resolver claims it.  enforce: "pre",  resolveId: (id) => (id === VIRTUAL_ID ? RESOLVED_ID : undefined),  load: async (id) => {    if (id !== RESOLVED_ID) return undefined;    return `export default ${JSON.stringify(await bundleInnerRenderer())};`;  },}); // ---------------------------------------------------------------------------// The in-frame Tailwind compiler, as source text// --------------------------------------------------------------------------- const TAILWIND_VIRTUAL_ID = "virtual:executor-tailwind-browser";const TAILWIND_RESOLVED_ID = `\0${TAILWIND_VIRTUAL_ID}`; /** * Supply `@tailwindcss/browser`'s bundle as a STRING. * * The shell inlines it into the sandboxed renderer frame, which compiles the * utilities the model's code uses — the build-time stylesheet can only contain * classes that existed at build time, and the model's did not. That frame runs * under `default-src 'none'` with no `connect-src`, so the compiler cannot be * fetched and has to travel as bytes. * * A plugin rather than an `?raw` import because the package's `exports` map * publishes only its module entry, so a deep path into `dist/` fails to * resolve. Reading the resolved entry's file is the supported way to its bytes. */export const tailwindBrowserSourcePlugin = (): InnerRendererVitePlugin => ({  name: "executor-tailwind-browser-source",  enforce: "pre",  resolveId: (id) => (id === TAILWIND_VIRTUAL_ID ? TAILWIND_RESOLVED_ID : undefined),  load: async (id) => {    if (id !== TAILWIND_RESOLVED_ID) return undefined;    const fs = await import("node:fs/promises");    const { createRequire } = await import("node:module");    const require = createRequire(path.join(packageRoot, "package.json"));    const entry = require.resolve("@tailwindcss/browser");    return `export default ${JSON.stringify(await fs.readFile(entry, "utf-8"))};`;  },}); // ---------------------------------------------------------------------------// The built shell document, as an app asset// --------------------------------------------------------------------------- const SHELL_VIRTUAL_ID = "virtual:executor-mcp-apps-shell-html";const SHELL_RESOLVED_ID = `\0${SHELL_VIRTUAL_ID}`;const DEV_SHELL_URL = "/assets/executor-mcp-apps-shell-dev.html";// The document's BYTES for the Worker in dev, where the stable asset does not// exist yet (assets are only emitted by a build) and the dev ASSETS binding// resolves against files on disk. `makeAssetsShellHtmlLoader` imports this// lazily, so the shell only builds when an artifact resource is actually read.const DEV_HTML_VIRTUAL_ID = "virtual:executor-mcp-apps-shell-dev-html";const DEV_HTML_RESOLVED_ID = `\0${DEV_HTML_VIRTUAL_ID}`; /** Where `build:shell` writes the self-contained shell document. */export const mcpAppsShellHtmlPath = (): string => path.resolve(packageRoot, "dist/mcp-app.html"); /** * Build the shell document and return its bytes. * * The shell is its own Vite build (`vite.config.shell.ts`), not an entry of the * app build: `vite-plugin-singlefile` inlines every chunk into one document, * which is only correct for a build whose sole output is that document. It runs * as a CHILD PROCESS rather than an in-process `vite.build()` because the caller * is itself a Vite build — nesting two builds in one process has them fight over * the singleton plugin state that `@tailwindcss/vite` and `@vitejs/plugin-react` * keep, and the shell's own Tailwind scan would then see the host app's sources. * * Always rebuilds rather than reusing a stale `dist/mcp-app.html`: the document * is what the artifact page renders, so serving yesterday's bytes is exactly the * class of bug this seam exists to prevent. The build takes about a second. */export const buildMcpAppsShellHtml = async (): Promise<string> => {  const fs = await import("node:fs/promises");  const { execFile } = await import("node:child_process");  const { promisify } = await import("node:util");   await promisify(execFile)(    process.execPath,    [      path.resolve(packageRoot, "node_modules/vite/bin/vite.js"),      "build",      "--config",      "vite.config.shell.ts",    ],    { cwd: packageRoot, maxBuffer: 32 * 1024 * 1024 },  );   return fs.readFile(mcpAppsShellHtmlPath(), "utf-8");}; /** The structural shape of the shell-asset plugin — same reasoning as above: *  no Vite types cross this module's boundary. */export interface McpAppsShellAssetVitePlugin {  readonly name: string;  readonly enforce?: "pre";  readonly configResolved: (config: {    readonly command: "build" | "serve";    readonly build?: { readonly ssr?: boolean | string };  }) => void;  readonly resolveId: (id: string) => string | undefined;  readonly load: (id: string) => Promise<string | undefined>;  readonly configureServer: (server: {    readonly middlewares: {      use: (        path: string,        handler: (          req: unknown,          res: {            setHeader: (name: string, value: string) => void;            end: (body: string) => void;          },          next: () => void,        ) => void,      ) => void;    };  }) => void;  /** Rollup calls this with its plugin context as `this` — declared here so the   *  implementation can reach `emitFile` without casting. */  readonly generateBundle: (    this: RollupEmitContext,    options: unknown,    bundle: unknown,    isWrite: boolean,  ) => Promise<void> | void;  readonly closeBundle: () => Promise<void>;} /** What this plugin needs from the hook context Vite calls it with. */interface RollupEmitContext {  readonly emitFile: (file: {    readonly type: "asset";    readonly fileName: string;    readonly source: string;  }) => void;  /** Vite's per-hook environment. `consumer` is "client" for the browser build   *  and "server" for an SSR/worker one. */  readonly environment?: { readonly config?: { readonly consumer?: string } };} /** * Serve the built shell document to the app at a stable URL. * * The artifact page needs the shell as a DOCUMENT, not as modules linked into * the console's own bundle — that is the whole point of the fix. So the shell * cannot travel through the app's module graph; it has to arrive as a URL the * iframe can load, with its own origin-less document scope. * * Under `serve` the document is built on first request and served from a dev * middleware. Under `build` it is emitted into the client output next to the * app's other assets. Either way the virtual module exports only the URL, so * the 4.5 MB document never enters a JS chunk. * * Content-hashed so a stale shell can never be served from a cached URL after * a rebuild, matching how `workerBundlerArtifact` addresses its own artifacts. */export const mcpAppsShellAsset = (): McpAppsShellAssetVitePlugin => {  let command: "build" | "serve" = "build";  let ssr = false;  let cached: { readonly html: string; readonly url: string } | undefined;   const load = async (): Promise<{ readonly html: string; readonly url: string }> => {    if (cached) return cached;    const html = await buildMcpAppsShellHtml();    // Build-blocking: runtime loaders authenticate the document by this    // fragment (an ASSETS-binding miss under SPA not-found handling answers    // with index.html and a 200), so a shell that lost it would make every    // deployed resource read fail. Catch that here, in the build.    if (!html.includes(MCP_APPS_SHELL_DOCUMENT_MARKER)) {      // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: Vite plugin hooks report build failures by throwing      throw new Error(        `Built MCP-Apps shell is missing its identity marker (${MCP_APPS_SHELL_DOCUMENT_MARKER}); ` +          "check the <meta> in src/shell/mcp-app.html.",      );    }    const digest = createHash("sha256").update(html).digest("hex").slice(0, 12);    cached = { html, url: `/assets/executor-mcp-apps-shell-${digest}.html` };    return cached;  };   return {    name: "executor-mcp-apps-shell-asset",    enforce: "pre",    configResolved(config) {      command = config.command;      // Recorded per environment, but ONE plugin instance sees every      // environment's `configResolved` before any of their bundles are      // generated — so the last write wins and this cannot be trusted at emit      // time. `generateBundle` reads Rollup's own output options instead; this      // only carries the single-environment case, where the two agree.      ssr = Boolean(config.build?.ssr);    },    resolveId: (id) => {      if (id === SHELL_VIRTUAL_ID) return SHELL_RESOLVED_ID;      if (id === DEV_HTML_VIRTUAL_ID) return DEV_HTML_RESOLVED_ID;      return undefined;    },    load: async (id) => {      if (id === DEV_HTML_RESOLVED_ID) {        // The Worker's dev-only escape hatch: under `build` it exports        // `undefined` and `makeAssetsShellHtmlLoader` uses the ASSETS binding;        // under `serve` it carries the built document inline, because no        // assets have been emitted for the binding to find. Guarded the same        // way as the URL module below — the build must not run at startup.        if (command !== "serve") {          return "export const devShellHtml = undefined;\nexport default devShellHtml;\n";        }        const { html } = await load();        return `export const devShellHtml = ${JSON.stringify(html)};\nexport default devShellHtml;\n`;      }      if (id !== SHELL_RESOLVED_ID) return undefined;      // Resolving the virtual module is part of Vite's startup graph. Building      // the multi-megabyte shell here makes every dev server pay that cost      // before it can answer even an unrelated route. In serve mode the      // middleware below owns the shell's lifetime, so hand the client a      // stable URL now and build only if that URL is actually requested.      if (command === "serve") {        return `export const shellHtmlUrl = ${JSON.stringify(DEV_SHELL_URL)};\nexport default shellHtmlUrl;\n`;      }      const { url } = await load();      return `export const shellHtmlUrl = ${JSON.stringify(url)};\nexport default shellHtmlUrl;\n`;    },    configureServer(server) {      // Dev has no emitted assets directory, so the document is served straight      // from memory at the same URL the virtual module advertises.      server.middlewares.use("/assets", (req, res, next) => {        const url = (req as { url?: string }).url ?? "";        if (!url.startsWith("/executor-mcp-apps-shell-")) {          next();          return;        }        void load().then(({ html }) => {          res.setHeader("content-type", "text/html; charset=utf-8");          res.setHeader("cache-control", "no-store");          res.end(html);        });      });    },    async generateBundle(_options, _bundle, _isWrite) {      if (command !== "build") return;       // Client output only. A multi-environment build (TanStack Start on cloud      // emits `dist/client` and `dist/server`) runs this hook once per      // environment, and `dist/server` IS the deployed Worker — emitting 4.5 MB      // of browser document there would inflate the Worker bundle with      // something only the browser ever fetches, over the ASSETS binding, from      // `dist/client`.      //      // The hook's own environment is the authority, because it is the only      // signal that is per-bundle: `configResolved`'s `build.ssr` is recorded      // once per environment on this shared plugin instance, so by the time any      // bundle is generated it holds whichever environment resolved last. A      // single-environment build (selfhost) reports no environment, and falls      // back to that flag, where the two do agree.      const consumer = this.environment?.config?.consumer;      if (consumer === undefined ? ssr : consumer !== "client") return;       const { html, url } = await load();      // `emitFile` puts the document through Rollup's own output writer, so it      // lands in whatever client outDir the app (or its framework plugin)      // configured — which `process.cwd()`-relative writes get wrong for      // TanStack Start, where the client build writes to `dist/client`.      this.emitFile({ type: "asset", fileName: url.replace(/^\//, ""), source: html });      // A second copy at the STABLE name, for the server side: a Workers host      // serves the `ui://executor/shell.html` MCP resource by fetching this      // through its ASSETS binding (`makeAssetsShellHtmlLoader`), and the      // self-host image reads it from the SPA dist on disk — neither can know      // the content hash the client build minted. See `./shell-asset-path`.      this.emitFile({        type: "asset",        fileName: MCP_APPS_SHELL_STABLE_ASSET_PATH.replace(/^\//, ""),        source: html,      });    },    async closeBundle() {      cached = undefined;    },  };};