nolo-cli 0.1.31 → 0.1.32

package/auth/server/utils.ts

@@ -1,200 +0,0 @@
-// auth/server/utils.ts
-import { logger } from "./shared";
-
-interface RetryOptions {
-  maxAttempts: number;
-  delayMs: number;
-  backoff?: boolean;
-  onRetry?: (attempt: number, error: Error) => void;
-}
-
-interface RetryError extends Error {
-  attempts?: number;
-  lastError?: Error;
-}
-
-const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-  maxAttempts: 3,
-  delayMs: 1000,
-  backoff: true,
-  onRetry: (attempt, error) => {
-    logger.warn({
-      event: "operation_retry",
-      attempt,
-      error: error.message,
-    });
-  },
-};
-
-/**
- * 通用重试函数
- * @param operation 需要重试的异步操作
- * @param options 重试配置选项
- * @returns 操作结果
- */
-export async function withRetry<T>(
-  operation: () => Promise<T>,
-  options: Partial<RetryOptions> = {}
-): Promise<T> {
-  const finalOptions = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  let lastError: Error | null = null;
-
-  for (let attempt = 1; attempt <= finalOptions.maxAttempts; attempt++) {
-    try {
-      return await operation();
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-
-      if (attempt === finalOptions.maxAttempts) {
-        break;
-      }
-
-      const delay = finalOptions.backoff
-        ? finalOptions.delayMs * Math.pow(2, attempt - 1)
-        : finalOptions.delayMs;
-
-      if (finalOptions.onRetry) {
-        finalOptions.onRetry(attempt, lastError);
-      }
-
-      await sleep(delay);
-    }
-  }
-
-  const error: RetryError = new Error(
-    `Operation failed after ${finalOptions.maxAttempts} attempts`
-  );
-  error.attempts = finalOptions.maxAttempts;
-  error.lastError = lastError || undefined;
-  throw error;
-}
-
-/**
- * 带超时的重试函数
- */
-export async function withRetryAndTimeout<T>(
-  operation: () => Promise<T>,
-  timeoutMs: number,
-  options?: Partial<RetryOptions>
-): Promise<T> {
-  const timeoutPromise = new Promise<never>((_, reject) => {
-    setTimeout(() => {
-      reject(new Error(`Operation timed out after ${timeoutMs}ms`));
-    }, timeoutMs);
-  });
-
-  return Promise.race([withRetry(operation, options), timeoutPromise]);
-}
-
-/**
- * 休眠函数
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-/**
- * 带重试的批量操作
- */
-export async function withBatchRetry<T>(
-  operations: (() => Promise<T>)[],
-  options?: Partial<RetryOptions>
-): Promise<T[]> {
-  return Promise.all(
-    operations.map((operation) => withRetry(operation, options))
-  );
-}
-
-/**
- * 用法示例:
- */
-/* 
-// 基本用法
-try {
-  const result = await withRetry(
-    async () => {
-      // 异步操作
-      return await someAsyncOperation();
-    },
-    {
-      maxAttempts: 3,
-      delayMs: 1000,
-      backoff: true,
-    }
-  );
-} catch (error) {
-  // 处理最终失败
-}
-
-// 带超时的用法
-try {
-  const result = await withRetryAndTimeout(
-    async () => {
-      return await someAsyncOperation();
-    },
-    5000, // 5秒超时
-    {
-      maxAttempts: 3,
-      delayMs: 1000,
-    }
-  );
-} catch (error) {
-  // 处理超时或重试失败
-}
-
-// 自定义重试回调
-const result = await withRetry(
-  async () => {
-    return await someAsyncOperation();
-  },
-  {
-    onRetry: (attempt, error) => {
-      logger.warn({
-        event: "custom_retry",
-        attempt,
-        error: error.message,
-        customData: "some context",
-      });
-    },
-  }
-);
-*/
-
-/**
- * 测试用例
- */
-/* 
-describe("withRetry", () => {
-  it("should retry failed operations", async () => {
-    let attempts = 0;
-    const operation = async () => {
-      attempts++;
-      if (attempts < 3) {
-        throw new Error("Temporary failure");
-      }
-      return "success";
-    };
-
-    const result = await withRetry(operation, {
-      maxAttempts: 3,
-      delayMs: 100,
-    });
-
-    expect(result).toBe("success");
-    expect(attempts).toBe(3);
-  });
-
-  it("should fail after max attempts", async () => {
-    const operation = async () => {
-      throw new Error("Persistent failure");
-    };
-
-    await expect(
-      withRetry(operation, {
-        maxAttempts: 3,
-        delayMs: 100,
-      })
-    ).rejects.toThrow("Operation failed after 3 attempts");
-  });
-});
-*/

