@plaud-ai/mcp 0.1.32 → 0.1.58

package/dist/server-5L7BYLYR.js

@@ -0,0 +1,304 @@
+import {
+  PlaudClient,
+  logger,
+  registerTools
+} from "./chunk-YMQLKZLW.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 { 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 { randomUUID } from "crypto";
+import { ProxyOAuthServerProvider } from "@modelcontextprotocol/sdk/server/auth/providers/proxyProvider.js";
+var PlaudOAuthProvider = class extends ProxyOAuthServerProvider {
+  _plaudClientId;
+  _plaudClientSecret;
+  _plaudTokenUrl;
+  _plaudApiBase;
+  _callbackUrl;
+  _registeredClients = /* @__PURE__ */ new Map();
+  // internalState → { clientRedirectUri, originalState }
+  // We generate our own state to track the pending flow regardless of whether the client sent one.
+  _pendingStates = /* @__PURE__ */ new Map();
+  // code → internalState: lets exchangeAuthorizationCode include state in the Plaud token request
+  _pendingCodes = /* @__PURE__ */ new Map();
+  constructor(options) {
+    const authUrl = options.authUrl ?? "https://web.plaud.ai/platform/oauth";
+    const tokenUrl = options.tokenUrl ?? "https://platform.plaud.ai/developer/api/oauth/third-party/access-token";
+    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: options.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 Error("Invalid or expired token");
+        }
+      },
+      getClient: async (id) => this._registeredClients.get(id)
+    });
+    this._plaudClientId = options.clientId;
+    this._plaudClientSecret = options.clientSecret;
+    this._plaudTokenUrl = tokenUrl;
+    this._plaudApiBase = apiBase;
+    this._callbackUrl = options.callbackUrl;
+    this.skipLocalPkceValidation = true;
+  }
+  // Override clientsStore to add in-memory dynamic client registration
+  get clientsStore() {
+    return {
+      getClient: async (id) => this._registeredClients.get(id),
+      registerClient: async (client) => {
+        const full = {
+          ...client,
+          client_id: randomUUID(),
+          client_id_issued_at: Math.floor(Date.now() / 1e3)
+        };
+        this._registeredClients.set(full.client_id, full);
+        return full;
+      }
+    };
+  }
+  /**
+   * 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
+    });
+    logger.info({ event: "oauth_authorize_start", internal_state: internalState, redirect_uri: params.redirectUri });
+    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(" "));
+    targetUrl.search = searchParams.toString();
+    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);
+    this._pendingCodes.set(code, state);
+    logger.info({ event: "oauth_callback_received", internal_state: state });
+    const target = new URL(pending.clientRedirectUri);
+    target.searchParams.set("code", code);
+    if (pending.originalState) {
+      target.searchParams.set("state", pending.originalState);
+    }
+    res.redirect(target.toString());
+  }
+  // Override to use Plaud's Basic auth + our fixed callback URL for redirect_uri
+  async exchangeAuthorizationCode(_client, authorizationCode, codeVerifier, _redirectUri) {
+    const basicAuth = Buffer.from(
+      `${this._plaudClientId}:${this._plaudClientSecret}`
+    ).toString("base64");
+    const internalState = this._pendingCodes.get(authorizationCode);
+    this._pendingCodes.delete(authorizationCode);
+    const body = {
+      grant_type: "authorization_code",
+      code: authorizationCode,
+      redirect_uri: this._callbackUrl
+    };
+    if (codeVerifier) body.code_verifier = codeVerifier;
+    if (internalState) body.state = internalState;
+    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) {
+      const text = await fetchRes.text();
+      logger.error({ event: "oauth_token_exchange_failed", status: fetchRes.status, body: text });
+      throw new Error(`Token exchange failed: ${fetchRes.status} ${text}`);
+    }
+    const data = await fetchRes.json();
+    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
+    };
+  }
+};
+
+// 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}`;
+function startHttpServer() {
+  const clientId = process.env.PLAUD_MCP_CLIENT_ID ?? process.env.PLAUD_CLIENT_ID ?? "client_9c501dad-8a0d-40b2-a7b0-d1cb8787f674";
+  const clientSecret = process.env.PLAUD_CLIENT_SECRET ?? "";
+  const apiBase = process.env.PLAUD_API_BASE;
+  const serverUrl = process.env.PLAUD_SERVER_URL ?? `http://localhost:${HTTP_PORT}`;
+  const provider = new PlaudOAuthProvider({
+    clientId,
+    clientSecret,
+    callbackUrl: CALLBACK_URL,
+    authUrl: process.env.PLAUD_AUTH_URL,
+    tokenUrl: process.env.PLAUD_TOKEN_URL,
+    apiBase
+  });
+  const issuerUrl = new URL(serverUrl);
+  const app = createMcpExpressApp({ host: HTTP_HOST });
+  app.get("/health", (_req, res) => {
+    res.json({ status: "ok", uptime_s: Math.floor(process.uptime()) });
+  });
+  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();
+    res.locals["reqId"] = reqId;
+    logger.info({ event: "http_request", req_id: reqId, method: req.method, path: req.url, user_agent: req.headers["user-agent"] ?? null });
+    next();
+  });
+  app.post("/token", express.urlencoded({ extended: false }), (req, _res, next) => {
+    if (req.body?.resource && !URL.canParse(req.body.resource)) {
+      delete req.body.resource;
+    }
+    next();
+  });
+  app.use(
+    mcpAuthRouter({
+      provider,
+      issuerUrl,
+      baseUrl: issuerUrl,
+      resourceName: "Plaud MCP Server"
+    })
+  );
+  app.post(
+    "/mcp",
+    requireBearerAuth({ verifier: provider, resourceMetadataUrl: `${serverUrl}/.well-known/oauth-protected-resource` }),
+    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.1.0" });
+      registerTools(mcpServer, client);
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: void 0
+        // stateless
+      });
+      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();
+      }
+    }
+  );
+  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
+};

package/dist/{setup-3PYAGQRG.js → setup-KGUMS567.js}

@@ -1,6 +1,6 @@
 import {
   SKILLS_COMBINED
-} from "./chunk-5JTZ7NKP.js";
+} from "./chunk-7PYQFJJW.js";
 
 // src/setup.ts
 import { readFile, writeFile, mkdir, rm } from "fs/promises";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaud-ai/mcp",
-  "version": "0.1.32",
+  "version": "0.1.58",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -21,11 +21,14 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
+    "express": "^5.2.1",
     "open": "^10.2.0",
+    "pino": "^10.3.1",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@plaud-ai/shared": "workspace:*",
+    "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
     "typescript": "^5.7.0"
   }

package/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "plaud",
-  "version": "0.1.32",
+  "version": "0.1.58",
   "description": "Access your Plaud recordings in Claude",
   "author": {
     "name": "Plaud AI"