perplexity-user-mcp 0.8.38 → 0.8.39

package/README.md

@@ -16,22 +16,34 @@ or run on demand with `npx`:
 npx perplexity-user-mcp
 ```
 
-The server speaks MCP over stdio, so normally you point your MCP client (Claude Desktop, Cursor, Windsurf, Cline, Claude Code, Amp, Codex CLI) at the binary rather than invoking it directly.
+The server speaks MCP over stdio, so normally you point your MCP client (Claude Desktop, Cursor, Windsurf, Cline, Claude Code, Amp, Codex CLI, VS Code MCP, Visual Studio 2022, OpenCode, GitHub Copilot CLI, Factory Droid, Qwen Code, Gemini CLI, Kiro, Firebase Studio, …) at the binary rather than invoking it directly.
 
 ## First run & login
 
 Login is interactive — Perplexity emails a one-time code that you have to paste back into the prompt. The MCP `perplexity_login` tool only returns instructions, because MCP tool calls cannot display interactive prompts. You log in either through the CLI or, if you have the VS Code extension, through its dashboard.
 
-Quick start from a fresh machine:
+Pick the row that matches your environment for a copy-pasteable quick start. Everything below assumes the package is installed (`npm install -g perplexity-user-mcp`).
+
+| Environment | Quick start |
+|---|---|
+| **A. Desktop + VS Code extension** | Install [the extension](https://marketplace.visualstudio.com/items?itemName=Nskha.perplexity-vscode), open the dashboard, click **Login**. The extension owns the browser, vault, and OTP prompt — no terminal needed. |
+| **B. Desktop, standalone CLI (Win / Mac / Linux with display)** | `npx perplexity-user-mcp login --mode manual` — opens a visible browser, sign in with email / Google / GitHub / Apple SSO, runner persists cookies and exits. |
+| **C. Desktop, standalone CLI, prefer terminal-only** | `npx perplexity-user-mcp install-speed-boost && npx perplexity-user-mcp login --mode auto --email me@example.com` — OTP prompt appears on stderr, paste the six-digit code from your email. |
+| **D. Headless VPS, can receive your email** | First run `npx perplexity-user-mcp setup-vault` — if the box has no OS keychain (libsecret missing on Linux servers) it generates a passphrase and prints persistence snippets (PowerShell / setx / zsh / bash / systemd / MCP-client env block). Then same as **C**. Speed Boost (impit) does the email/OTP flow over HTTP with no browser. Falls back to a browser runner only on `cf_blocked`, which fails on a true headless box — see pattern **E** if that happens. |
+| **E. Headless VPS, can't run a browser** | Log in on a desktop machine, then either set `PERPLEXITY_SESSION_TOKEN` from the cookie value on the VPS, **or** copy the vault. See [Headless / VPS deployment](#headless--vps-deployment) below. |
+| **F. Headless VPS + a desktop you control** | Run `npx perplexity-user-mcp daemon start --tunnel` on the desktop; point the VPS's MCP client at the printed Cloudflare URL with the bearer token. The desktop owns the browser; the VPS only sees a bearer-authed HTTP MCP endpoint. |
+
+Common verifications after any path:
 
 ```bash
-npm install -g perplexity-user-mcp
-npx perplexity-user-mcp install-speed-boost     # optional, strongly recommended
-npx perplexity-user-mcp login --mode auto --email me@example.com
-# terminal will prompt for the OTP from your email
+npx perplexity-user-mcp status                   # expect: valid, with a tier (Pro / Max / Enterprise / Authenticated)
+npx perplexity-user-mcp doctor                   # green across the board, especially profiles + vault
 ```
 
-`--mode auto` runs the email + OTP flow over HTTP (impit-backed if Speed Boost is installed; otherwise driven through the browser). `--mode manual` opens a visible browser window so you can sign in with Google, GitHub, or Apple SSO.
+What success vs failure looks like on the CLI:
+
+- `login finished (0)` and `status` reports `valid` → you're done.
+- Non-zero exit code from `login` is a failure even if the CLI prints a "finished" line. The runner emits a JSON line on stdout with the actual `reason`: `cf_blocked`, `chrome_missing`, `otp_rejected`, `crash`, `timeout`. Read stderr for the full message — that's where the structured error surfaces.
 
 Session state lives at `~/.perplexity-mcp/` (cookies, profile, models cache). Delete that directory to start over, or use `npx perplexity-user-mcp logout --purge`.
 
@@ -99,7 +111,7 @@ All overrides are optional and evaluated at call time:
 Most-used commands. Run `npx perplexity-user-mcp --help` for the full list (daemon, tunnel providers, etc.).
 
 ```bash