package/auth/sessionTokenVersion.ts

@@ -1,38 +0,0 @@
-type SessionVersionCarrier = {
-  tokenVersion?: unknown;
-} | null | undefined;
-
-export const SESSION_REVOKED_ERROR = "Token has been revoked";
-
-export function normalizeSessionTokenVersion(value: unknown): number {
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return 0;
-  }
-  if (value <= 0) {
-    return 0;
-  }
-  return Math.floor(value);
-}
-
-export function getSessionTokenVersion(payload: SessionVersionCarrier): number {
-  return normalizeSessionTokenVersion(payload?.tokenVersion);
-}
-
-export function getUserSessionVersion(user: SessionVersionCarrier): number {
-  return normalizeSessionTokenVersion(user?.tokenVersion);
-}
-
-export function assertSessionTokenVersion(
-  payload: SessionVersionCarrier,
-  user: SessionVersionCarrier
-) {
-  const tokenVersion = getSessionTokenVersion(payload);
-  const currentVersion = getUserSessionVersion(user);
-  if (tokenVersion !== currentVersion) {
-    throw new Error(SESSION_REVOKED_ERROR);
-  }
-}
-
-export function getNextSessionTokenVersion(user: SessionVersionCarrier): number {
-  return getUserSessionVersion(user) + 1;
-}

package/auth/token.ts

@@ -1,63 +0,0 @@
-import { detachedSign, verifyDetachedSignature } from "../core/crypto";
-import { Base64 } from "js-base64";
-
-/**
- * Token 格式：`base64(JSON(payload)).ed25519签名`
- *
- * 设计说明：
- * - 密钥派生是确定性的：用户名 + 哈希(密码) + locale → secretKey/publicKey
- * - token 由客户端本地签发，服务端用存储的 publicKey 验签，没有中心化密钥
- * - 忘记密码 = 无法恢复（类似助记词钱包），注册时应明确告知用户
- *
- * payload 约定：
- * - userId, username 必填
- * - exp: Unix 秒（number），仅旧 token 使用；新的登录 token 默认不设置过期时间
- */
-
-export const buildPersistentAuthTokenPayload = <T extends Record<string, unknown>>(
-  payload: T,
-  nowSec = Math.floor(Date.now() / 1000)
-) => ({
-  ...payload,
-  iat: nowSec,
-  nbf: nowSec,
-});
-
-export const signToken = (payload: any, secretKey: string) => {
-  const encodedPayload = Base64.encode(JSON.stringify(payload));
-  const signature = detachedSign(encodedPayload, secretKey);
-  return `${encodedPayload}.${signature}`;
-};
-
-export const verifyToken = (token: string, publicKey: string) => {
-  const [encodedPayload, signature] = token.split(".");
-
-  if (!verifyDetachedSignature(encodedPayload, signature, publicKey)) {
-    throw new Error("Invalid signature");
-  }
-
-  const payload = JSON.parse(Base64.decode(encodedPayload));
-
-  // exp 统一为 Unix 秒（number），直接与当前时间比较
-  if (payload.exp && typeof payload.exp === "number") {
-    if (Math.floor(Date.now() / 1000) > payload.exp) {
-      throw new Error("Token has expired");
-    }
-  }
-
-  return payload;
-};
-
-/**
- * 不验证签名，只解析 payload。
- * 用于从 token 中快速读取 userId 等字段（如初始化 auth 状态）。
- * 注意：结果未经验签，不可用于权限判断。
- */
-export const parseToken = (token: string) => {
-  try {
-    const [payloadBase64] = token.split(".");
-    return JSON.parse(Base64.decode(payloadBase64));
-  } catch {
-    return null;
-  }
-};

