perplexity-user-mcp 0.8.37 → 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 |
@@ -165,6 +273,92 @@ Claude Desktop (`claude_desktop_config.json`) uses the same shape.
 - `perplexity_login` — returns login instructions (interactive login runs via the CLI / extension)
 - `perplexity_doctor` — run diagnostic checks across browser, profile, auth, and network and return a Markdown report (pass `probe:true` for a live search probe)
 
+## Search sources and advanced queries
+
+Search-style tools support Perplexity source focus through a `sources` argument:
+
+- `web` — general web search. This is the default.
+- `scholar` — scholarly / academic source focus.
+- `social` — social discussion source focus.
+
+The source selector is explicit. If `sources` is omitted, the server sends `["web"]`.
+
+Examples:
+
+```json
+{
+  "tool": "perplexity_search",
+  "arguments": {
+    "query": "recent papers on retrieval augmented generation evaluation",
+    "sources": ["scholar"],
+    "language": "en-US"
+  }
+}
+```
+
+```json
+{
+  "tool": "perplexity_ask",
+  "arguments": {
+    "query": "What are practitioners saying about Cursor versus Windsurf for large TypeScript repos?",
+    "sources": ["social"],
+    "mode": "copilot"
+  }
+}
+```
+
+```json
+{
+  "tool": "perplexity_research",
+  "arguments": {
+    "query": "Compare academic evidence and practitioner discussion around code review automation",
+    "sources": ["scholar", "social"],
+    "language": "en-US"
+  }
+}
+```
+
+Natural-language prompts usually work too when they name the desired source mode:
+
+- "Use Perplexity scholar sources for recent papers on agentic search evaluation."
+- "Search social sources for developer reports about Claude Code memory issues."
+- "Run deep research using both scholar and web sources, and cite every claim."
+- "Use `perplexity_ask` with `sources: [\"social\"]` and keep the answer concise."
+
+Useful shorthand:
+
+- "search ..." usually maps to `perplexity_search` for quick lookup and source discovery.
+- "ask Perplexity ..." usually maps to `perplexity_ask` for a synthesized answer with citations.
+- "reason through ..." usually maps to `perplexity_reason` for multi-step analysis.
+- "research deeply ..." usually maps to `perplexity_research` for longer reports.
+- "use ASI", "Computer mode", "run a compute task", or "do code/execution-style analysis" maps to `perplexity_compute` when the account has Computer-mode access.
+
+For ASI / Computer mode, ask for `perplexity_compute` by name when precision matters:
+
+```json
+{
+  "tool": "perplexity_compute",
+  "arguments": {
+    "query": "Model the true cost of a 5 kW residential solar installation in the Philippines versus investing the same cash at 6% annually over 10 and 20 years. Show assumptions, calculations, and sensitivity cases.",
+    "language": "en-US"
+  }
+}
+```
+
+### Defaults
+
+| Tool | Model default | Mode default | Sources default | Language default |
+|---|---|---|---|---|
+| `perplexity_search` | Authenticated: `pplx_pro`; anonymous: `turbo` | Authenticated: `copilot`; anonymous: `concise` | `["web"]` | `en-US` |
+| `perplexity_ask` | `PERPLEXITY_SEARCH_MODEL` or `pplx_pro` | `copilot` | `["web"]` | `en-US` |
+| `perplexity_reason` | `PERPLEXITY_REASON_MODEL` or `claude46sonnetthinking` | `copilot` | `["web"]` | `en-US` |
+| `perplexity_research` | `PERPLEXITY_RESEARCH_MODEL` or `pplx_alpha` | `copilot` | `["web"]` | `en-US` |
+| `perplexity_compute` | Tool argument, then `PERPLEXITY_COMPUTE_MODEL`, then account ASI default, then `pplx_asi` | `asi` | web-only Computer mode | `en-US` |
+
+Model defaults are configurable with `PERPLEXITY_SEARCH_MODEL`, `PERPLEXITY_REASON_MODEL`, `PERPLEXITY_RESEARCH_MODEL`, and `PERPLEXITY_COMPUTE_MODEL`. `perplexity_ask`, `perplexity_reason`, and `perplexity_compute` also accept a per-call `model` argument. `perplexity_ask` accepts `mode: "concise" | "copilot"`.
+
+Under the hood, search-style tools post a Perplexity web-app style request from the logged-in browser session to `https://www.perplexity.ai/rest/sse/perplexity_ask`. The response is a Server-Sent Events stream, which the MCP runtime parses into answer text, citation sources, media items, suggested follow-ups, follow-up context, and the Perplexity thread URL.
+
 ## Library use
 
 Subpath exports are published for embedding the same runtime inside other Node tooling:

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-SVPRB62V.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,