@techysy/10router 1.1.0 → 1.1.2

package/app/src/lib/consoleArchiveStandalone.mjs

@@ -0,0 +1,73 @@
+// Long-term console archive — tees console.log/info/warn/error into a per-day
+// file under <dataDir>/logs/app-YYYY-MM-DD.log (local date, append-only, no cap
+// by design: this is the durable record of "what did upstream actually answer /
+// why did the request fail" that ring-buffer stores like requestDetails (200
+// records) and the desktop 5MB server.log deliberately don't keep).
+//
+// Self-contained by requirement: custom-server.js loads this in the STANDALONE
+// build, where src/lib sources are not shipped — Node builtins only, same
+// constraint as outboundProxyStandalone.js. Everything is best-effort: any
+// failure leaves the original console untouched and the app unbroken.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import util from "node:util";
+
+const LEVELS = ["log", "info", "warn", "error"];
+
+/** Local-date key "YYYY-MM-DD" — archives are read by humans, so local, not UTC. */
+export function dayKey(date) {
+  const p = (n) => String(n).padStart(2, "0");
+  return `${date.getFullYear()}-${p(date.getMonth() + 1)}-${p(date.getDate())}`;
+}
+
+/** Same resolution as src/lib/dataDir.js: DATA_DIR first, then the platform default. */
+export function resolveArchiveDir(env = process.env) {
+  if (env.DATA_DIR) return path.join(env.DATA_DIR, "logs");
+  if (process.platform === "win32") {
+    return path.join(env.APPDATA || path.join(os.homedir(), "AppData", "Roaming"), "10router", "logs");
+  }
+  return path.join(os.homedir(), ".10router", "logs");
+}
+
+/**
+ * Wrap `target`'s console methods so every line is also appended to
+ * `<dir>/app-<local-day>.log` as `<ISO> [level] <formatted>`. The file handle
+ * rolls over when the local date changes. Returns the wrapped level names.
+ *
+ * Callers should pass an explicit `target` in tests; custom-server.js uses the
+ * real global console once per process.
+ */
+export function installConsoleArchive({ target = console, dir = resolveArchiveDir(), now = () => new Date() } = {}) {
+  const state = { day: null, fd: null };
+  const original = Object.fromEntries(LEVELS.map((level) => [level, target[level]]));
+
+  function fdForDay(day) {
+    if (state.fd && state.day === day) return state.fd;
+    if (state.fd) {
+      try { fs.closeSync(state.fd); } catch { /* already closed */ }
+      state.fd = null;
+    }
+    try {
+      fs.mkdirSync(dir, { recursive: true });
+      state.fd = fs.openSync(path.join(dir, `app-${day}.log`), "a");
+      state.day = day;
+    } catch {
+      state.fd = null; // an unwritable archive must never break the app
+    }
+    return state.fd;
+  }
+
+  for (const level of LEVELS) {
+    target[level] = (...args) => {
+      original[level](...args);
+      try {
+        const d = now();
+        const fd = fdForDay(dayKey(d));
+        if (fd) fs.writeSync(fd, `${d.toISOString()} [${level}] ${util.format(...args)}\n`);
+      } catch { /* best-effort: the console itself already succeeded */ }
+    };
+  }
+  return LEVELS;
+}

package/app/src/lib/oauth/xiaomiIdentity.js

