nolo-cli 0.1.23 → 0.1.29

package/auth/server/signup.ts

@@ -0,0 +1,423 @@
+// database/server/signup.ts
+// 注册接口（按 IP 配额限制，默认：同一 IP 每日仅允许注册 1 个；支持灵活扩展周/月窗口）
+
+import i18nServer from "../../app/i18n/i18n.server";
+import serverDb from "../../database/server/db.js";
+import { signMessage } from "../../core/crypto";
+import { generateUserIdV1 } from "../../core/generateMainKey";
+import {
+  createErrorResponse,
+  createSuccessResponse,
+  handleOptionsRequest,
+} from "./shared";
+import { DB_PREFIX, createUserKey } from "../../database/keys";
+import pino from "pino";
+import { ulid } from "ulid";
+import { Mutex } from "async-mutex";
+import { rechargeUserBalance } from "../server/recharge";
+import { prepareUserSettings } from "../../app/settings/prepareUserSetting";
+import {
+  creditInviterReward,
+  resolveValidInviterId,
+} from "../server/inviteReward";
+import { sendWelcomeEmailForUser } from "../server/emailAutomation";
+import { CORE_FLOW_STAGES } from "../server/emailAutomationTypes";
+import {
+  DEFAULT_SIGNUP_IP_QUOTAS,
+  shouldBypassSignupIpQuota,
+} from "./signupIpQuota";
+
+const logger = pino({ name: "signup" });
+const signupLocks = new Map<string, Mutex>();
+const signupIpLocks = new Map<string, Mutex>();
+
+function getSignupLock(userId: string): Mutex {
+  let lock = signupLocks.get(userId);
+  if (!lock) {
+    lock = new Mutex();
+    signupLocks.set(userId, lock);
+  }
+  return lock;
+}
+
+function getSignupIpLock(ip: string): Mutex {
+  let lock = signupIpLocks.get(ip);
+  if (!lock) {
+    lock = new Mutex();
+    signupIpLocks.set(ip, lock);
+  }
+  return lock;
+}
+
+/**
+ * 可配置的 IP 配额：
+ * - 当前默认：每日 1 个
+ * - 示例（未来可改）：[{ days: 1, limit: 2 }, { days: 7, limit: 5 }, { days: 30, limit: 10 }]
+ */
+const IP_QUOTAS: Array<{ days: number; limit: number }> = [
+  ...DEFAULT_SIGNUP_IP_QUOTAS,
+];
+
+/** ========== IP 配额计数 ========== */
+
+const ABUSE_PREFIX = {
+  byIpDay: (ip: string, day: string) => `abuse:signup:ip:${ip}:${day}`, // value: string number
+};
+
+function isDbNotFoundError(err: any) {
+  return err?.code === "LEVEL_NOT_FOUND" || err?.notFound === true;
+}
+
+function getDayKey(d: Date = new Date()) {
+  // e.g., 2025-11-01 -> 20251101
+  return d.toISOString().slice(0, 10).replace(/-/g, "");
+}
+
+function getDayKeysBackwards(days: number): string[] {
+  const keys: string[] = [];
+  const now = new Date();
+  for (let i = 0; i < days; i++) {
+    const d = new Date(now);
+    d.setDate(now.getDate() - i);
+    keys.push(getDayKey(d));
+  }
+  return keys;
+}
+
+async function getIpDayCount(ip: string, dayKey: string): Promise<number> {
+  try {
+    const val = await serverDb.get(ABUSE_PREFIX.byIpDay(ip, dayKey));
+    const n = Number(val);
+    return Number.isFinite(n) ? n : 0;
+  } catch (e: any) {
+    if (isDbNotFoundError(e)) return 0;
+    throw e;
+  }
+}
+
+async function getIpCountInDays(ip: string, days: number): Promise<number> {
+  const keys = getDayKeysBackwards(days);
+  const counts = await Promise.all(keys.map((k) => getIpDayCount(ip, k)));
+  return counts.reduce((a, b) => a + b, 0);
+}
+
+function windowLabel(days: number) {
+  if (days === 1) return "今日";
+  if (days === 7) return "近7日";
+  if (days === 30) return "近30日";
+  return `近${days}日`;
+}
+
+async function checkIpQuotas(ip: string, t: any) {
+  for (const q of IP_QUOTAS) {
+    const used = await getIpCountInDays(ip, q.days);
+    if (used >= q.limit) {
+      const defaultMsg = `${windowLabel(q.days)}该 IP 注册数已达上限（限制：${q.limit}）`;
+      const msg =
+        typeof t === "function"
+          ? t("errors.ipQuotaExceeded") || defaultMsg
+          : defaultMsg;
+      return createErrorResponse(msg, 429);
+    }
+  }
+  return null;
+}
+
+async function recordIpRegistration(ip: string) {
+  const today = getDayKey();
+  const key = ABUSE_PREFIX.byIpDay(ip, today);
+  let count = 0;
+  try {
+    count = Number(await serverDb.get(key)) || 0;
+  } catch (e: any) {
+    // LEVEL_NOT_FOUND => 从 0 开始
+  }
+  await serverDb.put(key, String(count + 1));
+}
+
+/** ========== 原有辅助函数（传入 t） ========== */
+
+function validateRequestMethod(method: string, t: any) {
+  if (method === "OPTIONS") {
+    return handleOptionsRequest();
+  }
+  if (method !== "POST") {
+    return createErrorResponse(t("errors.methodNotAllowed"), 405);
+  }
+  return null;
+}
+
+function extractUserData(body: any, t: any) {
+  const { username, publicKey, locale, email, inviterId } = body || {};
+  if (!username || !publicKey || !locale) {
+    return createErrorResponse(t("errors.missingFields"), 400);
+  }
+  const normalizedInviterId =
+    typeof inviterId === "string" ? inviterId.trim() : undefined;
+  return {
+    username,
+    publicKey,
+    locale,
+    email,
+    inviterId: normalizedInviterId || undefined,
+  };
+}
+
+function generateUserId(publicKey: string, username: string, locale: string) {
+  return generateUserIdV1(publicKey, username, locale);
+}
+
+async function checkUserExists(userId: string, t: any) {
+  try {
+    const existingUser = await serverDb.get(DB_PREFIX.USER + userId);
+    if (existingUser) {
+      return createErrorResponse(t("errors.dataExists", { id: userId }), 409);
+    }
+  } catch (err: any) {
+    if (!isDbNotFoundError(err)) {
+      throw err;
+    }
+  }
+  return null;
+}
+
+/**
+ * 显式构造对象，只在有值时写入可选字段，行为等价但更直观。
+ */
+function prepareUserData(userData: any) {
+  const now = Date.now();
+  const prepared: any = {
+    username: userData.username,
+    publicKey: userData.publicKey,
+    locale: userData.locale,
+    createdAt: now,
+    lastActiveAt: now,
+    lastLoginAt: now,
+    balance: 0,
+    balanceUpdatedAt: now,
+    tokenVersion: 0,
+    tokenVersionUpdatedAt: now,
+    coreFlowStage: CORE_FLOW_STAGES.signupStarted,
+    coreFlowStageUpdatedAt: now,
+  };
+
+  if (userData.email != null) {
+    prepared.email = userData.email;
+  }
+  if (userData.inviterId != null) {
+    prepared.inviterId = userData.inviterId;
+  }
+
+  return prepared;
+}
+
+function prepareUserProfile(username: string, email?: string) {
+  const now = Date.now();
+  return {
+    nickname: username,
+    avatar: "",
+    bio: "",
+    createdAt: now,
+    updatedAt: now,
+    email,
+  };
+}
+
+async function saveUserDataToDb(
+  userId: string,
+  userData: any,
+  userSettings: any,
+  userProfile: any
+) {
+  await serverDb.batch([
+    { type: "put", key: DB_PREFIX.USER + userId, value: userData },
+    { type: "put", key: createUserKey.settings(userId), value: userSettings },
+    { type: "put", key: createUserKey.profile(userId), value: userProfile },
+  ]);
+}
+
+async function rollbackUserDataFromDb(userId: string) {
+  await serverDb.batch([
+    { type: "del", key: DB_PREFIX.USER + userId },
+    { type: "del", key: createUserKey.settings(userId) },
+    { type: "del", key: createUserKey.profile(userId) },
+  ]);
+}
+
+function signUserMessage(
+  username: string,
+  userId: string,
+  publicKey: string,
+  tokenVersion: number,
+  t: any
+) {
+  const message = JSON.stringify({ username, userId, publicKey, tokenVersion });
+  const secretKey = process.env.SECRET_KEY;
+  if (!secretKey) {
+    return createErrorResponse(t("errors.secretKeyMissing"), 500);
+  }
+  return signMessage(message, secretKey);
+}
+
+/** ========== 主处理函数（仅依赖 req.ip，不再从 headers 回退解析） ========== */
+
+export async function handleSignUp(req: any) {
+  let t: any = null; // 在 try 外声明 t，catch 中可用
+  try {
+    // i18n（仍从 headers 读取语言，这个在上游已透传）
+    const acceptLanguage: string | null = req.headers?.get("accept-language");
+    const lng = acceptLanguage?.split(",")[0] || "zh-CN";
+    t = await i18nServer.cloneInstance({ lng }).init();
+
+    // 1) 方法校验
+    const methodValidation = validateRequestMethod(req.method, t);
+    if (methodValidation) return methodValidation;
+
+    // 2) 解析 body 并校验
+    const userDataResult = extractUserData(req.body, t);
+    if (userDataResult instanceof Response) return userDataResult;
+    const { username, publicKey, locale, email, inviterId } = userDataResult;
+
+    // 3) 取 IP：仅依赖上游注入的 req.ip
+    const ip: string | null = req.ip || null;
+
+    if (!ip) {
+      // 若上游没有提供 IP，这里仅记录；如需严格限制，可改为直接返回 400/403
+      logger.warn(
+        { username, reportedClientIp: req?.reportedClientIp },
+        "Could not determine client IP for signup."
+      );
+    }
+
+    const runSignup = async () => {
+      // 4) 生成 userId 并查重
+      const userId = generateUserId(publicKey, username, locale);
+      const validatedInviterId = await resolveValidInviterId(
+        inviterId,
+        userId,
+        logger
+      );
+
+      const signupLock = getSignupLock(userId);
+      return await signupLock.runExclusive(async () => {
+        const userExistsResult = await checkUserExists(userId, t);
+        if (userExistsResult) return userExistsResult;
+
+        // 5) 组装并写入
+        const userData = prepareUserData({
+          ...userDataResult,
+          inviterId: validatedInviterId,
+        });
+        const userSettings = prepareUserSettings(locale);
+        const userProfile = prepareUserProfile(username, email);
+        await saveUserDataToDb(userId, userData, userSettings, userProfile);
+
+        // 6) 赠送余额（失败则回滚，避免“注册成功但余额未到账”）
+        const initialBalance = validatedInviterId ? 6 : 3;
+        const reason = validatedInviterId
+          ? "invited_signup_bonus"
+          : "new_user_bonus";
+        const initialRechargeResult = await rechargeUserBalance(
+          userId,
+          initialBalance,
+          reason,
+          `signup_${userId}_${ulid()}`
+        );
+        if (!initialRechargeResult.success) {
+          logger.error(
+            { userId, initialBalance, error: initialRechargeResult.error },
+            "CRITICAL: Failed to credit initial balance for new user."
+          );
+          try {
+            await rollbackUserDataFromDb(userId);
+          } catch (rollbackError) {
+            logger.error(
+              { userId, rollbackError },
+              "Failed to rollback signup data after initial balance credit failure."
+            );
+          }
+          const errorMessage = t
+            ? t("errors.internalServerError")
+            : "Internal Server Error";
+          return createErrorResponse(errorMessage, 500);
+        }
+
+        try {
+          await creditInviterReward(validatedInviterId, userId, logger);
+        } catch (error) {
+          logger.warn(
+            { userId, inviterId: validatedInviterId, error },
+            "Failed to credit inviter reward after signup"
+          );
+        }
+
+        try {
+          await sendWelcomeEmailForUser(userId, userData);
+        } catch (error) {
+          logger.warn(
+            { userId, email: userData.email, error },
+            "Welcome email send failed after signup"
+          );
+        }
+
+        // 7) 成功后计入“今日 +1”
+        if (ip) {
+          try {
+            await recordIpRegistration(ip);
+          } catch (e) {
+            logger.warn(
+              { ip, userId, err: e },
+              "Failed to record IP registration count."
+            );
+          }
+        }
+
+        // 8) 签名返回
+        const encryptedDataResult = signUserMessage(
+          username,
+          userId,
+          publicKey,
+          userData.tokenVersion,
+          t
+        );
+        if (encryptedDataResult instanceof Response) return encryptedDataResult;
+        const encryptedData = encryptedDataResult;
+
+        return createSuccessResponse({ encryptedData });
+      });
+    };
+
+    if (!ip) {
+      return await runSignup();
+    }
+
+    if (
+      shouldBypassSignupIpQuota({
+        ip,
+        hostHeader: req.headers?.get?.("host"),
+        nodeEnv: process.env.NODE_ENV,
+      })
+    ) {
+      return runSignup();
+    }
+
+    const ipLock = getSignupIpLock(ip);
+    return await ipLock.runExclusive(async () => {
+      const quotaRes = await checkIpQuotas(ip, t);
+      if (quotaRes) {
+        logger.warn(
+          { ip, username, reportedClientIp: req?.reportedClientIp },
+          "Blocked signup due to IP quota limit."
+        );
+        return quotaRes;
+      }
+      return runSignup();
+    });
+  } catch (error) {
+    logger.error({ error }, "An unexpected error occurred during signup.");
+    const errorMessage = t
+      ? t("errors.internalServerError")
+      : "Internal Server Error";
+    return createErrorResponse(errorMessage, 500);
+  }
+}

