Open-source AI coworkers that each get a computer of their own: a browser, files and tools, with every action decided before it happens and recorded after. Bring any AG-UI agent.
Send somebody back to Settings when the vendor cannot be reached at all (#345)
beardthelion412e7b770cb4
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex 7fd16d48..011f5652 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -8,6 +8,25 @@ Newest first. `Unreleased` is what is on `main` and not yet tagged.## Unreleased+### Connecting an account survives a vendor that is down++Finishing a connection used to end on a blank server error if the vendor could not be reached at the+moment you were sent back, whether that was a refused connection, a name that would not resolve, or+fifteen seconds of silence. It now ends where every other failed connect already ended: back on+Connected accounts with a note, and nothing stored. Pressing Connect for a vendor this deployment+has not introduced itself to yet behaves the same way, answering 502 rather than a server error, and+that message now covers a vendor that could not be reached as well as one that turned the+registration down.++A connection whose grant cannot be written to the vault ends the same way, rather than on the blank+error it used to give somebody who had just finished consenting.++Because the person is told the same thing whatever went wrong, the server log is now where the+difference lives. Three lines to look for: `oauth-token-endpoint-unreachable` and+`oauth-registration-endpoint-unreachable` name the vendor and the cause, and+`oauth-connection-not-recorded` says a consent completed and could not be kept. A fourth,+`oauth-token-endpoint-unusable`, means the fault is this deployment's catalogue rather than the+vendor.### A custom MCP server token is sent with the scheme it namesEvery token stored against a custom MCP server went out as `Bearer`, whatever the vendor asked for.diff --git a/server/src/plugins/oauth.ts b/server/src/plugins/oauth.tsindex 5d9c2b70..9ce11833 100644--- a/server/src/plugins/oauth.ts+++ b/server/src/plugins/oauth.ts@@ -323,20 +323,81 @@ export async function redeemAuthorizationCode(input: {// A public (DCR) client proves itself with PKCE, and some vendors refuse an unexpected empty field.if (input.clientSecret) params.set("client_secret", input.clientSecret);- const response = await fetch(input.tokenUrl, {- method: "POST",- headers: { "content-type": "application/x-www-form-urlencoded" },- body: params,+ /*+ * Our own catalogue, told apart from their outage before a request is attempted.+ *+ * `fetch` refuses a malformed URL by throwing the same kind of error a refused connection does,+ * so without this the two would reach the same catch and read as the same sentence. They are not+ * the same thing: one is a vendor having a bad day and the other is an endpoint in this+ * deployment's own catalogue that nobody can ever connect through. The person gets the ordinary+ * refusal either way, because there is nothing else to give them, and the log is where the+ * difference has to survive.+ *+ * Checking it here is also what leaves the catch below covering only the transport, rather than+ * quietly standing in for a mistake in a frozen literal.+ */+ if (!URL.canParse(input.tokenUrl)) {+ console.error(+ JSON.stringify({+ type: "oauth-token-endpoint-unusable",+ tokenUrl: input.tokenUrl,+ note: "This vendor's token endpoint is not a usable address, so nobody can connect it until the catalogue is fixed.",+ }),+ );+ return null;+ }++ /*+ * A vendor that could not be reached at all, which the refusal below cannot see.+ *+ * `!response.ok` needs a response, and there is none when the connection is refused, the name does+ * not resolve, TLS will not agree, or the timeout on this request fires. Unguarded, that rejection+ * escaped a function whose whole contract is to refuse quietly, and it escaped at the worst+ * available moment: the callback has no failure handler above it, so somebody who had just+ * consented at the vendor got a bare 500 with no Location instead of Settings telling them it did+ * not work. The same reasoning as the defensive read further down, one step earlier in the request.+ *+ * Nothing is read off the error. Which of those it was is a fact about the vendor's infrastructure+ * on a route that answers an unauthenticated caller, and the person is told the same sentence+ * either way.+ */+ let response: Response;+ try {+ response = await fetch(input.tokenUrl, {+ method: "POST",+ headers: { "content-type": "application/x-www-form-urlencoded" },+ body: params,+ /*+ * A redirect is a refusal, not a detour to be followed.+ *+ * `tokenUrl` is pinned in the catalogue because this request carries a client secret and an+ * authorization code, and following a 302 would hand both to whatever address the answer named.+ * Manual leaves the 3xx as the response, which is not `ok`, so it falls into the refusal below.+ */+ redirect: "manual",+ signal: AbortSignal.timeout(15_000),+ });+ } catch (error) {/*- * A redirect is a refusal, not a detour to be followed.+ * Logged, because refusing quietly to the person must not mean refusing quietly to the+ * deployment. Until this, an unreachable token endpoint reached Hono's default handler, which+ * prints the error before its 500; catching it without a line here would have bought the+ * redirect by making a vendor outage look exactly like nobody trying to connect.*- * `tokenUrl` is pinned in the catalogue because this request carries a client secret and an- * authorization code, and following a 302 would hand both to whatever address the answer named.- * Manual leaves the 3xx as the response, which is not `ok`, so it falls into the refusal below.+ * The status is what a person sees and this is what an operator sees, and only the second one+ * says which vendor and why. Neither the code nor the client secret is in a transport error:+ * they are in the request body, which never got sent.*/- redirect: "manual",- signal: AbortSignal.timeout(15_000),- });+ console.error(+ JSON.stringify({+ type: "oauth-token-endpoint-unreachable",+ tokenUrl: input.tokenUrl,+ note: "A person's consent could not be redeemed. They were sent back to Settings with a failure.",+ error: String(error),+ }),+ );+ return null;+ }if (!response.ok) return null;@@ -388,21 +449,55 @@ export async function registerDynamicClient(input: {registrationUrl: string;redirectUri: string;}): Promise<{ clientId: string; clientSecret: string } | null> {- const response = await fetch(input.registrationUrl, {- method: "POST",- headers: { "content-type": "application/json" },- body: JSON.stringify({- redirect_uris: [input.redirectUri],- grant_types: ["authorization_code", "refresh_token"],- response_types: ["code"],- token_endpoint_auth_method: "none",- client_name: "OpenBot",- }),- // The registration endpoint is pinned in the catalogue, so a redirect is somebody else deciding- // where this deployment introduces itself. Left as the response, which is not `ok`.- redirect: "manual",- signal: AbortSignal.timeout(15_000),- });+ // The same catalogue check the redemption makes, and for the same reason: a registration endpoint+ // that is not an address is this deployment's mistake, not the vendor's outage, and only the log+ // can tell them apart.+ if (!URL.canParse(input.registrationUrl)) {+ console.error(+ JSON.stringify({+ type: "oauth-registration-endpoint-unusable",+ registrationUrl: input.registrationUrl,+ note: "This vendor's registration endpoint is not a usable address, so this deployment can never introduce itself.",+ }),+ );+ return null;+ }++ // A vendor that could not be reached at all — see `redeemAuthorizationCode`, which states the same+ // gap in full. This one lands on an administrator pressing Connect rather than on somebody+ // mid-consent, and null is what turns it into the 502 that route already writes for a vendor that+ // would not register us.+ let response: Response;+ try {+ response = await fetch(input.registrationUrl, {+ method: "POST",+ headers: { "content-type": "application/json" },+ body: JSON.stringify({+ redirect_uris: [input.redirectUri],+ grant_types: ["authorization_code", "refresh_token"],+ response_types: ["code"],+ token_endpoint_auth_method: "none",+ client_name: "OpenBot",+ }),+ // The registration endpoint is pinned in the catalogue, so a redirect is somebody else deciding+ // where this deployment introduces itself. Left as the response, which is not `ok`.+ redirect: "manual",+ signal: AbortSignal.timeout(15_000),+ });+ } catch (error) {+ // Logged for the same reason the redemption above is: the caller's 502 tells an administrator+ // to check the vendor's status, and this is the line that says the vendor could not be reached+ // at all rather than that it turned us down.+ console.error(+ JSON.stringify({+ type: "oauth-registration-endpoint-unreachable",+ registrationUrl: input.registrationUrl,+ note: "This deployment could not introduce itself to the vendor. Connect answered 502.",+ error: String(error),+ }),+ );+ return null;+ }if (!response.ok) return null;// A 200 is not a promise of JSON — see `redeemAuthorizationCode`. A body that will not parse is// the vendor answering with something other than a client, which is this function's null.diff --git a/server/src/plugins/routes.ts b/server/src/plugins/routes.tsindex d03ac556..8e9e22c8 100644--- a/server/src/plugins/routes.ts+++ b/server/src/plugins/routes.ts@@ -415,7 +415,7 @@ export function createPluginRoutes(if (entry.auth.clientRegistration === "dynamic") {return context.json({- error: `${entry.title} refused this deployment's registration. Try again, and check the vendor's status if it persists.`,+ error: `${entry.title} would not register this deployment, or could not be reached. Try again, and check the vendor's status if it persists.`,},502,);@@ -514,12 +514,36 @@ export function createPluginRoutes(});if (!grant) return context.redirect(failed);- await store.recordConnection({- serverId: state.serverId,- userId: state.userId,- refreshToken: grant.refreshToken,- scope: grant.scope,- });+ /*+ * The last thing that can fail, answered the same way as everything before it.+ *+ * A vault that will not take the grant is this deployment's problem, not the person's, and they+ * have already done their part at the vendor. Unhandled, this threw past the handler and gave+ * them the bare 500 that every other failure on this route was written to avoid, on the one+ * path where they had most reason to think it had worked.+ *+ * Told, because unlike the refusals above this one is nobody's fault but ours, and the person's+ * sentence deliberately says nothing about which failure it was. The refresh token is not+ * logged: it is the one thing here worth stealing, and the row it belonged to was never written.+ */+ try {+ await store.recordConnection({+ serverId: state.serverId,+ userId: state.userId,+ refreshToken: grant.refreshToken,+ scope: grant.scope,+ });+ } catch (error) {+ console.error(+ JSON.stringify({+ type: "oauth-connection-not-recorded",+ serverId: state.serverId,+ note: "A person consented and the grant could not be stored. They were sent back to Settings with a failure and will have to connect again.",+ error: String(error),+ }),+ );+ return context.redirect(failed);+ }return context.redirect(connectedAccountsUrlFor(diff --git a/server/tests/plugin-connect-route.test.ts b/server/tests/plugin-connect-route.test.tsindex ccdcf46b..3aa9617f 100644--- a/server/tests/plugin-connect-route.test.ts+++ b/server/tests/plugin-connect-route.test.ts@@ -82,7 +82,15 @@ describe("connecting a dynamically registered vendor", () => {expect(url.searchParams.get("client_id")).toBe("dyn-1");});- test("a refused registration answers 502, naming the vendor", async () => {+ /**+ * One answer for two states, because there is one thing to do about either.+ *+ * A vendor that turned this deployment down and a vendor that could not be reached both leave+ * `ensureOAuthClient` with no client, and the person pressing Connect has the same next step+ * whichever it was. The sentence says both rather than naming the wrong one confidently; which it+ * actually was is in the log, where it is of use to somebody who can act on it.+ */+ test("a registration that produced no client answers 502, naming the vendor", async () => {const ensureCalls: { serverId: string; by: string }[] = [];const hono = app({oauthClientFor: async () => null,@@ -101,7 +109,7 @@ describe("connecting a dynamically registered vendor", () => {expect(ensureCalls.length).toBe(1);const body = (await response.json()) as { error: string };expect(body.error).toBe(- "Notion refused this deployment's registration. Try again, and check the vendor's status if it persists.",+ "Notion would not register this deployment, or could not be reached. Try again, and check the vendor's status if it persists.",);});});diff --git a/server/tests/plugin-oauth-callback.test.ts b/server/tests/plugin-oauth-callback.test.tsindex 757d84a7..a3d3f5c8 100644--- a/server/tests/plugin-oauth-callback.test.ts+++ b/server/tests/plugin-oauth-callback.test.ts@@ -2,7 +2,11 @@ import { describe, expect, test } from "bun:test";import type { MiddlewareHandler } from "hono";import { Hono } from "hono";import type { AppVariables } from "../src/auth/guards";-import { challengeFor, sealConnectState } from "../src/plugins/oauth";+import {+ challengeFor,+ redeemAuthorizationCode,+ sealConnectState,+} from "../src/plugins/oauth";import { createPluginRoutes } from "../src/plugins/routes";/**@@ -48,13 +52,17 @@ function app(input: {recorded: Recorded[];/** Whether the person named by the state still has access. Present by default. */personHasAccess?: (userId: string) => Promise<boolean>;+ /** What the vault does with the grant. Records it by default; a test may refuse instead. */+ recordConnection?: (connection: Recorded) => Promise<void>;}) {const store = {oauthClientFor: async () => ({ clientId: "dyn-1", clientSecret: "" }),ensureOAuthClient: async () => ({ clientId: "dyn-1", clientSecret: "" }),- recordConnection: async (connection: Recorded) => {- input.recorded.push(connection);- },+ recordConnection:+ input.recordConnection ??+ (async (connection: Recorded) => {+ input.recorded.push(connection);+ }),};const routes = createPluginRoutes(store as never,@@ -229,3 +237,225 @@ describe("a consent this deployment did not start", () => {expect(recorded).toEqual([]);});});++/**+ * The vendor answered the consent screen and then could not be reached for the redemption.+ *+ * Every other refusal here is one of our own checks saying no before the network is touched, which+ * is why nothing caught this: the vendor in these tests is either willing or never asked. A vendor+ * that is reachable enough to send somebody back and unreachable a moment later is the ordinary+ * shape of an outage, and it lands on somebody who has just consented.+ */+describe("a vendor that could not be reached for the redemption", () => {+ async function sealed(): Promise<string> {+ return await sealConnectState(+ { userId: "user-1", serverId: "notion", verifier: "v-1" },+ KEY,+ );+ }++ /**+ * The signal is inspected rather than ignored, which is the difference between proving the catch+ * runs and proving it runs on the failure it was written for. A real timeout rejects because the+ * request was already on the wire when `AbortSignal.timeout` fired, so a stub that never looked at+ * `init.signal` would pass just as happily against code that had forgotten to pass one.+ *+ * What is still not exercised is the fifteen seconds themselves: the deadline is a literal in the+ * source, and waiting it out is not a test anybody would run. The signal being present and unfired+ * at the moment of the call is the part that can be checked here.+ */+ async function withUnreachableVendor(+ reject: () => never,+ run: () => Promise<void>,+ seen?: { signals: (AbortSignal | undefined)[] },+ ): Promise<void> {+ const realFetch = globalThis.fetch;+ globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {+ seen?.signals.push(init?.signal ?? undefined);+ return reject();+ }) as unknown as typeof fetch;+ try {+ await run();+ } finally {+ globalThis.fetch = realFetch;+ }+ }++ test("a connection failure ends at Settings, not on a 500", async () => {+ const recorded: Recorded[] = [];+ const hono = app({ recorded });+ const state = await sealed();++ await withUnreachableVendor(+ () => {+ throw new TypeError(+ "Unable to connect. Is the computer able to access the url?",+ );+ },+ async () => {+ const response = await hono.request(callbackUrl(state));+ // Both halves of the promise the handler makes, and the status is the half that was broken:+ // a throw out of the redemption left Hono answering 500 with no Location at all.+ expect(response.status).toBe(302);+ expect(response.headers.get("location")).toBe(FAILED);+ },+ );+ expect(recorded).toEqual([]);+ });++ test("a token endpoint that never answers ends the same way", async () => {+ const recorded: Recorded[] = [];+ const hono = app({ recorded });+ const state = await sealed();+ const seen = { signals: [] as (AbortSignal | undefined)[] };++ await withUnreachableVendor(+ () => {+ throw new DOMException("The operation timed out.", "TimeoutError");+ },+ async () => {+ const response = await hono.request(callbackUrl(state));+ expect(response.status).toBe(302);+ expect(response.headers.get("location")).toBe(FAILED);+ },+ seen,+ );++ // The deadline was armed and had not fired when the request went out, which is what makes this+ // a timeout rather than a rejection that happened to arrive first.+ expect(seen.signals[0]).toBeInstanceOf(AbortSignal);+ expect(seen.signals[0]?.aborted).toBe(false);+ expect(recorded).toEqual([]);+ });++ /**+ * Quiet to the person, not quiet to the deployment.+ *+ * The redirect above is deliberately the same one every other refusal produces, which is what+ * makes this test necessary: from the outside a vendor that is down and a vendor that said no are+ * now indistinguishable, so the only place the difference survives is the log. Before the refusal+ * was caught at all, the framework's own handler printed it on the way to a 500; catching it+ * without putting a line back would have paid for the redirect with the outage nobody can see.+ */+ test("the deployment is told, even though the person is only sent back", async () => {+ const recorded: Recorded[] = [];+ const hono = app({ recorded });+ const state = await sealed();+ const said: string[] = [];+ const realError = console.error;+ console.error = (...args: unknown[]) => {+ said.push(args.map(String).join(" "));+ };++ try {+ await withUnreachableVendor(+ () => {+ throw new TypeError("Unable to connect.");+ },+ async () => {+ const response = await hono.request(callbackUrl(state));+ expect(response.status).toBe(302);+ expect(response.headers.get("location")).toBe(FAILED);+ },+ );+ } finally {+ console.error = realError;+ }++ const line = said.find((said) =>+ said.includes("oauth-token-endpoint-unreachable"),+ );+ expect(line).toBeDefined();+ // Which vendor, so an operator reading this knows where to look, and the cause.+ expect(line).toContain("mcp.notion.com");+ expect(line).toContain("Unable to connect.");+ expect(recorded).toEqual([]);+ });+});++/**+ * The last thing that can fail, and the one the redemption fix did not reach.+ *+ * Everything before this point answers a failure with the same redirect. Writing the grant did not:+ * a vault that will not take it threw past the handler, and the person who had just consented got+ * the same bare 500 that an unreachable vendor used to give them. It is the identical shape one step+ * later, so it gets the identical answer.+ */+describe("a grant the vault would not take", () => {+ test("a refused write ends at Settings, and no half-connection is claimed", async () => {+ const recorded: Recorded[] = [];+ const hono = app({+ recorded,+ recordConnection: async () => {+ throw new Error("could not reach the database");+ },+ });+ const state = await sealConnectState(+ { userId: "user-1", serverId: "notion", verifier: "v-1" },+ KEY,+ );+ const said: string[] = [];+ const realError = console.error;+ console.error = (...args: unknown[]) => {+ said.push(args.map(String).join(" "));+ };++ try {+ await withWillingVendor(async () => {+ const response = await hono.request(callbackUrl(state));+ expect(response.status).toBe(302);+ expect(response.headers.get("location")).toBe(FAILED);+ });+ } finally {+ console.error = realError;+ }++ expect(recorded).toEqual([]);+ // Told, for the same reason the unreachable vendor is: this one is the deployment's own fault,+ // and the person is being handed the sentence that says nothing about which.+ expect(+ said.find((line) => line.includes("oauth-connection-not-recorded")),+ ).toBeDefined();+ });+});++/**+ * A pinned endpoint that is not an address.+ *+ * `fetch` refuses a malformed URL by throwing the same kind of error a refused connection does, so+ * the catch that made the vendor's outage quiet would make this quiet in exactly the same words.+ * The person still gets the ordinary refusal, because there is nothing else to give them, but the+ * log has to say which of the two it was: one is somebody else's outage and the other is this+ * deployment's own catalogue, and only one of them is worth waking up for.+ */+describe("a token endpoint that is not a usable address", () => {+ test("is refused like any other, and named as ours in the log", async () => {+ const said: string[] = [];+ const realError = console.error;+ console.error = (...args: unknown[]) => {+ said.push(args.map(String).join(" "));+ };++ try {+ expect(+ await redeemAuthorizationCode({+ tokenUrl: "not a url",+ clientId: "dyn-1",+ clientSecret: "",+ code: "code-1",+ redirectUri: "https://openbot.example/api/plugins/oauth/callback",+ verifier: "v-1",+ }),+ ).toBeNull();+ } finally {+ console.error = realError;+ }++ expect(+ said.find((line) => line.includes("oauth-token-endpoint-unusable")),+ ).toBeDefined();+ expect(+ said.find((line) => line.includes("oauth-token-endpoint-unreachable")),+ ).toBeUndefined();+ });+});diff --git a/server/tests/plugin-oauth.test.ts b/server/tests/plugin-oauth.test.tsindex b8487c9d..ba13c4a0 100644--- a/server/tests/plugin-oauth.test.ts+++ b/server/tests/plugin-oauth.test.ts@@ -558,6 +558,60 @@ describe("registering this deployment as an OAuth client", () => {globalThis.fetch = realFetch;}});++ /**+ * A vendor that cannot be reached at all, which is not the same as one that refused.+ *+ * `!response.ok` needs a response, and there is none when the connection is refused, the name does+ * not resolve, TLS will not agree or the fifteen-second timeout fires first. Unguarded, the fetch+ * rejects straight through a function whose documented answer to a vendor that will not register+ * us is null, and the caller that reads null to mean "try again later" never runs.+ */+ test("a vendor that cannot be reached is a refusal, not a thrown transport error", async () => {+ const realFetch = globalThis.fetch;+ globalThis.fetch = (async () => {+ throw new TypeError(+ "Unable to connect. Is the computer able to access the url?",+ );+ }) as unknown as typeof fetch;+ try {+ expect(+ await registerDynamicClient({+ registrationUrl: "https://vendor.example/register",+ redirectUri: "https://openbot.example/cb",+ }),+ ).toBeNull();+ } finally {+ globalThis.fetch = realFetch;+ }+ });++ /**+ * The signal is checked, not just the catch. A stub that ignores `init.signal` would pass against+ * code that had dropped the deadline entirely, which is the one thing a timeout test exists to+ * notice. The fifteen seconds themselves stay unexercised; the literal is in the source and+ * waiting it out is not a test.+ */+ test("a registration endpoint that never answers is the same refusal", async () => {+ const seen: (AbortSignal | undefined)[] = [];+ const realFetch = globalThis.fetch;+ globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {+ seen.push(init?.signal ?? undefined);+ throw new DOMException("The operation timed out.", "TimeoutError");+ }) as unknown as typeof fetch;+ try {+ expect(+ await registerDynamicClient({+ registrationUrl: "https://vendor.example/register",+ redirectUri: "https://openbot.example/cb",+ }),+ ).toBeNull();+ } finally {+ globalThis.fetch = realFetch;+ }+ expect(seen[0]).toBeInstanceOf(AbortSignal);+ expect(seen[0]?.aborted).toBe(false);+ });});describe("redeeming an authorization code", () => {@@ -699,4 +753,62 @@ describe("redeeming an authorization code", () => {globalThis.fetch = realFetch;}});++ /**+ * A token endpoint that cannot be reached at all.+ *+ * The one failure with no response to inspect, so `!response.ok` never sees it: a refused+ * connection, a name that does not resolve, TLS that will not agree, or the fifteen-second timeout+ * firing. It is also the failure that lands at the worst moment, on somebody who has just consented+ * at the vendor and is being sent back here. Unguarded it escapes the callback as a bare 500 with+ * no Location, so instead of Settings saying it did not work, they get an error page.+ */+ test("a token endpoint that cannot be reached is a refusal, not a thrown transport error", async () => {+ const realFetch = globalThis.fetch;+ globalThis.fetch = (async () => {+ throw new TypeError(+ "Unable to connect. Is the computer able to access the url?",+ );+ }) as unknown as typeof fetch;+ try {+ expect(+ await redeemAuthorizationCode({+ tokenUrl: "https://vendor.example/token",+ clientId: "client-id",+ clientSecret: "",+ code: "code-1",+ redirectUri: "https://openbot.example/api/plugins/oauth/callback",+ verifier: "verifier-1",+ }),+ ).toBeNull();+ } finally {+ globalThis.fetch = realFetch;+ }+ });++ /** Same reasoning as the registration side: the deadline is what is being tested, so it is read. */+ test("a token endpoint that never answers is the same refusal", async () => {+ const seen: (AbortSignal | undefined)[] = [];+ const realFetch = globalThis.fetch;+ globalThis.fetch = (async (_url: unknown, init?: RequestInit) => {+ seen.push(init?.signal ?? undefined);+ throw new DOMException("The operation timed out.", "TimeoutError");+ }) as unknown as typeof fetch;+ try {+ expect(+ await redeemAuthorizationCode({+ tokenUrl: "https://vendor.example/token",+ clientId: "client-id",+ clientSecret: "",+ code: "code-1",+ redirectUri: "https://openbot.example/api/plugins/oauth/callback",+ verifier: "verifier-1",+ }),+ ).toBeNull();+ } finally {+ globalThis.fetch = realFetch;+ }+ expect(seen[0]).toBeInstanceOf(AbortSignal);+ expect(seen[0]?.aborted).toBe(false);+ });});diff --git a/server/tests/plugin-store.integration.test.ts b/server/tests/plugin-store.integration.test.tsindex f05914ff..89e2ef83 100644--- a/server/tests/plugin-store.integration.test.ts+++ b/server/tests/plugin-store.integration.test.ts@@ -2018,6 +2018,67 @@ describe("a dynamic client the vendor has evicted", () => {);});+ /**+ * The registration nothing stands in for.+ *+ * Every other test here injects `registerClient`, which is right for asserting what the store does+ * with an answer but means the real function is never the one answering. What it returns when the+ * vendor cannot be reached at all is exactly what the store's `null` branches were written for, so+ * once that path exists it is worth one test that lets the real code produce the value rather than+ * a stub asserting the value the real code is assumed to produce.+ */+ const storeWithRealRegistration = createPluginStore({+ database,+ auditStore: createAuditStore(database),+ credentials: vault,+ encryptionKey: DYNAMIC_KEY,+ policy: () => policy,+ callVendor: async () => ({+ text: "[vendor not reached in tests]",+ isError: false,+ }),+ exchangeRefreshToken: seams.exchangeRefreshToken,+ redirectUri: REDIRECT_URI,+ });++ test("an unreachable registration endpoint leaves no client and no trail", async () => {+ await clearClient();+ const registeredBefore = await registeredRows();+ const said: string[] = [];+ const realError = console.error;+ const realFetch = globalThis.fetch;+ console.error = (...args: unknown[]) => {+ said.push(args.map(String).join(" "));+ };+ globalThis.fetch = (async () => {+ throw new TypeError("Unable to connect.");+ }) as unknown as typeof fetch;++ try {+ expect(+ await storeWithRealRegistration.ensureOAuthClient(+ dynamicServerId,+ "[email protected]",+ ),+ ).toBeNull();+ } finally {+ globalThis.fetch = realFetch;+ console.error = realError;+ }++ // Nothing kept, and nothing claimed. A trail row here would say this deployment registered+ // itself with a vendor that never answered.+ expect(+ await storeWithRealRegistration.oauthClientFor(dynamicServerId),+ ).toBe(null);+ expect((await registeredRows()).length).toBe(registeredBefore.length);+ expect(+ said.find((line) =>+ line.includes("oauth-registration-endpoint-unreachable"),+ ),+ ).toBeDefined();+ });+test("an entry an administrator registers by hand is left alone", async () => {/** Drive, whose client is pasted in from Google's console. Registering one for it would be