@plaud-ai/mcp 0.3.2 → 0.3.4

package/dist/chunk-D2JZW2TW.js

@@ -0,0 +1,832 @@
+// ../shared/dist/errors.js
+function errorTypeFromStatus(status) {
+  if (status === 401)
+    return "auth";
+  if (status === 403)
+    return "permission";
+  if (status === 404)
+    return "not_found";
+  if (status >= 500)
+    return "server_error";
+  if (status >= 400)
+    return "client_error";
+  return "unknown";
+}
+function classifyError(err) {
+  const e = err instanceof Error ? err : void 0;
+  const msg = e ? e.message : String(err ?? "");
+  const name = e ? e.name : "";
+  if (name === "AbortError" || /\btimeout\b|ETIMEDOUT/i.test(msg))
+    return "timeout";
+  if (err instanceof TypeError || /fetch failed|ECONNREFUSED|ENOTFOUND|ECONNRESET|EAI_AGAIN|network/i.test(msg))
+    return "network";
+  if (/\b401\b|not authenticated|unauthorized/i.test(msg))
+    return "auth";
+  if (/\b403\b|forbidden/i.test(msg))
+    return "permission";
+  if (/\b404\b|not found/i.test(msg))
+    return "not_found";
+  if (/\b5\d\d\b|internal server error|bad gateway|service unavailable|gateway timeout/i.test(msg))
+    return "server_error";
+  if (/\b4\d\d\b/.test(msg))
+    return "client_error";
+  return "unknown";
+}
+function oauthCallbackErrorType(status) {
+  switch (status) {
+    case "denied":
+      return "user_cancel";
+    case "timeout":
+      return "timeout";
+    case "exchange-failed":
+      return "server_error";
+    case "listen-failed":
+      return "internal";
+    default:
+      return "unknown";
+  }
+}
+
+// ../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 state2 = 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: state2
+    });
+    return {
+      url: `${this.authorizationUrl}?${params.toString()}`,
+      codeVerifier,
+      state: state2
+    };
+  }
+  /**
+   * @deprecated Use createAuthorizationRequest() for PKCE flow
+   */
+  getAuthorizationUrl() {
+    return this.createAuthorizationRequest().url;
+  }
+  async exchangeCode(code, codeVerifier, state2) {
+    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 (state2) {
+      body.state = state2;
+    }
+    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) {
+    let res;
+    try {
+      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
+        })
+      });
+    } catch (err) {
+      this.config.onTokenRefresh?.("error", "network");
+      throw err;
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      this.config.onTokenRefresh?.("error", errorTypeFromStatus(res.status));
+      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);
+    this.config.onTokenRefresh?.("success");
+    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;
+  onRequest;
+  constructor(config) {
+    this.oauth = new OAuth(config);
+    this.apiBase = config.apiBase ?? DEFAULT_API_BASE;
+    this.extraHeaders = config.extraHeaders ?? {};
+    this.staticToken = config.staticToken;
+    this.onRequest = config.onRequest;
+  }
+  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 start = Date.now();
+    const res = await fetch(url, { ...init, headers });
+    if (this.onRequest) {
+      try {
+        const parsed = new URL(url);
+        this.onRequest({
+          host: parsed.host,
+          path: parsed.pathname,
+          method,
+          status: res.status,
+          durationMs: Date.now() - start
+        });
+      } catch {
+      }
+    }
+    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}`);
+  }
+};
+
+// ../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>';
+var NEUTRAL_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>Continue authorization in the original window.</h1><p>This page can be closed.</p></body></html>';
+function errorHtml(message) {
+  const escaped = message.replace(/[&<>]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;" })[c]);
+  return '<!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 failed</h1><pre style="white-space:pre-wrap;">' + escaped + "</pre></body></html>";
+}
+var CORS_HEADERS = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, OPTIONS",
+  "Access-Control-Allow-Headers": "*"
+};
+function runOAuthCallback(opts) {
+  const { port, expectedState, exchangeCode, timeoutMs = 12e4, onListening, postSuccessDelayMs = 1500 } = opts;
+  return new Promise((resolve) => {
+    let settled = false;
+    let exchangeStarted = false;
+    let exchangeSucceeded = false;
+    let timeoutId = null;
+    let closeTimeoutId = null;
+    const server = createServer((req, res) => {
+      if (req.method === "OPTIONS") {
+        res.writeHead(204, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      const reqUrl = new URL(req.url ?? "/", `http://localhost:${port}`);
+      if (reqUrl.pathname !== "/auth/callback") {
+        res.writeHead(404, CORS_HEADERS);
+        res.end();
+        return;
+      }
+      const params = reqUrl.searchParams;
+      const error = params.get("error");
+      const state2 = params.get("state");
+      const code = params.get("code");
+      if (error) {
+        const desc = params.get("error_description") ?? error;
+        res.writeHead(400, { "Content-Type": "text/html", ...CORS_HEADERS });
+        res.end(errorHtml(`Authorization denied: ${desc}`));
+        finalize({ status: "denied", error: new Error(desc) });
+        return;
+      }
+      if (!state2 || state2 !== expectedState) {
+        respondNeutral(res);
+        return;
+      }
+      if (exchangeSucceeded) {
+        respondSuccess(res);
+        return;
+      }
+      if (!code) {
+        respondNeutral(res);
+        return;
+      }
+      if (exchangeStarted) {
+        respondNeutral(res);
+        return;
+      }
+      exchangeStarted = true;
+      exchangeCode(code).then(() => {
+        exchangeSucceeded = true;
+        respondSuccess(res);
+        finalize({ status: "success" });
+      }, (err) => {
+        const e = err instanceof Error ? err : new Error(String(err));
+        res.writeHead(500, { "Content-Type": "text/html", ...CORS_HEADERS });
+        res.end(errorHtml(e.message));
+        finalize({ status: "exchange-failed", error: e });
+      });
+    });
+    server.on("error", (err) => {
+      if (settled)
+        return;
+      const message = err.code === "EADDRINUSE" ? `port ${port} is in use \u2014 another \`plaud login\` may still be running. Wait a few seconds and retry.` : `callback server error: ${err.message}`;
+      finalize({ status: "listen-failed", error: new Error(message) }, true);
+    });
+    timeoutId = setTimeout(() => {
+      finalize({ status: "timeout" }, true);
+    }, timeoutMs);
+    server.listen(port, () => {
+      onListening?.();
+    });
+    function respondSuccess(res) {
+      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
+      res.end(SUCCESS_HTML);
+    }
+    function respondNeutral(res) {
+      res.writeHead(200, { "Content-Type": "text/html", ...CORS_HEADERS });
+      res.end(NEUTRAL_HTML);
+    }
+    function finalize(result, immediate = false) {
+      if (settled)
+        return;
+      settled = true;
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+        timeoutId = null;
+      }
+      const close = () => {
+        try {
+          server.closeAllConnections?.();
+        } catch {
+        }
+        server.close(() => resolve(result));
+      };
+      if (immediate || result.status !== "success") {
+        close();
+      } else {
+        closeTimeoutId = setTimeout(close, postSuccessDelayMs);
+        closeTimeoutId.unref?.();
+      }
+    }
+  });
+}
+
+// ../telemetry/dist/client.js
+import { PostHog } from "posthog-node";
+
+// ../telemetry/dist/config.js
+var DEFAULT_HOST = "https://us.i.posthog.com";
+function isTruthyEnv(value) {
+  if (!value)
+    return false;
+  return ["1", "true", "yes", "on"].includes(value.toLowerCase());
+}
+function loadConfig() {
+  if (isTruthyEnv(process.env.DO_NOT_TRACK)) {
+    return {
+      apiKey: null,
+      host: DEFAULT_HOST,
+      optedOut: true,
+      optOutReason: "DO_NOT_TRACK is set"
+    };
+  }
+  if (isTruthyEnv(process.env.PLAUD_TELEMETRY_DISABLED)) {
+    return {
+      apiKey: null,
+      host: DEFAULT_HOST,
+      optedOut: true,
+      optOutReason: "PLAUD_TELEMETRY_DISABLED is set"
+    };
+  }
+  const apiKey = "phc_Be6wE0Vfi6lsbbfKfl4tgpzqKkB1UG29ddOlSA6B8NW";
+  const host = process.env.PLAUD_POSTHOG_HOST ?? DEFAULT_HOST;
+  return { apiKey, host, optedOut: false, optOutReason: null };
+}
+
+// ../telemetry/dist/client.js
+var FLUSH_AT = 5;
+var FLUSH_INTERVAL_MS = 1e3;
+var SHUTDOWN_TIMEOUT_MS = 3e3;
+var cachedClient = null;
+var cachedConfig = null;
+var initialised = false;
+function ensureInit() {
+  if (initialised)
+    return;
+  initialised = true;
+  cachedConfig = loadConfig();
+  if (cachedConfig.optedOut)
+    return;
+  if (!cachedConfig.apiKey)
+    return;
+  cachedClient = new PostHog(cachedConfig.apiKey, {
+    host: cachedConfig.host,
+    flushAt: FLUSH_AT,
+    flushInterval: FLUSH_INTERVAL_MS,
+    disableGeoip: true
+  });
+}
+function getClient() {
+  ensureInit();
+  return cachedClient;
+}
+async function shutdown() {
+  if (!cachedClient)
+    return;
+  const client = cachedClient;
+  cachedClient = null;
+  await Promise.race([
+    client.shutdown(),
+    new Promise((resolve) => setTimeout(resolve, SHUTDOWN_TIMEOUT_MS))
+  ]);
+}
+
+// ../telemetry/dist/api.js
+import { release as osRelease } from "os";
+
+// ../telemetry/dist/filter.js
+var EMAIL_REGEX = /[\w.+-]+@[\w-]+\.[\w.-]+/;
+var ALLOWED_PROPERTIES = /* @__PURE__ */ new Set([
+  // Global common properties (Plaud Common Event Properties + Spec §2)
+  "user_id",
+  "member_id",
+  // fill-if-present; OAuth /users/current doesn't return it yet (Q16)
+  "workspace_id",
+  // fill-if-present (Q18)
+  "role",
+  // workspace role, fill-if-present (Q44, 06-05 DA-added common prop)
+  "device_id",
+  "platform",
+  "os",
+  "os_version",
+  "app_version",
+  // Application surface
+  "transport",
+  // stdio | http
+  "mcp_host",
+  // claude_desktop | cursor | chatgpt | other
+  "dcr_client_id",
+  // OAuth Dynamic Client Registration id (HTTP MCP only)
+  // Per-call business properties
+  "duration_ms",
+  "status",
+  // success | failed
+  "error_type",
+  // Event Tracking Hub: auth|permission|not_found|timeout|network|server_error|client_error|user_cancel|internal|unknown
+  "failure_kind",
+  // legacy alias of error_type (kept allow-listed; error_type is canonical)
+  "file_id",
+  "passive",
+  // true | false
+  "request_id",
+  // per-invocation id; ties click ↔ success/error of one call (06-08)
+  // Event-discriminator props (generic event + name, per 06-04 decision):
+  // mcp:tool:* + tool_name, cli:command:* + command_name
+  "tool",
+  "command",
+  "tool_name",
+  "command_name",
+  // Pagination / result metadata
+  "page",
+  "page_size",
+  "total",
+  "count",
+  "scanned",
+  "matched",
+  "truncated",
+  "has_filter"
+]);
+var BANNED_PROPERTIES = /* @__PURE__ */ new Set([
+  // Direct PII (OAuth /users/current returns email + nickname inline — see Q16.1)
+  "email",
+  "email_hash",
+  "nickname",
+  "name",
+  "full_name",
+  "avatar",
+  "phone",
+  "phone_number",
+  "address",
+  "ip",
+  "ip_address",
+  // Credentials
+  "password",
+  "token",
+  "access_token",
+  "refresh_token",
+  "api_key",
+  "secret",
+  "credit_card",
+  "card_number",
+  "cvv",
+  "ssn",
+  // User-generated content (Plaud's core business deals with these)
+  "file_name",
+  "filename",
+  "title",
+  "file_title",
+  "transcript",
+  "transcript_text",
+  "summary",
+  "summary_text",
+  "note",
+  "note_content",
+  "content",
+  "message",
+  "text"
+]);
+function filterProperties(props) {
+  const filtered = {};
+  const dropped = [];
+  if (!props)
+    return { filtered, dropped };
+  for (const [key, value] of Object.entries(props)) {
+    if (key.startsWith("$")) {
+      dropped.push(key);
+      continue;
+    }
+    if (BANNED_PROPERTIES.has(key)) {
+      dropped.push(key);
+      continue;
+    }
+    if (!ALLOWED_PROPERTIES.has(key)) {
+      dropped.push(key);
+      continue;
+    }
+    if (typeof value === "string" && EMAIL_REGEX.test(value)) {
+      dropped.push(key);
+      continue;
+    }
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      dropped.push(key);
+      continue;
+    }
+    filtered[key] = value;
+  }
+  return { filtered, dropped };
+}
+
+// ../telemetry/dist/identity.js
+import { randomUUID } from "crypto";
+import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, rm as rm2 } from "fs/promises";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var CONFIG_DIR = join2(homedir2(), ".plaud");
+var ANONYMOUS_ID_PATH = join2(CONFIG_DIR, "anonymous_id");
+var DEVICE_ID_PATH = join2(CONFIG_DIR, "device_id");
+function userIdentityPath(surface) {
+  return join2(CONFIG_DIR, `telemetry-user-${surface}.json`);
+}
+var UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+var cachedAnonymousId = null;
+var cachedDeviceId = null;
+async function readOrCreateId(path) {
+  try {
+    const data = (await readFile2(path, "utf8")).trim();
+    if (UUID_V4_REGEX.test(data))
+      return data;
+  } catch {
+  }
+  const id = randomUUID();
+  await mkdir2(CONFIG_DIR, { recursive: true });
+  await writeFile2(path, id, "utf8");
+  return id;
+}
+async function getDeviceId() {
+  if (cachedDeviceId)
+    return cachedDeviceId;
+  cachedDeviceId = await readOrCreateId(DEVICE_ID_PATH);
+  return cachedDeviceId;
+}
+async function getAnonymousId() {
+  if (cachedAnonymousId)
+    return cachedAnonymousId;
+  cachedAnonymousId = await readOrCreateId(ANONYMOUS_ID_PATH);
+  return cachedAnonymousId;
+}
+async function clearAnonymousId() {
+  cachedAnonymousId = null;
+  try {
+    await rm2(ANONYMOUS_ID_PATH);
+  } catch {
+  }
+}
+async function saveUserIdentity(surface, userId, identity) {
+  const payload = { userId, identity };
+  await mkdir2(CONFIG_DIR, { recursive: true });
+  await writeFile2(userIdentityPath(surface), JSON.stringify(payload), "utf8");
+}
+async function loadUserIdentity(surface) {
+  try {
+    const parsed = JSON.parse(await readFile2(userIdentityPath(surface), "utf8"));
+    if (parsed && typeof parsed.userId === "string" && parsed.userId.length > 0) {
+      return {
+        userId: parsed.userId,
+        identity: typeof parsed.identity === "object" && parsed.identity !== null ? parsed.identity : void 0
+      };
+    }
+  } catch {
+  }
+  return null;
+}
+async function clearUserIdentity(surface) {
+  try {
+    await rm2(userIdentityPath(surface));
+  } catch {
+  }
+}
+
+// ../telemetry/dist/api.js
+var state = {
+  initialised: false,
+  surface: null,
+  appVersion: null,
+  transport: null,
+  deviceId: null,
+  currentUserId: null,
+  currentDistinctId: null,
+  memberId: null,
+  workspaceId: null,
+  role: null,
+  mcpHost: null
+};
+async function initTelemetry(options) {
+  state.surface = options.surface;
+  state.appVersion = options.appVersion;
+  state.transport = options.transport ?? null;
+  state.deviceId = await getDeviceId();
+  let userId = options.userId ?? null;
+  let identity = options.identity;
+  if (!userId) {
+    const persisted = await loadUserIdentity(options.surface);
+    if (persisted) {
+      userId = persisted.userId;
+      identity = identity ?? persisted.identity;
+    }
+  }
+  state.currentUserId = userId;
+  state.memberId = identity?.memberId ?? null;
+  state.workspaceId = identity?.workspaceId ?? null;
+  state.role = identity?.role ?? null;
+  state.currentDistinctId = identity?.idHash || userId || await getAnonymousId();
+  state.initialised = true;
+}
+async function setUser(userId, identity) {
+  if (!state.initialised)
+    return;
+  state.currentUserId = userId;
+  state.currentDistinctId = identity?.idHash || userId;
+  state.memberId = identity?.memberId ?? null;
+  state.workspaceId = identity?.workspaceId ?? null;
+  state.role = identity?.role ?? null;
+  if (state.surface) {
+    try {
+      await saveUserIdentity(state.surface, userId, identity);
+    } catch {
+    }
+  }
+  const client = getClient();
+  if (!client)
+    return;
+  const anonymousId = await getAnonymousId();
+  if (anonymousId === state.currentDistinctId)
+    return;
+  try {
+    client.alias({
+      distinctId: state.currentDistinctId,
+      alias: anonymousId
+    });
+  } catch {
+  }
+}
+async function clearUser() {
+  state.currentUserId = null;
+  state.memberId = null;
+  state.workspaceId = null;
+  state.role = null;
+  if (state.surface) {
+    try {
+      await clearUserIdentity(state.surface);
+    } catch {
+    }
+  }
+  await clearAnonymousId();
+  state.currentDistinctId = state.initialised ? await getAnonymousId() : null;
+}
+function setMcpHost(host) {
+  state.mcpHost = host && host.length > 0 ? host : null;
+}
+function capture(event, props) {
+  if (!state.initialised)
+    return;
+  if (!state.currentDistinctId)
+    return;
+  const client = getClient();
+  if (!client)
+    return;
+  const merged = { ...buildCommonProperties(), ...props ?? {} };
+  const { filtered } = filterProperties(merged);
+  const safe = { ...filtered, $ip: "0.0.0.0" };
+  try {
+    client.capture({
+      distinctId: state.currentDistinctId,
+      event,
+      properties: safe
+    });
+  } catch {
+  }
+}
+function buildCommonProperties() {
+  const out = {
+    platform: state.surface,
+    app_version: state.appVersion,
+    os: process.platform,
+    os_version: osRelease()
+  };
+  if (state.deviceId)
+    out.device_id = state.deviceId;
+  if (state.transport)
+    out.transport = state.transport;
+  if (state.currentUserId)
+    out.user_id = state.currentUserId;
+  if (state.memberId)
+    out.member_id = state.memberId;
+  if (state.workspaceId)
+    out.workspace_id = state.workspaceId;
+  if (state.role)
+    out.role = state.role;
+  if (state.mcpHost)
+    out.mcp_host = state.mcpHost;
+  return out;
+}
+function extractIdentity(user) {
+  const str = (v) => typeof v === "string" && v.length > 0 ? v : void 0;
+  return {
+    idHash: str(user.id_hash),
+    memberId: str(user.member_id),
+    workspaceId: str(user.workspace_id),
+    role: str(user.role)
+  };
+}
+
+export {
+  classifyError,
+  oauthCallbackErrorType,
+  PlaudClient,
+  runOAuthCallback,
+  shutdown,
+  initTelemetry,
+  setUser,
+  clearUser,
+  setMcpHost,
+  capture,
+  extractIdentity
+};