-npx perplexity-user-mcp                                  # start MCP stdio server
+npx perplexity-user-mcp                                  # start MCP stdio server (no output until a client connects)
 npx perplexity-user-mcp login [--profile X] [--mode auto|manual] [--plain-cookies]
 npx perplexity-user-mcp logout [--profile X] [--purge]
 npx perplexity-user-mcp status [--profile X] [--all]
@@ -118,9 +130,71 @@ npx perplexity-user-mcp daemon start [--port N] [--tunnel]
 npx perplexity-user-mcp --version
 ```
 
+> **Note** — `npx perplexity-user-mcp` with no subcommand starts the stdio MCP server and waits silently for JSON-RPC on stdin. There's no progress output; if you typed it expecting a login or status prompt, that's why "nothing happened." Use the explicit subcommand (`login`, `status`, etc.) for interactive operation.
+
+## Multiple accounts / profiles
+
+Each Perplexity account lives in its own profile under `~/.perplexity-mcp/profiles/<name>/`. The active profile is the one tools read cookies from. Naming them after the plan tier (`pro`, `max`, `personal`, `work`) keeps things obvious.
+
+```bash
+npx perplexity-user-mcp add-account --name pro --mode auto --email pro-account@example.com
+# ...follow the OTP prompt, persist cookies under profiles/pro/
+
+npx perplexity-user-mcp add-account --name personal --mode manual
+# opens a browser, persist under profiles/personal/
+
+npx perplexity-user-mcp list-accounts
+# * pro       [Pro]   mode=auto    lastLogin=2026-05-04...
+#   personal  [Free]  mode=manual  lastLogin=2026-05-04...
+
+npx perplexity-user-mcp switch-account personal       # switch active profile
+npx perplexity-user-mcp status                        # confirm "valid" for the new active profile
+```
+
+The MCP server picks up the active profile change immediately — version 0.8.40+ watches the active-pointer file and reloads cookies on switch, so you don't need to restart the server (or your IDE) when toggling between accounts. Pre-0.8.40 you'd see the old profile's data until the daemon was restarted.
+
+If you set `PERPLEXITY_PROFILE=<name>` in an MCP client's env block, that pins the server to that one profile regardless of `switch-account` — useful when you want one IDE on `pro` and another on `personal` simultaneously.
+
+## Headless / VPS deployment
+
+`login --mode manual` and the browser fallback for `--mode auto` both launch a real Chromium and need a graphical session. On a true headless box (no X server, no DISPLAY, no Wayland) those paths fail at browser launch with a `chrome_missing` or `crash` reason. Three workable patterns:
+
+**1. Terminal-only login (preferred when impit succeeds).** Try this first — it's the simplest and works on most VPS boxes if Cloudflare doesn't gate the email endpoint:
+
+```bash
+npx perplexity-user-mcp install-speed-boost      # required: provides the impit HTTP runner
+npx perplexity-user-mcp login --mode auto --email me@example.com
+# server emails the OTP; paste the six-digit code at the prompt on stderr
+```
+
+If this fails with `cf_blocked`, fall back to one of the other patterns. (impit is opt-in; without it the auto runner falls back to the browser, which won't work headless.)
+
+**2. Pre-supplied session token.** Log in on a desktop machine via any browser, extract the `__Secure-next-auth.session-token` cookie value, and feed it to the headless server:
+
+```bash
+PERPLEXITY_SESSION_TOKEN=<long-jwt-from-the-cookie> \
+PERPLEXITY_CSRF_TOKEN=<optional-companion-cookie> \
+  npx perplexity-user-mcp                        # stdio server bypasses login entirely
+```
+
+The cookie expires when Perplexity rotates it (typically ~30 days); refresh by re-extracting from the desktop browser. This path is acceptable for personal-use VPS boxes where the env block is `chmod 600`; do not use on shared hosts.
+
+**3. Daemon + tunnel from a desktop.** Run the daemon on a desktop machine you control, expose it via Cloudflare Quick Tunnels (built-in) or ngrok, and point your headless clients at the tunnel URL:
+
+```bash
+# on the desktop:
+npx perplexity-user-mcp daemon start --tunnel
+# prints: tunnel URL https://<random>.trycloudflare.com  bearer <token>
+# on the VPS, point your MCP client at the tunnel URL with the bearer in Authorization
+```
+
+The desktop owns the browser session and the vault; the VPS only sees a bearer-authed HTTP MCP endpoint. See [the Codex CLI setup guide](https://github.com/Automations-Project/VSCode-Perplexity-MCP/blob/main/docs/codex-cli-setup.md) for an end-to-end walkthrough using the same daemon + tunnel pattern.
+
+**Why not just `login --mode manual` on the VPS?** It launches a headed Chromium that needs `$DISPLAY`. On a server distro you'd see `Failed to launch browser process` and the runner exits with `crash`. A virtual framebuffer (`xvfb-run`) would technically work but the email/OTP step still requires a way to interact with the email — pattern 1 covers that without the X11 dependency.
+
 ## MCP client configuration
 
-Example `mcp.json` entry (Cursor, Windsurf, Claude Code format):
+Example `mcp.json` entry (Cursor, Windsurf, Claude Code, Cline, Amp, Kiro, Firebase Studio, Antigravity, Gemini CLI, Factory Droid, Qwen Code, Copilot CLI — `mcpServers` root key):
 
 ```json
 {
@@ -135,6 +209,40 @@ Example `mcp.json` entry (Cursor, Windsurf, Claude Code format):
 
 Claude Desktop (`claude_desktop_config.json`) uses the same shape.
 
+**VS Code MCP / Visual Studio 2022** use the `servers` root key with a `type` discriminator:
+
+```json
+{
+  "servers": {
+    "perplexity": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "perplexity-user-mcp"]
+    }
+  }
+}
+```
+
+Workspace paths: `.vscode/mcp.json` (VS Code), `<sln>/.mcp.json` or `%USERPROFILE%\.mcp.json` (Visual Studio 2022).
+
+**OpenCode** uses the `mcp` root key with a local-server entry shape:
+
+```json
+{
+  "mcp": {
+    "perplexity": {
+      "type": "local",
+      "command": ["npx", "-y", "perplexity-user-mcp"],
+      "enabled": true
+    }
+  }
+}
+```
+
+Path: `~/.config/opencode/opencode.json`.
+
+**Zed** uses the `context_servers` root key. **Codex CLI** uses TOML at `~/.codex/config.toml`.
+
 ## Environment variables
 
 | Variable | Purpose |

package/dist/checks/vault.d.ts

@@ -95,6 +95,47 @@ async function run(opts = {}) {
     }
   }
 