package/auth/tokenCookie.ts

@@ -1 +0,0 @@
-export const WEB_AUTH_TOKEN_COOKIE = "nolo_auth_token";

package/auth/types.ts

@@ -1,40 +0,0 @@
-// auth/types.ts
-import type { AdminPermissions } from "./adminPermissions";
-
-export interface User {
-  userId: string;
-  username?: string;
-  name?: string;
-  nickname?: string;
-  avatar?: string;
-  email?: string;
-  locale?: string;
-  publicKey?: string;
-  tokenVersion?: number;
-  balance?: number;
-  gptProAccess?: {
-    status?: string;
-    requiredRechargeAmount?: number;
-    rechargeAmount?: number;
-    source?: string;
-    sourceTxId?: string;
-    grantedAt?: number;
-    updatedAt?: number;
-  };
-  adminPermissions?: AdminPermissions;
-}
-export interface TokenManager {
-  getTokens(): Promise<string[]>;
-  storeToken(token: string): Promise<void>;
-  removeToken(token: string): Promise<void>;
-  initTokens(): Promise<string[]>;
-}
-
-export const safelyParseJSON = (jsonString: string) => {
-  try {
-    const parsed = JSON.parse(jsonString);
-    return typeof parsed === "string" ? [parsed] : parsed;
-  } catch {
-    return [jsonString];
-  }
-};

package/auth/utils.ts

@@ -1,110 +0,0 @@
-// path auth/utils.ts
-import { parseToken, verifyToken } from ".//token";
-import { assertSessionTokenVersion } from ".//sessionTokenVersion";
-import { getServerAuthorityStore } from "../database/server/db";
-import { WEB_AUTH_TOKEN_COOKIE } from "./tokenCookie";
-
-export const CORS_HEADERS_AUTH = {
-  "Access-Control-Allow-Origin": "*",
-  "Access-Control-Allow-Methods": "POST, GET, OPTIONS",
-  "Access-Control-Allow-Headers": "Content-Type, Authorization",
-  "Access-Control-Max-Age": "86400",
-};
-
-export const authErrorResponse = (
-  msg: string,
-  code: string,
-  status: number = 500
-): Response =>
-  new Response(JSON.stringify({ error: { message: msg, code } }), {
-    status,
-    headers: { "Content-Type": "application/json", ...CORS_HEADERS_AUTH },
-  });
-
-const getAuthUtilsStore = () => getServerAuthorityStore();
-
-const getPublicKey = async (userId: string) => {
-  try {
-    const u = await getAuthUtilsStore().get(`user:${userId}`);
-    if (!u?.publicKey || u.balance <= 0 || u.isDisabled) {
-      return { publicKey: null, isValid: false };
-    }
-    return { publicKey: u.publicKey, isValid: true };
-  } catch (e) {
-    return { publicKey: null, isValid: false };
-  }
-};
-
-export const authenticateRequest = async (
-  req: Request
-): Promise<
-  ({ userId: string; authToken: string } & Record<string, unknown>) | Response
-> => {
-  const authHeaderToken = req.headers.get("authorization")?.split(" ")[1];
-  const cookieHeader = req.headers.get("cookie") ?? req.headers.get("Cookie") ?? "";
-  const cookieToken = cookieHeader
-    .split(";")
-    .map((part) => part.trim())
-    .find((part) => part.startsWith(`${WEB_AUTH_TOKEN_COOKIE}=`))
-    ?.slice(`${WEB_AUTH_TOKEN_COOKIE}=`.length);
-  const token = authHeaderToken ?? (cookieToken ? decodeURIComponent(cookieToken) : undefined);
-  if (!token) {
-    return authErrorResponse(
-      "No authentication token provided.",
-      "AUTH_NO_TOKEN",
-      401
-    );
-  }
-
-  try {
-    const tokenHeaderPayload = parseToken(token);
-    const userIdFromTokenHeader = tokenHeaderPayload?.userId;
-
-    if (!userIdFromTokenHeader) {
-      return authErrorResponse(
-        "Invalid token format.",
-        "AUTH_INVALID_TOKEN",
-        401
-      );
-    }
-
-    const { publicKey, isValid } = await getPublicKey(userIdFromTokenHeader);
-    if (!isValid || !publicKey) {
-      return authErrorResponse("Invalid account.", "AUTH_ACCOUNT_INVALID", 401);
-    }
-
-    const user = await getAuthUtilsStore().get(`user:${userIdFromTokenHeader}`);
-    const decodedTokenData = verifyToken(token, publicKey);
-    assertSessionTokenVersion(decodedTokenData, user);
-    if (!decodedTokenData) {
-      return authErrorResponse(
-        "Invalid token signature.",
-        "AUTH_INVALID_TOKEN",
-        401
-      );
-    }
-
-    const now = Date.now();
-    if (decodedTokenData.exp && now > decodedTokenData.exp * 1000) {
-      return authErrorResponse("Token has expired.", "AUTH_TOKEN_EXPIRED", 401);
-    }
-    if (
-      decodedTokenData.nbf &&
-      now < decodedTokenData.nbf * 1000
-    ) {
-      return authErrorResponse(
-        "Token not yet active.",
-        "AUTH_TOKEN_NOT_ACTIVE",
-        401
-      );
-    }
-
-    return { ...decodedTokenData, userId: userIdFromTokenHeader, authToken: token };
-  } catch (e: any) {
-    return authErrorResponse(
-      `Authentication failed: ${e.message}.`,
-      "AUTH_VERIFICATION_FAILED",
-      401
-    );
-  }
-};

