perplexity-user-mcp 0.8.36

package/dist/chunk-ZQFUZPLO.mjs

@@ -0,0 +1,257 @@
+import {
+  ensureDaemon
+} from "./chunk-X45O6YD3.mjs";
+import {
+  getPackageVersion
+} from "./chunk-S5VD7WTU.mjs";
+
+// src/daemon/client-http.ts
+import { randomUUID } from "crypto";
+import { statSync } from "fs";
+import { TextDecoder } from "util";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+async function exportHistoryViaDaemon(historyId, format, options = {}) {
+  const clientId = options.clientId ?? `daemon-export-${randomUUID()}`;
+  const result = await callDaemonTool(
+    "perplexity_export",
+    {
+      history_id: historyId,
+      format
+    },
+    { ...options, clientId }
+  );
+  const savedPath = extractBacktickedPath(result.text);
+  const bytes = statSync(savedPath).size;
+  return {
+    savedPath,
+    bytes,
+    contentType: getExportContentType(format)
+  };
+}
+async function syncCloudHistoryViaDaemon(options = {}) {
+  const clientId = options.clientId ?? `daemon-sync-${randomUUID()}`;
+  const daemon = await ensureDaemon(options);
+  const relay = options.onProgress ? await subscribeToToolProgress(daemon, clientId, "perplexity_sync_cloud", options.onProgress) : null;
+  try {
+    const result = await callDaemonTool(
+      "perplexity_sync_cloud",
+      options.pageSize ? { page_size: options.pageSize } : {},
+      // 5-minute budget covers limit=1000 (a few MB payload + 1000 upserts
+      // each writing a .md file). Far above the 60s SDK default which was
+      // firing as MCP error -32001 in 0.8.21.
+      { ...options, clientId, requestTimeoutMs: 5 * 60 * 1e3 }
+    );
+    await relay?.waitForPhase("done", 250).catch(() => void 0);
+    return parseCloudSyncResult(result.text);
+  } finally {
+    await relay?.close();
+  }
+}
+async function hydrateCloudHistoryEntryViaDaemon(historyId, options = {}) {
+  const clientId = options.clientId ?? `daemon-hydrate-${randomUUID()}`;
+  const result = await callDaemonTool(
+    "perplexity_hydrate_cloud_entry",
+    {
+      history_id: historyId
+    },
+    { ...options, clientId }
+  );
+  return parseHydrateResult(result.text);
+}
+async function callDaemonTool(name, args, options) {
+  const daemon = await ensureDaemon(options);
+  const clientId = options.clientId ?? `daemon-client-${randomUUID()}`;
+  const transport = new StreamableHTTPClientTransport(new URL(`${daemon.url}/mcp`), {
+    requestInit: {
+      headers: {
+        Authorization: `Bearer ${daemon.bearerToken}`,
+        "x-perplexity-client-id": clientId,
+        "x-perplexity-source": options.source ?? "loopback"
+      }
+    }
+  });
+  const client = new Client(
+    {
+      name: clientId,
+      version: getPackageVersion()
+    },
+    {
+      capabilities: {}
+    }
+  );
+  try {
+    await client.connect(transport);
+    const callToolOptions = options.requestTimeoutMs ? { timeout: options.requestTimeoutMs } : void 0;
+    const result = await client.callTool({ name, arguments: args }, void 0, callToolOptions);
+    if (result.isError) {
+      throw new Error(getToolText(result));
+    }
+    return { text: getToolText(result) };
+  } finally {
+    await client.close().catch(() => void 0);
+    await transport.close().catch(() => void 0);
+  }
+}
+async function subscribeToToolProgress(daemon, clientId, tool, onProgress) {
+  const controller = new AbortController();
+  const phaseWaiters = /* @__PURE__ */ new Map();
+  const seenPhases = /* @__PURE__ */ new Set();
+  const response = await fetch(`${daemon.url}/daemon/events`, {
+    method: "GET",
+    headers: {
+      Authorization: `Bearer ${daemon.bearerToken}`,
+      "x-perplexity-client-id": clientId
+    },
+    signal: controller.signal
+  });
+  if (!response.ok || !response.body) {
+    throw new Error(`Could not subscribe to daemon events (${response.status}).`);
+  }
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const drain = (async () => {
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        buffer = consumeSseFrames(buffer, (event, payload) => {
+          if (event !== "daemon:tool-progress") {
+            return;
+          }
+          if (payload?.clientId !== clientId || payload?.tool !== tool) {
+            return;
+          }
+          const progress = payload.progress;
+          seenPhases.add(progress.phase);
+          onProgress(progress);
+          const waiters = phaseWaiters.get(progress.phase);
+          if (!waiters?.length) {
+            return;
+          }
+          phaseWaiters.delete(progress.phase);
+          for (const resolve of waiters) {
+            resolve();
+          }
+        });
+      }
+    } catch (error) {
+      if (!controller.signal.aborted) {
+        throw error;
+      }
+    }
+  })();
+  return {
+    close: async () => {
+      controller.abort();
+      await drain.catch(() => void 0);
+    },
+    waitForPhase: async (phase, timeoutMs) => {
+      if (seenPhases.has(phase)) {
+        return;
+      }
+      await new Promise((resolve, reject) => {
+        let wrappedResolve;
+        const timer = setTimeout(() => {
+          const waiters2 = phaseWaiters.get(phase);
+          if (waiters2 && wrappedResolve) {
+            phaseWaiters.set(phase, waiters2.filter((candidate) => candidate !== wrappedResolve));
+          }
+          reject(new Error(`Timed out waiting for daemon progress phase '${phase}'.`));
+        }, timeoutMs);
+        wrappedResolve = () => {
+          clearTimeout(timer);
+          resolve();
+        };
+        const waiters = phaseWaiters.get(phase) ?? [];
+        waiters.push(wrappedResolve);
+        phaseWaiters.set(phase, waiters);
+      });
+    }
+  };
+}
+function consumeSseFrames(buffer, onFrame) {
+  while (true) {
+    const boundary = buffer.indexOf("\n\n");
+    if (boundary < 0) {
+      return buffer;
+    }
+    const frame = buffer.slice(0, boundary);
+    buffer = buffer.slice(boundary + 2);
+    if (!frame.trim()) {
+      continue;
+    }
+    let event = "message";
+    const dataLines = [];
+    for (const rawLine of frame.split(/\r?\n/)) {
+      if (rawLine.startsWith("event:")) {
+        event = rawLine.slice(6).trim();
+      } else if (rawLine.startsWith("data:")) {
+        dataLines.push(rawLine.slice(5).trim());
+      }
+    }
+    if (!dataLines.length) {
+      continue;
+    }
+    try {
+      onFrame(event, JSON.parse(dataLines.join("\n")));
+    } catch {
+    }
+  }
+}
+function parseCloudSyncResult(text) {
+  const match = text.match(/fetched=(\d+)\s+inserted=(\d+)\s+updated=(\d+)\s+skipped=(\d+)/i);
+  if (!match) {
+    throw new Error(`Could not parse cloud sync result: ${text}`);
+  }
+  return {
+    fetched: Number(match[1]),
+    inserted: Number(match[2]),
+    updated: Number(match[3]),
+    skipped: Number(match[4])
+  };
+}
+function parseHydrateResult(text) {
+  const match = text.match(/^Cloud hydrate ([a-z-]+):/i);
+  if (!match) {
+    throw new Error(`Could not parse cloud hydrate result: ${text}`);
+  }
+  const action = match[1];
+  if (action !== "hydrated" && action !== "skipped-local" && action !== "skipped-hydrated") {
+    throw new Error(`Unexpected cloud hydrate action '${action}'.`);
+  }
+  return { action };
+}
+function getToolText(result) {
+  const textItem = result?.content?.find?.((item) => item?.type === "text" && typeof item.text === "string");
+  if (typeof textItem?.text !== "string" || textItem.text.length === 0) {
+    throw new Error("Daemon tool response did not contain text output.");
+  }
+  return textItem.text;
+}
+function extractBacktickedPath(text) {
+  const match = text.match(/`([^`]+)`/);
+  if (!match?.[1]) {
+    throw new Error(`Could not parse saved path from daemon export response: ${text}`);
+  }
+  return match[1];
+}
+function getExportContentType(format) {
+  if (format === "markdown") {
+    return "text/markdown; charset=utf-8";
+  }
+  if (format === "pdf") {
+    return "application/pdf";
+  }
+  return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+}
+
+export {
+  exportHistoryViaDaemon,
+  syncCloudHistoryViaDaemon,
+  hydrateCloudHistoryEntryViaDaemon
+};