+  // Active-decrypt verification — only when an encrypted vault.enc actually
+  // exists. This catches the "user has both keychain + passphrase set, but
+  // vault.enc was written with one and the read path now prefers the other"
+  // failure mode that surfaces as "Vault decrypt failed: wrong passphrase
+  // or corrupted ciphertext" mid-login. A status check that just reports
+  // "OS keychain holds master key" is misleading if the key can't actually
+  // open the on-disk blob.
+  if (existsSync(enc) && (kc.hasKey || envPass)) {
+    try {
+      const { Vault, __resetKeyCache } = await import('../vault.d-BSJWDLhp.d.ts');
+      // Use a fresh resolution context so the doctor's verification doesn't
+      // pollute the cached unseal material for the rest of the process.
+      __resetKeyCache();
+      // Vault.get returns null for absent keys without throwing; only a
+      // genuine decrypt failure throws.
+      await new Vault().get(profile, "cookies");
+      results.push({
+        category: CATEGORY,
+        name: "unseal-verify",
+        status: "pass",
+        message: "vault.enc decrypts cleanly with the active unseal material",
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isDecryptFailure = /wrong passphrase or corrupted ciphertext|Vault decrypt failed/.test(msg);
+      results.push({
+        category: CATEGORY,
+        name: "unseal-verify",
+        status: "fail",
+        message: isDecryptFailure
+          ? "vault.enc cannot be decrypted with any available unseal material"
+          : `vault.enc unreadable: ${msg}`,
+        hint: isDecryptFailure
+          ? (kc.hasKey && envPass
+              ? "Both keychain and PERPLEXITY_VAULT_PASSPHRASE are set, but neither matches the blob. The blob was likely written under a since-rotated passphrase or a different keychain key. Run 'perplexity-user-mcp logout --purge' on this profile and log in again to write a fresh vault."
+              : "The unseal material has changed since this blob was written. Restore the original passphrase, or run 'perplexity-user-mcp logout --purge' on this profile and log in again.")
+          : "Inspect the file at the path under 'profiles' check; consider restoring from backup or purging.",
+      });
+    }
+  }
+
   return results;
 }
 

package/dist/checks/vault.mjs

@@ -83,6 +83,29 @@ async function run(opts = {}) {
       });
     }
   }
