nolo-cli 0.1.31 → 0.1.32

package/auth/server/recharge.ts

@@ -1,290 +0,0 @@
-// auth/server/recharge.ts
-import { ulid } from "ulid";
-import { getServerAuthorityStore } from "../../database/server/db";
-import { writeStoreOps } from "../../database/server/storeBatchCompat";
-import { createTransactionKey } from "../../database/keys";
-import { balanceLockManager } from "./locks";
-import { withRetry } from "./utils";
-import pino from "pino";
-import { DB_PREFIX } from "../../database/keys";
-import { notifyRechargeResultEmail } from "./emailScenarioNotifications";
-import { CORE_FLOW_STAGES } from "./emailAutomationTypes";
-import {
-  prepareLedgerTransactionAppend,
-  userAvailableCreditsAccountId,
-} from "./ledger";
-const logger = pino({ name: "recharge" });
-
-interface RechargeResult {
-  success: boolean;
-  balance?: number;
-  error?: string;
-  txId?: string;
-}
-
-interface TransactionRecord {
-  txId: string;
-  toUserId: string;
-  type: "recharge";
-  amount: number;
-  reason: string;
-  timestamp: number;
-  status: "completed" | "failed";
-}
-
-interface UserData {
-  username: string;
-  publicKey: string;
-  locale: string;
-  createdAt: number;
-  email: string;
-  balance: number;
-  balanceUpdatedAt: number;
-  [key: string]: any;
-}
-
-const shouldMarkFirstCoreAction = (reason: string) => {
-  const value = String(reason || "").toLowerCase();
-  if (!value) return false;
-  if (value.includes("bonus")) return false;
-  if (value.includes("invite")) return false;
-  if (value.includes("reward")) return false;
-  return true;
-};
-
-export async function rechargeUserBalance(
-  toUserId: string,
-  amount: number,
-  reason: string = "admin_recharge",
-  txId: string = ulid()
-): Promise<RechargeResult> {
-  const lock = balanceLockManager.getLock(toUserId);
-  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 {
-      const numericAmount = Number(amount);
-
-      if (!numericAmount || isNaN(numericAmount) || numericAmount <= 0) {
-        logger.warn({ toUserId, amount }, "Invalid recharge amount");
-        return { success: false, error: "Invalid amount" };
-      }
-
-      const txIndexKey = createTransactionKey.index(txId);
-      let existingTx = null;
-
-      try {
-        existingTx = await store.get(txIndexKey);
-      } catch (err) {
-        if (!(err instanceof Error && "notFound" in err)) {
-          throw err;
-        }
-      }
-
-      if (existingTx) {
-        logger.warn({ txId, toUserId }, "Duplicate transaction detected");
-        return {
-          success: false,
-          error: "Duplicate transaction",
-          txId,
-        };
-      }
-
-      const userKey = `${DB_PREFIX.USER}${toUserId}`;
-      let userData: UserData | null = null;
-
-      try {
-        userData = await store.get(userKey);
-        logger.debug({ toUserId, userData, userKey }, "Retrieved user data");
-      } catch (err) {
-        if (err instanceof Error && "notFound" in err) {
-          logger.error({ toUserId, userKey }, "User not found");
-          return { success: false, error: "User not found" };
-        }
-        throw err;
-      }
-
-      if (typeof userData?.balance !== "number") {
-        logger.error(
-          { toUserId, userData, userKey },
-          "Invalid user data - balance must be a number"
-        );
-        void notifyRechargeResultEmail({
-          userId: toUserId,
-          amount: numericAmount,
-          reason,
-          success: false,
-          error: "User data invalid",
-        });
-        return { success: false, error: "User data invalid" };
-      }
-
-      const currentBalance = userData.balance;
-      const now = Date.now();
-      const ledgerAppend = await prepareLedgerTransactionAppend({
-        store: ledgerStore,
-        type: "recharge",
-        reason,
-        idempotencyKey: txId,
-        txId,
-        entries: [
-          {
-            accountId: userAvailableCreditsAccountId(toUserId),
-            ownerUserId: toUserId,
-            delta: numericAmount,
-            startingBalance: currentBalance,
-            metadata: { reason },
-          },
-        ],
-        metadata: { legacyTxId: txId },
-        now,
-      });
-      if (ledgerAppend.status === "duplicate") {
-        logger.warn({ txId, toUserId }, "Duplicate ledger transaction detected");
-        return {
-          success: false,
-          error: "Duplicate transaction",
-          txId,
-        };
-      }
-      if (ledgerAppend.status !== "prepared") {
-        logger.warn(
-          { txId, toUserId, status: ledgerAppend.status },
-          "Ledger append rejected"
-        );
-        return { success: false, error: "Ledger append rejected", txId };
-      }
-      const newBalance =
-        ledgerAppend.transaction.entries.find(
-          (entry) => entry.accountId === userAvailableCreditsAccountId(toUserId)
-        )?.balanceAfter ?? currentBalance + numericAmount;
-      const userPatch: UserData = {
-        ...userData,
-        balance: newBalance,
-        balanceUpdatedAt: now,
-      };
-      if (shouldMarkFirstCoreAction(reason) && !Number(userData.firstCoreActionAt || 0)) {
-        userPatch.firstCoreActionAt = now;
-        userPatch.firstCoreActionReason = reason;
-        userPatch.coreFlowStage = CORE_FLOW_STAGES.firstCoreActionCompleted;
-        userPatch.coreFlowStageUpdatedAt = now;
-      }
-
-      const txRecord: TransactionRecord = {
-        txId,
-        toUserId,
-        type: "recharge",
-        amount: numericAmount,
-        reason,
-        timestamp: now,
-        status: "completed",
-      };
-
-      await withRetry(
-        async () => {
-          await writeStoreOps(store, [
-            ...ledgerAppend.operations,
-            {
-              type: "put",
-              key: createTransactionKey.record(toUserId, txId),
-              value: txRecord,
-            },
-            {
-              type: "put",
-              key: txIndexKey,
-              value: {
-                toUserId,
-                timestamp: now,
-              },
-            },
-            {
-              type: "put",
-              key: userKey,
-              value: userPatch,
-            },
-          ]);
-        },
-        {
-          maxAttempts: 3,
-          delayMs: 1000,
-          backoff: true,
-        }
-      );
-
-      logger.info(
-        { toUserId, amount: numericAmount, newBalance, txId },
-        "Recharge completed successfully"
-      );
-      void notifyRechargeResultEmail({
-        userId: toUserId,
-        amount: numericAmount,
-        reason,
-        success: true,
-      });
-
-      return {
-        success: true,
-        balance: newBalance,
-        txId,
-      };
-    } catch (err) {
-      logger.error(
-        { err, toUserId, amount, txId },
-        "Error during recharge process"
-      );
-
-      try {
-        await withRetry(
-          async () => {
-            const txKey = createTransactionKey.record(toUserId, txId);
-            let txRecord: TransactionRecord | null = null;
-
-            try {
-              txRecord = await store.get(txKey);
-            } catch (err) {
-              if (!(err instanceof Error && "notFound" in err)) {
-                throw err;
-              }
-            }
-
-            if (txRecord) {
-              await store.put(txKey, {
-                ...txRecord,
-                status: "failed",
-              });
-            }
-          },
-          {
-            maxAttempts: 2,
-            delayMs: 500,
-            backoff: true,
-          }
-        );
-      } catch (updateError) {
-        logger.error(
-          { updateError, toUserId, txId },
-          "Failed to update transaction status"
-        );
-      }
-
-      void notifyRechargeResultEmail({
-        userId: toUserId,
-        amount: Number(amount),
-        reason,
-        success: false,
-        error: "Internal error during recharge",
-      });
-
-      return {
-        success: false,
-        error: "Internal error during recharge",
-        txId,
-      };
-    }
-  });
-}