@@ -0,0 +1,41 @@
+// Shared identity matching for Xiaomi MiMo connections.
+//
+// MiMo has two credential families (desktop account session + sk- API key) and
+// several ways they arrive (QR import, browser authorization, manual key). All
+// of them must resolve to ONE connection per Xiaomi account, otherwise the
+// dashboard shows duplicate rows for the same uid and routing picks a row that
+// lacks the credential the requested model needs.
+//
+// Match priority (first hit wins):
+//   1. uid          — the account id the browser/desktop flow reports
+//   2. mimoUserId   — the desktop-session account id (covers uid-less payloads)
+//   3. email        — `${uid}@xiaomi` synthetic address
+//   4. accessToken  — exact key/token reuse (same file imported twice)
+//
+// Every caller must go through this so the rules cannot drift apart again.
+
+/**
+ * @param {object} conn      candidate connection row
+ * @param {{uid?: string|null, key?: string|null, mimoUserId?: string|null}} ident
+ * @returns {boolean}
+ */
+export function matchesXiaomiIdentity(conn, ident = {}) {
+  if (!conn || conn.provider !== "xiaomi-mimo") return false;
+  const { uid = null, key = null, mimoUserId = null } = ident;
+  const psd = conn.providerSpecificData || {};
+
+  if (uid && (psd.uid === uid || psd.mimoUserId === uid)) return true;
+  if (uid && conn.email === `${uid}@xiaomi`) return true;
+  if (mimoUserId && psd.mimoUserId === mimoUserId) return true;
+  if (key && conn.accessToken === key) return true;
+  return false;
+}
+
+/**
+ * Find the connection that `ident` belongs to, or null.
+ * @param {Array<object>} connections
+ * @param {{uid?: string|null, key?: string|null, mimoUserId?: string|null}} ident
+ */
+export function findXiaomiConnection(connections, ident = {}) {
+  return (connections || []).find((c) => matchesXiaomiIdentity(c, ident)) || null;
+}

package/app/src/sse/services/codebuddyCheckin.js

@@ -1,21 +1,81 @@
-// CodeBuddy CN auto daily check-in (experimental).
-// Checks every active codebuddy-cn connection into the CodeBuddy CN "billing
-// meter" once per day at a random 00:00-06:00 local slot, so free daily
-// quota is renewed without user action. Fail-open everywhere: a tick error or
-// a single connection failure never rejects the whole run or kills the server.
+// CodeBuddy auto daily check-in (CN) + daily active-session probe (intl).
+//
+// CN: checks every active codebuddy-cn connection into the CodeBuddy CN
+// "billing meter" (daily-checkin) so free daily quota is renewed without user
+// action. The scheduler ticks ALL DAY (~every 2h + jitter): an account is
+// attempted only until the day's check-in is confirmed (status endpoint or a
+// successful POST), then it is memoized for the rest of the local day — no
+// more repeated "已签到" churn across the day.
+//
+// intl: CodeBuddy's activity campaign grants daily credits (Free 30 / Pro 50)
+// to accounts with ≥1 valid conversation request that day (official docs:
+// "当天有对话请求即视为活跃用户"). There is no claim endpoint, so the intl
+// pass sends one minimal stream chat request per active codebuddy-intl
+// connection per day on a free-tier model (rateMultiplier 0, ~0 credit cost),
+// memoized the same way. Experimental, separate settings toggle.
+//
+// Fail-open everywhere: a tick error or a single connection failure never
+// rejects the whole run or kills the server.
 
 import * as log from "../utils/logger.js";
 
 const DAILY_CHECKIN_URL = "https://www.codebuddy.cn/v2/billing/meter/daily-checkin";
 const STATUS_URL = "https://www.codebuddy.cn/v2/billing/meter/checkin-activity-status";
 
-// Random daily slot window: 00:00 - 06:00 local time (exclusive of 06:00).
-const SLOT_HOUR_MIN = 0;
-const SLOT_HOUR_MAX = 6; // upper bound exclusive for Math.floor(rand*(max-min))
+// intl daily active-session probe. Free-tier model (rateMultiplier 0) so the
+// request itself costs ~0 credits; body shape mirrors executors/codebuddy-intl
+// (stream-only gateway: leading system prompt + user content as typed blocks,
+// otherwise 11101 invalid request).
+const INTL_CHAT_URL = "https://www.codebuddy.ai/v2/chat/completions";
+const INTL_PROBE_MODEL = "hy4-preview";
+const INTL_PROBE_MAX_TOKENS = 16;
+
+// All-day cadence: retry every ~2h (plus jitter) until each account is done
+// for the day; the per-day memo keeps already-done accounts fully idle.
+const TICK_MS = 2 * 60 * 60 * 1000;
+const TICK_JITTER_MS = 10 * 60 * 1000;
 
 let started = false;
 let timerHandle = null;
 
