@plaud-ai/mcp 0.3.9 → 0.3.11

package/dist/{chunk-RUFCT6DQ.js → chunk-DIPROABB.js}

@@ -2,11 +2,12 @@
 import { Registry, Counter, Histogram, Gauge, collectDefaultMetrics } from "prom-client";
 var registry = new Registry();
 collectDefaultMetrics({ register: registry });
+var LATENCY_BUCKETS = [0.01, 0.05, 0.1, 0.25, 0.5, 0.75, 1, 1.5, 2, 3, 5, 10, 30];
 var httpRequestDuration = new Histogram({
   name: "http_request_duration_seconds",
   help: "HTTP request latency in seconds",
   labelNames: ["method", "handler", "status"],
-  buckets: [0.01, 0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+  buckets: LATENCY_BUCKETS,
   registers: [registry]
 });
 var httpRequestsInProgress = new Gauge({
@@ -25,7 +26,7 @@ var mcpToolDuration = new Histogram({
   name: "mcp_tool_duration_seconds",
   help: "MCP tool execution latency in seconds",
   labelNames: ["tool"],
-  buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10, 30],
+  buckets: LATENCY_BUCKETS,
   registers: [registry]
 });
 var oauthTokenRefresh = new Counter({
@@ -44,7 +45,7 @@ var httpClientDuration = new Histogram({
   name: "http_client_duration_seconds",
   help: "Outbound HTTP request latency in seconds",
   labelNames: ["host", "endpoint"],
-  buckets: [0.05, 0.1, 0.25, 0.5, 1, 2.5, 5, 10],
+  buckets: LATENCY_BUCKETS,
   registers: [registry]
 });
 

package/dist/{chunk-FSNFNJXH.js → chunk-O6BKY23H.js}

@@ -1,18 +1,19 @@
 import {
   capture,
   classifyError,
+  describeError,
   loadBlockContent,
   localDayEnd,
   localDayStart,
   parseApiTimestamp
-} from "./chunk-5NWKLF3V.js";
+} from "./chunk-VUPXBO2J.js";
 import {
   logger
-} from "./chunk-NPCCDRWQ.js";
+} from "./chunk-OEZV5MA4.js";
 import {
   mcpToolCalls,
   mcpToolDuration
-} from "./chunk-RUFCT6DQ.js";
+} from "./chunk-DIPROABB.js";
 
 // src/tools/index.ts
 import { z } from "zod";
@@ -20,6 +21,7 @@ import { randomUUID } from "crypto";
 var toolHooks = null;
 var MAX_FILTER_PAGES = 5;
 var FILTER_PAGE_SIZE = 100;
+var MIN_PAGE_SIZE = 10;
 var TRANSCRIPT_PAGE_SIZE = 50;
 var TRANSCRIPT_BLOCKS = ["transaction", "outline", "transaction_polish", "mark_memo"];
 var BLOCK_ITEMS_KEY = { mark_memo: "marks" };
@@ -38,7 +40,7 @@ async function resolveNotes(noteList) {
       } catch (err) {
         return {
           ...note,
-          data_content_error: err instanceof Error ? err.message : "Failed to fetch content from data_link"
+          data_content_error: err ? describeError(err) : "Failed to fetch content from data_link"
         };
       }
     })
