fix(daemon): start daemon on MCP request, harden idle park and config watcher lifecycle

registration.ts: replace passive getDaemonStatus with ensureDaemon({implicit:true})
so MCP tool calls can bring the daemon up, reducing profile contention (one shared
daemon vs stdio-per-window). Fall through to stdio on failure so MCP still works.

auth.js: resolveIdleParkMs now returns the default on malformed input instead of
disabling parking (a typo — "30m", "1_800_000" — used to pin ~300-600MB Chromium

Author: ARHAEEM

packages/extension/src/mcp/registration.ts

@@ -74,14 +74,47 @@ export function registerMcpProvider(
         try {
           // ── HTTP definition branch (D-03) ──────────────────────────────
           const settings = getSettings();
+          // Declared out here so the stdio fallback below can tell "the daemon is
+          // serving us" from "we fell through" — the credential branch depends on it.
+          let daemon: { port: number; bearerToken: string } | null = null;
           if (settings.mcp.useDaemon && daemonManager) {
-            const daemonStatus = await daemonManager.getDaemonStatus();
-            if (daemonStatus.healthy && daemonStatus.port != null && daemonStatus.bearerToken != null) {
+            // START the daemon, don't just look for one. A passive getDaemonStatus()
+            // meant an MCP request could never bring the daemon up, so unless the user
+            // had opened the dashboard (or run a formula command) EVERY session fell
+            // through to the stdio branch below — and that branch is the one that
+            // contends for the shared .chrome-profile, once per VS Code window. One
+            // shared daemon is the configuration that avoids Chrome exit 21, so
+            // starting it here makes profile collisions LESS likely, not more.
+            //
+            // implicit:true is load-bearing: it keeps the _userStopped latch (a
+            // deliberate Stop must not be undone by the next tool call) and the
+            // SPAWN_SUPPRESS_MS window that closed the runaway-spawn OOM documented
+            // in daemon-manager.ts. Never pass implicit:false from here.
+            //
+            // Timeout matches ensureDaemon's own default and SPAWN_SUPPRESS_MS. It is
+            // a ceiling, not a cost: a healthy daemon returns on the first poll.
+            // ponytail: on failure we fall through to stdio rather than returning [],
+            // so MCP still works when the daemon can't start. That leaves a narrow
+            // window where a late-arriving daemon and the stdio server both drive the
+            // same profile; give the fallback its own AIRTABLE_PROFILE_DIR if that
+            // ever shows up in the wild.
+            try {
+              const info = await daemonManager.ensureDaemon({ implicit: true, timeoutMs: 15_000 });
+              if (info?.port != null && info.bearerToken != null) {
+                daemon = { port: info.port, bearerToken: info.bearerToken };
+              }
+            } catch {
+              daemon = null;
+            }
+            if (daemon) {
               const httpDef = createHttpDefinition(
-                `http://127.0.0.1:${daemonStatus.port}/mcp`,
-                `Bearer ${daemonStatus.bearerToken}`,
+                `http://127.0.0.1:${daemon.port}/mcp`,
+                `Bearer ${daemon.bearerToken}`,
               );
               if (httpDef) return [httpDef];
+              // A definition we could not construct is not a served daemon — fall
+              // through to stdio AND let the credential branch know it must inject.
+              daemon = null;
             }
           }
 
@@ -124,11 +157,17 @@ export function registerMcpProvider(
           if (authManager) {
             const authMode = settings.mcp.authMode;
             const isCredMode = authMode === 'byo' || authMode === 'direct-login';
-            if (isCredMode && !settings.mcp.useDaemon) {
-              // Pure stdio mode (no daemon): byo/direct-login REQUIRE credentials
-              // (no browser), and env is the only channel VS Code gives a stdio
-              // spawn. In daemon mode the daemon endpoint (/daemon/auth-credentials)
-              // is the SINGLE credential channel — never duplicate secrets into env.
+            if (isCredMode && !daemon) {
+              // Gate on "did we actually fall through to stdio", NOT on the useDaemon
+              // SETTING. Those used to be the same thing; they no longer are. useDaemon
+              // defaults true, so with the setting-based test a byo/direct-login user
+              // who reached this branch — daemon failed to start, or they pressed Stop —
+              // got a stdio server with NO credentials and no browser to fall back on:
+              // *_CREDENTIALS_MISSING on every tool call. `daemon` is null here exactly
+              // when the daemon is not serving us, which is precisely when env is once
+              // again the only credential channel VS Code gives a stdio spawn.
+              // When the daemon IS serving, /daemon/auth-credentials stays the SINGLE
+              // channel — secrets are still never duplicated into env on that path.
               const credEnv = await authManager.getCredentialsEnv(authMode);
               if (credEnv) Object.assign(env, credEnv);
             } else if (!isCredMode && settings.auth.loginMode === 'auto') {

packages/mcp-server/src/auth.js

@@ -77,7 +77,13 @@ function resolveIdleParkMs() {
   const trimmed = String(raw).trim();
   if (trimmed === '') return 30 * 60_000;
   const parsed = Number(trimmed);
-  if (!Number.isInteger(parsed) || parsed <= 0) return 0;
+  // Only an explicit, well-formed 0 (or negative) disables parking. Garbage used to
+  // land here too, so a typo — "30m", "1_800_000", a stray quote — silently pinned a
+  // ~300-600MB Chromium tree resident forever, and the env var that was meant to tune
+  // parking switched it off instead. Unparseable now means "I didn't understand you,
+  // keep the default", which is the safe direction to fail.
+  if (!Number.isInteger(parsed)) return 30 * 60_000;
+  if (parsed <= 0) return 0;
   return parsed;
 }
 
@@ -836,7 +842,15 @@ export class AirtableAuth {
       // Without a cookie header, cookie-only park would leave isLoggedIn true
       // with no HTTP path and force a full Chromium relaunch next call.
       if (!this._credentials?.cookieHeader) {
-        console.error('[auth] idle park aborted — no cookie snapshot available; keeping browser up.');
+        // Bailing here does NOT strand the browser, though it reads like it does:
+        // scheduleIdlePark() nulled _parkTimer before calling us, so nothing is armed
+        // at this instant. The re-arm comes from _subscribeBusy — we are inside
+        // runBarrier, so the scheduler is busy now and fires a busy→idle edge the
+        // moment this returns, which calls scheduleIdlePark() again. Retry is
+        // automatic; an explicit re-arm here is redundant, not defensive.
+        // Pinned by "a cookie-less park RE-ARMS the timer" in test-auth-idle-park —
+        // that test fails only if BOTH paths are gone, which is the real invariant.
+        console.error('[auth] idle park deferred — no cookie snapshot available; will retry when idle again.');
         return;
       }
 

packages/mcp-server/src/daemon/exit-intent.js

@@ -0,0 +1,52 @@
+/**
+ * One-slot handoff from a tool handler to the express /mcp route.
+ *
+ * A `manage_daemon` stop/restart arriving over /mcp CANNOT shut the process down
+ * from inside the handler. Traced through the bundled SDK
+ * (@modelcontextprotocol/sdk/dist/cjs/server/webStandardStreamableHttp.js):
+ * with `enableJsonResponse`, `handlePostRequest` returns a Promise that is only
+ * ever settled by `resolveJson`, which lives in `_streamMapping`. `close()`
+ * runs each entry's `cleanup()` — which merely DELETES the map entry, never
+ * calling `resolveJson` — then clears the map. The still-pending tool call then
+ * returns, `send()` finds the request id in `_requestToStreamMapping` (close()
+ * does not clear that one) but no stream, and throws
+ * `No connection established for request ID: …`. The handleRequest promise stays
+ * unsettled forever, `res` never ends, and `httpServer.close()` blocks on the
+ * open socket. A `setTimeout` inside the handler is the same race with extra
+ * steps: the handler has no signal that its JSON was flushed.
+ *
+ * So the handler only STATES the intent here; server.js consumes it from the
+ * response's own 'finish' event, which fires strictly after the body is handed
+ * to the OS. Express owns the exit, the handler owns the answer.
+ *
+ * ponytail: a module-global single slot, not a per-request map — an exit is
+ * process-wide by definition and there is exactly one daemon per process, so
+ * two concurrent stop requests collapsing into one exit is the correct outcome.
+ */
+
+/** @typedef {{ action: 'stop'|'restart', by?: string, reason?: string|null }} DaemonExitIntent */
+
+/** @type {DaemonExitIntent|null} */
+let pending = null;
+
+/** @param {DaemonExitIntent} intent */
+export function requestDaemonExit(intent) {
+  pending = intent;
+}
+
+/** Read-and-clear. @returns {DaemonExitIntent|null} */
+export function takeDaemonExit() {
+  const intent = pending;
+  pending = null;
+  return intent;
+}
+
+/** Non-consuming peek — for tests and for a handler that wants to report what it just staged. */
+export function peekDaemonExit() {
+  return pending;
+}
+
+/** Drop a staged intent (e.g. the action failed validation after staging). */
+export function clearDaemonExit() {
+  pending = null;
+}

packages/mcp-server/src/daemon/launcher.js

@@ -10,6 +10,7 @@ import { startDaemonServer } from './server.js';
 import { acquire, getLockfilePath, isStale, read, release, replace } from './lockfile.js';
 import { ensureToken, getTokenPath, readToken } from './token.js';
 import { readTunnelSettings, writeTunnelSettings, getTunnelProvider } from './tunnel-providers/index.js';
+import { clearStopSentinel } from './stop-sentinel.js';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -60,7 +61,15 @@ async function probeHealth(record, options = {}) {
   }
 }
 
-async function adminRequest(record, path, options) {
+/**
+ * Authenticated loopback call to a daemon's own /daemon/* route, using the
+ * bearer from its lockfile. Exported so `manage_daemon` can drive tunnel and
+ * token administration through the SERVER's routes instead of reimplementing
+ * them — `activeTunnel` and `currentToken` are closure state inside
+ * startDaemonServer, and anything that mutates them from outside leaves the
+ * running server holding a stale handle.
+ */
+export async function adminRequest(record, path, options) {
   const response = await fetch(`http://127.0.0.1:${record.port}${path}`, {
     method: options.method,
     headers: {
@@ -268,6 +277,12 @@ export async function startDaemon(options = {}) {
       continue;
     }
 
+    // A daemon is starting on purpose, so any "the user stopped this deliberately"
+    // marker is now spent. Clearing it HERE — on the one path every intentional
+    // start goes through — is what stops a stale sentinel from wedging startup
+    // forever; see stop-sentinel.js.
+    clearStopSentinel({ configDir });
+
     let server;
     let lspChild = null;
     let activeTunnel = null;