@plaud-ai/mcp 0.1.32 → 0.1.58

package/dist/{chunk-5JTZ7NKP.js → chunk-7PYQFJJW.js}

@@ -1,33 +1,3 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
 // src/skills.ts
 var SKILLS = [
   {
@@ -136,9 +106,6 @@ var ACTIVE_SKILLS = SKILLS.filter((s) => s.supported !== false);
 var SKILLS_COMBINED = ACTIVE_SKILLS.map((s) => s.content).join("\n\n---\n\n");
 
 export {
-  __commonJS,
-  __export,
-  __toESM,
   ACTIVE_SKILLS,
   SKILLS_COMBINED
 };

package/dist/chunk-YMQLKZLW.js

@@ -0,0 +1,334 @@
+// ../shared/dist/oauth.js
+import { randomBytes, createHash } from "crypto";
+
+// ../shared/dist/token-store.js
+import { readFile, writeFile, mkdir, rm } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+var TokenStore = class {
+  configDir;
+  tokenPath;
+  constructor(filename = "tokens.json") {
+    this.configDir = join(homedir(), ".plaud");
+    this.tokenPath = join(this.configDir, filename);
+  }
+  async save(tokenSet) {
+    await mkdir(this.configDir, { recursive: true });
+    await writeFile(this.tokenPath, JSON.stringify(tokenSet, null, 2), "utf-8");
+  }
+  async load() {
+    try {
+      const data = await readFile(this.tokenPath, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  async clear() {
+    try {
+      await rm(this.tokenPath);
+    } catch {
+    }
+  }
+};
+
+// ../shared/dist/oauth.js
+var DEFAULT_AUTHORIZATION_URL = "https://web.plaud.ai/platform/oauth";
+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";
+function generateCodeVerifier() {
+  return randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return createHash("sha256").update(verifier).digest("base64url");
+}
+function generateState() {
+  return randomBytes(16).toString("base64url");
+}
+var OAuth = class {
+  config;
+  tokenStore;
+  authorizationUrl;
+  tokenUrl;
+  refreshUrl;
+  constructor(config) {
+    this.config = config;
+    this.tokenStore = new TokenStore(config.tokenFile);
+    this.authorizationUrl = config.authorizationUrl ?? DEFAULT_AUTHORIZATION_URL;
+    this.tokenUrl = config.tokenUrl ?? DEFAULT_TOKEN_URL;
+    this.refreshUrl = config.refreshUrl ?? DEFAULT_REFRESH_URL;
+  }
+  createAuthorizationRequest() {
+    const codeVerifier = generateCodeVerifier();
+    const codeChallenge = generateCodeChallenge(codeVerifier);
+    const state = generateState();
+    const params = new URLSearchParams({
+      client_id: this.config.clientId,
+      redirect_uri: this.config.redirectUri,
+      response_type: "code",
+      code_challenge: codeChallenge,
+      code_challenge_method: "S256",
+      state
+    });
+    return {
+      url: `${this.authorizationUrl}?${params.toString()}`,
+      codeVerifier,
+      state
+    };
+  }
+  /**
+   * @deprecated Use createAuthorizationRequest() for PKCE flow
+   */
+  getAuthorizationUrl() {
+    return this.createAuthorizationRequest().url;
+  }
+  async exchangeCode(code, codeVerifier, state) {
+    const basicAuth = Buffer.from(`${this.config.clientId}:${this.config.clientSecret}`).toString("base64");
+    const body = {
+      code,
+      redirect_uri: this.config.redirectUri
+    };
+    if (codeVerifier) {
+      body.code_verifier = codeVerifier;
+    }
+    if (state) {
+      body.state = state;
+    }
+    const res = await fetch(this.tokenUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        Authorization: `Basic ${basicAuth}`,
+        ...this.config.extraHeaders
+      },
+      body: new URLSearchParams(body)
+    });
+    if (!res.ok) {
+      throw new Error(`Token exchange failed: ${res.status} ${await res.text()}`);
+    }
+    const data = await res.json();
+    const tokenSet = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token,
+      token_type: data.token_type ?? "Bearer",
+      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+    await this.tokenStore.save(tokenSet);
+    return tokenSet;
+  }
+  async getAccessToken() {
+    const tokenSet = await this.tokenStore.load();
+    if (!tokenSet)
+      return null;
+    if (tokenSet.expires_at && Date.now() > tokenSet.expires_at - 6e4) {
+      if (tokenSet.refresh_token) {
+        try {
+          const refreshed = await this.refresh(tokenSet.refresh_token);
+          return refreshed.access_token;
+        } catch {
+          return null;
+        }
+      }
+      return null;
+    }
+    return tokenSet.access_token;
+  }
+  async refresh(refreshToken) {
+    const res = await fetch(this.refreshUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: "application/json",
+        ...this.config.extraHeaders
+      },
+      body: new URLSearchParams({
+        refresh_token: refreshToken
+      })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Token refresh failed: ${res.status} ${body}`);
+    }
+    const data = await res.json();
+    const tokenSet = {
+      access_token: data.access_token,
+      refresh_token: data.refresh_token ?? refreshToken,
+      token_type: data.token_type ?? "Bearer",
+      expires_at: data.expires_in ? Date.now() + data.expires_in * 1e3 : void 0
+    };
+    await this.tokenStore.save(tokenSet);
+    return tokenSet;
+  }
+  async logout() {
+    await this.tokenStore.clear();
+  }
+};
+
+// ../shared/dist/client.js
+var DEFAULT_API_BASE = "https://platform.plaud.ai/developer/api";
+var PlaudClient = class {
+  oauth;
+  apiBase;
+  extraHeaders;
+  staticToken;
+  constructor(config) {
+    this.oauth = new OAuth(config);
+    this.apiBase = config.apiBase ?? DEFAULT_API_BASE;
+    this.extraHeaders = config.extraHeaders ?? {};
+    this.staticToken = config.staticToken;
+  }
+  get auth() {
+    return this.oauth;
+  }
+  async request(path, init) {
+    const token = this.staticToken ?? await this.oauth.getAccessToken();
+    if (!token) {
+      throw new Error("Not authenticated. Please login first.");
+    }
+    const url = `${this.apiBase}${path}`;
+    const method = init?.method ?? "GET";
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/json",
+      ...this.extraHeaders,
+      ...init?.headers
+    };
+    const res = await fetch(url, { ...init, headers });
+    if (!res.ok) {
+      const body = await res.text();
+      if (res.status === 422) {
+        try {
+          const parsed = JSON.parse(body);
+          const messages = parsed.detail.map((d) => `${d.loc.at(-1)}: ${d.msg}`).join("; ");
+          throw new Error(messages);
+        } catch (e) {
+          if (e instanceof SyntaxError)
+            throw new Error(`API error: ${res.status} ${res.statusText}`);
+          throw e;
+        }
+      }
+      throw new Error(`API error: ${res.status} ${res.statusText}`);
+    }
+    const json = await res.json();
+    return json;
+  }
+  async getCurrentUser() {
+    return this.request("/open/third-party/users/current");
+  }
+  async revokeCurrentUser() {
+    await this.request("/open/third-party/users/current/revoke", {
+      method: "POST"
+    });
+  }
+  async listFiles(page = 1, pageSize = 20) {
+    return this.request(`/open/third-party/files/?page=${page}&page_size=${pageSize}`);
+  }
+  async getFile(fileId) {
+    return this.request(`/open/third-party/files/${fileId}`);
+  }
+};
+
+// src/logger.ts
+import pino from "pino";
+var logger = pino({
+  level: process.env.LOG_LEVEL ?? "info"
+});
+
+// src/tools/index.ts
+import { z } from "zod";
+function registerTools(server, client) {
+  server.tool(
+    "list_files",
+    "List Plaud recordings",
+    {
+      page: z.number().optional().default(1).describe("Page number"),
+      page_size: z.number().optional().default(20).describe("Items per page")
+    },
+    async ({ page, page_size }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "list_files" });
+      try {
+        const result = await client.listFiles(page, page_size);
+        logger.info({ event: "tool_call_end", tool: "list_files", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "list_files", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to list files: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_file",
+    "Get details of a specific Plaud recording by ID",
+    { file_id: z.string().describe("The file ID to retrieve") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_file", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_file", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file, null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_file", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get file: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_note",
+    "Fetch AI-generated notes for a Plaud recording \u2014 compact summary, action items, and key topics",
+    { file_id: z.string().describe("The file ID to retrieve notes for") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_note", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_note", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file.note_list ?? [], null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_note", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get note: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_transcript",
+    "Fetch the full timestamped transcript with speaker attribution for a Plaud recording",
+    { file_id: z.string().describe("The file ID to retrieve transcript for") },
+    async ({ file_id }) => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_transcript", file_id });
+      try {
+        const file = await client.getFile(file_id);
+        logger.info({ event: "tool_call_end", tool: "get_transcript", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(file.source_list ?? [], null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_transcript", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get transcript: ${err}` }], isError: true };
+      }
+    }
+  );
+  server.tool(
+    "get_current_user",
+    "Get current authenticated user info",
+    async () => {
+      const start = Date.now();
+      logger.info({ event: "tool_call", tool: "get_current_user" });
+      try {
+        const user = await client.getCurrentUser();
+        logger.info({ event: "tool_call_end", tool: "get_current_user", duration_ms: Date.now() - start });
+        return { content: [{ type: "text", text: JSON.stringify(user, null, 2) }] };
+      } catch (err) {
+        logger.error({ event: "tool_call_error", tool: "get_current_user", duration_ms: Date.now() - start, error: String(err) });
+        return { content: [{ type: "text", text: `Failed to get user info: ${err}` }], isError: true };
+      }
+    }
+  );
+}
+
+export {
+  PlaudClient,
+  logger,
+  registerTools
+};