package/auth/web/bootstrapAuthState.ts

@@ -1,60 +0,0 @@
-import { parseToken } from "../token";
-import type { User } from "../types";
-import { safelyParseJSON } from "../types";
-
-export interface BootstrappedAuthState {
-  currentUser: User;
-  users: User[];
-  isLoggedIn: true;
-  currentToken: string;
-  isLoading: false;
-}
-
-const isUser = (value: unknown): value is User =>
-  typeof value === "object" &&
-  value !== null &&
-  typeof (value as { userId?: unknown }).userId === "string";
-
-export const getBootstrappedAuthState = (
-  storedTokens: string | null
-): BootstrappedAuthState | null => {
-  if (!storedTokens) return null;
-
-  const tokens = safelyParseJSON(storedTokens).filter(
-    (token): token is string => typeof token === "string" && token.length > 0
-  );
-
-  if (!tokens.length) return null;
-
-  const users: User[] = [];
-  const seenUserIds = new Set<string>();
-  let currentUser: User | null = null;
-  let currentToken: string | null = null;
-
-  for (const token of tokens) {
-    const parsedUser = parseToken(token);
-    if (!isUser(parsedUser)) continue;
-    if (seenUserIds.has(parsedUser.userId)) continue;
-    seenUserIds.add(parsedUser.userId);
-
-    users.push(parsedUser);
-    if (!currentUser) {
-      currentUser = parsedUser;
-      currentToken = token;
-    }
-  }
-
-  if (!currentUser || !currentToken) return null;
-
-  return {
-    currentUser,
-    users,
-    isLoggedIn: true,
-    currentToken,
-    isLoading: false,
-  };
-};
-
-export const readBootstrappedAuthState = (
-  storage: Pick<Storage, "getItem">
-) => getBootstrappedAuthState(storage.getItem("tokens"));

package/auth/web/tokenManager.ts

