@haikit/mcp 0.33.0 → 0.34.0

package/src/postgres.ts

@@ -0,0 +1,127 @@
+/**
+ * @haikit/mcp/postgres — each user's credentials in Postgres, shared by every
+ * server. As in @haikit/postgres, every method is one statement, and the
+ * driver is yours.
+ */
+
+import type { CredentialStore } from "./store.js";
+
+/**
+ * Anything that runs a parameterised statement and returns rows: a `pg.Pool`,
+ * a `pg.Client` and PGlite all fit as they are. The same shape as
+ * @haikit/postgres's and @haikit/auth/postgres's `Queryable`, so one pool
+ * serves all three.
+ */
+export interface Queryable {
+  query(text: string, params?: unknown[]): Promise<{ rows: any[] }>;
+}
+
+/**
+ * The schema, one statement per entry. `migrate()` runs these; export them to
+ * your own migration tool instead if you have one.
+ */
+export const schema: readonly string[] = [
+  `CREATE TABLE IF NOT EXISTS haikit_mcp_credentials (
+     user_id      text NOT NULL,
+     server       text NOT NULL,
+     value        text NOT NULL,
+     updated_at   timestamptz NOT NULL DEFAULT now(),
+     lease_holder text,
+     lease_until  timestamptz,
+     PRIMARY KEY (user_id, server)
+   )`,
+  `CREATE TABLE IF NOT EXISTS haikit_mcp_clients (
+     server text NOT NULL,
+     issuer text NOT NULL,
+     value  text NOT NULL,
+     PRIMARY KEY (server, issuer)
+   )`,
+  `CREATE TABLE IF NOT EXISTS haikit_mcp_flows (
+     state      text PRIMARY KEY,
+     value      text NOT NULL,
+     expires_at timestamptz NOT NULL
+   )`,
+];
+
+export async function migrate(db: Queryable): Promise<void> {
+  for (const statement of schema) await db.query(statement);
+}
+
+export function pgCredentialStore(db: Queryable): CredentialStore {
+  return {
+    async get(userId, server) {
+      const { rows } = await db.query(`SELECT value FROM haikit_mcp_credentials WHERE user_id = $1 AND server = $2`, [userId, server]);
+      return rows[0]?.value ?? null;
+    },
+    async put(userId, server, value, previous) {
+      // One statement each: the check of what the row holds and the write
+      // can't come apart, so two servers can't both win.
+      const { rows } =
+        previous === null
+          ? await db.query(
+              `INSERT INTO haikit_mcp_credentials (user_id, server, value) VALUES ($1, $2, $3)
+               ON CONFLICT (user_id, server) DO NOTHING
+               RETURNING 1 AS written`,
+              [userId, server, value],
+            )
+          : await db.query(
+              `UPDATE haikit_mcp_credentials SET value = $3, updated_at = now(), lease_holder = NULL, lease_until = NULL
+               WHERE user_id = $1 AND server = $2 AND value = $4
+               RETURNING 1 AS written`,
+              [userId, server, value, previous],
+            );
+      return rows.length === 1;
+    },
+    async delete(userId, server, previous) {
+      if (server === undefined) {
+        await db.query(`DELETE FROM haikit_mcp_credentials WHERE user_id = $1`, [userId]);
+      } else if (previous === undefined) {
+        await db.query(`DELETE FROM haikit_mcp_credentials WHERE user_id = $1 AND server = $2`, [userId, server]);
+      } else {
+        await db.query(`DELETE FROM haikit_mcp_credentials WHERE user_id = $1 AND server = $2 AND value = $3`, [userId, server, previous]);
+      }
+    },
+    async list(userId) {
+      const { rows } = await db.query(`SELECT server FROM haikit_mcp_credentials WHERE user_id = $1 ORDER BY server`, [userId]);
+      return rows.map((row) => row.server as string);
+    },
+    async lease(userId, server, previous, holder, ms) {
+      // by the database's clock, so servers whose clocks differ agree when it lapses
+      const { rows } = await db.query(
+        `UPDATE haikit_mcp_credentials SET lease_holder = $4, lease_until = now() + $5::float8 * interval '1 millisecond'
+         WHERE user_id = $1 AND server = $2 AND value = $3
+           AND (lease_until IS NULL OR lease_until <= now() OR lease_holder = $4)
+         RETURNING 1 AS leased`,
+        [userId, server, previous, holder, ms],
+      );
+      return rows.length === 1;
+    },
+    async getClient(server, issuer) {
+      const { rows } = await db.query(`SELECT value FROM haikit_mcp_clients WHERE server = $1 AND issuer = $2`, [server, issuer]);
+      return rows[0]?.value ?? null;
+    },
+    async putClient(server, issuer, value) {
+      await db.query(
+        `INSERT INTO haikit_mcp_clients (server, issuer, value) VALUES ($1, $2, $3)
+         ON CONFLICT (server, issuer) DO UPDATE SET value = EXCLUDED.value`,
+        [server, issuer, value],
+      );
+    },
+    async putFlow(state, value, expiresAt) {
+      // flows never taken go as new ones come, in the same statement
+      await db.query(
+        `WITH gone AS (DELETE FROM haikit_mcp_flows WHERE expires_at <= now())
+         INSERT INTO haikit_mcp_flows (state, value, expires_at) VALUES ($1, $2, to_timestamp($3::float8 / 1000))`,
+        [state, value, expiresAt],
+      );
+    },
+    async takeFlow(state) {
+      // taken once: a second take of the same state finds nothing
+      const { rows } = await db.query(
+        `DELETE FROM haikit_mcp_flows WHERE state = $1 RETURNING value, expires_at > now() AS live`,
+        [state],
+      );
+      return rows[0]?.live ? rows[0].value : null;
+    },
+  };
+}

