@jskit-ai/connectors-catalog 0.1.1

package/test/mapbox.test.js

@@ -0,0 +1,181 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, readdir, readFile, rm } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { createConnectionService } from "../../connectors-core/src/server/index.js";
+import { createFileConnectionStore, createCredentialProtection } from "../../connectors-core/src/server/fileStorage.js";
+import { parseIntegrationConfiguration } from "../../connectors-core/src/shared/configuration.js";
+import { mapboxProvider } from "../src/server/mapbox.js";
+
+const context = { applicationId: "app-one", subjectId: "team-one" };
+const input = { context, integrationId: "maps" };
+const token = { code: "TokenValid", token: { usage: "sk", user: "fixture", authorization: "token-id" } };
+const places = { type: "FeatureCollection", features: [{ type: "Feature", geometry: { type: "Point", coordinates: [115.86, -31.95] }, properties: { name: "Perth" } }], attribution: "Fixture attribution" };
+
+async function fixture(t) {
+  const directory = await mkdtemp(path.join(tmpdir(), "mapbox-connector-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const protection = createCredentialProtection({ keys: { current: new Uint8Array(32).fill(7) }, activeKeyId: "current" });
+  const requests = [];
+  const state = { key: "sk.fixture", status: 200, response: token };
+  const options = {
+    configuration: { schemaVersion: 1, integrations: {
+      maps: { provider: "mapbox", accountMode: "shared", scopes: [],
+        authentication: { method: "api-key", secretRef: "env:MAPBOX_BACKEND_TOKEN" },
+        settings: { usage: "backend", publicTokenRef: "env:MAPBOX_PUBLIC_TOKEN" }, extensions: { keep: true } }
+    }, registrations: {}, extensions: { fromCli: true } },
+    providers: [mapboxProvider], authorize: async (owner) => owner,
+    resolveReference: async (ref) => {
+      assert.equal(ref, "env:MAPBOX_BACKEND_TOKEN");
+      return state.key;
+    },
+    store: createFileConnectionStore({ directory, protection }),
+    fetchImpl: async (address, init) => {
+      requests.push({ url: new URL(String(address)), init, headers: new Headers(init.headers) });
+      return Response.json(state.response, { status: state.status });
+    }
+  };
+  return { service: createConnectionService(options), options, directory, protection, requests, state };
+}
+
+test("Mapbox verifies an active token, persists only references and isolates application owners", async (t) => {
+  const { service, options, directory, protection, requests, state } = await fixture(t);
+  const connected = await service.connectApiKey(input);
+  assert.equal(connected.status, "connected");
+  assert.equal(requests[0].url.href, "https://api.mapbox.com/tokens/v2?access_token=sk.fixture");
+  assert.equal(requests[0].headers.has("authorization"), false);
+  assert.equal(requests[0].headers.has("referer"), false);
+  assert.equal(requests[0].init.redirect, "error");
+  assert.equal(JSON.stringify(connected).includes(state.key), false);
+  for (const name of await readdir(directory)) assert.equal((await readFile(path.join(directory, name), "utf8")).includes(state.key), false);
+  const restarted = createConnectionService({ ...options, store: createFileConnectionStore({ directory, protection }) });
+  assert.deepEqual(await restarted.status(input), connected);
+  state.key = "pk.replacement";
+  state.response = { code: "TokenValid", token: { usage: "pk", user: "fixture", authorization: "replacement-id" } };
+  assert.deepEqual(await restarted.invoke({ ...input, operation: "token.read" }), state.response);
+  assert.equal(requests.at(-1).url.searchParams.get("access_token"), state.key);
+  for (const owner of [{ ...context, applicationId: "other-app" }, { ...context, subjectId: "other-team" }]) {
+    await assert.rejects(restarted.invoke({ ...input, context: owner, operation: "token.read" }), { code: "connector_reconnect_required" });
+  }
+  await restarted.disconnect(input);
+  assert.equal((await service.status(input)).status, "disconnected");
+});
+
+test("Mapbox keeps browser references separate and re-verifies changed configuration", async (t) => {
+  const { options, service, requests } = await fixture(t);
+  const parse = (configuration) => parseIntegrationConfiguration(JSON.stringify(configuration), { providers: [mapboxProvider] });
+  assert.deepEqual(parse(options.configuration), options.configuration);
+  const changed = structuredClone(options.configuration);
+  changed.integrations.maps.settings.publicTokenRef = "pk.must-not-be-source";
+  assert.throws(() => parse(changed), (error) => Boolean(error.fieldErrors["integrations.maps.settings.publicTokenRef"]));
+  delete changed.integrations.maps.settings.publicTokenRef;
+  assert.deepEqual(parse(changed), changed);
+  await service.connectApiKey(input);
+  const replacement = createConnectionService({ ...options, configuration: changed });
+  assert.equal((await replacement.status(input)).status, "reconnect-required");
+  await assert.rejects(replacement.invoke({ ...input, operation: "token.read" }), { code: "connector_reconnect_required" });
+  assert.equal(requests.length, 1);
+  await replacement.connectApiKey(input);
+  assert.equal((await replacement.status(input)).status, "connected");
+});
+
+test("Mapbox rejects inactive token replies even with HTTP 200 and persists reconnect state", async (t) => {
+  const { service, state } = await fixture(t);
+  for (const code of ["TokenMalformed", "TokenInvalid", "TokenExpired", "TokenRevoked"]) {
+    state.response = { code, token: { ...token.token, diagnostic: state.key } };
+    await assert.rejects(service.connectApiKey(input), { code: "connector_reconnect_required" });
+    assert.equal((await service.status(input)).status, "disconnected");
+  }
+  for (const response of [{ code: "TokenValid" }, { code: "TokenValid", token: { usage: "unknown", user: "x" } }, { code: "TokenValid", token: { usage: "pk" } }, { code: "Unexpected" }]) {
+    state.response = response;
+    await assert.rejects(service.connectApiKey(input), { code: "connector_response_invalid" });
+  }
+  state.response = token;
+  await service.connectApiKey(input);
+  state.response = { code: "TokenRevoked", message: state.key };
+  await assert.rejects(service.invoke({ ...input, operation: "token.read" }), (error) => {
+    assert.equal(error.code, "connector_reconnect_required");
+    assert.equal(error.stack.includes(state.key), false);
+    return true;
+  });
+  assert.equal((await service.status(input)).status, "reconnect-required");
+});
+
+test("Mapbox geocoding preserves features, attribution and explicit storage intent", async (t) => {
+  const { service, state, requests } = await fixture(t);
+  await service.connectApiKey(input);
+  state.response = places;
+  assert.deepEqual(await service.invoke({ ...input, operation: "geocoding.forward", input: { q: "Café & Perth" } }), places);
+  assert.equal(requests.at(-1).url.pathname, "/search/geocode/v6/forward");
+  assert.deepEqual(Object.fromEntries(requests.at(-1).url.searchParams), { q: "Café & Perth", limit: "5", autocomplete: "false", permanent: "false", access_token: "sk.fixture" });
+  await service.invoke({ ...input, operation: "geocoding.forward", input: { q: "Perth", limit: 10, autocomplete: true, permanent: true } });
+  assert.equal(requests.at(-1).url.searchParams.get("permanent"), "true");
+  assert.deepEqual(await service.invoke({ ...input, operation: "geocoding.reverse", input: { longitude: 115.86, latitude: -31.95 } }), places);
+  assert.equal(requests.at(-1).url.pathname, "/search/geocode/v6/reverse");
+  assert.deepEqual(Object.fromEntries(requests.at(-1).url.searchParams), { longitude: "115.86", latitude: "-31.95", permanent: "false", access_token: "sk.fixture" });
+  state.response = { ...places, features: [] };
+  assert.deepEqual(await service.invoke({ ...input, operation: "geocoding.reverse", input: { longitude: -180, latitude: 90 } }), state.response);
+  for (const response of [{ type: "FeatureCollection", features: [] }, { ...places, features: {} }, { ...places, type: "Feature" }]) {
+    state.response = response;
+    await assert.rejects(service.invoke({ ...input, operation: "geocoding.forward", input: { q: "Perth" } }), { code: "connector_response_invalid" });
+  }
+});
+
+test("Mapbox bounds geocoding input before transport and cannot override credentials or URLs", async (t) => {
+  const { service, requests } = await fixture(t);
+  await service.connectApiKey(input);
+  for (const value of [{}, { q: "" }, { q: "x".repeat(257) }, { q: "one ".repeat(21) }, { q: "A;B" }, { q: "Perth", limit: 0 }, { q: "Perth", limit: 11 }, { q: "Perth", limit: 1.5 }, { q: "Perth", autocomplete: "maybe" }, { q: "Perth", permanent: [] }, { q: "Perth", access_token: "other" }, { q: "Perth", url: "https://attacker.invalid" }]) {
+    await assert.rejects(service.invoke({ ...input, operation: "geocoding.forward", input: value }), { code: "connector_input_invalid" });
+  }
+  for (const value of [{}, { longitude: 0 }, { latitude: 0 }, { longitude: 181, latitude: 0 }, { longitude: 0, latitude: -91 }, { longitude: NaN, latitude: 0 }, { longitude: 0, latitude: Infinity }]) {
+    await assert.rejects(service.invoke({ ...input, operation: "geocoding.reverse", input: value }), { code: "connector_input_invalid" });
+  }
+  assert.equal(requests.length, 1);
+});
+
+test("Mapbox token verification does not bypass geocoding permission or quota failures", async (t) => {
+  const { service, state } = await fixture(t);
+  await service.connectApiKey(input);
+  for (const [status, code] of [[403, "connector_permission_denied"], [429, "connector_rate_limited"], [500, "connector_provider_failed"], [401, "connector_reconnect_required"]]) {
+    state.status = status;
+    state.response = { message: state.key };
+    await assert.rejects(service.invoke({ ...input, operation: "geocoding.forward", input: { q: "Perth" } }), (error) => {
+      assert.equal(error.code, code);
+      assert.equal(error.stack.includes(state.key), false);
+      assert.equal(error.cause, undefined);
+      return true;
+    });
+  }
+  assert.equal((await service.status(input)).status, "reconnect-required");
+});
+
+test("Mapbox browser-only configuration needs a public reference but no backend credential", () => {
+  const configuration = { schemaVersion: 1, registrations: {}, integrations: { maps: {
+    provider: "mapbox", accountMode: "shared", scopes: [], authentication: { method: "none" },
+    settings: { usage: "browser", publicTokenRef: "env:MAPBOX_PUBLIC_TOKEN" }
+  } } };
+  const parse = value => parseIntegrationConfiguration(JSON.stringify(value), { providers: [mapboxProvider] });
+  assert.deepEqual(parse(configuration), configuration);
+  assert.equal(mapboxProvider.configurationOnlyForSettings(configuration.integrations.maps.settings), true);
+  delete configuration.integrations.maps.settings.publicTokenRef;
+  assert.throws(() => parse(configuration));
+});
+
+test("Mapbox directions preserve route geometry and distinguish unavailable routes", async t => {
+  const { service, requests, state } = await fixture(t);
+  await service.connectApiKey(input);
+  const values = { profile: "walking", coordinates: [{ longitude: 115.86, latitude: -31.95 }, { longitude: 115.87, latitude: -31.96 }], steps: true };
+  state.response = { code: "Ok", routes: [{ distance: 1400, duration: 1100, geometry: { type: "LineString", coordinates: [[115.86, -31.95], [115.87, -31.96]] } }] };
+  const call = values => service.invoke({ ...input, operation: "directions.get", input: values });
+  assert.deepEqual(await call(values), state.response);
+  assert.equal(requests.at(-1).url.pathname, "/directions/v5/mapbox/walking/115.86,-31.95;115.87,-31.96");
+  assert.equal(requests.at(-1).url.searchParams.get("geometries"), "geojson");
+  for (const code of ["NoRoute", "NoSegment"]) { state.response = { code }; assert.deepEqual(await call(values), { code }); }
+  const count = requests.length;
+  for (const changes of [{ coordinates: [] }, { profile: "../keys" }, { coordinates: [{ longitude: 181, latitude: 0 }, { longitude: 0, latitude: 0 }] }])
+    await assert.rejects(call({ ...values, ...changes }), { code: "connector_input_invalid" });
+  assert.equal(requests.length, count);
+  state.response = { code: "Ok", routes: [{ distance: -1 }] };
+  await assert.rejects(call(values), { code: "connector_response_invalid" });
+});

package/test/mcp.test.js

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, readFile, readdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { createConnectionService } from "../../connectors-core/src/server/index.js";
+import { createFileConnectionStore, createCredentialProtection } from "../../connectors-core/src/server/fileStorage.js";
+import { parseIntegrationConfiguration } from "../../connectors-core/src/shared/configuration.js";
+import { n8nProvider } from "../src/server/n8n.js";
+import { sanityProvider } from "../src/server/sanity.js";
+
+const context = { applicationId: "editor", subjectId: "assistant-owner" };
+const input = { context, integrationId: "assistant" };
+const tools = [{ name: "search_documents", description: "Fixture search", inputSchema: { type: "object", properties: { query: { type: "string" } } } }];
+const cases = [
+  { provider: n8nProvider, settings: { serverUrl: "https://automation.example:8443/team/mcp-server/http" }, endpoint: "https://automation.example:8443/team/mcp-server/http" },
+  { provider: sanityProvider, endpoint: "https://mcp.sanity.io/" }
+];
+
+async function fixture(t, spec) {
+  const directory = await mkdtemp(path.join(tmpdir(), "mcp-connectors-"));
+  t.after(() => rm(directory, { recursive: true, force: true }));
+  const protection = createCredentialProtection({ keys: { current: new Uint8Array(32).fill(4) }, activeKeyId: "current" });
+  const requests = [];
+  const policy = [];
+  const state = { token: "fixture-private-token", status: 200, sse: false, sessions: true,
+    list: { tools, nextCursor: "opaque+/=cursor" }, call: { content: [{ type: "text", text: "Result" }] } };
+  const options = {
+    configuration: { schemaVersion: 1, registrations: {}, integrations: { assistant: {
+      provider: spec.provider.id, accountMode: "assistant", scopes: [],
+      authentication: { method: "api-key", secretRef: "env:MCP_TOKEN" }, ...(spec.settings ? { settings: spec.settings } : {})
+    } } }, providers: [spec.provider], store: createFileConnectionStore({ directory, protection }),
+    resolveReference: async (reference) => { assert.equal(reference, "env:MCP_TOKEN"); return state.token; },
+    authorize: async (owner, request) => {
+      policy.push(structuredClone(request));
+      if (request.operation === "tools.call" && request.input.name !== "search_documents") return null;
+      return owner;
+    },
+    fetchImpl: async (address, init) => {
+      init.signal.throwIfAborted();
+      const message = init.body ? JSON.parse(init.body) : undefined;
+      requests.push({ url: String(address), headers: new Headers(init.headers), init, message });
+      if (init.method === "DELETE") return new Response(null, { status: state.cleanupStatus || 204 });
+      if (init.method === "GET") return new Response(null, { status: 405 });
+      if (state.status !== 200) return new Response(state.token, { status: state.status,
+        headers: { "WWW-Authenticate": 'Bearer resource_metadata="https://unexpected.example/auth"', Location: "https://unexpected.example/redirect" } });
+      if (message.id === undefined) return new Response(null, { status: 202 });
+      if (state.pause && message.method === "tools/call") {
+        state.started?.();
+        return new Promise((resolve, reject) => init.signal.addEventListener("abort", () => reject(init.signal.reason), { once: true }));
+      }
+      const result = message.method === "initialize"
+        ? { protocolVersion: message.params.protocolVersion, capabilities: { tools: {} }, serverInfo: { name: "fixture", version: "1.0" } }
+        : message.method === "tools/list" ? state.list : state.call;
+      const payload = state.rpcError && message.method === "tools/call"
+        ? { jsonrpc: "2.0", id: message.id, error: { code: -32602, message: state.token } }
+        : { jsonrpc: "2.0", id: message.id, result };
+      const headers = state.sessions ? { "Mcp-Session-Id": "fixture-session" } : {};
+      return state.sse
+        ? new Response(`event: message\ndata: ${JSON.stringify(payload)}\n\n`, { headers: { ...headers, "Content-Type": "text/event-stream" } })
+        : Response.json(payload, { headers });
+    }
+  };
+  return { options, service: createConnectionService(options), directory, protection, requests, state, policy };
+}
+
+for (const spec of cases) {
+  test(`${spec.provider.name} negotiates MCP, discovers tools and closes sessions using the configured token`, async (t) => {
+    const { service, requests, options, state, directory, protection } = await fixture(t, spec);
+    assert.equal((await service.connectApiKey(input)).status, "connected");
+    assert.deepEqual(requests.filter(({ message }) => message).map(({ message }) => message.method), ["initialize", "notifications/initialized", "tools/list"]);
+    assert.equal(requests.at(-1).init.method, "DELETE");
+    for (const request of requests) {
+      assert.equal(request.url, spec.endpoint);
+      assert.equal(request.headers.get("authorization"), `Bearer ${state.token}`);
+      assert.equal(request.init.redirect, "error");
+      assert.equal(request.init.credentials, "omit");
+      if (request.message?.method !== "initialize") assert.equal(request.headers.get("mcp-session-id"), "fixture-session");
+    }
+    assert.deepEqual(requests[0].message.params.capabilities, {}, "No sampling, elicitation or local resources are granted.");
+    const restarted = createConnectionService({ ...options, store: createFileConnectionStore({ directory, protection }) });
+    state.token = "rotated-fixture-token";
+    assert.deepEqual(await restarted.invoke({ ...input, operation: "tools.list", input: { cursor: "opaque+/=cursor" } }), state.list);
+    assert.equal(requests.findLast(({ message }) => message?.method === "tools/list").message.params.cursor, "opaque+/=cursor");
+    assert.equal(requests.at(-1).headers.get("authorization"), `Bearer ${state.token}`);
+    for (const name of await readdir(directory)) assert.equal((await readFile(path.join(directory, name), "utf8")).includes(state.token), false);
+    for (const owner of [{ ...context, applicationId: "other-app" }, { ...context, subjectId: "other-user" }]) {
+      await assert.rejects(restarted.invoke({ ...input, context: owner, operation: "tools.list" }), { code: "connector_reconnect_required" });
+    }
+    await restarted.disconnect(input);
+    assert.equal((await service.status(input)).status, "disconnected");
+  });
+
+  test(`${spec.provider.name} supports SSE and stateless servers without executing a tool during connection`, async (t) => {
+    const { service, state, requests } = await fixture(t, spec);
+    state.sse = true;
+    state.sessions = false;
+    await service.connectApiKey(input);
+    assert.equal(requests.some(({ message }) => message?.method === "tools/call"), false);
+    assert.equal(requests.some(({ init }) => init.method === "DELETE"), false);
+    assert.deepEqual(await service.invoke({ ...input, operation: "tools.call", input: { name: "search_documents", arguments: { query: "title:hello" } } }), state.call);
+    assert.deepEqual(requests.at(-1).message.params, { name: "search_documents", arguments: { query: "title:hello" } });
+  });
+
+  test(`${spec.provider.name} authorizes the exact tool and arguments before sending any request`, async (t) => {
+    const { service, requests, options, policy } = await fixture(t, spec);
+    await service.connectApiKey(input);
+    const count = requests.length;
+    await assert.rejects(service.invoke({ ...input, operation: "tools.call", input: { name: "delete_documents", arguments: { id: "all" } } }), { code: "connector_access_denied" });
+    assert.equal(requests.length, count);
+    assert.deepEqual(policy.at(-1), { integrationId: "assistant", operation: "tools.call", accountMode: "assistant", input: { name: "delete_documents", arguments: { id: "all" } } });
+    const supplied = { name: "search_documents", arguments: { query: "approved" } };
+    const guarded = createConnectionService({ ...options, authorize: async (owner, request) => {
+      supplied.name = "delete_documents";
+      supplied.arguments.query = "changed";
+      request.input.name = "delete_documents";
+      request.input.arguments.query = "policy-mutated";
+      return owner;
+    } });
+    await guarded.invoke({ ...input, operation: "tools.call", input: supplied });
+    assert.deepEqual(requests.findLast(({ message }) => message?.method === "tools/call").message.params, { name: "search_documents", arguments: { query: "approved" } });
+  });
+
+  test(`${spec.provider.name} validates assistant configuration and operation inputs before HTTP`, async (t) => {
+    const { service, options, requests } = await fixture(t, spec);
+    const parse = (config) => parseIntegrationConfiguration(JSON.stringify(config), { providers: [spec.provider] });
+    assert.deepEqual(parse(options.configuration), options.configuration);
+    for (const mode of ["shared", "per-user"]) {
+      const config = structuredClone(options.configuration);
+      config.integrations.assistant.accountMode = mode;
+      assert.throws(() => parse(config));
+    }
+    if (spec.settings) {
+      for (const serverUrl of [undefined, "", "http://n8n.example/mcp-server/http", "https://a:b@n8n.example/mcp-server/http", "https://n8n.example/mcp-server/http?token=secret", "https://n8n.example/../mcp-server/http", "https://n8n.example/api/v1"]) {
+        const config = structuredClone(options.configuration);
+        config.integrations.assistant.settings.serverUrl = serverUrl;
+        assert.throws(() => parse(config));
+      }
+    }
+    await service.connectApiKey(input);
+    const count = requests.length;
+    for (const args of [{ name: "search_documents" }, { name: "search_documents", arguments: [] }, { name: "search_documents", arguments: {}, url: "https://other.example" }]) {
+      await assert.rejects(service.invoke({ ...input, operation: "tools.call", input: args }), { code: "connector_input_invalid" });
+    }
+    await assert.rejects(service.invoke({ ...input, operation: "tools.list", input: { cursor: "x".repeat(4097) } }), { code: "connector_input_invalid" });
+    assert.equal(requests.length, count);
+  });
+
+  test(`${spec.provider.name} handles HTTP failures without discovery, redirects or secret leaks`, async (t) => {
+    const { service, requests, state } = await fixture(t, spec);
+    for (const [status, code] of [[401, "connector_reconnect_required"], [403, "connector_permission_denied"], [429, "connector_rate_limited"], [500, "connector_provider_failed"], [302, "connector_provider_failed"]]) {
+      state.status = status;
+      const count = requests.length;
+      await assert.rejects(service.connectApiKey(input), (error) => error.code === code && !error.message.includes(state.token));
+      assert.equal(requests.length, count + 1);
+      assert.equal((await service.status(input)).status, "disconnected");
+    }
+    state.status = 200;
+    await service.connectApiKey(input);
+    state.status = 401;
+    await assert.rejects(service.invoke({ ...input, operation: "tools.list" }), { code: "connector_reconnect_required" });
+    assert.equal((await service.status(input)).status, "reconnect-required");
+    assert.equal(requests.every(({ url }) => url === spec.endpoint), true);
+  });
+
+  test(`${spec.provider.name} rejects malformed protocol data, preserves tool errors and cleans up`, async (t) => {
+    const { service, state, requests } = await fixture(t, spec);
+    state.list = { tools: [{ name: "broken" }] };
+    await assert.rejects(service.connectApiKey(input), { code: "connector_provider_failed" });
+    assert.equal((await service.status(input)).status, "disconnected");
+    assert.equal(requests.at(-1).init.method, "DELETE");
+    state.list = { tools };
+    await service.connectApiKey(input);
+    state.rpcError = true;
+    await assert.rejects(service.invoke({ ...input, operation: "tools.call", input: { name: "search_documents", arguments: {} } }), (error) => error.code === "connector_provider_failed" && !error.message.includes(state.token));
+    assert.equal(requests.at(-1).init.method, "DELETE");
+    state.rpcError = false;
+    state.call = { isError: true, content: [{ type: "text", text: "Query cannot be evaluated" }] };
+    state.cleanupStatus = 405;
+    assert.deepEqual(await service.invoke({ ...input, operation: "tools.call", input: { name: "search_documents", arguments: {} } }), state.call);
+    assert.equal((await service.status(input)).status, "connected");
+  });
+
+  test(`${spec.provider.name} cancels in-flight calls and closes the temporary session`, async (t) => {
+    const { service, state, requests } = await fixture(t, spec);
+    await service.connectApiKey(input);
+    const controller = new AbortController();
+    state.pause = true;
+    const started = new Promise((resolve) => { state.started = resolve; });
+    const result = service.invoke({ ...input, operation: "tools.call", input: { name: "search_documents", arguments: {} }, signal: controller.signal });
+    const rejected = assert.rejects(result, { code: "connector_cancelled" });
+    await started;
+    controller.abort();
+    await rejected;
+    assert.equal(requests.at(-1).init.method, "DELETE");
+    assert.equal((await service.status(input)).status, "connected");
+    const count = requests.length;
+    await assert.rejects(service.invoke({ ...input, operation: "tools.list", signal: controller.signal }), { code: "connector_cancelled" });
+    assert.equal(requests.length, count);
+  });
+}
+
+test("changing the n8n MCP destination requires verification and cannot reuse the old connection", async (t) => {
+  const { service, options, requests } = await fixture(t, cases[0]);
+  await service.connectApiKey(input);
+  const config = structuredClone(options.configuration);
+  config.integrations.assistant.settings.serverUrl = "https://other.example/mcp-server/http";
+  const changed = createConnectionService({ ...options, configuration: config });
+  const count = requests.length;
+  assert.equal((await changed.status(input)).status, "reconnect-required");
+  await assert.rejects(changed.invoke({ ...input, operation: "tools.list" }), { code: "connector_reconnect_required" });
+  assert.equal(requests.length, count);
+});
+
+// Controlled workflow tool names exercise transport and policy, not n8n's live catalogue.
+test("n8n returns workflow execution results only for the authorized workflow", async (t) => {
+  const { options, state, requests } = await fixture(t, cases[0]);
+  const service = createConnectionService({ ...options, authorize: async (owner, request) =>
+    request.operation !== "tools.call" || request.input.name === "fixture_run_workflow" && request.input.arguments.workflowId === "report-one" ? owner : null });
+  state.list = { tools: [{ name: "fixture_run_workflow", inputSchema: { type: "object" } }] };
+  state.call = { content: [{ type: "text", text: JSON.stringify({ workflowId: "report-one", executionId: "execution-one", status: "success", output: { report: "Ready" } }) }] };
+  await service.connectApiKey(input);
+  assert.deepEqual(await service.invoke({ ...input, operation: "tools.call", input: { name: "fixture_run_workflow", arguments: { workflowId: "report-one" } } }), state.call);
+  const count = requests.length;
+  await assert.rejects(service.invoke({ ...input, operation: "tools.call", input: { name: "fixture_run_workflow", arguments: { workflowId: "other-workflow" } } }), { code: "connector_access_denied" });
+  assert.equal(requests.length, count);
+});