+  if (existsSync(enc) && (kc.hasKey || envPass)) {
+    try {
+      const { Vault, __resetKeyCache } = await import("../vault.mjs");
+      __resetKeyCache();
+      await new Vault().get(profile, "cookies");
+      results.push({
+        category: CATEGORY,
+        name: "unseal-verify",
+        status: "pass",
+        message: "vault.enc decrypts cleanly with the active unseal material"
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const isDecryptFailure = /wrong passphrase or corrupted ciphertext|Vault decrypt failed/.test(msg);
+      results.push({
+        category: CATEGORY,
+        name: "unseal-verify",
+        status: "fail",
+        message: isDecryptFailure ? "vault.enc cannot be decrypted with any available unseal material" : `vault.enc unreadable: ${msg}`,
+        hint: isDecryptFailure ? kc.hasKey && envPass ? "Both keychain and PERPLEXITY_VAULT_PASSPHRASE are set, but neither matches the blob. The blob was likely written under a since-rotated passphrase or a different keychain key. Run 'perplexity-user-mcp logout --purge' on this profile and log in again to write a fresh vault." : "The unseal material has changed since this blob was written. Restore the original passphrase, or run 'perplexity-user-mcp logout --purge' on this profile and log in again." : "Inspect the file at the path under 'profiles' check; consider restoring from backup or purging."
+      });
+    }
+  }
   return results;
 }
 export {

package/dist/{chunk-Q2VY4R5F.mjs → chunk-2FPGJKCA.mjs}

@@ -2,11 +2,11 @@ import {
   PerplexityClient,
   getCloudThreadViaImpit,
   listCloudThreadsViaImpit
-} from "./chunk-H4BUAPPO.mjs";
+} from "./chunk-C3HPFFTD.mjs";
 import {
   hydrateCloudEntry,
   upsertFromCloud
-} from "./chunk-OF4DMAPJ.mjs";
+} from "./chunk-B65IJQZJ.mjs";
 
 // src/cloud-sync.js
 var DEFAULT_PAGE_SIZE = 1e3;

package/dist/{chunk-ZQFUZPLO.mjs → chunk-452DK6OS.mjs}

@@ -1,9 +1,9 @@
 import {
   ensureDaemon
-} from "./chunk-X45O6YD3.mjs";
+} from "./chunk-RK4EBZJ3.mjs";
 import {
   getPackageVersion
-} from "./chunk-S5VD7WTU.mjs";
+} from "./chunk-T6ARJK2P.mjs";
 
 // src/daemon/client-http.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-OF4DMAPJ.mjs → chunk-B65IJQZJ.mjs}

