@techysy/10router 1.5.1 → 1.6.0

package/app/src/shared/services/quotaAutoPing.js

@@ -1,313 +1,345 @@
-// Quota auto-ping scheduler: warms 5h windows by sending tiny opt-in requests right after reset.
-import "open-sse/index.js";
-
-import { getSettings, getProviderConnections, updateProviderConnection } from "@/lib/localDb";
-import { getClaudeUsage } from "open-sse/services/usage/claude.js";
-import { getCodexUsage } from "open-sse/services/usage/codex.js";
-import { getExecutor } from "open-sse/executors/index.js";
-import { CLAUDE_CLI_SPOOF_HEADERS } from "open-sse/providers/shared.js";
-import { proxyAwareFetch } from "open-sse/utils/proxyFetch.js";
-import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
-import { refreshAndUpdateCredentials } from "@/app/api/usage/[connectionId]/route.js";
-import { QUOTA_AUTOPING_CONFIG } from "@/shared/constants/config";
-
-const C = QUOTA_AUTOPING_CONFIG;
-const CLAUDE_PING_URL = "https://api.anthropic.com/v1/messages?beta=true";
-
-const providerHandlers = {
-  claude: {
-    getUsage: getClaudeUsage,
-    sendPing: sendClaudePing,
-  },
-  codex: {
-    getUsage: getCodexUsage,
-    sendPing: sendCodexPing,
-  },
-};
-
-// Survive Next.js hot reload and keep one scheduler per server process.
-const g = (global.__quotaAutoPing ??= {
-  interval: null,
-  running: false,
-  resetCache: {},
-  failureCache: {},
-});
-
-function cacheKey(provider, connectionId) {
-  return `${provider}:${connectionId}`;
-}
-
-function normalizeResetKey(resetAt) {
-  const ms = new Date(resetAt).getTime();
-  if (!Number.isFinite(ms)) return resetAt;
-  return new Date(Math.floor(ms / 60000) * 60000).toISOString();
-}
-
-function getResetDriftMs(previousResetAt, nextResetAt) {
-  const previousMs = new Date(previousResetAt).getTime();
-  const nextMs = new Date(nextResetAt).getTime();
-  if (!Number.isFinite(previousMs) || !Number.isFinite(nextMs)) return 0;
-  return nextMs - previousMs;
-}
-
-function toFiniteNumber(value, fallback = null) {
-  if (typeof value === "number" && Number.isFinite(value)) return value;
-  if (typeof value === "string" && value.trim()) {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed)) return parsed;
-  }
-  return fallback;
-}
-
-function isQuotaExhausted(quota) {
-  if (!quota || quota.unlimited === true) return false;
-  const remaining = toFiniteNumber(quota.remaining);
-  if (remaining !== null) return remaining <= 0;
-
-  const used = toFiniteNumber(quota.used);
-  const total = toFiniteNumber(quota.total);
-  return total !== null && total > 0 && used !== null && used >= total;
-}
-
-function wasPingedRecently(connection, intervalMs, nowMs = Date.now()) {
-  if (!intervalMs) return false;
-  const lastPingAtMs = new Date(connection.lastPingAt).getTime();
-  return Number.isFinite(lastPingAtMs) && nowMs - lastPingAtMs < intervalMs;
-}
-
-function isBlockingQuotaName(name, sessionKey) {
-  if (name === sessionKey) return false;
-  return !String(name).toLowerCase().includes("session");
-}
-
-function hasExhaustedBlockingQuota(quotas, sessionKey) {
-  return Object.entries(quotas || {}).some(([name, quota]) => isBlockingQuotaName(name, sessionKey) && isQuotaExhausted(quota));
-}
-
-function shouldPingForReset(providerConfig, cachedReset, resetAt, now) {
-  if (providerConfig.pingWhenResetAtSlides) {
-    return Boolean(cachedReset) && getResetDriftMs(cachedReset, resetAt) >= (providerConfig.resetAtDriftMs || 0);
-  }
-
-  const resetMs = new Date(resetAt).getTime();
-  return Number.isFinite(resetMs) && now >= resetMs - C.pingLeadMs;
-}
-
-function buildProxyOptions(cfg) {
-  return {
-    connectionProxyEnabled: cfg.connectionProxyEnabled === true,
-    connectionProxyUrl: cfg.connectionProxyUrl || "",
-    connectionNoProxy: cfg.connectionNoProxy || "",
-    vercelRelayUrl: cfg.vercelRelayUrl || "",
-    strictProxy: false,
-  };
-}
-
-async function sendClaudePing(connection, providerConfig, proxyOptions, deps) {
-  const res = await deps.proxyAwareFetch(CLAUDE_PING_URL, {
-    method: "POST",
-    headers: {
-      ...CLAUDE_CLI_SPOOF_HEADERS,
-      "Authorization": `Bearer ${connection.accessToken}`,
-      "content-type": "application/json",
-    },
-    body: JSON.stringify({
-      model: providerConfig.pingModel,
-      max_tokens: providerConfig.pingMaxTokens,
-      messages: [{ role: "user", content: providerConfig.pingText }],
-    }),
-  }, proxyOptions);
-  return res.ok;
-}
-
-function buildCodexPingInput(text) {
-  return [{
-    type: "message",
-    role: "user",
-    content: [{ type: "input_text", text }],
-  }];
-}
-
-async function drainResponseBody(response) {
-  if (typeof response?.text === "function") {
-    await response.text();
-    return;
-  }
-
-  const reader = response?.body?.getReader?.();
-  if (!reader) return;
-
-  try {
-    while (true) {
-      const { done } = await reader.read();
-      if (done) return;
-    }
-  } finally {
-    reader.releaseLock?.();
-  }
-}
-
-async function sendCodexPing(connection, providerConfig, proxyOptions, deps) {
-  const executor = deps.getExecutor("codex");
-  const { response } = await executor.execute({
-    model: providerConfig.pingModel,
-    stream: true,
-    credentials: {
-      accessToken: connection.accessToken,
-      connectionId: connection.id,
-      providerSpecificData: connection.providerSpecificData,
-    },
-    proxyOptions,
-    log: console,
-    body: {
-      model: providerConfig.pingModel,
-      input: buildCodexPingInput(providerConfig.pingText),
-      instructions: providerConfig.pingInstructions,
-      reasoning: providerConfig.pingReasoningEffort
-        ? { effort: providerConfig.pingReasoningEffort, summary: "auto" }
-        : undefined,
-      store: false,
-      stream: true,
-    },
-  });
-  if (!response.ok) {
-    try { await response.body?.cancel?.(); } catch { /* noop */ }
-    return false;
-  }
-
-  // Codex only starts the 5h window after the streaming response completes.
-  await drainResponseBody(response);
-  return true;
-}
-
-function shouldSkipAfterFailure(state, key, nowMs = Date.now()) {
-  const failedAt = state.failureCache[key];
-  return failedAt && nowMs - failedAt < C.failureCooldownMs;
-}
-
-async function pingConnection(conn, provider, providerConfig, handler, deps, state = g) {
-  const key = cacheKey(provider, conn.id);
-
-  // resetAt is stable for time-based windows; Codex polls every tick because inactive windows slide forward.
-  const cachedReset = state.resetCache[key];
-  if (!providerConfig.pingWhenResetAtSlides && cachedReset && Date.now() < new Date(cachedReset).getTime() - C.refreshAheadMs) return;
-
-  // Avoid hammering provider auth/quota endpoints if a ping failed recently.
-  if (shouldSkipAfterFailure(state, key)) return;
-
-  const proxyCfg = await deps.resolveConnectionProxyConfig(conn.providerSpecificData);
-  const proxyOptions = buildProxyOptions(proxyCfg);
-
-  let connection = conn;
-  try {
-    const r = await deps.refreshAndUpdateCredentials(connection, false, proxyOptions);
-    connection = r.connection;
-  } catch (e) {
-    state.failureCache[key] = Date.now();
-    console.warn(`[AutoPing] ${provider}:${conn.id}: refresh failed: ${e.message}`);
-    return;
-  }
-
-  const usage = await handler.getUsage(connection.accessToken, proxyOptions);
-  const quotas = usage?.quotas || {};
-  const quota = quotas?.[providerConfig.quotaKey];
-  const resetAt = quota?.resetAt;
-  if (!resetAt) return;
-
-  state.resetCache[key] = resetAt;
-
-  if (providerConfig.skipWhenBlockingQuotaExhausted && hasExhaustedBlockingQuota(quotas, providerConfig.quotaKey)) return;
-  if (isQuotaExhausted(quota)) return;
-
-  const now = Date.now();
-  const resetKey = normalizeResetKey(resetAt);
-  const lastPingedResetKey = connection.lastPingedResetKey || normalizeResetKey(connection.lastPingedResetAt);
-
-  // Claude waits for reset. Codex pings only when resetAt slides, which means the 5h window is inactive.
-  if (!shouldPingForReset(providerConfig, cachedReset, resetAt, now)) return;
-  if (wasPingedRecently(connection, providerConfig.minPingIntervalMs, now)) return;
-  if (lastPingedResetKey === resetKey) return;
-
-  const ok = await handler.sendPing(connection, providerConfig, proxyOptions, deps);
-  if (!ok) {
-    // Do not mark reset as pinged unless upstream accepted the tiny request.
-    state.failureCache[key] = Date.now();
-    console.warn(`[AutoPing] ${provider}:${connection.id}: ping failed (reset ${resetAt})`);
-    return;
-  }
-
-  delete state.failureCache[key];
-  await deps.updateProviderConnection(connection.id, {
-    lastPingedResetAt: resetAt,
-    lastPingedResetKey: resetKey,
-    lastPingAt: new Date().toISOString(),
-    updatedAt: new Date().toISOString(),
-  });
-  console.log(`[AutoPing] ${provider}:${connection.id}: ping sent (reset ${resetAt})`);
-}
-
-function createDefaultDeps() {
-  return {
-    getSettings,
-    getProviderConnections,
-    updateProviderConnection,
-    resolveConnectionProxyConfig,
-    refreshAndUpdateCredentials,
-    proxyAwareFetch,
-    getExecutor,
-  };
-}
-
-export async function runQuotaAutoPingTick(deps = createDefaultDeps(), state = g) {
-  if (state.running) return;
-  state.running = true;
-  try {
-    const settings = await deps.getSettings();
-
-    for (const [provider, providerConfig] of Object.entries(C.providers)) {
-      const handler = providerHandlers[provider];
-      if (!handler) continue;
-
-      const enabledMap = settings?.[providerConfig.settingsKey]?.connections || {};
-      if (Object.keys(enabledMap).length === 0) continue;
-
-      const conns = await deps.getProviderConnections({ provider, isActive: true });
-      const targets = conns.filter((conn) => conn.authType === "oauth" && enabledMap[conn.id] === true);
-      for (const conn of targets) {
-        try {
-          await pingConnection(conn, provider, providerConfig, handler, deps, state);
-        } catch (e) {
-          state.failureCache[cacheKey(provider, conn.id)] = Date.now();
-          console.warn(`[AutoPing] ${provider}:${conn.id}: ${e.message}`);
-        }
-      }
-    }
-  } catch (e) {
-    console.warn("[AutoPing] tick error:", e.message);
-  } finally {
-    state.running = false;
-  }
-}
-
-export function startQuotaAutoPing() {
-  if (g.interval) return;
-  console.log("[AutoPing] scheduler started");
-  runQuotaAutoPingTick().catch(() => {});
-  g.interval = setInterval(() => { runQuotaAutoPingTick().catch(() => {}); }, C.tickIntervalMs);
-  if (g.interval.unref) g.interval.unref();
-}
-
-export function stopQuotaAutoPing() {
-  if (!g.interval) return;
-  clearInterval(g.interval);
-  g.interval = null;
-  console.log("[AutoPing] scheduler stopped");
-}
-
-export function configureQuotaAutoPing(settings) {
-  const enabled = Object.values(C.providers).some((providerConfig) =>
-    Object.values(settings?.[providerConfig.settingsKey]?.connections || {}).some(Boolean)
-  );
-  if (enabled) startQuotaAutoPing();
-  else stopQuotaAutoPing();
-}
+// Quota auto-ping scheduler: warms 5h windows by sending tiny opt-in requests right after reset.
+import "open-sse/index.js";
+
+import { getSettings, getProviderConnections, updateProviderConnection } from "@/lib/localDb";
+import { getClaudeUsage } from "open-sse/services/usage/claude.js";
+import { getCodexUsage } from "open-sse/services/usage/codex.js";
+import { getExecutor } from "open-sse/executors/index.js";
+import { CLAUDE_CLI_SPOOF_HEADERS } from "open-sse/providers/shared.js";
+import { proxyAwareFetch } from "open-sse/utils/proxyFetch.js";
+import { resolveConnectionProxyConfig } from "@/lib/network/connectionProxy";
+import { refreshAndUpdateCredentials } from "@/app/api/usage/[connectionId]/route.js";
+import { QUOTA_AUTOPING_CONFIG } from "@/shared/constants/config";
+import { getDuePingSlot, normalizePingSchedule } from "@/shared/services/quotaPingSchedule";
+
+const C = QUOTA_AUTOPING_CONFIG;
+const CLAUDE_PING_URL = "https://api.anthropic.com/v1/messages?beta=true";
+
+const providerHandlers = {
+  claude: {
+    getUsage: getClaudeUsage,
+    sendPing: sendClaudePing,
+  },
+  codex: {
+    getUsage: getCodexUsage,
+    sendPing: sendCodexPing,
+  },
+};
+
+// Survive Next.js hot reload and keep one scheduler per server process.
+const g = (global.__quotaAutoPing ??= {
+  interval: null,
+  running: false,
+  resetCache: {},
+  failureCache: {},
+});
+
+function cacheKey(provider, connectionId) {
+  return `${provider}:${connectionId}`;
+}
+
+function normalizeResetKey(resetAt) {
+  const ms = new Date(resetAt).getTime();
+  if (!Number.isFinite(ms)) return resetAt;
+  return new Date(Math.floor(ms / 60000) * 60000).toISOString();
+}
+
+function getResetDriftMs(previousResetAt, nextResetAt) {
+  const previousMs = new Date(previousResetAt).getTime();
+  const nextMs = new Date(nextResetAt).getTime();
+  if (!Number.isFinite(previousMs) || !Number.isFinite(nextMs)) return 0;
+  return nextMs - previousMs;
+}
+
+function toFiniteNumber(value, fallback = null) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return fallback;
+}
+
+function isQuotaExhausted(quota) {
+  if (!quota || quota.unlimited === true) return false;
+  const remaining = toFiniteNumber(quota.remaining);
+  if (remaining !== null) return remaining <= 0;
+
+  const used = toFiniteNumber(quota.used);
+  const total = toFiniteNumber(quota.total);
+  return total !== null && total > 0 && used !== null && used >= total;
+}
+
+function wasPingedRecently(connection, intervalMs, nowMs = Date.now()) {
+  if (!intervalMs) return false;
+  const lastPingAtMs = new Date(connection.lastPingAt).getTime();
+  return Number.isFinite(lastPingAtMs) && nowMs - lastPingAtMs < intervalMs;
+}
+
+function isBlockingQuotaName(name, sessionKey) {
+  if (name === sessionKey) return false;
+  return !String(name).toLowerCase().includes("session");
+}
+
+function hasExhaustedBlockingQuota(quotas, sessionKey) {
+  return Object.entries(quotas || {}).some(([name, quota]) => isBlockingQuotaName(name, sessionKey) && isQuotaExhausted(quota));
+}
+
+function shouldPingForReset(providerConfig, cachedReset, resetAt, now) {
+  if (providerConfig.pingWhenResetAtSlides) {
+    return Boolean(cachedReset) && getResetDriftMs(cachedReset, resetAt) >= (providerConfig.resetAtDriftMs || 0);
+  }
+
+  const resetMs = new Date(resetAt).getTime();
+  return Number.isFinite(resetMs) && now >= resetMs - C.pingLeadMs;
+}
+
+function getConnectionSchedule(settings, providerConfig, connectionId) {
+  const schedules = settings?.[providerConfig.settingsKey]?.schedules || {};
+  return normalizePingSchedule(schedules[connectionId]);
+}
+
+function buildProxyOptions(cfg) {
+  return {
+    connectionProxyEnabled: cfg.connectionProxyEnabled === true,
+    connectionProxyUrl: cfg.connectionProxyUrl || "",
+    connectionNoProxy: cfg.connectionNoProxy || "",
+    vercelRelayUrl: cfg.vercelRelayUrl || "",
+    strictProxy: false,
+  };
+}
+
+async function sendClaudePing(connection, providerConfig, proxyOptions, deps) {
+  const res = await deps.proxyAwareFetch(CLAUDE_PING_URL, {
+    method: "POST",
+    headers: {
+      ...CLAUDE_CLI_SPOOF_HEADERS,
+      "Authorization": `Bearer ${connection.accessToken}`,
+      "content-type": "application/json",
+    },
+    body: JSON.stringify({
+      model: providerConfig.pingModel,
+      max_tokens: providerConfig.pingMaxTokens,
+      messages: [{ role: "user", content: providerConfig.pingText }],
+    }),
+  }, proxyOptions);
+  return res.ok;
+}
+
+function buildCodexPingInput(text) {
+  return [{
+    type: "message",
+    role: "user",
+    content: [{ type: "input_text", text }],
+  }];
+}
+
+async function drainResponseBody(response) {
+  if (typeof response?.text === "function") {
+    await response.text();
+    return;
+  }
+
+  const reader = response?.body?.getReader?.();
+  if (!reader) return;
+
+  try {
+    while (true) {
+      const { done } = await reader.read();
+      if (done) return;
+    }
+  } finally {
+    reader.releaseLock?.();
+  }
+}
+
+async function sendCodexPing(connection, providerConfig, proxyOptions, deps) {
+  const executor = deps.getExecutor("codex");
+  const { response } = await executor.execute({
+    model: providerConfig.pingModel,
+    stream: true,
+    credentials: {
+      accessToken: connection.accessToken,
+      connectionId: connection.id,
+      providerSpecificData: connection.providerSpecificData,
+    },
+    proxyOptions,
+    log: console,
+    body: {
+      model: providerConfig.pingModel,
+      input: buildCodexPingInput(providerConfig.pingText),
+      instructions: providerConfig.pingInstructions,
+      reasoning: providerConfig.pingReasoningEffort
+        ? { effort: providerConfig.pingReasoningEffort, summary: "auto" }
+        : undefined,
+      store: false,
+      stream: true,
+    },
+  });
+  if (!response.ok) {
+    try { await response.body?.cancel?.(); } catch { /* noop */ }
+    return false;
+  }
+
+  // Codex only starts the 5h window after the streaming response completes.
+  await drainResponseBody(response);
+  return true;
+}
+
+function shouldSkipAfterFailure(state, key, nowMs = Date.now()) {
+  const failedAt = state.failureCache[key];
+  return failedAt && nowMs - failedAt < C.failureCooldownMs;
+}
+
+async function pingConnection(conn, provider, providerConfig, handler, deps, state = g, schedule = null, reactive = true) {
+  const key = cacheKey(provider, conn.id);
+
+  // resetAt is stable for time-based windows; Codex polls every tick because inactive windows slide forward.
+  // A schedule needs a fresh look every tick, since its slots do not depend on resetAt.
+  const cachedReset = state.resetCache[key];
+  if (!schedule && !providerConfig.pingWhenResetAtSlides && cachedReset && Date.now() < new Date(cachedReset).getTime() - C.refreshAheadMs) return;
+
+  // Avoid hammering provider auth/quota endpoints if a ping failed recently.
+  if (shouldSkipAfterFailure(state, key)) return;
+
+  const proxyCfg = await deps.resolveConnectionProxyConfig(conn.providerSpecificData);
+  const proxyOptions = buildProxyOptions(proxyCfg);
+
+  let connection = conn;
+  try {
+    const r = await deps.refreshAndUpdateCredentials(connection, false, proxyOptions);
+    connection = r.connection;
+  } catch (e) {
+    state.failureCache[key] = Date.now();
+    console.warn(`[AutoPing] ${provider}:${conn.id}: refresh failed: ${e.message}`);
+    return;
+  }
+
+  const usage = await handler.getUsage(connection.accessToken, proxyOptions);
+  const quotas = usage?.quotas || {};
+  const quota = quotas?.[providerConfig.quotaKey];
+  const resetAt = quota?.resetAt;
+  if (resetAt) state.resetCache[key] = resetAt;
+
+  if (providerConfig.skipWhenBlockingQuotaExhausted && hasExhaustedBlockingQuota(quotas, providerConfig.quotaKey)) return;
+  if (isQuotaExhausted(quota)) return;
+
+  const now = Date.now();
+  const resetKey = resetAt ? normalizeResetKey(resetAt) : null;
+
+  // Anchored schedule runs alongside the reactive path: it fires on its own wall-clock
+  // slots, whether or not the provider reported a reset.
+  const dueSlot = schedule ? getDuePingSlot(schedule, now) : null;
+  const slotPending = Boolean(dueSlot) && connection.lastPingedSlotKey !== dueSlot.key;
+
+  if (slotPending) {
+    if (wasPingedRecently(connection, providerConfig.minPingIntervalMs, now)) return;
+  } else {
+    if (!reactive || !resetAt) return;
+
+    const lastPingedResetKey = connection.lastPingedResetKey || normalizeResetKey(connection.lastPingedResetAt);
+
+    // Claude waits for reset. Codex pings only when resetAt slides, which means the 5h window is inactive.
+    if (!shouldPingForReset(providerConfig, cachedReset, resetAt, now)) return;
+    if (wasPingedRecently(connection, providerConfig.minPingIntervalMs, now)) return;
+    if (lastPingedResetKey === resetKey) return;
+  }
+
+  const ok = await handler.sendPing(connection, providerConfig, proxyOptions, deps);
+  if (!ok) {
+    // Do not mark reset/slot as pinged unless upstream accepted the tiny request.
+    state.failureCache[key] = Date.now();
+    console.warn(`[AutoPing] ${provider}:${connection.id}: ping failed (${slotPending ? `slot ${dueSlot.key}` : `reset ${resetAt}`})`);
+    return;
+  }
+
+  delete state.failureCache[key];
+  const pingedAt = new Date().toISOString();
+  await deps.updateProviderConnection(connection.id, {
+    ...(resetAt ? { lastPingedResetAt: resetAt, lastPingedResetKey: resetKey } : {}),
+    ...(slotPending ? { lastPingedSlotKey: dueSlot.key } : {}),
+    lastPingAt: pingedAt,
+    updatedAt: pingedAt,
+  });
+  console.log(`[AutoPing] ${provider}:${connection.id}: ping sent (${slotPending ? `slot ${dueSlot.key}` : `reset ${resetAt}`})`);
+}
+
+function createDefaultDeps() {
+  return {
+    getSettings,
+    getProviderConnections,
+    updateProviderConnection,
+    resolveConnectionProxyConfig,
+    refreshAndUpdateCredentials,
+    proxyAwareFetch,
+    getExecutor,
+  };
+}
+
+export async function runQuotaAutoPingTick(deps = createDefaultDeps(), state = g) {
+  if (state.running) return;
+  state.running = true;
+  try {
+    const settings = await deps.getSettings();
+
+    for (const [provider, providerConfig] of Object.entries(C.providers)) {
+      const handler = providerHandlers[provider];
+      if (!handler) continue;
+
+      const enabledMap = settings?.[providerConfig.settingsKey]?.connections || {};
+      const scheduleMap = settings?.[providerConfig.settingsKey]?.schedules || {};
+      if (Object.keys(enabledMap).length === 0 && Object.keys(scheduleMap).length === 0) continue;
+
+      const conns = await deps.getProviderConnections({ provider, isActive: true });
+      // A schedule stands on its own: an account can run only on its slots, with the
+      // reactive ping left off.
+      const targets = conns.filter((conn) => (
+        conn.authType === "oauth"
+        && (enabledMap[conn.id] === true || normalizePingSchedule(scheduleMap[conn.id]) !== null)
+      ));
+      for (const conn of targets) {
+        try {
+          const schedule = getConnectionSchedule(settings, providerConfig, conn.id);
+          const reactive = enabledMap[conn.id] === true;
+          await pingConnection(conn, provider, providerConfig, handler, deps, state, schedule, reactive);
+        } catch (e) {
+          state.failureCache[cacheKey(provider, conn.id)] = Date.now();
+          console.warn(`[AutoPing] ${provider}:${conn.id}: ${e.message}`);
+        }
+      }
+    }
+  } catch (e) {
+    console.warn("[AutoPing] tick error:", e.message);
+  } finally {
+    state.running = false;
+  }
+}
+
+export function startQuotaAutoPing() {
+  if (g.interval) return;
+  console.log("[AutoPing] scheduler started");
+  runQuotaAutoPingTick().catch(() => {});
+  g.interval = setInterval(() => { runQuotaAutoPingTick().catch(() => {}); }, C.tickIntervalMs);
+  if (g.interval.unref) g.interval.unref();
+}
+
+export function stopQuotaAutoPing() {
+  if (!g.interval) return;
+  clearInterval(g.interval);
+  g.interval = null;
+  console.log("[AutoPing] scheduler stopped");
+}
+
+// An opted-in account or a single enabled schedule is enough to need the scheduler.
+export function hasAnyAutoPingEnabled(settings) {
+  return Object.values(C.providers).some((providerConfig) => {
+    const config = settings?.[providerConfig.settingsKey];
+    return Object.values(config?.connections || {}).some(Boolean)
+      || Object.values(config?.schedules || {}).some((schedule) => normalizePingSchedule(schedule) !== null);
+  });
+}
+
+export function configureQuotaAutoPing(settings) {
+  if (hasAnyAutoPingEnabled(settings)) startQuotaAutoPing();
+  else stopQuotaAutoPing();
+}