+// connId -> local "YYYY-MM-DD" the account was last confirmed done. Persisted
+// in settings as `codeBuddyDailyDone` (lazy-loaded into this cache) so a
+// restart doesn't re-verify already-done accounts until the day rolls over;
+// entries are pruned to today on every write. The manual check-in route never
+// touches this memo.
+let doneMap = null;
+
+async function getDoneMap() {
+  if (doneMap) return doneMap;
+  const settings = await loadSettingsSafe();
+  const raw = settings?.codeBuddyDailyDone;
+  doneMap = raw && typeof raw === "object" && !Array.isArray(raw) ? { ...raw } : {};
+  return doneMap;
+}
+
+// Write the in-memory memo back to settings, pruned to today. Called by the
+// scheduler after each pass (the ticks only mutate the passed memo object).
+async function persistDoneMap() {
+  if (!doneMap) return;
+  const today = dayKey();
+  const pruned = {};
+  for (const [id, day] of Object.entries(doneMap)) {
+    if (day === today) pruned[id] = day;
+  }
+  try {
+    const { updateSettings } = await import("../../lib/localDb.js");
+    await updateSettings({ codeBuddyDailyDone: pruned });
+    for (const k of Object.keys(doneMap)) delete doneMap[k];
+    Object.assign(doneMap, pruned);
+  } catch (err) {
+    // Persist is best-effort — the in-memory cache still prevents same-process
+    // repeats; a failed write just means one extra status check after restart.
+    log.warn("CB_CN_CHECKIN", "Persist daily-done map failed (swallowed)", {
+      error: err?.message ?? String(err),
+    });
+  }
+}
+
 // ─── Pure helpers (unit-testable, no I/O) ──────────────────────────────────
 
 function decodeJwt(jwt) {
@@ -36,6 +96,18 @@ function isCodeBuddyCnRealm(iss) {
   );
 }
 
