9router 0.5.30 → 0.5.40

package/app/src/lib/db/adapters/betterSqliteAdapter.js

@@ -40,9 +40,9 @@ export function createBetterSqliteAdapter(filePath) {
 
   return {
     driver: "better-sqlite3",
-    run(sql, params = []) { return prepare(sql).run(params); },
-    get(sql, params = []) { return prepare(sql).get(params); },
-    all(sql, params = []) { return prepare(sql).all(params); },
+    run(sql, params = []) { return prepare(sql).run(...params); },
+    get(sql, params = []) { return prepare(sql).get(...params); },
+    all(sql, params = []) { return prepare(sql).all(...params); },
     exec(sql) { return db.exec(sql); },
     transaction(fn) { return db.transaction(fn)(); },
     checkpoint() { try { db.pragma("wal_checkpoint(TRUNCATE)"); } catch {} },

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

@@ -0,0 +1,313 @@
+// 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();
+}

package/cli.js

@@ -67,6 +67,19 @@ const { ensureSqliteRuntime, buildEnvWithRuntime } = require("./hooks/sqliteRunt
 const { ensureTrayRuntime } = require("./hooks/trayRuntime");
 const args = process.argv.slice(2);
 
+// Subcommands (`9router xai video …`) run against an already-running gateway
+// and bypass the launcher flow (no runtime self-heal, no server spawn).
+if (args[0] === "xai" && args[1] === "video") {
+  const { run } = require("./src/cli/commands/xaiVideo");
+  run(args.slice(2))
+    .then((code) => process.exit(code))
+    .catch((err) => {
+      console.error(`❌ ${err?.message || err}`);
+      process.exit(1);
+    });
+  return;
+}
+
 // Self-heal SQLite runtime deps (sql.js + better-sqlite3) into ~/.9router/runtime
 // so the server can resolve them via NODE_PATH. Best-effort — sql.js is required,
 // better-sqlite3 is optional. Logs to stderr only on failure.
@@ -139,6 +152,11 @@ Options:
   --skip-update       Skip auto-update check
   -h, --help          Show this help message
   -v, --version       Show version
+
+Commands:
+  xai video --prompt "..." --output video.mp4
+                      Generate a Grok Imagine video via the running gateway
+                      (see: ${APP_NAME} xai video --help)
 `);
     process.exit(0);
   } else if (args[i] === "--version" || args[i] === "-v") {
@@ -594,7 +612,7 @@ function startServer(updatePromise) {
   function spawnServer() {
     serverStartTime = Date.now();
     crashLog = [];
-    const child = spawn(RUNTIME, ["--max-old-space-size=6144", serverPath], {
+    const child = spawn(RUNTIME, ["--dns-result-order=ipv4first", "--max-old-space-size=6144", serverPath], {
       cwd: standaloneDir,
       stdio: showLog ? "inherit" : ["ignore", "ignore", "pipe"],
       detached: true,
@@ -767,7 +785,7 @@ function startServer(updatePromise) {
           // Windows/Linux: spawn detached bgProcess (systray works fine in child)
           console.log(`\n⏳ Starting background process... (tray icon will appear in ~3s)`);
 
-          const bgProcess = spawn(process.execPath, [__filename, "--tray", "--skip-update", "-p", port.toString()], {
+          const bgProcess = spawn(process.execPath, ["--dns-result-order=ipv4first", __filename, "--tray", "--skip-update", "-p", port.toString()], {
             detached: true,
             stdio: "ignore",
             windowsHide: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "9router",
-  "version": "0.5.30",
+  "version": "0.5.40",
   "description": "9Router CLI - Start and manage 9Router server",
   "bin": {
     "9router": "./cli.js"