package/src/routes.ts

@@ -0,0 +1,243 @@
+import { createHash } from "node:crypto";
+import type { IncomingMessage, ServerResponse } from "node:http";
+import type { McpAccount, McpConnected } from "./auth.js";
+import { takeFlow, type OAuthCore, type OAuthServer } from "./oauth.js";
+
+export interface RoutesContext {
+  core: OAuthCore;
+  basePath: string;
+  /** The user signed in, or null. */
+  requestUser(req: IncomingMessage): Promise<string | null>;
+  userOf(conversationId: string): Promise<string | null>;
+  onConnected: ((connected: McpConnected) => void | Promise<void>) | undefined;
+  /** The `oauth()` server of this name, if there is one. */
+  oauth(name: string): OAuthServer | undefined;
+  connections(userId: string): Promise<McpAccount[]>;
+  disconnect(userId: string, server?: string): Promise<void>;
+}
+
+/** Why the done page says the user isn't connected. */
+type Failure = "signed_out" | "access_denied" | "expired" | "refused" | "failed";
+
+/** The done page's one line, for a browser with no opener to tell. */
+const LINES: Record<Failure | "ok", string> = {
+  ok: "Connected. You can close this window.",
+  signed_out: "Not connected: sign in, then try again.",
+  access_denied: "Not connected: access wasn't allowed.",
+  expired: "Not connected: this link has expired. Try again.",
+  refused: "Not connected: you're signed in as someone else.",
+  failed: "Not connected: something went wrong. Try again.",
+};
+
+/** The done page's one script, which its CSP allows by hash: it tells the window that opened it, at this origin, and closes. */
+const SCRIPT =
+  'const m=document.getElementById("m");if(window.opener){window.opener.postMessage(JSON.parse(m.dataset.message),location.origin);window.close()}';
+const CSP = `default-src 'none'; script-src 'sha256-${createHash("sha256").update(SCRIPT).digest("base64")}'; frame-ancestors 'none'`;
+
+/** The longest `scope` a connect link may ask for. */
+const SCOPE_LENGTH = 1_000;
+/** RFC 6749's scope: tokens of printable ASCII but `"` and `\`, one space apart. */
+const SCOPE = /^[\x21\x23-\x5b\x5d-\x7e]+( [\x21\x23-\x5b\x5d-\x7e]+)*$/;
+/** The longest `conversation` a connect link may name. */
+const CONVERSATION_LENGTH = 512;
+
+const SIGNED_OUT = "sign in to continue";
+const CROSS_SITE = "this request came from another site";
+const NO_SERVER = "no server of that name connects with OAuth";
+
+type Headers = Record<string, string | string[] | undefined>;
+const first = (value: string | string[] | undefined) => (Array.isArray(value) ? value[0] : value);
+
+export function routes(ctx: RoutesContext): (req: IncomingMessage, res: ServerResponse) => Promise<boolean> {
+  const { core, basePath } = ctx;
+  const callbackPath = new URL(core.redirectUri).pathname;
+  // the redirect URI's origin is this site's, whatever Host a proxy passes on
+  const siteOrigin = new URL(core.redirectUri).origin;
+
+  /**
+   * Whether a request came from a page of this site, as @haikit/auth checks
+   * its sign-out: a browser always sends `Origin` on a POST from a page, and
+   * a page can't forge it, nor `Host`. A client that isn't a browser sends
+   * no `Origin`, and passes.
+   */
+  function fromThisSite(headers: Headers): boolean {
+    const origin = first(headers.origin);
+    if (origin === undefined) {
+      const site = first(headers["sec-fetch-site"]);
+      return site === undefined || site === "same-origin" || site === "none";
+    }
+    if (origin === siteOrigin) return true;
+    try {
+      return new URL(origin).host === first(headers.host);
+    } catch {
+      return false; // "null", from a sandboxed frame or a file
+    }
+  }
+
+  /** `GET {basePath}/connect/{server}`: off to the authorization server, with the flow kept meanwhile. */
+  async function connect(name: string, url: URL, req: IncomingMessage, res: ServerResponse) {
+    const oauth = ctx.oauth(name);
+    const user = await ctx.requestUser(req);
+    if (user === null) return done(res, oauth && name, "signed_out");
+    if (!oauth) return send(res, 404, { error: NO_SERVER });
+    let conversation = url.searchParams.get("conversation") || null;
+    if (conversation !== null) {
+      // kept only for its owner, so a connect wakes no one else's conversation
+      try {
+        if (conversation.length > CONVERSATION_LENGTH || (await ctx.userOf(conversation)) !== user) conversation = null;
+      } catch (err) {
+        console.error(`@haikit/mcp: ${name}: the owner of the conversation a connect link names couldn't be looked up, so it's dropped:`, err);
+        conversation = null;
+      }
+    }
+    const scope = url.searchParams.get("scope") || undefined;
+    if (scope !== undefined && (scope.length > SCOPE_LENGTH || !SCOPE.test(scope))) {
+      console.error(`@haikit/mcp: ${name}: a connect link asked for a scope that isn't an OAuth scope`);
+      return done(res, name, "failed");
+    }
+    let to: URL;
+    try {
+      to = await oauth.start(user, conversation, scope);
+    } catch (err) {
+      console.error(`@haikit/mcp: ${name}: connecting user ${user} couldn't start:`, err);
+      return done(res, name, "failed");
+    }
+    res.writeHead(303, { location: to.href, "cache-control": "no-store" }).end();
+  }
+
+  /** The redirect URI: the code exchanged for the user's tokens, and the done page. */
+  async function callback(url: URL, req: IncomingMessage, res: ServerResponse) {
+    const state = url.searchParams.get("state");
+    // used up whatever comes next, so a link sent to someone else connects no one
+    const flow = state ? await takeFlow(core, state) : null;
+    if (!flow) return done(res, undefined, "expired");
+    const name = flow.server;
+    const user = await ctx.requestUser(req);
+    if (user === null) return done(res, name, "signed_out");
+    if (user !== flow.user) return done(res, name, "refused");
+    const error = url.searchParams.get("error");
+    if (error === "access_denied") return done(res, name, "access_denied");
+    const code = url.searchParams.get("code");
+    const oauth = ctx.oauth(name);
+    if (error !== null || !code || !oauth) {
+      console.error(
+        `@haikit/mcp: ${name}: connecting user ${user} failed: ${
+          !oauth ? "the server is no longer configured" : error !== null ? `the authorization server answered ${JSON.stringify(error)}` : "the answer has no code"
+        }`,
+      );
+      return done(res, name, "failed");
+    }
+    try {
+      await oauth.finish(flow, code, url.searchParams.get("iss") ?? undefined);
+    } catch (err) {
+      console.error(`@haikit/mcp: ${name}: connecting user ${user} failed:`, err);
+      return done(res, name, "failed");
+    }
+    if (ctx.onConnected) {
+      try {
+        await ctx.onConnected({ userId: user, server: name, ...(flow.conversation === null ? {} : { conversationId: flow.conversation }) });
+      } catch (err) {
+        console.error(`@haikit/mcp: ${name}: onConnected threw, and user ${user} is connected all the same:`, err);
+      }
+    }
+    done(res, name, null);
+  }
+
+  return async function handle(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+    let url: URL;
+    try {
+      url = new URL(req.url ?? "/", "http://localhost");
+    } catch {
+      return false;
+    }
+    const { pathname } = url;
+    const method = req.method;
+    const page = async (answer: () => Promise<void>) => {
+      try {
+        await answer();
+      } catch (err) {
+        console.error("@haikit/mcp: a request failed:", err);
+        if (!res.headersSent) done(res, undefined, "failed");
+      }
+      return true;
+    };
+    const api = async (answer: () => Promise<void>) => {
+      try {
+        await answer();
+      } catch (err) {
+        // as nodeHandler does: answered and logged, never thrown on to the server
+        console.error("@haikit/mcp: a request failed:", err);
+        if (!res.headersSent) send(res, 500, { error: err instanceof Error ? err.message : String(err) });
+      }
+      return true;
+    };
+
+    if (pathname === callbackPath && method === "GET") return page(() => callback(url, req, res));
+    if (!pathname.startsWith(`${basePath}/`)) return false;
+    const rest = pathname.slice(basePath.length + 1);
+
+    if (rest === "connections" && method === "GET") {
+      return api(async () => {
+        const user = await ctx.requestUser(req);
+        if (user === null) return send(res, 401, { error: SIGNED_OUT });
+        send(res, 200, { servers: await ctx.connections(user) });
+      });
+    }
+    if (rest === "client.json" && method === "GET" && core.clientMetadataUrl !== undefined) {
+      res.writeHead(200, { "content-type": "application/json", "cache-control": "max-age=3600" });
+      res.end(JSON.stringify({ client_id: core.clientMetadataUrl, ...core.clientMetadata }));
+      return true;
+    }
+
+    const at = rest.indexOf("/");
+    const route = rest.slice(0, at);
+    const segment = rest.slice(at + 1);
+    if (at < 0 || segment === "" || segment.includes("/")) return false;
+    let name: string;
+    try {
+      name = decodeURIComponent(segment);
+    } catch {
+      return false;
+    }
+    if (route === "connect" && method === "GET") return page(() => connect(name, url, req, res));
+    if (route === "disconnect" && method === "POST") {
+      return api(async () => {
+        if (!fromThisSite(req.headers)) return send(res, 403, { error: CROSS_SITE });
+        const user = await ctx.requestUser(req);
+        if (user === null) return send(res, 401, { error: SIGNED_OUT });
+        if (!ctx.oauth(name)) return send(res, 404, { error: NO_SERVER });
+        await ctx.disconnect(user, name);
+        res.writeHead(204, { "cache-control": "no-store" }).end();
+      });
+    }
+    return false;
+  };
+}
+
+/**
+ * The done page: it posts `{ type: "haikit:mcp", server, ok, error? }` to
+ * the window that opened it, at its own origin, and closes. With no opener,
+ * such as a blocked popup, it shows one line and a link back to `/`.
+ */
+function done(res: ServerResponse, server: string | undefined, failure: Failure | null) {
+  const message = { type: "haikit:mcp", ...(server === undefined ? {} : { server }), ok: failure === null, ...(failure === null ? {} : { error: failure }) };
+  const line = LINES[failure ?? "ok"];
+  res.writeHead(200, {
+    "content-type": "text/html; charset=utf-8",
+    "content-security-policy": CSP,
+    "cache-control": "no-store",
+    "referrer-policy": "no-referrer",
+  });
+  res.end(
+    `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>${escape(line)}</title></head>` +
+      `<body><p id="m" data-message="${escape(JSON.stringify(message))}">${escape(line)}</p><p><a href="/">Back</a></p><script>${SCRIPT}</script></body></html>`,
+  );
+}
+
+const escape = (text: string) =>
+  text.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
+
+function send(res: ServerResponse, status: number, body: unknown) {
+  res.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+  res.end(JSON.stringify(body));
+}

