@cursor/bdk 0.2.2 → 0.2.4

package/src/internal/mcp-oauth.ts

@@ -1,549 +0,0 @@
-/**
- * Host-side MCP OAuth for `defineConnection({ url, oauth: true })`.
- * Local: mcp-auth.json. Prod secrets: `mcp oauth <name> --store`.
- */
-
-import { execFile } from "node:child_process";
-import { randomUUID } from "node:crypto";
-import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
-import { createServer, type Server } from "node:http";
-import { dirname, join } from "node:path";
-import type { OAuthClientProvider } from "@modelcontextprotocol/sdk/client/auth.js";
-import type {
-  OAuthClientInformationFull,
-  OAuthClientMetadata,
-  OAuthTokens,
-} from "@modelcontextprotocol/sdk/shared/auth.js";
-import { configDirPath } from "./cursor/credentials.js";
-
-export const MCP_OAUTH_CALLBACK_PORT = 8787;
-export const MCP_OAUTH_CALLBACK_PATH = "/callback";
-export const MCP_OAUTH_CALLBACK_URL: string = `http://localhost:${MCP_OAUTH_CALLBACK_PORT}${MCP_OAUTH_CALLBACK_PATH}`;
-
-/** `anytool` → `MCP_OAUTH_ANYTOOL`. */
-export function mcpOauthEnvPrefix(connection: string): string {
-  const key = connection
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z0-9]+/g, "_")
-    .replace(/^_+|_+$/g, "");
-  return `MCP_OAUTH_${key.length > 0 ? key : "CONNECTION"}`;
-}
-
-export type McpOauthSecretNames = {
-  accessToken: string;
-  refreshToken: string;
-  clientId: string;
-};
-
-export function mcpOauthSecretNames(connection: string): McpOauthSecretNames {
-  const prefix = mcpOauthEnvPrefix(connection);
-  return {
-    accessToken: `${prefix}_ACCESS_TOKEN`,
-    refreshToken: `${prefix}_REFRESH_TOKEN`,
-    clientId: `${prefix}_CLIENT_ID`,
-  };
-}
-
-export function tokensFromEnv(
-  connection: string,
-  env: NodeJS.ProcessEnv = process.env,
-): OAuthTokens | undefined {
-  const names = mcpOauthSecretNames(connection);
-  const access = env[names.accessToken]?.trim();
-  if (access === undefined || access === "") {
-    return undefined;
-  }
-  const refresh = env[names.refreshToken]?.trim();
-  return {
-    access_token: access,
-    refresh_token: refresh === undefined || refresh === "" ? undefined : refresh,
-    token_type: "Bearer",
-  };
-}
-
-export function clientIdFromEnv(
-  connection: string,
-  env: NodeJS.ProcessEnv = process.env,
-): OAuthClientInformationFull | undefined {
-  const clientId = env[mcpOauthSecretNames(connection).clientId]?.trim();
-  if (clientId === undefined || clientId === "") {
-    return undefined;
-  }
-  return {
-    client_id: clientId,
-    redirect_uris: [MCP_OAUTH_CALLBACK_URL],
-  };
-}
-
-interface AuthEntry {
-  /** MCP resource URL this entry was issued for (origin + path, no query). */
-  resourceUrl?: string;
-  tokens?: OAuthTokens;
-  clientInfo?: OAuthClientInformationFull;
-}
-
-type AuthFile = Record<string, AuthEntry>;
-
-const locks = new Map<string, Promise<void>>();
-
-/** Sibling of `credentials.json` under `~/.config/agent-serve/`. */
-export function defaultMcpAuthPath(): string {
-  return join(configDirPath(), "mcp-auth.json");
-}
-
-/** Canonical MCP resource key for binding stored tokens to a server URL. */
-export function normalizeMcpResourceUrl(url: string): string {
-  const parsed = new URL(url);
-  parsed.hash = "";
-  parsed.search = "";
-  // Drop default ports so http://h:80 and http://h match.
-  if (
-    (parsed.protocol === "https:" && parsed.port === "443") ||
-    (parsed.protocol === "http:" && parsed.port === "80")
-  ) {
-    parsed.port = "";
-  }
-  let path = parsed.pathname;
-  if (path.length > 1 && path.endsWith("/")) {
-    path = path.slice(0, -1);
-  }
-  return `${parsed.origin}${path === "/" ? "" : path}`;
-}
-
-export class FileMcpOAuthStore {
-  private cache: AuthFile | undefined;
-  private loading: Promise<AuthFile> | undefined;
-
-  constructor(readonly path: string = defaultMcpAuthPath()) {}
-
-  async loadTokens(id: string, resourceUrl: string): Promise<OAuthTokens | undefined> {
-    return (await this.entryFor(id, resourceUrl))?.tokens;
-  }
-
-  async loadClientInformation(
-    id: string,
-    resourceUrl: string,
-  ): Promise<OAuthClientInformationFull | undefined> {
-    return (await this.entryFor(id, resourceUrl))?.clientInfo;
-  }
-
-  async saveTokens(id: string, resourceUrl: string, tokens: OAuthTokens): Promise<void> {
-    await this.update(id, resourceUrl, entry => {
-      entry.tokens = tokens;
-    });
-  }
-
-  async saveClientInformation(
-    id: string,
-    resourceUrl: string,
-    clientInfo: OAuthClientInformationFull,
-  ): Promise<void> {
-    await this.update(id, resourceUrl, entry => {
-      entry.clientInfo = clientInfo;
-    });
-  }
-
-  async deleteCredentials(id: string): Promise<void> {
-    await this.withLock(async () => {
-      const data = await this.read();
-      delete data[id];
-      await this.write(data);
-    });
-  }
-
-  private async entryFor(id: string, resourceUrl: string): Promise<AuthEntry | undefined> {
-    const entry = (await this.read())[id];
-    if (entry === undefined) {
-      return undefined;
-    }
-    const bound = entry.resourceUrl;
-    if (bound === undefined || bound !== normalizeMcpResourceUrl(resourceUrl)) {
-      return undefined;
-    }
-    return entry;
-  }
-
-  private async update(
-    id: string,
-    resourceUrl: string,
-    mutate: (entry: AuthEntry) => void,
-  ): Promise<void> {
-    const normalized = normalizeMcpResourceUrl(resourceUrl);
-    await this.withLock(async () => {
-      const data = await this.read();
-      const existing = data[id];
-      const entry: AuthEntry = existing?.resourceUrl === normalized ? { ...existing } : {};
-      entry.resourceUrl = normalized;
-      mutate(entry);
-      data[id] = entry;
-      await this.write(data);
-    });
-  }
-
-  private async read(): Promise<AuthFile> {
-    if (this.cache !== undefined) {
-      return this.cache;
-    }
-    this.loading ??= this.readDisk().then(data => {
-      this.cache = data;
-      return data;
-    });
-    return this.loading;
-  }
-
-  private async readDisk(): Promise<AuthFile> {
-    try {
-      const parsed: unknown = JSON.parse(await readFile(this.path, "utf8"));
-      if (typeof parsed !== "object" || parsed === null) {
-        return {};
-      }
-      return parsed as AuthFile;
-    } catch (error: unknown) {
-      if (
-        typeof error === "object" &&
-        error !== null &&
-        "code" in error &&
-        (error as { code: unknown }).code === "ENOENT"
-      ) {
-        return {};
-      }
-      throw error;
-    }
-  }
-
-  private async write(data: AuthFile): Promise<void> {
-    this.cache = data;
-    await mkdir(dirname(this.path), { recursive: true, mode: 0o700 });
-    await writeFile(this.path, `${JSON.stringify(data, null, 2)}\n`, {
-      mode: 0o600,
-    });
-    await chmod(this.path, 0o600);
-  }
-
-  private async withLock<T>(fn: () => Promise<T>): Promise<T> {
-    const prev = locks.get(this.path) ?? Promise.resolve();
-    let release!: () => void;
-    locks.set(
-      this.path,
-      new Promise<void>(resolve => {
-        release = resolve;
-      }),
-    );
-    try {
-      await prev;
-      return await fn();
-    } finally {
-      release();
-    }
-  }
-}
-
-type ProviderArgs = {
-  identifier: string;
-  resourceUrl: string;
-  store: FileMcpOAuthStore;
-  redirectUrl?: string;
-  onRedirect?: (url: URL) => void;
-  tokens?: OAuthTokens;
-  clientInformation?: OAuthClientInformationFull;
-  /**
-   * True when authorize/token requests must NOT carry the RFC 8707
-   * `resource` indicator, read off the server's protected-resource
-   * metadata (`cursor_omit_resource_indicator`). Entra rejects the
-   * indicator with AADSTS9010010, so Microsoft 365 flows through Cursor's
-   * REST-as-MCP translator fail pre-auth without this.
-   */
-  omitResourceIndicator?: boolean;
-};
-
-/**
- * Reads the Cursor REST-as-MCP translator's OAuth quirk off the resource's
- * RFC 9728 protected-resource metadata. Deliberately self-contained
- * (`@cursor/bdk` publishes to public npm with no private workspace
- * dependencies — see `waitForMcpOAuthCallback`): matches the translator
- * path shape on any origin so local translators work, and fails to the
- * default behavior (indicator kept) when the PRM is unreachable.
- */
-export async function fetchOmitResourceIndicatorFromPrm(
-  resourceUrl: string,
-  fetchImpl: typeof fetch = fetch,
-): Promise<boolean> {
-  let url: URL;
-  try {
-    url = new URL(resourceUrl);
-  } catch {
-    return false;
-  }
-  if (!/^\/rest-mcp\/[^/]+\/mcp\/?$/.test(url.pathname)) {
-    return false;
-  }
-  const prmUrl = `${url.origin}/.well-known/oauth-protected-resource${url.pathname.replace(/\/+$/, "")}`;
-  try {
-    const response = await fetchImpl(prmUrl);
-    if (!response.ok) {
-      return false;
-    }
-    const document = (await response.json()) as {
-      cursor_omit_resource_indicator?: unknown;
-    };
-    return document.cursor_omit_resource_indicator === true;
-  } catch {
-    return false;
-  }
-}
-
-export class HostMcpOAuthProvider implements OAuthClientProvider {
-  private tokensValue: OAuthTokens | undefined;
-  private clientInfo: OAuthClientInformationFull | undefined;
-  private verifier: string | undefined;
-  private redirect: URL | undefined;
-  private readonly meta: OAuthClientMetadata;
-  private readonly args: ProviderArgs;
-  /**
-   * Assigned only when the PRM sets `cursor_omit_resource_indicator`; left
-   * absent otherwise so the SDK's default resource validation applies.
-   */
-  readonly validateResourceURL: (() => Promise<URL | undefined>) | undefined;
-
-  constructor(args: ProviderArgs) {
-    this.args = args;
-    this.tokensValue = args.tokens;
-    this.clientInfo = args.clientInformation;
-    if (args.omitResourceIndicator === true) {
-      this.validateResourceURL = async () => undefined;
-    }
-    this.meta = {
-      redirect_uris: [args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL],
-      token_endpoint_auth_method: "none",
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      client_name: "Agent SDK",
-    };
-  }
-
-  get redirectUrl(): string {
-    return this.args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL;
-  }
-
-  get clientMetadata(): OAuthClientMetadata {
-    return this.meta;
-  }
-
-  get lastRedirectUrl(): URL | undefined {
-    return this.redirect;
-  }
-
-  state(): string {
-    return randomUUID();
-  }
-
-  clientInformation(): OAuthClientInformationFull | undefined {
-    return this.clientInfo;
-  }
-
-  async saveClientInformation(info: OAuthClientInformationFull): Promise<void> {
-    this.clientInfo = info;
-    await this.args.store.saveClientInformation(this.args.identifier, this.args.resourceUrl, info);
-  }
-
-  tokens(): OAuthTokens | undefined {
-    return this.tokensValue;
-  }
-
-  async saveTokens(tokens: OAuthTokens): Promise<void> {
-    this.tokensValue = tokens;
-    await this.args.store.saveTokens(this.args.identifier, this.args.resourceUrl, tokens);
-  }
-
-  redirectToAuthorization(url: URL): void {
-    this.redirect = url;
-    this.args.onRedirect?.(url);
-  }
-
-  async saveCodeVerifier(codeVerifier: string): Promise<void> {
-    this.verifier = codeVerifier;
-  }
-
-  codeVerifier(): string {
-    if (this.verifier === undefined) {
-      throw new Error("No PKCE code verifier saved for this OAuth attempt.");
-    }
-    return this.verifier;
-  }
-
-  async invalidateCredentials(scope: "all" | "client" | "tokens" | "verifier"): Promise<void> {
-    if (scope === "tokens" || scope === "all") {
-      this.tokensValue = undefined;
-    }
-    if (scope === "client" || scope === "all") {
-      this.clientInfo = undefined;
-    }
-    if (scope === "verifier" || scope === "all") {
-      this.verifier = undefined;
-      this.redirect = undefined;
-    }
-    if (scope === "all") {
-      await this.args.store.deleteCredentials(this.args.identifier);
-    }
-  }
-}
-
-function clientForRedirect(
-  info: OAuthClientInformationFull | undefined,
-  redirectUrl: string,
-): OAuthClientInformationFull | undefined {
-  if (info === undefined || !info.redirect_uris.includes(redirectUrl)) {
-    return undefined;
-  }
-  return info;
-}
-
-export async function createHostMcpOAuthProvider(args: {
-  identifier: string;
-  resourceUrl: string;
-  store?: FileMcpOAuthStore;
-  onRedirect?: (url: URL) => void;
-  redirectUrl?: string;
-}): Promise<HostMcpOAuthProvider> {
-  const store = args.store ?? new FileMcpOAuthStore();
-  const redirectUrl = args.redirectUrl ?? MCP_OAUTH_CALLBACK_URL;
-  const [fileTokens, fileClient, omitResourceIndicator] = await Promise.all([
-    store.loadTokens(args.identifier, args.resourceUrl),
-    store.loadClientInformation(args.identifier, args.resourceUrl),
-    fetchOmitResourceIndicatorFromPrm(args.resourceUrl),
-  ]);
-  return new HostMcpOAuthProvider({
-    identifier: args.identifier,
-    resourceUrl: args.resourceUrl,
-    store,
-    redirectUrl,
-    tokens: fileTokens ?? tokensFromEnv(args.identifier),
-    clientInformation: clientForRedirect(
-      fileClient ?? clientIdFromEnv(args.identifier),
-      redirectUrl,
-    ),
-    onRedirect: args.onRedirect,
-    omitResourceIndicator,
-  });
-}
-
-export type OAuthCallbackResult = {
-  code: string;
-  state?: string;
-};
-
-/**
- * Deliberately not `@anysphere/mcp-core/oauth/loopback`, which is the canonical
- * implementation every other Cursor surface shares. `@cursor/bdk` publishes to
- * public npm with no private workspace dependencies, and its OAuth state is a
- * bare UUID rather than the payload that module's validator expects.
- */
-export async function waitForMcpOAuthCallback(args: {
-  authorizationUrl: string;
-  port?: number;
-  path?: string;
-  timeoutMs?: number;
-}): Promise<OAuthCallbackResult> {
-  const port = args.port ?? MCP_OAUTH_CALLBACK_PORT;
-  const path = args.path ?? MCP_OAUTH_CALLBACK_PATH;
-  const timeoutMs = args.timeoutMs ?? 5 * 60 * 1000;
-  const expectedState = new URL(args.authorizationUrl).searchParams.get("state");
-
-  return new Promise((resolve, reject) => {
-    let done = false;
-    const finish = (result: OAuthCallbackResult | undefined, error?: Error): void => {
-      if (done) {
-        return;
-      }
-      done = true;
-      clearTimeout(timer);
-      server.close();
-      if (error !== undefined) {
-        reject(error);
-        return;
-      }
-      if (result !== undefined) {
-        resolve(result);
-      }
-    };
-
-    const server: Server = createServer((req, res) => {
-      if (req.url === "/favicon.ico") {
-        res.writeHead(404).end();
-        return;
-      }
-      const url = new URL(req.url ?? "", `http://localhost:${port}`);
-      if (url.pathname !== path) {
-        res.writeHead(404).end("Not found");
-        return;
-      }
-      const code = url.searchParams.get("code");
-      const oauthError = url.searchParams.get("error");
-      const state = url.searchParams.get("state") ?? undefined;
-      // Without this, any page that can reach the loopback port during a login
-      // can inject its own authorization code into the exchange. Ignore what is
-      // not ours rather than failing the login: treating a stray request as
-      // fatal would let any page cancel a login, and free the port for someone
-      // else to bind before the real callback arrives.
-      if (state !== (expectedState ?? undefined)) {
-        res
-          .writeHead(404, { "content-type": "text/html; charset=utf-8" })
-          .end("<!doctype html><html><body><h1>Not found</h1></body></html>");
-        return;
-      }
-      if (code) {
-        res
-          .writeHead(200, { "content-type": "text/html; charset=utf-8" })
-          .end(
-            "<!doctype html><html><body><h1>Authorized</h1><p>Return to Agent SDK.</p></body></html>",
-          );
-        finish({ code, state });
-        return;
-      }
-      res
-        .writeHead(400, { "content-type": "text/html; charset=utf-8" })
-        .end(
-          `<!doctype html><html><body><h1>Authorization failed</h1><p>${oauthError ?? "missing code"}</p></body></html>`,
-        );
-      finish(undefined, new Error(`OAuth authorization failed: ${oauthError ?? "missing code"}`));
-    });
-
-    const timer = setTimeout(() => {
-      finish(
-        undefined,
-        new Error(`Timed out waiting for OAuth callback on http://localhost:${port}${path}`),
-      );
-    }, timeoutMs);
-
-    server.on("error", error => {
-      finish(
-        undefined,
-        new Error(
-          `OAuth callback port ${port} failed: ${
-            error instanceof Error ? error.message : String(error)
-          }`,
-        ),
-      );
-    });
-    server.listen(port, "127.0.0.1");
-  });
-}
-
-export function openBrowser(url: string): void {
-  const parsed = new URL(url);
-  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
-    throw new Error(`Refusing to open non-http(s) authorization URL: ${parsed.protocol}`);
-  }
-  const href = parsed.href;
-  if (process.platform === "darwin") {
-    execFile("open", [href], () => undefined);
-    return;
-  }
-  if (process.platform === "win32") {
-    // Avoid `cmd /c start` — authorize URLs with `&` are shell-metachar risks.
-    execFile("rundll32", ["url.dll,FileProtocolHandler", href], () => undefined);
-    return;
-  }
-  execFile("xdg-open", [href], () => undefined);
-}