@@ -1,7 +1,7 @@
 import {
   getActiveName,
   getProfilePaths
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/history-store.js
 import { randomUUID } from "crypto";

package/dist/{chunk-H4BUAPPO.mjs → chunk-C3HPFFTD.mjs}

@@ -1,12 +1,12 @@
 import {
   impitFetchJson,
   isImpitAvailable
-} from "./chunk-Z7DAACGZ.mjs";
+} from "./chunk-DQQISMYN.mjs";
 import {
   FORMAT_TO_CONTENT_TYPE,
   exportThread,
   resolveExportApiFormat
-} from "./chunk-LZPLNZ5U.mjs";
+} from "./chunk-D254EFYB.mjs";
 import {
   ASI_ACCESS_ENDPOINT,
   AUTH_SESSION_ENDPOINT,
@@ -21,12 +21,12 @@ import {
   getOrCreateContext,
   getSavedCookies,
   resolveBrowserExecutable
-} from "./chunk-LKJMLGFP.mjs";
+} from "./chunk-U7QPUNRH.mjs";
 import {
   getActiveName,
   getConfigDir,
   getProfilePaths
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/client.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-LZPLNZ5U.mjs → chunk-D254EFYB.mjs}

@@ -1,6 +1,6 @@
 import {
   PERPLEXITY_URL
-} from "./chunk-LKJMLGFP.mjs";
+} from "./chunk-U7QPUNRH.mjs";
 
 // src/export.js
 import { Buffer } from "buffer";

package/dist/{chunk-Z7DAACGZ.mjs → chunk-DQQISMYN.mjs}

@@ -9,12 +9,12 @@ import {
   getOrCreateContext,
   getSavedCookies,
   resolveBrowserExecutable
-} from "./chunk-LKJMLGFP.mjs";
+} from "./chunk-U7QPUNRH.mjs";
 import {
   getActiveName,
   getConfigDir,
   getProfilePaths
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/refresh.ts
 import { readFileSync, writeFileSync, existsSync, statSync, mkdirSync } from "fs";

package/dist/{chunk-3B276PGG.mjs → chunk-FKQ3HP4Q.mjs}

@@ -1,6 +1,6 @@
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/install-tunnel.ts
 import { createHash } from "crypto";

package/dist/{chunk-7JL36EBH.mjs → chunk-HNSPNCFH.mjs}

@@ -1,6 +1,6 @@
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 import {
   __glob
 } from "./chunk-4UEJOM6W.mjs";

package/dist/{chunk-6EP2BLTV.mjs → chunk-KJFX2ZXR.mjs}

@@ -1,6 +1,6 @@
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/lockfile.ts
 import { closeSync, existsSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, writeFileSync } from "fs";

package/dist/{chunk-YUGDOXIN.mjs → chunk-NJX4RBO6.mjs}

@@ -1,6 +1,6 @@
 import {
   ensureDaemon
-} from "./chunk-X45O6YD3.mjs";
+} from "./chunk-RK4EBZJ3.mjs";
 
 // src/daemon/attach.ts
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

package/dist/{chunk-X45O6YD3.mjs → chunk-RK4EBZJ3.mjs}

