// The console artifact page's transport. It has no MCP client, so it answers the// shell's two tool calls over the executions HTTP API — which is exactly the// path that used to surface a raw `ExecutionNotFoundError` to the user when an// approval arrived after the pause was gone.import { afterEach, describe, expect, it } from "@effect/vitest";import { Schema } from "effect"; import { EXECUTOR_ORG_HEADER, setActiveOrgSlugOverride } from "./server-connection";import { APPROVAL_EXPIRED_MESSAGE, createHttpShellHost } from "./shell-host"; /** The adapter's request body, read back off the wire. */const decodeRequestBody = Schema.decodeUnknownSync(  Schema.fromJsonString(Schema.Record(Schema.String, Schema.Unknown)),); const jsonResponse = (body: unknown, status = 200): Response =>  new Response(JSON.stringify(body), {    status,    headers: { "content-type": "application/json" },  }); /** Records what the adapter put on the wire, so the assertions are about the *  request the server actually receives rather than the adapter's internals. */const recordingFetch = (respond: (url: string) => Response) => {  const calls: Array<{ url: string; body: unknown; headers: Record<string, string> }> = [];  const fetch: typeof globalThis.fetch = async (input, init) => {    const url = String(input);    calls.push({      url,      body: typeof init?.body === "string" ? decodeRequestBody(init.body) : undefined,      headers: Object.fromEntries(new Headers(init?.headers).entries()),    });    return respond(url);  };  return { calls, fetch };}; const completed = () =>  jsonResponse({ status: "completed", text: "ok", structured: {}, isError: false }); describe("createHttpShellHost", () => {  // Module state on the org scope: leaking a slug would silently head the  // "no org" cases below.  afterEach(() => {    setActiveOrgSlugOverride(null);  });   it("maps execute-action onto POST /executions, carrying the artifact id", async () => {    const { calls, fetch } = recordingFetch(() =>      jsonResponse({ status: "completed", text: "ok", structured: { result: 1 }, isError: false }),    );    const host = createHttpShellHost({ fetch });     const result = await host.callServerTool({      name: "execute-action",      arguments: { code: "return await tools.a.b()", artifactId: "art_1" },    });     expect(calls).toHaveLength(1);    expect(calls[0]?.url).toContain("/executions");    expect(calls[0]?.body).toStrictEqual({ code: "return await tools.a.b()", artifactId: "art_1" });    expect(result.isError).toBeUndefined();  });   it("maps execute-action-resume onto the execution's resume route", async () => {    const { calls, fetch } = recordingFetch(() =>      jsonResponse({ status: "completed", text: "ok", structured: {}, isError: false }),    );    const host = createHttpShellHost({ fetch });     await host.callServerTool({      name: "execute-action-resume",      arguments: { executionId: "exec_1", action: "accept", content: '{"note":"hi"}' },    });     expect(calls[0]?.url).toContain("/executions/exec_1/resume");    expect(calls[0]?.body).toStrictEqual({ action: "accept", content: { note: "hi" } });  });   // The reported bug's user-visible half: the approval failed and the person  // clicking Approve got a JSON-RPC envelope wrapping an internal error tag.  it("reports an expired approval as a next action, not a raw server error", async () => {    const { fetch } = recordingFetch(() =>      jsonResponse({ _tag: "ApprovalExpiredError", executionId: "exec_1" }, 410),    );    const host = createHttpShellHost({ fetch });     await expect(      host.callServerTool({        name: "execute-action-resume",        arguments: { executionId: "exec_1", action: "accept", content: "{}" },      }),    ).rejects.toThrow(APPROVAL_EXPIRED_MESSAGE);  });   it("does not disguise other failures as an expired approval", async () => {    const { fetch } = recordingFetch(() => new Response("upstream exploded", { status: 500 }));    const host = createHttpShellHost({ fetch });     await expect(      host.callServerTool({ name: "execute-action", arguments: { code: "return 1" } }),    ).rejects.toThrow("upstream exploded");  });   // A malformed body must not lose the user's decision — the action still has to  // reach the server so the paused execution gets an answer.  it("still sends the decision when the resume content will not parse", async () => {    const { calls, fetch } = recordingFetch(() =>      jsonResponse({ status: "completed", text: "ok", structured: {}, isError: false }),    );    const host = createHttpShellHost({ fetch });     await host.callServerTool({      name: "execute-action-resume",      arguments: { executionId: "exec_1", action: "decline", content: "{not json" },    });     // `content` is absent rather than null: an unparseable body is dropped, but    // the decision still travels.    expect(calls[0]?.body).toStrictEqual({ action: "decline" });  });   // The prod outage this file's fix addresses. An org-scoped host (cloud) fails  // CLOSED on a session request with no org selector — it 403s rather than  // falling back to the session's org — so a header-less request from here made  // every artifact tool call return `no_organization`. Asserted on all three  // request shapes, since each built its own headers before.  describe("the org selector header", () => {    it("scopes execute-action to the console's org", async () => {      setActiveOrgSlugOverride("acme");      const { calls, fetch } = recordingFetch(completed);       await createHttpShellHost({ fetch }).callServerTool({        name: "execute-action",        arguments: { code: "return 1", artifactId: "art_1" },      });       expect(calls[0]?.headers[EXECUTOR_ORG_HEADER]).toBe("acme");    });     // The approval leg: a resume that lost the scope would strand the user's    // decision on a paused execution.    it("scopes execute-action-resume to the console's org", async () => {      setActiveOrgSlugOverride("acme");      const { calls, fetch } = recordingFetch(completed);       await createHttpShellHost({ fetch }).callServerTool({        name: "execute-action-resume",        arguments: { executionId: "exec_1", action: "accept", content: "{}" },      });       expect(calls[0]?.headers[EXECUTOR_ORG_HEADER]).toBe("acme");    });     it("scopes the preview upload to the console's org", async () => {      setActiveOrgSlugOverride("acme");      const { calls, fetch } = recordingFetch(() => jsonResponse({}));       createHttpShellHost({ fetch }).savePreview("art_1", "data:image/png;base64,AA==");      // savePreview is deliberately fire-and-forget, so wait for the microtask      // that issues the request rather than a returned promise.      await Promise.resolve();       expect(calls[0]?.url).toContain("/artifacts/art_1/preview");      expect(calls[0]?.headers[EXECUTOR_ORG_HEADER]).toBe("acme");    });     // Hosts without org scoping (local, desktop, self-host) have no slug to    // send, and their servers would have nothing to do with one.    it("sends no selector when the host has no org scope", async () => {      setActiveOrgSlugOverride(null);      const { calls, fetch } = recordingFetch(completed);       await createHttpShellHost({ fetch }).callServerTool({        name: "execute-action",        arguments: { code: "return 1" },      });       expect(calls[0]?.headers).not.toHaveProperty(EXECUTOR_ORG_HEADER);    });     // The host outlives any one org: it is memoized for the page's lifetime,    // so the scope has to be read per request, not captured at construction.    it("follows the scope when the console switches org", async () => {      setActiveOrgSlugOverride("acme");      const { calls, fetch } = recordingFetch(completed);      const host = createHttpShellHost({ fetch });       await host.callServerTool({ name: "execute-action", arguments: { code: "return 1" } });      setActiveOrgSlugOverride("globex");      await host.callServerTool({ name: "execute-action", arguments: { code: "return 1" } });       expect(calls.map((call) => call.headers[EXECUTOR_ORG_HEADER])).toStrictEqual([        "acme",        "globex",      ]);    });  });});