package/auth/server/signupIpQuota.ts

@@ -0,0 +1,44 @@
+export const DEFAULT_SIGNUP_IP_QUOTAS: Array<{ days: number; limit: number }> = [
+  { days: 1, limit: 1 },
+];
+
+const normalizeHost = (hostHeader?: string | null) => {
+  const raw = String(hostHeader || "").trim().toLowerCase();
+  if (!raw) return "";
+  if (raw.startsWith("[") && raw.includes("]")) {
+    const end = raw.indexOf("]");
+    return raw.slice(1, end);
+  }
+  return raw.split(":")[0];
+};
+
+const isLoopbackIp = (ip: string) => {
+  const normalized = String(ip || "").trim().toLowerCase();
+  if (!normalized) return false;
+  return (
+    normalized === "::1" ||
+    normalized === "::ffff:127.0.0.1" ||
+    normalized === "127.0.0.1" ||
+    normalized.startsWith("127.")
+  );
+};
+
+const isLocalHost = (hostHeader?: string | null) => {
+  const host = normalizeHost(hostHeader);
+  return host === "localhost" || host === "127.0.0.1" || host === "::1";
+};
+
+export const shouldBypassSignupIpQuota = ({
+  ip,
+  hostHeader,
+  nodeEnv,
+}: {
+  ip: string;
+  hostHeader?: string | null;
+  nodeEnv?: string;
+}) => {
+  if (String(nodeEnv || "").toLowerCase() === "production") {
+    return false;
+  }
+  return isLoopbackIp(ip) || isLocalHost(hostHeader);
+};