package/src/internal/net.ts

@@ -1,29 +0,0 @@
-/** True for IPv4/IPv6 loopback addresses (including IPv4-mapped IPv6). */
-export function isLoopbackAddress(address: string): boolean {
-  const normalized = address.startsWith("::ffff:") ? address.slice("::ffff:".length) : address;
-  if (normalized === "::1" || normalized === "localhost") {
-    return true;
-  }
-  return normalized.startsWith("127.");
-}
-
-/** True when a parsed URL hostname refers to loopback (localhost / 127.x / ::1). */
-export function isLoopbackHostname(hostname: string): boolean {
-  const normalized = hostname.toLowerCase();
-  if (normalized === "localhost" || normalized === "::1") {
-    return true;
-  }
-  if (normalized.startsWith("[") && normalized.endsWith("]")) {
-    const inner = normalized.slice(1, -1);
-    return inner === "::1";
-  }
-  const ipv4 = /^(\d{1,3})\.(\d{1,3})\.(\d{1,3})\.(\d{1,3})$/.exec(normalized);
-  if (ipv4 === null) {
-    return false;
-  }
-  const octets = ipv4.slice(1, 5).map(part => Number(part));
-  if (octets.some(octet => octet > 255)) {
-    return false;
-  }
-  return octets[0] === 127;
-}

