@plaud-ai/mcp 0.2.2 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plaud-ai/mcp",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
@@ -12,6 +12,14 @@
     ".mcp.json",
     "skills"
   ],
+  "scripts": {
+    "version:show": "node -p \"require('./package.json').version\"",
+    "prebuild": "node ../../scripts/sync-skills.mjs",
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist skills",
+    "prepublishOnly": "node -e \"const fs=require('fs'),v=require('./package.json').version,p=JSON.parse(fs.readFileSync('./plugin.json','utf8'));p.version=v;fs.writeFileSync('./plugin.json',JSON.stringify(p,null,2)+'\\n');\""
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "express": "^5.2.1",
@@ -20,16 +28,9 @@
     "zod": "^4.3.6"
   },
   "devDependencies": {
+    "@plaud-ai/shared": "workspace:*",
     "@types/express": "^5.0.6",
     "@types/node": "^25.5.0",
-    "typescript": "^5.7.0",
-    "@plaud-ai/shared": "0.1.0"
-  },
-  "scripts": {
-    "version:show": "node -p \"require('./package.json').version\"",
-    "prebuild": "node ../../scripts/sync-skills.mjs",
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist skills"
+    "typescript": "^5.7.0"
   }
-}
+}

package/plugin.json

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

package/dist/server-QWAZPBHU.js

@@ -1,293 +0,0 @@
-import {
-  logger,
-  registerTools
-} from "./chunk-IZKXHQM3.js";
-import {
-  PlaudClient
-} from "./chunk-SNSGVRCU.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;
-  _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();
-  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: "",
-          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._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);
-    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 PKCE public-client flow — no Basic auth, client_id sent in body.
-  async exchangeAuthorizationCode(_client, authorizationCode, codeVerifier, _redirectUri) {
-    const body = {
-      grant_type: "authorization_code",
-      client_id: this._plaudClientId,
-      code: authorizationCode,
-      redirect_uri: this._callbackUrl
-    };
-    if (codeVerifier) body.code_verifier = codeVerifier;
-    const fetchRes = await fetch(this._plaudTokenUrl, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/x-www-form-urlencoded",
-        Accept: "application/json"
-      },
-      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 ?? "client_37d250cb-50f8-4af1-8cd6-bc6711c5d684";
-  const apiBase = process.env.PLAUD_API_BASE;
-  const serverUrl = process.env.PLAUD_SERVER_URL ?? `http://localhost:${HTTP_PORT}`;
-  const provider = new PlaudOAuthProvider({
-    clientId,
-    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.2.2" });
-      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
-};