@@ -114,8 +116,13 @@ function registerTools(server, client, hooks) {
         openWorldHint: true
       },
       inputSchema: {
-        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)"),
+        // Advertise the lower bound instead of making clients discover it:
+        // the API rejects page_size < 10 with a 422, and an unconstrained
+        // schema meant they learned that from a failed call (#670875).
+        // Deliberately NO upper bound — the API's real ceiling is unverified,
+        // and capping here would newly reject page sizes it may well accept.
+        page: z.number().int().min(1).optional().default(1).describe("Page number, 1-based (ignored when filters are set)"),
+        page_size: z.number().int().min(MIN_PAGE_SIZE).optional().default(20).describe(`Items per page, minimum ${MIN_PAGE_SIZE} (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, interpreted in the server's timezone"),
         date_to: z.string().optional().describe("End date inclusive, YYYY-MM-DD, interpreted in the server's timezone")
@@ -169,17 +176,17 @@ function registerTools(server, client, hooks) {
         };
       } catch (err) {
         recordToolMetric("list_files", "error", Date.now() - start, requestId, {}, 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 };
+        logger.error({ event: "tool_call_error", tool: "list_files", duration_ms: Date.now() - start, error: describeError(err) });
+        return { content: [{ type: "text", text: `Failed to list files: ${describeError(err)}` }], isError: true };
       }
     }
   );
   server.registerTool(
     "get_file",
     {
-      description: "Get details of a specific Plaud recording by ID",
+      description: "Get the full record for a Plaud recording: metadata, the audio download URL, and an inventory of its transcript blocks and notes. This is the tool that returns audio \u2014 `presigned_url` is a signed link to the recording's audio file, valid 24h, and is how you download it or hand the user a download link. Call this whenever the user asks for the audio, the download link, or the recording file itself; use get_transcript or get_note to read transcript or note bodies instead.",
       annotations: {
-        title: "Get recording details",
+        title: "Get recording details and audio download URL",
         readOnlyHint: true,
         destructiveHint: false,
         openWorldHint: true
@@ -214,8 +221,8 @@ Note: note_list ${linkedNotes.map((t) => `\`${t}\``).join(", ")} returned an emp
         return { content: [{ type: "text", text }] };
       } catch (err) {
         recordToolMetric("get_file", "error", Date.now() - start, requestId, { file_id }, 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 };
+        logger.error({ event: "tool_call_error", tool: "get_file", duration_ms: Date.now() - start, error: describeError(err) });
+        return { content: [{ type: "text", text: `Failed to get file: ${describeError(err)}` }], isError: true };
       }
     }
   );
@@ -243,8 +250,8 @@ Note: note_list ${linkedNotes.map((t) => `\`${t}\``).join(", ")} returned an emp
         return { content: [{ type: "text", text: JSON.stringify(notes, null, 2) }] };
       } catch (err) {
         recordToolMetric("get_note", "error", Date.now() - start, requestId, { file_id }, 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 };
+        logger.error({ event: "tool_call_error", tool: "get_note", duration_ms: Date.now() - start, error: describeError(err) });
+        return { content: [{ type: "text", text: `Failed to get note: ${describeError(err)}` }], isError: true };
       }
     }
   );
@@ -337,8 +344,8 @@ Note: note_list ${linkedNotes.map((t) => `\`${t}\``).join(", ")} returned an emp
         return { content: [{ type: "text", text: JSON.stringify(payload, null, 2) }] };
       } catch (err) {
         recordToolMetric("get_transcript", "error", Date.now() - start, requestId, { file_id }, 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 };
+        logger.error({ event: "tool_call_error", tool: "get_transcript", duration_ms: Date.now() - start, error: describeError(err) });
+        return { content: [{ type: "text", text: `Failed to get transcript: ${describeError(err)}` }], isError: true };
       }
     }
   );
@@ -364,8 +371,8 @@ Note: note_list ${linkedNotes.map((t) => `\`${t}\``).join(", ")} returned an emp
         return { content: [{ type: "text", text: JSON.stringify(user, null, 2) }] };
       } catch (err) {
         recordToolMetric("get_current_user", "error", Date.now() - start, requestId, {}, 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 };
+        logger.error({ event: "tool_call_error", tool: "get_current_user", duration_ms: Date.now() - start, error: describeError(err) });
+        return { content: [{ type: "text", text: `Failed to get user info: ${describeError(err)}` }], isError: true };
       }
     }
   );

package/dist/chunk-OEZV5MA4.js

@@ -0,0 +1,20 @@
+// src/logger.ts
+import pino from "pino";
+import { trace } from "@opentelemetry/api";
+var logger = pino(
+  {
+    level: process.env.LOG_LEVEL ?? "info",
+    // Tempo tracing (SOP §5⑤): stamp trace_id/span_id on every log line so logs
+    // can be found in OpenSearch by trace_id. No-op when no span is active
+    // (stdio mode, or OTEL_SDK_DISABLED=true).
+    mixin() {
+      const ctx = trace.getActiveSpan()?.spanContext();
+      return ctx ? { trace_id: ctx.traceId, span_id: ctx.spanId } : {};
+    }
+  },
+  pino.destination(2)
+);
+
+export {
+  logger
+};

package/dist/{chunk-EY5K2UXG.js → chunk-PZSLLSMX.js}