@@ -1,61 +0,0 @@
-// auth/web/tokenManager.ts
-import type { TokenManager } from "../types";
-import { safelyParseJSON } from "../types";
-import { parseToken } from "../token";
-import { WEB_AUTH_TOKEN_COOKIE } from "../tokenCookie";
-
-const PERSISTENT_AUTH_TOKEN_COOKIE_MAX_AGE_SECONDS = 10 * 365 * 24 * 3600;
-
-function writeAuthTokenCookie(token: string | null): void {
-  if (typeof document === "undefined") return;
-  if (!token) {
-    document.cookie = `${WEB_AUTH_TOKEN_COOKIE}=; Path=/; Max-Age=0; SameSite=Lax`;
-    return;
-  }
-  document.cookie =
-    `${WEB_AUTH_TOKEN_COOKIE}=${encodeURIComponent(token)}; ` +
-    `Path=/; Max-Age=${PERSISTENT_AUTH_TOKEN_COOKIE_MAX_AGE_SECONDS}; SameSite=Lax`;
-}
-
-export function syncWebAuthTokenCookie(tokens: readonly string[]): void {
-  const firstToken = typeof tokens[0] === "string" && tokens[0] ? tokens[0] : null;
-  writeAuthTokenCookie(firstToken);
-}
-
-function tokenUserId(token: string): string | null {
-  const parsed = parseToken(token);
-  return typeof parsed?.userId === "string" ? parsed.userId : null;
-}
-
-export const webTokenManager: TokenManager = {
-  async getTokens() {
-    const stored = localStorage.getItem("tokens");
-    if (!stored) return [];
-    return safelyParseJSON(stored);
-  },
-
-  async storeToken(newToken: string) {
-    const tokens = await this.getTokens();
-    const newUserId = tokenUserId(newToken);
-    const filtered = tokens.filter((token) => {
-      if (token === newToken) return false;
-      return !newUserId || tokenUserId(token) !== newUserId;
-    });
-    filtered.unshift(newToken);
-    localStorage.setItem("tokens", JSON.stringify(filtered));
-    syncWebAuthTokenCookie(filtered);
-  },
-
-  async removeToken(tokenToRemove: string) {
-    const tokens = await this.getTokens();
-    const filtered = tokens.filter((t) => t !== tokenToRemove);
-    localStorage.setItem("tokens", JSON.stringify(filtered));
-    syncWebAuthTokenCookie(filtered);
-  },
-
-  async initTokens() {
-    const tokens = await this.getTokens();
-    syncWebAuthTokenCookie(tokens);
-    return tokens;
-  },
-};

package/auth/web/useRegister.ts

@@ -1,70 +0,0 @@
-import { useState } from "react";
-import { useAppDispatch } from "../../app/store";
-import { startPersonalizationDialog } from "../../ai/policy/personalizationDialog";
-import { signUp } from "../authSlice";
-import { useNavigate } from "react-router-dom";
-import { useTranslation } from "react-i18next";
-import { resolvePreferredAuthLocale } from "../locale";
-
-/**
- * 定义注册时需要提交的数据结构
- */
-interface RegisterData {
-  username: string;
-  password: string;
-  email?: string;
-  inviter?: string;
-  inviterCode?: string;
-}
-
-/**
- * 处理用户注册逻辑的自定义 Hook
- */
-const useRegister = () => {
-  const navigate = useNavigate();
-  const dispatch = useAppDispatch();
-  const { t, i18n } = useTranslation();
-  const [error, setError] = useState<string | null>(null);
-
-  /**
-   * 异步处理注册请求
-   * @param {RegisterData} data - 用户注册表单数据
-   */
-  const handleRegister = async (data: RegisterData) => {
-    // 每次尝试注册时先清空之前的错误信息
-    setError(null);
-    try {
-      const locale = resolvePreferredAuthLocale(navigator.language, [i18n.language]);
-      const result = await dispatch(signUp({ ...data, locale })).unwrap();
-
-      // 注册成功后，直接用对话完成第一轮偏好 onboarding。
-      if (result.token) {
-        try {
-          await startPersonalizationDialog({
-            dispatch,
-            navigate,
-            language: i18n.language || locale,
-            source: "signup",
-          });
-        } catch (startupError) {
-          console.error(
-            "Failed to start personalization dialog after signup:",
-            startupError
-          );
-          navigate("/");
-        }
-      }
-    } catch (err: any) {
-      console.error("Register error:", err);
-      // 从 unwrap() 抛出的错误中提取 message 属性，如果不存在则使用通用错误提示
-      const errorMessage = err?.message || err;
-      setError(
-        typeof errorMessage === "string" ? errorMessage : t("networkError")
-      );
-    }
-  };
-
-  return { handleRegister, error };
-};
-
-export default useRegister;