package/src/internal/open-browser.ts

@@ -1,41 +0,0 @@
-/**
- * Best-effort browser open; callers should always print the URL as fallback.
- */
-
-import { spawn } from "node:child_process";
-import { join } from "node:path";
-
-export function openBrowser(url: string): void {
-  const command =
-    process.platform === "darwin"
-      ? { cmd: "open", args: [url] }
-      : process.platform === "win32"
-        ? {
-            cmd: join(
-              process.env.SYSTEMROOT ?? "C:\\Windows",
-              "System32",
-              "WindowsPowerShell",
-              "v1.0",
-              "powershell.exe",
-            ),
-            args: [
-              "-NoProfile",
-              "-NonInteractive",
-              "-WindowStyle",
-              "Hidden",
-              "-Command",
-              `Start-Process '${url.replace(/'/g, "''")}'`,
-            ],
-          }
-        : { cmd: "xdg-open", args: [url] };
-  try {
-    const child = spawn(command.cmd, command.args, {
-      stdio: "ignore",
-      detached: true,
-    });
-    child.on("error", () => {});
-    child.unref();
-  } catch {
-    // Printed URL is the fallback.
-  }
-}

package/src/internal/otel/attrs.ts

@@ -1,16 +0,0 @@
-/**
- * Build OTel attribute maps without conditional spreads. `undefined` values
- * are dropped (the OTel API rejects them).
- */
-
-export type AttrValue = string | number | boolean;
-
-export function attrs(input: Record<string, AttrValue | undefined>): Record<string, AttrValue> {
-  const out: Record<string, AttrValue> = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== undefined) {
-      out[key] = value;
-    }
-  }
-  return out;
-}