@@ -1,11 +1,11 @@
 import {
   PlaudClient,
   capture
-} from "./chunk-5NWKLF3V.js";
+} from "./chunk-VUPXBO2J.js";
 import {
   httpClientDuration,
   httpClientRequests
-} from "./chunk-RUFCT6DQ.js";
+} from "./chunk-DIPROABB.js";
 
 // src/config.ts
 function buildExtraHeaders() {

package/dist/{chunk-5NWKLF3V.js → chunk-VUPXBO2J.js}

@@ -32,6 +32,38 @@ function classifyError(err) {
     return "client_error";
   return "unknown";
 }
+function isTransportError(err) {
+  const type = classifyError(err);
+  return type === "network" || type === "timeout" || type === "server_error";
+}
+var MAX_CAUSE_DEPTH = 5;
+var MAX_DESCRIPTION_LENGTH = 400;
+function summarizeError(err) {
+  if (!(err instanceof Error))
+    return String(err ?? "unknown error");
+  const code = err.code;
+  const suffix = typeof code === "string" && !err.message.includes(code) ? ` (${code})` : "";
+  return `${err.name}: ${err.message}${suffix}`;
+}
+function describeError(err) {
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = err;
+  for (let depth = 0; depth < MAX_CAUSE_DEPTH && current && !seen.has(current); depth++) {
+    seen.add(current);
+    chain.push(summarizeError(current));
+    const aggregated = current instanceof AggregateError ? current.errors : void 0;
+    if (aggregated && aggregated.length > 0) {
+      chain.push(aggregated.map(summarizeError).join("; "));
+      break;
+    }
+    current = current instanceof Error ? current.cause : void 0;
+  }
+  const text = chain.join(" | cause: ");
+  if (text.length === 0)
+    return "unknown error";
+  return text.length > MAX_DESCRIPTION_LENGTH ? `${text.slice(0, MAX_DESCRIPTION_LENGTH - 1)}\u2026` : text;
+}
 function oauthCallbackErrorType(status) {
   switch (status) {
     case "denied":
@@ -176,6 +208,21 @@ var OAuth = class {
     await this.tokenStore.save(tokenSet);
     return tokenSet;
   }
+  /** Are there stored credentials? Local-only — never touches the network, so
+   *  logout can tell "nothing to do" from "cannot reach Plaud". */
+  async hasStoredToken() {
+    return await this.tokenStore.load() !== null;
+  }
+  /**
+   * The current access token, refreshing it first when it is about to expire.
+   *
+   * `null` means genuinely unauthenticated: nothing stored, no refresh token, or
+   * the refresh token was rejected. A transport failure instead THROWS — it says
+   * nothing about the credentials, and reporting it as unauthenticated is what
+   * pushed #670875's reporter into a re-login loop (and would have let callers
+   * delete a perfectly good token file). Callers that only want to know whether
+   * we are logged in should use `isTransportError` to tell the two apart.
+   */
   async getAccessToken() {
     const tokenSet = await this.tokenStore.load();
     if (!tokenSet)
@@ -185,8 +232,10 @@ var OAuth = class {
         try {
           const refreshed = await this.refresh(tokenSet.refresh_token);
           return refreshed.access_token;
-        } catch {
-          return null;
+        } catch (err) {
+          if (!isTransportError(err))
+            return null;
+          throw err;
         }
       }
       return null;
@@ -312,6 +361,46 @@ var PlaudClient = class {
   }
 };
 
+// ../shared/dist/proxy.js
+var PROXY_ENV_VARS = [
+  "HTTP_PROXY",
+  "http_proxy",
+  "HTTPS_PROXY",
+  "https_proxy",
+  "ALL_PROXY",
+  "all_proxy"
+];
+function proxyEnvVars(env = process.env) {
+  return PROXY_ENV_VARS.filter((key) => (env[key] ?? "").trim().length > 0);
+}
+async function installProxyDispatcher(env = process.env) {
+  const active = proxyEnvVars(env);
+  if (active.length === 0)
+    return null;
+  try {
+    const { EnvHttpProxyAgent, setGlobalDispatcher } = await import("undici");
+    setGlobalDispatcher(withoutExperimentalWarning(() => new EnvHttpProxyAgent()));
+    return active;
+  } catch {
+    return null;
+  }
+}
+function withoutExperimentalWarning(build) {
+  const original = process.emitWarning;
+  process.emitWarning = ((warning, ...rest) => {
+    const [first, second] = rest;
+    const code = typeof first === "object" && first !== null ? first.code : second;
+    if (code === "UNDICI-EHPA")
+      return;
+    return original.call(process, warning, ...rest);
+  });
+  try {
+    return build();
+  } finally {
+    process.emitWarning = original;
+  }
+}
+
 // ../shared/dist/oauth-callback-server.js
 import { createServer } from "http";
 var SUCCESS_HTML = '<!doctype html><html><head><meta charset="utf-8"><title>Plaud</title></head><body style="font-family:system-ui;padding:2rem;text-align:center;"><h1>Authorization successful!</h1><p>You can close this tab.</p></body></html>';
@@ -905,9 +994,12 @@ function extractIdentity(user) {
 
 export {
   classifyError,
+  isTransportError,
+  describeError,
   oauthCallbackErrorType,
   clientUserIdFromAccessToken,
   PlaudClient,
+  installProxyDispatcher,
   runOAuthCallback,
   loadBlockContent,
   parseApiTimestamp,

package/dist/index.js

@@ -1,29 +1,33 @@
 #!/usr/bin/env node
 import {
   getClient
-} from "./chunk-EY5K2UXG.js";
+} from "./chunk-PZSLLSMX.js";
 import {
   loadSkills
 } from "./chunk-242FRP4P.js";
 import {
   normalizeMcpHost,
   registerTools
-} from "./chunk-FSNFNJXH.js";
+} from "./chunk-O6BKY23H.js";
 import {
   capture,
   classifyError,
   clearUser,
   clientUserIdFromAccessToken,
+  describeError,
   extractIdentity,
   initTelemetry,
+  installProxyDispatcher,
   oauthCallbackErrorType,
   runOAuthCallback,
   setMcpHost,
   setUser,
   shutdown
-} from "./chunk-5NWKLF3V.js";
-import "./chunk-NPCCDRWQ.js";
-import "./chunk-RUFCT6DQ.js";
+} from "./chunk-VUPXBO2J.js";
+import {
+  logger
+} from "./chunk-OEZV5MA4.js";
+import "./chunk-DIPROABB.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -31,7 +35,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import open from "open";
 var server = new McpServer({
   name: "plaud",
-  version: "0.3.9"
+  version: "0.3.11"
 });
 var CALLBACK_PORT = 8199;
 var LOGIN_TIMEOUT_MS = 12e4;
@@ -39,7 +43,15 @@ server.registerTool("login", {
   description: "Log in, sign in, or authenticate with Plaud account via OAuth (opens browser)"
 }, async () => {
   const client = getClient();
-  const existingToken = await client.auth.getAccessToken();
+  let existingToken;
+  try {
+    existingToken = await client.auth.getAccessToken();
+  } catch (err) {
+    return {
+      content: [{ type: "text", text: `Cannot reach Plaud to check the saved credentials: ${describeError(err)}` }],
+      isError: true
+    };
+  }
   if (existingToken) {
     try {
       await client.getCurrentUser();
@@ -50,7 +62,7 @@ server.registerTool("login", {
         await client.auth.logout();
       } else {
         return {
-          content: [{ type: "text", text: `Failed to verify login state: ${msg}` }],
+          content: [{ type: "text", text: `Failed to verify login state: ${describeError(err)}` }],
           isError: true
         };
       }
@@ -124,8 +136,7 @@ server.registerTool("logout", {
   description: "Log out, sign out, revoke authorization, and disconnect from Plaud account"
 }, async () => {
   const client = getClient();
-  const existingToken = await client.auth.getAccessToken();
-  if (!existingToken) {
+  if (!await client.auth.hasStoredToken()) {
     return { content: [{ type: "text", text: "Already logged out." }] };
   }
   try {
@@ -155,10 +166,14 @@ async function registerSkillPrompts() {
   }
 }
 async function main() {
+  const proxied = await installProxyDispatcher();
+  if (proxied) {
+    logger.info({ event: "proxy_dispatcher_installed", proxy_env: proxied });
+  }
   const sub = process.argv[2];
   const sub2 = process.argv[3];
   if (sub === "install") {
-    const { runInstall } = await import("./install-RTIXREYV.js");
+    const { runInstall } = await import("./install-XYADZE7L.js");
     const args = process.argv.slice(3);
     const yes = args.some((a) => a === "--yes" || a === "-y");
     const noLogin = args.some((a) => a === "--no-login");
@@ -191,8 +206,8 @@ async function main() {
     return;
   }
   if (sub === "http") {
-    const { startHttpServer } = await import("./server-SYSE62NO.js");
-    const { startMetricsServer } = await import("./server-NKCNUA6P.js");
+    const { startHttpServer } = await import("./server-KMU2TWA5.js");
+    const { startMetricsServer } = await import("./server-P6CNPNJ6.js");
     startMetricsServer();
     startHttpServer();
     return;
@@ -217,7 +232,7 @@ Usage:
   try {
     await initTelemetry({
       surface: "mcp",
-      appVersion: "0.3.9",
+      appVersion: "0.3.11",
       transport: "stdio"
     });
   } catch {

package/dist/{install-RTIXREYV.js → install-XYADZE7L.js}

@@ -1,6 +1,6 @@
 import {
   getClient
-} from "./chunk-EY5K2UXG.js";
+} from "./chunk-PZSLLSMX.js";
 import {
   commandPathIsStale,
   copyToClipboard,
@@ -11,9 +11,11 @@ import {
   skillsCombined
 } from "./chunk-242FRP4P.js";
 import {
+  describeError,
+  isTransportError,
   runOAuthCallback
-} from "./chunk-5NWKLF3V.js";
-import "./chunk-RUFCT6DQ.js";
+} from "./chunk-VUPXBO2J.js";
+import "./chunk-DIPROABB.js";
 
 // src/install.ts
 import { createInterface } from "readline/promises";
@@ -489,7 +491,8 @@ async function runLogin() {
         }
       }
     }
-  } catch {
+  } catch (err) {
+    if (isTransportError(err)) return { status: "already-authed" };
     await client.auth.logout().catch(() => void 0);
   }
   const { url, codeVerifier, state } = client.auth.createAuthorizationRequest();
@@ -613,12 +616,19 @@ async function doLoginStep(nonInteractive) {
         if (msg.includes("401") || msg.includes("Not authenticated")) {
           console.log("  saved token was revoked server-side \u2014 clearing and re-authenticating.");
           await client.auth.logout().catch(() => void 0);
+        } else if (isTransportError(err)) {
+          console.log(`  cannot reach Plaud to verify the saved login \u2014 keeping it: ${describeError(err)}`);
+          return { status: "already-authed" };
         } else {
           console.log("  token present but user lookup failed \u2014 will re-auth.");
         }
       }
     }
-  } catch {
+  } catch (err) {
+    if (isTransportError(err)) {
+      console.log(`  cannot reach Plaud to refresh the saved login \u2014 keeping it: ${describeError(err)}`);
+      return { status: "already-authed" };
+    }
   }
   if (!nonInteractive) {
     const yes = await prompt("Log in to Plaud now? (opens browser)", true);

package/dist/instrumentation.js

@@ -0,0 +1,54 @@
+// src/instrumentation.ts
+import { NodeSDK } from "@opentelemetry/sdk-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-grpc";
+import { HttpInstrumentation } from "@opentelemetry/instrumentation-http";
+import { ExpressInstrumentation } from "@opentelemetry/instrumentation-express";
+import { UndiciInstrumentation } from "@opentelemetry/instrumentation-undici";
+var URL_ATTRIBUTES = ["http.url", "url.full", "http.target", "url.query"];
+function redactUrl(url) {
+  const q = url.indexOf("?");
+  return q === -1 ? url : `${url.slice(0, q)}?REDACTED`;
+}
+function redactSpanUrlAttributes(span) {
+  const attrs = span.attributes;
+  for (const key of URL_ATTRIBUTES) {
+    const value = attrs[key];
+    if (typeof value !== "string" || value === "") continue;
+    attrs[key] = key === "url.query" ? "REDACTED" : redactUrl(value);
+  }
+}
+var RedactingSpanExporter = class {
+  constructor(inner) {
+    this.inner = inner;
+  }
+  inner;
+  export(spans, resultCallback) {
+    for (const span of spans) redactSpanUrlAttributes(span);
+    this.inner.export(spans, resultCallback);
+  }
+  shutdown() {
+    return this.inner.shutdown();
+  }
+  forceFlush() {
+    return this.inner.forceFlush?.() ?? Promise.resolve();
+  }
+};
+var sdk = new NodeSDK({
+  traceExporter: new RedactingSpanExporter(new OTLPTraceExporter()),
+  instrumentations: [
+    new HttpInstrumentation(),
+    // inbound server spans
+    new ExpressInstrumentation(),
+    // route-level spans
+    new UndiciInstrumentation()
+    // outbound: native fetch, injects traceparent
+  ]
+});
+sdk.start();
+process.on("SIGTERM", () => sdk.shutdown().catch(() => {
+}));
+export {
+  RedactingSpanExporter,
+  redactSpanUrlAttributes,
+  redactUrl
+};