nolo-cli 0.1.29 → 0.1.31

package/render/page/server/createPage.ts

@@ -5,7 +5,7 @@ import { format } from "date-fns";
 import { createPageKey } from "../../../database/keys";
 import { DataType } from "../../../create/types";
 import { markdownToSlate } from "../../../create/editor/transforms/markdownToSlate";
-import serverDb, { ensureServerDbOpen } from "../../../database/server/db";
+import { ensureServerDbOpen, getServerAuthorityStore } from "../../../database/server/db";
 import type { PageData } from "../types";
 import {
     createEmptyParagraph,
@@ -15,6 +15,8 @@ import {
 import { slateToRenderMarkdown } from "../../../create/editor/transforms/slateToRenderMarkdown";
 import { parseSkillDocProtocol } from "../../../ai/skills/skillDocProtocol";
 
+const serverDb = getServerAuthorityStore();
+
 export interface CreatePageServerArgs {
     userId: string;
     title?: string;

package/render/page/server/handleCreatePage.ts

@@ -2,7 +2,7 @@
 // HTTP handler for createPage (Bun serve 兼容)
 
 import { createPageServer } from "./createPage";
-import { handleToken } from "../../../auth/server/token";
+import { readUserFromRequest } from "../../../auth/server/token";
 import { logger } from "../../../auth/server/shared";
 
 const CORS_HEADERS = {
@@ -27,15 +27,7 @@ const CORS_HEADERS = {
  */
 export const handleCreatePage = async (req: Request): Promise<Response> => {
     try {
-        // 鉴权：创建一个简化的 req 对象用于 handleToken
-        const authReq: any = {
-            headers: {
-                get: (name: string) => req.headers.get(name),
-            },
-        };
-        const authRes: any = {}; // handleToken 可能不需要 res
-
-        const user = await handleToken(authReq, authRes);
+        const user = await readUserFromRequest(req);
         const userId = user?.userId;
 
         if (!userId) {
@@ -88,4 +80,3 @@ export const handleCreatePage = async (req: Request): Promise<Response> => {
         );
     }
 };
-

package/runtimeDoctorCommands.ts

@@ -1,41 +1,22 @@
-import { resolveAgentRuntimeDecision } from "./agent-runtime/runtimeDecision";
 import {
   type AgentCommandDeps,
   type LocalRuntimeProbeResult,
 } from "./agentCommandSupport";
+import {
+  buildCliRuntimeDoctorProbe,
+  buildCliRuntimeDoctorReport,
+  formatCliRuntimeDoctorReport,
+} from "./cliRuntimeDoctorReport";
 import {
   resolveAuthToken,
   resolveServerUrl,
   type EnvLike,
 } from "./cliEnvHelpers";
 
-function detectLocalAgentConfig(env: EnvLike) {
-  return Boolean(readLocalAgentKey(env) || env.NOLO_AGENT_CACHE_READY);
-}
-
 function readLocalAgentKey(env: EnvLike) {
   return env.NOLO_LOCAL_AGENT_KEY || env.NOLO_AGENT || "";
 }
 
-function detectLocalProvider(env: EnvLike) {
-  return Boolean(
-    env.OPENAI_API_KEY ||
-    env.ANTHROPIC_API_KEY ||
-    env.GOOGLE_API_KEY ||
-    env.NOLO_LOCAL_OPENAI_BASE_URL ||
-    env.OLLAMA_BASE_URL
-  );
-}
-
-function detectProviderLabel(env: EnvLike) {
-  if (env.NOLO_LOCAL_OPENAI_BASE_URL) return `openai-compatible endpoint ${env.NOLO_LOCAL_OPENAI_BASE_URL}`;
-  if (env.OLLAMA_BASE_URL) return `ollama-compatible endpoint ${env.OLLAMA_BASE_URL}`;
-  if (env.OPENAI_API_KEY) return "openai via env OPENAI_API_KEY";
-  if (env.ANTHROPIC_API_KEY) return "anthropic via env ANTHROPIC_API_KEY";
-  if (env.GOOGLE_API_KEY) return "google via env GOOGLE_API_KEY";
-  return "missing";
-}
-
 async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbeResult> {
   const { resolveCliLocalRuntimeDbPath } = await import("./localRuntimeDb");
   const dbPath = resolveCliLocalRuntimeDbPath({ env });
@@ -64,55 +45,23 @@ async function defaultLocalRuntimeProbe(env: EnvLike): Promise<LocalRuntimeProbe
 }
 
 export async function runDoctorRuntimeCommand(
-  _args: string[],
+  args: string[],
   deps: AgentCommandDeps = {}
 ) {
   const env = deps.env ?? process.env;
   const output = deps.output ?? process.stdout;
-  const authToken = resolveAuthToken(env);
-  const serverUrl = resolveServerUrl(env);
+  const authToken = resolveAuthToken(args, env);
+  const serverUrl = resolveServerUrl(args, env);
   const localProbe = await (deps.localRuntimeProbe ?? defaultLocalRuntimeProbe)(env);
-  const hasLocalAgentConfig = detectLocalAgentConfig(env) && localProbe.ok && localProbe.agentFound;
-  const hasLocalProvider = detectLocalProvider(env);
-  const missingLocalCapabilities = [
-    ...(localProbe.ok ? [] : ["leveldb"]),
-    ...(hasLocalAgentConfig ? [] : ["agent-config"]),
-    ...(hasLocalProvider ? [] : ["provider"]),
-  ];
-  const decision = resolveAgentRuntimeDecision({
-    requestedMode: "auto",
-    syncRequested: false,
-    host: "cli",
-    hasLocalAgentConfig,
-    hasLocalProvider,
-    hasLocalPersistence: true,
-    missingLocalCapabilities,
-    requiresServer: false,
-    serverFallbackAvailable: Boolean(authToken || env.NOLO_SERVER || env.BASE_URL),
-  });
-
-  output.write(`Runtime: ${decision.mode}\n`);
-  output.write(`Reason: ${decision.reason}\n`);
-  output.write(`LevelDB: ${localProbe.ok ? "ok" : "failed"}\n`);
-  output.write(`DB path: ${localProbe.dbPath}\n`);
-  if (!localProbe.ok && localProbe.error) {
-    output.write(`DB error: ${localProbe.error}\n`);
-  }
-  if (localProbe.agentKey) {
-    output.write(`Agent config: ${localProbe.agentFound ? "found" : "missing"} (${localProbe.agentKey})\n`);
-  } else {
-    output.write("Agent config: missing (no local agent key)\n");
-  }
-  output.write(`Provider: ${hasLocalProvider ? "available" : "missing"} (${detectProviderLabel(env)})\n`);
-  output.write("Persistence: LevelDB local store\n");
-  output.write(`Sync: ${authToken ? "available" : "unavailable"}${authToken ? "" : " (not authenticated)"}\n`);
-  output.write(`Server fallback: ${decision.runnable && decision.mode === "server" ? serverUrl : authToken || env.NOLO_SERVER || env.BASE_URL ? serverUrl : "unavailable"}\n`);
-  if (decision.missingLocalCapabilities.length > 0) {
-    output.write("Missing local capabilities:\n");
-    for (const capability of decision.missingLocalCapabilities) {
-      output.write(`- ${capability}\n`);
-    }
-  }
+  const report = buildCliRuntimeDoctorReport(
+    buildCliRuntimeDoctorProbe({
+      env,
+      localProbe,
+      authToken,
+      serverUrl,
+    })
+  );
+  output.write(formatCliRuntimeDoctorReport(report));
 
-  return decision.runnable ? 0 : 1;
+  return report.decision.runnable ? 0 : 1;
 }

package/server/api/methods.ts

@@ -1,6 +1,6 @@
 // ai/server/apiMethods.ts
 
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { MemberRole, SpaceVisibility, SpaceMemberWithSpaceInfo } from "../../app/types";
 import { fetchMessages, MessageWithKey } from "../../chat/messages/fetchMessages";
 import type { Message } from "../../chat/messages/types";
@@ -23,14 +23,20 @@ import {
   updateEmailTags,
 } from "../../database/server/emailRepository";
 import { isTombstoneRecord } from "../../database/tombstones";
+
+type ApiMethodsStore = ReturnType<typeof getServerAuthorityStore>;
+
+const getApiMethodsStore = () => getServerAuthorityStore();
+
 // DB 列表迭代 (保留，因为 fetchUserSpaceMemberships 仍在使用)
 async function dbListEntries<T>(
+  store: ApiMethodsStore,
   gte: string,
   lte: string,
   filter?: (key: string, value: T) => boolean
 ): Promise<Array<{ key: string; value: T }>> {
   const res: Array<{ key: string; value: T }> = [];
-  for await (const [key, value] of serverDb.iterator({ gte, lte })) {
+  for await (const [key, value] of store.iterator({ gte, lte })) {
     if (typeof key !== "string") continue;
     if (!filter || filter(key, value as T)) res.push({ key, value: value as T });
   }
@@ -88,6 +94,7 @@ const membershipFromSpace = (
 };
 
 const repairMissingMembershipsFromSpaces = async (
+  store: ApiMethodsStore,
   userId: string,
   existing: SpaceMemberWithSpaceInfo[],
   indexedSpaceIds: Set<string>
@@ -100,6 +107,7 @@ const repairMissingMembershipsFromSpaces = async (
   );
   const repaired: SpaceMemberWithSpaceInfo[] = [];
   const spaces = await dbListEntries<any>(
+    store,
     "space-",
     "space-\xff",
     (key, space) =>
@@ -116,13 +124,14 @@ const repairMissingMembershipsFromSpaces = async (
     if (bySpaceId.has(normalizedSpaceId)) continue;
     bySpaceId.set(normalizedSpaceId, membership);
     repaired.push(membership);
-    await serverDb.put(membershipKey(userId, normalizedSpaceId), membership);
+    await store.put(membershipKey(userId, normalizedSpaceId), membership);
   }
 
   return [...existing, ...repaired];
 };
 
 const hasActiveSpaceMembership = async (
+  store: ApiMethodsStore,
   userId: string,
   memberKey: string,
   membership: SpaceMemberWithSpaceInfo
@@ -149,7 +158,7 @@ const hasActiveSpaceMembership = async (
   }
 
   try {
-    const space = await serverDb.get(`space-${keySpaceId}`);
+    const space = await store.get(`space-${keySpaceId}`);
     if (!space || isTombstoneRecord(space)) return false;
     if (space.ownerId === userId) return true;
     return Array.isArray(space.members) && space.members.includes(userId);
@@ -162,11 +171,13 @@ export async function fetchUserSpaceMemberships(
   params: string | { userId: string },
   context?: ApiContext
 ): Promise<SpaceMemberWithSpaceInfo[]> {
+  const store = getApiMethodsStore();
   const userId =
     context?.userId || (typeof params === "string" ? params : params.userId);
   if (!userId) throw new Error("userId 必传");
   const prefix = `space-member-${userId}-`;
   const memberships = await dbListEntries<SpaceMemberWithSpaceInfo>(
+    store,
     prefix,
     prefix + "\xff",
     (_, membership) => !isTombstoneRecord(membership)
@@ -179,7 +190,7 @@ export async function fetchUserSpaceMemberships(
   );
   const activeMemberships = await Promise.all(
     memberships.map(async ({ key, value }) =>
-      await hasActiveSpaceMembership(userId, key, value)
+      await hasActiveSpaceMembership(store, userId, key, value)
         ? value
         : null
     )
@@ -187,7 +198,12 @@ export async function fetchUserSpaceMemberships(
   const verifiedMemberships = activeMemberships.filter(
     (membership): membership is SpaceMemberWithSpaceInfo => !!membership
   );
-  return repairMissingMembershipsFromSpaces(userId, verifiedMemberships, indexedSpaceIds);
+  return repairMissingMembershipsFromSpaces(
+    store,
+    userId,
+    verifiedMemberships,
+    indexedSpaceIds
+  );
 }
 
 interface FetchConvMsgsParams {
@@ -201,6 +217,7 @@ export async function fetchConvMsgs(
   params: string | FetchConvMsgsParams,
   context?: ApiContext
 ): Promise<Message[]> {
+  const store = getApiMethodsStore();
   let dialogId: string,
     dialogKey: string | undefined,
     limit: number | undefined,
@@ -226,7 +243,7 @@ export async function fetchConvMsgs(
     };
   }
 
-  const dialogRecord = await findDialogRecord(dialogId, dialogKey);
+  const dialogRecord = await findDialogRecord(store, dialogId, dialogKey);
   if (!dialogRecord) {
     throw {
       code: "not_found",
@@ -247,7 +264,7 @@ export async function fetchConvMsgs(
     };
   }
 
-  const msgs: MessageWithKey[] = await fetchMessages(serverDb, dialogId, {
+  const msgs: MessageWithKey[] = await fetchMessages(store, dialogId, {
     limit,
     beforeKey,
     throwOnError: true,
@@ -275,6 +292,7 @@ function isDialogRecordForId(record: any, dialogId: string): boolean {
 }
 
 async function readDialogRecordByKey(
+  store: ApiMethodsStore,
   dialogKey: string | undefined,
   dialogId: string
 ): Promise<{ dbKey: string; record: any } | null> {
@@ -282,7 +300,7 @@ async function readDialogRecordByKey(
     return null;
   }
   try {
-    const record = await serverDb.get(dialogKey);
+    const record = await store.get(dialogKey);
     if (!isDialogRecordForId(record, dialogId)) return null;
     return { dbKey: dialogKey, record };
   } catch (error) {
@@ -291,15 +309,19 @@ async function readDialogRecordByKey(
   }
 }
 
-async function findDialogRecord(dialogId: string, dialogKey?: string): Promise<{
+async function findDialogRecord(
+  store: ApiMethodsStore,
+  dialogId: string,
+  dialogKey?: string
+): Promise<{
   dbKey: string;
   record: any;
 } | null> {
-  const directRecord = await readDialogRecordByKey(dialogKey, dialogId);
+  const directRecord = await readDialogRecordByKey(store, dialogKey, dialogId);
   if (directRecord) return directRecord;
 
   const suffix = `-${dialogId}`;
-  for await (const [key, value] of serverDb.iterator({
+  for await (const [key, value] of store.iterator({
     gte: "dialog-",
     lte: "dialog-\uffff",
   })) {

package/server/api/tableHandlers.ts

@@ -1,10 +1,12 @@
 // server/api/tableHandlers.ts
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { metaKey, rowKey } from "../../database/keys";
 import { DataType } from "../../create/types";
 import type { ApiContext, ApiError } from "./types";
 import { assertCanReadTableRows } from "../handlers/tableAccess";
 
+const getTableHandlersStore = () => getServerAuthorityStore();
+
 interface ListTableRowsParams {
   tenantId: string;
   tableId: string;
@@ -14,6 +16,7 @@ export async function listTableRows(
   params: ListTableRowsParams,
   context?: ApiContext
 ) {
+  const store = getTableHandlersStore();
   const { tenantId, tableId } = params || {};
   if (!tenantId || !tableId) {
     throw new Error("tenantId 和 tableId 必传");
@@ -24,7 +27,7 @@ export async function listTableRows(
       message: "Cannot list table rows for another tenant",
     } as ApiError;
   }
-  const tableMeta = await serverDb.get(metaKey(tenantId, tableId)).catch(() => null);
+  const tableMeta = await store.get(metaKey(tenantId, tableId)).catch(() => null);
   try {
     await assertCanReadTableRows({
       userId: context.userId,
@@ -44,7 +47,7 @@ export async function listTableRows(
   const MAX_ROWS = 5000;
 
   const rows: any[] = [];
-  for await (const [, value] of serverDb.iterator({ gte, lte })) {
+  for await (const [, value] of store.iterator({ gte, lte })) {
     if (value?.type === DataType.TABLE_ROW && !value?.deletedAt) {
       rows.push(value);
       if (rows.length >= MAX_ROWS) break;

package/server/authenticateToken.ts

@@ -1,7 +1,8 @@
 import { assertSessionTokenVersion } from "../auth/sessionTokenVersion";
 import { parseToken, verifyToken } from "../auth/token";
+import { NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../database/config";
 import { DB_PREFIX } from "../database/keys";
-import serverDb from "../database/server/db";
+import { getServerAuthorityStore } from "../database/server/db";
 import type { ApiError } from "./api/types";
 
 const unauthorized = (message: string): ApiError => ({
@@ -31,10 +32,46 @@ const isOutsideTokenWindow = (payload: any): boolean => {
   return false;
 };
 
+const normalizeServerOrigin = (value: string | null | undefined): string | null => {
+  if (typeof value !== "string" || !value.trim()) return null;
+  return normalizeKnownServerOrigin(value);
+};
+
+const resolveAuthFallbackServers = (): string[] => {
+  const current = normalizeServerOrigin(process.env.APP_BASE_URL);
+  return NOLO_CLUSTER_SERVERS.filter((server) => normalizeServerOrigin(server) !== current);
+};
+
+const getAuthTokenStore = () => getServerAuthorityStore();
+
+const readUserFromClusterPeer = async (userId: string, token: string): Promise<any | null> => {
+  const store = getAuthTokenStore();
+  for (const server of resolveAuthFallbackServers()) {
+    try {
+      const res = await fetch(`${server}/api/v1/users/${encodeURIComponent(userId)}`, {
+        method: "GET",
+        headers: { Authorization: `Bearer ${token}` },
+      });
+      if (!res.ok) continue;
+      const data = await res.json().catch(() => null);
+      if (!data || typeof data !== "object") continue;
+      const record = { ...(data as Record<string, unknown>) };
+      delete (record as Record<string, unknown>).id;
+      if (typeof record.publicKey !== "string" || !record.publicKey) continue;
+      await store.put(`${DB_PREFIX.USER}${userId}`, record);
+      return record;
+    } catch {
+      // Try the next peer.
+    }
+  }
+  return null;
+};
+
 export async function authenticateToken(token?: string | null): Promise<{
   userId: string;
   payload: any;
 }> {
+  const store = getAuthTokenStore();
   if (!token) {
     throw unauthorized("Authentication required");
   }
@@ -47,8 +84,16 @@ export async function authenticateToken(token?: string | null): Promise<{
 
   let user: any;
   try {
-    user = await serverDb.get(`${DB_PREFIX.USER}${userId}`);
+    user = await store.get(`${DB_PREFIX.USER}${userId}`);
   } catch {
+    user = null;
+  }
+
+  if (!user) {
+    user = await readUserFromClusterPeer(userId, token);
+  }
+
+  if (!user) {
     throw unauthorized("User not found");
   }
 

package/server/billingLedgerRoutes.ts

@@ -3,6 +3,9 @@ import { handleBillingLedgerWitness } from "./handlers/billingLedgerWitnessHandl
 import { handleBillingUsageReport } from "./handlers/billingUsageReportHandler";
 import { handleCreatorEarningsReport } from "./handlers/creatorEarningsReportHandler";
 import { handleCreatorSettlementReport } from "./handlers/creatorSettlementReportHandler";
+import { handleProviderCallsRecent } from "./handlers/providerCallsRecentHandler";
+import { handleProviderRequestIds } from "./handlers/providerRequestIdsHandler";
+import { handleProviderReconciliationRun } from "./handlers/providerReconciliationRunHandler";
 import { handleRevenueShareReport } from "./handlers/revenueShareReportHandler";
 
 const CORS_HEADERS: Record<string, string> = {
@@ -33,6 +36,18 @@ export const billingLedgerRoutes: Record<string, any> = {
     GET: handleBillingUsageReport,
     OPTIONS: options,
   },
+  "/api/admin/provider-calls/recent": {
+    GET: handleProviderCallsRecent,
+    OPTIONS: options,
+  },
+  "/api/admin/provider-request-ids/recent": {
+    GET: handleProviderRequestIds,
+    OPTIONS: options,
+  },
+  "/api/admin/provider-reconciliation/run": {
+    POST: handleProviderReconciliationRun,
+    OPTIONS: options,
+  },
   "/api/admin/revenue-share/report": {
     GET: handleRevenueShareReport,
     OPTIONS: options,

package/server/buildManifest.ts

@@ -0,0 +1,54 @@
+import { readFileSync } from "node:fs";
+
+import { resolvePublicPath } from "./publicPaths";
+
+export type NoloBuildManifest = {
+  basePath: string | null;
+  timestamp: string | null;
+  buildSha: string | null;
+  buildTime: string | null;
+};
+
+export const EMPTY_BUILD_MANIFEST: NoloBuildManifest = {
+  basePath: null,
+  timestamp: null,
+  buildSha: null,
+  buildTime: null,
+};
+
+const readOptionalString = (value: unknown): string | null =>
+  typeof value === "string" && value.trim().length > 0 ? value : null;
+
+export function parseBuildManifestFromJson(rawValue: string): NoloBuildManifest {
+  try {
+    const parsed = JSON.parse(rawValue);
+    return {
+      basePath: readOptionalString(parsed?.basePath),
+      timestamp: readOptionalString(parsed?.timestamp),
+      buildSha: readOptionalString(parsed?.buildSha),
+      buildTime: readOptionalString(parsed?.buildTime),
+    };
+  } catch {
+    return EMPTY_BUILD_MANIFEST;
+  }
+}
+
+export function readBuildManifestSync(): NoloBuildManifest {
+  try {
+    return parseBuildManifestFromJson(
+      readFileSync(resolvePublicPath("latest-assets.json"), "utf8")
+    );
+  } catch {
+    return EMPTY_BUILD_MANIFEST;
+  }
+}
+
+export async function readBuildManifest(): Promise<NoloBuildManifest> {
+  try {
+    return parseBuildManifestFromJson(
+      await Bun.file(resolvePublicPath("latest-assets.json")).text()
+    );
+  } catch {
+    return EMPTY_BUILD_MANIFEST;
+  }
+}

package/server/coreReadiness.ts

@@ -1,13 +1,18 @@
-import { withServiceHeaders } from "./coreHeaders";
-import { getCoreRuntimeSnapshot } from "./coreRuntime";
-
-export function handleCoreReady(_req: Request) {
-  const snapshot = getCoreRuntimeSnapshot();
-  const body = {
-    ok: snapshot.ready,
-    ready: snapshot.ready,
-    status: snapshot.status,
-  };
+import { withServiceHeaders } from "./coreHeaders";
+import { readBuildManifestSync } from "./buildManifest";
+import { getCoreRuntimeSnapshot } from "./coreRuntime";
+
+export function handleCoreReady(_req: Request) {
+  const snapshot = getCoreRuntimeSnapshot();
+  const buildManifest = readBuildManifestSync();
+  const body = {
+    ok: snapshot.ready,
+    ready: snapshot.ready,
+    status: snapshot.status,
+    role: snapshot.role,
+    buildSha: buildManifest.buildSha,
+    buildTime: buildManifest.buildTime,
+  };
 
   return withServiceHeaders(
     Response.json(body, {
@@ -21,19 +26,23 @@ export function handleCoreReady(_req: Request) {
   );
 }
 
-export function handleCoreMeta(_req: Request) {
-  const snapshot = getCoreRuntimeSnapshot();
-
-  return withServiceHeaders(
-    Response.json({
-      service: "core",
-      status: snapshot.status,
-      ready: snapshot.ready,
-    }),
-    {
-      service: "core",
-      owner: "core-route",
-      routeKind: "core",
-    }
-  );
+export function handleCoreMeta(_req: Request) {
+  const snapshot = getCoreRuntimeSnapshot();
+  const buildManifest = readBuildManifestSync();
+
+  return withServiceHeaders(
+    Response.json({
+      service: "core",
+      status: snapshot.status,
+      ready: snapshot.ready,
+      role: snapshot.role,
+      buildSha: buildManifest.buildSha,
+      buildTime: buildManifest.buildTime,
+    }),
+    {
+      service: "core",
+      owner: "core-route",
+      routeKind: "core",
+    }
+  );
 }

package/server/coreRuntime.ts

@@ -26,22 +26,27 @@ import {
   startCryptoUsdtTronWatcher,
   stopCryptoUsdtTronWatcher,
 } from "./payments/crypto/cryptoUsdtTronWatcher";
-
-type CoreRuntimeStatus = "idle" | "starting" | "ready" | "stopping";
+import { resolveRuntimeRole, shouldRunBackgroundWorkers } from "./runtimeRole";
+
+type CoreRuntimeStatus = "idle" | "starting" | "ready" | "stopping";
 
 let status: CoreRuntimeStatus = "idle";
 let startPromise: Promise<void> | null = null;
 let stopPromise: Promise<void> | null = null;
 
+const getRuntimeRole = () => resolveRuntimeRole(process.env);
+
 const backgroundWorkersDisabled = () =>
-  process.env.NOLO_DISABLE_BACKGROUND_WORKERS === "1";
-
-export function getCoreRuntimeSnapshot() {
-  return {
-    status,
-    ready: status === "ready",
-  };
-}
+  process.env.NOLO_DISABLE_BACKGROUND_WORKERS === "1" ||
+  !shouldRunBackgroundWorkers(getRuntimeRole());
+
+export function getCoreRuntimeSnapshot() {
+  return {
+    status,
+    ready: status === "ready",
+    role: getRuntimeRole(),
+  };
+}
 
 export async function startCoreRuntime() {
   if (startPromise) return startPromise;

package/server/handlers/activityStatsHandler.ts

@@ -4,13 +4,15 @@
 //
 // GET /api/admin/activity-stats?days=30
 
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 
 const CORS = {
     "Access-Control-Allow-Origin": "*",
     "Content-Type": "application/json",
 };
 
+const getActivityStatsStore = () => getServerAuthorityStore();
+
 export async function handleActivityStats(req: Request): Promise<Response> {
     if (req.method === "OPTIONS") return new Response(null, { status: 204, headers: CORS });
 
@@ -27,8 +29,9 @@ export async function handleActivityStats(req: Request): Promise<Response> {
     let skipped = 0;
 
     try {
+        const store = getActivityStatsStore();
         // 扫描所有以 "token-" 开头但不是 "token-stats-" 的记录
-        const iter = serverDb.iterator({
+        const iter = store.iterator({
             gte: "token-",
             lte: "token-\uffff",
         });