// Local-only — the integration Edit sheet for a STDIO MCP server, driven in a// real browser. `local` is the only surface that enables stdio MCP// (`dangerouslyAllowStdioMCP: true`), so it is the only place this sheet can be// exercised end to end.//// The sheet used to say "Stdio MCP integrations cannot be edited. Remove and// recreate the integration with the updated command." (#812) — changing a// command meant editing `executor.jsonc` by hand, or losing the integration's// connections and policies to a delete-and-re-add.//// The assertion is deliberately not "the field accepted my text". The scenario// edits the DECLARED env map through the form and then reads the tool catalog:// the fixture advertises `saw_declared_env` only when that variable is present// in the spawned child's environment, so the tool appearing proves the edited// config travelled the whole way — form, config write, respawn, rediscovery.import { fileURLToPath } from "node:url"; import { expect } from "@effect/vitest";import { Effect } from "effect";import { HttpApiClient } from "effect/unstable/httpapi";import { FetchHttpClient, HttpClient, HttpClientRequest } from "effect/unstable/http";import { composePluginApi } from "@executor-js/api/server";import { mcpHttpPlugin } from "@executor-js/plugin-mcp/api"; import { scenario } from "../src/scenario";import { Browser, Cli, RunDir, Target } from "../src/services";import { withLocalServer } from "./local-server"; const api = composePluginApi([mcpHttpPlugin()] as const); const FIXTURE = fileURLToPath(new URL("./fixtures/stdio-mcp-server.mjs", import.meta.url)); const SECRET = "s3cr3t-typed-into-the-edit-sheet"; scenario(  "Local · a stdio MCP server's command and environment are editable from the integration Edit sheet",  { timeout: 300_000 },  Effect.gen(function* () {    const cli = yield* Cli;    const browser = yield* Browser;    const target = yield* Target;    const runDir = yield* RunDir;    const identity = yield* target.newIdentity();     yield* withLocalServer(cli, runDir, (server) =>      Effect.gen(function* () {        const client = yield* HttpApiClient.make(api, {          baseUrl: new URL("/api", server.origin).toString(),          transformClient: HttpClient.mapRequest((request) =>            HttpClientRequest.setHeader(request, "authorization", `Bearer ${server.token}`),          ),        }).pipe(Effect.provide(FetchHttpClient.layer));         const slug = "e2e-stdio-editable";         // A plain stdio server: no declared env, so the env-gated tool is absent        // until the edit adds the variable.        yield* client.mcp.addServer({          payload: {            transport: "stdio",            name: "E2E Stdio Editable",            command: "node",            args: [FIXTURE],            slug,          },        });         const before = yield* client.tools.list({ query: { integration: slug } });        expect(          before.map((t) => t.name),          "the server starts with its base tool and no declared env",        ).toContain("echo_tool");        expect(          before.map((t) => t.name),          "the env-gated tool is absent before the edit",        ).not.toContain("saw_declared_env");         yield* browser.session(identity, async ({ page, step }) => {          await step("Open the stdio integration from the console", async () => {            await page.goto(server.url, { waitUntil: "domcontentloaded" });            await page.getByTestId(`integration-entry-${slug}`).first().click();            // Wait for the detail page's own data, not just its shell: clicking            // Edit while the accounts panel is still a skeleton races the layout            // shift that lands when it resolves.            await page.getByText("default").first().waitFor({ timeout: 30_000 });            await page.getByRole("button", { name: "Edit" }).waitFor({ timeout: 30_000 });          });           await step("Open the Edit sheet — the stdio command is editable", async () => {            await page.getByRole("button", { name: "Edit" }).click();            await page.getByText("Edit integration").waitFor({ timeout: 30_000 });            await page.getByText("Server command").waitFor({ timeout: 30_000 });            // The read-only dead end this replaces.            expect(              await page.getByText("Stdio MCP integrations cannot be edited").count(),              "the read-only message is gone",            ).toBe(0);            expect(              await page.getByRole("textbox", { name: "Command" }).inputValue(),              "the stored command is loaded into the form",            ).toBe("node");          });           await step("Declare an environment variable and save", async () => {            await page              .getByRole("textbox", { name: "Environment variables" })              .fill(`EXECUTOR_E2E_SECRET=${SECRET}`);            await page.getByRole("button", { name: "Save" }).click();            await page.getByText("Server command").waitFor({ state: "hidden", timeout: 30_000 });          });        });         // The edit persisted as the DECLARED static env map on the config.        const stored = yield* client.mcp.getServer({ params: { slug } });        expect(          stored?.config.transport === "stdio" ? stored.config.env : undefined,          "the sheet wrote the declared env map",        ).toEqual({ EXECUTOR_E2E_SECRET: SECRET });        expect(          stored?.config.transport === "stdio" ? stored.config.command : undefined,          "the command it did not touch is unchanged",        ).toBe("node");         // And it reached the spawned server: the fixture gates this tool's very        // existence on that variable being in its own environment.        const after = yield* client.tools.list({ query: { integration: slug } });        expect(          after.map((t) => t.name),          "the edited environment reached the respawned server and the catalog was rebuilt",        ).toContain("saw_declared_env");        expect(          after.map((t) => t.name),          "the rebuild kept the tools that still exist",        ).toContain("echo_tool");      }),    );  }),);