/** * The HTTP-backed host an embedded MCP-Apps shell talks to. * * A shell normally runs inside an MCP client, where `callServerTool` is the * MCP bridge. On the artifact page there is no MCP client — the console renders * the artifact itself — so this adapter answers the same two tool calls over * the ordinary executions HTTP API instead: * *   execute-action        -> POST /executions *   execute-action-resume -> POST /executions/:id/resume * * The shell's `proxy.ts` already turns `tools.a.b.c(...)` into `execute-action` * and recurses through `waiting_for_interaction` -> trusted modal -> resume, so * elicitation approvals work unchanged; this layer only moves bytes. * * The type is declared structurally rather than imported from * `@executor-js/mcp-apps-shell`: that package depends on THIS one for its * component barrel, so a type import here would close a package cycle that * turbo rejects outright. The shell's `McpAppsShellHost` is deliberately * structural for exactly this reason — see its declaration. */ import { getExecutorApiBaseUrl, getExecutorServerAuthorizationHeader } from "./server-connection"; /** The wire shape of `POST /executions` and `POST /executions/:id/resume`. */type ExecutionResponse =  | {      readonly status: "completed";      readonly text: string;      readonly structured: unknown;      readonly isError: boolean;    }  | { readonly status: "paused"; readonly text: string; readonly structured: unknown }; /** The subset of `CallToolResult` the shell reads back. */export interface ShellToolResult {  readonly content: ReadonlyArray<{ readonly type: "text"; readonly text: string }>;  readonly structuredContent?: Record<string, unknown>;  readonly isError?: boolean | undefined;} /** Structurally compatible with the shell package's `McpAppsShellHost`. */export interface HttpShellHost {  readonly callServerTool: (params: {    name: string;    arguments?: Record<string, unknown>;  }) => Promise<ShellToolResult>;  readonly getHostContext: () => { readonly theme: "light" | "dark" } | undefined;  readonly openLink: (params: { url: string }) => Promise<unknown>;  /** Store a settled-render snapshot as the artifact's gallery preview.   *  Best-effort: failures are swallowed, since the layout preview remains. */  readonly savePreview: (artifactId: string, preview: string) => void;} const isRecord = (value: unknown): value is Record<string, unknown> =>  typeof value === "object" && value !== null && !Array.isArray(value); /** `ApprovalExpiredError`'s status: the paused execution existed and *  deliberately no longer does. See `packages/core/api/src/executions/api.ts`. */const APPROVAL_EXPIRED_STATUS = 410; /** What the user reads when their approval arrived too late. Phrased as the next *  action, because nothing ran and retrying is safe. */export const APPROVAL_EXPIRED_MESSAGE = "This approval expired. Trigger the action again."; /** * The kernel's envelope travels in `structured`; the shell unwraps it itself. * A completed-and-failed execution maps to `isError` so the shell's proxy * throws inside the generated component instead of handing it a bogus value. */const toShellToolResult = (response: ExecutionResponse): ShellToolResult => ({  content: [{ type: "text", text: response.text }],  structuredContent: isRecord(response.structured)    ? response.structured    : { result: response.structured },  isError: response.status === "completed" && response.isError ? true : undefined,}); /** The resume action the shell sends back after the user answers the modal. */const isResumeAction = (value: unknown): value is "accept" | "decline" | "cancel" =>  value === "accept" || value === "decline" || value === "cancel"; /** * `execute-action-resume` carries the elicitation answer as a JSON *string* * (the MCP tool contract is string-typed), so it is parsed back here. An * unparseable or non-object body becomes `undefined` rather than throwing: the * user's decision (accept/decline/cancel) still deserves to reach the server. */const parseResumeContent = (raw: unknown): Record<string, unknown> | undefined => {  if (typeof raw !== "string" || raw === "{}") return undefined;  // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: JSON.parse over a value the shell built; a malformed body must not lose the user's answer  try {    // oxlint-disable-next-line executor/no-json-parse -- boundary: the resume content arrives as an opaque JSON string across the shell's postMessage bridge    const parsed: unknown = JSON.parse(raw);    return isRecord(parsed) ? parsed : undefined;  } catch {    return undefined;  }}; const prefersDark = (): boolean =>  typeof globalThis.window !== "undefined" &&  typeof globalThis.window.matchMedia === "function" &&  globalThis.window.matchMedia("(prefers-color-scheme: dark)").matches; /** * Build the host. `fetch` is injectable so the seam can be tested without a * server; everything else is read at call time from the active server * connection, matching how the typed API client resolves its base URL and * bearer (a desktop connection carries no auth and sends none). */export const createHttpShellHost = (options?: {  readonly fetch?: typeof globalThis.fetch;}): HttpShellHost => {  const doFetch = options?.fetch ?? globalThis.fetch.bind(globalThis);   const post = async (path: string, payload: Record<string, unknown>): Promise<unknown> => {    const headers: Record<string, string> = { "content-type": "application/json" };    const authorization = getExecutorServerAuthorizationHeader();    if (authorization) headers.authorization = authorization;     const response = await doFetch(`${getExecutorApiBaseUrl()}${path}`, {      method: "POST",      headers,      body: JSON.stringify(payload),    });    if (!response.ok) {      const text = await response.text();      // An approval that outlived its window is an ordinary outcome, not a      // fault: nothing ran, and the fix is to trigger the action again. Say that      // instead of surfacing the transport's error body, which reached the user      // as a raw `ExecutionNotFoundError` inside a JSON-RPC envelope.      if (response.status === APPROVAL_EXPIRED_STATUS) {        // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: the shell's tool proxy is Promise-based and surfaces rejections as component errors        throw new Error(APPROVAL_EXPIRED_MESSAGE);      }      // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: the shell's tool proxy is Promise-based and surfaces rejections as component errors      throw new Error(text || `Executor API request failed with ${response.status}`);    }    return response.json();  };   return {    getHostContext: () => ({ theme: prefersDark() ? "dark" : "light" }),     /**     * Store a snapshot of the settled render as the artifact's gallery preview.     *     * Best-effort in every direction: a failure is swallowed, because the card     * already has a layout preview to fall back on and a viewer who merely     * opened an artifact has done nothing that deserves an error. Supplying     * this at all is what tells the shell it may capture — see `savePreview` on     * `McpAppsShellHost`.     */    savePreview: (artifactId: string, preview: string): void => {      const headers: Record<string, string> = { "content-type": "application/json" };      const authorization = getExecutorServerAuthorizationHeader();      if (authorization) headers.authorization = authorization;      void doFetch(        `${getExecutorApiBaseUrl()}/artifacts/${encodeURIComponent(artifactId)}/preview`,        { method: "PUT", headers, body: JSON.stringify({ preview }) },      ).then(        () => undefined,        // Deliberately silent, and not an Effect: there is no caller to report        // to and nothing downstream to recover. A failed upload leaves the card        // on its layout preview, which is already a good picture.        () => undefined,      );    },     openLink: async ({ url }) => {      globalThis.window?.open(url, "_blank", "noopener,noreferrer");      return {};    },     callServerTool: async ({ name, arguments: args }) => {      const input = args ?? {};       if (name === "execute-action") {        const code = input.code;        if (typeof code !== "string") {          // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: see above          throw new Error("Missing execute-action code.");        }        // The artifact id travels with the call: the code addresses integrations        // by role, and the bindings that resolve a role live on the artifact row.        const artifactId = input.artifactId;        return toShellToolResult(          (await post("/executions", {            code,            ...(typeof artifactId === "string" ? { artifactId } : {}),          })) as ExecutionResponse,        );      }       if (name === "execute-action-resume") {        const executionId = input.executionId;        const action = input.action;        if (typeof executionId !== "string") {          // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: see above          throw new Error("Missing execution id.");        }        if (!isResumeAction(action)) {          // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: see above          throw new Error("Invalid resume action.");        }        return toShellToolResult(          (await post(`/executions/${encodeURIComponent(executionId)}/resume`, {            action,            content: parseResumeContent(input.content),          })) as ExecutionResponse,        );      }       // oxlint-disable-next-line executor/no-try-catch-or-throw, executor/no-error-constructor -- boundary: see above      throw new Error(`Unsupported shell tool: ${name}`);    },  };};