@@ -1,7 +1,7 @@
 import {
   getTunnelProvider,
   readTunnelSettings
-} from "./chunk-KCXM2M4B.mjs";
+} from "./chunk-XTRJSV72.mjs";
 import {
   acquire,
   getLockfilePath,
@@ -9,26 +9,27 @@ import {
   read,
   release,
   replace
-} from "./chunk-6EP2BLTV.mjs";
+} from "./chunk-KJFX2ZXR.mjs";
 import {
   getPackageVersion,
   startDaemonServer
-} from "./chunk-S5VD7WTU.mjs";
+} from "./chunk-T6ARJK2P.mjs";
 import {
   ensureToken,
   getTokenPath,
   readToken
-} from "./chunk-HTUAQRKH.mjs";
+} from "./chunk-TDXETAQT.mjs";
 import {
+  watchActiveProfile,
   watchReinit
-} from "./chunk-U3DGFLXZ.mjs";
+} from "./chunk-WDIW33DA.mjs";
 import {
   PerplexityClient
-} from "./chunk-H4BUAPPO.mjs";
+} from "./chunk-C3HPFFTD.mjs";
 import {
   getActiveName,
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/launcher.ts
 import { spawn } from "child_process";
@@ -186,13 +187,15 @@ async function startDaemon(options = {}) {
       continue;
     }
     let watcher;
+    let activeWatcher;
     let server;
     let finalizePromise = null;
     let finalizeResolve;
     const closed = new Promise((resolve) => {
       finalizeResolve = resolve;
     });
-    const profile = process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+    let currentWatchedProfile = process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+    const profile = currentWatchedProfile;
     const client = options.createClient ? options.createClient() : new PerplexityClient();
     let tunnelState = {
       status: "disabled",
@@ -289,6 +292,7 @@ async function startDaemon(options = {}) {
         finalizePromise = (async () => {
           await disableTunnelRuntime().catch(() => void 0);
           watcher?.dispose();
+          activeWatcher?.dispose();
           if (options.signal && abortHandler) {
             options.signal.removeEventListener("abort", abortHandler);
           }
@@ -313,9 +317,24 @@ async function startDaemon(options = {}) {
       await finalize();
     };
     try {
-      watcher = watchReinit(profile, async () => {
+      watcher = watchReinit(currentWatchedProfile, async () => {
         await client.reinit();
       });
+      activeWatcher = watchActiveProfile(configDir, async () => {
+        try {
+          const nextProfile = process.env.PERPLEXITY_PROFILE || getActiveName() || "default";
+          if (nextProfile !== currentWatchedProfile) {
+            currentWatchedProfile = nextProfile;
+            watcher?.dispose();
+            watcher = watchReinit(nextProfile, async () => {
+              await client.reinit();
+            });
+          }
+          await client.reinit();
+        } catch (err) {
+          console.error(`[perplexity-mcp] active-profile watcher: ${err.message}`);
+        }
+      });
       server = await startDaemonServer({
         host: options.host,
         port: options.port,

package/dist/{chunk-TQLCLE4L.mjs → chunk-S677V2JU.mjs}

@@ -3,12 +3,12 @@ import {
 } from "./chunk-MTDFKNXX.mjs";
 import {
   getProfilePaths
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.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 { existsSync, readFileSync, mkdirSync, renameSync, rmSync } from "fs";
 import { dirname } from "path";
 var MAGIC = Buffer.from("PXVT");
 var VERSION_V1 = 1;
@@ -255,6 +255,14 @@ async function getUnsealMaterial() {
     "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 getAllUnsealMaterials() {
+  const materials = [];
+  const fromKc = await keyFromKeychain();
+  if (fromKc) materials.push({ kind: "key", key: fromKc });
+  const envPass = process.env.PERPLEXITY_VAULT_PASSPHRASE;
+  if (envPass) materials.push({ kind: "passphrase", passphrase: envPass });
+  return materials;
+}
 async function getMasterKey() {
   if (_keyCache) return _keyCache;
   const unseal = await getUnsealMaterial();
@@ -280,16 +288,31 @@ async function readVaultObject(profileName) {
   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.`);
+  const materials = _unsealMaterialCache ? [_unsealMaterialCache, ...(await getAllUnsealMaterials()).filter((m) => m !== _unsealMaterialCache)] : await getAllUnsealMaterials();
+  if (materials.length === 0) {
+    await getUnsealMaterial();
+    return {};
   }
+  let lastErr;
+  for (const unseal of materials) {
+    try {
+      const key = await deriveKeyForHeader(header, unseal);
+      const plain = aesGcmOpen(header, key);
+      try {
+        const parsed = JSON.parse(plain.toString("utf8"));
+        _unsealMaterialCache = unseal;
+        return parsed;
+      } 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.`);
+      }
+    } catch (err) {
+      lastErr = err;
+      if (!/wrong passphrase or corrupted ciphertext/.test(String(err?.message ?? ""))) throw err;
+    }
+  }
+  throw lastErr ?? new Error("Vault decrypt failed: no unseal material succeeded.");
 }
 async function writeVaultObject(profileName, obj) {
   const paths = getProfilePaths(profileName);
@@ -319,7 +342,28 @@ var Vault = class {
     return obj[key] ?? null;
   }
   async set(profile, key, value) {
-    const obj = await readVaultObject(profile);
+    let obj;
+    try {
+      obj = await readVaultObject(profile);
+    } catch (err) {
+      const msg = String(err?.message ?? "");
+      if (/wrong passphrase or corrupted ciphertext|Vault decrypt failed/.test(msg)) {
+        const paths = getProfilePaths(profile);
+        if (existsSync(paths.vault)) {
+          const quarantine = `${paths.vault}.unreadable.${Date.now()}.bak`;
+          try {
+            renameSync(paths.vault, quarantine);
+          } catch {
+          }
+          console.error(
+            `[vault] WARN existing vault.enc for profile '${profile}' could not be decrypted with any available unseal material; quarantined at ${quarantine} and starting fresh. Possible cause: keychain key rotation or PERPLEXITY_VAULT_PASSPHRASE change. Original error: ${msg}`
+          );
+        }
+        obj = {};
+      } else {
+        throw err;
+      }
+    }
     obj[key] = value;
     await writeVaultObject(profile, obj);
   }
@@ -340,6 +384,7 @@ export {
   decryptBlob,
   __resetKeyCache,
   getUnsealMaterial,
+  getAllUnsealMaterials,
   getMasterKey,
   Vault
 };

package/dist/{chunk-S5VD7WTU.mjs → chunk-T6ARJK2P.mjs}

@@ -2,22 +2,22 @@ import {
   appendAuditEntry,
   getAuditLogPath,
   readAuditTail
-} from "./chunk-PE23RMXY.mjs";
+} from "./chunk-V4U3JM4R.mjs";
 import {
   ensureToken,
   getTokenPath,
   rotateToken
-} from "./chunk-HTUAQRKH.mjs";
+} from "./chunk-TDXETAQT.mjs";
 import {
   hydrateCloudHistoryEntry,
   syncCloudHistory
-} from "./chunk-Q2VY4R5F.mjs";
+} from "./chunk-2FPGJKCA.mjs";
 import {
   PerplexityClient,
   exportThreadViaImpit,
   readCachedAccountInfoFromDisk,
   retrieveThreadViaImpit
-} from "./chunk-H4BUAPPO.mjs";
+} from "./chunk-C3HPFFTD.mjs";
 import {
   append,
   findPendingByThread,
@@ -26,13 +26,13 @@ import {
   getHistoryDir,
   list,
   update
-} from "./chunk-OF4DMAPJ.mjs";
+} from "./chunk-B65IJQZJ.mjs";
 import {
   safeAtomicWriteFileSync
 } from "./chunk-MTDFKNXX.mjs";
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/server.ts
 import { createServer } from "http";

package/dist/{chunk-HTUAQRKH.mjs → chunk-TDXETAQT.mjs}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-MTDFKNXX.mjs";
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/token.ts
 import { randomBytes } from "crypto";

package/dist/{chunk-LKJMLGFP.mjs → chunk-U7QPUNRH.mjs}

@@ -1,10 +1,10 @@
 import {
   Vault
-} from "./chunk-TQLCLE4L.mjs";
+} from "./chunk-S677V2JU.mjs";
 import {
   getActiveName,
   getProfilePaths
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/config.ts
 import { existsSync } from "fs";

package/dist/{chunk-PE23RMXY.mjs → chunk-V4U3JM4R.mjs}

@@ -1,6 +1,6 @@
 import {
   getConfigDir
-} from "./chunk-XKSWCEGI.mjs";
+} from "./chunk-HJIXH6CL.mjs";
 
 // src/daemon/audit.ts
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync } from "fs";