package/src/seal.ts

@@ -0,0 +1,62 @@
+import { createCipheriv, createDecipheriv, hkdfSync, randomBytes } from "node:crypto";
+
+/** The shortest secret that seals, in bytes. */
+export const SECRET_BYTES = 32;
+const INFO = "haikit/mcp credentials";
+const IV_BYTES = 12;
+const TAG_BYTES = 16;
+/** Marks the format, so another can follow it. */
+const PREFIX = "v1.";
+
+/**
+ * What a sealed value is bound to: the row it's kept in. A value copied to
+ * another row doesn't open there, as another user's credential, another
+ * server's client, or another flow.
+ */
+export const binding = {
+  credential: (userId: string, server: string) => JSON.stringify(["credential", userId, server]),
+  client: (server: string, issuer: string) => JSON.stringify(["client", server, issuer]),
+  flow: (state: string) => JSON.stringify(["flow", state]),
+};
+
+/**
+ * AES-256-GCM, with a key from each secret by HKDF-SHA256. The first secret
+ * seals, and every one opens, so a secret can be rotated out: add the new one
+ * first, and drop the old once nothing sealed with it is kept.
+ */
+export class Sealer {
+  private readonly keys: Buffer[];
+
+  constructor(secrets: readonly string[]) {
+    this.keys = secrets.map((secret) => Buffer.from(hkdfSync("sha256", secret, new Uint8Array(0), INFO, 32)));
+  }
+
+  seal(value: unknown, bound: string): string {
+    const iv = randomBytes(IV_BYTES);
+    const cipher = createCipheriv("aes-256-gcm", this.keys[0], iv);
+    cipher.setAAD(Buffer.from(bound));
+    const sealed = Buffer.concat([cipher.update(JSON.stringify(value), "utf8"), cipher.final()]);
+    return PREFIX + Buffer.concat([iv, cipher.getAuthTag(), sealed]).toString("base64url");
+  }
+
+  /** What `seal` was given, if one of the secrets sealed it for `bound`; else null. */
+  open(sealed: string, bound: string): unknown {
+    if (typeof sealed !== "string" || !sealed.startsWith(PREFIX)) return null;
+    const bytes = Buffer.from(sealed.slice(PREFIX.length), "base64url");
+    if (bytes.length < IV_BYTES + TAG_BYTES) return null;
+    const iv = bytes.subarray(0, IV_BYTES);
+    const tag = bytes.subarray(IV_BYTES, IV_BYTES + TAG_BYTES);
+    const body = bytes.subarray(IV_BYTES + TAG_BYTES);
+    for (const key of this.keys) {
+      try {
+        const decipher = createDecipheriv("aes-256-gcm", key, iv);
+        decipher.setAAD(Buffer.from(bound));
+        decipher.setAuthTag(tag);
+        return JSON.parse(Buffer.concat([decipher.update(body), decipher.final()]).toString("utf8"));
+      } catch {
+        // sealed with another secret, or for another row: the next secret may open it
+      }
+    }
+    return null;
+  }
+}

