perplexity-user-mcp 0.8.36

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+import { PerplexityClient } from './client.js';
+export { ensureDaemon, startDaemon } from './daemon/launcher.js';
+export { attachToDaemon } from './daemon/attach.js';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { SearchResult } from './config.js';
+export { BrowserInfo, findBrowser } from './config.js';
+export { append as appendHistory, countAll as countAllHistory, deleteEntry, findByBackendUuid, findPendingByThread, get, getAttachmentsDir, getAttachmentsRoot, getHistoryDir, getIndexPath as getHistoryPath, getMdPath, hydrateCloudEntry, pin, list as readHistory, rebuildIndex, tag, update, upsertFromCloud } from './history-store.d-BzjBF2m3.js';
+export { hydrateCloudHistoryEntry, syncCloudHistory } from './cloud-sync.d-Cqt6y18U.js';
+export { HistoryItem } from '@perplexity-user-mcp/shared';
+export { RefreshOptions, RefreshResult, RefreshTier, getImpitRuntimeDir, getModelsCacheInfo, isImpitAvailable, refreshAccountInfo } from './refresh.js';
+import { DoctorReport, DoctorCategory } from './doctor.d-CXmUqOXX.js';
+export { CATEGORIES as DOCTOR_CATEGORIES, formatReportMarkdown, runAll as runDoctor } from './doctor.d-CXmUqOXX.js';
+import 'patchright';
+import './daemon/lockfile.js';
+import 'node:stream';
+
+type GetClient = () => Promise<PerplexityClient>;
+interface ToolAuditEvent {
+    tool: string;
+    clientId: string;
+    source: "loopback" | "tunnel";
+    durationMs: number;
+    ok: boolean;
+    error?: string;
+}
+interface ToolProgressEvent {
+    tool: string;
+    clientId: string;
+    source: "loopback" | "tunnel";
+    progress: Record<string, unknown>;
+}
+interface ToolHooks {
+    onToolSettled?: (event: ToolAuditEvent) => void;
+    onToolProgress?: (event: ToolProgressEvent) => void;
+}
+declare function registerTools(server: McpServer, getClient: GetClient, enabledTools?: Set<string>, hooks?: ToolHooks): void;
+
+declare function registerPrompts(server: McpServer): void;
+
+interface AccountSnapshotProvider {
+    (): Record<string, unknown>;
+}
+declare function registerResources(server: McpServer, getAccountSnapshot?: AccountSnapshotProvider): void;
+
+interface HistoryEntry {
+    tool: string;
+    query: string;
+    model: string | null;
+    mode: string | null;
+    language: string | null;
+    answerPreview: string;
+    sourceCount: number;
+    threadUrl?: string;
+    error?: string;
+}
+declare function formatResponse(result: SearchResult): string;
+declare function buildAnswerPreview(result: SearchResult | null, error?: string): string;
+declare function buildHistoryEntry(options: {
+    tool: string;
+    query: string;
+    model: string | null;
+    mode: string | null;
+    language: string | null;
+    result?: SearchResult;
+    error?: string;
+}): HistoryEntry;
+declare function buildHistoryBody(result: SearchResult | undefined, error?: string): string;
+declare function buildStoredHistoryEntry(options: {
+    tool: string;
+    query: string;
+    model: string | null;
+    mode: string | null;
+    language: string | null;
+    tier?: "Max" | "Pro" | "Enterprise" | "Authenticated" | "Anonymous";
+    status?: "completed" | "pending" | "failed";
+    createdAt?: string;
+    completedAt?: string;
+    result?: SearchResult;
+    error?: string;
+}): HistoryEntry & {
+    createdAt: string;
+    body: string;
+    status?: "completed" | "pending" | "failed";
+    completedAt?: string;
+    tier?: "Max" | "Pro" | "Enterprise" | "Authenticated" | "Anonymous";
+    threadSlug?: string | null;
+    backendUuid?: string | null;
+    readWriteToken?: string | null;
+    sources?: Array<{
+        n: number;
+        title: string;
+        url: string;
+        snippet?: string;
+    }>;
+};
+
+type ExportFormat = "pdf" | "markdown" | "docx";
+
+interface ExportResult {
+  buffer: Buffer;
+  filename: string;
+  contentType: string;
+}
+declare function exportThread(options: {
+  entryUuid: string;
+  format: ExportFormat;
+  fetchImpl?: (input: string, init?: RequestInit) => Promise<Response>;
+  baseUrl?: string;
+  headers?: HeadersInit;
+}): Promise<ExportResult>;
+
+type ToolProfile = "read-only" | "full" | "custom";
+interface ToolConfig {
+    profile: ToolProfile;
+    customEnabled?: string[];
+}
+declare function loadToolConfig(): ToolConfig;
+declare function getEnabledTools(config: ToolConfig): Set<string>;
+declare function saveToolConfig(config: ToolConfig): void;
+declare function watchToolConfig(onChange: (config: ToolConfig) => void): void;
+
+declare function buildIssueBody(input: {
+  report: DoctorReport;
+  stderrTail: string;
+  extVersion: string;
+  nodeVersion: string;
+  os: string;
+  activeTier?: string | null;
+}): string;
+
+declare function redactIssueBody(md: string): string;
+
+declare function decideTransport(input: { bodyBytes: number }): "inline" | "file";
+
+declare function buildIssueUrl(input: {
+  owner: string;
+  repo: string;
+  category: DoctorCategory | string;
+  check: string;
+  body: string;
+}): string;
+
+declare function __resetVaultPreflightForTests(): void;
+/**
+ * Probe the vault unseal chain at startup. If unsealing succeeds, the result
+ * is cached inside `vault.js` for free — subsequent tool calls skip the
+ * keychain hit. If it fails (e.g. headless Codex CLI: no keychain, no env var,
+ * no TTY), emit a structured stderr warning so the user sees the actionable
+ * setup hint in their IDE's MCP server-launch logs instead of waiting for the
+ * first cookie-needing tool to fail with a deep-stack "Vault locked" trace.
+ *
+ * Never throws. The MCP server must continue to load and serve tools that
+ * don't need cookies (perplexity_doctor, anonymous perplexity_search).
+ */
+declare function runVaultPreflight(stderr?: NodeJS.WritableStream): Promise<void>;
+declare function main(): Promise<void>;
+
+export { type HistoryEntry, PerplexityClient, type ToolProfile, __resetVaultPreflightForTests, buildAnswerPreview, buildHistoryBody, buildHistoryEntry, buildIssueBody, buildIssueUrl, buildStoredHistoryEntry, decideTransport, exportThread, formatResponse, getEnabledTools, loadToolConfig, main, redactIssueBody, registerPrompts, registerResources, registerTools, runVaultPreflight, saveToolConfig, watchToolConfig };

