From 7db9888ddf478df8cc87e2f9e7cdfe29f9ae3204 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:03:17 +0300
Subject: [PATCH 01/13] fix(#6.1): resolve symlinks in direct-run guard

`import.meta.url === pathToFileURL(process.argv[1]).href` silently
returned false when the CLI was invoked through a symlink (npm .bin,
Homebrew Cellar, etc.), causing the CLI to exit 0 with no output.

Extract a shared `isMainModule()` helper that resolves both sides
through `realpathSync` before comparing, with a graceful fallback
to the old behavior if realpath fails.

Files: cli.js, index.ts, is-main-module.js(+d.ts)
---
 packages/mcp-server/src/cli.js              |  7 ++--
 packages/mcp-server/src/index.ts            |  4 +--
 packages/mcp-server/src/is-main-module.d.ts |  6 ++++
 packages/mcp-server/src/is-main-module.js   | 37 +++++++++++++++++++++
 4 files changed, 49 insertions(+), 5 deletions(-)
 create mode 100644 packages/mcp-server/src/is-main-module.d.ts
 create mode 100644 packages/mcp-server/src/is-main-module.js

diff --git a/packages/mcp-server/src/cli.js b/packages/mcp-server/src/cli.js
index 274b42b..b9487b8 100644
--- a/packages/mcp-server/src/cli.js
+++ b/packages/mcp-server/src/cli.js
@@ -8,6 +8,7 @@ import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { fileURLToPath, pathToFileURL } from "node:url";
+import { isMainModule } from "./is-main-module.js";
 
 const execFile = promisify(execFileCallback);
 
@@ -1302,8 +1303,8 @@ Environment:
   PERPLEXITY_NO_DAEMON=1        'daemon attach' runs in-process stdio (bypass daemon)
 `;
 
-/* v8 ignore start -- only runs when cli.js is executed as a script */
-if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+
+if (isMainModule(import.meta.url)) {
   const parsed = parseArgs(process.argv.slice(2));
   routeCommand(parsed).then((res) => {
     if (res.stdout) process.stdout.write(res.stdout);
@@ -1311,4 +1312,4 @@ if (import.meta.url === pathToFileURL(process.argv[1]).href) {
     process.exit(res.code);
   });
 }
-/* v8 ignore stop */
+
diff --git a/packages/mcp-server/src/index.ts b/packages/mcp-server/src/index.ts
index 322df8c..597ad00 100644
--- a/packages/mcp-server/src/index.ts
+++ b/packages/mcp-server/src/index.ts
@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { pathToFileURL } from "node:url";
+import { isMainModule } from "./is-main-module.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { PerplexityClient } from "./client.js";
@@ -191,7 +191,7 @@ export async function main() {
   }
 }
 
-if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+if (isMainModule(import.meta.url)) {
   runEntrypoint().catch(async (error) => {
     console.error("[perplexity-mcp] Fatal error:", error);
     await shutdownClientWithTimeout(client);
diff --git a/packages/mcp-server/src/is-main-module.d.ts b/packages/mcp-server/src/is-main-module.d.ts
new file mode 100644
index 0000000..8f42651
--- /dev/null
+++ b/packages/mcp-server/src/is-main-module.d.ts
@@ -0,0 +1,6 @@
+/**
+ * Returns true when the importing module is the process entrypoint (i.e. was
+ * invoked as `node <script>` or via a bin symlink), false when it was imported
+ * by another module.
+ */
+export function isMainModule(metaUrl: string): boolean;
diff --git a/packages/mcp-server/src/is-main-module.js b/packages/mcp-server/src/is-main-module.js
new file mode 100644
index 0000000..f731fec
--- /dev/null
+++ b/packages/mcp-server/src/is-main-module.js
@@ -0,0 +1,37 @@
+// Direct-run guard helper shared between cli.js and index.ts. Both entrypoints
+// historically used `import.meta.url === pathToFileURL(process.argv[1]).href`,
+// which silently returns false when the bin is invoked through a symlink
+// (Homebrew's `Cellar/...` layout, npm's `node_modules/.bin/<name>` symlink,
+// or any user-created symlink): the LHS resolves to the realpath of the built
+// `dist/cli.mjs` file while the RHS still points at the symlink. The result
+// was a CLI that silently exited 0 with no output for any user whose `bin`
+// path was symlinked — confirmed by issue #6.
+//
+// We resolve both sides through `realpathSync` so symlink layers don't matter,
+// and fall back to the unresolved URL comparison when realpath rejects (rare:
+// virtual filesystems, missing-file races on uninstall, restricted sandboxes).
+
+import { realpathSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+/**
+ * Returns true when the importing module is the process entrypoint (i.e. was
+ * invoked as `node <script>` or via a bin symlink), false when it was imported
+ * by another module.
+ *
+ * @param {string} metaUrl - The caller's `import.meta.url`
+ * @returns {boolean}
+ */
+export function isMainModule(metaUrl) {
+  if (!process.argv[1]) return false;
+  try {
+    const moduleReal = realpathSync(fileURLToPath(metaUrl));
+    const argvReal = realpathSync(process.argv[1]);
+    return moduleReal === argvReal;
+  } catch {
+    // Defensive fallback to the original (broken-on-symlinks) comparison.
+    // Kept so a realpath failure on an exotic platform degrades to the
+    // pre-fix behavior rather than crashing the CLI outright.
+    return metaUrl === pathToFileURL(process.argv[1]).href;
+  }
+}

From 942821cb223af70b6146036bc49bbdb0787a9ef8 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:09:14 +0300
Subject: [PATCH 02/13] fix(#6.2): add shebang + exec bit to dist/cli.mjs
 post-build

npm's bin linker creates symlinks (not wrappers) on POSIX, so the
kernel needs a shebang in `dist/cli.mjs` for direct `./dist/cli.mjs`
execution to work.

Add `scripts/post-build-shebang.mjs` that prepends `#!/usr/bin/env node`
and chmods to 755, wired into the `build` script after tsup.
Update the tsup.config.ts comment to document the new pipeline.

Refs issue #6
---
 packages/mcp-server/package.json   | 2 +-
 packages/mcp-server/tsup.config.ts | 9 ++++-----
 2 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 20472e6..14df915 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -126,7 +126,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup",
+    "build": "tsup && node scripts/post-build-shebang.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "cd ../.. && npx vitest run packages/mcp-server/test",
     "test:coverage": "cd ../.. && npx vitest run --coverage packages/mcp-server/test"
diff --git a/packages/mcp-server/tsup.config.ts b/packages/mcp-server/tsup.config.ts
index 2d9cfbf..b563e82 100644
--- a/packages/mcp-server/tsup.config.ts
+++ b/packages/mcp-server/tsup.config.ts
@@ -80,10 +80,9 @@ export default defineConfig({
     "helmet",
   ],
   // Shebang is NOT emitted into source files — it tripped vitest/esbuild
-  // during test imports of cli.js. npm's `bin` linker wraps the entry with
-  // its own node invocation on install, so the shebang isn't required for
-  // `npx perplexity-user-mcp` to work. If direct execution (`./dist/cli.mjs`)
-  // ever needs to work without npm, re-add via a post-build script that
-  // targets cli.mjs specifically.
+  // during test imports of cli.js.  A post-build script (see package.json
+  // `build` and scripts/post-build-shebang.mjs) prepends the shebang to
+  // `dist/cli.mjs` and chmods it to 755 so that direct execution works
+  // on POSIX where npm creates symlinks rather than wrapper scripts.
   outExtension: () => ({ js: ".mjs" }),
 });

