nolo-cli 0.1.29 → 0.1.31

package/auth/server/billingAnomalies.ts

@@ -0,0 +1,235 @@
+import {
+  createBillingAdminAuditEvent,
+  type BillingAdminAuditAction,
+} from "../../ai/token/billingAdminAuditEvent";
+import { writeBillingAdminAuditEvent } from "../../ai/token/billingAdminAuditEventWriter";
+import type { BillingAnomalyStatus } from "../../ai/token/billingAnomaly";
+import { createBillingAnomalyLifecycleEvent } from "../../ai/token/billingAnomalyLifecycle";
+import { writeBillingAnomalyLifecycleEvent } from "../../ai/token/billingAnomalyLifecycleWriter";
+import { buildProviderBillingAnomalyDrilldown } from "../../ai/token/providerBillingAnomalyDrilldown";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { ulid } from "ulid";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+} from "./shared";
+import { canManageUsageReportAccess } from "./usageManagementAccess";
+
+const serverDb = getServerAuthorityStore();
+
+const parseStatus = (value: unknown): BillingAnomalyStatus | undefined => {
+  if (
+    value === "open" ||
+    value === "acknowledged" ||
+    value === "resolved" ||
+    value === "ignored"
+  ) {
+    return value;
+  }
+  return undefined;
+};
+
+const parseAuditAction = (value: unknown): BillingAdminAuditAction | undefined => {
+  if (
+    value === "dry_run_viewed" ||
+    value === "plan_marked_reviewed" ||
+    value === "plan_abandoned"
+  ) {
+    return value;
+  }
+  return undefined;
+};
+
+const parseLimit = (value: string | null) => {
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) return 50;
+  return Math.min(Math.max(Math.floor(parsed), 1), 200);
+};
+
+type BillingAnomalyLifecycleDeps = {
+  store?: Parameters<typeof writeBillingAnomalyLifecycleEvent>[0]["store"];
+  canManage?: (userId?: string | null) => Promise<boolean>;
+  now?: () => string;
+  createEventId?: () => string;
+};
+
+export async function handleUpdateBillingAnomalyLifecycle(
+  req: Request,
+  deps: BillingAnomalyLifecycleDeps = {}
+) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  const canManage = deps.canManage ?? canManageUsageReportAccess;
+  if (!(await canManage(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = (await req.json()) as Record<string, unknown>;
+  } catch {
+    return createErrorResponse("Invalid JSON body", 400);
+  }
+
+  const anomalyId =
+    typeof body.anomalyId === "string" ? body.anomalyId.trim() : "";
+  if (!anomalyId) return createErrorResponse("anomalyId is required", 400);
+
+  const status = parseStatus(body.status);
+  if (!status) {
+    return createErrorResponse(
+      "status must be open, acknowledged, resolved, or ignored",
+      400
+    );
+  }
+
+  const now = deps.now?.() ?? new Date().toISOString();
+  const event = createBillingAnomalyLifecycleEvent({
+    anomalyId,
+    eventId:
+      typeof body.eventId === "string" && body.eventId.trim()
+        ? body.eventId.trim()
+        : deps.createEventId?.() ?? `evt_${ulid()}`,
+    status,
+    createdAt: now,
+    actorId: actionUserId,
+    reason: typeof body.reason === "string" ? body.reason : undefined,
+  });
+
+  try {
+    const result = await writeBillingAnomalyLifecycleEvent({
+      store: deps.store ?? serverDb,
+      event,
+    });
+    return createSuccessResponse({
+      success: true,
+      key: result.key,
+      event: {
+        anomalyId: event.anomalyId,
+        eventId: event.eventId,
+        status: event.status,
+        createdAt: event.createdAt,
+        actorId: event.actorId,
+      },
+    });
+  } catch {
+    return createErrorResponse("Internal server error");
+  }
+}
+
+type BillingAnomalyDrilldownDeps = {
+  store?: Parameters<typeof buildProviderBillingAnomalyDrilldown>[0]["store"];
+  canManage?: (userId?: string | null) => Promise<boolean>;
+};
+
+export async function handleGetBillingAnomalyDrilldown(
+  req: Request,
+  deps: BillingAnomalyDrilldownDeps = {}
+) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  const canManage = deps.canManage ?? canManageUsageReportAccess;
+  if (!(await canManage(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  try {
+    const url = new URL(req.url);
+    const anomalyId = url.searchParams.get("anomalyId")?.trim();
+    if (!anomalyId) {
+      return createErrorResponse("Missing anomalyId", 400);
+    }
+    const drilldown = await buildProviderBillingAnomalyDrilldown({
+      store: deps.store ?? serverDb,
+      anomalyId,
+      limit: parseLimit(url.searchParams.get("limit")),
+    });
+    return createSuccessResponse({ success: true, drilldown });
+  } catch (error) {
+    if (
+      error instanceof Error &&
+      error.message.startsWith("billing anomaly not found:")
+    ) {
+      return createErrorResponse("Billing anomaly not found", 404);
+    }
+    return createErrorResponse("Internal server error");
+  }
+}
+
+type BillingAdminAuditDeps = {
+  store?: Parameters<typeof writeBillingAdminAuditEvent>[0]["store"];
+  canManage?: (userId?: string | null) => Promise<boolean>;
+  now?: () => string;
+  createEventId?: () => string;
+};
+
+export async function handleCreateBillingAdminAuditEvent(
+  req: Request,
+  deps: BillingAdminAuditDeps = {}
+) {
+  if (req.method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+
+  const { userId: actionUserId } = req.user;
+  const canManage = deps.canManage ?? canManageUsageReportAccess;
+  if (!(await canManage(actionUserId))) {
+    return createErrorResponse("Unauthorized: Usage management access required", 403);
+  }
+
+  let body: Record<string, unknown>;
+  try {
+    body = (await req.json()) as Record<string, unknown>;
+  } catch {
+    return createErrorResponse("Invalid JSON body", 400);
+  }
+  const action = parseAuditAction(body.action);
+  if (!action) {
+    return createErrorResponse(
+      "action must be dry_run_viewed, plan_marked_reviewed, or plan_abandoned",
+      400
+    );
+  }
+  const event = createBillingAdminAuditEvent({
+    eventId:
+      typeof body.eventId === "string" && body.eventId.trim()
+        ? body.eventId.trim()
+        : deps.createEventId?.() ?? `evt_${ulid()}`,
+    actorId: actionUserId,
+    action,
+    anomalyId: typeof body.anomalyId === "string" ? body.anomalyId : "",
+    planId: typeof body.planId === "string" ? body.planId : "",
+    inputSetHash: typeof body.inputSetHash === "string" ? body.inputSetHash : "",
+    createdAt: deps.now?.() ?? new Date().toISOString(),
+    reason: typeof body.reason === "string" ? body.reason : undefined,
+  });
+
+  try {
+    const result = await writeBillingAdminAuditEvent({
+      store: deps.store ?? serverDb,
+      event,
+    });
+    return createSuccessResponse({
+      success: true,
+      key: result.key,
+      event: {
+        eventId: event.eventId,
+        actorId: event.actorId,
+        action: event.action,
+        anomalyId: event.anomalyId,
+        planId: event.planId,
+        inputSetHash: event.inputSetHash,
+        createdAt: event.createdAt,
+      },
+    });
+  } catch {
+    return createErrorResponse("Internal server error");
+  }
+}

package/auth/server/billingUsageReport.ts

@@ -19,20 +19,31 @@ export type BillingUsageReport = {
     titleCostRatio: number;
     inputTokens: number;
     outputTokens: number;
+    cacheCreationInputTokens: number;
+    cacheReadInputTokens: number;
   };
   byCybot: BillingUsageGroup[];
+  byUser: BillingUsageGroup[];
+  byDialog: BillingUsageGroup[];
   byModel: BillingUsageGroup[];
   byProvider: BillingUsageGroup[];
+  byDay: BillingUsageGroup[];
 };
 
 export type BillingUsageGroup = {
   cybotId?: string;
+  userId?: string;
+  username?: string;
+  dialogId?: string;
   model?: string;
   provider?: string;
+  dateKey?: string;
   count: number;
   cost: number;
   inputTokens: number;
   outputTokens: number;
+  cacheCreationInputTokens: number;
+  cacheReadInputTokens: number;
   costRatio: number;
 };
 
@@ -40,11 +51,15 @@ type TokenRecord = {
   type?: string;
   userId?: string;
   cybotId?: string;
+  dialogId?: string;
   provider?: string;
   model?: string;
   input_tokens?: number;
   output_tokens?: number;
+  cache_creation_input_tokens?: number;
+  cache_read_input_tokens?: number;
   cost?: number;
+  dateKey?: string;
   timestamp?: number;
   createdAt?: string;
 };
@@ -85,6 +100,8 @@ const createAccumulator = () => ({
   cost: 0,
   inputTokens: 0,
   outputTokens: 0,
+  cacheCreationInputTokens: 0,
+  cacheReadInputTokens: 0,
 });
 
 type Accumulator = ReturnType<typeof createAccumulator>;
@@ -94,6 +111,8 @@ const addToAccumulator = (acc: Accumulator, record: TokenRecord) => {
   acc.cost += toFiniteNumber(record.cost);
   acc.inputTokens += toFiniteNumber(record.input_tokens);
   acc.outputTokens += toFiniteNumber(record.output_tokens);
+  acc.cacheCreationInputTokens += toFiniteNumber(record.cache_creation_input_tokens);
+  acc.cacheReadInputTokens += toFiniteNumber(record.cache_read_input_tokens);
 };
 
 const addGroupedRecord = (
@@ -107,7 +126,7 @@ const addGroupedRecord = (
 };
 
 const formatGroup = (
-  keyName: "cybotId" | "model" | "provider",
+  keyName: "cybotId" | "userId" | "dialogId" | "model" | "provider" | "dateKey",
   totalCost: number,
   [key, acc]: [string, Accumulator]
 ): BillingUsageGroup => ({
@@ -116,11 +135,13 @@ const formatGroup = (
   cost: roundMetric(acc.cost),
   inputTokens: acc.inputTokens,
   outputTokens: acc.outputTokens,
+  cacheCreationInputTokens: acc.cacheCreationInputTokens,
+  cacheReadInputTokens: acc.cacheReadInputTokens,
   costRatio: totalCost > 0 ? roundMetric(acc.cost / totalCost) : 0,
 });
 
 const sortedGroups = (
-  keyName: "cybotId" | "model" | "provider",
+  keyName: "cybotId" | "userId" | "dialogId" | "model" | "provider" | "dateKey",
   totalCost: number,
   groups: Map<string, Accumulator>
 ) =>
@@ -136,8 +157,11 @@ export async function buildBillingUsageReport(args: {
 }): Promise<BillingUsageReport> {
   const totals = createAccumulator();
   const byCybot = new Map<string, Accumulator>();
+  const byUser = new Map<string, Accumulator>();
+  const byDialog = new Map<string, Accumulator>();
   const byModel = new Map<string, Accumulator>();
   const byProvider = new Map<string, Accumulator>();
+  const byDay = new Map<string, Accumulator>();
   let recordsScanned = 0;
   let titleCost = 0;
   let titleCount = 0;
@@ -157,11 +181,19 @@ export async function buildBillingUsageReport(args: {
     addToAccumulator(totals, value);
 
     const cybotId = value.cybotId || "unknown";
+    const userId = value.userId || "unknown";
+    const dialogId = value.dialogId || "unknown";
     const model = value.model || "unknown";
     const provider = value.provider || "unknown";
+    const dateKey =
+      value.dateKey ||
+      (timestamp == null ? "unknown" : new Date(timestamp).toISOString().slice(0, 10));
     addGroupedRecord(byCybot, cybotId, value);
+    addGroupedRecord(byUser, userId, value);
+    addGroupedRecord(byDialog, dialogId, value);
     addGroupedRecord(byModel, model, value);
     addGroupedRecord(byProvider, provider, value);
+    addGroupedRecord(byDay, dateKey, value);
 
     if (cybotId === TITLE_CYBOT_ID) {
       titleCount += 1;
@@ -184,9 +216,16 @@ export async function buildBillingUsageReport(args: {
       titleCostRatio: totalCost > 0 ? roundMetric(roundedTitleCost / totalCost) : 0,
       inputTokens: totals.inputTokens,
       outputTokens: totals.outputTokens,
+      cacheCreationInputTokens: totals.cacheCreationInputTokens,
+      cacheReadInputTokens: totals.cacheReadInputTokens,
     },
     byCybot: sortedGroups("cybotId", totalCost, byCybot),
+    byUser: sortedGroups("userId", totalCost, byUser),
+    byDialog: sortedGroups("dialogId", totalCost, byDialog),
     byModel: sortedGroups("model", totalCost, byModel),
     byProvider: sortedGroups("provider", totalCost, byProvider),
+    byDay: sortedGroups("dateKey", totalCost, byDay).sort((a, b) =>
+      String(b.dateKey ?? "").localeCompare(String(a.dateKey ?? ""))
+    ),
   };
 }

package/auth/server/creatorEarningCreditConversion.ts

@@ -1,7 +1,8 @@
 import { createHash } from "node:crypto";
 
 import { createTransactionKey, DB_PREFIX } from "../../database/keys";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 import { ulid } from "ulid";
 import { balanceLockManager } from "./locks";
 import { withRetry } from "./utils";
@@ -31,6 +32,13 @@ export type CreatorEarningCreditConversionStore = {
   batch: (ops: StoreOperation[]) => Promise<void>;
 };
 
+const createCreatorEarningCreditConversionStore = (
+  authorityStore = getServerAuthorityStore()
+): CreatorEarningCreditConversionStore => ({
+  get: (key) => authorityStore.get(key),
+  batch: (ops) => writeStoreOps(authorityStore, ops),
+});
+
 type ConversionRecord = {
   kind: "creator_earning_credit_conversion";
   clusterId: string;
@@ -148,7 +156,7 @@ const defaultTxId = (clusterId: string, entryId: string) =>
   `creator-earning-credit-${clusterId}-${safeKeyPart(entryId)}`;
 
 export async function convertCreatorEarningToCredits({
-  store = serverDb,
+  store = createCreatorEarningCreditConversionStore(getServerAuthorityStore()),
   runtime = getBillingLedgerRuntime(),
   creatorUserId,
   entryId,

package/auth/server/deduct.ts

@@ -1,6 +1,7 @@
 // auth/server/deduct.ts
 import { ulid } from "ulid";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { writeStoreOps } from "../../database/server/storeBatchCompat";
 import { createTransactionKey } from "../../database/keys";
 import { logger } from "../server/shared";
 import { balanceLockManager } from "./locks";
@@ -29,6 +30,12 @@ export async function deductUserBalance(
   txId: string = ulid()
 ): Promise<DeductResult> {
   const lock = balanceLockManager.getLock(userId);
+  const store = getServerAuthorityStore();
+  const ledgerStore = {
+    get: (key: string) => store.get(key),
+    batch: (ops: Array<{ type: "put"; key: string; value: unknown }>) =>
+      writeStoreOps(store, ops),
+  };
 
   return await lock.runExclusive(async () => {
     try {
@@ -54,7 +61,7 @@ export async function deductUserBalance(
       let existingTx = null;
 
       try {
-        existingTx = await serverDb.get(txIndexKey);
+        existingTx = await store.get(txIndexKey);
       } catch (err) {
         if (!(err instanceof Error && "notFound" in err)) {
           throw err;
@@ -78,7 +85,7 @@ export async function deductUserBalance(
       let userData = null;
 
       try {
-        userData = await serverDb.get(userKey);
+        userData = await store.get(userKey);
       } catch (err) {
         if (err instanceof Error && "notFound" in err) {
           logger.warn({
@@ -100,7 +107,7 @@ export async function deductUserBalance(
 
       const currentBalance = userData.balance;
       const ledgerAppend = await prepareLedgerTransactionAppend({
-        store: serverDb,
+        store: ledgerStore,
         type: "usage_charge",
         reason,
         idempotencyKey: txId,
@@ -167,7 +174,7 @@ export async function deductUserBalance(
 
       await withRetry(
         async () => {
-          await serverDb.batch([
+          await writeStoreOps(store, [
             ...ledgerAppend.operations,
             {
               type: "put",
@@ -229,7 +236,7 @@ export async function deductUserBalance(
             let txRecord = null;
 
             try {
-              txRecord = await serverDb.get(txKey);
+              txRecord = await store.get(txKey);
             } catch (err) {
               if (!(err instanceof Error && "notFound" in err)) {
                 throw err;
@@ -237,7 +244,7 @@ export async function deductUserBalance(
             }
 
             if (txRecord) {
-              await serverDb.put(txKey, {
+              await store.put(txKey, {
                 ...txRecord,
                 status: "failed",
               });

package/auth/server/delete.ts

@@ -1,6 +1,7 @@
 // 文件: auth/deleteUser.ts
 
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
+import { createStoreBatch } from "../../database/server/storeBatchCompat";
 import { authRoutes } from "../routes";
 import { NOLO_CLUSTER_SERVERS } from "../../database/config";
 
@@ -833,6 +834,13 @@ async function deleteUserRelatedData(
   }
 }
 
+const createDeleteUserDb = (store = getServerAuthorityStore()) => ({
+  get: (key: string) => store.get(key),
+  del: (key: string) => store.del(key),
+  batch: () => createStoreBatch(store),
+  iterator: (options: { gte: string; lte: string }) => store.iterator(options),
+});
+
 export async function deleteUser(
   db: any,
   userId: string,
@@ -856,7 +864,7 @@ export async function deleteUser(
 export async function handleDeleteUser(
   req: Request,
   userId: string,
-  db: any = serverDb
+  db: any = createDeleteUserDb(getServerAuthorityStore())
 ) {
   if (req.method === "OPTIONS") {
     return handleOptionsRequest();

package/auth/server/disable.ts

@@ -1,5 +1,5 @@
 // auth/server/disable.ts
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { DB_PREFIX } from "../../database/keys";
 import {
   createErrorResponse,
@@ -11,10 +11,11 @@ import { balanceLockManager } from "./locks";
 import { notifyAccountStatusChangeEmail } from "./emailScenarioNotifications";
 
 async function disableUser(userId: string) {
+  const store = getServerAuthorityStore();
   const lock = balanceLockManager.getLock(userId);
   await lock.runExclusive(async () => {
     const userKey = `${DB_PREFIX.USER}${userId}`;
-    const userData = await serverDb.get(userKey).catch(() => null);
+    const userData = await store.get(userKey).catch(() => null);
 
     if (!userData) {
       throw new Error("User not found");
@@ -26,7 +27,7 @@ async function disableUser(userId: string) {
       isDisabled: true,
       disabledAt: new Date().toISOString(), // 记录停用时间，可选
     };
-    await serverDb.put(userKey, updatedUserData);
+    await store.put(userKey, updatedUserData);
   });
 }
 

package/auth/server/emailAutomation.ts

@@ -1,5 +1,5 @@
 import { DB_PREFIX } from "../../database/keys";
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { logger } from "./shared";
 import { balanceLockManager } from "./locks";
 import { canSendEmailToUser } from "./emailPolicy";
@@ -34,9 +34,10 @@ let reengagementRunning = false;
 const patchUserRecord = async (userId: string, patch: Record<string, any>) => {
   const key = `${USER_PREFIX}${userId}`;
   const lock = balanceLockManager.getLock(userId);
+  const store = getServerAuthorityStore();
   await lock.runExclusive(async () => {
-    const current = (await serverDb.get(key)) as UserEmailRecord;
-    await serverDb.put(key, { ...current, ...patch });
+    const current = (await store.get(key)) as UserEmailRecord;
+    await store.put(key, { ...current, ...patch });
   });
 };
 
@@ -115,8 +116,9 @@ export async function runReengagementSweep() {
     userId: string;
     user: UserEmailRecord;
   }> = [];
+  const store = getServerAuthorityStore();
 
-  const iter = serverDb.iterator({
+  const iter = store.iterator({
     gt: USER_PREFIX,
     lt: USER_PREFIX + "\xFF",
   });
@@ -295,7 +297,7 @@ export async function runReengagementSweep() {
       }
     }
   } finally {
-    await iter.close();
+    await (iter as any).close?.();
     reengagementRunning = false;
   }
 

package/auth/server/emailDbConfig.ts

@@ -1,4 +1,4 @@
-import serverDb from "../../database/server/db";
+import { getServerAuthorityStore } from "../../database/server/db";
 import { logger } from "./shared";
 
 export const EMAIL_RUNTIME_CONFIG_KEY = "config:email:runtime";
@@ -109,7 +109,9 @@ export async function applyEmailRuntimeConfigFromDb() {
 }
 
 export async function readEmailRuntimeConfigFromDb() {
-  const raw = await serverDb.get(EMAIL_RUNTIME_CONFIG_KEY).catch(() => null);
+  const raw = await getServerAuthorityStore()
+    .get(EMAIL_RUNTIME_CONFIG_KEY)
+    .catch(() => null);
   if (!isRecord(raw)) {
     return null;
   }