package/auth/server/revenueShareLedger.ts

@@ -1,389 +0,0 @@
-import { createHash } from "node:crypto";
-import { ulid } from "ulid";
-
-import { nolotusId } from "../../core/init";
-import { buildCreatorEarningStoreOps } from "./creatorEarningsLedger";
-import {
-  getBillingLedgerRuntime,
-  type BillingLedgerClusterId,
-  type BillingLedgerRole,
-} from "./ledger";
-import {
-  resolveRevenueSplitPolicy,
-  type RevenueSplitPolicyRef,
-} from "./revenueSplitPolicy";
-
-export type RevenueShareRuntime = {
-  clusterId: BillingLedgerClusterId;
-  nodeId: string;
-  role?: BillingLedgerRole;
-};
-
-export type RevenueShareStoreOperation = {
-  type: "put";
-  key: string;
-  value: unknown;
-};
-
-export type RevenueShareStore = {
-  get: (key: string) => Promise<unknown | null>;
-  batch: (ops: RevenueShareStoreOperation[]) => Promise<void>;
-};
-
-export type RevenueShareProductKind =
-  | "doc"
-  | "agent"
-  | "tool"
-  | "license"
-  | "agent_usage"
-  | "builtin_usage"
-  | "tool_usage"
-  | "llm_usage";
-
-export type RevenueShareLeg = {
-  role: "platform_cost" | "creator_share" | "platform_net";
-  accountId: string;
-  userId?: string;
-  amountCredits: number;
-};
-
-export type RevenueShareEventSource =
-  | {
-      kind: "token_usage";
-      tokenKey: string;
-      billingTxId?: string;
-      dialogId?: string;
-      cybotId?: string;
-    }
-  | {
-      kind: "product_purchase";
-      productId: string;
-      purchaseId: string;
-      billingTxId?: string;
-    };
-
-export type RevenueShareEvent = {
-  eventId: string;
-  idempotencyKey: string;
-  clusterId: BillingLedgerClusterId;
-  nodeId: string;
-  createdAt: number;
-  source: RevenueShareEventSource;
-  payerUserId?: string;
-  product: {
-    kind: RevenueShareProductKind;
-    id: string;
-    model?: string;
-    provider?: string;
-  };
-  splitPolicy?: RevenueSplitPolicyRef;
-  grossCredits: number;
-  platformCostCredits: number;
-  creatorShareCredits: number;
-  platformNetCredits: number;
-  shares: RevenueShareLeg[];
-  hash: string;
-};
-
-export type TokenRevenueShareRecord = {
-  type?: string;
-  userId?: string;
-  cybotId?: string;
-  dialogId?: string;
-  model?: string;
-  provider?: string;
-  cost?: number;
-  pay?: unknown;
-  revenueSplitPolicy?: unknown;
-  splitPolicy?: unknown;
-};
-
-const stableJson = (value: unknown): string => {
-  if (value === null || typeof value !== "object") {
-    return JSON.stringify(value);
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map((item) => stableJson(item)).join(",")}]`;
-  }
-  return `{${Object.entries(value as Record<string, unknown>)
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`)
-    .join(",")}}`;
-};
-
-const sha256 = (value: string) =>
-  createHash("sha256").update(value).digest("hex");
-
-const safeKeyPart = (value: string) => sha256(value).slice(0, 32);
-
-const roundCredits = (value: number) => Math.round(value * 1_000_000) / 1_000_000;
-
-const isFinitePositive = (value: unknown): value is number =>
-  typeof value === "number" && Number.isFinite(value) && value > 0;
-
-const normalizePayMap = (value: unknown) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return new Map<string, number>();
-  }
-  const pay = new Map<string, number>();
-  for (const [userId, amount] of Object.entries(value)) {
-    if (typeof amount === "number" && Number.isFinite(amount) && amount > 0) {
-      pay.set(userId, roundCredits(amount));
-    }
-  }
-  return pay;
-};
-
-const resolveProductKind = (record: TokenRevenueShareRecord): RevenueShareProductKind => {
-  const cybotId = record.cybotId || "";
-  if (cybotId === "external_tool") return "tool_usage";
-  if (cybotId.startsWith("builtin-")) return "builtin_usage";
-  if (cybotId.startsWith("agent-") || cybotId.startsWith("cybot-")) {
-    return "agent_usage";
-  }
-  return "llm_usage";
-};
-
-export const revenueShareEventKeyPrefix = (
-  clusterId: BillingLedgerClusterId
-) => `revenue-share-event-${clusterId}-`;
-
-export const revenueShareEventKey = (
-  clusterId: BillingLedgerClusterId,
-  eventId: string
-) => `${revenueShareEventKeyPrefix(clusterId)}${eventId}`;
-
-export const revenueShareIdempotencyKey = (
-  clusterId: BillingLedgerClusterId,
-  idempotencyKey: string
-) => `revenue-share-idem-${clusterId}-${safeKeyPart(idempotencyKey)}`;
-
-const computeRevenueShareEventHash = (
-  event: Omit<RevenueShareEvent, "hash">
-) =>
-  sha256(
-    stableJson({
-      version: 1,
-      event,
-    })
-  );
-
-export type RecordRevenueShareResult =
-  | { status: "recorded"; event: RevenueShareEvent }
-  | { status: "duplicate"; event: RevenueShareEvent }
-  | { status: "skipped"; reason: string };
-
-export type TokenRevenueShareProjectionResult =
-  | {
-      status: "projected";
-      event: RevenueShareEvent;
-      operations: RevenueShareStoreOperation[];
-    }
-  | { status: "skipped"; reason: string };
-
-export function buildRevenueShareProjectionOps({
-  runtime,
-  idempotencyKey,
-  eventId,
-  createdAt,
-  source,
-  payerUserId,
-  product,
-  splitPolicy,
-  grossCredits,
-  platformCostCredits,
-  creatorShareCredits,
-  platformNetCredits,
-  shares,
-}: {
-  runtime: RevenueShareRuntime;
-  idempotencyKey: string;
-  eventId?: string;
-  createdAt: number;
-  source: RevenueShareEventSource;
-  payerUserId?: string;
-  product: RevenueShareEvent["product"];
-  splitPolicy?: RevenueSplitPolicyRef;
-  grossCredits: number;
-  platformCostCredits: number;
-  creatorShareCredits: number;
-  platformNetCredits: number;
-  shares: RevenueShareLeg[];
-}): { event: RevenueShareEvent; operations: RevenueShareStoreOperation[] } {
-  const eventBase: Omit<RevenueShareEvent, "hash"> = {
-    eventId: eventId ?? ulid(createdAt),
-    idempotencyKey,
-    clusterId: runtime.clusterId,
-    nodeId: runtime.nodeId,
-    createdAt,
-    source,
-    ...(payerUserId ? { payerUserId } : {}),
-    product,
-    ...(splitPolicy ? { splitPolicy } : {}),
-    grossCredits: roundCredits(grossCredits),
-    platformCostCredits: roundCredits(platformCostCredits),
-    creatorShareCredits: roundCredits(creatorShareCredits),
-    platformNetCredits: roundCredits(platformNetCredits),
-    shares,
-  };
-  const event: RevenueShareEvent = {
-    ...eventBase,
-    hash: computeRevenueShareEventHash(eventBase),
-  };
-  const eventKey = revenueShareEventKey(runtime.clusterId, event.eventId);
-
-  return {
-    event,
-    operations: [
-      {
-        type: "put",
-        key: eventKey,
-        value: event,
-      },
-      {
-        type: "put",
-        key: revenueShareIdempotencyKey(runtime.clusterId, idempotencyKey),
-        value: {
-          eventKey,
-          event,
-          createdAt,
-        },
-      },
-      ...buildCreatorEarningStoreOps(event),
-    ],
-  };
-}
-
-export function buildTokenRevenueShareProjectionOps({
-  runtime,
-  tokenKey,
-  tokenRecord,
-  billingTxId,
-  nowMs,
-}: {
-  runtime: RevenueShareRuntime;
-  tokenKey: string;
-  tokenRecord: TokenRevenueShareRecord;
-  billingTxId?: string;
-  nowMs: number;
-}): TokenRevenueShareProjectionResult {
-  if (runtime.role && runtime.role !== "leader") {
-    return { status: "skipped", reason: "not_leader" };
-  }
-  if (!isFinitePositive(tokenRecord.cost)) {
-    return { status: "skipped", reason: "zero_cost" };
-  }
-
-  const grossCredits = roundCredits(tokenRecord.cost);
-  const pay = normalizePayMap(tokenRecord.pay);
-  const splitPolicy = resolveRevenueSplitPolicy(tokenRecord, nolotusId);
-  const productKind = resolveProductKind(tokenRecord);
-  const platformCostCredits = roundCredits(
-    pay.get(nolotusId) ?? (productKind === "tool_usage" ? grossCredits : 0)
-  );
-  const creatorShares = Array.from(pay.entries()).filter(
-    ([userId]) => userId !== nolotusId
-  );
-  const creatorShareCredits = roundCredits(
-    creatorShares.reduce((sum, [, amount]) => sum + amount, 0)
-  );
-  const platformNetCredits = roundCredits(
-    grossCredits - platformCostCredits - creatorShareCredits
-  );
-
-  const shares: RevenueShareLeg[] = [];
-  if (platformCostCredits > 0) {
-    shares.push({
-      role: "platform_cost",
-      accountId: `platform:${nolotusId}:provider-cost`,
-      userId: nolotusId,
-      amountCredits: platformCostCredits,
-    });
-  }
-  for (const [userId, amountCredits] of creatorShares) {
-    shares.push({
-      role: "creator_share",
-      accountId: `creator:${userId}:earnings:pending`,
-      userId,
-      amountCredits,
-    });
-  }
-  if (platformNetCredits !== 0) {
-    shares.push({
-      role: "platform_net",
-      accountId: `platform:${nolotusId}:net-revenue`,
-      userId: nolotusId,
-      amountCredits: platformNetCredits,
-    });
-  }
-
-  const projection = buildRevenueShareProjectionOps({
-    runtime,
-    idempotencyKey: `token:${tokenKey}`,
-    createdAt: nowMs,
-    source: {
-      kind: "token_usage",
-      tokenKey,
-      ...(billingTxId ? { billingTxId } : {}),
-      ...(tokenRecord.dialogId ? { dialogId: tokenRecord.dialogId } : {}),
-      ...(tokenRecord.cybotId ? { cybotId: tokenRecord.cybotId } : {}),
-    },
-    payerUserId: tokenRecord.userId,
-    product: {
-      kind: productKind,
-      id: tokenRecord.cybotId || "unknown",
-      ...(tokenRecord.model ? { model: tokenRecord.model } : {}),
-      ...(tokenRecord.provider ? { provider: tokenRecord.provider } : {}),
-    },
-    splitPolicy,
-    grossCredits,
-    platformCostCredits,
-    creatorShareCredits,
-    platformNetCredits,
-    shares,
-  });
-
-  return {
-    status: "projected",
-    event: projection.event,
-    operations: projection.operations,
-  };
-}
-
-export async function recordTokenRevenueShare({
-  store,
-  runtime = getBillingLedgerRuntime(),
-  tokenKey,
-  tokenRecord,
-  billingTxId,
-  nowMs = Date.now(),
-}: {
-  store: RevenueShareStore;
-  runtime?: RevenueShareRuntime;
-  tokenKey: string;
-  tokenRecord: TokenRevenueShareRecord;
-  billingTxId?: string;
-  nowMs?: number;
-}): Promise<RecordRevenueShareResult> {
-  const idempotencyKey = `token:${tokenKey}`;
-  const idemKey = revenueShareIdempotencyKey(runtime.clusterId, idempotencyKey);
-  const existing = (await store.get(idemKey).catch(() => null)) as
-    | { event?: RevenueShareEvent }
-    | null;
-  if (existing?.event) {
-    return { status: "duplicate", event: existing.event };
-  }
-
-  const projection = buildTokenRevenueShareProjectionOps({
-    runtime,
-    tokenKey,
-    tokenRecord,
-    billingTxId,
-    nowMs,
-  });
-  if (projection.status !== "projected") return projection;
-
-  await store.batch(projection.operations);
-
-  return { status: "recorded", event: projection.event };
-}