@plaud-ai/mcp 0.1.32 → 0.2.0

package/dist/chunk-4QBEOJPX.js

@@ -0,0 +1,92 @@
+// src/skills.ts
+import { readdir, readFile } from "fs/promises";
+import { statSync } from "fs";
+import { join, dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function parseFrontmatter(raw) {
+  if (!raw.startsWith("---\n")) return { meta: {}, body: raw };
+  const end = raw.indexOf("\n---\n", 4);
+  if (end === -1) return { meta: {}, body: raw };
+  const yaml = raw.slice(4, end);
+  const body = raw.slice(end + 5);
+  const meta = {};
+  let currentKey = null;
+  for (const line of yaml.split("\n")) {
+    if (!line.trim()) continue;
+    const topMatch = line.match(/^([a-zA-Z_][\w-]*):\s*(.*)$/);
+    if (topMatch && !line.startsWith(" ")) {
+      const [, k, v] = topMatch;
+      currentKey = k;
+      if (v !== "") {
+        const unq = v.replace(/^["']|["']$/g, "");
+        meta[k] = unq;
+        currentKey = null;
+      } else {
+        meta[k] = {};
+      }
+    }
+  }
+  return { meta, body };
+}
+function findSkillsDir() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(here, "..", "skills"),
+    resolve(here, "..", "..", "skills")
+  ];
+  for (const c of candidates) {
+    try {
+      if (statSync(c).isDirectory()) return c;
+    } catch {
+    }
+  }
+  return candidates[0];
+}
+var cached = null;
+async function loadSkills() {
+  if (cached) return cached;
+  const dir = findSkillsDir();
+  let entries;
+  try {
+    entries = await readdir(dir);
+  } catch {
+    cached = [];
+    return cached;
+  }
+  const skills = [];
+  for (const name of entries) {
+    try {
+      const skillPath = join(dir, name, "SKILL.md");
+      const raw = await readFile(skillPath, "utf-8");
+      const { meta, body } = parseFrontmatter(raw);
+      const skillName = typeof meta.name === "string" ? meta.name : name;
+      const description = typeof meta.description === "string" ? meta.description : "";
+      const version = typeof meta.version === "string" ? meta.version : "0.0.0";
+      skills.push({
+        name: skillName,
+        version,
+        description,
+        body: body.trimStart(),
+        content: raw,
+        supported: true
+      });
+    } catch {
+    }
+  }
+  skills.sort((a, b) => {
+    if (a.name === "plaud-shared") return -1;
+    if (b.name === "plaud-shared") return 1;
+    return a.name.localeCompare(b.name);
+  });
+  cached = skills;
+  return cached;
+}
+async function skillsCombined() {
+  const skills = await loadSkills();
+  return skills.map((s) => s.content).join("\n\n---\n\n");
+}
+
+export {
+  loadSkills,
+  skillsCombined
+};

package/dist/chunk-7KGB7GSZ.js

@@ -0,0 +1,33 @@
+import {
+  PlaudClient
+} from "./chunk-SNSGVRCU.js";
+
+// src/config.ts
+function buildExtraHeaders() {
+  const headers = {};
+  if (process.env.PLAUD_ENV) headers["x-pld-env"] = process.env.PLAUD_ENV;
+  if (process.env.PLAUD_REGION) headers["x-pld-region"] = process.env.PLAUD_REGION;
+  return headers;
+}
+var CONFIG = {
+  clientId: process.env.PLAUD_MCP_CLIENT_ID ?? process.env.PLAUD_CLIENT_ID ?? "client_9c501dad-8a0d-40b2-a7b0-d1cb8787f674",
+  clientSecret: process.env.PLAUD_CLIENT_SECRET ?? "",
+  redirectUri: "http://localhost:8199/auth/callback",
+  tokenFile: "tokens-mcp.json",
+  apiBase: process.env.PLAUD_API_BASE,
+  authorizationUrl: process.env.PLAUD_AUTH_URL,
+  tokenUrl: process.env.PLAUD_TOKEN_URL,
+  refreshUrl: process.env.PLAUD_REFRESH_URL,
+  extraHeaders: buildExtraHeaders()
+};
+var client = null;
+function getClient() {
+  if (!client) {
+    client = new PlaudClient(CONFIG);
+  }
+  return client;
+}
+
+export {
+  getClient
+};

package/dist/chunk-MPCF6HMK.js

@@ -0,0 +1,151 @@
+// src/logger.ts
+import pino from "pino";
+var logger = pino(
+  { level: process.env.LOG_LEVEL ?? "info" },
+  pino.destination(2)
+);
+
+// src/tools/index.ts
+import { z } from "zod";
+var MAX_FILTER_PAGES = 5;
+var FILTER_PAGE_SIZE = 100;
+function parseDate(s) {
+  if (!s) return null;
+  const d = new Date(s);
+  if (Number.isNaN(d.getTime())) return null;
+  return d.getTime();
+}
+function registerTools(server, client) {
+  server.tool(
+    "list_files",
+    "List Plaud recordings. Supports optional client-side filtering: `query` (case-insensitive name substring), `date_from`/`date_to` (YYYY-MM-DD, inclusive). When any filter is set, paginates up to 5 pages \xD7 100 recordings and returns all matches.",
+    {
+      page: z.number().optional().default(1).describe("Page number (ignored when filters are set)"),
+      page_size: z.number().optional().default(20).describe("Items per page (ignored when filters are set)"),
+      query: z.string().optional().describe("Case-insensitive substring match on recording name"),
+      date_from: z.string().optional().describe("Start date inclusive, YYYY-MM-DD"),
+      date_to: z.string().optional().describe("End date inclusive, YYYY-MM-DD")
+    },
+    async ({ page, page_size, query, date_from, date_to }) => {
+      const start = Date.now();
+      const hasFilter = Boolean(query || date_from || date_to);
+      logger.info({ event: "tool_call", tool: "list_files", has_filter: hasFilter });
+      try {
+        if (!hasFilter) {
+          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) }] };
+        }
+        const q = query?.toLowerCase();
+        const from = parseDate(date_from);
+        const toRaw = parseDate(date_to);
+        const to = toRaw !== null ? toRaw + 24 * 60 * 60 * 1e3 - 1 : null;
+        const matches = [];
+        let scanned = 0;
+        let truncated = false;
+        for (let p = 1; p <= MAX_FILTER_PAGES; p++) {
+          const pageResult = await client.listFiles(p, FILTER_PAGE_SIZE);
+          const items = pageResult.data;
+          scanned += items.length;
+          for (const item of items) {
+            if (q && !(item.name ?? "").toLowerCase().includes(q)) continue;
+            if (from !== null || to !== null) {
+              const created = parseDate(item.created_at);
+              if (created === null) continue;
+              if (from !== null && created < from) continue;
+              if (to !== null && created > to) continue;
+            }
+            matches.push(item);
+          }
+          if (items.length < FILTER_PAGE_SIZE) break;
+          if (p === MAX_FILTER_PAGES) truncated = true;
+        }
+        logger.info({ event: "tool_call_end", tool: "list_files", duration_ms: Date.now() - start, scanned, matched: matches.length, truncated });
+        return {
+          content: [{ type: "text", text: JSON.stringify({
+            data: matches,
+            scanned,
+            matched: matches.length,
+            truncated,
+            note: truncated ? `Scanned first ${MAX_FILTER_PAGES * FILTER_PAGE_SIZE} recordings; narrow filters for a complete match.` : void 0
+          }, 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 {
+  logger,
+  registerTools
+};

package/dist/chunk-SNSGVRCU.js

@@ -0,0 +1,234 @@
+// ../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}`);
+  }
+};
+
+export {
+  PlaudClient
+};

package/dist/chunk-UPEENHCG.js

@@ -0,0 +1,70 @@
+import {
+  skillsCombined
+} from "./chunk-4QBEOJPX.js";
+
+// src/install-utils.ts
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join, dirname } from "path";
+import { homedir, platform } from "os";
+import { spawnSync } from "child_process";
+var SKILLS_MARKER_START = "<!-- plaud-skills:start -->";
+var SKILLS_MARKER_END = "<!-- plaud-skills:end -->";
+function getMcpEntry() {
+  return {
+    command: "npx",
+    args: ["-y", "@plaud-ai/mcp@latest"]
+  };
+}
+function copyToClipboard(content) {
+  if (platform() === "win32") {
+    return spawnSync("clip", [], { input: content }).status === 0;
+  }
+  if (platform() === "darwin") {
+    return spawnSync("pbcopy", [], { input: content }).status === 0;
+  }
+  return false;
+}
+async function writeSkillsToClaudeCode() {
+  const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+  const combined = await skillsCombined();
+  const block = `${SKILLS_MARKER_START}
+${combined}
+${SKILLS_MARKER_END}`;
+  let existing = "";
+  try {
+    existing = await readFile(claudeMdPath, "utf-8");
+  } catch {
+  }
+  if (existing.includes(SKILLS_MARKER_START)) {
+    const updated = existing.replace(
+      new RegExp(`${SKILLS_MARKER_START}[\\s\\S]*?${SKILLS_MARKER_END}`),
+      block
+    );
+    await mkdir(dirname(claudeMdPath), { recursive: true });
+    await writeFile(claudeMdPath, updated, "utf-8");
+  } else {
+    await mkdir(dirname(claudeMdPath), { recursive: true });
+    await writeFile(claudeMdPath, existing + (existing.endsWith("\n") ? "" : "\n") + block + "\n", "utf-8");
+  }
+}
+async function removeSkillsFromClaudeCode() {
+  const claudeMdPath = join(homedir(), ".claude", "CLAUDE.md");
+  let existing = "";
+  try {
+    existing = await readFile(claudeMdPath, "utf-8");
+  } catch {
+    return;
+  }
+  if (!existing.includes(SKILLS_MARKER_START)) {
+    return;
+  }
+  const updated = existing.replace(new RegExp(`\\n?${SKILLS_MARKER_START}[\\s\\S]*?${SKILLS_MARKER_END}\\n?`), "").trimEnd();
+  await writeFile(claudeMdPath, updated ? updated + "\n" : "", "utf-8");
+}
+
+export {
+  getMcpEntry,
+  copyToClipboard,
+  writeSkillsToClaudeCode,
+  removeSkillsFromClaudeCode
+};