perplexity-user-mcp 0.8.36

package/dist/chunk-X45O6YD3.mjs

@@ -0,0 +1,688 @@
+import {
+  getTunnelProvider,
+  readTunnelSettings
+} from "./chunk-KCXM2M4B.mjs";
+import {
+  acquire,
+  getLockfilePath,
+  isStale,
+  read,
+  release,
+  replace
+} from "./chunk-6EP2BLTV.mjs";
+import {
+  getPackageVersion,
+  startDaemonServer
+} from "./chunk-S5VD7WTU.mjs";
+import {
+  ensureToken,
+  getTokenPath,
+  readToken
+} from "./chunk-HTUAQRKH.mjs";
+import {
+  watchReinit
+} from "./chunk-U3DGFLXZ.mjs";
+import {
+  PerplexityClient
+} from "./chunk-H4BUAPPO.mjs";
+import {
+  getActiveName,
+  getConfigDir
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/daemon/launcher.ts
+import { spawn } from "child_process";
+import { randomUUID } from "crypto";
+import { existsSync } from "fs";
+import { fileURLToPath } from "url";
+import { setTimeout as delay } from "timers/promises";
+async function getDaemonStatus(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const lockPath = getLockfilePath(configDir);
+  const tokenPath = getTokenPath(configDir);
+  const record = read({ lockPath });
+  if (!record) {
+    return {
+      running: false,
+      healthy: false,
+      stale: false,
+      configDir,
+      lockPath,
+      tokenPath,
+      record: null,
+      health: null
+    };
+  }
+  if (options.treatSelfAsZombie && record.pid === process.pid) {
+    if (options.reclaimStale) {
+      release({ lockPath, expectedUuid: record.uuid });
+    }
+    return {
+      running: false,
+      healthy: false,
+      stale: true,
+      configDir,
+      lockPath,
+      tokenPath,
+      record,
+      health: null
+    };
+  }
+  let health = await probeHealth(record, { timeoutMs: options.healthTimeoutMs });
+  if (!health) {
+    try {
+      const tokenRecord = readToken({ tokenPath });
+      if (tokenRecord && tokenRecord.bearerToken !== record.bearerToken) {
+        health = await probeHealth(
+          { ...record, bearerToken: tokenRecord.bearerToken },
+          { timeoutMs: options.healthTimeoutMs }
+        );
+        if (health && options.reclaimStale) {
+          try {
+            replace(
+              { ...record, bearerToken: tokenRecord.bearerToken },
+              { lockPath, expectedUuid: record.uuid }
+            );
+          } catch {
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const healthy = Boolean(health?.ok && health.uuid === record.uuid);
+  const stale = !healthy && isStale(record, { echoedUuid: health?.uuid ?? null });
+  if (stale && options.reclaimStale) {
+    release({ lockPath, expectedUuid: record.uuid });
+    return {
+      running: false,
+      healthy: false,
+      stale: true,
+      configDir,
+      lockPath,
+      tokenPath,
+      record,
+      health
+    };
+  }
+  return {
+    running: !stale,
+    healthy,
+    stale,
+    configDir,
+    lockPath,
+    tokenPath,
+    record,
+    health
+  };
+}
+async function ensureDaemon(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const deadline = Date.now() + (options.startTimeoutMs ?? 15e3);
+  let launched = false;
+  while (Date.now() < deadline) {
+    const status = await getDaemonStatus({
+      configDir,
+      reclaimStale: true,
+      healthTimeoutMs: options.healthTimeoutMs,
+      treatSelfAsZombie: options.treatSelfAsZombie
+    });
+    if (status.running && status.healthy && status.record && status.health) {
+      return toConnectionInfo(status.record, status.health);
+    }
+    if (!status.running && !launched) {
+      await (options.spawnDaemon ?? spawnDetachedDaemon)({
+        configDir,
+        host: options.host,
+        port: options.port,
+        tunnel: options.tunnel
+      });
+      launched = true;
+    }
+    await delay(options.pollIntervalMs ?? 200);
+  }
+  throw new Error(`Timed out waiting for daemon startup in ${configDir}.`);
+}
+async function startDaemon(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const lockPath = getLockfilePath(configDir);
+  const tokenPath = getTokenPath(configDir);
+  const retries = options.retries ?? 3;
+  const retryDelayMs = options.retryDelayMs ?? 200;
+  const version = options.version ?? getPackageVersion();
+  for (let attempt = 0; attempt < retries; attempt++) {
+    const status = await getDaemonStatus({
+      configDir,
+      reclaimStale: true,
+      healthTimeoutMs: options.healthTimeoutMs
+    });
+    if (status.running && status.healthy && status.record && status.health) {
+      return {
+        attached: true,
+        ...toConnectionInfo(status.record, status.health),
+        close: async () => void 0,
+        closed: Promise.resolve()
+      };
+    }
+    if (status.running) {
+      await delay(retryDelayMs);
+      continue;
+    }
+    const uuid = randomUUID();
+    const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const token = ensureToken({ tokenPath });
+    const provisional = {
+      pid: process.pid,
+      uuid,
+      port: typeof options.port === "number" ? options.port : 0,
+      bearerToken: token.bearerToken,
+      version,
+      startedAt,
+      cloudflaredPid: null,
+      tunnelUrl: null
+    };
+    if (!acquire(provisional, { lockPath })) {
+      await delay(retryDelayMs);
+      continue;
+    }
+    let watcher;
+    let server;
+    let finalizePromise = null;
+    let finalizeResolve;
+    const closed = new Promise((resolve) => {
+      finalizeResolve = resolve;
+    });
+    const profile = process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+    const client = options.createClient ? options.createClient() : new PerplexityClient();
+    let tunnelState = {
+      status: "disabled",
+      url: null,
+      pid: null,
+      error: null
+    };
+    let tunnelController = null;
+    let tunnelStartPromise = null;
+    const buildRecord = (bearerToken = server?.bearerToken ?? token.bearerToken) => ({
+      pid: process.pid,
+      uuid,
+      port: server?.port ?? provisional.port,
+      bearerToken,
+      version,
+      startedAt,
+      cloudflaredPid: tunnelState.pid ?? null,
+      tunnelUrl: tunnelState.url ?? null
+    });
+    const syncLockfile = (bearerToken = server?.bearerToken ?? token.bearerToken) => {
+      replace(buildRecord(bearerToken), { lockPath, expectedUuid: uuid });
+    };
+    const publishTunnelState = () => {
+      if (!server) {
+        return;
+      }
+      syncLockfile(server.bearerToken);
+      server.publishEvent("daemon:tunnel-url", {
+        status: tunnelState.status,
+        url: tunnelState.url,
+        pid: tunnelState.pid,
+        error: tunnelState.error ?? null
+      });
+    };
+    const enableTunnelRuntime = async () => {
+      if (!server) {
+        throw new Error("Daemon server is not ready yet.");
+      }
+      if (tunnelState.status === "enabled") {
+        return;
+      }
+      if (tunnelStartPromise) {
+        await tunnelStartPromise;
+        return;
+      }
+      const settings = readTunnelSettings(configDir);
+      const provider = getTunnelProvider(settings.activeProvider);
+      const setup = await provider.isSetupComplete(configDir);
+      if (!setup.ready) {
+        throw new Error(setup.reason ?? `${provider.displayName} setup incomplete.`);
+      }
+      tunnelController = await provider.start({
+        port: server.port,
+        configDir,
+        onStateChange: (nextState) => {
+          tunnelState = nextState;
+          if (nextState.status === "crashed" || nextState.status === "disabled") {
+            tunnelController = null;
+          }
+          publishTunnelState();
+        }
+      });
+      tunnelStartPromise = tunnelController.waitUntilReady.then(() => void 0).finally(() => {
+        tunnelStartPromise = null;
+      });
+      await tunnelStartPromise;
+    };
+    const disableTunnelRuntime = async () => {
+      const controller = tunnelController;
+      tunnelController = null;
+      if (!controller) {
+        if (tunnelState.status !== "disabled") {
+          tunnelState = {
+            status: "disabled",
+            url: null,
+            pid: null,
+            error: null
+          };
+          publishTunnelState();
+        }
+        return;
+      }
+      await controller.stop();
+      tunnelState = {
+        status: "disabled",
+        url: null,
+        pid: null,
+        error: null
+      };
+      publishTunnelState();
+    };
+    const finalize = async () => {
+      if (!finalizePromise) {
+        finalizePromise = (async () => {
+          await disableTunnelRuntime().catch(() => void 0);
+          watcher?.dispose();
+          if (options.signal && abortHandler) {
+            options.signal.removeEventListener("abort", abortHandler);
+          }
+          process.off("SIGINT", signalHandler);
+          process.off("SIGTERM", signalHandler);
+          release({ lockPath, expectedUuid: uuid });
+          finalizeResolve?.();
+        })();
+      }
+      await finalizePromise;
+    };
+    const signalHandler = () => {
+      void close();
+    };
+    const abortHandler = () => {
+      void close();
+    };
+    const close = async () => {
+      if (server) {
+        await server.close().catch(() => void 0);
+      }
+      await finalize();
+    };
+    try {
+      watcher = watchReinit(profile, async () => {
+        await client.reinit();
+      });
+      server = await startDaemonServer({
+        host: options.host,
+        port: options.port,
+        uuid,
+        version,
+        configDir,
+        bearerToken: token.bearerToken,
+        createClient: () => client,
+        onShutdown: finalize,
+        getTunnelState: () => tunnelState,
+        onEnableTunnel: enableTunnelRuntime,
+        onDisableTunnel: disableTunnelRuntime,
+        onTunnelAutoDisable: async (info) => {
+          await disableTunnelRuntime().catch(() => void 0);
+          tunnelState = {
+            status: "crashed",
+            url: null,
+            pid: null,
+            error: `Auto-disabled: ${info.failures} auth failures within ${Math.round(info.windowMs / 1e3)}s.`
+          };
+          publishTunnelState();
+        },
+        onTokenRotated: async (nextToken) => {
+          syncLockfile(nextToken.bearerToken);
+        }
+      });
+      syncLockfile(server.bearerToken);
+      process.on("SIGINT", signalHandler);
+      process.on("SIGTERM", signalHandler);
+      options.signal?.addEventListener("abort", abortHandler);
+      if (options.tunnel) {
+        await enableTunnelRuntime();
+      }
+      return {
+        attached: false,
+        pid: process.pid,
+        uuid,
+        port: server.port,
+        url: server.url,
+        bearerToken: server.bearerToken,
+        version,
+        startedAt,
+        tunnelUrl: tunnelState.url,
+        close,
+        closed
+      };
+    } catch (error) {
+      watcher?.dispose();
+      await server?.close?.().catch(() => void 0);
+      release({ lockPath, expectedUuid: uuid });
+      if (isAddressInUseError(error)) {
+        if (typeof options.port === "number" && options.port > 0) {
+          throw new Error(
+            `Port ${options.port} is in use; daemon cannot start. Another perplexity daemon instance or unrelated process holds it.`
+          );
+        }
+        await delay(retryDelayMs);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new Error(`Unable to start or attach to daemon after ${retries} attempts.`);
+}
+function isAddressInUseError(error) {
+  if (!error || typeof error !== "object") return false;
+  const code = error.code;
+  return code === "EADDRINUSE";
+}
+async function stopDaemon(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const status = await getDaemonStatus({
+    configDir,
+    reclaimStale: true,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!status.running || !status.record) {
+    if (options.force && status.record) {
+      try {
+        release({ lockPath: getLockfilePath(configDir), expectedUuid: status.record.uuid });
+      } catch {
+      }
+    }
+    return { stopped: false, forced: false, pid: status.record?.pid ?? null };
+  }
+  const recordForShutdown = status.record;
+  if (status.healthy) {
+    try {
+      await adminRequest(recordForShutdown, "/daemon/shutdown", { method: "POST" });
+    } catch (err) {
+      if (!options.force) throw err;
+    }
+  }
+  const deadline = Date.now() + (options.waitTimeoutMs ?? 1e4);
+  while (Date.now() < deadline) {
+    const nextStatus = await getDaemonStatus({
+      configDir,
+      reclaimStale: true,
+      healthTimeoutMs: options.healthTimeoutMs
+    });
+    if (!nextStatus.running) {
+      return { stopped: true, forced: false, pid: recordForShutdown.pid };
+    }
+    await delay(options.pollIntervalMs ?? 200);
+  }
+  if (!options.force) {
+    throw new Error("Timed out waiting for daemon shutdown.");
+  }
+  const pid = recordForShutdown.pid;
+  let signalled = false;
+  try {
+    process.kill(pid, "SIGTERM");
+    signalled = true;
+    await delay(1e3);
+    try {
+      process.kill(pid, 0);
+      process.kill(pid, "SIGKILL");
+      await delay(500);
+    } catch {
+    }
+  } catch {
+  }
+  try {
+    release({ lockPath: getLockfilePath(configDir), expectedUuid: recordForShutdown.uuid });
+  } catch {
+  }
+  return { stopped: signalled, forced: true, pid };
+}
+async function restartDaemon(options = {}) {
+  let stopped = false;
+  try {
+    const result = await stopDaemon({
+      configDir: options.configDir,
+      waitTimeoutMs: options.waitTimeoutMs,
+      pollIntervalMs: options.pollIntervalMs,
+      healthTimeoutMs: options.healthTimeoutMs
+    });
+    stopped = result.stopped;
+  } catch {
+  }
+  const connection = await ensureDaemon({
+    configDir: options.configDir,
+    healthTimeoutMs: options.healthTimeoutMs,
+    startTimeoutMs: options.startTimeoutMs,
+    pollIntervalMs: options.pollIntervalMs,
+    spawnDaemon: options.spawnDaemon,
+    treatSelfAsZombie: options.treatSelfAsZombie
+  });
+  return { stopped, reSpawned: true, connection };
+}
+async function rotateDaemonToken(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const status = await getDaemonStatus({
+    configDir,
+    reclaimStale: true,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!status.running || !status.healthy || !status.record) {
+    throw new Error("Daemon is not running.");
+  }
+  await adminRequest(status.record, "/daemon/rotate-token", { method: "POST" });
+  await delay(100);
+  const updated = await getDaemonStatus({
+    configDir,
+    reclaimStale: false,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!updated.running || !updated.healthy || !updated.record || !updated.health) {
+    throw new Error("Daemon token rotation completed, but the daemon is not healthy.");
+  }
+  return toConnectionInfo(updated.record, updated.health);
+}
+async function enableDaemonTunnel(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const status = await getDaemonStatus({
+    configDir,
+    reclaimStale: true,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!status.running || !status.healthy || !status.record) {
+    throw new Error("Daemon is not running.");
+  }
+  await adminRequest(status.record, "/daemon/enable-tunnel", { method: "POST" });
+  await delay(100);
+  return await getDaemonStatus({
+    configDir,
+    reclaimStale: false,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+}
+async function disableDaemonTunnel(options = {}) {
+  const configDir = options.configDir ?? getConfigDir();
+  const status = await getDaemonStatus({
+    configDir,
+    reclaimStale: true,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!status.running || !status.healthy || !status.record) {
+    throw new Error("Daemon is not running.");
+  }
+  await adminRequest(status.record, "/daemon/disable-tunnel", { method: "POST" });
+  await delay(100);
+  return await getDaemonStatus({
+    configDir,
+    reclaimStale: false,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+}
+async function requireRunningRecord(options) {
+  const configDir = options.configDir ?? getConfigDir();
+  const status = await getDaemonStatus({
+    configDir,
+    reclaimStale: true,
+    healthTimeoutMs: options.healthTimeoutMs
+  });
+  if (!status.running || !status.healthy || !status.record) {
+    throw new Error("Daemon is not running.");
+  }
+  return status.record;
+}
+async function listOAuthConsents(options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-consents", { method: "GET" });
+  const consents = body?.consents;
+  return Array.isArray(consents) ? consents : [];
+}
+async function revokeOAuthConsent(clientId, redirectUri, options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-consents", {
+    method: "DELETE",
+    body: redirectUri ? { clientId, redirectUri } : { clientId }
+  });
+  const removed = body?.removed ?? 0;
+  return Number(removed) || 0;
+}
+async function revokeAllOAuthConsents(options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-consents", { method: "DELETE" });
+  const removed = body?.removed ?? 0;
+  return Number(removed) || 0;
+}
+async function listOAuthClients(options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-clients", { method: "GET" });
+  const clients = body?.clients;
+  return Array.isArray(clients) ? clients : [];
+}
+async function revokeOAuthClient(clientId, options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-clients", {
+    method: "DELETE",
+    body: { clientId }
+  });
+  const ok = body?.ok;
+  return Boolean(ok);
+}
+async function revokeAllOAuthClients(options = {}) {
+  const record = await requireRunningRecord(options);
+  const body = await adminRequest(record, "/daemon/oauth-clients", { method: "DELETE" });
+  const removed = body?.removed ?? 0;
+  return Number(removed) || 0;
+}
+async function probeHealth(record, options = {}) {
+  if (!record.port || record.port <= 0) {
+    return null;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), options.timeoutMs ?? 2e3);
+  try {
+    const response = await fetch(`http://127.0.0.1:${record.port}/daemon/health`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${record.bearerToken}`
+      },
+      signal: controller.signal
+    });
+    if (!response.ok) {
+      if (process.env.PERPLEXITY_DEBUG === "1") {
+        console.error(`[trace] probeHealth non-ok status=${response.status} port=${record.port}`);
+      }
+      return null;
+    }
+    return await response.json();
+  } catch (err) {
+    if (process.env.PERPLEXITY_DEBUG === "1") {
+      const stack = err instanceof Error ? err.stack ?? err.message : String(err);
+      console.error(`[trace] probeHealth threw port=${record.port}: ${stack}`);
+    }
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function adminRequest(record, path, options) {
+  const response = await fetch(`http://127.0.0.1:${record.port}${path}`, {
+    method: options.method,
+    headers: {
+      Authorization: `Bearer ${record.bearerToken}`,
+      ...options.body ? { "Content-Type": "application/json" } : {}
+    },
+    ...options.body ? { body: JSON.stringify(options.body) } : {}
+  });
+  if (!response.ok) {
+    const detail = await response.text().catch(() => "");
+    throw new Error(`Daemon admin request failed (${response.status}): ${detail || response.statusText}`);
+  }
+  if (response.status === 204) {
+    return null;
+  }
+  const contentType = response.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    return await response.json();
+  }
+  return await response.text().catch(() => null);
+}
+function toConnectionInfo(record, health) {
+  return {
+    pid: record.pid,
+    uuid: record.uuid,
+    port: record.port,
+    url: `http://127.0.0.1:${record.port}`,
+    bearerToken: record.bearerToken,
+    version: record.version,
+    startedAt: record.startedAt,
+    tunnelUrl: health.tunnel?.url ?? record.tunnelUrl ?? null
+  };
+}
+async function spawnDetachedDaemon(options) {
+  const cliEntry = resolveCliEntry();
+  const args = [cliEntry, "daemon", "start"];
+  if (typeof options.port === "number") {
+    args.push("--port", String(options.port));
+  }
+  if (options.tunnel) {
+    args.push("--tunnel");
+  }
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      PERPLEXITY_CONFIG_DIR: options.configDir
+    }
+  });
+  child.unref();
+}
+function resolveCliEntry() {
+  const mjsPath = fileURLToPath(new URL("../cli.mjs", import.meta.url));
+  if (existsSync(mjsPath)) {
+    return mjsPath;
+  }
+  return fileURLToPath(new URL("../cli.js", import.meta.url));
+}
+
+export {
+  getDaemonStatus,
+  ensureDaemon,
+  startDaemon,
+  stopDaemon,
+  restartDaemon,
+  rotateDaemonToken,
+  enableDaemonTunnel,
+  disableDaemonTunnel,
+  listOAuthConsents,
+  revokeOAuthConsent,
+  revokeAllOAuthConsents,
+  listOAuthClients,
+  revokeOAuthClient,
+  revokeAllOAuthClients
+};