package/auth/server/token.ts

@@ -0,0 +1,109 @@
+// auth/handleToken.js
+import { verifyToken, parseToken } from "../token";
+import { assertSessionTokenVersion } from "../sessionTokenVersion";
+import serverDb from "../../database/server/db";
+import { balanceLockManager } from "./locks";
+import { recordUserAccessActivity } from "./accessActivity";
+
+const handleError = (res, error, status = 500) =>
+  res.status(status).json({ error: error.message });
+
+const getUserActivityUpdateIntervalMs = () => {
+  const rawActivityIntervalMs = Number(process.env.USER_ACTIVITY_UPDATE_INTERVAL_MS);
+  return Number.isFinite(rawActivityIntervalMs)
+    ? Math.max(60_000, Math.floor(rawActivityIntervalMs))
+    : 5 * 60 * 1000;
+};
+
+const getPublicKey = async (userId) => {
+  try {
+    const user = await serverDb.get(`user:${userId}`);
+    if (user?.publicKey) return user.publicKey;
+  } catch { }
+  return null;
+};
+
+const updateUserLastActiveAt = async (userId, metadata?: { ip?: string | null; userAgent?: string | null }) => {
+  const key = `user:${userId}`;
+  const lock = balanceLockManager.getLock(userId);
+  let shouldRecord = false;
+  try {
+    await lock.runExclusive(async () => {
+      const user = await serverDb.get(key);
+      if (!user) return;
+
+      const now = Date.now();
+      const lastActiveAt = Number(user.lastActiveAt || 0);
+      if (
+        Number.isFinite(lastActiveAt) &&
+        lastActiveAt > 0 &&
+        now - lastActiveAt < getUserActivityUpdateIntervalMs()
+      ) {
+        return;
+      }
+      shouldRecord = true;
+    });
+    if (!shouldRecord) return;
+
+    await recordUserAccessActivity(userId, {
+      source: "token",
+      ip: metadata?.ip,
+      userAgent: metadata?.userAgent,
+      replaceWithinMs: getUserActivityUpdateIntervalMs(),
+      updateLastActiveAt: true,
+    });
+  } catch (error) {
+    console.warn("Failed to update user lastActiveAt", { userId, error });
+  }
+};
+
+// NOTE: 这里用 new Date(exp) 处理 ISO 字符串，
+// 而 verifyToken 只检查 number 类型 exp（见 auth/token.ts 的 BUG 注释）
+// 两套逻辑不一致，待 token.ts 的 exp 检查统一修复后可删除此函数
+const isTokenExpired = ({ exp, nbf }) => {
+  const now = Date.now();
+  return (exp && now > exp * 1000) || (nbf && now < nbf * 1000);
+};
+
+export async function handleToken(req, res) {
+  const token = req.headers.get("authorization")?.split(" ")[1];
+  const requestIp =
+    req.headers.get("x-nolo-client-ip")?.trim() ||
+    req.headers.get("x-forwarded-for")?.split(",")[0]?.trim() ||
+    req.headers.get("x-real-ip") ||
+    "";
+  const userAgent = req.headers.get("user-agent") || "";
+  if (!token) return handleError(res, new Error("Access denied. No token provided."), 401);
+
+  try {
+    // parseToken 使用 js-base64，正确处理中文用户名的 UTF-8 编码
+    // 原 atob 方案在中文用户名时会产生乱码，导致 userId 错误、publicKey 查找失败
+    const parsed = parseToken(token);
+    if (!parsed?.userId) return handleError(res, new Error("Invalid token format"), 401);
+    const { userId } = parsed;
+    const publicKey = await getPublicKey(userId);
+
+    if (!publicKey) return handleError(res, new Error("Public key not found"), 401);
+
+    const user = await serverDb.get(`user:${userId}`);
+    if (!user?.publicKey) {
+      return handleError(res, new Error("Public key not found"), 401);
+    }
+
+    const payload = verifyToken(token, publicKey);
+    assertSessionTokenVersion(payload, user);
+    // NOTE: verifyToken 验签失败会直接 throw，不会返回 null/falsy
+    // 所以下面这行是死代码，永远不会执行
+    if (!payload) return handleError(res, new Error("Invalid token"), 401);
+
+    // NOTE: verifyToken 内部已检查 Unix 秒格式的 exp，这里再检查 ISO 字符串格式
+    // 两处检查逻辑不同，待 token.ts 修复后可删除此行
+    if (isTokenExpired(payload)) return handleError(res, new Error("Token has expired"), 401);
+
+    await updateUserLastActiveAt(userId, { ip: requestIp, userAgent });
+
+    return payload;
+  } catch (err) {
+    return handleError(res, err, 401);
+  }
+}