zevairouter 1.0.152 → 1.0.154

package/src/lib/safeFetch.js

@@ -24,7 +24,10 @@ export function isPrivateAddress(address) {
 
 export async function readJsonResponse(response, maxBytes) {
   const declaredLength = Number(response.headers.get("content-length"));
-  if (declaredLength > maxBytes) throw new Error("Response body is too large");
+  if (declaredLength > maxBytes) {
+    await response.body?.cancel?.();
+    throw new Error("Response body is too large");
+  }
 
   const chunks = [];
   let size = 0;
@@ -36,6 +39,95 @@ export async function readJsonResponse(response, maxBytes) {
   return JSON.parse(Buffer.concat(chunks).toString("utf8"));
 }
 
+function abortError(signal) {
+  if (signal?.reason) return signal.reason;
+  return Object.assign(new Error("The operation was aborted"), { name: "AbortError" });
+}
+
+async function lookupWithSignal(hostname, signal) {
+  if (!signal) return dns.lookup(hostname, { all: true });
+  if (signal.aborted) throw abortError(signal);
+
+  const lookup = dns.lookup(hostname, { all: true });
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, addresses) => {
+      if (settled) return;
+      settled = true;
+      signal.removeEventListener("abort", onAbort);
+      if (error) reject(error);
+      else resolve(addresses);
+    };
+    const onAbort = () => finish(abortError(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    lookup.then(
+      (addresses) => finish(null, addresses),
+      (error) => finish(error),
+    );
+  });
+}
+
+function wrapResponseBody(response, dispatcher, signal) {
+  if (!response.body?.getReader) return null;
+
+  const reader = response.body.getReader();
+  let closePromise = null;
+  let released = false;
+  const releaseReader = () => {
+    if (released) return;
+    released = true;
+    reader.releaseLock();
+  };
+  const closeDispatcher = () => {
+    signal?.removeEventListener("abort", onAbort);
+    closePromise ||= Promise.resolve(dispatcher.close()).catch(() => {});
+    return closePromise;
+  };
+  const onAbort = () => {
+    void closeDispatcher();
+  };
+
+  if (signal?.aborted) onAbort();
+  else signal?.addEventListener("abort", onAbort, { once: true });
+
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const { done, value } = await reader.read();
+        if (!done) {
+          controller.enqueue(value);
+          return;
+        }
+        releaseReader();
+        await closeDispatcher();
+        controller.close();
+      } catch (error) {
+        releaseReader();
+        await closeDispatcher();
+        controller.error(error);
+      }
+    },
+    async cancel(reason) {
+      try {
+        await reader.cancel(reason);
+      } finally {
+        releaseReader();
+        await closeDispatcher();
+      }
+    },
+  });
+
+  const wrapped = new Response(body, {
+    headers: response.headers,
+    status: response.status,
+    statusText: response.statusText,
+  });
+  for (const key of ["url", "redirected", "type"]) {
+    Object.defineProperty(wrapped, key, { configurable: true, value: response[key] });
+  }
+  return wrapped;
+}
+
 export async function safeFetch(rawUrl, options = {}, { expectedOrigin, httpsOnly = false } = {}) {
   const url = new URL(rawUrl);
   const allowedProtocols = httpsOnly ? ["https:"] : ["http:", "https:"];
@@ -44,7 +136,7 @@ export async function safeFetch(rawUrl, options = {}, { expectedOrigin, httpsOnl
     throw new Error("URL is not an allowed public HTTP endpoint");
   }
 
-  const addresses = await dns.lookup(url.hostname, { all: true });
+  const addresses = await lookupWithSignal(url.hostname, options.signal);
   if (!addresses.length || addresses.some(({ address }) => isPrivateAddress(address))) {
     throw new Error("URL must resolve only to public addresses");
   }
@@ -63,8 +155,13 @@ export async function safeFetch(rawUrl, options = {}, { expectedOrigin, httpsOnl
   });
 
   try {
-    return await undiciFetch(url, { ...options, redirect: "error", dispatcher });
-  } finally {
+    const response = await undiciFetch(url, { ...options, redirect: "error", dispatcher });
+    const wrapped = wrapResponseBody(response, dispatcher, options.signal);
+    if (wrapped) return wrapped;
+    await dispatcher.close();
+    return response;
+  } catch (error) {
     await dispatcher.close();
+    throw error;
   }
 }

package/src/lib/usage/quotaRefresh.js

@@ -2,26 +2,58 @@
 //
 // Periodically snapshots each active, usage-eligible connection's upstream quota
 // into the server-side quota cache (quotaCache table) so request routing can read
-// remaining quota synchronously. Requests are staggered to avoid a burst of
-// upstream calls. Guarded via globalThis so Next.js hot-reload / multiple imports
-// don't start duplicate loops.
+// remaining quota synchronously. Refreshes use bounded concurrency so large
+// pools finish promptly without an unbounded upstream burst. Guarded via
+// globalThis so Next.js hot-reload / multiple imports don't start duplicate loops.
 
 import { getProviderConnections } from "@/lib/localDb";
 import { resolveUsageForConnection, isUsageEligible } from "./quotaService.js";
 
 const REFRESH_INTERVAL_MS = 5 * 60 * 1000; // full sweep cadence per connection
-const STAGGER_MS = 4 * 1000;               // gap between connections in a sweep
 const MIN_START_DELAY_MS = 15 * 1000;      // let the server settle before first sweep
+const MAX_CONCURRENT_REFRESHES = 12;
 
 if (!globalThis._quotaRefreshState) {
-  globalThis._quotaRefreshState = { started: false, startTimer: null, timer: null, running: false };
+  globalThis._quotaRefreshState = {
+    started: false,
+    startTimer: null,
+    timer: null,
+    running: false,
+    runningPromise: null,
+  };
 }
 const state = globalThis._quotaRefreshState;
+state.runningPromise ??= null;
+
+export async function refreshQuotaConnections(connections, options = {}) {
+  const {
+    force = false,
+    concurrency = MAX_CONCURRENT_REFRESHES,
+    resolveUsage = resolveUsageForConnection,
+  } = options;
+  const eligible = connections.filter(isUsageEligible);
+  const workerCount = Math.min(Math.max(1, concurrency), eligible.length);
+  let nextIndex = 0;
+
+  const workers = Array.from({ length: workerCount }, async () => {
+    while (nextIndex < eligible.length) {
+      const conn = eligible[nextIndex++];
+      try {
+        await resolveUsage(conn.id, { writeCache: true, force });
+      } catch (e) {
+        console.warn(`[QuotaRefresh] ${conn.provider}/${conn.id}: ${e.message}`);
+      }
+    }
+  });
+  await Promise.all(workers);
+  return eligible.length;
+}
+
+export function sweepOnce() {
+  if (state.runningPromise) return state.runningPromise;
 
-async function sweepOnce() {
-  if (state.running) return;
   state.running = true;
-  try {
+  const runningPromise = (async () => {
     let connections = [];
     try {
       connections = await getProviderConnections({ isActive: true });
@@ -29,19 +61,15 @@ async function sweepOnce() {
       console.warn(`[QuotaRefresh] failed to list connections: ${e.message}`);
       return;
     }
-    const eligible = connections.filter(isUsageEligible);
-    for (const conn of eligible) {
-      try {
-        await resolveUsageForConnection(conn.id, { writeCache: true });
-      } catch (e) {
-        console.warn(`[QuotaRefresh] ${conn.provider}/${conn.id}: ${e.message}`);
-      }
-      // Stagger to avoid hammering upstreams all at once.
-      await new Promise((r) => setTimeout(r, STAGGER_MS));
+    await refreshQuotaConnections(connections);
+  })().finally(() => {
+    if (state.runningPromise === runningPromise) {
+      state.runningPromise = null;
+      state.running = false;
     }
-  } finally {
-    state.running = false;
-  }
+  });
+  state.runningPromise = runningPromise;
+  return runningPromise;
 }
 
 /** Start the background loop once per process. Safe to call repeatedly. */
@@ -63,9 +91,10 @@ export function stopQuotaRefreshLoop() {
   state.startTimer = null;
   state.timer = null;
   state.started = false;
+  return state.runningPromise || Promise.resolve();
 }
 
-/** Trigger an immediate one-off sweep (fire-and-forget). */
+/** Trigger an immediate one-off sweep. */
 export function refreshQuotaNow() {
-  void sweepOnce();
+  return sweepOnce();
 }

package/src/lib/usage/quotaService.js

@@ -11,6 +11,8 @@ import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
 import { USAGE_APIKEY_PROVIDERS } from "@/shared/constants/providers";
 
 const AUTH_EXPIRED_PATTERNS = ["expired", "authentication", "unauthorized", "401", "re-authorize"];
+const usageInflight = globalThis._quotaUsageInflight ??= new Map();
+
 function isAuthExpiredMessage(usage) {
   if (!usage?.message) return false;
   const msg = usage.message.toLowerCase();
@@ -102,7 +104,7 @@ function isUsageEligible(connection) {
  * @param {string} connectionId
  * @param {object} opts { writeCache?: boolean, force?: boolean }
  */
-export async function resolveUsageForConnection(connectionId, opts = {}) {
+async function resolveUsage(connectionId, opts, inflightEntry) {
   const { writeCache = false, force = false } = opts;
   const connection = await getProviderConnectionById(connectionId);
   if (!connection) return { error: "Connection not found", notFound: true };
@@ -140,7 +142,8 @@ export async function resolveUsageForConnection(connectionId, opts = {}) {
     }
   }
 
-  if (writeCache && usage && !usage.error) {
+  // A concurrent cache-writing caller may have joined after this request began.
+  if ((writeCache || inflightEntry.writeCache) && usage && !usage.error) {
     try {
       await saveQuotaSnapshot(conn.id, conn.provider, usage);
     } catch (e) {
@@ -151,4 +154,53 @@ export async function resolveUsageForConnection(connectionId, opts = {}) {
   return usage;
 }
 
+export async function resolveUsageForConnection(connectionId, opts = {}) {
+  let state = usageInflight.get(connectionId);
+  if (!state) {
+    state = { active: null, queuedForce: null };
+    usageInflight.set(connectionId, state);
+  }
+
+  // Once a forced refresh is queued/running, non-forced readers should share
+  // that fresher result. Forced callers must never collapse into an older
+  // non-forced request, though, because force also refreshes credentials.
+  if (state.queuedForce) {
+    if (opts.writeCache) state.queuedForce.writeCache = true;
+    return state.queuedForce.promise;
+  }
+  if (state.active && (!opts.force || state.active.force)) {
+    if (opts.writeCache) state.active.writeCache = true;
+    return state.active.promise;
+  }
+
+  const cleanup = (entry) => {
+    if (state.active === entry) state.active = null;
+    if (!state.active && !state.queuedForce && usageInflight.get(connectionId) === state) {
+      usageInflight.delete(connectionId);
+    }
+  };
+
+  if (state.active) {
+    const prior = state.active.promise;
+    const entry = { force: true, writeCache: opts.writeCache === true, promise: null };
+    const launch = () => {
+      if (state.queuedForce === entry) state.queuedForce = null;
+      state.active = entry;
+      return resolveUsage(connectionId, { ...opts, force: true }, entry);
+    };
+    entry.promise = prior.then(launch, launch).finally(() => cleanup(entry));
+    state.queuedForce = entry;
+    return entry.promise;
+  }
+
+  const entry = {
+    force: opts.force === true,
+    writeCache: opts.writeCache === true,
+    promise: null,
+  };
+  state.active = entry;
+  entry.promise = resolveUsage(connectionId, opts, entry).finally(() => cleanup(entry));
+  return entry.promise;
+}
+
 export { isUsageEligible };

package/src/shared/components/BulkAccountAutomationModal.js

@@ -8,6 +8,7 @@ import Button from "./Button";
 import Input from "./Input";
 import Modal from "./Modal";
 import Select from "./Select";
+import { startAsyncPolling } from "@/shared/utils/asyncPolling";
 
 const DEFAULT_CONCURRENCY = 4;
 const ACTIVE_JOB_STATUSES = new Set(["queued", "running", "needs_manual"]);
@@ -209,25 +210,20 @@ export default function BulkAccountAutomationModal({
   useEffect(() => {
     if (!isOpen || !activeJob?.jobId || finishedJob) return undefined;
 
-    const interval = window.setInterval(async () => {
-      try {
-        const { res, data } = await fetchJob(provider, activeJob.jobId);
-        if (res.ok && data?.job) {
-          setActiveJob(data.job);
-          if (typeof window !== "undefined") {
-            window.localStorage.setItem(storageKey, data.job.jobId);
-          }
-          if (TERMINAL_JOB_STATUSES.has(data.job.status) && !completedRefreshJobsRef.current.has(data.job.jobId)) {
-            completedRefreshJobsRef.current.add(data.job.jobId);
-            onSuccess?.();
-          }
+    return startAsyncPolling(async (isCancelled) => {
+      const { res, data } = await fetchJob(provider, activeJob.jobId);
+      if (isCancelled()) return;
+      if (res.ok && data?.job) {
+        setActiveJob(data.job);
+        if (typeof window !== "undefined") {
+          window.localStorage.setItem(storageKey, data.job.jobId);
+        }
+        if (TERMINAL_JOB_STATUSES.has(data.job.status) && !completedRefreshJobsRef.current.has(data.job.jobId)) {
+          completedRefreshJobsRef.current.add(data.job.jobId);
+          onSuccess?.();
         }
-      } catch {
-        // Keep the current snapshot visible; the next interval can recover.
       }
     }, 2000);
-
-    return () => window.clearInterval(interval);
   }, [activeJob?.jobId, finishedJob, isOpen, onSuccess, provider, storageKey]);
 
   const handleStartBulk = async () => {

package/src/shared/components/CodeBuddyCnPhoneRegisterModal.js

@@ -4,6 +4,7 @@ import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import PropTypes from "prop-types";
 import Badge from "./Badge";
 import Button from "./Button";
+import { startAsyncPolling } from "@/shared/utils/asyncPolling";
 
 const PROVIDER = "codebuddy-cn";
 const POLL_INTERVAL_MS = 2000;
@@ -62,6 +63,7 @@ export default function CodeBuddyCnPhoneRegisterModal({ isOpen, onClose, onSucce
   const [jobRestoreNotice, setJobRestoreNotice] = useState(null);
 
   const runningJob = activeJob && ACTIVE_JOB_STATUSES.has(activeJob.status);
+  const activeJobId = activeJob?.jobId;
 
   // Fetch proxy pools on open
   useEffect(() => {
@@ -112,24 +114,20 @@ export default function CodeBuddyCnPhoneRegisterModal({ isOpen, onClose, onSucce
 
   // Poll active job
   useEffect(() => {
-    if (!activeJob || !runningJob) return;
-    const jobId = activeJob.jobId;
-    const interval = setInterval(async () => {
-      try {
-        const { res, data } = await fetchJob(jobId);
-        if (res.ok && data?.job) {
-          setActiveJob(data.job);
-          if (TERMINAL_JOB_STATUSES.has(data.job.status) && !completedRefreshJobsRef.current.has(data.job.jobId)) {
-            completedRefreshJobsRef.current.add(data.job.jobId);
-            onSuccess?.();
-          }
+    if (!activeJobId || !runningJob) return;
+    const jobId = activeJobId;
+    return startAsyncPolling(async (isCancelled) => {
+      const { res, data } = await fetchJob(jobId);
+      if (isCancelled()) return;
+      if (res.ok && data?.job) {
+        setActiveJob(data.job);
+        if (TERMINAL_JOB_STATUSES.has(data.job.status) && !completedRefreshJobsRef.current.has(data.job.jobId)) {
+          completedRefreshJobsRef.current.add(data.job.jobId);
+          onSuccess?.();
         }
-      } catch {
-        // ignore poll errors
       }
     }, POLL_INTERVAL_MS);
-    return () => clearInterval(interval);
-  }, [activeJob, runningJob, fetchJob, onSuccess]);
+  }, [activeJobId, runningJob, fetchJob, onSuccess]);
 
   // Restore active job on mount
   useEffect(() => {

package/src/shared/components/KiroAuthModal.js

@@ -4,6 +4,7 @@ import { useEffect, useMemo, useRef, useState } from "react";
 import Image from "next/image";
 import PropTypes from "prop-types";
 import { Modal, Button, Input } from "@/shared/components";
+import { startAsyncPolling } from "@/shared/utils/asyncPolling";
 
 const DEFAULT_CONCURRENCY = 4;
 const BULK_JOB_STORAGE_KEY = "kiro-bulk-import-active-job";
@@ -254,39 +255,35 @@ export default function KiroAuthModal({
   useEffect(() => {
     if (!isOpen || !activeJob?.jobId || isJobTerminal(activeJob.status)) return undefined;
 
-    const interval = window.setInterval(async () => {
-      try {
-        const current = await fetchBulkJobById(activeJob.jobId);
-        if (current.res.ok && current.data?.job) {
+    return startAsyncPolling(async (isCancelled) => {
+      const current = await fetchBulkJobById(activeJob.jobId);
+      if (isCancelled()) return;
+      if (current.res.ok && current.data?.job) {
+        setJobRestoreNotice(null);
+        setActiveJob(current.data.job);
+        return;
+      }
+
+      if (current.res.status === 404) {
+        const latest = await fetchLatestBulkJob();
+        if (isCancelled()) return;
+        if (latest.res.ok && latest.data?.job) {
           setJobRestoreNotice(null);
-          setActiveJob(current.data.job);
+          setActiveJob(latest.data.job);
+          if (typeof window !== "undefined") {
+            window.localStorage.setItem(BULK_JOB_STORAGE_KEY, latest.data.job.jobId);
+          }
           return;
         }
 
-        if (current.res.status === 404) {
-          const latest = await fetchLatestBulkJob();
-          if (latest.res.ok && latest.data?.job) {
-            setJobRestoreNotice(null);
-            setActiveJob(latest.data.job);
-            if (typeof window !== "undefined") {
-              window.localStorage.setItem(BULK_JOB_STORAGE_KEY, latest.data.job.jobId);
-            }
-            return;
-          }
-
-          if (typeof window !== "undefined") {
-            window.localStorage.removeItem(BULK_JOB_STORAGE_KEY);
-          }
-          onBulkJobChange?.(null);
-          setActiveJob(null);
-          setJobRestoreNotice("Bulk import progress expired or was cleared.");
+        if (typeof window !== "undefined") {
+          window.localStorage.removeItem(BULK_JOB_STORAGE_KEY);
         }
-      } catch {
-        // Keep last-known UI state and let user retry/cancel manually.
+        onBulkJobChange?.(null);
+        setActiveJob(null);
+        setJobRestoreNotice("Bulk import progress expired or was cleared.");
       }
     }, 1500);
-
-    return () => window.clearInterval(interval);
   }, [activeJob?.jobId, activeJob?.status, isOpen, onBulkJobChange]);
 
   useEffect(() => {

package/src/shared/components/Modal.js

@@ -23,7 +23,6 @@ export default function Modal({
   // pass inline handlers (common). Otherwise each parent re-render (e.g. typing
   // into a controlled input) re-focuses the first button and steals the caret.
   const onCloseRef = useRef(onClose);
-  onCloseRef.current = onClose;
   const sizes = {
     sm: "max-w-sm",
     md: "max-w-md",
@@ -37,6 +36,10 @@ export default function Modal({
   const FIELD_SELECTOR =
     'input:not([disabled]):not([type="hidden"]):not([type="button"]):not([type="submit"]):not([type="checkbox"]):not([type="radio"]), textarea:not([disabled]), select:not([disabled])';
 
+  useEffect(() => {
+    onCloseRef.current = onClose;
+  }, [onClose]);
+
   useEffect(() => {
     if (!isOpen) return;
 

package/src/shared/components/UsageStats.js

@@ -16,6 +16,7 @@ import OverviewCards from "@/app/(dashboard)/dashboard/usage/components/Overview
 import UsageTable, { fmt, fmtTime } from "@/app/(dashboard)/dashboard/usage/components/UsageTable";
 import ProviderTopology from "@/app/(dashboard)/dashboard/usage/components/ProviderTopology";
 import UsageChart from "@/app/(dashboard)/dashboard/usage/components/UsageChart";
+import { getAccountPendingCount } from "@/shared/utils/usageStats";
 
 function timeAgo(timestamp) {
   const diff = Math.max(0, Math.floor((Date.now() - new Date(timestamp)) / 1000));
@@ -94,7 +95,7 @@ function RecentRequests({ requests = [], streamStatus = "connecting" }) {
       {!requests.length ? (
         <div className="flex-1 flex items-center justify-center text-text-muted text-sm">No requests yet.</div>
       ) : (
-        <div className="flex-1 overflow-y-auto px-4 pb-3">
+        <div className="flex-1 overflow-x-auto overflow-y-auto px-4 pb-3">
           <table className="w-full min-w-[300px] border-collapse text-xs">
             <thead className="sticky top-0 z-10 bg-surface/95 backdrop-blur-sm">
               <tr className="border-b border-border">
@@ -214,9 +215,9 @@ const MODEL_COLUMNS = [
 ];
 
 const ACCOUNT_COLUMNS = [
+  { field: "accountName", label: "Account" },
   { field: "rawModel", label: "Model" },
   { field: "provider", label: "Provider" },
-  { field: "accountName", label: "Account" },
   { field: "requests", label: "Requests", align: "right" },
   { field: "lastUsed", label: "Last Used", align: "right" },
 ];
@@ -389,11 +390,7 @@ export default function UsageStats({ period: periodProp, setPeriod: setPeriodPro
         const pendingMap = {};
         if (stats?.pending?.byAccount) {
           Object.entries(stats.byAccount || {}).forEach(([accountKey, data]) => {
-            const connPending = stats.pending.byAccount[data.connectionId];
-            if (connPending) {
-              const modelKey = data.provider ? `${data.rawModel} (${data.provider})` : data.rawModel;
-              pendingMap[accountKey] = connPending[modelKey] || 0;
-            }
+            pendingMap[accountKey] = getAccountPendingCount(data, stats.pending.byAccount);
           });
         }
         return {

package/src/shared/hooks/useModelLockUntil.js

@@ -0,0 +1,18 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { scheduleModelLockRefresh } from "@/shared/utils/modelLockTimer";
+
+export function useModelLockUntil(connection = {}) {
+  const [modelLockUntil, setModelLockUntil] = useState(null);
+  const modelLockSignature = JSON.stringify(Object.entries(connection)
+    .filter(([key]) => key.startsWith("modelLock_"))
+    .sort(([left], [right]) => left.localeCompare(right)));
+
+  useEffect(() => {
+    const modelLocks = Object.fromEntries(JSON.parse(modelLockSignature));
+    return scheduleModelLockRefresh(modelLocks, setModelLockUntil);
+  }, [modelLockSignature]);
+
+  return modelLockUntil;
+}

package/src/shared/services/initializeApp.js

@@ -16,8 +16,9 @@ import {
 import { getMitmStatus, startMitm, loadEncryptedPassword, initDbHooks, restoreToolDNS, removeAllDNSEntriesSync } from "@/mitm/manager";
 import { syncToJson as syncMitmAliasCache } from "@/lib/mitmAliasCache";
 import { flushRequestDetails } from "@/lib/db/repos/requestDetailsRepo";
+import { flushRequestUsageWrites } from "@/lib/db/repos/usageRepo";
 import { closeAdapter } from "@/lib/db/driver";
-import { stopQuotaRefreshLoop } from "@/lib/usage/quotaRefresh";
+import { startQuotaRefreshLoop, stopQuotaRefreshLoop } from "@/lib/usage/quotaRefresh";
 
 // Inject correct paths and DB hooks into manager.js (CJS) from ESM context
 (function bootstrapMitm() {
@@ -45,10 +46,15 @@ const g = global.__appSingleton ??= {
   mitmStartInProgress: false,
   tunnelAutoResumed: false,
   tailscaleAutoResumed: false,
+  shuttingDown: false,
 };
+g.shuttingDown ??= false;
 
 export async function initializeApp() {
   try {
+    // Routing relies on fresh server-side quota snapshots even when no dashboard
+    // client ever calls the legacy /api/init endpoint.
+    startQuotaRefreshLoop();
     await cleanupProviderConnections();
     const settings = await getSettings();
 
@@ -71,7 +77,13 @@ export async function initializeApp() {
       const cleanup = async () => {
         if (shuttingDown) return;
         shuttingDown = true;
-        stopQuotaRefreshLoop();
+        g.shuttingDown = true;
+        if (g.watchdogInterval) clearInterval(g.watchdogInterval);
+        if (g.networkMonitorInterval) clearInterval(g.networkMonitorInterval);
+        g.watchdogInterval = null;
+        g.networkMonitorInterval = null;
+        try { await stopQuotaRefreshLoop(); } catch (e) { console.error("[InitApp] quota refresh stop failed:", e); }
+        try { await flushRequestUsageWrites(); } catch (e) { console.error("[InitApp] usage flush failed:", e); }
         try { await flushRequestDetails(); } catch (e) { console.error("[InitApp] request detail flush failed:", e); }
         try { await closeAdapter(); } catch (e) { console.error("[InitApp] database close failed:", e); }
         try { removeAllDNSEntriesSync(); } catch { /* best effort */ }
@@ -103,7 +115,7 @@ export async function initializeApp() {
 }
 
 async function autoStartMitm() {
-  if (g.mitmStartInProgress) return;
+  if (g.mitmStartInProgress || g.shuttingDown) return;
   g.mitmStartInProgress = true;
   try {
     const settings = await getSettings();
@@ -120,6 +132,7 @@ async function autoStartMitm() {
     const keys = await getApiKeys(true);
     const activeKey = keys.find(k => k.isActive !== false);
 
+    if (g.shuttingDown) return;
     console.log("[InitApp] MITM was enabled, auto-starting...");
     await startMitm(activeKey?.key || "sk_zevai", password);
     console.log("[InitApp] MITM auto-started");
@@ -143,6 +156,7 @@ const FORCE_RESTART_REASONS = /^(startup|netchange|sleep|sleep\+netchange|online
 // ─── Safe restart (4 guards: spawn / cooldown / alive / internet) ────────────
 
 async function safeRestartTunnel(reason) {
+  if (g.shuttingDown) return;
   const svc = getTunnelService();
   const settings = await getSettings();
   if (!settings.tunnelEnabled) return;
@@ -174,6 +188,7 @@ async function safeRestartTunnel(reason) {
 }
 
 async function safeRestartTailscale(reason) {
+  if (g.shuttingDown) return;
   const svc = getTailscaleService();
   const settings = await getSettings();
   if (!settings.tailscaleEnabled) return;
@@ -207,6 +222,7 @@ async function safeRestartTailscale(reason) {
 function startWatchdog() {
   if (g.watchdogInterval) return;
   g.watchdogInterval = setInterval(() => {
+    if (g.shuttingDown) return;
     safeRestartTunnel("watchdog").catch(() => {});
     safeRestartTailscale("watchdog").catch(() => {});
   }, WATCHDOG_INTERVAL_MS);
@@ -238,6 +254,7 @@ function startNetworkMonitor() {
   g.lastOnline = null;
 
   g.networkMonitorInterval = setInterval(async () => {
+    if (g.shuttingDown) return;
     try {
       const now = Date.now();
       const elapsed = now - g.lastWatchdogTick;