+// intl tokens are issued by the codebuddy.ai side; matching the "codebuddy"
+// family keeps a workbuddy/other realm out without over-fitting the realm URL.
+function isCodeBuddyRealm(iss) {
+  return typeof iss === "string" && iss.includes("codebuddy");
+}
+
+function dayKey(nowMs = Date.now()) {
+  const d = new Date(nowMs);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
+}
+
 /**
  * Eligibility: an active codebuddy-cn OAuth connection whose access token is
  * signed by a CodeBuddy CN Keycloak realm (has an access token at all).
@@ -50,6 +122,19 @@ export function isEligibleCbcnConnection(conn) {
   return isCodeBuddyCnRealm(claims.iss || "");
 }
 
+/**
+ * Eligibility for the intl daily active-session probe.
+ * @param {object} conn
+ * @returns {boolean}
+ */
+export function isEligibleCbIntlConnection(conn) {
+  if (!conn || !conn.accessToken) return false;
+  if (conn.provider !== "codebuddy-intl") return false;
+  if (conn.isActive === false) return false;
+  const claims = decodeJwt(conn.accessToken) || {};
+  return isCodeBuddyRealm(claims.iss || "");
+}
+
 function isIdempotentAlready(msg) {
   if (typeof msg !== "string") return false;
   // CN "今天已签到" / generic "repeat/already" markers from the CodeBuddy gateway.
@@ -71,27 +156,15 @@ export function mapDailyCheckinStatus({ httpStatus, code, msg } = {}) {
 }
 
 /**
- * Random delay (ms) until the next 00:00-06:00 local daily slot, strictly in
- * the future within roughly (0, ~30h]. `rand` is injectable for tests.
+ * Delay (ms) until the next all-day tick: fixed ~2h cadence plus jitter so
+ * many instances don't tick in lockstep. `rand` is injectable for tests.
  * @param {number} [nowMs]
  * @param {() => number} [rand] 0..1 uniform
  * @returns {number}
  */
-export function msUntilNextSlot(nowMs = Date.now(), rand = Math.random) {
-  const now = new Date(nowMs);
-  const hour = SLOT_HOUR_MIN + Math.floor(rand() * (SLOT_HOUR_MAX - SLOT_HOUR_MIN));
-  const minute = Math.floor(rand() * 60);
-  const target = new Date(now);
-  target.setHours(hour, minute, 0, 0);
-  let diff = target.getTime() - now.getTime();
-  if (diff <= 0) {
-    // Past today → next day (also keeps the timer far enough from the loop edge).
-    target.setDate(target.getDate() + 1);
-    diff = target.getTime() - now.getTime();
-  }
-  // Sanity guard: never schedule a pathological 0ms/loop. In tests callers pass
-  // a deterministic rand so this is only a belt-and-braces floor.
-  return Math.max(diff, 1000);
+export function msUntilNextTick(nowMs = Date.now(), rand = Math.random) {
+  const jitter = Math.floor(rand() * TICK_JITTER_MS);
+  return Math.max(TICK_MS + jitter, 1000);
 }
 
 function isNonServerRuntime() {
@@ -111,17 +184,25 @@ async function loadActiveConnections() {
   return getProviderConnections({ provider: "codebuddy-cn" });
 }
 
-async function isEnabledSetting() {
-  const { getSettings } = await import("../../lib/localDb.js");
-  const settings = await getSettings();
-  return settings.codeBuddyCheckin === true;
+async function loadIntlConnections() {
+  const { getProviderConnections } = await import("../../lib/db/repos/connectionsRepo.js");
+  return getProviderConnections({ provider: "codebuddy-intl" });
+}
+
+async function loadSettingsSafe() {
+  try {
+    const { getSettings } = await import("../../lib/localDb.js");
+    return await getSettings();
+  } catch {
+    return {};
+  }
 }
 
 // Reuse the existing proactive refresh pipeline (refreshes + persists the new
 // access token) exactly like backgroundTokenRefresh on a 401.
-async function refreshOne(connection) {
+async function refreshOne(provider, connection) {
   const { checkAndRefreshToken } = await import("./tokenRefresh.js");
-  const creds = await checkAndRefreshToken("codebuddy-cn", connection, { force: true });
+  const creds = await checkAndRefreshToken(provider, connection, { force: true });
   return creds?.accessToken ? creds : null;
 }
 
@@ -182,7 +263,7 @@ async function postStatus(accessToken, uid, proxyOptions) {
   return { httpStatus: res.status, body };
 }
 
-// Is the account already signed in today? Used by the boot safety pass so we
+// Is the account already signed in today? Used by the scheduled pass so we
 // don't re-check-in accounts that already renewed.
 function isCheckedInToday(status) {
   const data = status?.body?.data || {};
@@ -196,7 +277,7 @@ function isCheckedInToday(status) {
  * @returns {Promise<{status: string, error?: string}>}
  */
 async function checkinOne(conn, deps) {
-  const refresh = deps?.refreshConnection || refreshOne;
+  const refresh = deps?.refreshConnection || ((c) => refreshOne("codebuddy-cn", c));
   let accessToken = conn.accessToken;
   const claims = decodeJwt(accessToken) || {};
   const uid = claims.sub || conn.id;
@@ -225,7 +306,7 @@ async function checkinOne(conn, deps) {
   return { status: "failed", error: "unexpected" };
 }
 
-// Prefer status-check to skip already-checked-in accounts (boot safety pass).
+// Prefer status-check to skip already-checked-in accounts.
 async function checkinIfNotDone(conn, deps) {
   const proxyOptions = proxyOptionsOf(conn);
   const claims = decodeJwt(conn.accessToken) || {};
@@ -239,13 +320,85 @@ async function checkinIfNotDone(conn, deps) {
   return checkinOne(conn, deps);
 }
 
+// One intl active-session probe (with a single 401 → refresh → retry).
+async function probeOne(conn, deps) {
+  const refresh = deps?.refreshConnection || ((c) => refreshOne("codebuddy-intl", c));
+  let accessToken = conn.accessToken;
+  const proxyOptions = proxyOptionsOf(conn);
+
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      const result = await postIntlProbe(accessToken, proxyOptions);
+      if (result.httpStatus >= 200 && result.httpStatus < 300) return { status: "session-ok" };
+      if (result.httpStatus === 401 && attempt === 0) {
+        log.info("CB_INTL_SESSION", "401 on active-session probe, refreshing token once", {
+          id: conn.id,
+        });
+        const refreshed = await refresh(conn);
+        if (refreshed?.accessToken) accessToken = refreshed.accessToken;
+        else return { status: "failed", error: "refresh_failed" };
+        continue;
+      }
+      return { status: "failed", error: result.msg || `http_${result.httpStatus}` };
+    } catch (err) {
+      return { status: "failed", error: err?.message || String(err) };
+    }
+  }
+  return { status: "failed", error: "unexpected" };
+}
+
+async function postIntlProbe(accessToken, proxyOptions) {
+  const { proxyAwareFetch } = await import("open-sse/utils/proxyFetch.js");
+  const { default: registry } = await import("open-sse/providers/registry/codebuddy-intl.js");
+  const headers = {
+    ...(registry?.transport?.headers || {}),
+    Authorization: `Bearer ${accessToken}`,
+    "Content-Type": "application/json",
+    Accept: "text/event-stream",
+  };
+  const body = JSON.stringify({
+    model: INTL_PROBE_MODEL,
+    stream: true,
+    max_tokens: INTL_PROBE_MAX_TOKENS,
+    messages: [
+      { role: "system", content: "You are CodeBuddy Code." },
+      { role: "user", content: [{ type: "text", text: "hi" }] },
+    ],
+  });
+  const res = await proxyAwareFetch(
+    INTL_CHAT_URL,
+    { method: "POST", headers, body },
+    proxyOptions
+  );
+  // Stream-only gateway: 2xx means a valid session was established — drain and
+  // discard the SSE body (a few tokens on a rateMultiplier-0 model).
+  let msg = "";
+  if (res.ok && res.body) {
+    try {
+      await res.text();
+    } catch {
+      /* drain best-effort */
+    }
+  } else {
+    try {
+      const text = await res.text();
+      msg = (text || "").slice(0, 200);
+    } catch {
+      /* ignore */
+    }
+  }
+  return { httpStatus: res.status, msg };
+}
+
 /**
- * One tick: list active codebuddy-cn connections and check each in. Fail-open
- * (never rejects on a single account error). `skipIfCheckedToday` uses the
- * status endpoint first (boot safety) to avoid duplicate renewals.
+ * One CN tick: list active codebuddy-cn connections and check each in. Fail-open
+ * (never rejects on a single account error). With `memo` (plain object), accounts
+ * confirmed done for the local day are skipped entirely (no network) and
+ * successful outcomes are recorded. The manual check-in route passes no memo.
  *
  * @param {{ loadConnections?: Function, refreshConnection?: Function,
- *           checkinConnection?: Function, skipIfCheckedToday?: boolean }} [deps]
+ *           checkinConnection?: Function, skipIfCheckedToday?: boolean,
+ *           memo?: Record<string, string> }} [deps]
  * @returns {Promise<Array<{id: string, name: string, status: string, error?: string}>>}
  */
 export async function runCodebuddyCheckinTick(deps = {}) {
@@ -274,10 +427,22 @@ export async function runCodebuddyCheckinTick(deps = {}) {
     ids: eligible.map((c) => c.id).filter(Boolean),
   });
 
+  const memo = deps.memo || null;
+  const today = dayKey();
+  const checkin = deps.checkinConnection || (deps.skipIfCheckedToday ? checkinIfNotDone : checkinOne);
+
   for (const conn of eligible) {
     try {
-      const checkin = deps.checkinConnection || (deps.skipIfCheckedToday ? checkinIfNotDone : checkinOne);
+      if (memo && memo[conn.id] === today) {
+        log.debug("CB_CN_CHECKIN", `${conn.name || conn.id}: 已确认今日完成,跳过`, {
+          id: conn.id,
+        });
+        continue;
+      }
       const outcome = await checkin(conn, deps);
+      if (memo && (outcome.status === "checked-in" || outcome.status === "already")) {
+        memo[conn.id] = today;
+      }
       results.push({
         id: conn.id,
         name: conn.name || conn.id,
@@ -304,18 +469,100 @@ export async function runCodebuddyCheckinTick(deps = {}) {
   return results;
 }
 
+/**
+ * One intl tick: one free-tier chat request per active codebuddy-intl
+ * connection so the day's "活跃赠送" credits are granted. Same memo/fail-open
+ * contract as the CN tick.
+ *
+ * @param {{ loadConnections?: Function, refreshConnection?: Function,
+ *           probeConnection?: Function, memo?: Record<string, string> }} [deps]
+ * @returns {Promise<Array<{id: string, name: string, status: string, error?: string}>>}
+ */
+export async function runCodebuddyIntlSessionTick(deps = {}) {
+  const results = [];
+  const load = deps.loadConnections || loadIntlConnections;
+  let connections = [];
+  try {
+    connections = await load();
+  } catch (err) {
+    log.warn("CB_INTL_SESSION", "Tick: failed to load codebuddy-intl connections (swallowed)", {
+      error: err?.message ?? String(err),
+    });
+    return results;
+  }
+
+  const eligible = (Array.isArray(connections) ? connections : []).filter(isEligibleCbIntlConnection);
+  if (eligible.length === 0) {
+    log.debug("CB_INTL_SESSION", "Tick: no eligible codebuddy-intl connections", {
+      total: Array.isArray(connections) ? connections.length : 0,
+    });
+    return results;
+  }
+
+  log.info("CB_INTL_SESSION", "Daily active-session pass started", {
+    eligible: eligible.length,
+    ids: eligible.map((c) => c.id).filter(Boolean),
+  });
+
+  const memo = deps.memo || null;
+  const today = dayKey();
+
+  for (const conn of eligible) {
+    try {
+      if (memo && memo[conn.id] === today) {
+        log.debug("CB_INTL_SESSION", `${conn.name || conn.id}: 已确认今日完成,跳过`, {
+          id: conn.id,
+        });
+        continue;
+      }
+      const outcome = deps.probeConnection
+        ? await deps.probeConnection(conn)
+        : await probeOne(conn, deps);
+      if (memo && outcome.status === "session-ok") {
+        memo[conn.id] = today;
+      }
+      results.push({
+        id: conn.id,
+        name: conn.name || conn.id,
+        status: outcome.status,
+        ...(outcome.error ? { error: outcome.error } : {}),
+      });
+      log.info(
+        "CB_INTL_SESSION",
+        `${conn.name || conn.id}: ${outcome.status === "session-ok" ? "活跃会话完成" : `失败(${outcome.error || outcome.status})`}`,
+        { id: conn.id }
+      );
+    } catch (err) {
+      results.push({ id: conn.id, name: conn.name || conn.id, status: "failed" });
+      log.warn("CB_INTL_SESSION", "Connection probe failed (swallowed)", {
+        id: conn?.id,
+        error: err?.message ?? String(err),
+      });
+    }
+  }
+  return results;
+}
+
 // ─── Scheduler ─────────────────────────────────────────────────────────────
 
-// Run one guarded check-in pass, reading the enable flag each fire so turning
-// the toggle off stops further work without a restart (fail-open, never throws).
+// Run one guarded pass, reading both enable flags each fire so toggling off
+// stops further work without a restart (fail-open, never throws).
 async function safeTick(how) {
   try {
-    const on = await isEnabledSetting();
-    if (!on) {
+    const settings = await loadSettingsSafe();
+    const done = await getDoneMap();
+    if (settings.codeBuddyCheckin === true) {
+      await runCodebuddyCheckinTick({ skipIfCheckedToday: true, memo: done });
+      await persistDoneMap();
+    } else {
       log.debug("CB_CN_CHECKIN", `Scheduled ${how}: setting off, skipping`);
-      return;
     }
-    await runCodebuddyCheckinTick({ skipIfCheckedToday: how === "boot" });
+    if (settings.codeBuddyIntlSession === true) {
+      await runCodebuddyIntlSessionTick({ memo: done });
+      await persistDoneMap();
+    } else {
+      log.debug("CB_INTL_SESSION", `Scheduled ${how}: setting off, skipping`);
+    }
   } catch (err) {
     log.warn("CB_CN_CHECKIN", `Scheduled ${how} rejected (swallowed)`, {
       error: err?.message ?? String(err),
@@ -325,13 +572,13 @@ async function safeTick(how) {
 
 function scheduleNext() {
   if (!started) return;
-  const delayMs = msUntilNextSlot();
+  const delayMs = msUntilNextTick();
   clearTimer();
   timerHandle = setTimeout(() => {
-    safeTick("daily").finally(() => scheduleNext());
+    safeTick("tick").finally(() => scheduleNext());
   }, delayMs);
   if (timerHandle.unref) timerHandle.unref();
-  log.info("CB_CN_CHECKIN", "Next daily check-in slot scheduled", {
+  log.info("CB_CN_CHECKIN", "Next all-day check-in tick scheduled", {
     delayMs: Math.round(delayMs / 1000),
   });
 }
@@ -344,10 +591,10 @@ function clearTimer() {
 }
 
 /**
- * Start the daily check-in scheduler. Runs an immediate boot safety pass
- * (status-check + check-in of not-yet-checked-in accounts) then schedules the
- * next random 00:00-06:00 local slot. Safe to call repeatedly (idempotent).
- * @param {{ nowMs?: number, rand?: Function, skipBoot?: boolean }} [opts]
+ * Start the scheduler. Runs an immediate boot pass (status-check + check-in of
+ * not-yet-done accounts) then ticks all day every ~2h. Safe to call repeatedly
+ * (idempotent).
+ * @param {{ skipBoot?: boolean }} [opts]
  * @returns {boolean} true if started this call
  */
 export function startCodebuddyCheckin(opts = {}) {
@@ -358,13 +605,13 @@ export function startCodebuddyCheckin(opts = {}) {
   }
   started = true;
 
-  // Boot safety pass (only acts when the setting is on & accounts not yet in).
+  // Boot pass (only acts when a setting is on & accounts not yet done today).
   if (opts.skipBoot !== true) {
     safeTick("boot");
   }
   scheduleNext();
 
-  log.info("CB_CN_CHECKIN", "Scheduler started");
+  log.info("CB_CN_CHECKIN", "Scheduler started (all-day cadence)");
   return true;
 }
 
@@ -382,4 +629,11 @@ export const __internals = {
   isIdempotentAlready,
   DAILY_CHECKIN_URL,
   STATUS_URL,
+  INTL_CHAT_URL,
+  INTL_PROBE_MODEL,
+  dayKey,
+  msUntilNextTick,
+  getDoneMap,
+  persistDoneMap,
+  isEligibleCbIntlConnection,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@techysy/10router",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "description": "10Router CLI - Start and manage 10Router server",
   "publishConfig": {
     "access": "public"