// Cross-target: updating an OpenAPI spec IN PLACE — the "our API changed,// don't make me remove/re-add the integration" promise. A real 127.0.0.1// server serves the spec; after registration + connection the spec evolves// (one operation removed, one added) and `openapi.updateSpec` re-fetches it.// The tool catalog follows, the response reports the diff, and everything// user-curated (connection, description, auth template) survives.import { randomBytes, randomUUID } from "node:crypto";import { createServer } from "node:http"; import { expect } from "@effect/vitest";import { Effect } from "effect";import { composePluginApi } from "@executor-js/api/server";import { openApiHttpPlugin } from "@executor-js/plugin-openapi/api";import {  AuthTemplateSlug,  ConnectionName,  IntegrationSlug,  ProviderItemId,} from "@executor-js/sdk/shared"; import { scenario } from "../src/scenario";import { Api, Target } from "../src/services"; const api = composePluginApi([openApiHttpPlugin()] as const); const specV1 = JSON.stringify({  openapi: "3.0.3",  info: { title: "Evolving API", version: "1.0.0" },  paths: {    "/ping": {      get: {        operationId: "ping",        summary: "Return a pong",        responses: { "200": { description: "pong" } },      },    },    "/legacy": {      get: {        operationId: "legacyOp",        summary: "Soon to be removed",        responses: { "200": { description: "ok" } },      },    },  },}); const specV2 = JSON.stringify({  openapi: "3.0.3",  info: { title: "Evolving API", version: "2.0.0" },  paths: {    "/ping": {      get: {        operationId: "ping",        summary: "Return a pong",        responses: { "200": { description: "pong" } },      },    },    "/widgets": {      get: {        operationId: "listWidgets",        summary: "List widgets",        responses: { "200": { description: "widgets" } },      },    },  },}); /** A real 127.0.0.1 server whose served spec can be swapped mid-scenario. */const serveMutableSpec = (initial: string) =>  Effect.acquireRelease(    Effect.callback<{      readonly url: string;      readonly setBody: (body: string) => void;      readonly close: () => void;    }>((resume) => {      let body = initial;      const server = createServer((_request, response) => {        response.writeHead(200, { "content-type": "application/json" });        response.end(body);      });      server.listen(0, "127.0.0.1", () => {        const address = server.address();        const port = typeof address === "object" && address ? address.port : 0;        resume(          Effect.succeed({            url: `http://127.0.0.1:${port}/spec.json`,            setBody: (next: string) => {              body = next;            },            close: () => {              server.close();              server.closeAllConnections();            },          }),        );      });    }),    (server) => Effect.sync(server.close),  ); scenario(  "OpenAPI · updating the spec rebuilds tools without re-adding the integration",  {},  Effect.scoped(    Effect.gen(function* () {      const target = yield* Target;      const { client } = yield* Api;      const identity = yield* target.newIdentity();      const apiClient = yield* client(api, identity);       const slug = `update-spec-${randomBytes(4).toString("hex")}`;      const specServer = yield* serveMutableSpec(specV1);       yield* Effect.ensuring(        Effect.gen(function* () {          const added = yield* apiClient.openapi.addSpec({            payload: {              spec: { kind: "url", url: specServer.url },              slug,              baseUrl: "http://127.0.0.1:59999", // tools are never invoked here              description: "Curated description that must survive the update.",              authenticationTemplate: [                {                  slug: "apiKey",                  type: "apiKey",                  headers: { "x-api-key": [{ type: "variable", name: "token" }] },                },              ],            },          });          expect(added.toolCount, "v1 spec has two operations").toBe(2);           const providers = yield* apiClient.providers.list();          yield* apiClient.connections.create({            payload: {              owner: "org",              name: ConnectionName.make("main"),              integration: IntegrationSlug.make(slug),              template: AuthTemplateSlug.make("apiKey"),              from: { provider: providers[0]!, id: ProviderItemId.make(randomUUID()) },            },          });          const toolNames = (filter: { integration: string }) =>            Effect.map(              apiClient.tools.list({                query: { integration: IntegrationSlug.make(filter.integration) },              }),              (tools) => tools.map((tool) => tool.name).sort(),            );          expect(yield* toolNames({ integration: slug }), "v1 tools are live").toEqual([            "legacy.legacyOp",            "ping.getOperation",          ]);           // The upstream API ships v2: legacyOp is gone, listWidgets appears.          specServer.setBody(specV2);          const updated = yield* apiClient.openapi.updateSpec({            params: { slug },            payload: {},          });           expect(updated.addedTools, "the diff names the new tool").toEqual([            "widgets.listWidgets",          ]);          expect(updated.removedTools, "the diff names the removed tool").toEqual([            "legacy.legacyOp",          ]);           // The connection's catalog follows the new spec — same connection,          // no re-add.          expect(yield* toolNames({ integration: slug }), "v2 tools are live").toEqual([            "ping.getOperation",            "widgets.listWidgets",          ]);          const connections = yield* apiClient.connections.list({            query: { integration: IntegrationSlug.make(slug) },          });          expect(            connections.map((connection) => String(connection.name)),            "the connection survived",          ).toEqual(["main"]);          const integration = yield* apiClient.integrations.get({            params: { slug: IntegrationSlug.make(slug) },          });          expect(integration.description, "the curated description survived").toBe(            "Curated description that must survive the update.",          );        }),        Effect.gen(function* () {          yield* apiClient.connections            .remove({              params: {                owner: "org",                integration: IntegrationSlug.make(slug),                name: ConnectionName.make("main"),              },            })            .pipe(Effect.ignore);          yield* apiClient.openapi.removeSpec({ params: { slug } }).pipe(Effect.ignore);        }),      );    }),  ),);