package/src/store.ts

@@ -0,0 +1,118 @@
+/**
+ * Where each user's credentials are kept, with the OAuth clients registered
+ * for them and the connect flows on their way. `memoryCredentialStore` for
+ * one process; `pgCredentialStore` from `@haikit/mcp/postgres` for several.
+ *
+ * Every value is an opaque string, sealed before the store sees it: a leaked
+ * table or backup holds no usable token. Two sealings of the same thing never
+ * give the same string, so a value tells one write from another.
+ */
+export interface CredentialStore {
+  /** A user's sealed credential for a server, or null. */
+  get(userId: string, server: string): Promise<string | null>;
+  /**
+   * Writes a user's credential for a server if the row still holds
+   * `previous` (null: no row yet), and resolves true. False if another write
+   * came first: the check and the write must be one atomic step.
+   */
+  put(userId: string, server: string, value: string, previous: string | null): Promise<boolean>;
+  /**
+   * Deletes one server's credential, or with no `server`, all of the user's.
+   * With `previous`, only if the row still holds it.
+   */
+  delete(userId: string, server?: string, previous?: string): Promise<void>;
+  /** The servers a user has a credential for. */
+  list(userId: string): Promise<string[]>;
+  /**
+   * The refresh lease of a user's credential for a server, so one process at
+   * a time spends its refresh token. Taken for `ms`, by the store's clock, if
+   * the row still holds `previous` and no lease but `holder`'s is held: true.
+   * Else false, changing nothing. `ms` 0 gives `holder`'s back. A write or a
+   * delete of the row ends its lease; a lease is no write.
+   */
+  lease(userId: string, server: string, previous: string, holder: string, ms: number): Promise<boolean>;
+  /** A registered OAuth client, per server and authorization server, shared by every user. */
+  getClient(server: string, issuer: string): Promise<string | null>;
+  putClient(server: string, issuer: string, value: string): Promise<void>;
+  /** A connect flow on its way, kept until it's taken or `expiresAt` (epoch ms) passes. */
+  putFlow(state: string, value: string, expiresAt: number): Promise<void>;
+  /** Removes and returns a flow, once: null when there's none, or it has expired. */
+  takeFlow(state: string): Promise<string | null>;
+}
+
+/** The methods a `CredentialStore` has, to check one an app passes. */
+export const STORE_METHODS = ["get", "put", "delete", "list", "lease", "getClient", "putClient", "putFlow", "takeFlow"] as const;
+
+/** The most flows `memoryCredentialStore` keeps: past it, the oldest goes. */
+const MEMORY_FLOWS = 10_000;
+
+/**
+ * Credentials in this process's memory. Gone on a restart, and not shared:
+ * with several servers, use `pgCredentialStore`. Keeps the latest 10,000
+ * flows on their way.
+ */
+export function memoryCredentialStore(): CredentialStore {
+  const credentials = new Map<string, Map<string, string>>();
+  /** Each credential's refresh lease, by user and server. */
+  const leases = new Map<string, { holder: string; until: number }>();
+  const clients = new Map<string, string>();
+  const flows = new Map<string, { value: string; expiresAt: number }>();
+  const key = (a: string, b: string) => JSON.stringify([a, b]);
+  return {
+    async get(userId, server) {
+      return credentials.get(userId)?.get(server) ?? null;
+    },
+    async put(userId, server, value, previous) {
+      const servers = credentials.get(userId) ?? new Map<string, string>();
+      if ((servers.get(server) ?? null) !== previous) return false;
+      servers.set(server, value);
+      credentials.set(userId, servers);
+      leases.delete(key(userId, server));
+      return true;
+    },
+    async delete(userId, server, previous) {
+      const servers = credentials.get(userId);
+      if (!servers) return;
+      if (server === undefined) {
+        for (const name of servers.keys()) leases.delete(key(userId, name));
+        credentials.delete(userId);
+        return;
+      }
+      if (previous !== undefined && servers.get(server) !== previous) return;
+      servers.delete(server);
+      leases.delete(key(userId, server));
+      if (!servers.size) credentials.delete(userId);
+    },
+    async list(userId) {
+      return [...(credentials.get(userId)?.keys() ?? [])];
+    },
+    async lease(userId, server, previous, holder, ms) {
+      if (credentials.get(userId)?.get(server) !== previous) return false;
+      const now = Date.now();
+      const held = leases.get(key(userId, server));
+      if (held && held.until > now && held.holder !== holder) return false;
+      leases.set(key(userId, server), { holder, until: now + ms });
+      return true;
+    },
+    async getClient(server, issuer) {
+      return clients.get(key(server, issuer)) ?? null;
+    },
+    async putClient(server, issuer, value) {
+      clients.set(key(server, issuer), value);
+    },
+    async putFlow(state, value, expiresAt) {
+      const now = Date.now();
+      // the oldest first: past their time, or past the most kept
+      for (const [old, flow] of flows) {
+        if (flow.expiresAt > now && flows.size < MEMORY_FLOWS) break;
+        flows.delete(old);
+      }
+      flows.set(state, { value, expiresAt });
+    },
+    async takeFlow(state) {
+      const flow = flows.get(state);
+      flows.delete(state);
+      return flow && flow.expiresAt > Date.now() ? flow.value : null;
+    },
+  };
+}

package/src/transports.ts

@@ -1,6 +1,7 @@
 import {
   StreamableHTTPClientTransport,
   type AuthProvider,
+  type FetchLike,
   type StreamableHTTPClientTransportOptions,
   type Transport,
 } from "@modelcontextprotocol/client";
@@ -17,6 +18,10 @@ export interface HttpMade {
   authProvider: boolean;
   /** It sends an `Authorization` header of its own. */
   authorization: boolean;
+  /** The server's URL: the protected resource an `oauth()` server's tokens are for. */
+  url: URL;
+  /** Its `fetch`, which an `oauth()` server's requests to the authorization server go through too. */
+  fetch: FetchLike | undefined;
 }
 
 /** The factories `http()` made: only these can carry each user's credential. */
@@ -41,6 +46,8 @@ export function http(url: string | URL, options: HttpOptions = {}): (authProvide
   madeByHttp.set(make, {
     authProvider: rest.authProvider !== undefined,
     authorization: new Headers(rest.requestInit?.headers).has("authorization"),
+    url: target,
+    fetch: rest.fetch,
   });
   return make;
 }