@plaud-ai/mcp 0.2.2 → 0.2.4

package/dist/server-VY7ANVCH.js

@@ -0,0 +1,1039 @@
+import {
+  logger,
+  registerTools
+} from "./chunk-BZOIX6WC.js";
+import {
+  PlaudClient
+} from "./chunk-3XRFIJUG.js";
+
+// src/http/server.ts
+import express from "express";
+import { createServer } from "http";
+import { randomUUID as randomUUID2 } from "crypto";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { createOAuthMetadata, mcpAuthRouter } from "@modelcontextprotocol/sdk/server/auth/router.js";
+import { requireBearerAuth } from "@modelcontextprotocol/sdk/server/auth/middleware/bearerAuth.js";
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+
+// src/http/oauth-provider.ts
+import { createCipheriv, createDecipheriv, createHmac, randomBytes, randomUUID, timingSafeEqual } from "crypto";
+import { ProxyOAuthServerProvider } from "@modelcontextprotocol/sdk/server/auth/providers/proxyProvider.js";
+import {
+  InvalidGrantError,
+  InvalidTokenError,
+  ServerError as McpServerError
+} from "@modelcontextprotocol/sdk/server/auth/errors.js";
+
+// src/http/cimd.ts
+import { lookup as dnsLookup } from "dns/promises";
+import { isIP, isIPv4, isIPv6 } from "net";
+var FETCH_TIMEOUT_MS = 5e3;
+var MAX_DOCUMENT_SIZE_BYTES = 10 * 1024;
+var DEFAULT_TTL_MS = 60 * 60 * 1e3;
+var CACHE_MAX_ENTRIES = 1e3;
+var FORBIDDEN_AUTH_METHODS = /* @__PURE__ */ new Set([
+  "client_secret_post",
+  "client_secret_basic",
+  "client_secret_jwt"
+]);
+function isValidCimdUrl(value) {
+  if (typeof value !== "string" || !URL.canParse(value)) return false;
+  const url = new URL(value);
+  if (url.protocol !== "https:") return false;
+  if (url.username || url.password) return false;
+  if (url.hash) return false;
+  if (!url.pathname || url.pathname === "/") return false;
+  if (url.pathname.split("/").some((seg) => seg === "." || seg === "..")) return false;
+  return true;
+}
+function isPrivateIp(ip) {
+  if (isIPv4(ip)) {
+    const parts = ip.split(".").map((p) => Number(p));
+    if (parts.length !== 4 || parts.some((n) => Number.isNaN(n))) return false;
+    const [a, b] = parts;
+    if (a === 0) return true;
+    if (a === 10) return true;
+    if (a === 127) return true;
+    if (a === 169 && b === 254) return true;
+    if (a === 172 && b >= 16 && b <= 31) return true;
+    if (a === 192 && b === 168) return true;
+    if (a >= 224) return true;
+    return false;
+  }
+  if (isIPv6(ip)) {
+    const lower = ip.toLowerCase();
+    if (lower === "::" || lower === "::1") return true;
+    if (lower.startsWith("fc") || lower.startsWith("fd")) return true;
+    if (lower.startsWith("fe80:")) return true;
+    if (lower.startsWith("ff")) return true;
+    if (lower.startsWith("::ffff:")) {
+      const v4 = lower.slice("::ffff:".length);
+      if (isIPv4(v4)) return isPrivateIp(v4);
+    }
+    return false;
+  }
+  return false;
+}
+var CimdLoader = class {
+  cache = /* @__PURE__ */ new Map();
+  allowPrivateIp;
+  fetchImpl;
+  lookupImpl;
+  ttlMs;
+  constructor(options = {}) {
+    this.allowPrivateIp = options.allowPrivateIp ?? false;
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.lookupImpl = options.lookupImpl ?? dnsLookup;
+    this.ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
+  }
+  /**
+   * Resolve a CIMD client_id URL into an OAuthClientInformationFull, fetching
+   * and validating the metadata document if necessary. Returns undefined on
+   * any failure (logged at warn level).
+   */
+  async load(clientIdUrl) {
+    if (!isValidCimdUrl(clientIdUrl)) {
+      logger.warn({ event: "cimd_invalid_url", client_id_url: clientIdUrl });
+      return void 0;
+    }
+    const cached = this.cache.get(clientIdUrl);
+    if (cached && cached.expiresAt > Date.now()) {
+      return cached.client;
+    }
+    if (cached) this.cache.delete(clientIdUrl);
+    if (!this.allowPrivateIp) {
+      const safe = await this.checkHostAllowed(new URL(clientIdUrl).hostname);
+      if (!safe) return void 0;
+    }
+    const client = await this.fetchAndValidate(clientIdUrl);
+    if (!client) return void 0;
+    this.put(clientIdUrl, client);
+    logger.info({
+      event: "cimd_client_loaded",
+      client_id_url: clientIdUrl,
+      client_name: client.client_name ?? null,
+      redirect_uri_count: client.redirect_uris.length
+    });
+    return client;
+  }
+  async checkHostAllowed(hostname) {
+    if (isIP(hostname) !== 0) {
+      logger.warn({ event: "cimd_ip_literal_blocked", hostname });
+      return false;
+    }
+    try {
+      const results = await this.lookupImpl(hostname, { all: true });
+      for (const r of results) {
+        if (isPrivateIp(r.address)) {
+          logger.warn({ event: "cimd_private_ip_blocked", hostname, ip: r.address });
+          return false;
+        }
+      }
+      return true;
+    } catch (err) {
+      logger.warn({
+        event: "cimd_dns_failed",
+        hostname,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return false;
+    }
+  }
+  async fetchAndValidate(clientIdUrl) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    try {
+      const res = await this.fetchImpl(clientIdUrl, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal: ctrl.signal,
+        redirect: "error"
+        // CIMD URL identifies the client; redirects not allowed
+      });
+      if (!res.ok) {
+        logger.warn({ event: "cimd_fetch_non_ok", client_id_url: clientIdUrl, status: res.status });
+        return void 0;
+      }
+      const declared = Number(res.headers.get("content-length") ?? "0");
+      if (declared > MAX_DOCUMENT_SIZE_BYTES) {
+        logger.warn({
+          event: "cimd_document_too_large",
+          client_id_url: clientIdUrl,
+          content_length: declared
+        });
+        return void 0;
+      }
+      const text = await res.text();
+      if (text.length > MAX_DOCUMENT_SIZE_BYTES) {
+        logger.warn({
+          event: "cimd_document_too_large",
+          client_id_url: clientIdUrl,
+          actual_size: text.length
+        });
+        return void 0;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(text);
+      } catch (err) {
+        logger.warn({
+          event: "cimd_invalid_json",
+          client_id_url: clientIdUrl,
+          error: err instanceof Error ? err.message : String(err)
+        });
+        return void 0;
+      }
+      return validateMetadata(parsed, clientIdUrl);
+    } catch (err) {
+      logger.warn({
+        event: "cimd_fetch_error",
+        client_id_url: clientIdUrl,
+        error: err instanceof Error ? err.message : String(err)
+      });
+      return void 0;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  put(key, client) {
+    if (this.cache.size >= CACHE_MAX_ENTRIES) {
+      const oldest = this.cache.keys().next().value;
+      if (oldest !== void 0) this.cache.delete(oldest);
+    }
+    this.cache.set(key, { client, expiresAt: Date.now() + this.ttlMs });
+  }
+};
+function validateMetadata(parsed, expectedClientIdUrl) {
+  if (!parsed || typeof parsed !== "object") {
+    logger.warn({ event: "cimd_invalid_shape", client_id_url: expectedClientIdUrl });
+    return void 0;
+  }
+  const m = parsed;
+  if (m["client_id"] !== expectedClientIdUrl) {
+    logger.warn({
+      event: "cimd_client_id_mismatch",
+      client_id_url: expectedClientIdUrl,
+      document_client_id: typeof m["client_id"] === "string" ? m["client_id"] : null
+    });
+    return void 0;
+  }
+  const redirects = m["redirect_uris"];
+  if (!Array.isArray(redirects) || redirects.length === 0 || !redirects.every((u) => typeof u === "string")) {
+    logger.warn({ event: "cimd_invalid_redirect_uris", client_id_url: expectedClientIdUrl });
+    return void 0;
+  }
+  const authMethod = m["token_endpoint_auth_method"];
+  if (typeof authMethod === "string" && FORBIDDEN_AUTH_METHODS.has(authMethod)) {
+    logger.warn({
+      event: "cimd_forbidden_auth_method",
+      client_id_url: expectedClientIdUrl,
+      token_endpoint_auth_method: authMethod
+    });
+    return void 0;
+  }
+  const optString = (key) => typeof m[key] === "string" ? m[key] : void 0;
+  const optStringArray = (key) => {
+    const v = m[key];
+    return Array.isArray(v) && v.every((x) => typeof x === "string") ? v : void 0;
+  };
+  return {
+    client_id: expectedClientIdUrl,
+    client_id_issued_at: Math.floor(Date.now() / 1e3),
+    redirect_uris: redirects,
+    token_endpoint_auth_method: typeof authMethod === "string" ? authMethod : "none",
+    grant_types: optStringArray("grant_types"),
+    response_types: optStringArray("response_types"),
+    client_name: optString("client_name"),
+    client_uri: optString("client_uri"),
+    logo_uri: optString("logo_uri"),
+    scope: optString("scope"),
+    contacts: optStringArray("contacts"),
+    tos_uri: optString("tos_uri"),
+    policy_uri: optString("policy_uri"),
+    jwks_uri: optString("jwks_uri"),
+    software_id: optString("software_id"),
+    software_version: optString("software_version"),
+    software_statement: optString("software_statement")
+  };
+}
+
+// src/http/oauth-provider.ts
+var DEFAULT_TOKEN_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token";
+var DEFAULT_REFRESH_URL = "https://platform.plaud.ai/developer/api/oauth/third-party/access-token/refresh";
+var STATELESS_CODE_PREFIX = "pc1_";
+var AUTHORIZATION_CODE_TTL_MS = 10 * 60 * 1e3;
+function urlParts(value) {
+  if (!value || !URL.canParse(value)) {
+    return { host: null, path: null };
+  }
+  const url = new URL(value);
+  return { host: url.host, path: url.pathname };
+}
+var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
+  _plaudClientId;
+  _plaudClientSecret;
+  _plaudTokenUrl;
+  _plaudRefreshUrl;
+  _plaudApiBase;
+  _callbackUrl;
+  _debugOAuthLogs;
+  _cimdLoader;
+  _registeredClients = /* @__PURE__ */ new Map();
+  // HMAC secret used to sign DCR-issued client_ids so we can recover them
+  // across container restarts without persistent storage. See verifyAndRecover.
+  _clientIdSecret;
+  // internalState → client redirect, original client state, and resource indicator
+  // We generate our own state to track the pending flow regardless of whether the client sent one.
+  _pendingStates = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const authUrl = options.authUrl ?? "https://web.plaud.ai/platform/oauth";
+    const tokenUrl = options.tokenUrl ?? DEFAULT_TOKEN_URL;
+    const refreshUrl = options.refreshUrl ?? DEFAULT_REFRESH_URL;
+    const apiBase = options.apiBase ?? "https://platform.plaud.ai/developer/api";
+    super({
+      endpoints: {
+        authorizationUrl: authUrl,
+        tokenUrl
+      },
+      verifyAccessToken: async (token) => {
+        const client = new PlaudClient({
+          clientId: options.clientId,
+          clientSecret: "",
+          redirectUri: "",
+          apiBase,
+          staticToken: token
+        });
+        try {
+          const user = await client.getCurrentUser();
+          let expiresAt;
+          try {
+            const payload = JSON.parse(
+              Buffer.from(token.split(".")[1], "base64url").toString()
+            );
+            expiresAt = typeof payload.exp === "number" ? payload.exp : Math.floor(Date.now() / 1e3) + 3600;
+          } catch {
+            expiresAt = Math.floor(Date.now() / 1e3) + 3600;
+          }
+          const authInfo = {
+            token,
+            clientId: String(user.id ?? "unknown"),
+            scopes: [],
+            expiresAt
+          };
+          logger.info({ event: "token_verified", client_id: authInfo.clientId, expires_at: expiresAt });
+          return authInfo;
+        } catch (err) {
+          logger.warn({ event: "token_verify_failed", error: String(err) });
+          throw new InvalidTokenError("Invalid or expired token");
+        }
+      },
+      getClient: async (id) => this._registeredClients.get(id)
+    });
+    this._plaudClientId = options.clientId;
+    this._plaudClientSecret = options.clientSecret ?? "";
+    this._plaudTokenUrl = tokenUrl;
+    this._plaudRefreshUrl = refreshUrl;
+    this._plaudApiBase = apiBase;
+    this._callbackUrl = options.callbackUrl;
+    this._debugOAuthLogs = options.debugOAuthLogs ?? false;
+    this._cimdLoader = options.cimdLoader;
+    const secret = process.env["PLAUD_DCR_HMAC_SECRET"];
+    if (secret && secret.length >= 32) {
+      this._clientIdSecret = Buffer.from(secret, "utf-8");
+    } else {
+      this._clientIdSecret = randomBytes(32);
+      logger.warn({
+        event: "oauth_dcr_secret_missing",
+        message: "PLAUD_DCR_HMAC_SECRET unset or too short (<32 chars); using ephemeral per-process secret. Cached client_ids will not survive restarts."
+      });
+    }
+    this.skipLocalPkceValidation = true;
+  }
+  // Override clientsStore. registerClient signs the issued client_id with HMAC
+  // so verifyAndRecover can later resurrect it across container restarts.
+  get clientsStore() {
+    return {
+      getClient: async (id) => {
+        if (this._cimdLoader && isValidCimdUrl(id)) {
+          return await this._cimdLoader.load(id);
+        }
+        return this._registeredClients.get(id);
+      },
+      registerClient: async (client) => {
+        const rawId = randomBytes(16).toString("base64url");
+        const tokenEndpointAuthMethod = client.token_endpoint_auth_method ?? "none";
+        const full = {
+          ...client,
+          token_endpoint_auth_method: tokenEndpointAuthMethod,
+          client_secret: tokenEndpointAuthMethod === "none" ? void 0 : client.client_secret,
+          client_secret_expires_at: tokenEndpointAuthMethod === "none" ? void 0 : client.client_secret_expires_at,
+          client_id: this.signClientId(rawId),
+          client_id_issued_at: Math.floor(Date.now() / 1e3)
+        };
+        this._registeredClients.set(full.client_id, full);
+        if (this._debugOAuthLogs) {
+          logger.info({
+            event: "oauth_client_registered",
+            client_id_len: full.client_id.length,
+            client_name: client.client_name ?? null,
+            client_uri: client.client_uri ?? null,
+            logo_uri: client.logo_uri ?? null,
+            redirect_uri_count: full.redirect_uris.length,
+            redirect_uri_hosts: [...new Set(full.redirect_uris.map((uri) => urlParts(uri).host).filter(Boolean))],
+            redirect_uri_paths: full.redirect_uris.map((uri) => urlParts(uri).path).filter(Boolean),
+            token_endpoint_auth_method: full.token_endpoint_auth_method ?? null,
+            grant_types: full.grant_types ?? null,
+            response_types: full.response_types ?? null,
+            has_client_secret: !!full.client_secret,
+            client_secret_expires_at: full.client_secret_expires_at ?? null,
+            registered_clients_count: this._registeredClients.size
+          });
+        }
+        return full;
+      }
+    };
+  }
+  // Sign a raw id so the resulting client_id is `<rawId>.<base64url(hmac)>`.
+  // Truncated to 16 bytes (128 bits) — plenty for non-cryptographic forgery
+  // resistance, keeps the client_id short.
+  signClientId(rawId) {
+    const sig = createHmac("sha256", this._clientIdSecret).update(rawId).digest().subarray(0, 16);
+    return `${rawId}.${sig.toString("base64url")}`;
+  }
+  // Verify a previously-issued client_id. Returns true only for ids whose HMAC
+  // signature matches our secret — i.e. ids this server (or its predecessor with
+  // the same PLAUD_DCR_HMAC_SECRET) issued via registerClient.
+  verifyClientIdSignature(signedId) {
+    const idx = signedId.lastIndexOf(".");
+    if (idx <= 0 || idx >= signedId.length - 1) return false;
+    const rawId = signedId.slice(0, idx);
+    const sigPart = signedId.slice(idx + 1);
+    const expected = createHmac("sha256", this._clientIdSecret).update(rawId).digest().subarray(0, 16);
+    let actual;
+    try {
+      actual = Buffer.from(sigPart, "base64url");
+    } catch {
+      return false;
+    }
+    if (actual.length !== expected.length) return false;
+    return timingSafeEqual(actual, expected);
+  }
+  authorizationCodeKey() {
+    return createHmac("sha256", this._clientIdSecret).update("plaud-mcp-authorization-code").digest();
+  }
+  encodeAuthorizationCode(payload) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", this.authorizationCodeKey(), iv);
+    const plaintext = Buffer.from(JSON.stringify({
+      upstreamCode: payload.upstreamCode,
+      upstreamState: payload.upstreamState,
+      resource: payload.resource,
+      expiresAt: Date.now() + AUTHORIZATION_CODE_TTL_MS
+    }), "utf8");
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${STATELESS_CODE_PREFIX}${Buffer.concat([iv, tag, ciphertext]).toString("base64url")}`;
+  }
+  decodeAuthorizationCode(code) {
+    if (!code.startsWith(STATELESS_CODE_PREFIX)) return null;
+    try {
+      const encoded = code.slice(STATELESS_CODE_PREFIX.length);
+      const data = Buffer.from(encoded, "base64url");
+      if (data.length <= 28) return null;
+      const iv = data.subarray(0, 12);
+      const tag = data.subarray(12, 28);
+      const ciphertext = data.subarray(28);
+      const decipher = createDecipheriv("aes-256-gcm", this.authorizationCodeKey(), iv);
+      decipher.setAuthTag(tag);
+      const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]).toString("utf8");
+      const payload = JSON.parse(plaintext);
+      if (typeof payload.upstreamCode !== "string" || typeof payload.upstreamState !== "string" || payload.resource !== void 0 && typeof payload.resource !== "string" || typeof payload.expiresAt !== "number") {
+        return null;
+      }
+      if (Date.now() > payload.expiresAt) {
+        return null;
+      }
+      return {
+        upstreamCode: payload.upstreamCode,
+        upstreamState: payload.upstreamState,
+        resource: payload.resource
+      };
+    } catch {
+      return null;
+    }
+  }
+  // Recover a client_id that the registry doesn't know about. Directory clients
+  // (OpenAI Apps, Claude directory) cache the client_id they got from /register;
+  // when this stateless container restarts, the in-memory map is empty and the
+  // SDK auth handlers reject the cached client_id with InvalidClientError.
+  // We synthesize an entry on demand — but only for client_ids whose HMAC
+  // signature verifies against our secret, so this server can't be coaxed into
+  // accepting forged ids. Real auth still happens upstream at Plaud.
+  // Returns true if the caller should proceed (client is now in the registry).
+  verifyAndRecover(clientId, redirectUri) {
+    const existing = this._registeredClients.get(clientId);
+    if (existing) {
+      if (redirectUri && !existing.redirect_uris.includes(redirectUri)) {
+        existing.redirect_uris = [...existing.redirect_uris, redirectUri];
+      }
+      return true;
+    }
+    if (!this.verifyClientIdSignature(clientId)) {
+      return false;
+    }
+    this._registeredClients.set(clientId, {
+      client_id: clientId,
+      client_id_issued_at: Math.floor(Date.now() / 1e3),
+      redirect_uris: redirectUri ? [redirectUri] : [],
+      grant_types: ["authorization_code", "refresh_token"],
+      response_types: ["code"],
+      token_endpoint_auth_method: "none",
+      client_name: "auto-recovered client"
+    });
+    logger.info({ event: "oauth_client_recovered", client_id: clientId, redirect_uri: redirectUri ?? null });
+    return true;
+  }
+  /**
+   * Redirect to Plaud using our own registered callback URL.
+   * Store the client's original redirect_uri keyed by state so we can forward after Plaud calls back.
+   */
+  async authorize(_client, params, res) {
+    const internalState = randomUUID();
+    this._pendingStates.set(internalState, {
+      clientRedirectUri: params.redirectUri,
+      originalState: params.state,
+      resource: params.resource?.href
+    });
+    const redirectParts = urlParts(params.redirectUri);
+    logger.info({
+      event: "oauth_authorize_start",
+      internal_state: internalState,
+      redirect_uri: params.redirectUri,
+      ...this._debugOAuthLogs ? {
+        redirect_uri_host: redirectParts.host,
+        redirect_uri_path: redirectParts.path,
+        has_original_state: !!params.state,
+        has_resource: !!params.resource,
+        resource: params.resource?.href ?? null,
+        pending_states_count: this._pendingStates.size
+      } : {}
+    });
+    const targetUrl = new URL(this._endpoints.authorizationUrl);
+    const searchParams = new URLSearchParams({
+      client_id: this._plaudClientId,
+      response_type: "code",
+      redirect_uri: this._callbackUrl,
+      code_challenge: params.codeChallenge,
+      code_challenge_method: "S256",
+      state: internalState
+      // always send our internal state to Plaud
+    });
+    if (params.scopes?.length) searchParams.set("scope", params.scopes.join(" "));
+    if (_client.client_name) searchParams.set("mcp_display_name", _client.client_name);
+    if (_client.redirect_uris?.[0]) searchParams.set("mcp_redirect_uri", _client.redirect_uris[0]);
+    if (_client.logo_uri) searchParams.set("mcp_logo_uri", _client.logo_uri);
+    if (_client.client_uri) searchParams.set("mcp_client_uri", _client.client_uri);
+    targetUrl.search = searchParams.toString();
+    logger.info({ event: "oauth_authorize_redirect", url: targetUrl.toString(), scopes: params.scopes ?? [] });
+    res.redirect(targetUrl.toString());
+  }
+  /**
+   * Called when Plaud redirects to our /oauth/callback.
+   * Looks up the original client redirect_uri and forwards the code+state to it.
+   */
+  handleCallback(code, state, res) {
+    const pending = this._pendingStates.get(state);
+    if (!pending) {
+      logger.warn({ event: "oauth_callback_unknown_state", state });
+      res.status(400).send("Unknown state \u2014 authorization request not found");
+      return;
+    }
+    this._pendingStates.delete(state);
+    logger.info({ event: "oauth_callback_received", internal_state: state });
+    const pendingCode = {
+      upstreamCode: code,
+      upstreamState: state,
+      resource: pending.resource
+    };
+    const clientCode = this.encodeAuthorizationCode(pendingCode);
+    const target = new URL(pending.clientRedirectUri);
+    target.searchParams.set("code", clientCode);
+    if (pending.originalState) {
+      target.searchParams.set("state", pending.originalState);
+    }
+    const redirectParts = urlParts(pending.clientRedirectUri);
+    logger.info({
+      event: "oauth_callback_redirect",
+      internal_state: state,
+      redirect_uri: pending.clientRedirectUri,
+      has_original_state: !!pending.originalState,
+      original_state_len: pending.originalState?.length ?? 0,
+      upstream_code_len: code.length,
+      client_code_len: clientCode.length,
+      stateless_code: true,
+      redirect_url_len: target.toString().length,
+      ...this._debugOAuthLogs ? {
+        redirect_uri_host: redirectParts.host,
+        redirect_uri_path: redirectParts.path,
+        redirect_has_existing_query: pending.clientRedirectUri.includes("?"),
+        redirect_has_code: target.searchParams.has("code"),
+        redirect_has_state: target.searchParams.has("state")
+      } : {}
+    });
+    res.redirect(target.toString());
+  }
+  // Override to use PKCE public-client flow — no Basic auth, client_id sent in body.
+  async exchangeAuthorizationCode(_client, authorizationCode, codeVerifier, _redirectUri, resource) {
+    const pendingCode = this.decodeAuthorizationCode(authorizationCode);
+    if (!pendingCode) {
+      logger.warn({ event: "oauth_authorization_code_unknown", code_len: authorizationCode.length });
+      throw new InvalidGrantError("Unknown or expired authorization code");
+    }
+    if (pendingCode.resource && resource && resource.href !== pendingCode.resource) {
+      logger.warn({
+        event: "oauth_resource_mismatch",
+        expected_resource: pendingCode.resource,
+        received_resource: resource.href
+      });
+      throw new InvalidGrantError("Mismatched resource");
+    }
+    const body = {
+      grant_type: "authorization_code",
+      client_id: this._plaudClientId,
+      code: pendingCode.upstreamCode,
+      redirect_uri: this._callbackUrl
+    };
+    body.state = pendingCode.upstreamState;
+    if (codeVerifier) body.code_verifier = codeVerifier;
+    const basicAuth = Buffer.from(`${this._plaudClientId}:${this._plaudClientSecret}`).toString("base64");
+    logger.info({
+      event: "oauth_token_exchange_attempt",
+      token_url: this._plaudTokenUrl,
+      client_id: this._plaudClientId,
+      has_secret: !!this._plaudClientSecret,
+      has_code_verifier: !!body.code_verifier,
+      redirect_uri: body.redirect_uri
+    });
+    const fetchRes = await fetch(this._plaudTokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        Authorization: `Basic ${basicAuth}`
+      },
+      body: new URLSearchParams(body)
+    });
+    if (!fetchRes.ok) {
+      let text;
+      try {
+        text = await fetchRes.text();
+      } catch {
+        text = "<unreadable>";
+      }
+      logger.error({ event: "oauth_token_exchange_failed", status: fetchRes.status, body: text.slice(0, 500) });
+      if (fetchRes.status >= 500) {
+        throw new McpServerError(`Upstream token endpoint error: ${fetchRes.status} ${text.slice(0, 200)}`);
+      }
+      throw new InvalidGrantError(`Plaud token exchange: ${fetchRes.status} ${text.slice(0, 200)}`);
+    }
+    let data;
+    try {
+      data = await fetchRes.json();
+    } catch (err) {
+      logger.error({ event: "oauth_token_json_parse_failed", error: String(err) });
+      throw new McpServerError("Token endpoint returned non-JSON response");
+    }
+    logger.info({ event: "oauth_token_exchange_ok", has_refresh_token: !!data.refresh_token });
+    return {
+      access_token: data.access_token,
+      token_type: data.token_type ?? "Bearer",
+      refresh_token: data.refresh_token,
+      expires_in: data.expires_in
+    };
+  }
+  // Override refresh too: the SDK proxy implementation would forward the local
+  // DCR client_id and RFC 8707 resource to Plaud, but Plaud uses its dedicated
+  // refresh endpoint and does not support resource indicators.
+  async exchangeRefreshToken(_client, refreshToken, scopes, resource) {
+    logger.info({
+      event: "oauth_token_refresh_attempt",
+      token_url: this._plaudRefreshUrl,
+      has_scope: !!scopes?.length,
+      has_resource: !!resource,
+      ...this._debugOAuthLogs ? { resource: resource?.href ?? null } : {}
+    });
+    const fetchRes = await fetch(this._plaudRefreshUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json"
+      },
+      body: new URLSearchParams({ refresh_token: refreshToken })
+    });
+    if (!fetchRes.ok) {
+      let text;
+      try {
+        text = await fetchRes.text();
+      } catch {
+        text = "<unreadable>";
+      }
+      logger.error({ event: "oauth_token_refresh_failed", status: fetchRes.status, body: text.slice(0, 500) });
+      if (fetchRes.status >= 500) {
+        throw new McpServerError(`Upstream refresh endpoint error: ${fetchRes.status} ${text.slice(0, 200)}`);
+      }
+      throw new InvalidGrantError(`Plaud token refresh: ${fetchRes.status} ${text.slice(0, 200)}`);
+    }
+    let data;
+    try {
+      data = await fetchRes.json();
+    } catch (err) {
+      logger.error({ event: "oauth_refresh_json_parse_failed", error: String(err) });
+      throw new McpServerError("Refresh endpoint returned non-JSON response");
+    }
+    logger.info({
+      event: "oauth_token_refresh_ok",
+      has_refresh_token: !!data.refresh_token,
+      ignored_scope: !!scopes?.length,
+      ignored_resource: !!resource
+    });
+    return {
+      access_token: data.access_token,
+      token_type: data.token_type ?? "Bearer",
+      refresh_token: data.refresh_token ?? refreshToken,
+      expires_in: data.expires_in
+    };
+  }
+};
+
+// src/http/server.ts
+var HTTP_PORT = Number(process.env.PLAUD_HTTP_PORT ?? 3e3);
+var HTTP_HOST = process.env.PLAUD_HTTP_HOST ?? "0.0.0.0";
+var CALLBACK_PORT = 8199;
+var CALLBACK_PATH = "/auth/callback";
+var CALLBACK_URL = process.env.PLAUD_CALLBACK_URL ?? `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+var DEFAULT_ALLOWED_ORIGINS = [
+  "https://claude.ai",
+  "https://claude.com",
+  "https://chatgpt.com",
+  "https://chat.openai.com",
+  "https://platform.openai.com"
+];
+var ALLOWED_ORIGINS = (process.env.PLAUD_ALLOWED_ORIGINS ?? DEFAULT_ALLOWED_ORIGINS.join(",")).split(",").map((s) => s.trim()).filter(Boolean);
+var OPENAI_APPS_CHALLENGE_TOKEN = "bBlB7N7fF7YaQnONtEQNAGP7SLaqpJT3a3DS5Zv1F8s";
+var OAUTH_DEBUG_LOGS = !["0", "false", "no", "off"].includes(
+  (process.env.PLAUD_OAUTH_DEBUG_LOGS ?? "").toLowerCase()
+);
+var CIMD_ENABLED = ["1", "true", "yes", "on"].includes(
+  (process.env.PLAUD_CIMD_ENABLED ?? "").toLowerCase()
+);
+var CIMD_ALLOW_PRIVATE_IP = ["1", "true", "yes", "on"].includes(
+  (process.env.PLAUD_CIMD_ALLOW_PRIVATE_IP ?? "").toLowerCase()
+);
+function queryValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function arrayValue(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string") ? value : void 0;
+}
+function urlParts2(value) {
+  if (!value || !URL.canParse(value)) {
+    return { host: null, path: null };
+  }
+  const url = new URL(value);
+  return { host: url.host, path: url.pathname };
+}
+function basicAuthCredentials(value) {
+  if (typeof value !== "string" || !value.startsWith("Basic ")) {
+    return null;
+  }
+  try {
+    const decoded = Buffer.from(value.slice("Basic ".length), "base64").toString("utf8");
+    const separator = decoded.indexOf(":");
+    if (separator < 0) return null;
+    return {
+      clientId: decoded.slice(0, separator),
+      clientSecret: decoded.slice(separator + 1) || void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function isDiagnosticPath(path) {
+  return path === "/mcp" || path === "/register" || path === "/authorize" || path === "/token" || path.startsWith("/.well-known/");
+}
+function startHttpServer() {
+  const clientId = process.env.PLAUD_MCP_CLIENT_ID ?? "client_37d250cb-50f8-4af1-8cd6-bc6711c5d684";
+  const clientSecret = process.env.PLAUD_MCP_CLIENT_SECRET;
+  const apiBase = process.env.PLAUD_API_BASE;
+  const serverUrl = process.env.PLAUD_SERVER_URL ?? `http://localhost:${HTTP_PORT}`;
+  const cimdLoader = CIMD_ENABLED ? new CimdLoader({ allowPrivateIp: CIMD_ALLOW_PRIVATE_IP }) : void 0;
+  if (CIMD_ENABLED) {
+    logger.info({
+      event: "cimd_enabled",
+      allow_private_ip: CIMD_ALLOW_PRIVATE_IP
+    });
+  }
+  const provider = new PlaudOAuthProvider({
+    clientId,
+    clientSecret,
+    callbackUrl: CALLBACK_URL,
+    authUrl: process.env.PLAUD_AUTH_URL,
+    tokenUrl: process.env.PLAUD_TOKEN_URL,
+    refreshUrl: process.env.PLAUD_REFRESH_URL,
+    apiBase,
+    debugOAuthLogs: OAUTH_DEBUG_LOGS,
+    cimdLoader
+  });
+  const issuerUrl = new URL(serverUrl);
+  const trimmedServerUrl = serverUrl.replace(/\/$/, "");
+  const mcpResourceUrl = `${trimmedServerUrl}/mcp`;
+  const protectedResourceMetadataUrl = `${trimmedServerUrl}/.well-known/oauth-protected-resource/mcp`;
+  const protectedResourceMetadata = {
+    resource: mcpResourceUrl,
+    authorization_servers: [issuerUrl.href],
+    resource_name: "Plaud MCP Server",
+    bearer_methods_supported: ["header"]
+  };
+  const oauthMetadata = {
+    ...createOAuthMetadata({ provider, issuerUrl, baseUrl: issuerUrl }),
+    token_endpoint_auth_methods_supported: ["client_secret_basic", "client_secret_post", "none"],
+    // Only advertise CIMD support when actually enabled. Advertising while the
+    // backing fetch path is disabled would mislead clients into using CIMD and
+    // failing.
+    ...CIMD_ENABLED ? { client_id_metadata_document_supported: true } : {}
+  };
+  const app = createMcpExpressApp({ host: HTTP_HOST });
+  app.set("trust proxy", 1);
+  app.get("/.well-known/openai-apps-challenge", (_req, res) => {
+    res.type("text/plain").send(OPENAI_APPS_CHALLENGE_TOKEN);
+  });
+  app.get("/.well-known/oauth-protected-resource", (_req, res) => {
+    res.json(protectedResourceMetadata);
+  });
+  app.get("/.well-known/oauth-protected-resource/mcp", (_req, res) => {
+    res.json(protectedResourceMetadata);
+  });
+  app.get("/.well-known/oauth-authorization-server", (_req, res) => {
+    res.json(oauthMetadata);
+  });
+  app.get("/.well-known/openid-configuration", (_req, res) => {
+    res.json(oauthMetadata);
+  });
+  app.get("/health", (_req, res) => {
+    res.json({
+      status: "ok",
+      uptime_s: Math.floor(process.uptime()),
+      config: {
+        has_client_id: !!process.env.PLAUD_MCP_CLIENT_ID,
+        has_client_secret: !!process.env.PLAUD_MCP_CLIENT_SECRET,
+        callback_url: process.env.PLAUD_CALLBACK_URL ?? "(default:localhost)",
+        server_url: process.env.PLAUD_SERVER_URL ?? "(default:localhost)",
+        oauth_debug_logs: OAUTH_DEBUG_LOGS,
+        cimd_enabled: CIMD_ENABLED
+      }
+    });
+  });
+  if (process.env.PLAUD_CALLBACK_URL) {
+    app.get(CALLBACK_PATH, (req, res) => {
+      const code = req.query["code"];
+      const state = req.query["state"];
+      if (!code || !state) {
+        logger.warn({ event: "oauth_callback_invalid", code: !!code, state: !!state });
+        res.status(400).send("Missing code or state");
+        return;
+      }
+      provider.handleCallback(code, state, res);
+    });
+  }
+  app.use((req, res, next) => {
+    const reqId = req.headers["x-request-id"] ?? randomUUID2();
+    const startMs = Date.now();
+    res.locals["reqId"] = reqId;
+    res.on("finish", () => {
+      if (OAUTH_DEBUG_LOGS && isDiagnosticPath(req.path)) {
+        logger.info({
+          event: "http_response",
+          req_id: reqId,
+          method: req.method,
+          path: req.path,
+          status_code: res.statusCode,
+          duration_ms: Date.now() - startMs
+        });
+      }
+    });
+    logger.info({ event: "http_request", req_id: reqId, method: req.method, path: req.url, user_agent: req.headers["user-agent"] ?? null });
+    next();
+  });
+  app.use("/mcp", (req, res, next) => {
+    const origin = req.headers["origin"];
+    if (origin && !ALLOWED_ORIGINS.includes(origin)) {
+      logger.warn({ event: "origin_rejected", origin, req_id: res.locals["reqId"] });
+      res.status(403).json({ error: "forbidden_origin", origin });
+      return;
+    }
+    next();
+  });
+  app.post("/token", express.urlencoded({ extended: false }), (req, res, next) => {
+    const basicAuth = basicAuthCredentials(req.headers.authorization);
+    if (basicAuth) {
+      req.body ??= {};
+      req.body.client_id ??= basicAuth.clientId;
+      req.body.client_secret ??= basicAuth.clientSecret;
+    }
+    const resource = queryValue(req.body?.resource);
+    const resourceParts = urlParts2(resource);
+    if (OAUTH_DEBUG_LOGS) {
+      logger.info({
+        event: "oauth_token_request_received",
+        req_id: res.locals["reqId"],
+        grant_type: req.body?.grant_type ?? null,
+        has_code: !!req.body?.code,
+        has_resource: !!req.body?.resource,
+        resource_host: resourceParts.host,
+        resource_path: resourceParts.path,
+        has_client_id: !!req.body?.client_id,
+        has_client_secret: !!req.body?.client_secret,
+        has_code_verifier: !!req.body?.code_verifier,
+        has_redirect_uri: !!req.body?.redirect_uri
+      });
+    }
+    if (req.body?.resource && !URL.canParse(req.body.resource)) {
+      delete req.body.resource;
+    }
+    const clientId2 = queryValue(req.body?.client_id);
+    const redirectUri = queryValue(req.body?.redirect_uri);
+    if (clientId2) {
+      provider.verifyAndRecover(clientId2, redirectUri && URL.canParse(redirectUri) ? redirectUri : void 0);
+    }
+    next();
+  });
+  if (OAUTH_DEBUG_LOGS) {
+    app.post("/register", express.json(), (req, res, next) => {
+      const redirectUris = arrayValue(req.body?.redirect_uris) ?? [];
+      logger.info({
+        event: "oauth_register_request_received",
+        req_id: res.locals["reqId"],
+        redirect_uri_count: redirectUris.length,
+        redirect_uri_hosts: [...new Set(redirectUris.map((uri) => urlParts2(uri).host).filter(Boolean))],
+        redirect_uri_paths: redirectUris.map((uri) => urlParts2(uri).path).filter(Boolean),
+        token_endpoint_auth_method: queryValue(req.body?.token_endpoint_auth_method) ?? null,
+        grant_types: arrayValue(req.body?.grant_types) ?? null,
+        response_types: arrayValue(req.body?.response_types) ?? null,
+        has_scope: typeof req.body?.scope === "string",
+        has_jwks_uri: typeof req.body?.jwks_uri === "string",
+        has_jwks: !!req.body?.jwks,
+        client_name: queryValue(req.body?.client_name) ?? null
+      });
+      next();
+    });
+  }
+  app.use("/authorize", express.urlencoded({ extended: false }), (req, _res, next) => {
+    const params = (req.method === "POST" ? req.body : req.query) ?? {};
+    const clientId2 = typeof params.client_id === "string" ? params.client_id : void 0;
+    const redirectUri = typeof params.redirect_uri === "string" ? params.redirect_uri : void 0;
+    const resource = typeof params.resource === "string" ? params.resource : void 0;
+    const redirectParts = urlParts2(redirectUri);
+    const resourceParts = urlParts2(resource);
+    if (OAUTH_DEBUG_LOGS) {
+      logger.info({
+        event: "oauth_authorize_request_received",
+        req_id: _res.locals["reqId"],
+        response_type: queryValue(params.response_type) ?? null,
+        client_id_len: clientId2?.length ?? 0,
+        redirect_uri_host: redirectParts.host,
+        redirect_uri_path: redirectParts.path,
+        resource_host: resourceParts.host,
+        resource_path: resourceParts.path,
+        has_state: typeof params.state === "string",
+        state_prefix: typeof params.state === "string" ? params.state.slice(0, 28) : null,
+        has_code_challenge: typeof params.code_challenge === "string",
+        code_challenge_method: queryValue(params.code_challenge_method) ?? null,
+        has_scope: typeof params.scope === "string"
+      });
+    }
+    if (clientId2 && redirectUri && URL.canParse(redirectUri)) {
+      provider.verifyAndRecover(clientId2, redirectUri);
+    }
+    next();
+  });
+  app.use(
+    mcpAuthRouter({
+      provider,
+      issuerUrl,
+      baseUrl: issuerUrl,
+      resourceServerUrl: new URL(mcpResourceUrl),
+      resourceName: "Plaud MCP Server"
+    })
+  );
+  app.post(
+    "/mcp",
+    requireBearerAuth({ verifier: provider, resourceMetadataUrl: protectedResourceMetadataUrl }),
+    async (req, res) => {
+      const token = req.auth.token;
+      const reqId = res.locals["reqId"] ?? randomUUID2();
+      const reqLog = logger.child({ req_id: reqId });
+      const startMs = Date.now();
+      reqLog.info({ event: "mcp_request_start", client_id: req.auth.clientId });
+      const client = new PlaudClient({
+        clientId,
+        clientSecret: "",
+        redirectUri: "",
+        apiBase,
+        staticToken: token
+      });
+      const mcpServer = new McpServer({ name: "plaud", version: "0.2.4" });
+      registerTools(mcpServer, client);
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0,
+        // stateless
+        enableDnsRebindingProtection: true,
+        allowedOrigins: ALLOWED_ORIGINS
+      });
+      try {
+        await mcpServer.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+        const clientVersion = mcpServer.server.getClientVersion();
+        if (clientVersion) {
+          reqLog.info({ event: "mcp_client_info", client_name: clientVersion.name, client_version: clientVersion.version });
+        }
+        reqLog.info({ event: "mcp_request_end", duration_ms: Date.now() - startMs });
+      } catch (err) {
+        reqLog.error({ event: "mcp_request_error", error: String(err), duration_ms: Date.now() - startMs });
+        if (!res.headersSent) {
+          res.status(500).json({ error: String(err) });
+        }
+      } finally {
+        await mcpServer.close();
+      }
+    }
+  );
+  if (!process.env.PLAUD_CALLBACK_URL) {
+    const callbackApp = express();
+    callbackApp.get(CALLBACK_PATH, (req, res) => {
+      const code = req.query["code"];
+      const state = req.query["state"];
+      if (!code || !state) {
+        logger.warn({ event: "oauth_callback_invalid", code: !!code, state: !!state });
+        res.status(400).send("Missing code or state");
+        return;
+      }
+      provider.handleCallback(code, state, res);
+    });
+    createServer(callbackApp).listen(CALLBACK_PORT, "localhost", () => {
+      logger.info({ event: "server_start", role: "oauth_callback", url: CALLBACK_URL });
+    });
+  }
+  app.listen(HTTP_PORT, HTTP_HOST, () => {
+    logger.info({
+      event: "server_start",
+      role: "mcp_http",
+      url: serverUrl,
+      mcp_endpoint: `${serverUrl}/mcp`,
+      oauth_metadata: `${serverUrl}/.well-known/oauth-authorization-server`
+    });
+  });
+}
+export {
+  startHttpServer
+};