package/dist/index.mjs

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+import {
+  CATEGORIES,
+  formatReportMarkdown,
+  runAll
+} from "./chunk-7JL36EBH.mjs";
+import {
+  buildIssueBody,
+  buildIssueUrl,
+  decideTransport,
+  redactIssueBody
+} from "./chunk-DPGMKSSA.mjs";
+import {
+  attachToDaemon
+} from "./chunk-SVPRB62V.mjs";
+import {
+  ensureDaemon,
+  startDaemon
+} from "./chunk-X45O6YD3.mjs";
+import "./chunk-KCXM2M4B.mjs";
+import "./chunk-6YMQVLFX.mjs";
+import "./chunk-3B276PGG.mjs";
+import "./chunk-6EP2BLTV.mjs";
+import {
+  buildAnswerPreview,
+  buildHistoryBody,
+  buildHistoryEntry,
+  buildStoredHistoryEntry,
+  formatResponse,
+  getEnabledTools,
+  getPackageVersion,
+  loadToolConfig,
+  registerPrompts,
+  registerResources,
+  registerTools,
+  saveToolConfig,
+  watchToolConfig
+} from "./chunk-S5VD7WTU.mjs";
+import "./chunk-PE23RMXY.mjs";
+import "./chunk-HTUAQRKH.mjs";
+import {
+  watchReinit
+} from "./chunk-U3DGFLXZ.mjs";
+import "./chunk-HMKLWVXB.mjs";
+import {
+  hydrateCloudHistoryEntry,
+  syncCloudHistory
+} from "./chunk-Q2VY4R5F.mjs";
+import {
+  PerplexityClient
+} from "./chunk-H4BUAPPO.mjs";
+import {
+  getImpitRuntimeDir,
+  getModelsCacheInfo,
+  isImpitAvailable,
+  refreshAccountInfo
+} from "./chunk-Z7DAACGZ.mjs";
+import {
+  append,
+  countAll,
+  deleteEntry,
+  findByBackendUuid,
+  findPendingByThread,
+  get,
+  getAttachmentsDir,
+  getAttachmentsRoot,
+  getHistoryDir,
+  getIndexPath,
+  getMdPath,
+  hydrateCloudEntry,
+  list,
+  pin,
+  rebuildIndex,
+  tag,
+  update,
+  upsertFromCloud
+} from "./chunk-OF4DMAPJ.mjs";
+import {
+  exportThread
+} from "./chunk-LZPLNZ5U.mjs";
+import {
+  findBrowser
+} from "./chunk-LKJMLGFP.mjs";
+import {
+  getUnsealMaterial
+} from "./chunk-TQLCLE4L.mjs";
+import "./chunk-MTDFKNXX.mjs";
+import {
+  getActiveName
+} from "./chunk-XKSWCEGI.mjs";
+import "./chunk-4UEJOM6W.mjs";
+
+// src/index.ts
+import { pathToFileURL } from "url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+var client;
+var clientInitPromise = null;
+async function getClient() {
+  if (!clientInitPromise) clientInitPromise = client.init();
+  await clientInitPromise;
+  return client;
+}
+var _vaultPreflightDone = false;
+function __resetVaultPreflightForTests() {
+  _vaultPreflightDone = false;
+}
+async function runVaultPreflight(stderr = process.stderr) {
+  if (_vaultPreflightDone) return;
+  _vaultPreflightDone = true;
+  try {
+    await getUnsealMaterial();
+  } catch (err) {
+    const summary = err instanceof Error ? err.message.split("\n")[0] : String(err);
+    stderr.write(`[perplexity-mcp] WARN vault-locked: ${summary}
+`);
+    stderr.write(`[perplexity-mcp]   Setup docs: docs/codex-cli-setup.md
+`);
+    stderr.write(`[perplexity-mcp]   Tools that don't need cookies (perplexity_doctor, perplexity_search anonymous mode) will still work.
+`);
+    stderr.write(`[perplexity-mcp]   Tools that need cookies (perplexity_research, perplexity_compute, perplexity_reason) will fail until the vault is unsealed.
+`);
+  }
+}
+async function main() {
+  client = new PerplexityClient();
+  const server = new McpServer({
+    name: "perplexity",
+    version: getPackageVersion()
+  });
+  const toolConfig = loadToolConfig();
+  const enabledTools = getEnabledTools(toolConfig);
+  registerResources(server);
+  registerPrompts(server);
+  registerTools(server, getClient, enabledTools);
+  const profile = process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+  console.error(`[perplexity-mcp] Starting with profile: ${profile}`);
+  await runVaultPreflight();
+  const watcher = watchReinit(profile, async () => {
+    console.error("[perplexity-mcp] .reinit sentinel fired \u2014 reloading client.");
+    try {
+      clientInitPromise = client.reinit();
+      await clientInitPromise;
+    } catch (err) {
+      console.error("[perplexity-mcp] reinit failed:", err);
+    }
+  });
+  process.on("SIGINT", async () => {
+    watcher.dispose();
+    await client.shutdown();
+    process.exit(0);
+  });
+  process.on("SIGTERM", async () => {
+    watcher.dispose();
+    await client.shutdown();
+    process.exit(0);
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  runEntrypoint().catch(async (error) => {
+    console.error("[perplexity-mcp] Fatal error:", error);
+    await client?.shutdown?.().catch(() => void 0);
+    process.exit(1);
+  });
+}
+async function runEntrypoint() {
+  if (process.argv.length > 2) {
+    const { parseArgs, routeCommand } = await import("./cli.mjs");
+    const result = await routeCommand(parseArgs(process.argv.slice(2)));
+    if (result.stdout) {
+      process.stdout.write(result.stdout);
+    }
+    if (result.stderr) {
+      process.stderr.write(result.stderr);
+    }
+    process.exitCode = result.code;
+    return;
+  }
+  await main();
+}
+export {
+  CATEGORIES as DOCTOR_CATEGORIES,
+  PerplexityClient,
+  __resetVaultPreflightForTests,
+  append as appendHistory,
+  attachToDaemon,
+  buildAnswerPreview,
+  buildHistoryBody,
+  buildHistoryEntry,
+  buildIssueBody,
+  buildIssueUrl,
+  buildStoredHistoryEntry,
+  countAll as countAllHistory,
+  decideTransport,
+  deleteEntry,
+  ensureDaemon,
+  exportThread,
+  findBrowser,
+  findByBackendUuid,
+  findPendingByThread,
+  formatReportMarkdown,
+  formatResponse,
+  get,
+  getAttachmentsDir,
+  getAttachmentsRoot,
+  getEnabledTools,
+  getHistoryDir,
+  getIndexPath as getHistoryPath,
+  getImpitRuntimeDir,
+  getMdPath,
+  getModelsCacheInfo,
+  hydrateCloudEntry,
+  hydrateCloudHistoryEntry,
+  isImpitAvailable,
+  loadToolConfig,
+  main,
+  pin,
+  list as readHistory,
+  rebuildIndex,
+  redactIssueBody,
+  refreshAccountInfo,
+  registerPrompts,
+  registerResources,
+  registerTools,
+  runAll as runDoctor,
+  runVaultPreflight,
+  saveToolConfig,
+  startDaemon,
+  syncCloudHistory,
+  tag,
+  update,
+  upsertFromCloud,
+  watchToolConfig
+};