perplexity-user-mcp 0.8.36

package/dist/chunk-SVPRB62V.mjs

@@ -0,0 +1,106 @@
+import {
+  ensureDaemon
+} from "./chunk-X45O6YD3.mjs";
+
+// src/daemon/attach.ts
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+async function attachToDaemon(options = {}) {
+  const ensure = options.dependencies?.ensureDaemon ?? ensureDaemon;
+  const sourceIn = options.stdin ?? process.stdin;
+  const sourceOut = options.stdout ?? process.stdout;
+  let daemon;
+  try {
+    daemon = await ensure({
+      configDir: options.configDir,
+      startTimeoutMs: options.ensureTimeoutMs ?? 15e3
+    });
+  } catch (error) {
+    if (options.fallbackStdio) {
+      await runFallback(error, options);
+      return;
+    }
+    throw error;
+  }
+  const stdio = new StdioServerTransport(sourceIn, sourceOut);
+  const http = new StreamableHTTPClientTransport(new URL(`${daemon.url}/mcp`), {
+    requestInit: {
+      headers: {
+        Authorization: `Bearer ${daemon.bearerToken}`,
+        "x-perplexity-client-id": options.clientId ?? `daemon-attach-${process.pid}`,
+        "x-perplexity-source": "loopback"
+      }
+    }
+  });
+  const completion = new Promise((resolve, reject) => {
+    let settled = false;
+    const handleInputClosed = () => settle();
+    const settle = (error) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      sourceIn.off("end", handleInputClosed);
+      sourceIn.off("close", handleInputClosed);
+      void Promise.all([
+        http.close().catch(() => void 0),
+        stdio.close().catch(() => void 0)
+      ]).finally(() => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    };
+    stdio.onmessage = (message) => {
+      void http.send(message).catch((error) => settle(asError(error)));
+    };
+    stdio.onclose = () => settle();
+    stdio.onerror = (error) => settle(error);
+    http.onmessage = (message) => {
+      void stdio.send(message).catch((error) => settle(asError(error)));
+    };
+    http.onclose = () => settle();
+    http.onerror = (error) => settle(error);
+    sourceIn.on("end", handleInputClosed);
+    sourceIn.on("close", handleInputClosed);
+  });
+  try {
+    await Promise.all([stdio.start(), http.start()]);
+  } catch (error) {
+    await Promise.all([
+      stdio.close().catch(() => void 0),
+      http.close().catch(() => void 0)
+    ]);
+    if (options.fallbackStdio) {
+      await runFallback(error, options);
+      return;
+    }
+    throw error;
+  }
+  await completion;
+}
+async function runFallback(error, options) {
+  const reason = truncate(asError(error).message, 120);
+  process.stderr.write(
+    `[perplexity-mcp] daemon unreachable (${reason}); falling back to in-process stdio
+`
+  );
+  const runStdioMain = options.dependencies?.runStdioMain ?? (async () => {
+    const mod = await import("./index.mjs");
+    await mod.main();
+  });
+  await runStdioMain();
+}
+function truncate(value, max) {
+  if (value.length <= max) return value;
+  return value.slice(0, max);
+}
+function asError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+export {
+  attachToDaemon
+};

package/dist/chunk-TQLCLE4L.mjs