From ae60549754b6f8a11359e71e2a074b119e902d25 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:28:26 +0300
Subject: [PATCH 03/13] fix(#6.3): cache keytar probe + add
 PERPLEXITY_DISABLE_KEYCHAIN=1 escape hatch

macOS users reported repeated Keychain permission prompts because four
independent code paths each did an uncached `import("keytar")` call.

- vault.js: Cache the keytar module load (both success and failure) in
  `_keytarModuleCache` per-process. Add `isKeychainDisabled()` helper
  that respects `PERPLEXITY_DISABLE_KEYCHAIN=1`.
- Export `probeKeychainState()` from vault.js so cli.js and
  checks/vault.js can share the cached probe instead of doing their own
  inline imports.
- extension/src/auth/vault-passphrase.ts: Check the env var before
  spawning the keytar probe child process, and also inside the child
  inline code.

Fixes issue #6 bug 3.
---
 .../extension/src/auth/vault-passphrase.ts    |  6 +++
 packages/mcp-server/src/checks/vault.js       | 13 +-----
 packages/mcp-server/src/cli.js                | 23 +---------
 packages/mcp-server/src/vault.js              | 42 ++++++++++++++++++-
 4 files changed, 50 insertions(+), 34 deletions(-)

diff --git a/packages/extension/src/auth/vault-passphrase.ts b/packages/extension/src/auth/vault-passphrase.ts
index 9bd3d49..eff40a1 100644
--- a/packages/extension/src/auth/vault-passphrase.ts
+++ b/packages/extension/src/auth/vault-passphrase.ts
@@ -126,6 +126,9 @@ export async function peekStoredVaultPassphrase(
 export async function probeKeytarAvailable(
   context: vscode.ExtensionContext,
 ): Promise<boolean> {
+  if (process.env.PERPLEXITY_DISABLE_KEYCHAIN === "1") {
+    return false;
+  }
   // Use the bundled mcp-server probe so we agree with the runner's own
   // detection. The file lives at `dist/mcp/server.mjs` when packaged; the
   // runner scripts sit next to it. We spawn a 1-shot inline script so we don't
@@ -137,6 +140,9 @@ export async function probeKeytarAvailable(
     // prepare-package-deps copies keytar into `dist/node_modules`.
     const code = `
       (async () => {
+        if (process.env.PERPLEXITY_DISABLE_KEYCHAIN === "1") {
+          process.exit(4);
+        }
         try {
           const mod = await import("keytar");
           const kt = mod.default ?? mod;
diff --git a/packages/mcp-server/src/checks/vault.js b/packages/mcp-server/src/checks/vault.js
index ee5724a..b05e4a8 100644
--- a/packages/mcp-server/src/checks/vault.js
+++ b/packages/mcp-server/src/checks/vault.js
@@ -3,17 +3,6 @@ import { join } from "node:path";
 
 const CATEGORY = "vault";
 
-async function tryKeychain() {
-  try {
-    const mod = await import("keytar");
-    const keytar = mod.default ?? mod;
-    const hex = await keytar.getPassword("perplexity-user-mcp", "vault-master-key");
-    return { available: true, hasKey: !!hex };
-  } catch {
-    return { available: false, hasKey: false };
-  }
-}
-
 function keychainExpected() {
   return process.platform === "win32" || process.platform === "darwin" ||
     (process.platform === "linux" && !process.env.CI);
@@ -26,7 +15,7 @@ export async function run(opts = {}) {
   const enc = join(dir, "profiles", profile, "vault.enc");
   const plain = join(dir, "profiles", profile, "vault.json");
   const envPass = process.env.PERPLEXITY_VAULT_PASSPHRASE;
-  const kc = await tryKeychain();
+  const kc = await probeKeychainState();
 
   // Encryption mode (separate from unseal path so plaintext opt-out is always a warn, not a skip).
   if (existsSync(plain)) {
diff --git a/packages/mcp-server/src/cli.js b/packages/mcp-server/src/cli.js
index b9487b8..49ea6b0 100644
--- a/packages/mcp-server/src/cli.js
+++ b/packages/mcp-server/src/cli.js
@@ -9,6 +9,7 @@ import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { isMainModule } from "./is-main-module.js";
+import { probeKeychainState } from "./vault.js";
 
 const execFile = promisify(execFileCallback);
 
@@ -92,27 +93,7 @@ function normalizeExportFormat(value) {
  * advice stays consistent with what the runner will actually do.
  */
 async function probeVaultState({ profile } = {}) {
-  let keychainAvailable = false;
-  let keychainHasKey = false;
-  try {
-    const mod = await import("keytar");
-    const keytar = mod.default ?? mod;
-    if (keytar && typeof keytar.getPassword === "function") {
-      keychainAvailable = true;
-      try {
-        const hex = await keytar.getPassword("perplexity-user-mcp", "vault-master-key");
-        keychainHasKey = !!hex;
-      } catch {
-        // getPassword can throw on broken credstore backends (e.g. headless
-        // Linux without libsecret). The binding loaded but isn't usable —
-        // treat that as "available but no key", same posture as a fresh
-        // box. vault.js falls back to env var when keychain returns null.
-        keychainHasKey = false;
-      }
-    }
-  } catch {
-    keychainAvailable = false;
-  }
+  const { available: keychainAvailable, hasKey: keychainHasKey } = await probeKeychainState();
   const envPassphraseSet = !!process.env.PERPLEXITY_VAULT_PASSPHRASE;
   const hasTty = process.stdin?.isTTY === true && process.env.PERPLEXITY_MCP_STDIO !== "1";
 
diff --git a/packages/mcp-server/src/vault.js b/packages/mcp-server/src/vault.js
index a26de35..1b1b856 100644
--- a/packages/mcp-server/src/vault.js
+++ b/packages/mcp-server/src/vault.js
@@ -71,6 +71,7 @@ const scryptAsync = promisify(nodeScrypt);
 // sets the seam, so the floor remains enforced. Cleared by `__resetKeyCache`.
 let _kdfParamsOverride = null;
 let _kdfTestModeActive = false;
+  _keytarModuleCache = null;
 
 /**
  * TEST SEAM — drop scrypt cost during tests by setting (logN, r, p).
@@ -320,6 +321,14 @@ const KEYTAR_ACCOUNT = "vault-master-key";
 let _keyCache = null;
 let _unsealMaterialCache = null;
 
+/** Module-level keytar probe cache. `null` = not checked yet; `false` = unavailable. */
+let _keytarModuleCache = null;
+
+/** Environment escape hatch to suppress all keychain access (issue #6 bug 3). */
+function isKeychainDisabled() {
+  return process.env.PERPLEXITY_DISABLE_KEYCHAIN === "1";
+}
+
 /**
  * Reset the in-memory caches (key, unseal material, and the test-seam KDF
  * params override). Called on profile-state changes (account switch, login,
@@ -330,13 +339,19 @@ export function __resetKeyCache() {
   _unsealMaterialCache = null;
   _kdfParamsOverride = null;
   _kdfTestModeActive = false;
+  _keytarModuleCache = null;
 }
 
 async function tryKeytar() {
+  if (isKeychainDisabled()) return null;
+  if (_keytarModuleCache !== null) return _keytarModuleCache;
   try {
     const mod = await import("keytar");
-    return mod.default ?? mod;
+    const keytar = mod.default ?? mod;
+    _keytarModuleCache = keytar;
+    return keytar;
   } catch {
+    _keytarModuleCache = false;
     return null;
   }
 }
@@ -360,6 +375,31 @@ async function keyFromKeychain() {
   }
 }
 
+
+/**
+ * Probe the OS keychain for vault unseal capability. Returns whether keytar is
+ * available and whether a master key already exists. Caches the keytar
+ * availability check per-process so repeated probes do not trigger multiple
+ * macOS Keychain permission prompts (issue #6 bug 3). Respects
+ * PERPLEXITY_DISABLE_KEYCHAIN=1.
+ *
+ * @returns {Promise<{available: boolean, hasKey: boolean}>}
+ */
+export async function probeKeychainState() {
+  if (isKeychainDisabled()) {
+    return { available: false, hasKey: false };
+  }
+  const keytar = await tryKeytar();
+  if (!keytar) {
+    return { available: false, hasKey: false };
+  }
+  try {
+    const hex = await keytar.getPassword(KEYTAR_SERVICE, KEYTAR_ACCOUNT);
+    return { available: true, hasKey: !!hex };
+  } catch {
+    return { available: true, hasKey: false };
+  }
+}
 function isStdioServerMode() {
   return process.env.PERPLEXITY_MCP_STDIO === "1" || (process.stdin && process.stdin.isTTY === false);
 }

From fd85176742c59eec688ce91dc892926eb9abc221 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:30:50 +0300
Subject: [PATCH 04/13] fix(#6.4): use persistent browser context for login
 runners

The manual and auto login runners used `chromium.launch()` +
`browser.newContext()`, which created a fresh ephemeral context every
run. Any Cloudflare clearance cookies acquired during the login flow
were lost on browser close, forcing the user through CF again on the
next login.

Switch both runners to `chromium.launchPersistentContext()` using a
dedicated `login-browser-data/` directory under the profile (separate
from the daemon's `browser-data/` to avoid singleton-lock collisions).

Add `loginBrowserData` path to `getProfilePaths()` in profiles.js.

Fixes issue #6 bug 4.
---
 packages/mcp-server/src/login-runner.js       | 20 +++++++++----------
 .../mcp-server/src/manual-login-runner.js     | 18 ++++++++---------
 packages/mcp-server/src/profiles.js           |  1 +
 3 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/packages/mcp-server/src/login-runner.js b/packages/mcp-server/src/login-runner.js
index c7cab22..e3a235a 100644
--- a/packages/mcp-server/src/login-runner.js
+++ b/packages/mcp-server/src/login-runner.js
@@ -58,6 +58,7 @@ async function main() {
   }
 
   const PROFILE = resolveProfile();
+  const paths = getProfilePaths(PROFILE);
   const localOrigin = isLocalOrigin(ORIGIN);
 
   let executablePath;
@@ -71,13 +72,13 @@ async function main() {
     }
   }
 
-  const browser = await chromium.launch({
+  const ctx = await chromium.launchPersistentContext(paths.loginBrowserData, {
     headless: localOrigin,
+    ignoreHTTPSErrors: true,
     ...(executablePath ? { executablePath } : {}),
     ...(channel && ["chrome", "msedge", "chromium"].includes(channel) ? { channel } : {}),
     args: localOrigin ? [] : ["--start-minimized"],
   });
-  const ctx = await browser.newContext({ ignoreHTTPSErrors: true });
   const page = await ctx.newPage();
 
   try {
@@ -88,7 +89,7 @@ async function main() {
   const ready = await waitForLoginReady(page);
   if (!ready) {
     const title = await page.title().catch(() => "");
-    await browser.close().catch(() => {});
+    await ctx.browser().close().catch(() => {});
     emit({ ok: false, reason: /just a moment/i.test(title) ? "cf_blocked" : "auto_unsupported" });
     process.exit(/just a moment/i.test(title) ? 3 : 2);
   }
@@ -101,19 +102,19 @@ async function main() {
   if (!localOrigin) await minimizePageWindow(page);
 
   if (authFlow.kind === "sso_required") {
-    await browser.close().catch(() => {});
+    await ctx.browser().close().catch(() => {});
     emit({ ok: false, reason: "sso_required" });
     process.exit(2);
   }
 
   if (authFlow.kind === "unsupported") {
-    await browser.close().catch(() => {});
+    await ctx.browser().close().catch(() => {});
     emit({ ok: false, reason: "auto_unsupported", detail: authFlow.detail });
     process.exit(2);
   }
 
   if (authFlow.kind === "email_rejected") {
-    await browser.close().catch(() => {});
+    await ctx.browser().close().catch(() => {});
     emit({ ok: false, reason: "email_rejected", detail: authFlow.detail });
     process.exit(2);
   }
@@ -124,7 +125,7 @@ async function main() {
     try {
       otp = await awaitOtp();
     } catch {
-      await browser.close().catch(() => {});
+      await ctx.browser().close().catch(() => {});
       emit({ ok: false, reason: "otp_timeout" });
       process.exit(2);
     }
@@ -142,13 +143,12 @@ async function main() {
       if (metadata.sessionData?.user?.email) await vault.set(PROFILE, "email", metadata.sessionData.user.email);
       if (metadata.sessionData?.user?.id) await vault.set(PROFILE, "userId", metadata.sessionData.user.id);
 
-      const paths = getProfilePaths(PROFILE);
       if (!existsSync(paths.dir)) mkdirSync(paths.dir, { recursive: true });
       writeFileSync(paths.modelsCache, JSON.stringify(metadata.cache, null, 2));
       recordLoginSuccess(PROFILE, { tier: metadata.tier, loginMode: "auto", lastLogin: new Date().toISOString() });
       writeFileSync(paths.reinit, String(Date.now()));
 
-      await browser.close().catch(() => {});
+      await ctx.browser().close().catch(() => {});
       emit({ ok: true, tier: metadata.tier, modelCount: Object.keys(metadata.models?.models ?? {}).length });
       process.exit(0);
     }
@@ -159,7 +159,7 @@ async function main() {
     }
 
     if (attempt === MAX_RETRIES) {
-      await browser.close().catch(() => {});
+      await ctx.browser().close().catch(() => {});
       emit({ ok: false, reason: "otp_rejected" });
       process.exit(2);
     }
diff --git a/packages/mcp-server/src/manual-login-runner.js b/packages/mcp-server/src/manual-login-runner.js
index 188dff6..6d136cf 100644
--- a/packages/mcp-server/src/manual-login-runner.js
+++ b/packages/mcp-server/src/manual-login-runner.js
@@ -30,6 +30,7 @@ function emit(obj) { process.stdout.write(JSON.stringify(obj) + "\n"); }
 
 async function main() {
   const PROFILE = resolveProfile();
+  const paths = getProfilePaths(PROFILE);
 
   let executablePath;
   let channel;
@@ -42,16 +43,16 @@ async function main() {
     }
   }
 
-  const browser = await chromium.launch({
+  const ctx = await chromium.launchPersistentContext(paths.loginBrowserData, {
     headless: isTest,
+    ignoreHTTPSErrors: true,
     ...(executablePath ? { executablePath } : {}),
     ...(channel && ["chrome", "msedge", "chromium"].includes(channel) ? { channel } : {}),
-  });  // isTest = headless in CI; humans see headed.
-  const ctx = await browser.newContext({ ignoreHTTPSErrors: true });
+  });
   const page = await ctx.newPage();
 
   let cfClosed = false;
-  browser.on("disconnected", () => { cfClosed = true; });
+  ctx.browser().on("disconnected", () => { cfClosed = true; });
 
   // Navigate to the login page so the page has a same-origin context for
   // subsequent credentialed fetch() calls. Going to ORIGIN's root path can
@@ -73,7 +74,7 @@ async function main() {
   if (Date.now() - cfStart >= CF_TIMEOUT_MS) {
     const title = await page.title().catch(() => "");
     if (/just a moment/i.test(title)) {
-      await browser.close().catch(() => {});
+      await ctx.browser().close().catch(() => {});
       emit({ ok: false, reason: "cf_blocked" });
       process.exit(3);
     }
@@ -93,7 +94,7 @@ async function main() {
 
   // Test hook: force a browser close to exercise the cancelled path.
   if (process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS) {
-    setTimeout(() => browser.close().catch(() => {}), Number(process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS));
+    setTimeout(() => ctx.browser().close().catch(() => {}), Number(process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS));
   }
 
   const started = Date.now();
@@ -109,7 +110,7 @@ async function main() {
     if (sessionCookie) break;
   }
   if (!sessionCookie) {
-    await browser.close().catch(() => {});
+    await ctx.browser().close().catch(() => {});
     emit({ ok: false, reason: "timeout" });
     process.exit(2);
   }
@@ -122,7 +123,6 @@ async function main() {
   if (metadata.sessionData?.user?.email) await vault.set(PROFILE, "email", metadata.sessionData.user.email);
   if (metadata.sessionData?.user?.id) await vault.set(PROFILE, "userId", metadata.sessionData.user.id);
 
-  const paths = getProfilePaths(PROFILE);
   if (!existsSync(paths.dir)) mkdirSync(paths.dir, { recursive: true });
   writeFileSync(paths.modelsCache, JSON.stringify(metadata.cache, null, 2));
 
@@ -130,7 +130,7 @@ async function main() {
 
   writeFileSync(paths.reinit, String(Date.now()));
 
-  await browser.close().catch(() => {});
+  await ctx.browser().close().catch(() => {});
   emit({ ok: true, tier: metadata.tier, modelCount: Object.keys(metadata.models?.models ?? {}).length });
   process.exit(0);
 }
diff --git a/packages/mcp-server/src/profiles.js b/packages/mcp-server/src/profiles.js
index 28fbf6d..6ed72f2 100644
--- a/packages/mcp-server/src/profiles.js
+++ b/packages/mcp-server/src/profiles.js
@@ -23,6 +23,7 @@ export function getProfilePaths(name) {
     vault: join(dir, "vault.enc"),
     vaultPlain: join(dir, "vault.json"),
     browserData: join(dir, "browser-data"),
+    loginBrowserData: join(dir, "login-browser-data"),
     modelsCache: join(dir, "models-cache.json"),
     history: join(dir, "history"),
     attachments: join(dir, "attachments"),

From d53b0080f15070d075b976e5b3ff5877e1a77caf Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:31:20 +0300
Subject: [PATCH 05/13] fix(#5.3): add diagnostic logging to getSavedCookies
 empty paths

getSavedCookies returned `[]` silently in three situations:
1. vault.enc missing for the resolved profile
2. vault.enc exists but the `cookies` key is absent
3. JSON parse failure of the stored cookies

Without log lines, users and support can't distinguish scenario 1
(run login first) from scenario 2 (data corruption or wrong profile).

Log each empty path with the profile name and the specific cause so
that daemon logs and extension output channels show the real reason.
---
 packages/mcp-server/src/config.ts | 26 +++++++++++++++++++++-----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/packages/mcp-server/src/config.ts b/packages/mcp-server/src/config.ts
index e869a21..d43c11f 100644
--- a/packages/mcp-server/src/config.ts
+++ b/packages/mcp-server/src/config.ts
@@ -405,16 +405,32 @@ export async function getSavedCookies(): Promise<PlaywrightCookie[]> {
   // return [] so the caller can report "no-cookies", but log the real reason
   // so the extension output channel shows why — otherwise the user sees
   // "run Login first" for a profile they already logged into.
-  const raw = await _vault.get(activeName(), "cookies").catch((err: unknown) => {
+  const profile = activeName();
+  const raw = await _vault.get(profile, "cookies").catch((err: unknown) => {
     const msg = err instanceof Error ? err.message : String(err);
-    console.error(`[vault] getSavedCookies failed for profile ${activeName()}: ${msg}`);
+    console.error(`[vault] getSavedCookies failed for profile '${profile}': ${msg}`);
     return null;
   });
-  if (!raw) return [];
+  if (!raw) {
+    // Distinguish "no vault.enc" from "vault exists but has no cookies key"
+    const paths = getProfilePaths(profile);
+    if (!existsSync(paths.vault)) {
+      console.error(`[vault] getSavedCookies: no vault.enc for profile '${profile}' — run login first`);
+    } else {
+      console.error(`[vault] getSavedCookies: vault.enc exists for profile '${profile}' but 'cookies' key is absent`);
+    }
+    return [];
+  }
   try {
     const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
+    if (!Array.isArray(parsed)) {
+      console.error(`[vault] getSavedCookies: 'cookies' value for profile '${profile}' is not an array (${typeof parsed})`);
+      return [];
+    }
+    return parsed;
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[vault] getSavedCookies: JSON parse failed for profile '${profile}': ${msg}`);
     return [];
   }
 }

From 0c935a53de411308c00cd5402eafcf49b234da3c Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:34:08 +0300
Subject: [PATCH 06/13] fix(#5.1): strip HEADLESS_ONLY/NO_DAEMON from daemon
 spawn env
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Issue #5 root cause: `PERPLEXITY_HEADLESS_ONLY=1` leaked from the IDE
config env block into the daemon process. When the daemon spawned, it
inherited `...process.env`, so `PerplexityClient.init()` saw the flag
and skipped the headed bootstrap entirely — authenticated Pro features
remained unavailable.

Changes:
- stdio-daemon-proxy.ts: remove `PERPLEXITY_HEADLESS_ONLY` from the
  auto-generated env block (new configs won't carry it).
- launcher.ts spawnDetachedDaemon: delete both `PERPLEXITY_HEADLESS_ONLY`
  and `PERPLEXITY_NO_DAEMON` from the env before spawning.
- runtime.ts spawnBundledDaemon: same stripping.

This also fixes pre-existing IDE configs that still have the flag:
the spawn-time strip removes it regardless of config age.

Refs issue #5
---
 .../src/auto-config/transports/stdio-daemon-proxy.ts      | 3 ++-
 packages/extension/src/daemon/runtime.ts                  | 8 +++++++-
 packages/mcp-server/src/daemon/launcher.ts                | 8 +++++++-
 3 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/packages/extension/src/auto-config/transports/stdio-daemon-proxy.ts b/packages/extension/src/auto-config/transports/stdio-daemon-proxy.ts
index b30f1c5..1de49fc 100644
--- a/packages/extension/src/auto-config/transports/stdio-daemon-proxy.ts
+++ b/packages/extension/src/auto-config/transports/stdio-daemon-proxy.ts
@@ -17,8 +17,9 @@ export const stdioDaemonProxyBuilder: TransportBuilder = {
     }
 
     const env: Record<string, string> = {
-      PERPLEXITY_HEADLESS_ONLY: "1",
       // NOTE: no PERPLEXITY_NO_DAEMON — launcher multiplexes onto the shared daemon.
+      // NOTE: no PERPLEXITY_HEADLESS_ONLY — the daemon decides headless vs headed
+      // based on its own availability probe, not the IDE's env block.
     };
 
     if (typeof input.chromePath === "string" && input.chromePath.length > 0) {
diff --git a/packages/extension/src/daemon/runtime.ts b/packages/extension/src/daemon/runtime.ts
index 217cdb3..0562ebb 100644
--- a/packages/extension/src/daemon/runtime.ts
+++ b/packages/extension/src/daemon/runtime.ts
@@ -460,11 +460,17 @@ async function spawnBundledDaemon(options: { configDir: string; host?: string; p
     `[daemon] PERPLEXITY_VAULT_PASSPHRASE: ${extraEnv.PERPLEXITY_VAULT_PASSPHRASE ? "set" : "unset"}`,
   );
 
+  // Strip launcher-scoped flags that must never reach the daemon's own
+  // PerplexityClient.init() — they would force headless mode or stdio bypass.
+  const baseEnv = { ...process.env };
+  delete baseEnv.PERPLEXITY_HEADLESS_ONLY;
+  delete baseEnv.PERPLEXITY_NO_DAEMON;
+
   const child = spawn(process.execPath, args, {
     detached: true,
     stdio: ["ignore", logFd, logFd],
     env: {
-      ...process.env,
+      ...baseEnv,
       ...extraEnv,
       // Hard-coded overrides — must come AFTER extraEnv so a buggy provider
       // cannot clobber them.
diff --git a/packages/mcp-server/src/daemon/launcher.ts b/packages/mcp-server/src/daemon/launcher.ts
index 8a17100..bae0b57 100644
--- a/packages/mcp-server/src/daemon/launcher.ts
+++ b/packages/mcp-server/src/daemon/launcher.ts
@@ -931,11 +931,17 @@ async function spawnDetachedDaemon(options: {
     args.push("--tunnel");
   }
 
+  // Strip launcher-scoped flags that must never reach the daemon's own
+  // PerplexityClient.init() — they would force headless mode or stdio bypass.
+  const env = { ...process.env };
+  delete env.PERPLEXITY_HEADLESS_ONLY;
+  delete env.PERPLEXITY_NO_DAEMON;
+
   const child = spawn(process.execPath, args, {
     detached: true,
     stdio: "ignore",
     env: {
-      ...process.env,
+      ...env,
       PERPLEXITY_CONFIG_DIR: options.configDir,
     },
   });

From c84112421505189943338ebd0d5b04adb5eebf8f Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:37:13 +0300
Subject: [PATCH 07/13] fix(#5.2): Phase 2 uses persistent context + selective
 vault cookie injection
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Phase 1 (headed bootstrap) wrote fresh cf_clearance to disk via
`launchPersistentContext(browserData)`, but Phase 2 used
`chromium.launch()` + `getOrCreateContext()` — a non-persistent
context — so the fresh clearance was never loaded. Only stale vault
cookies were injected.

Fix: Phase 2 now uses `launchPersistentContext(activePaths.browserData)`
so it inherits the disk cookies from Phase 1 automatically.

To avoid overwriting the fresh cf_clearance with the stale vault copy,
inject vault cookies ONLY for cookie names not already present on disk.

Remove now-unused `getOrCreateContext` import from client.ts.

Refs issue #5
---
 packages/mcp-server/src/client.ts | 39 ++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 16 deletions(-)

diff --git a/packages/mcp-server/src/client.ts b/packages/mcp-server/src/client.ts
index 1486a3d..c24a88e 100644
--- a/packages/mcp-server/src/client.ts
+++ b/packages/mcp-server/src/client.ts
@@ -19,7 +19,6 @@ import {
   findBrowser,
   findChromeExecutable,
   resolveBrowserExecutable,
-  getOrCreateContext,
   getSavedCookies,
   type BrowserChannel,
   type ASIFile,
@@ -914,25 +913,33 @@ export class PerplexityClient {
     }
 
     // Phase 2: Headless browser for search operations.
-    console.error("[perplexity-mcp] Launching headless browser...");
+    // Use the SAME persistent browserData directory as Phase 1 so that
+    // any cf_clearance cookie acquired during the headed bootstrap is
+    // already on disk and loaded automatically.  This fixes the bug where
+    // Phase 2 used a non-persistent context and only had stale vault
+    // cookies (issue #5).
+    console.error("[perplexity-mcp] Launching headless persistent browser...");
     const launchOpts = buildLaunchOptions(true);
-    this.browser = await chromium.launch({
-      headless: launchOpts.headless,
-      args: launchOpts.args,
-      ...(launchOpts.executablePath ? { executablePath: launchOpts.executablePath } : {}),
-      ...(launchOpts.channel ? { channel: launchOpts.channel } : {}),
-      ignoreDefaultArgs: launchOpts.ignoreDefaultArgs,
-    });
-    this.context = await getOrCreateContext(this.browser, {
-      viewport: launchOpts.viewport,
-      userAgent: launchOpts.userAgent,
-    });
+    this.context = await chromium.launchPersistentContext(
+      activePaths.browserData,
+      launchOpts,
+    );
+    this.browser = this.context.browser();
 
-    // Inject saved cookies (session + cf_clearance from login)
+    // Inject vault cookies only for cookies not already present on disk.
+    // The headed bootstrap may have refreshed cf_clearance; we must not
+    // overwrite the fresh disk cookie with the stale vault copy.
     const saved = await getSavedCookies();
     if (saved.length > 0) {
-      await this.context.addCookies(saved);
-      console.error(`[perplexity-mcp] Injected ${saved.length} saved cookies into browser context.`);
+      const current = await this.context.cookies();
+      const currentNames = new Set(current.map((c) => c.name));
+      const toInject = saved.filter((c) => !currentNames.has(c.name));
+      if (toInject.length > 0) {
+        await this.context.addCookies(toInject);
+        console.error(`[perplexity-mcp] Injected ${toInject.length} missing cookies from vault.`);
+      } else {
+        console.error("[perplexity-mcp] All vault cookies already present on disk; skipping injection.");
+      }
     }
 
     this.page = await this.context.newPage();

From c1f6dab4a87c7b9d4a4ff4cde46542f6a798d8d5 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 21:58:27 +0300
Subject: [PATCH 08/13] test: regression tests for #5/#6 fixes + adjust
 existing tests

- Add is-main-module.test.js covering symlink resolution (issue #6.1)
- Add vault.test.js cases for probeKeychainState caching and
  PERPLEXITY_DISABLE_KEYCHAIN=1 escape hatch (issue #6.3)
- Add config-getSavedCookies.test.js for diagnostic logging (issue #5.3)
- Update stdio-daemon-proxy.test.ts to expect empty env (issue #5.1)
- Update auto-config.test.ts to expect empty env for OpenCode (issue #5.1)
- Fix checks/vault.js to import probeKeychainState from vault.js
- Harden tryKeytar() against vitest mock proxies: validate getPassword
  is a function inside the try-catch so proxy-access errors are caught.

Refs issues #5, #6
---
 packages/extension/tests/auto-config.test.ts  |  4 +-
 .../transports/stdio-daemon-proxy.test.ts     |  5 +-
 packages/mcp-server/src/checks/vault.js       |  1 +
 packages/mcp-server/src/vault.js              | 11 ++--
 .../test/config-getSavedCookies.test.js       | 55 +++++++++++++++++++
 .../mcp-server/test/is-main-module.test.js    | 55 +++++++++++++++++++
 packages/mcp-server/test/vault.test.js        | 39 +++++++++++++
 7 files changed, 159 insertions(+), 11 deletions(-)
 create mode 100644 packages/mcp-server/test/config-getSavedCookies.test.js
 create mode 100644 packages/mcp-server/test/is-main-module.test.js

diff --git a/packages/extension/tests/auto-config.test.ts b/packages/extension/tests/auto-config.test.ts
index 34cf2e8..71ab847 100644
--- a/packages/extension/tests/auto-config.test.ts
+++ b/packages/extension/tests/auto-config.test.ts
@@ -191,9 +191,7 @@ describe("2026-05 IDE expansion", () => {
       type: "local",
       command: ["C:/node.exe", "C:/bundle/server.mjs"],
       enabled: true,
-      environment: {
-        PERPLEXITY_HEADLESS_ONLY: "1",
-      },
+      environment: {},
     });
     expect(nextConfig.mcp?.Perplexity.args).toBeUndefined();
     expect(nextConfig.mcp?.Perplexity.env).toBeUndefined();
diff --git a/packages/extension/tests/transports/stdio-daemon-proxy.test.ts b/packages/extension/tests/transports/stdio-daemon-proxy.test.ts
index 8837b18..37204c2 100644
--- a/packages/extension/tests/transports/stdio-daemon-proxy.test.ts
+++ b/packages/extension/tests/transports/stdio-daemon-proxy.test.ts
@@ -31,7 +31,7 @@ describe("stdioDaemonProxyBuilder", () => {
     expect(result).toEqual({
       command: "node",
       args: ["/home/user/.perplexity-mcp/launcher.cjs"],
-      env: { PERPLEXITY_HEADLESS_ONLY: "1" },
+      env: {},
     });
     // Critical: proxy variant must NOT force the launcher into no-daemon mode.
     expect("env" in result ? result.env : {}).not.toHaveProperty("PERPLEXITY_NO_DAEMON");
@@ -67,7 +67,6 @@ describe("stdioDaemonProxyBuilder", () => {
     expect(env.PERPLEXITY_CHROME_PATH).toBe(
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
     );
-    expect(env.PERPLEXITY_HEADLESS_ONLY).toBe("1");
     expect(env).not.toHaveProperty("PERPLEXITY_NO_DAEMON");
   });
 
@@ -108,7 +107,7 @@ describe("stdioDaemonProxyBuilder", () => {
     expect(result).toEqual({
       command: "node",
       args: ["/home/user/.perplexity-mcp/launcher.cjs"],
-      env: { PERPLEXITY_HEADLESS_ONLY: "1" },
+      env: {},
     });
 
     const env = "env" in result ? result.env ?? {} : {};
diff --git a/packages/mcp-server/src/checks/vault.js b/packages/mcp-server/src/checks/vault.js
index b05e4a8..c021ae1 100644
--- a/packages/mcp-server/src/checks/vault.js
+++ b/packages/mcp-server/src/checks/vault.js
@@ -1,5 +1,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { probeKeychainState } from "../vault.js";
 
 const CATEGORY = "vault";
 
diff --git a/packages/mcp-server/src/vault.js b/packages/mcp-server/src/vault.js
index 1b1b856..d607a67 100644
--- a/packages/mcp-server/src/vault.js
+++ b/packages/mcp-server/src/vault.js
@@ -71,7 +71,7 @@ const scryptAsync = promisify(nodeScrypt);
 // sets the seam, so the floor remains enforced. Cleared by `__resetKeyCache`.
 let _kdfParamsOverride = null;
 let _kdfTestModeActive = false;
-  _keytarModuleCache = null;
+let _keytarModuleCache = null;
 
 /**
  * TEST SEAM — drop scrypt cost during tests by setting (logN, r, p).
@@ -321,9 +321,6 @@ const KEYTAR_ACCOUNT = "vault-master-key";
 let _keyCache = null;
 let _unsealMaterialCache = null;
 
-/** Module-level keytar probe cache. `null` = not checked yet; `false` = unavailable. */
-let _keytarModuleCache = null;
-
 /** Environment escape hatch to suppress all keychain access (issue #6 bug 3). */
 function isKeychainDisabled() {
   return process.env.PERPLEXITY_DISABLE_KEYCHAIN === "1";
@@ -348,6 +345,10 @@ async function tryKeytar() {
   try {
     const mod = await import("keytar");
     const keytar = mod.default ?? mod;
+    if (!keytar || typeof keytar.getPassword !== "function") {
+      _keytarModuleCache = false;
+      return null;
+    }
     _keytarModuleCache = keytar;
     return keytar;
   } catch {
@@ -390,7 +391,7 @@ export async function probeKeychainState() {
     return { available: false, hasKey: false };
   }
   const keytar = await tryKeytar();
-  if (!keytar) {
+  if (!keytar || typeof keytar.getPassword !== "function") {
     return { available: false, hasKey: false };
   }
   try {
diff --git a/packages/mcp-server/test/config-getSavedCookies.test.js b/packages/mcp-server/test/config-getSavedCookies.test.js
new file mode 100644
index 0000000..f83259a
--- /dev/null
+++ b/packages/mcp-server/test/config-getSavedCookies.test.js
@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+describe("getSavedCookies diagnostic logging (issue #5.3)", () => {
+  let TMP;
+  let capturedErrors;
+  let originalConsoleError;
+
+  beforeEach(() => {
+    TMP = mkdtempSync(join(tmpdir(), "pplx-config-"));
+    process.env.PERPLEXITY_CONFIG_DIR = TMP;
+    process.env.PERPLEXITY_PROFILE = "default";
+    delete process.env.PERPLEXITY_SESSION_TOKEN;
+    delete process.env.PERPLEXITY_CSRF_TOKEN;
+    capturedErrors = [];
+    originalConsoleError = console.error;
+    console.error = (...args) => {
+      capturedErrors.push(args.join(" "));
+    };
+  });
+
+  afterEach(() => {
+    rmSync(TMP, { recursive: true, force: true });
+    delete process.env.PERPLEXITY_CONFIG_DIR;
+    delete process.env.PERPLEXITY_PROFILE;
+    delete process.env.PERPLEXITY_VAULT_PASSPHRASE;
+    console.error = originalConsoleError;
+  });
+
+  it("logs 'no vault.enc' when vault is missing", async () => {
+    const { getSavedCookies } = await import("../src/config.js");
+    const cookies = await getSavedCookies();
+    expect(cookies).toEqual([]);
+    expect(capturedErrors.some((c) => /no vault\.enc/.test(c))).toBe(true);
+    expect(capturedErrors.some((c) => /run login first/.test(c))).toBe(true);
+  });
+
+  it("logs 'cookies key absent' when vault exists but has no cookies", async () => {
+    const { createProfile } = await import("../src/profiles.js");
+    const { Vault, __resetKeyCache } = await import("../src/vault.js");
+    createProfile("default");
+    __resetKeyCache();
+    process.env.PERPLEXITY_VAULT_PASSPHRASE = "test-passphrase";
+    const v = new Vault();
+    await v.set("default", "email", "test@example.com");
+
+    vi.resetModules();
+    const { getSavedCookies } = await import("../src/config.js");
+    const cookies = await getSavedCookies();
+    expect(cookies).toEqual([]);
+    expect(capturedErrors.some((c) => c.includes("'cookies' key is absent"))).toBe(true);
+  });
+});
diff --git a/packages/mcp-server/test/is-main-module.test.js b/packages/mcp-server/test/is-main-module.test.js
new file mode 100644
index 0000000..76d7a64
--- /dev/null
+++ b/packages/mcp-server/test/is-main-module.test.js
@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { isMainModule } from "../src/is-main-module.js";
+import { writeFileSync, symlinkSync, realpathSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+const TMP = join(tmpdir(), "perplexity-is-main-module-test");
+
+function cleanTmp() {
+  try { rmSync(TMP, { recursive: true }); } catch { /* ignore */ }
+}
+
+describe("isMainModule", () => {
+  beforeEach(() => {
+    cleanTmp();
+    mkdirSync(TMP, { recursive: true });
+  });
+  afterEach(() => {
+    cleanTmp();
+    delete process.argv[1];
+  });
+
+  it("returns true when argv[1] matches import.meta.url exactly", () => {
+    const realFile = join(TMP, "real.mjs");
+    writeFileSync(realFile, "");
+    process.argv[1] = realFile;
+    const metaUrl = "file://" + realFile.replace(/\\/g, "/");
+    expect(isMainModule(metaUrl)).toBe(true);
+  });
+
+  it("returns false when argv[1] points at a different file", () => {
+    const realFile = join(TMP, "real.mjs");
+    const otherFile = join(TMP, "other.mjs");
+    writeFileSync(realFile, "");
+    writeFileSync(otherFile, "");
+    process.argv[1] = otherFile;
+    const metaUrl = "file://" + realFile.replace(/\\/g, "/");
+    expect(isMainModule(metaUrl)).toBe(false);
+  });
+
+  it("returns true when argv[1] is a symlink to the real file (issue #6)", () => {
+    const realFile = join(TMP, "real.mjs");
+    const linkFile = join(TMP, "link.mjs");
+    writeFileSync(realFile, "");
+    symlinkSync(realFile, linkFile);
+    process.argv[1] = linkFile;
+    const metaUrl = "file://" + realFile.replace(/\\/g, "/");
+    expect(isMainModule(metaUrl)).toBe(true);
+  });
+
+  it("returns false when argv[1] is missing", () => {
+    delete process.argv[1];
+    expect(isMainModule("file:///any/path.mjs")).toBe(false);
+  });
+});
diff --git a/packages/mcp-server/test/vault.test.js b/packages/mcp-server/test/vault.test.js
index 12206de..b108fe2 100644
--- a/packages/mcp-server/test/vault.test.js
+++ b/packages/mcp-server/test/vault.test.js
@@ -1340,3 +1340,42 @@ describe("v3 migration", () => {
     }
   });
 });
+
+describe("probeKeychainState — caching + escape hatch (issue #6.3)", () => {
+  beforeEach(() => {
+    __resetKeyCache();
+    delete process.env.PERPLEXITY_DISABLE_KEYCHAIN;
+    vi.doUnmock("keytar");
+  });
+  afterEach(() => {
+    vi.doUnmock("keytar");
+    delete process.env.PERPLEXITY_DISABLE_KEYCHAIN;
+  });
+
+  it("returns false immediately when PERPLEXITY_DISABLE_KEYCHAIN=1", async () => {
+    const { probeKeychainState } = await import("../src/vault.js");
+    process.env.PERPLEXITY_DISABLE_KEYCHAIN = "1";
+    const result = await probeKeychainState();
+    expect(result).toEqual({ available: false, hasKey: false });
+  });
+
+  it("caches keytar load result so repeated probes don't re-import", async () => {
+    let importCount = 0;
+    vi.doMock("keytar", () => {
+      importCount++;
+      return {
+        default: {
+          getPassword: async () => null,
+          setPassword: async () => undefined,
+        },
+      };
+    });
+    const { probeKeychainState } = await import("../src/vault.js");
+    __resetKeyCache(); // clear any prior cache
+    await probeKeychainState();
+    await probeKeychainState();
+    await probeKeychainState();
+    // keytar should only be imported once because the result is cached
+    expect(importCount).toBe(1);
+  });
+});

From f51e7cb615f35413f64058f2e5f831f923dd6b8f Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Mon, 11 May 2026 22:19:10 +0300
Subject: [PATCH 09/13] build(mcp-server): avoid tsup DTS worker OOM by
 delegating to tsc --allowJs --emitDeclarationOnly

The 47-entry-point mcp-server bundle causes tsup's rollup-dts worker to
hit ERR_WORKER_OUT_OF_MEMORY on Node 22 / Windows (pre-existing; reproducible
on commits before 0.8.43).  Split the build so tsup handles the ESM bundle
and a post-step `tsc --allowJs --emitDeclarationOnly` generates the .d.ts
files.  This unblocks the full extension build pipeline.

Generated with [Devin](https://cli.devin.ai/docs)

Co-Authored-By: Devin <158243242+devin-ai-integration[bot]@users.noreply.github.com>
---
 packages/mcp-server/package.json   | 2 +-
 packages/mcp-server/tsup.config.ts | 6 +++++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 14df915..3894f49 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -126,7 +126,7 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "build": "tsup && node scripts/post-build-shebang.mjs",
+    "build": "tsup --no-dts && tsc --allowJs --emitDeclarationOnly && node scripts/post-build-shebang.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "cd ../.. && npx vitest run packages/mcp-server/test",
     "test:coverage": "cd ../.. && npx vitest run --coverage packages/mcp-server/test"
diff --git a/packages/mcp-server/tsup.config.ts b/packages/mcp-server/tsup.config.ts
index b563e82..160f682 100644
--- a/packages/mcp-server/tsup.config.ts
+++ b/packages/mcp-server/tsup.config.ts
@@ -51,7 +51,11 @@ export default defineConfig({
   target: "node20",
   outDir: "dist",
   clean: true,
-  dts: true,
+  // tsup's rollup-dts worker thread OOMs on this package's 47 entry points
+  // under Node 22 / Windows (pre-existing; fails even on commits before 0.8.43).
+  // Declarations are generated separately with tsc --allowJs --emitDeclarationOnly
+  // in the package.json build script, which is faster and avoids the worker heap.
+  dts: false,
   // got-scraping and its transitive data-bearing deps must resolve at runtime
   // from node_modules (they load JSON data files via fs.readFileSync that tsup
   // can't inline). Same story for patchright (native Chromium).

From d8f6fa8cc9057f878b45a543fe71961dd273403b Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Tue, 12 May 2026 00:28:35 +0300
Subject: [PATCH 10/13] fix(review): suppress misleading 'key absent' log on
 unseal failure + optional-chain ctx.browser()
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

getSavedCookies was logging both the real unseal error AND a spurious
"'cookies' key is absent" message because the existsSync branch fired
regardless of whether the null came from a vault error or a missing key.
Added an unsealFailed flag to skip the second diagnostic when the catch
path already explained the failure.

login-runner.js / manual-login-runner.js: ctx.browser().close()
→ ctx.browser()?.close() so a null browser() return degrades gracefully
instead of throwing a TypeError swallowed by .catch().

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 packages/mcp-server/src/config.ts              | 16 ++++++++++------
 packages/mcp-server/src/login-runner.js        | 14 +++++++-------
 packages/mcp-server/src/manual-login-runner.js |  8 ++++----
 3 files changed, 21 insertions(+), 17 deletions(-)

diff --git a/packages/mcp-server/src/config.ts b/packages/mcp-server/src/config.ts
index d43c11f..bc93efd 100644
--- a/packages/mcp-server/src/config.ts
+++ b/packages/mcp-server/src/config.ts
@@ -406,18 +406,22 @@ export async function getSavedCookies(): Promise<PlaywrightCookie[]> {
   // so the extension output channel shows why — otherwise the user sees
   // "run Login first" for a profile they already logged into.
   const profile = activeName();
+  let unsealFailed = false;
   const raw = await _vault.get(profile, "cookies").catch((err: unknown) => {
+    unsealFailed = true;
     const msg = err instanceof Error ? err.message : String(err);
     console.error(`[vault] getSavedCookies failed for profile '${profile}': ${msg}`);
     return null;
   });
   if (!raw) {
-    // Distinguish "no vault.enc" from "vault exists but has no cookies key"
-    const paths = getProfilePaths(profile);
-    if (!existsSync(paths.vault)) {
-      console.error(`[vault] getSavedCookies: no vault.enc for profile '${profile}' — run login first`);
-    } else {
-      console.error(`[vault] getSavedCookies: vault.enc exists for profile '${profile}' but 'cookies' key is absent`);
+    if (!unsealFailed) {
+      // Distinguish "no vault.enc" from "vault exists but has no cookies key"
+      const paths = getProfilePaths(profile);
+      if (!existsSync(paths.vault)) {
+        console.error(`[vault] getSavedCookies: no vault.enc for profile '${profile}' — run login first`);
+      } else {
+        console.error(`[vault] getSavedCookies: vault.enc exists for profile '${profile}' but 'cookies' key is absent`);
+      }
     }
     return [];
   }
diff --git a/packages/mcp-server/src/login-runner.js b/packages/mcp-server/src/login-runner.js
index e3a235a..eb01b8c 100644
--- a/packages/mcp-server/src/login-runner.js
+++ b/packages/mcp-server/src/login-runner.js
@@ -89,7 +89,7 @@ async function main() {
   const ready = await waitForLoginReady(page);
   if (!ready) {
     const title = await page.title().catch(() => "");
-    await ctx.browser().close().catch(() => {});
+    await ctx.browser()?.close().catch(() => {});
     emit({ ok: false, reason: /just a moment/i.test(title) ? "cf_blocked" : "auto_unsupported" });
     process.exit(/just a moment/i.test(title) ? 3 : 2);
   }
@@ -102,19 +102,19 @@ async function main() {
   if (!localOrigin) await minimizePageWindow(page);
 
   if (authFlow.kind === "sso_required") {
-    await ctx.browser().close().catch(() => {});
+    await ctx.browser()?.close().catch(() => {});
     emit({ ok: false, reason: "sso_required" });
     process.exit(2);
   }
 
   if (authFlow.kind === "unsupported") {
-    await ctx.browser().close().catch(() => {});
+    await ctx.browser()?.close().catch(() => {});
     emit({ ok: false, reason: "auto_unsupported", detail: authFlow.detail });
     process.exit(2);
   }
 
   if (authFlow.kind === "email_rejected") {
-    await ctx.browser().close().catch(() => {});
+    await ctx.browser()?.close().catch(() => {});
     emit({ ok: false, reason: "email_rejected", detail: authFlow.detail });
     process.exit(2);
   }
@@ -125,7 +125,7 @@ async function main() {
     try {
       otp = await awaitOtp();
     } catch {
-      await ctx.browser().close().catch(() => {});
+      await ctx.browser()?.close().catch(() => {});
       emit({ ok: false, reason: "otp_timeout" });
       process.exit(2);
     }
@@ -148,7 +148,7 @@ async function main() {
       recordLoginSuccess(PROFILE, { tier: metadata.tier, loginMode: "auto", lastLogin: new Date().toISOString() });
       writeFileSync(paths.reinit, String(Date.now()));
 
-      await ctx.browser().close().catch(() => {});
+      await ctx.browser()?.close().catch(() => {});
       emit({ ok: true, tier: metadata.tier, modelCount: Object.keys(metadata.models?.models ?? {}).length });
       process.exit(0);
     }
@@ -159,7 +159,7 @@ async function main() {
     }
 
     if (attempt === MAX_RETRIES) {
-      await ctx.browser().close().catch(() => {});
+      await ctx.browser()?.close().catch(() => {});
       emit({ ok: false, reason: "otp_rejected" });
       process.exit(2);
     }
diff --git a/packages/mcp-server/src/manual-login-runner.js b/packages/mcp-server/src/manual-login-runner.js
index 6d136cf..e311e61 100644
--- a/packages/mcp-server/src/manual-login-runner.js
+++ b/packages/mcp-server/src/manual-login-runner.js
@@ -74,7 +74,7 @@ async function main() {
   if (Date.now() - cfStart >= CF_TIMEOUT_MS) {
     const title = await page.title().catch(() => "");
     if (/just a moment/i.test(title)) {
-      await ctx.browser().close().catch(() => {});
+      await ctx.browser()?.close().catch(() => {});
       emit({ ok: false, reason: "cf_blocked" });
       process.exit(3);
     }
@@ -94,7 +94,7 @@ async function main() {
 
   // Test hook: force a browser close to exercise the cancelled path.
   if (process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS) {
-    setTimeout(() => ctx.browser().close().catch(() => {}), Number(process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS));
+    setTimeout(() => ctx.browser()?.close().catch(() => {}), Number(process.env.PERPLEXITY_TEST_BROWSER_CLOSE_AFTER_MS));
   }
 
   const started = Date.now();
@@ -110,7 +110,7 @@ async function main() {
     if (sessionCookie) break;
   }
   if (!sessionCookie) {
-    await ctx.browser().close().catch(() => {});
+    await ctx.browser()?.close().catch(() => {});
     emit({ ok: false, reason: "timeout" });
     process.exit(2);
   }
@@ -130,7 +130,7 @@ async function main() {
 
   writeFileSync(paths.reinit, String(Date.now()));
 
-  await ctx.browser().close().catch(() => {});
+  await ctx.browser()?.close().catch(() => {});
   emit({ ok: true, tier: metadata.tier, modelCount: Object.keys(metadata.models?.models ?? {}).length });
   process.exit(0);
 }

From ee8568f8b3b3b28198e3e449059e7154c360bdab Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Tue, 12 May 2026 00:40:06 +0300
Subject: [PATCH 11/13] chore: bump to 0.8.43 + CHANGELOG for issues #5 and #6

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 CHANGELOG.md                     | 31 +++++++++++++++++++++++++++++++
 packages/extension/package.json  |  2 +-
 packages/mcp-server/package.json |  2 +-
 3 files changed, 33 insertions(+), 2 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 50281fb..125aafd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -6,6 +6,37 @@ All notable changes to this project are documented here. Format follows
 
 ## [Unreleased]
 
+## [0.8.43] — 2026-05-12 — Auth/CLI hardening (issues #5 + #6)
+
+> Refs [#5](https://github.com/Automations-Project/VSCode-Perplexity-MCP/issues/5) and [#6](https://github.com/Automations-Project/VSCode-Perplexity-MCP/issues/6). Two stacked regressions caused the daemon to report anonymous mode after a successful login: `PERPLEXITY_HEADLESS_ONLY=1` leaked from the launcher env into the daemon's spawn env (disabling the headed bootstrap entirely), and Phase 2 used a non-persistent browser context that discarded the fresh `cf_clearance` acquired in Phase 1. Separately, a symlink-detection bug silently no-oped the CLI on POSIX Homebrew/npm global installs, and repeated keychain probes triggered macOS Keychain permission prompts on every diagnostic pass.
+
+### Fixed
+
+- **`PERPLEXITY_HEADLESS_ONLY` and `PERPLEXITY_NO_DAEMON` are now stripped from the daemon spawn env** in all three spawn sites (`daemon/launcher.ts`, `extension/src/daemon/runtime.ts`, `extension/src/auto-config/transports/stdio-daemon-proxy.ts`). These are launcher-scoped flags that must never reach the daemon's own `PerplexityClient.init()` — leaking them forced the daemon to skip the headed bootstrap (the only phase that can solve CF challenges) or bypass daemon attach entirely. Fixes the "anonymous mode despite successful login" regression.
+- **Phase 2 (headless search) now uses a persistent browser context** (`chromium.launchPersistentContext(browserData, ...)`) sharing the same profile directory as Phase 1. The fresh `cf_clearance` written to disk by the headed bootstrap is loaded automatically, eliminating the CF-challenge failure that caused every subsequent search to see anonymous mode. Vault cookies are injected selectively — only cookies not already present on disk are added, so a freshly-written `cf_clearance` from Phase 1 is never overwritten by a stale vault copy.
+- **CLI and daemon entrypoints now resolve symlinks in the direct-run guard** (`isMainModule()` in new `src/is-main-module.js`). The previous `import.meta.url === pathToFileURL(process.argv[1]).href` check silently returned `false` when the binary was invoked through a symlink (npm global install, Homebrew Cellar, `node_modules/.bin/`), causing the CLI and daemon to exit `0` with no output. Both `cli.js` and `index.ts` now use `realpathSync` on both sides with a defensive fallback.
+- **`dist/cli.mjs` now has a shebang and executable mode** after build. A new `scripts/post-build-shebang.mjs` post-build script prepends `#!/usr/bin/env node` and `chmod 755`s the file. tsup intentionally omits the shebang (it trips vitest/esbuild during test imports); the post-build script targets only `dist/cli.mjs`. No-op on Windows where npm uses `.cmd` wrappers.
+- **Keytar probe results are cached per-process** in `vault.js`. Previously `tryKeytar()` re-imported the native module on every vault read, triggering macOS Keychain permission dialogs repeatedly within a single session. The new `_keytarModuleCache` variable caches success and failure alike; `__resetKeyCache()` clears it on profile-state changes. `probeKeychainState()` is exported for shared use across `cli.js` and `checks/vault.js`, removing three duplicate inline probe implementations.
+- **`PERPLEXITY_DISABLE_KEYCHAIN=1`** environment variable disables all keychain access. Useful in headless test environments and CI where no credstore is available and the "no keychain" code path should be taken without a failed import attempt.
+- **Login runners now use a persistent browser context** (`login-browser-data/` under the active profile directory, separate from the daemon's `browser-data/`). Google SSO and Cloudflare state accumulated across login sessions — eliminating the "log in constantly" UX paper cut. The separate directory avoids Chromium singleton-lock collisions with the daemon's headed bootstrap.
+- **`getSavedCookies` now emits specific diagnostic log lines** for each empty-return path: no `vault.enc` (run login first), vault exists but `cookies` key absent, cookies value is not an array, and JSON parse failure. An `unsealFailed` flag prevents the "key absent" message from firing when the real cause is an unseal error (which is already logged by the catch path).
+
+### Added
+
+- **`src/is-main-module.js` + `src/is-main-module.d.ts`** — shared symlink-aware direct-run guard extracted from `cli.js` and `index.ts`.
+- **`scripts/post-build-shebang.mjs`** — post-build shebang injection + chmod for `dist/cli.mjs`. Runs as part of `npm run build` in `packages/mcp-server`.
+- **`probeKeychainState()`** exported from `vault.js` — single keychain probe entry point with caching and `PERPLEXITY_DISABLE_KEYCHAIN` awareness.
+
+### Changed
+
+- **Build script** (`packages/mcp-server/package.json`): `tsup` → `tsup --no-dts && tsc --allowJs --emitDeclarationOnly && node scripts/post-build-shebang.mjs`. tsup's rollup-dts worker OOMs on this package's 47+ entry points under Node 22+/Windows; `tsc --allowJs --emitDeclarationOnly` is faster and avoids the worker heap ceiling.
+- **`tsup.config.ts`**: `dts: true` → `dts: false`; comment updated to reflect the build script split.
+
+### Verification
+
+- All 130 test files pass (1151 tests, 2 intentionally skipped) on Node 22 / Windows.
+- Full typecheck clean across all four packages.
+
 ## [0.8.41] — 2026-05-10 — Vault unseal hardening for external MCP clients
 
 > Refs [#3](https://github.com/Automations-Project/VSCode-Perplexity-MCP/issues/3). Driver: an external user (Claude Code on Win11) hit "Vault locked" because the extension-managed daemon never received the SecretStorage passphrase, AND the launcher silently fell back to direct vault access in the client's runtime.
diff --git a/packages/extension/package.json b/packages/extension/package.json
index 2802384..1a30dd3 100644
--- a/packages/extension/package.json
+++ b/packages/extension/package.json
@@ -1,7 +1,7 @@
 {
   "name": "perplexity-vscode",
   "displayName": "Perplexity MCP",
-  "version": "0.8.42",
+  "version": "0.8.43",
   "publisher": "Nskha",
   "private": true,
   "description": "Perplexity AI search, reasoning, research, and compute — MCP server, dashboard, and multi-IDE auto-config for VS Code.",
diff --git a/packages/mcp-server/package.json b/packages/mcp-server/package.json
index 3894f49..8a0d32f 100644
--- a/packages/mcp-server/package.json
+++ b/packages/mcp-server/package.json
@@ -1,6 +1,6 @@
 {
   "name": "perplexity-user-mcp",
-  "version": "0.8.42",
+  "version": "0.8.43",
   "mcpName": "io.github.Automations-Project/perplexity-user-mcp",
   "type": "module",
   "description": "Perplexity AI MCP server — browser automation for search, reasoning, research, and compute. Not affiliated with Perplexity AI, Inc.",

From a196df728b6a3f6bc507133cce7e63c00a010872 Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Tue, 12 May 2026 01:14:18 +0300
Subject: [PATCH 12/13] =?UTF-8?q?feat(#daemonSync):=20live=20daemon?=
 =?UTF-8?q?=E2=86=94UI=20auth=20status=20sync?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- shared: add DaemonAuthStatus + daemonAuth field on AccountSnapshot
- profiles.js: add daemonStatus + loginBrowserData to ProfilePaths (impl + .d.ts)
- client.ts: writeDaemonStatus() after every init/reinit/shutdown; fix bare throw→throw err
- session.ts: read daemon-status.json into AccountSnapshot
- DashboardProvider: FSWatcher on daemon-status.json with 300ms debounce + dispose cleanup; dashboard:refresh touches .reinit when daemon is anonymous with stored login
- views.tsx: daemonAuth status dot in hero panel (ok/warn; hidden in stdio mode)
- logout.js: clear loginBrowserData on softLogout so next login starts fresh
- checks/profiles.js: daemon-status.json auth/tier report + loginBrowserData presence note

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 packages/extension/src/auth/session.ts        |   6 +-
 .../src/webview/DashboardProvider.ts          |  92 ++++++++++-
 packages/mcp-server/src/checks/profiles.js    |  37 +++++
 packages/mcp-server/src/client.ts             | 156 ++++++++++++------
 packages/mcp-server/src/logout.js             |   2 +
 packages/mcp-server/src/profiles.d.ts         |   2 +
 packages/mcp-server/src/profiles.js           |   1 +
 packages/shared/src/models.ts                 |  22 +++
 packages/webview/src/views.tsx                |  13 ++
 9 files changed, 274 insertions(+), 57 deletions(-)

diff --git a/packages/extension/src/auth/session.ts b/packages/extension/src/auth/session.ts
index 18e1940..f8779a1 100644
--- a/packages/extension/src/auth/session.ts
+++ b/packages/extension/src/auth/session.ts
@@ -1,5 +1,5 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
-import type { AccountSnapshot, ModelsConfigSource, RefreshTier } from "@perplexity-user-mcp/shared";
+import type { AccountSnapshot, DaemonAuthStatus, ModelsConfigSource, RefreshTier } from "@perplexity-user-mcp/shared";
 import { MODELS_FALLBACK, MODELS_FALLBACK_CAPTURED_AT } from "@perplexity-user-mcp/shared";
 import { getConfigDir, getProfilePaths, getActiveName } from "perplexity-user-mcp/profiles";
 import type { AccountInfo } from "../browser/runtime.js";
@@ -91,6 +91,9 @@ export function getAccountSnapshot(): AccountSnapshot {
 
   const speedBoost = getImpitStatus();
 
+  // Read live daemon auth state — null when file absent (stdio mode / first run).
+  const daemonAuth = readJsonFile<DaemonAuthStatus>(paths.daemonStatus);
+
   return {
     loggedIn,
     userId: null,
@@ -109,6 +112,7 @@ export function getAccountSnapshot(): AccountSnapshot {
       installedAt: speedBoost.installedAt,
       runtimeDir: speedBoost.runtimeDir,
     },
+    daemonAuth,
   };
 }
 
diff --git a/packages/extension/src/webview/DashboardProvider.ts b/packages/extension/src/webview/DashboardProvider.ts
index 9a664d7..46c85e2 100644
--- a/packages/extension/src/webview/DashboardProvider.ts
+++ b/packages/extension/src/webview/DashboardProvider.ts
@@ -1,4 +1,5 @@
 import * as crypto from "node:crypto";
+import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import * as vscode from "vscode";
@@ -55,6 +56,7 @@ import {
 import {
   listProfiles,
   getActiveName,
+  getProfilePaths,
   setActive,
   createProfile,
   deleteProfile,
@@ -119,6 +121,7 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
   private otpResolvers = new Map<string, (s: string | null) => void>();
   private onMcpServerDefinitionsChanged?: () => void;
   private daemonEventsAbort: AbortController | null = null;
+  private daemonStatusWatcher: fs.FSWatcher | null = null;
   // v0.8.5: deps factory injected from extension.ts so the auto-regen hook
   // on `postStaleness` can reuse the live ApplyIdeConfigDeps without pulling
   // the daemon runtime singletons into the webview module.
@@ -231,6 +234,7 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
 
     const disposeHook = (webviewView as vscode.WebviewView & { onDidDispose?: (listener: () => void) => vscode.Disposable }).onDidDispose?.(() => {
       this.stopDaemonEventStream();
+      this.stopDaemonStatusWatch();
     });
     if (disposeHook) {
       this.context.subscriptions.push(disposeHook);
@@ -249,8 +253,16 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
       try {
         switch (message.type) {
           case "ready":
+            debug("Handling ready");
+            await this.refresh();
+            break;
           case "dashboard:refresh":
-            debug("Handling refresh/ready");
+            debug("Handling refresh");
+            // If the daemon is reporting anonymous but the profile has stored
+            // credentials, touch .reinit so the daemon re-runs init() and
+            // re-checks auth. The daemon-status.json watcher picks up the
+            // result and calls refresh() automatically when it completes.
+            this.triggerDaemonReinitIfStale();
             await this.refresh();
             break;
           case "auth:login":
@@ -1583,6 +1595,8 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
       return;
     }
 
+    this.ensureDaemonStatusWatch();
+
     await this.view.webview.postMessage({
       type: "dashboard:state",
       payload: this.buildState()
@@ -2056,6 +2070,82 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
     this.daemonEventsAbort = null;
   }
 
+  // ── daemon-status.json watcher ────────────────────────────────────────────
+
+  /**
+   * Watch daemon-status.json for the active profile. When it changes (daemon
+   * finished init/reinit), push a fresh dashboard state to the webview so the
+   * daemonAuth indicator updates without the user manually clicking Refresh.
+   */
+  private startDaemonStatusWatch(): void {
+    this.stopDaemonStatusWatch();
+    const profile = getActiveName() ?? "default";
+    const statusFile = getProfilePaths(profile).daemonStatus;
+    let debounce: ReturnType<typeof setTimeout> | null = null;
+    try {
+      this.daemonStatusWatcher = fs.watch(statusFile, () => {
+        if (debounce) clearTimeout(debounce);
+        debounce = setTimeout(() => {
+          debounce = null;
+          void this.refresh();
+        }, 300);
+      });
+      this.daemonStatusWatcher.on("error", () => {
+        // File may not exist yet (daemon not started). Re-arm on next refresh.
+        this.stopDaemonStatusWatch();
+      });
+    } catch {
+      // daemon-status.json doesn't exist yet — watcher will be re-armed
+      // the next time refresh() is called (startDaemonStatusWatch is called
+      // from refresh() → ensureWatcher() path below).
+      this.daemonStatusWatcher = null;
+    }
+  }
+
+  private stopDaemonStatusWatch(): void {
+    this.daemonStatusWatcher?.close();
+    this.daemonStatusWatcher = null;
+  }
+
+  /**
+   * Called from refresh() to ensure the watcher is tracking the current
+   * active profile. Re-arms if the profile changed or the previous watch
+   * failed because the file didn't exist yet.
+   */
+  private ensureDaemonStatusWatch(): void {
+    const profile = getActiveName() ?? "default";
+    const statusFile = getProfilePaths(profile).daemonStatus;
+    // Re-arm if watcher is null (never started, file missing at last attempt,
+    // or profile changed). A live watcher needs no action.
+    if (!this.daemonStatusWatcher) {
+      if (fs.existsSync(statusFile)) {
+        this.startDaemonStatusWatch();
+      }
+    }
+  }
+
+  /**
+   * If the daemon's last-known auth state is anonymous while the profile has
+   * stored credentials, touch the .reinit sentinel to ask the daemon to
+   * re-run init() and re-check auth. The daemon-status.json watcher will
+   * pick up the result automatically.
+   */
+  private triggerDaemonReinitIfStale(): void {
+    try {
+      const snapshot = this.buildState().snapshot;
+      if (!snapshot.loggedIn) return;
+      if (!snapshot.daemonAuth) return;
+      if (snapshot.daemonAuth.authenticated) return;
+      // Stored login but daemon is anonymous → touch .reinit
+      const profile = getActiveName() ?? "default";
+      const reinitPath = getProfilePaths(profile).reinit;
+      fs.writeFileSync(reinitPath, String(Date.now()));
+      debug("[daemonStatusSync] Touched .reinit — daemon was anonymous with stored login");
+    } catch (err) {
+      debug(`[daemonStatusSync] triggerDaemonReinitIfStale error: ${(err as Error).message}`);
+    }
+  }
+
   private async readDaemonEvents(body: ReadableStream<Uint8Array>, controller: AbortController): Promise<void> {
     const reader = body.getReader();
     const decoder = new TextDecoder();
diff --git a/packages/mcp-server/src/checks/profiles.js b/packages/mcp-server/src/checks/profiles.js
index c756412..6bcc512 100644
--- a/packages/mcp-server/src/checks/profiles.js
+++ b/packages/mcp-server/src/checks/profiles.js
@@ -91,6 +91,43 @@ export async function run(opts = {}) {
         results.push({ category: CATEGORY, name: `${name}/models-cache`, status: "pass", message: `${Math.round(ageDays)}d old` });
       }
     }
+
+    const daemonStatusPath = join(pdir, "daemon-status.json");
+    if (!existsSync(daemonStatusPath)) {
+      results.push({ category: CATEGORY, name: `${name}/daemon-status`, status: "skip", message: "no daemon status file (stdio-only or not yet started)" });
+    } else {
+      try {
+        const ds = JSON.parse(readFileSync(daemonStatusPath, "utf8"));
+        if (!ds.authenticated) {
+          results.push({
+            category: CATEGORY,
+            name: `${name}/daemon-status`,
+            status: "warn",
+            message: `daemon last init: ${ds.lastInit} — authenticated: false (tier: ${ds.tier})${ds.error ? `, error: ${ds.error}` : ""}`,
+            hint: "Open the extension dashboard and click 'Refresh state' to trigger a daemon reinit.",
+          });
+        } else {
+          results.push({
+            category: CATEGORY,
+            name: `${name}/daemon-status`,
+            status: "pass",
+            message: `authenticated as ${ds.tier}, last init: ${ds.lastInit} (${ds.initDurationMs}ms)`,
+          });
+        }
+      } catch {
+        results.push({ category: CATEGORY, name: `${name}/daemon-status`, status: "warn", message: "daemon-status.json is corrupt or unreadable" });
+      }
+    }
+
+    const loginBrowserDataPath = join(pdir, "login-browser-data");
+    if (existsSync(loginBrowserDataPath)) {
+      results.push({
+        category: CATEGORY,
+        name: `${name}/login-browser-data`,
+        status: "info",
+        message: "login-browser-data directory present (leftover from a past login session; safe to ignore)",
+      });
+    }
   }
 
   return results;
diff --git a/packages/mcp-server/src/client.ts b/packages/mcp-server/src/client.ts
index c24a88e..d287a5c 100644
--- a/packages/mcp-server/src/client.ts
+++ b/packages/mcp-server/src/client.ts
@@ -33,6 +33,7 @@ import { isImpitAvailable, impitFetchJson } from "./refresh.js";
 import { writeFileSync, readFileSync, mkdirSync, existsSync } from "fs";
 import { join } from "path";
 import { getActiveName, getConfigDir, getProfilePaths } from "./profiles.js";
+import type { DaemonAuthStatus } from "@perplexity-user-mcp/shared";
 import { clearStaleSingletonLocks } from "./fs-utils.js";
 
 function getActiveProfileName(): string {
@@ -894,69 +895,77 @@ export class PerplexityClient {
    * Set env PERPLEXITY_HEADLESS_ONLY=1 to skip the headed phase (uses disk cache).
    */
   async init(): Promise<void> {
-    const activePaths = getActivePaths();
-    if (!existsSync(activePaths.browserData)) {
-      mkdirSync(activePaths.browserData, { recursive: true });
-    }
+    const _initAt = Date.now();
+    try {
+      const activePaths = getActivePaths();
+      if (!existsSync(activePaths.browserData)) {
+        mkdirSync(activePaths.browserData, { recursive: true });
+      }
 
-    // Fail fast with a readable message if no browser is installed at all.
-    const browser = await resolveBrowserExecutable();
-    console.error(`[perplexity-mcp] Using ${browser.source}: ${browser.path}`);
+      // Fail fast with a readable message if no browser is installed at all.
+      const browser = await resolveBrowserExecutable();
+      console.error(`[perplexity-mcp] Using ${browser.source}: ${browser.path}`);
 
-    // Phase 1: Headed session — solve CF challenge + fetch account info
-    const skipHeaded = process.env.PERPLEXITY_HEADLESS_ONLY === "1";
-    if (!skipHeaded) {
-      await this.headedBootstrap();
-    } else {
-      console.error("[perplexity-mcp] Skipping headed session (PERPLEXITY_HEADLESS_ONLY=1).");
-      this.loadCachedAccountInfo();
-    }
-
-    // Phase 2: Headless browser for search operations.
-    // Use the SAME persistent browserData directory as Phase 1 so that
-    // any cf_clearance cookie acquired during the headed bootstrap is
-    // already on disk and loaded automatically.  This fixes the bug where
-    // Phase 2 used a non-persistent context and only had stale vault
-    // cookies (issue #5).
-    console.error("[perplexity-mcp] Launching headless persistent browser...");
-    const launchOpts = buildLaunchOptions(true);
-    this.context = await chromium.launchPersistentContext(
-      activePaths.browserData,
-      launchOpts,
-    );
-    this.browser = this.context.browser();
-
-    // Inject vault cookies only for cookies not already present on disk.
-    // The headed bootstrap may have refreshed cf_clearance; we must not
-    // overwrite the fresh disk cookie with the stale vault copy.
-    const saved = await getSavedCookies();
-    if (saved.length > 0) {
-      const current = await this.context.cookies();
-      const currentNames = new Set(current.map((c) => c.name));
-      const toInject = saved.filter((c) => !currentNames.has(c.name));
-      if (toInject.length > 0) {
-        await this.context.addCookies(toInject);
-        console.error(`[perplexity-mcp] Injected ${toInject.length} missing cookies from vault.`);
+      // Phase 1: Headed session — solve CF challenge + fetch account info
+      const skipHeaded = process.env.PERPLEXITY_HEADLESS_ONLY === "1";
+      if (!skipHeaded) {
+        await this.headedBootstrap();
       } else {
-        console.error("[perplexity-mcp] All vault cookies already present on disk; skipping injection.");
+        console.error("[perplexity-mcp] Skipping headed session (PERPLEXITY_HEADLESS_ONLY=1).");
+        this.loadCachedAccountInfo();
       }
-    }
 
-    this.page = await this.context.newPage();
+      // Phase 2: Headless browser for search operations.
+      // Use the SAME persistent browserData directory as Phase 1 so that
+      // any cf_clearance cookie acquired during the headed bootstrap is
+      // already on disk and loaded automatically.  This fixes the bug where
+      // Phase 2 used a non-persistent context and only had stale vault
+      // cookies (issue #5).
+      console.error("[perplexity-mcp] Launching headless persistent browser...");
+      const launchOpts = buildLaunchOptions(true);
+      this.context = await chromium.launchPersistentContext(
+        activePaths.browserData,
+        launchOpts,
+      );
+      this.browser = this.context.browser();
+
+      // Inject vault cookies only for cookies not already present on disk.
+      // The headed bootstrap may have refreshed cf_clearance; we must not
+      // overwrite the fresh disk cookie with the stale vault copy.
+      const saved = await getSavedCookies();
+      if (saved.length > 0) {
+        const current = await this.context.cookies();
+        const currentNames = new Set(current.map((c) => c.name));
+        const toInject = saved.filter((c) => !currentNames.has(c.name));
+        if (toInject.length > 0) {
+          await this.context.addCookies(toInject);
+          console.error(`[perplexity-mcp] Injected ${toInject.length} missing cookies from vault.`);
+        } else {
+          console.error("[perplexity-mcp] All vault cookies already present on disk; skipping injection.");
+        }
+      }
 
-    // Navigate to Perplexity (headless — relies on fresh cf_clearance from headed phase)
-    try {
-      await this.page.goto(PERPLEXITY_URL, { waitUntil: "domcontentloaded", timeout: 30000 });
-      await this.page.waitForTimeout(2000);
-    } catch (err) {
-      console.error("[perplexity-mcp] Navigation warning:", (err as Error).message);
-    }
+      this.page = await this.context.newPage();
 
-    await this.checkAuth();
+      // Navigate to Perplexity (headless — relies on fresh cf_clearance from headed phase)
+      try {
+        await this.page.goto(PERPLEXITY_URL, { waitUntil: "domcontentloaded", timeout: 30000 });
+        await this.page.waitForTimeout(2000);
+      } catch (err) {
+        console.error("[perplexity-mcp] Navigation warning:", (err as Error).message);
+      }
+
+      await this.checkAuth();
 
-    // If headed phase was skipped or failed, try loading account info from headless
-    if (!this.accountInfo.modelsConfig) {
-      await this.loadAccountInfo();
+      // If headed phase was skipped or failed, try loading account info from headless
+      if (!this.accountInfo.modelsConfig) {
+        await this.loadAccountInfo();
+      }
+
+      this.writeDaemonStatus(_initAt, null);
+    } catch (err: unknown) {
+      this.writeDaemonStatus(_initAt, err instanceof Error ? err.message : String(err));
+      throw err;
     }
   }
 
@@ -2601,5 +2610,42 @@ export class PerplexityClient {
       await this.browser.close().catch(() => {});
       this.browser = null;
     }
+    this.authenticated = false;
+    this.userId = null;
+    this.writeDaemonStatus(Date.now(), null);
+  }
+
+  // ── Daemon status file ─────────────────────────────────────────────────────
+
+  private daemonTier(): DaemonAuthStatus["tier"] {
+    if (!this.authenticated) return "Anonymous";
+    if (this.accountInfo.isMax) return "Max";
+    if (this.accountInfo.isPro) return "Pro";
+    if (this.accountInfo.isEnterprise) return "Enterprise";
+    return "Authenticated";
+  }
+
+  /**
+   * Write daemon-status.json so the extension UI can show live auth state
+   * instead of relying on the stale models-cache.json snapshot.
+   * @param startedAt - Date.now() captured at the start of init/reinit
+   * @param error - error message if init threw, null on success or shutdown
+   */
+  private writeDaemonStatus(startedAt: number, error: string | null): void {
+    try {
+      const paths = getActivePaths();
+      const status: DaemonAuthStatus = {
+        authenticated: this.authenticated,
+        tier: this.daemonTier(),
+        userId: this.userId,
+        pid: process.pid,
+        lastInit: new Date().toISOString(),
+        initDurationMs: Date.now() - startedAt,
+        error,
+      };
+      writeFileSync(paths.daemonStatus, JSON.stringify(status, null, 2) + "\n");
+    } catch {
+      // Never let a status write crash the daemon.
+    }
   }
 }
diff --git a/packages/mcp-server/src/logout.js b/packages/mcp-server/src/logout.js
index 36831a0..4b6d7db 100644
--- a/packages/mcp-server/src/logout.js
+++ b/packages/mcp-server/src/logout.js
@@ -11,6 +11,8 @@ export async function softLogout(name) {
     delete meta.lastLogin;
     writeFileSync(paths.meta, JSON.stringify(meta, null, 2) + "\n");
   }
+  // Clear login-browser-data so the next login attempt starts with a fresh context.
+  if (existsSync(paths.loginBrowserData)) rmSync(paths.loginBrowserData, { recursive: true, force: true });
   if (existsSync(paths.dir)) writeFileSync(paths.reinit, String(Date.now()));
 }
 
diff --git a/packages/mcp-server/src/profiles.d.ts b/packages/mcp-server/src/profiles.d.ts
index 666bb78..f646266 100644
--- a/packages/mcp-server/src/profiles.d.ts
+++ b/packages/mcp-server/src/profiles.d.ts
@@ -13,7 +13,9 @@ export interface ProfilePaths {
   vault: string;
   vaultPlain: string;
   browserData: string;
+  loginBrowserData: string;
   modelsCache: string;
+  daemonStatus: string;
   history: string;
   attachments: string;
   researches: string;
diff --git a/packages/mcp-server/src/profiles.js b/packages/mcp-server/src/profiles.js
index 6ed72f2..24e7b7f 100644
--- a/packages/mcp-server/src/profiles.js
+++ b/packages/mcp-server/src/profiles.js
@@ -25,6 +25,7 @@ export function getProfilePaths(name) {
     browserData: join(dir, "browser-data"),
     loginBrowserData: join(dir, "login-browser-data"),
     modelsCache: join(dir, "models-cache.json"),
+    daemonStatus: join(dir, "daemon-status.json"),
     history: join(dir, "history"),
     attachments: join(dir, "attachments"),
     researches: join(dir, "researches"),
diff --git a/packages/shared/src/models.ts b/packages/shared/src/models.ts
index a1cb3c6..d3355c3 100644
--- a/packages/shared/src/models.ts
+++ b/packages/shared/src/models.ts
@@ -49,6 +49,21 @@ export interface SpeedBoostStatus {
   runtimeDir: string;
 }
 
+/**
+ * Runtime auth state written by the daemon after every init/reinit/shutdown.
+ * Lives at profiles/<name>/daemon-status.json. Null when the file does not
+ * exist (stdio-only installs, first run, daemon not yet started).
+ */
+export interface DaemonAuthStatus {
+  authenticated: boolean;
+  tier: "Anonymous" | "Authenticated" | "Pro" | "Max" | "Enterprise";
+  userId: string | null;
+  pid: number;
+  lastInit: string;       // ISO timestamp when init/reinit completed
+  initDurationMs: number;
+  error: string | null;   // non-null only when init/reinit threw
+}
+
 export interface AccountSnapshot {
   loggedIn: boolean;
   userId: string | null;
@@ -63,6 +78,13 @@ export interface AccountSnapshot {
   /** Which tier last satisfied a live refresh — null when no refresh has completed yet. */
   lastRefreshTier: RefreshTier | null;
   speedBoost: SpeedBoostStatus;
+  /**
+   * Live auth state from the running daemon. Null when daemon-status.json does
+   * not exist (stdio mode, first run, or daemon not yet started). When present
+   * and authenticated=false while loggedIn=true, the daemon sees anonymous mode
+   * despite stored credentials — the Refresh button can trigger a reinit.
+   */
+  daemonAuth: DaemonAuthStatus | null;
 }
 
 export interface SavedResearchSummary {
diff --git a/packages/webview/src/views.tsx b/packages/webview/src/views.tsx
index 4bad505..456fe7c 100644
--- a/packages/webview/src/views.tsx
+++ b/packages/webview/src/views.tsx
@@ -241,6 +241,19 @@ export function DashboardView({
               : "Run login once to unlock the server."}
           </div>
         </div>
+        {snapshot.daemonAuth && (
+          <div className="flex items-center gap-2">
+            <StatusDot
+              variant={snapshot.daemonAuth.authenticated ? "ok" : "warn"}
+              decorative
+            />
+            <div className="dashboard-status-text">
+              {snapshot.daemonAuth.authenticated
+                ? `Daemon: ${snapshot.daemonAuth.tier}`
+                : "Daemon sees anonymous session — use Refresh state to reconnect"}
+            </div>
+          </div>
+        )}
         <div className="flex flex-wrap gap-2 mt-2">
           {!snapshot.loggedIn && (
             <button className="primary-button" onClick={() => send(authAction)} title={authAction.title}>

From cfcd8ff4f12dc7b3f572764a8b27778942b81dfd Mon Sep 17 00:00:00 2001
From: "A.R." <test@example.com>
Date: Tue, 12 May 2026 01:25:00 +0300
Subject: [PATCH 13/13] fix(ci): commit missing post-build-shebang.mjs + re-arm
 watcher on profile switch

- .gitignore: add packages/mcp-server/scripts/ to allowlist (blanket * rule was
  excluding the scripts dir, so post-build-shebang.mjs was never tracked)
- post-build-shebang.mjs: add the missing script that CI was failing on
  (Cannot find module: post-build-shebang.mjs across all 8 matrix jobs)
- DashboardProvider: track daemonStatusWatchedProfile so ensureDaemonStatusWatch()
  re-arms when the active profile changes (addresses P2 review comment)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
---
 .gitignore                                    |  2 ++
 .../src/webview/DashboardProvider.ts          | 10 ++++--
 .../mcp-server/scripts/post-build-shebang.mjs | 32 +++++++++++++++++++
 3 files changed, 41 insertions(+), 3 deletions(-)
 create mode 100644 packages/mcp-server/scripts/post-build-shebang.mjs

diff --git a/.gitignore b/.gitignore
index 1c2b7b2..75ef70f 100644
--- a/.gitignore
+++ b/.gitignore
@@ -56,6 +56,8 @@
 !packages/mcp-server/
 !packages/mcp-server/src/
 !packages/mcp-server/src/**
+!packages/mcp-server/scripts/
+!packages/mcp-server/scripts/**
 !packages/mcp-server/test/
 !packages/mcp-server/test/**
 !packages/mcp-server/package.json
diff --git a/packages/extension/src/webview/DashboardProvider.ts b/packages/extension/src/webview/DashboardProvider.ts
index 46c85e2..00417f6 100644
--- a/packages/extension/src/webview/DashboardProvider.ts
+++ b/packages/extension/src/webview/DashboardProvider.ts
@@ -122,6 +122,7 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
   private onMcpServerDefinitionsChanged?: () => void;
   private daemonEventsAbort: AbortController | null = null;
   private daemonStatusWatcher: fs.FSWatcher | null = null;
+  private daemonStatusWatchedProfile: string | null = null;
   // v0.8.5: deps factory injected from extension.ts so the auto-regen hook
   // on `postStaleness` can reuse the live ApplyIdeConfigDeps without pulling
   // the daemon runtime singletons into the webview module.
@@ -2094,17 +2095,20 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
         // File may not exist yet (daemon not started). Re-arm on next refresh.
         this.stopDaemonStatusWatch();
       });
+      this.daemonStatusWatchedProfile = profile;
     } catch {
       // daemon-status.json doesn't exist yet — watcher will be re-armed
       // the next time refresh() is called (startDaemonStatusWatch is called
       // from refresh() → ensureWatcher() path below).
       this.daemonStatusWatcher = null;
+      this.daemonStatusWatchedProfile = null;
     }
   }
 
   private stopDaemonStatusWatch(): void {
     this.daemonStatusWatcher?.close();
     this.daemonStatusWatcher = null;
+    this.daemonStatusWatchedProfile = null;
   }
 
   /**
@@ -2115,9 +2119,9 @@ export class DashboardProvider implements vscode.WebviewViewProvider {
   private ensureDaemonStatusWatch(): void {
     const profile = getActiveName() ?? "default";
     const statusFile = getProfilePaths(profile).daemonStatus;
-    // Re-arm if watcher is null (never started, file missing at last attempt,
-    // or profile changed). A live watcher needs no action.
-    if (!this.daemonStatusWatcher) {
+    // Re-arm when: watcher never started, file was missing last time, or
+    // the active profile has changed since the watcher was last started.
+    if (!this.daemonStatusWatcher || this.daemonStatusWatchedProfile !== profile) {
       if (fs.existsSync(statusFile)) {
         this.startDaemonStatusWatch();
       }
diff --git a/packages/mcp-server/scripts/post-build-shebang.mjs b/packages/mcp-server/scripts/post-build-shebang.mjs
new file mode 100644
index 0000000..f589939
--- /dev/null
+++ b/packages/mcp-server/scripts/post-build-shebang.mjs
@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/**
+ * Post-build shebang injection for dist/cli.mjs.
+ *
+ * tsup intentionally omits shebang from bundled output because a shebang in
+ * source files trips vitest/esbuild during test imports.  However, the npm
+ * package.json `bin` field points directly at `dist/cli.mjs`; on POSIX npm
+ * creates a symlink (not a wrapper script), so the kernel needs the shebang
+ * to exec the file directly.
+ *
+ * This script prepends `#!/usr/bin/env node` and ensures the file is
+ * executable (0o755).  It is a no-op on Windows where the kernel ignores
+ * shebangs and npm uses `.cmd` wrappers anyway.
+ */
+import { readFileSync, writeFileSync, chmodSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const file = join(import.meta.dirname, "..", "dist", "cli.mjs");
+if (!existsSync(file)) {
+  console.error("post-build-shebang: dist/cli.mjs not found");
+  process.exit(1);
+}
+
+const content = readFileSync(file, "utf8");
+if (content.startsWith("#!/usr/bin/env node")) {
+  console.log("post-build-shebang: already present, skipping");
+  process.exit(0);
+}
+
+writeFileSync(file, "#!/usr/bin/env node\n" + content);
+chmodSync(file, 0o755);
+console.log("post-build-shebang: injected shebang + chmod 755");