nolo-cli 0.1.26 → 0.1.29

package/auth/routes.ts

@@ -0,0 +1,127 @@
+// auth/routes.ts
+import { API_VERSION } from "../database/config";
+
+export interface RouteParams {
+  userId?: string;
+}
+
+export const authRoutes = {
+  login: {
+    path: `${API_VERSION}/users/login`,
+    method: "POST" as const,
+    createPath: () => `${API_VERSION}/users/login`,
+  },
+  signup: {
+    path: `${API_VERSION}/users/signup`,
+    method: "POST" as const,
+    createPath: () => `${API_VERSION}/users/signup`,
+  },
+  users: {
+    cliLoginStart: {
+      path: `${API_VERSION}/users/cli-login/start`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/cli-login/start`,
+    },
+    cliLoginAuthorize: {
+      path: `${API_VERSION}/users/cli-login/authorize`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/cli-login/authorize`,
+    },
+    cliLoginPoll: {
+      path: `${API_VERSION}/users/cli-login/poll`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/cli-login/poll`,
+    },
+    list: {
+      path: `${API_VERSION}/users`,
+      method: "GET" as const,
+      createPath: () => `${API_VERSION}/users`,
+    },
+    detail: {
+      path: `${API_VERSION}/users/:userId`,
+      method: "GET" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}`,
+    },
+    sessionRevoke: {
+      path: `${API_VERSION}/users/session-revoke`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/session-revoke`,
+    },
+    transfer: {
+      path: `${API_VERSION}/users/:userId/transfer`,
+      method: "POST" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}/transfer`,
+    },
+    delete: {
+      path: `${API_VERSION}/users/:userId`,
+      method: "DELETE" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}`,
+    },
+    disable: {
+      path: `${API_VERSION}/users/:userId/disable`,
+      method: "POST" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}/disable`,
+    },
+    enable: {
+      path: `${API_VERSION}/users/:userId/enable`,
+      method: "POST" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}/enable`,
+    },
+    sendEmail: {
+      path: `${API_VERSION}/users/send-email`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/send-email`,
+    },
+    emailPreferencesGet: {
+      path: `${API_VERSION}/users/email-preferences`,
+      method: "GET" as const,
+      createPath: () => `${API_VERSION}/users/email-preferences`,
+    },
+    emailPreferencesUpdate: {
+      path: `${API_VERSION}/users/email-preferences`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/email-preferences`,
+    },
+    emailReport: {
+      path: `${API_VERSION}/users/email-report`,
+      method: "GET" as const,
+      createPath: () => `${API_VERSION}/users/email-report`,
+    },
+    emailRetryRun: {
+      path: `${API_VERSION}/users/email-retry/run`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/email-retry/run`,
+    },
+    emailReplayFailures: {
+      path: `${API_VERSION}/users/email-replay-failures`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/email-replay-failures`,
+    },
+    emailConfigGet: {
+      path: `${API_VERSION}/users/email-config`,
+      method: "GET" as const,
+      createPath: () => `${API_VERSION}/users/email-config`,
+    },
+    emailConfigUpdate: {
+      path: `${API_VERSION}/users/email-config`,
+      method: "POST" as const,
+      createPath: () => `${API_VERSION}/users/email-config`,
+    },
+    rechargeHistory: {
+      path: `${API_VERSION}/users/:userId/recharge-history`,
+      method: "POST" as const,
+      createPath: (params: RouteParams) =>
+        `${API_VERSION}/users/${params.userId}/recharge-history`,
+    },
+  },
+} as const;
+
+// 简单的路径匹配器，只处理基本的参数提取
+export function createPathMatcher(routePath: string) {
+  return new RegExp(`^${routePath.replace(/:(\w+)/g, "([^/]+)")}$`);
+}

package/auth/server/accessActivity.ts

@@ -0,0 +1,143 @@
+import { DB_PREFIX } from "../../database/keys";
+import serverDb from "../../database/server/db";
+
+import { balanceLockManager } from "./locks";
+
+export type AccessActivitySource = "login" | "token";
+
+export interface RecentAccessEntry {
+  timestamp: number;
+  source: AccessActivitySource;
+  ip: string;
+  device: string;
+}
+
+const MAX_RECENT_ACCESSES = 8;
+
+const normalizeIp = (ip?: string | null) => (ip || "").trim();
+
+export const maskIpAddress = (ip?: string | null): string => {
+  const normalized = normalizeIp(ip);
+  if (!normalized) return "Unknown IP";
+
+  if (normalized.includes(":")) {
+    const segments = normalized.split(":").filter(Boolean);
+    if (segments.length === 0) return "Unknown IP";
+    return `${segments.slice(0, 3).join(":")}:*`;
+  }
+
+  const parts = normalized.split(".");
+  if (parts.length !== 4) return normalized;
+  return `${parts[0]}.${parts[1]}.${parts[2]}.*`;
+};
+
+export const summarizeUserAgent = (userAgent?: string | null): string => {
+  const ua = (userAgent || "").toLowerCase();
+  if (!ua) return "Unknown device";
+
+  const platform = ua.includes("iphone")
+    ? "iPhone"
+    : ua.includes("ipad")
+      ? "iPad"
+      : ua.includes("android")
+        ? "Android"
+        : ua.includes("mac os x")
+          ? "Mac"
+          : ua.includes("windows")
+            ? "Windows"
+            : ua.includes("linux")
+              ? "Linux"
+              : "Unknown device";
+
+  const browser = ua.includes("edg/")
+    ? "Edge"
+    : ua.includes("chrome/")
+      ? "Chrome"
+      : ua.includes("firefox/")
+        ? "Firefox"
+        : ua.includes("safari/") && !ua.includes("chrome/")
+          ? "Safari"
+          : ua.includes("bun/")
+            ? "Bun"
+            : ua.includes("nolo")
+              ? "Nolo"
+              : "Browser";
+
+  return `${platform} · ${browser}`;
+};
+
+export const mergeRecentAccesses = (
+  existing: unknown,
+  entry: RecentAccessEntry,
+  replaceWithinMs = 0
+): RecentAccessEntry[] => {
+  const list = Array.isArray(existing)
+    ? existing.filter(
+      (item): item is RecentAccessEntry =>
+        !!item &&
+        typeof item === "object" &&
+        typeof (item as RecentAccessEntry).timestamp === "number" &&
+        typeof (item as RecentAccessEntry).source === "string" &&
+        typeof (item as RecentAccessEntry).ip === "string" &&
+        typeof (item as RecentAccessEntry).device === "string"
+    )
+    : [];
+
+  const [latest, ...rest] = list;
+  const shouldReplaceLatest =
+    !!latest &&
+    replaceWithinMs > 0 &&
+    entry.timestamp - latest.timestamp < replaceWithinMs &&
+    latest.source === entry.source &&
+    latest.ip === entry.ip &&
+    latest.device === entry.device;
+
+  if (shouldReplaceLatest) {
+    return [{ ...latest, timestamp: entry.timestamp }, ...rest].slice(
+      0,
+      MAX_RECENT_ACCESSES
+    );
+  }
+
+  return [entry, ...list].slice(0, MAX_RECENT_ACCESSES);
+};
+
+export async function recordUserAccessActivity(
+  userId: string,
+  options: {
+    source: AccessActivitySource;
+    ip?: string | null;
+    userAgent?: string | null;
+    timestamp?: number;
+    replaceWithinMs?: number;
+    updateLastLoginAt?: boolean;
+    updateLastActiveAt?: boolean;
+  }
+) {
+  const timestamp = options.timestamp ?? Date.now();
+  const key = `${DB_PREFIX.USER}${userId}`;
+  const lock = balanceLockManager.getLock(userId);
+
+  await lock.runExclusive(async () => {
+    const user = await serverDb.get(key).catch(() => null);
+    if (!user) return;
+
+    const entry: RecentAccessEntry = {
+      timestamp,
+      source: options.source,
+      ip: maskIpAddress(options.ip),
+      device: summarizeUserAgent(options.userAgent),
+    };
+
+    await serverDb.put(key, {
+      ...user,
+      ...(options.updateLastActiveAt ? { lastActiveAt: timestamp } : {}),
+      ...(options.updateLastLoginAt ? { lastLoginAt: timestamp } : {}),
+      recentAccesses: mergeRecentAccesses(
+        user.recentAccesses,
+        entry,
+        options.replaceWithinMs ?? 0
+      ),
+    });
+  });
+}

package/auth/server/billingFullChainSimulator.ts

@@ -0,0 +1,325 @@
+import { nolotusId } from "../../core/init";
+import { DB_PREFIX } from "../../database/keys";
+
+import { auditBillingLedger } from "./ledgerAudit";
+import { convertCreatorEarningToCredits } from "./creatorEarningCreditConversion";
+import {
+  creatorEarningEntryKeyPrefix,
+  type CreatorEarningEntry,
+} from "./creatorEarningsLedger";
+import {
+  creatorEarningStatusProjectionKey,
+  prepareCreatorEarningStatusTransition,
+} from "./creatorSettlementLedger";
+import { buildCreatorSettlementReport } from "./creatorSettlementReport";
+import { buildCreatorProductSplitPolicy } from "./creatorSplitConfig";
+import {
+  productKey,
+  type ProductKind,
+  type ProductRecord,
+} from "./productEntitlements";
+import { purchaseProduct } from "./productPurchase";
+import { buildRevenueShareReport } from "./revenueShareReport";
+import type { BillingLedgerRuntime } from "./ledger";
+
+type StoreOperation = { type: "put"; key: string; value: unknown };
+
+export type BillingFullChainSimulationOptions = {
+  buyerUserId?: string;
+  creatorUserId?: string;
+  productId?: string;
+  productKind?: ProductKind;
+  buyerStartingCredits?: number;
+  creatorStartingCredits?: number;
+  grossCredits?: number;
+  creatorShareRatio?: number;
+  platformCostCredits?: number;
+  nowMs?: number;
+  runtime?: BillingLedgerRuntime;
+};
+
+export type BillingFullChainSimulationResult = {
+  success: boolean;
+  runtime: BillingLedgerRuntime;
+  buyer: {
+    userId: string;
+    startingCredits: number;
+    endingCredits: number;
+  };
+  creator: {
+    userId: string;
+    startingCredits: number;
+    endingCredits: number;
+    spendableCreditsAdded: number;
+  };
+  product: {
+    productId: string;
+    kind: ProductKind;
+    grossCredits: number;
+    creatorShareRatio: number;
+    platformCostCredits: number;
+  };
+  purchase: {
+    status: string;
+    txId?: string;
+  };
+  earning: {
+    entryId: string;
+    creatorUserId: string;
+    amountCredits: number;
+    currentStatus: string;
+  };
+  conversion: {
+    status: string;
+    txId?: string;
+    amountCredits?: number;
+  };
+  revenueShare: Awaited<ReturnType<typeof buildRevenueShareReport>> & {
+    reconciliation: {
+      deltaCredits: number;
+    };
+  };
+  creatorSettlement: Awaited<ReturnType<typeof buildCreatorSettlementReport>>;
+  audit: Awaited<ReturnType<typeof auditBillingLedger>>;
+};
+
+class BillingSimulationMemoryStore {
+  readonly data = new Map<string, unknown>();
+
+  async get(key: string) {
+    return this.data.get(key) ?? null;
+  }
+
+  async batch(ops: StoreOperation[]) {
+    for (const op of ops) {
+      this.data.set(op.key, op.value);
+    }
+  }
+
+  async *iterator(options: { gte?: string; lte?: string; reverse?: boolean } = {}) {
+    const entries = Array.from(this.data.entries()).sort(([a], [b]) =>
+      a.localeCompare(b)
+    );
+    if (options.reverse) entries.reverse();
+    for (const [key, value] of entries) {
+      if (options.gte && key < options.gte) continue;
+      if (options.lte && key > options.lte) continue;
+      yield [key, value] as [string, unknown];
+    }
+  }
+}
+
+const defaultRuntime: BillingLedgerRuntime = {
+  clusterId: "main",
+  nodeId: "billing-simulator",
+  role: "leader",
+  balanceAuthorityClusterId: "main",
+  isAuthoritativeBalance: true,
+};
+
+const roundCredits = (value: number) =>
+  Math.round(Number(value || 0) * 1_000_000) / 1_000_000;
+
+const seedUser = (
+  store: BillingSimulationMemoryStore,
+  userId: string,
+  balance: number
+) => {
+  store.data.set(`${DB_PREFIX.USER}${userId}`, {
+    userId,
+    publicKey: `sim-${userId}`,
+    balance,
+  });
+};
+
+const scanCreatorEarnings = (
+  store: BillingSimulationMemoryStore,
+  clusterId: string
+) =>
+  Array.from(store.data.entries())
+    .filter(([key]) => key.startsWith(creatorEarningEntryKeyPrefix(clusterId)))
+    .map(([, value]) => value as CreatorEarningEntry)
+    .sort((a, b) => a.createdAt - b.createdAt || a.entryId.localeCompare(b.entryId));
+
+export async function runBillingFullChainSimulation({
+  buyerUserId = "sim-buyer",
+  creatorUserId = "sim-creator",
+  productId = "sim-product-creator-split",
+  productKind = "agent",
+  buyerStartingCredits = 50,
+  creatorStartingCredits = 0,
+  grossCredits = 10,
+  creatorShareRatio = 0.7,
+  platformCostCredits = 1,
+  nowMs = Date.now(),
+  runtime = defaultRuntime,
+}: BillingFullChainSimulationOptions = {}): Promise<BillingFullChainSimulationResult> {
+  const store = new BillingSimulationMemoryStore();
+  const productPolicy = buildCreatorProductSplitPolicy({
+    policyId: "sim-creator-split",
+    policyVersion: 1,
+    label: "Simulator creator split",
+    creatorUserId,
+    creatorShareRatio,
+    platformCostCredits,
+  });
+  if (productPolicy.status !== "built") {
+    throw new Error(productPolicy.error);
+  }
+
+  seedUser(store, buyerUserId, buyerStartingCredits);
+  seedUser(store, creatorUserId, creatorStartingCredits);
+
+  const product: ProductRecord = {
+    dbKey: productKey(productId),
+    productId,
+    kind: productKind,
+    status: "active",
+    ownerUserId: creatorUserId,
+    title: "Simulator Creator Product",
+    source: { type: "manual", id: productId },
+    pricing: { currency: "credits", amountCredits: grossCredits },
+    splitPolicy: productPolicy.policy,
+    createdAt: nowMs,
+    updatedAt: nowMs,
+  };
+  store.data.set(product.dbKey, product);
+
+  const purchaseTxId = `sim-product-purchase-${buyerUserId}-${productId}`;
+  const purchase = await purchaseProduct({
+    store,
+    runtime,
+    buyerId: buyerUserId,
+    productId,
+    txId: purchaseTxId,
+    nowMs,
+  });
+  if (!purchase.success) {
+    throw new Error("error" in purchase ? purchase.error : "Purchase failed");
+  }
+  if (purchase.status !== "purchased") {
+    throw new Error(`Unexpected purchase status ${purchase.status}`);
+  }
+
+  const earning = scanCreatorEarnings(store, runtime.clusterId)[0];
+  if (!earning) {
+    throw new Error("Simulator did not produce a creator earning entry");
+  }
+
+  const availableTransition = await prepareCreatorEarningStatusTransition({
+    store,
+    runtime,
+    entry: earning,
+    toStatus: "available",
+    idempotencyKey: `simulator:${earning.entryId}:available`,
+    reason: "billing_full_chain_simulation_release",
+    reviewedByUserId: "billing-simulator",
+    eventId: `sim-settlement-available-${earning.entryId}`,
+    nowMs: nowMs + 1,
+  });
+  if (availableTransition.status !== "prepared") {
+    throw new Error(`Available transition failed: ${availableTransition.status}`);
+  }
+  await store.batch(availableTransition.operations);
+
+  const conversion = await convertCreatorEarningToCredits({
+    store,
+    runtime,
+    creatorUserId,
+    entryId: earning.entryId,
+    reviewedByUserId: "billing-simulator",
+    txId: `sim-creator-credit-${earning.entryId}`,
+    settlementEventId: `sim-settlement-credit-${earning.entryId}`,
+    nowMs: nowMs + 2,
+  });
+  if (!conversion.success) {
+    throw new Error(
+      "error" in conversion ? conversion.error : "Creator credit conversion failed"
+    );
+  }
+
+  const sinceMs = nowMs - 1;
+  const untilMs = nowMs + 10;
+  const revenueShare = await buildRevenueShareReport({
+    store,
+    clusterId: runtime.clusterId,
+    sinceMs,
+    untilMs,
+    nowMs: nowMs + 3,
+  });
+  const revenueDelta = roundCredits(
+    revenueShare.summary.grossCredits -
+      revenueShare.summary.platformCostCredits -
+      revenueShare.summary.creatorShareCredits -
+      revenueShare.summary.platformNetCredits
+  );
+  const creatorSettlement = await buildCreatorSettlementReport({
+    store,
+    clusterId: runtime.clusterId,
+    sinceMs,
+    untilMs,
+    nowMs: nowMs + 3,
+  });
+  const audit = await auditBillingLedger({
+    store,
+    runtime,
+    legacySinceMs: null,
+  });
+  const creatorUser = (await store.get(`${DB_PREFIX.USER}${creatorUserId}`)) as
+    | { balance?: number }
+    | null;
+  const buyerUser = (await store.get(`${DB_PREFIX.USER}${buyerUserId}`)) as
+    | { balance?: number }
+    | null;
+  const statusProjection = (await store.get(
+    creatorEarningStatusProjectionKey(runtime.clusterId, earning.entryId)
+  )) as { currentStatus?: string } | null;
+
+  return {
+    success: true,
+    runtime,
+    buyer: {
+      userId: buyerUserId,
+      startingCredits: buyerStartingCredits,
+      endingCredits: roundCredits(buyerUser?.balance ?? 0),
+    },
+    creator: {
+      userId: creatorUserId,
+      startingCredits: creatorStartingCredits,
+      endingCredits: roundCredits(creatorUser?.balance ?? 0),
+      spendableCreditsAdded: roundCredits(
+        (creatorUser?.balance ?? 0) - creatorStartingCredits
+      ),
+    },
+    product: {
+      productId,
+      kind: productKind,
+      grossCredits: roundCredits(grossCredits),
+      creatorShareRatio,
+      platformCostCredits: roundCredits(platformCostCredits),
+    },
+    purchase: {
+      status: purchase.status,
+      txId: purchase.txId,
+    },
+    earning: {
+      entryId: earning.entryId,
+      creatorUserId: earning.creatorUserId,
+      amountCredits: earning.amountCredits,
+      currentStatus: statusProjection?.currentStatus ?? earning.status,
+    },
+    conversion: {
+      status: conversion.status,
+      txId: conversion.txId,
+      amountCredits: conversion.amountCredits,
+    },
+    revenueShare: {
+      ...revenueShare,
+      reconciliation: {
+        deltaCredits: revenueDelta,
+      },
+    },
+    creatorSettlement,
+    audit,
+  };
+}