@@ -0,0 +1,345 @@
+import {
+  safeAtomicWriteFileSync
+} from "./chunk-MTDFKNXX.mjs";
+import {
+  getProfilePaths
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/vault.js
+import { createCipheriv, createDecipheriv, randomBytes, hkdfSync, scrypt as nodeScrypt } from "crypto";
+import { promisify } from "util";
+import { existsSync, readFileSync, mkdirSync, rmSync } from "fs";
+import { dirname } from "path";
+var MAGIC = Buffer.from("PXVT");
+var VERSION_V1 = 1;
+var VERSION_V2 = 2;
+var VERSION_V3 = 3;
+var IV_LEN = 12;
+var AUTHTAG_LEN = 16;
+var SALT_LEN = 16;
+var KDF_ID_SCRYPT = 1;
+var SCRYPT_LOGN_DEFAULT = 17;
+var SCRYPT_R_DEFAULT = 8;
+var SCRYPT_P_DEFAULT = 1;
+var SCRYPT_LOGN_FLOOR = 16;
+var SCRYPT_MAXMEM = 256 * 1024 * 1024;
+var SCRYPT_PARAMS_LEN = 3;
+var LEGACY_STATIC_SALT = Buffer.from("perplexity-user-mcp:v1:salt");
+var HKDF_INFO = Buffer.from("vault-master-key");
+var V1_HEADER_LEN = 4 + 1 + IV_LEN;
+var V2_HEADER_LEN = 4 + 1 + 1 + SALT_LEN + IV_LEN;
+var V3_HEADER_FIXED_PREAMBLE = 4 + 1 + 1 + 1;
+var scryptAsync = promisify(nodeScrypt);
+var _kdfParamsOverride = null;
+var _kdfTestModeActive = false;
+function __setKdfParamsForTest(params) {
+  if (!params || typeof params.logN !== "number" || typeof params.r !== "number" || typeof params.p !== "number") {
+    throw new Error("__setKdfParamsForTest requires {logN, r, p} numbers.");
+  }
+  _kdfParamsOverride = { logN: params.logN, r: params.r, p: params.p };
+  _kdfTestModeActive = true;
+}
+function getActiveKdfParams() {
+  return _kdfParamsOverride ?? {
+    logN: SCRYPT_LOGN_DEFAULT,
+    r: SCRYPT_R_DEFAULT,
+    p: SCRYPT_P_DEFAULT
+  };
+}
+function parseVaultHeader(blob) {
+  if (!Buffer.isBuffer(blob) || blob.length < 5) {
+    throw new Error(`Vault file too short / truncated (${blob ? blob.length : 0} bytes).`);
+  }
+  if (!blob.slice(0, 4).equals(MAGIC)) {
+    if (blob.length < V1_HEADER_LEN + AUTHTAG_LEN) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, no valid header).`);
+    }
+    throw new Error("Vault file has wrong magic header \u2014 not a Perplexity vault.");
+  }
+  const version = blob[4];
+  if (version === VERSION_V1) {
+    if (blob.length < V1_HEADER_LEN + AUTHTAG_LEN) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v1).`);
+    }
+    const iv = blob.slice(5, 5 + IV_LEN);
+    const tag = blob.slice(blob.length - AUTHTAG_LEN);
+    const ct = blob.slice(5 + IV_LEN, blob.length - AUTHTAG_LEN);
+    return { version, kdfId: null, kdfParams: null, salt: null, iv, ct, tag };
+  }
+  if (version === VERSION_V2) {
+    if (blob.length < 6) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v2 header).`);
+    }
+    const saltLen = blob[5];
+    if (saltLen !== SALT_LEN) {
+      throw new Error(`Vault has invalid salt length: ${saltLen} (expected ${SALT_LEN}). Possible corruption.`);
+    }
+    if (blob.length < V2_HEADER_LEN + AUTHTAG_LEN) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v2).`);
+    }
+    const salt = blob.slice(6, 6 + SALT_LEN);
+    const iv = blob.slice(6 + SALT_LEN, 6 + SALT_LEN + IV_LEN);
+    const tag = blob.slice(blob.length - AUTHTAG_LEN);
+    const ct = blob.slice(V2_HEADER_LEN, blob.length - AUTHTAG_LEN);
+    return { version, kdfId: null, kdfParams: null, salt, iv, ct, tag };
+  }
+  if (version === VERSION_V3) {
+    if (blob.length < V3_HEADER_FIXED_PREAMBLE) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v3 preamble).`);
+    }
+    const kdfId = blob[5];
+    const kdfParamsLen = blob[6];
+    if (kdfId === KDF_ID_SCRYPT) {
+      if (kdfParamsLen !== SCRYPT_PARAMS_LEN) {
+        throw new Error(
+          `Vault has invalid KDF params length: ${kdfParamsLen} (expected ${SCRYPT_PARAMS_LEN} for scrypt). Possible corruption.`
+        );
+      }
+    } else {
+      throw new Error(
+        `Vault uses unsupported KDF id: 0x${kdfId.toString(16).padStart(2, "0")}.`
+      );
+    }
+    const kdfParamsStart = V3_HEADER_FIXED_PREAMBLE;
+    const kdfParamsEnd = kdfParamsStart + kdfParamsLen;
+    if (blob.length < kdfParamsEnd + 1) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v3 KDF params).`);
+    }
+    const kdfParamsBytes = blob.slice(kdfParamsStart, kdfParamsEnd);
+    let kdfParams;
+    if (kdfId === KDF_ID_SCRYPT) {
+      kdfParams = {
+        logN: kdfParamsBytes[0],
+        r: kdfParamsBytes[1],
+        p: kdfParamsBytes[2]
+      };
+    }
+    const saltLenOffset = kdfParamsEnd;
+    const saltLen = blob[saltLenOffset];
+    if (saltLen !== SALT_LEN) {
+      throw new Error(`Vault has invalid salt length: ${saltLen} (expected ${SALT_LEN}). Possible corruption.`);
+    }
+    const saltStart = saltLenOffset + 1;
+    const ivStart = saltStart + SALT_LEN;
+    const ctStart = ivStart + IV_LEN;
+    const fullHeaderAndTag = ctStart + AUTHTAG_LEN;
+    if (blob.length < fullHeaderAndTag) {
+      throw new Error(`Vault file too short / truncated (${blob.length} bytes, v3).`);
+    }
+    const salt = blob.slice(saltStart, saltStart + SALT_LEN);
+    const iv = blob.slice(ivStart, ctStart);
+    const tag = blob.slice(blob.length - AUTHTAG_LEN);
+    const ct = blob.slice(ctStart, blob.length - AUTHTAG_LEN);
+    return { version, kdfId, kdfParams, salt, iv, ct, tag };
+  }
+  throw new Error(`Vault uses unsupported version byte: ${version}. Upgrade required.`);
+}
+function hkdfFromPassphrase(passphrase, salt) {
+  return Buffer.from(hkdfSync("sha256", Buffer.from(passphrase, "utf8"), salt, HKDF_INFO, 32));
+}
+async function scryptDerive(passphrase, salt, params) {
+  const { logN, r, p } = params;
+  if (!_kdfTestModeActive && logN < SCRYPT_LOGN_FLOOR) {
+    throw new Error(
+      `Vault scrypt parameters below security floor (logN=${logN} < ${SCRYPT_LOGN_FLOOR}). Refusing to derive.`
+    );
+  }
+  if (r < 1 || p < 1) {
+    throw new Error(`Vault scrypt parameters invalid (r=${r}, p=${p}).`);
+  }
+  const N = 1 << logN;
+  const key = await scryptAsync(Buffer.from(passphrase, "utf8"), salt, 32, {
+    N,
+    r,
+    p,
+    maxmem: SCRYPT_MAXMEM
+  });
+  return Buffer.from(key);
+}
+function encryptBlob(plaintext, key) {
+  if (!Buffer.isBuffer(key) || key.length !== 32) {
+    throw new Error("Vault key must be 32 bytes.");
+  }
+  const salt = randomBytes(SALT_LEN);
+  const iv = randomBytes(IV_LEN);
+  const params = getActiveKdfParams();
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  return Buffer.concat([
+    MAGIC,
+    Buffer.from([VERSION_V3, KDF_ID_SCRYPT, SCRYPT_PARAMS_LEN, params.logN, params.r, params.p, SALT_LEN]),
+    salt,
+    iv,
+    ct,
+    tag
+  ]);
+}
+function decryptBlob(blob, key) {
+  if (!Buffer.isBuffer(key) || key.length !== 32) {
+    throw new Error("Vault key must be 32 bytes.");
+  }
+  const header = parseVaultHeader(blob);
+  return aesGcmOpen(header, key);
+}
+function aesGcmOpen({ iv, ct, tag }, key) {
+  const decipher = createDecipheriv("aes-256-gcm", key, iv);
+  decipher.setAuthTag(tag);
+  try {
+    return Buffer.concat([decipher.update(ct), decipher.final()]);
+  } catch {
+    throw new Error(
+      "Vault decrypt failed: wrong passphrase or corrupted ciphertext. If you recently rotated PERPLEXITY_VAULT_PASSPHRASE or VS Code SecretStorage, restore the original passphrase."
+    );
+  }
+}
+var KEYTAR_SERVICE = "perplexity-user-mcp";
+var KEYTAR_ACCOUNT = "vault-master-key";
+var _keyCache = null;
+var _unsealMaterialCache = null;
+function __resetKeyCache() {
+  _keyCache = null;
+  _unsealMaterialCache = null;
+  _kdfParamsOverride = null;
+  _kdfTestModeActive = false;
+}
+async function tryKeytar() {
+  try {
+    const mod = await import("keytar");
+    return mod.default ?? mod;
+  } catch {
+    return null;
+  }
+}
+async function keyFromKeychain() {
+  const keytar = await tryKeytar();
+  if (!keytar) return null;
+  try {
+    let hex = await keytar.getPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+    if (!hex) {
+      const fresh = randomBytes(32);
+      hex = fresh.toString("hex");
+      await keytar.setPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT, hex);
+    }
+    const buf = Buffer.from(hex, "hex");
+    if (buf.length !== 32) return null;
+    return buf;
+  } catch {
+    return null;
+  }
+}
+function isStdioServerMode() {
+  return process.env.PERPLEXITY_MCP_STDIO === "1" || process.stdin && process.stdin.isTTY === false;
+}
+async function getUnsealMaterial() {
+  if (_unsealMaterialCache) return _unsealMaterialCache;
+  const fromKc = await keyFromKeychain();
+  if (fromKc) {
+    _unsealMaterialCache = { kind: "key", key: fromKc };
+    return _unsealMaterialCache;
+  }
+  const envPass = process.env.PERPLEXITY_VAULT_PASSPHRASE;
+  if (envPass) {
+    _unsealMaterialCache = { kind: "passphrase", passphrase: envPass };
+    return _unsealMaterialCache;
+  }
+  if (!isStdioServerMode() && process.stdin.isTTY) {
+    const { promptSecret } = await import("./tty-prompt.mjs");
+    const pass = await promptSecret({ prompt: "Perplexity vault passphrase: " });
+    if (pass) {
+      _unsealMaterialCache = { kind: "passphrase", passphrase: pass };
+      return _unsealMaterialCache;
+    }
+  }
+  throw new Error(
+    "Vault locked: no keychain, no env var, no TTY. Three unseal paths on Linux/headless: (a) install an OS keychain (libsecret + gnome-keyring) so the MCP process can read it, (b) set PERPLEXITY_VAULT_PASSPHRASE in your IDE's MCP server env block, or (c) run the VS Code extension's daemon and connect over HTTP transport instead of stdio. Codex CLI setup: docs/codex-cli-setup.md. Generic vault-unseal docs: docs/vault-unseal.md."
+  );
+}
+async function getMasterKey() {
+  if (_keyCache) return _keyCache;
+  const unseal = await getUnsealMaterial();
+  if (unseal.kind === "key") {
+    _keyCache = unseal.key;
+  } else {
+    _keyCache = hkdfFromPassphrase(unseal.passphrase, LEGACY_STATIC_SALT);
+  }
+  return _keyCache;
+}
+async function deriveKeyForHeader(header, unseal) {
+  if (unseal.kind === "key") return unseal.key;
+  if (header.version === VERSION_V1) {
+    return hkdfFromPassphrase(unseal.passphrase, LEGACY_STATIC_SALT);
+  }
+  if (header.version === VERSION_V2) {
+    return hkdfFromPassphrase(unseal.passphrase, header.salt);
+  }
+  return scryptDerive(unseal.passphrase, header.salt, header.kdfParams);
+}
+async function readVaultObject(profileName) {
+  const p = getProfilePaths(profileName).vault;
+  if (!existsSync(p)) return {};
+  const blob = readFileSync(p);
+  const header = parseVaultHeader(blob);
+  const unseal = await getUnsealMaterial();
+  const key = await deriveKeyForHeader(header, unseal);
+  const plain = aesGcmOpen(header, key);
+  try {
+    return JSON.parse(plain.toString("utf8"));
+  } catch (err) {
+    const { redact } = await import("./redact.mjs");
+    console.error(`[vault] Corrupt vault JSON for profile ${redact(profileName)}: ${redact(err.message)}`);
+    throw new Error(`Vault for profile '${profileName}' is corrupt or unreadable.`);
+  }
+}
+async function writeVaultObject(profileName, obj) {
+  const paths = getProfilePaths(profileName);
+  if (!existsSync(paths.dir)) mkdirSync(paths.dir, { recursive: true });
+  const unseal = await getUnsealMaterial();
+  const salt = randomBytes(SALT_LEN);
+  const params = getActiveKdfParams();
+  const key = unseal.kind === "key" ? unseal.key : await scryptDerive(unseal.passphrase, salt, params);
+  const iv = randomBytes(IV_LEN);
+  const cipher = createCipheriv("aes-256-gcm", key, iv);
+  const plaintext = Buffer.from(JSON.stringify(obj));
+  const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  const blob = Buffer.concat([
+    MAGIC,
+    Buffer.from([VERSION_V3, KDF_ID_SCRYPT, SCRYPT_PARAMS_LEN, params.logN, params.r, params.p, SALT_LEN]),
+    salt,
+    iv,
+    ct,
+    tag
+  ]);
+  safeAtomicWriteFileSync(paths.vault, blob);
+}
+var Vault = class {
+  async get(profile, key) {
+    const obj = await readVaultObject(profile);
+    return obj[key] ?? null;
+  }
+  async set(profile, key, value) {
+    const obj = await readVaultObject(profile);
+    obj[key] = value;
+    await writeVaultObject(profile, obj);
+  }
+  async delete(profile, key) {
+    const obj = await readVaultObject(profile);
+    delete obj[key];
+    await writeVaultObject(profile, obj);
+  }
+  async deleteAll(profile) {
+    const p = getProfilePaths(profile).vault;
+    if (existsSync(p)) rmSync(p, { force: true });
+  }
+};
+
+export {
+  __setKdfParamsForTest,
+  encryptBlob,
+  decryptBlob,
+  __resetKeyCache,
+  getUnsealMaterial,
+  getMasterKey,
+  Vault
+};

package/dist/chunk-U3DGFLXZ.mjs

@@ -0,0 +1,43 @@
+import {
+  getProfilePaths
+} from "./chunk-XKSWCEGI.mjs";
+
+// src/reinit-watcher.js
+import { existsSync, mkdirSync, watch } from "fs";
+import { dirname } from "path";
+function watchReinit(profileName, callback, opts = {}) {
+  const { debounceMs = 200 } = opts;
+  const target = getProfilePaths(profileName).reinit;
+  const parent = dirname(target);
+  if (!existsSync(parent)) mkdirSync(parent, { recursive: true });
+  let timer = null;
+  const w = watch(parent, { persistent: false }, (event, filename) => {
+    if (!filename) return;
+    if (!String(filename).endsWith(".reinit")) return;
+    if (!existsSync(target)) return;
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      try {
+        callback();
+      } catch {
+      }
+    }, debounceMs);
+  });
+  return {
+    dispose() {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      try {
+        w.close();
+      } catch {
+      }
+    }
+  };
+}
+
+export {
+  watchReinit
+};