@juspay/neurolink 9.86.4 → 9.87.0

package/dist/cli/commands/proxy.js

@@ -18,11 +18,13 @@ import { buildProxyHealthResponse, createProxyReadinessState, markProxyReady, wa
 import { logger } from "../../lib/utils/logger.js";
 import { formatUptime, isProcessRunning, StateFileManager, } from "../utils/serverUtils.js";
 import { configureProxyKeepAliveDispatcher } from "../../lib/proxy/proxyDispatcher.js";
+import { anthropicAccountKeysEqual, createAccountAllowlist, ENV_ANTHROPIC_ACCOUNT_KEY, isAccountAllowed, LEGACY_ANTHROPIC_ACCOUNT_KEY, normalizeAnthropicAccountKey, shouldLoadFallbackCredential, } from "../../lib/proxy/accountSelection.js";
 import { loadProxyEnvFile, resolveProxyEnvFile, } from "../../lib/proxy/proxyEnv.js";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
+import packageJson from "../../../package.json" with { type: "json" };
 const _require = createRequire(import.meta.url);
-const { version: PROXY_VERSION } = _require("../../../package.json");
+const PROXY_VERSION = packageJson.version;
 const PROXY_TELEMETRY_SCRIPT_PATH = fileURLToPath(new URL("../../../scripts/observability/manage-local-openobserve.sh", import.meta.url));
 // =============================================================================
 // STATE MANAGEMENT
@@ -73,6 +75,7 @@ function getProcessStatus(pid) {
  *  when the configured account isn't currently usable. */
 async function resolveStatusPrimaryAccount(proxyConfig) {
     const configured = proxyConfig?.routing?.primaryAccount?.trim() || null;
+    const accountAllowlist = createAccountAllowlist(proxyConfig?.routing?.accountAllowlist);
     let enabledAnthropicKeys = [];
     try {
         const { tokenStore } = await import("../../lib/auth/tokenStore.js");
@@ -80,7 +83,7 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         const filtered = [];
         for (const key of all) {
             const disabled = await tokenStore.isDisabled(key);
-            if (!disabled) {
+            if (!disabled && isAccountAllowed(key, accountAllowlist)) {
                 filtered.push(key);
             }
         }
@@ -90,11 +93,12 @@ async function resolveStatusPrimaryAccount(proxyConfig) {
         logger.debug(`[proxy] /status: failed to enumerate anthropic accounts: ${err instanceof Error ? err.message : String(err)}`);
     }
     if (configured) {
-        const configuredKey = `anthropic:${configured}`;
-        if (enabledAnthropicKeys.includes(configuredKey)) {
+        const configuredKey = normalizeAnthropicAccountKey(configured);
+        const matchedKey = enabledAnthropicKeys.find((key) => anthropicAccountKeysEqual(key, configuredKey));
+        if (matchedKey) {
             return {
                 configured,
-                key: configuredKey,
+                key: matchedKey,
                 label: configured,
                 source: "configured",
             };
@@ -129,39 +133,11 @@ async function isLaunchdManaging() {
         return false;
     }
 }
-/**
- * Attempt to restart the proxy via launchd kickstart.
- * Returns true if the proxy comes back healthy within timeoutMs.
- */
-async function tryLaunchdRestart(host, port, timeoutMs = 15_000) {
-    if (process.platform !== "darwin") {
-        return false;
-    }
-    try {
-        const { existsSync } = await import("fs");
-        if (!existsSync(PLIST_PATH)) {
-            return false;
-        }
-    }
-    catch {
-        return false;
-    }
-    try {
-        const { execFileSync } = await import("node:child_process");
-        const uid = process.getuid?.() ?? 501;
-        execFileSync("launchctl", ["kickstart", "-k", `gui/${uid}/${PLIST_LABEL}`], { stdio: "ignore", timeout: 5_000 });
-    }
-    catch {
-        return false;
-    }
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        await sleep(1_000);
-        if (await isProxyHealthy(host, port, 2_000)) {
-            return true;
-        }
-    }
-    return false;
+function isLaunchdManagedProcess() {
+    return process.platform === "darwin" && process.ppid === 1;
+}
+function isProxyAutoUpdateEnabled(value = process.env.NEUROLINK_PROXY_AUTO_UPDATE) {
+    return ["1", "on", "true"].includes((value ?? "").trim().toLowerCase());
 }
 /** Keys we manage in Claude Code's settings.env */
 const PROXY_MANAGED_KEYS = ["ANTHROPIC_BASE_URL", "ENABLE_TOOL_SEARCH"];
@@ -760,17 +736,14 @@ async function loadProxyStartConfiguration(argv, spinner) {
         }
     }
     catch (configError) {
-        if (argv.config) {
-            if (spinner) {
-                spinner.fail(chalk.red(`Failed to load proxy config: ${configPath}`));
-            }
-            process.exit(1);
-        }
         const isNotFound = configError instanceof Error &&
             "code" in configError &&
             configError.code === "ENOENT";
-        if (!isNotFound) {
-            logger.warn(`[proxy] Ignoring default config ${configPath}: ${configError instanceof Error ? configError.message : String(configError)}`);
+        if (argv.config || !isNotFound) {
+            if (spinner) {
+                spinner.fail(chalk.red(`Failed to load proxy config: ${configPath}`));
+            }
+            throw configError;
         }
     }
     const strategy = (argv.strategy ??
@@ -787,6 +760,11 @@ async function loadProxyStartConfiguration(argv, spinner) {
         });
     }
     const primaryAccountKey = await resolveBootPrimaryAccountKey(proxyConfig?.routing?.primaryAccount);
+    const accountAllowlist = await resolveBootAccountAllowlist(proxyConfig?.routing?.accountAllowlist);
+    if (primaryAccountKey &&
+        !isAccountAllowed(primaryAccountKey, accountAllowlist)) {
+        throw new Error(`Configured routing.primaryAccount=${proxyConfig?.routing?.primaryAccount} is excluded by routing.accountAllowlist`);
+    }
     return {
         configPath,
         proxyConfig,
@@ -794,8 +772,34 @@ async function loadProxyStartConfiguration(argv, spinner) {
         modelRouter,
         passthrough: argv.passthrough ?? false,
         primaryAccountKey,
+        accountAllowlist,
     };
 }
+async function resolveBootAccountAllowlist(configuredAccounts) {
+    const allowlist = createAccountAllowlist(configuredAccounts);
+    if (allowlist === undefined) {
+        return undefined;
+    }
+    if (allowlist.size === 0) {
+        logger.warn("[proxy] routing.accountAllowlist is empty; all stored Anthropic credentials are denied");
+        return allowlist;
+    }
+    try {
+        const { tokenStore } = await import("../../lib/auth/tokenStore.js");
+        const known = new Set((await tokenStore.listByPrefix("anthropic:")).map(normalizeAnthropicAccountKey));
+        known.add(LEGACY_ANTHROPIC_ACCOUNT_KEY);
+        known.add(ENV_ANTHROPIC_ACCOUNT_KEY);
+        for (const key of allowlist) {
+            if (!known.has(key)) {
+                logger.warn(`[proxy] WARN: routing.accountAllowlist entry ${key} is allowed but not currently authenticated`);
+            }
+        }
+    }
+    catch (err) {
+        logger.debug(`[proxy] could not validate account allowlist against token store: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return allowlist;
+}
 /** Resolve the operator's configured primary email to a stable token-store
  *  key (anthropic:<email>). Cross-checks the token store and emits a one-time
  *  startup warning if the configured account isn't authenticated — but still
@@ -806,11 +810,11 @@ async function resolveBootPrimaryAccountKey(primaryEmail) {
     if (!trimmed) {
         return undefined;
     }
-    const key = `anthropic:${trimmed}`;
+    const key = normalizeAnthropicAccountKey(trimmed);
     try {
         const { tokenStore } = await import("../../lib/auth/tokenStore.js");
         const known = await tokenStore.listByPrefix("anthropic:");
-        if (!known.includes(key)) {
+        if (!known.some((knownKey) => anthropicAccountKeysEqual(knownKey, key))) {
             logger.warn(`[proxy] WARN: configured routing.primaryAccount=${trimmed} not ` +
                 `found in token store; falling back to first enabled account. ` +
                 `Run \`neurolink auth login --add\` to authenticate it, or ` +
@@ -842,7 +846,7 @@ async function createProxyStartApp(params) {
             },
         }, 502);
     });
-    const routeGroup = createClaudeProxyRoutes(params.modelRouter, "", params.strategy, params.passthrough, params.primaryAccountKey);
+    const routeGroup = createClaudeProxyRoutes(params.modelRouter, "", params.strategy, params.passthrough, params.primaryAccountKey, params.accountAllowlist);
     const openaiRouteGroup = createOpenAIProxyRoutes(params.modelRouter, "", params.port);
     const allProxyRoutes = [...routeGroup.routes, ...openaiRouteGroup.routes];
     for (const route of allProxyRoutes) {
@@ -967,7 +971,20 @@ async function createProxyStartApp(params) {
     })));
     app.get("/status", async (c) => {
         const { getStats } = await import("../../lib/proxy/usageStats.js");
+        const { loadAccountCooldowns } = await import("../../lib/proxy/accountCooldown.js");
         const stats = getStats();
+        const cooldowns = await loadAccountCooldowns();
+        const storedAccountKeys = new Set();
+        try {
+            const { tokenStore } = await import("../../lib/auth/tokenStore.js");
+            for (const key of await tokenStore.listByPrefix("anthropic:")) {
+                storedAccountKeys.add(normalizeAnthropicAccountKey(key));
+            }
+        }
+        catch (err) {
+            logger.debug(`[proxy] /status: failed to resolve account cooldown labels: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        const now = Date.now();
         const health = buildProxyHealthResponse(readiness, {
             strategy: params.strategy,
             passthrough: params.passthrough,
@@ -992,20 +1009,35 @@ async function createProxyStartApp(params) {
                 totalSuccess: stats.totalSuccess,
                 totalErrors: stats.totalErrors,
                 totalRateLimits: stats.totalRateLimits,
-                accounts: Object.values(stats.accounts).map((account) => ({
-                    label: account.label,
-                    type: account.type,
-                    attempts: account.attemptCount,
-                    requests: account.attemptCount,
-                    success: account.successCount,
-                    errors: account.errorCount,
-                    rateLimits: account.rateLimitCount,
-                    cooling: false, // No persistent cooldown — always active
-                })),
+                accounts: Object.values(stats.accounts).map((account) => {
+                    const normalizedKey = normalizeAnthropicAccountKey(account.label);
+                    const accountKey = storedAccountKeys.has(normalizedKey)
+                        ? normalizedKey
+                        : account.label === "env"
+                            ? ENV_ANTHROPIC_ACCOUNT_KEY
+                            : account.type === "oauth"
+                                ? LEGACY_ANTHROPIC_ACCOUNT_KEY
+                                : normalizedKey;
+                    return {
+                        label: account.label,
+                        type: account.type,
+                        attempts: account.attemptCount,
+                        requests: account.attemptCount,
+                        success: account.successCount,
+                        errors: account.errorCount,
+                        rateLimits: account.rateLimitCount,
+                        cooling: (cooldowns[accountKey]?.coolingUntil ?? 0) > now,
+                    };
+                }),
                 primaryAccount,
             },
             config: params.proxyConfig
-                ? { hasRouting: !!params.proxyConfig.routing }
+                ? {
+                    hasRouting: !!params.proxyConfig.routing,
+                    accountAllowlist: params.accountAllowlist
+                        ? [...params.accountAllowlist]
+                        : null,
+                }
                 : null,
         });
     });
@@ -1057,14 +1089,45 @@ async function initializeProxyOpenTelemetry() {
         logger.debug(`[proxy] OpenTelemetry init failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
     }
 }
-async function refreshProxyTokensInBackground() {
-    const { needsRefresh, refreshToken, persistTokens } = await import("../../lib/proxy/tokenRefresh.js");
+const BACKGROUND_REFRESH_BASE_COOLDOWN_MS = 30_000;
+const BACKGROUND_REFRESH_MAX_COOLDOWN_MS = 5 * 60 * 1000;
+const backgroundRefreshFailures = new Map();
+const backgroundRejectedRefreshTokens = new Map();
+let backgroundRefreshInProgress = false;
+function canAttemptBackgroundRefresh(key, refreshToken) {
+    const rejectedToken = backgroundRejectedRefreshTokens.get(key);
+    if (rejectedToken !== undefined) {
+        if (rejectedToken === refreshToken) {
+            return false;
+        }
+        backgroundRejectedRefreshTokens.delete(key);
+    }
+    const state = backgroundRefreshFailures.get(key);
+    return !state || Date.now() >= state.coolingUntil;
+}
+function recordBackgroundRefreshFailure(key) {
+    const consecutiveFailures = (backgroundRefreshFailures.get(key)?.consecutiveFailures ?? 0) + 1;
+    const delayMs = Math.min(BACKGROUND_REFRESH_MAX_COOLDOWN_MS, BACKGROUND_REFRESH_BASE_COOLDOWN_MS *
+        2 ** Math.min(consecutiveFailures - 1, 4));
+    backgroundRefreshFailures.set(key, {
+        consecutiveFailures,
+        coolingUntil: Date.now() + delayMs,
+    });
+}
+async function refreshProxyTokensInBackground(accountAllowlist) {
+    const { needsRefresh, refreshToken, persistTokens, isPermanentRefreshFailure, } = await import("../../lib/proxy/tokenRefresh.js");
     const { tokenStore } = await import("../../lib/auth/tokenStore.js");
+    let storedAnthropicAccountCount;
     try {
         const allKeys = await tokenStore.listProviders();
         const anthropicKeys = allKeys.filter((key) => key.startsWith("anthropic:"));
+        storedAnthropicAccountCount = anthropicKeys.length;
         for (const key of anthropicKeys) {
             try {
+                if (!isAccountAllowed(key, accountAllowlist) ||
+                    (await tokenStore.isDisabled(key))) {
+                    continue;
+                }
                 const tokens = await tokenStore.loadTokens(key);
                 if (!tokens) {
                     continue;
@@ -1075,12 +1138,29 @@ async function refreshProxyTokensInBackground() {
                     refreshToken: tokens.refreshToken,
                     expiresAt: tokens.expiresAt,
                 };
-                if (needsRefresh(account)) {
-                    const result = await refreshToken(account);
-                    if (result.success) {
-                        await persistTokens({ providerKey: key }, account);
-                        logger.debug(`[proxy] background token refresh succeeded for ${key}`);
-                    }
+                if (!needsRefresh(account)) {
+                    backgroundRefreshFailures.delete(key);
+                    continue;
+                }
+                if (!canAttemptBackgroundRefresh(key, tokens.refreshToken)) {
+                    continue;
+                }
+                const result = await refreshToken(account);
+                if (result.success) {
+                    await persistTokens({ providerKey: key }, account);
+                    backgroundRefreshFailures.delete(key);
+                    logger.debug(`[proxy] background token refresh succeeded for ${key}`);
+                }
+                else if (isPermanentRefreshFailure(result)) {
+                    await tokenStore.markDisabled(key, "refresh_invalid");
+                    backgroundRefreshFailures.delete(key);
+                    logger.warn(`[proxy] background refresh credential rejected for ${key}; disabled until explicit login`);
+                }
+                else {
+                    recordBackgroundRefreshFailure(key);
+                    logger.debug(`[proxy] background token refresh deferred for ${key}`, {
+                        status: result.status,
+                    });
                 }
             }
             catch {
@@ -1092,6 +1172,10 @@ async function refreshProxyTokensInBackground() {
         // non-fatal
     }
     try {
+        if (storedAnthropicAccountCount === undefined ||
+            !shouldLoadFallbackCredential(storedAnthropicAccountCount, LEGACY_ANTHROPIC_ACCOUNT_KEY, accountAllowlist)) {
+            return;
+        }
         const credPath = join(homedir(), ".neurolink", "anthropic-credentials.json");
         const { readFileSync } = await import("fs");
         const creds = JSON.parse(readFileSync(credPath, "utf8"));
@@ -1104,32 +1188,108 @@ async function refreshProxyTokensInBackground() {
             refreshToken: creds.oauth.refreshToken,
             expiresAt: creds.oauth.expiresAt,
         };
-        if (needsRefresh(account)) {
+        const legacyKey = LEGACY_ANTHROPIC_ACCOUNT_KEY;
+        if (!needsRefresh(account)) {
+            backgroundRefreshFailures.delete(legacyKey);
+            return;
+        }
+        if (canAttemptBackgroundRefresh(legacyKey, account.refreshToken)) {
             const result = await refreshToken(account);
             if (result.success) {
                 await persistTokens(credPath, account);
+                backgroundRefreshFailures.delete(legacyKey);
+                backgroundRejectedRefreshTokens.delete(legacyKey);
                 logger.debug("[proxy] background token refresh succeeded");
             }
+            else if (isPermanentRefreshFailure(result)) {
+                backgroundRefreshFailures.delete(legacyKey);
+                backgroundRejectedRefreshTokens.set(legacyKey, account.refreshToken ?? "");
+                logger.warn("[proxy] background legacy refresh credential rejected; waiting for explicit login");
+            }
+            else {
+                recordBackgroundRefreshFailure(legacyKey);
+                logger.debug("[proxy] background legacy token refresh deferred", {
+                    status: result.status,
+                });
+            }
         }
     }
     catch {
         // non-fatal
     }
 }
-function startProxyBackgroundMaintenance(cleanupLogs) {
+function startProxyBackgroundMaintenance(cleanupLogs, accountAllowlist) {
     const refreshInterval = setInterval(() => {
-        void refreshProxyTokensInBackground();
+        if (backgroundRefreshInProgress) {
+            return;
+        }
+        backgroundRefreshInProgress = true;
+        void refreshProxyTokensInBackground(accountAllowlist)
+            .catch((error) => {
+            logger.debug(`[proxy] background token refresh cycle failed: ${error instanceof Error ? error.message : String(error)}`);
+        })
+            .finally(() => {
+            backgroundRefreshInProgress = false;
+        });
     }, 30_000);
     const logCleanupInterval = setInterval(() => {
-        cleanupLogs(7, 500);
+        try {
+            cleanupLogs(7, 500);
+        }
+        catch (error) {
+            logger.debug(`[proxy] background log cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
     }, 60 * 60 * 1000);
     return { refreshInterval, logCleanupInterval };
 }
 function registerProxyShutdownHandlers(params) {
+    let shutdownStarted = false;
+    const closeServer = async () => {
+        const close = params.server.close?.bind(params.server);
+        if (!close) {
+            return;
+        }
+        await new Promise((resolve, reject) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timeout);
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            };
+            const timeout = setTimeout(() => finish(new Error("Timed out draining the proxy server")), 30_000);
+            timeout.unref?.();
+            try {
+                close((error) => finish(error));
+            }
+            catch (error) {
+                finish(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    };
     const shutdown = async (signal) => {
+        if (shutdownStarted) {
+            return;
+        }
+        shutdownStarted = true;
         clearInterval(params.refreshInterval);
         clearInterval(params.logCleanupInterval);
         logger.always(`\nShutting down proxy (${signal})...`);
+        let exitCode = signal === "SIGINT" ? 0 : 1;
+        try {
+            await closeServer();
+        }
+        catch (error) {
+            exitCode = 1;
+            logger.error(`[proxy] failed to drain server during shutdown: ${error instanceof Error ? error.message : String(error)}`);
+        }
         try {
             const { flushOpenTelemetry, shutdownOpenTelemetry } = await import("../../lib/services/server/ai/observability/instrumentation.js");
             await flushOpenTelemetry();
@@ -1155,19 +1315,23 @@ function registerProxyShutdownHandlers(params) {
             }
         }
         try {
-            params.server.close?.();
+            clearProxyState();
         }
-        catch {
-            // Best-effort close
+        catch (error) {
+            exitCode = 1;
+            logger.error(`[proxy] failed to clear runtime state during shutdown: ${error instanceof Error ? error.message : String(error)}`);
         }
-        clearProxyState();
-        process.exit(signal === "SIGINT" ? 0 : 1);
+        process.exit(exitCode);
+    };
+    const forceExitAfterShutdownFailure = (error) => {
+        logger.error(`[proxy] unexpected shutdown failure: ${error instanceof Error ? error.message : String(error)}`);
+        process.exit(1);
     };
     process.on("SIGTERM", () => {
-        void shutdown("SIGTERM");
+        void shutdown("SIGTERM").catch(forceExitAfterShutdownFailure);
     });
     process.on("SIGINT", () => {
-        void shutdown("SIGINT");
+        void shutdown("SIGINT").catch(forceExitAfterShutdownFailure);
     });
 }
 async function startProxyRuntime(params) {
@@ -1177,9 +1341,11 @@ async function startProxyRuntime(params) {
         port: params.port,
         hostname: params.host,
     });
-    // Skip the fail-open guard in dev mode — it monitors the proxy and clears
-    // global Claude settings on exit, which is exactly what we want to avoid.
-    const guardPid = params.argv.dev
+    const managedByLaunchd = isLaunchdManagedProcess();
+    // launchd already owns restart supervision. A second detached supervisor can
+    // outlive its parent and terminate a healthy replacement, so the guard is
+    // reserved for foreground mode where it only cleans stale client settings.
+    const guardPid = params.argv.dev || managedByLaunchd
         ? undefined
         : spawnFailOpenGuard(params.host, params.port, process.pid);
     const readinessHost = params.host === "0.0.0.0" ? "127.0.0.1" : params.host;
@@ -1206,10 +1372,11 @@ async function startProxyRuntime(params) {
         statusPath: "/status",
         envFile: params.loadedEnvFile,
         fallbackChain,
+        accountAllowlist: params.accountAllowlist
+            ? [...params.accountAllowlist]
+            : undefined,
         guardPid,
-        managedBy: process.platform === "darwin" && process.ppid === 1
-            ? "launchd"
-            : "manual",
+        managedBy: managedByLaunchd ? "launchd" : "manual",
         passthrough: params.passthrough,
     });
     if (params.spinner) {
@@ -1255,7 +1422,7 @@ async function startProxyRuntime(params) {
     else {
         logger.always(chalk.dim("  ⊘ Dev mode: skipping client auto-configuration"));
     }
-    const maintenance = startProxyBackgroundMaintenance(params.cleanupLogs);
+    const maintenance = startProxyBackgroundMaintenance(params.cleanupLogs, params.accountAllowlist);
     registerProxyShutdownHandlers({
         server,
         host: params.host,
@@ -1276,6 +1443,8 @@ async function startProxyCommandHandler(argv) {
             setProxyStateDir(devPaths.stateDir);
             const { initAccountQuota } = await import("../../lib/proxy/accountQuota.js");
             initAccountQuota(devPaths.quotaFile);
+            const { initAccountCooldown } = await import("../../lib/proxy/accountCooldown.js");
+            initAccountCooldown(devPaths.cooldownFile);
             // Ensure the dev state directory exists
             const { mkdirSync, existsSync } = await import("fs");
             if (!existsSync(devPaths.stateDir)) {
@@ -1291,7 +1460,7 @@ async function startProxyCommandHandler(argv) {
         // content-filters. Runs once, after env load so it can be tuned via env.
         configureProxyKeepAliveDispatcher();
         const { neurolink, cleanupLogs } = await createProxyNeurolinkRuntime(devPaths?.logsDir);
-        const { proxyConfig, strategy, modelRouter, passthrough, primaryAccountKey, } = await loadProxyStartConfiguration(argv, spinner);
+        const { proxyConfig, strategy, modelRouter, passthrough, primaryAccountKey, accountAllowlist, } = await loadProxyStartConfiguration(argv, spinner);
         if (spinner) {
             spinner.text = "Configuring server...";
         }
@@ -1306,6 +1475,7 @@ async function startProxyCommandHandler(argv) {
             host,
             proxyConfig,
             primaryAccountKey,
+            accountAllowlist,
         });
         await initializeProxyOpenTelemetry();
         if (spinner) {
@@ -1320,6 +1490,7 @@ async function startProxyCommandHandler(argv) {
             port,
             strategy,
             proxyConfig,
+            accountAllowlist,
             loadedEnvFile,
             passthrough,
             cleanupLogs,
@@ -1471,6 +1642,7 @@ export const proxyStatusCommand = {
                 url: null,
                 envFile: null,
                 fallbackChain: null,
+                accountAllowlist: null,
             };
             if (state && isProcessRunning(state.pid)) {
                 status.running = true;
@@ -1484,6 +1656,7 @@ export const proxyStatusCommand = {
                 status.url = `http://${state.host === "0.0.0.0" ? "localhost" : state.host}:${state.port}`;
                 status.envFile = state.envFile ?? null;
                 status.fallbackChain = state.fallbackChain ?? null;
+                status.accountAllowlist = state.accountAllowlist ?? null;
             }
             // Fetch live stats before rendering (JSON or text)
             let liveStats = null;
@@ -1519,6 +1692,12 @@ export const proxyStatusCommand = {
                 if (status.envFile) {
                     logger.always(`  ${chalk.bold("Env File:")}   ${chalk.cyan(status.envFile)}`);
                 }
+                if (status.accountAllowlist) {
+                    const scope = status.accountAllowlist.length > 0
+                        ? status.accountAllowlist.join(", ")
+                        : "none (deny all)";
+                    logger.always(`  ${chalk.bold("Accounts:")}   ${chalk.cyan(scope)}`);
+                }
                 // Display fallback chain if configured
                 if (status.fallbackChain && status.fallbackChain.length > 0) {
                     logger.always("");
@@ -1676,10 +1855,8 @@ export const proxyGuardCommand = {
         if (!Number.isFinite(parentPid) || parentPid <= 0) {
             return;
         }
-        // ---------------------------------------------------------------
-        // Auto-update loop (runs concurrently with the health monitor)
-        // Always on — no flags needed. Hardcoded sensible defaults.
-        // ---------------------------------------------------------------
+        // Automatic package mutation is disabled by default. Operators must opt in
+        // explicitly, and launchd-managed proxy processes do not spawn this guard.
         const UPDATE_CHECK_INTERVAL_MS = 2 * 60 * 60 * 1000; // 2 hours
         const QUIET_THRESHOLD_MS = 120 * 1000; // 2 minutes of silence
         const UPDATE_TIMEOUT_MS = 30 * 1000; // 30 seconds to come healthy
@@ -1697,11 +1874,27 @@ export const proxyGuardCommand = {
         }
         // Auto-update only works on macOS with launchd. On other platforms,
         // there's no restart mechanism, so skip the update loop entirely.
-        const canAutoUpdate = process.platform === "darwin" && (await isLaunchdManaging());
+        const canAutoUpdate = isProxyAutoUpdateEnabled() &&
+            process.platform === "darwin" &&
+            (await isLaunchdManaging());
+        let guardStopping = false;
+        let updateCheckTimeout;
+        let updateCheckInterval;
+        const stopUpdateChecks = () => {
+            guardStopping = true;
+            if (updateCheckTimeout) {
+                clearTimeout(updateCheckTimeout);
+                updateCheckTimeout = undefined;
+            }
+            if (updateCheckInterval) {
+                clearInterval(updateCheckInterval);
+                updateCheckInterval = undefined;
+            }
+        };
         let updateInProgress = false;
         let updateRestartInProgress = false;
         const runUpdateCheck = async () => {
-            if (updateInProgress) {
+            if (guardStopping || updateInProgress) {
                 return;
             }
             updateInProgress = true;
@@ -1769,6 +1962,9 @@ export const proxyGuardCommand = {
                     return;
                 }
                 logger.always(`[guard] traffic quiet, installing @juspay/neurolink@${result.latestVersion} via ${pnpmResolution.bin} (pnpm v${pnpmResolution.version})...`);
+                if (guardStopping || getProcessStatus(parentPid) === "not_running") {
+                    return;
+                }
                 const { execFileSync } = await import("node:child_process");
                 try {
                     execFileSync(pnpmResolution.bin, ["add", "-g", `@juspay/neurolink@${result.latestVersion}`], {
@@ -1831,6 +2027,9 @@ export const proxyGuardCommand = {
                     logger.always(`[guard] WARNING: failed to rewrite plist (restart may use stale path): ${plistErr instanceof Error ? plistErr.message : String(plistErr)}`);
                     // Continue with restart anyway — the stable bin symlink may still be correct
                 }
+                if (guardStopping || getProcessStatus(parentPid) === "not_running") {
+                    return;
+                }
                 // Signal the health loop to not exit when it detects
                 // the parent PID is gone — we're intentionally restarting.
                 updateRestartInProgress = true;
@@ -1838,7 +2037,7 @@ export const proxyGuardCommand = {
                 const uid = process.getuid?.() ?? 501;
                 try {
                     // bootout unloads the in-memory job definition. This is required
-                    // because `kickstart -k` reuses the cached plist and ignores any
+                    // because a forced kickstart reuses the cached plist and ignores any
                     // on-disk changes (like the trampoline rewrite above).
                     try {
                         execFileSync("launchctl", ["bootout", `gui/${uid}/${PLIST_LABEL}`], { timeout: 10_000, stdio: "pipe" });
@@ -1904,8 +2103,8 @@ export const proxyGuardCommand = {
         };
         // Run first check after a short delay, then on interval
         if (canAutoUpdate) {
-            setTimeout(runUpdateCheck, 30_000);
-            setInterval(runUpdateCheck, UPDATE_CHECK_INTERVAL_MS);
+            updateCheckTimeout = setTimeout(runUpdateCheck, 30_000);
+            updateCheckInterval = setInterval(runUpdateCheck, UPDATE_CHECK_INTERVAL_MS);
         }
         const startedAt = Date.now();
         let parentStatus = getProcessStatus(parentPid);
@@ -1923,31 +2122,32 @@ export const proxyGuardCommand = {
                 // Parent is gone (and we're not mid-update-restart).
                 // If endpoint is still healthy, another proxy took over.
                 if (healthy) {
+                    stopUpdateChecks();
                     return;
                 }
                 break;
             }
             if (!healthy && consecutiveUnhealthy >= failureThreshold) {
-                // Parent still exists but endpoint is repeatedly unhealthy.
-                break;
+                // A detached guard cannot safely decide that a live process should be
+                // replaced. Leave recovery to the foreground operator or launchd.
+                if (!argv.quiet) {
+                    logger.always(`[proxy] fail-open guard observed an unhealthy live parent; leaving process supervision unchanged`);
+                }
+                stopUpdateChecks();
+                return;
             }
             if (maxWaitMs > 0 && Date.now() - startedAt >= maxWaitMs) {
+                stopUpdateChecks();
                 return;
             }
             await sleep(pollIntervalMs);
             parentStatus = getProcessStatus(parentPid);
         }
+        stopUpdateChecks();
         const guardHost = host === "0.0.0.0" ? "localhost" : host;
         const expectedBaseUrl = `http://${guardHost}:${port}`;
-        // Attempt restart via launchd before falling back to cleanup
-        const restarted = await tryLaunchdRestart(guardHost, port);
-        if (restarted) {
-            if (!argv.quiet) {
-                logger.always(`[proxy] fail-open guard restarted proxy via launchd`);
-            }
-            return;
-        }
-        // Restart failed or launchd not installed — clean up Claude settings
+        // The parent is confirmed gone and no replacement is healthy. Foreground
+        // guards are cleanup-only; they never restart or signal proxy processes.
         const cleared = await clearClaudeProxySettings(expectedBaseUrl);
         try {
             await clearOpenCodeProxySettings(`${expectedBaseUrl}/v1`);
@@ -2215,6 +2415,9 @@ ${configArgs}
   <key>ThrottleInterval</key>
   <integer>5</integer>
 
+  <key>ExitTimeOut</key>
+  <integer>45</integer>
+
   <key>StandardOutPath</key>
   <string>${join(homedir(), ".neurolink", "logs", "proxy-launchd-stdout.log")}</string>