nolo-cli 0.1.26 → 0.1.29

package/auth/client/deleteUserRequest.ts

@@ -0,0 +1,86 @@
+import { authRoutes } from "../routes";
+
+export const deleteUserRequest = async (
+  currentServer: string,
+  token: string,
+  userId: string
+) => {
+  const path = authRoutes.users.delete.createPath({ userId });
+
+  return fetch(`${currentServer}${path}`, {
+    method: authRoutes.users.delete.method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+    },
+  });
+};
+
+export interface DeleteUserAcrossServersParams {
+  servers: string[];
+  token: string;
+  userId: string;
+}
+
+export interface DeleteUserAcrossServersResult {
+  server: string;
+  ok: boolean;
+  status: number | null;
+  required: boolean;
+}
+
+export class DeleteUserAcrossServersError extends Error {
+  results: DeleteUserAcrossServersResult[];
+
+  constructor(results: DeleteUserAcrossServersResult[]) {
+    super("Failed to delete user on all configured servers");
+    this.name = "DeleteUserAcrossServersError";
+    this.results = results;
+  }
+}
+
+const buildDeleteFailureMessage = (results: DeleteUserAcrossServersResult[]) =>
+  results
+    .filter((result) => !result.ok)
+    .map((result) => `${result.server}(${result.status ?? "network"})`)
+    .join(", ");
+
+export const deleteUserAcrossServers = async ({
+  servers,
+  token,
+  userId,
+}: DeleteUserAcrossServersParams): Promise<DeleteUserAcrossServersResult[]> => {
+  if (!servers.length) {
+    throw new Error("No configured servers available for account deletion");
+  }
+
+  const results = await Promise.all(
+    servers.map(async (server, index): Promise<DeleteUserAcrossServersResult> => {
+      const required = index === 0;
+      try {
+        const response = await deleteUserRequest(server, token, userId);
+        return {
+          server,
+          ok: response.ok || response.status === 404,
+          status: response.status,
+          required,
+        };
+      } catch {
+        return {
+          server,
+          ok: false,
+          status: null,
+          required,
+        };
+      }
+    })
+  );
+
+  if (results.some((result) => result.required && !result.ok)) {
+    const error = new DeleteUserAcrossServersError(results);
+    error.message = `Failed to delete user on primary server: ${buildDeleteFailureMessage(results.filter((result) => result.required))}`;
+    throw error;
+  }
+
+  return results;
+};

package/auth/client/loginRequest.ts

@@ -0,0 +1,14 @@
+// auth/api.ts
+import { authRoutes } from "../routes";
+
+export const loginRequest = async (currentServer: string, data: any) => {
+  const path = authRoutes.login.createPath();
+
+  return fetch(`${currentServer}${path}`, {
+    method: authRoutes.login.method,
+    headers: {
+      "Content-Type": "application/json",
+    },
+    body: JSON.stringify(data),
+  });
+};

package/auth/hooks/useAuth.ts

@@ -0,0 +1,9 @@
+import { useAppSelector } from "../../app/store";
+import { selectCurrentUser, selectIsLoggedIn } from "../authSlice";
+
+export const useAuth = () => {
+  const user = useAppSelector(selectCurrentUser);
+  const isLoggedIn = useAppSelector(selectIsLoggedIn);
+
+  return { user, isLoggedIn };
+};

package/auth/hooks/useDeleteOwnAccount.ts

@@ -0,0 +1,50 @@
+import { useCallback } from "react";
+import pino from "pino";
+
+import { useAppSelector } from "../../app/store";
+import { selectRemoteServers } from "../../app/settings/settingSlice";
+import { deleteUserAcrossServers } from "../client/deleteUserRequest";
+import { selectCurrentToken, selectCurrentUser } from "../authSlice";
+
+const logger = pino({ name: "useDeleteOwnAccount" });
+
+export function useDeleteOwnAccount(onSuccess?: () => void) {
+  const servers = useAppSelector(selectRemoteServers);
+  const token = useAppSelector(selectCurrentToken);
+  const currentUser = useAppSelector(selectCurrentUser);
+
+  return useCallback(async () => {
+    if (!servers.length || !token || !currentUser?.userId) {
+      const error = new Error("Missing remote servers, token, or current user");
+      logger.error({ err: error }, "Delete own account failed before request");
+      throw error;
+    }
+
+    try {
+      logger.info({ userId: currentUser.userId, primaryServer: servers[0] }, "Deleting own account");
+
+      const results = await deleteUserAcrossServers({
+        servers,
+        token,
+        userId: currentUser.userId,
+      });
+
+      const replicaFailures = results.filter((result) => !result.required && !result.ok);
+      if (replicaFailures.length > 0) {
+        logger.warn(
+          { userId: currentUser.userId, results: replicaFailures },
+          "Own account deletion skipped failed replica servers"
+        );
+      }
+
+      logger.info({ userId: currentUser.userId }, "Own account deleted");
+      onSuccess?.();
+    } catch (err) {
+      logger.error(
+        { err, userId: currentUser.userId, results: (err as any)?.results },
+        "Delete own account failed"
+      );
+      throw err;
+    }
+  }, [currentUser?.userId, onSuccess, servers, token]);
+}

package/auth/hooks/useDeleteOwnAccountFlow.ts

@@ -0,0 +1,66 @@
+import { useCallback, useState } from "react";
+
+import { useAppDispatch } from "../../app/store";
+import { signOut } from "../authSlice";
+
+import { useDeleteOwnAccount } from "./useDeleteOwnAccount";
+
+interface DeleteOwnAccountFlowOptions {
+  afterSignOut: () => void;
+  onDeleteSucceeded?: () => void;
+  onDeleteFailed?: (error: unknown) => void;
+  onLocalCleanupFailed?: (error: unknown) => void;
+}
+
+export function useDeleteOwnAccountFlow({
+  afterSignOut,
+  onDeleteSucceeded,
+  onDeleteFailed,
+  onLocalCleanupFailed,
+}: DeleteOwnAccountFlowOptions) {
+  const dispatch = useAppDispatch();
+  const deleteOwnAccount = useDeleteOwnAccount();
+  const [isDeletingAccount, setIsDeletingAccount] = useState(false);
+
+  const deleteAccount = useCallback(async () => {
+    if (isDeletingAccount) {
+      return false;
+    }
+
+    let deletionSucceeded = false;
+    setIsDeletingAccount(true);
+
+    try {
+      await deleteOwnAccount();
+      deletionSucceeded = true;
+      onDeleteSucceeded?.();
+      await dispatch(signOut() as any).unwrap();
+      afterSignOut();
+      return true;
+    } catch (error) {
+      if (deletionSucceeded) {
+        onLocalCleanupFailed?.(error);
+        afterSignOut();
+        return true;
+      }
+
+      onDeleteFailed?.(error);
+      return false;
+    } finally {
+      setIsDeletingAccount(false);
+    }
+  }, [
+    afterSignOut,
+    deleteOwnAccount,
+    dispatch,
+    isDeletingAccount,
+    onDeleteFailed,
+    onDeleteSucceeded,
+    onLocalCleanupFailed,
+  ]);
+
+  return {
+    deleteAccount,
+    isDeletingAccount,
+  };
+}

package/auth/hooks/useDeleteUser.ts

@@ -0,0 +1,45 @@
+// auth/hooks/useDeleteUser.ts
+import { useCallback } from "react";
+import { useAppSelector } from "../../app/store";
+import { selectRemoteServers } from "../../app/settings/settingSlice";
+import { selectCurrentToken } from "../authSlice";
+import pino from "pino";
+import { deleteUserAcrossServers } from "../client/deleteUserRequest";
+
+const logger = pino({ name: "useDeleteUser" });
+
+export function useDeleteUser(onSuccess?: () => void) {
+  const servers = useAppSelector(selectRemoteServers);
+  const token = useAppSelector(selectCurrentToken);
+
+  return useCallback(
+    async (userId: string) => {
+      if (!servers.length || !token) {
+        const error = new Error("Missing remote servers or token");
+        logger.error({ err: error }, "Delete failed before request");
+        throw error;
+      }
+
+      try {
+        logger.info({ userId, primaryServer: servers[0] }, "Deleting user");
+        const results = await deleteUserAcrossServers({
+          servers,
+          token,
+          userId,
+        });
+
+        const replicaFailures = results.filter((result) => !result.required && !result.ok);
+        if (replicaFailures.length > 0) {
+          logger.warn({ userId, results: replicaFailures }, "User deletion skipped failed replica servers");
+        }
+
+        logger.info({ userId }, "User deleted");
+        onSuccess?.();
+      } catch (err) {
+        logger.error({ err, userId, results: (err as any)?.results }, "Delete failed");
+        throw err;
+      }
+    },
+    [servers, token, onSuccess]
+  );
+}

package/auth/hooks/useEnableUser.ts

@@ -0,0 +1,50 @@
+// auth/hooks/useEnableUser.ts
+import { useCallback } from "react";
+import { useAppSelector } from "../../app/store";
+import { selectRemoteServer } from "../../app/settings/settingSlice";
+import { selectCurrentToken } from "../authSlice";
+import pino from "pino";
+import { authRoutes } from "../routes";
+
+const logger = pino({ name: "useEnableUser" });
+
+export function useEnableUser(onSuccess?: () => void) {
+  const serverUrl = useAppSelector(selectRemoteServer);
+  const token = useAppSelector(selectCurrentToken);
+
+  return useCallback(
+    async (userId: string) => {
+      if (!serverUrl || !token) {
+        logger.error("Missing serverUrl or token");
+        return;
+      }
+
+      try {
+        // 假设 authRoutes.users.enable 提供了启用用户的路径和方法
+        const path = authRoutes.users.enable.createPath({ userId });
+        const url = `${serverUrl}${path}`;
+
+        logger.info({ userId, url }, "Enabling user");
+
+        const response = await fetch(url, {
+          method: authRoutes.users.enable.method, // 假设为 POST
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+          },
+        });
+
+        if (!response.ok) {
+          throw new Error(`HTTP ${response.status}`);
+        }
+
+        logger.info({ userId }, "User enabled");
+        onSuccess?.();
+      } catch (err) {
+        logger.error({ err, userId }, "Enable failed");
+        throw err;
+      }
+    },
+    [serverUrl, token, onSuccess]
+  );
+}

package/auth/hooks/useFetchUsers.ts

@@ -0,0 +1,77 @@
+// hooks/useFetchUsers.ts
+import { useCallback } from "react";
+import { useAppSelector } from "../../app/store";
+import { selectRemoteServer } from "../../app/settings/settingSlice";
+import { selectCurrentToken } from "../authSlice";
+import { authRoutes } from "../routes";
+
+const PAGE_SIZE = 10;
+
+interface User {
+  id: string;
+  username: string;
+  email: string;
+  balance: number;
+  createdAt?: number | string;
+  lastLoginAt?: number | string | null;
+  lastActiveAt?: number | string | null;
+  welcomeEmailSentAt?: number | string | null;
+  onboardingGuideSentAt?: number | string | null;
+  lastReengagementEmailAt?: number | string | null;
+  reengagementEmailCount?: number;
+  emailOptOutAll?: boolean;
+  emailMutedUntil?: number | string | null;
+  emailOptOutTags?: string[];
+  isDisabled?: boolean;
+}
+
+interface FetchUsersResult {
+  list: User[];
+  total: number;
+  currentPage: number;
+  totalPages: number;
+  hasMore: boolean;
+}
+
+export function useFetchUsers() {
+  const serverUrl = useAppSelector(selectRemoteServer);
+  const token = useAppSelector(selectCurrentToken);
+
+  return useCallback(
+    async (page: number, search?: string): Promise<FetchUsersResult | null> => {
+      if (!serverUrl || !token) {
+        return null;
+      }
+
+      const path = authRoutes.users.list.createPath();
+      const url = new URL(`${serverUrl}${path}`);
+      url.searchParams.append("page", page.toString());
+      url.searchParams.append("pageSize", PAGE_SIZE.toString());
+      if (search) {
+        // 新增：如果有搜索关键字，添加到 URL 参数
+        url.searchParams.append("search", search);
+      }
+
+      try {
+        const response = await fetch(url.toString(), {
+          method: authRoutes.users.list.method,
+          headers: {
+            Authorization: `Bearer ${token}`,
+          },
+        });
+
+        if (!response.ok) {
+          const errorMessage = `HTTP error! status: ${response.status}`;
+          throw new Error(errorMessage);
+        }
+
+        const data = await response.json();
+
+        return data;
+      } catch (err) {
+        throw err;
+      }
+    },
+    [serverUrl, token]
+  );
+}

package/auth/hooks/useRechargeUser.ts

@@ -0,0 +1,82 @@
+// hooks/useRechargeUser.ts
+import { ulid } from "ulid";
+import { useCallback } from "react";
+import { useAppDispatch } from "../../app/store";
+import { write } from "../../database/dbSlice";
+import { DataType } from "../../create/types";
+import pino from "pino";
+
+const logger = pino({ name: "useRechargeUser" });
+
+interface Transaction {
+  type: DataType.TRANSACTION;
+  transactionType: "recharge";
+  toUserId: string; // 改为 toUserId
+  amount: number;
+  reason: string;
+  timestamp: number;
+}
+
+export class RechargeError extends Error {
+  constructor(
+    message: string,
+    public readonly cause?: unknown
+  ) {
+    super(message);
+    this.name = "RechargeError";
+  }
+}
+
+export function useRechargeUser(onSuccess?: () => void) {
+  const dispatch = useAppDispatch();
+
+  return useCallback(
+    async (
+      toUserId: string,
+      amount: number,
+      reason: string = "admin_recharge"
+    ): Promise<void> => {
+      // 参数名改为 toUserId
+      // 参数验证
+      if (!toUserId?.trim()) {
+        throw new RechargeError("Invalid target user ID");
+      }
+
+      if (typeof amount !== "number" || amount <= 0) {
+        throw new RechargeError("Invalid amount");
+      }
+
+      const txId = ulid();
+
+      logger.debug({ toUserId, amount, txId }, "Starting recharge transaction");
+
+      try {
+        const transaction: Transaction = {
+          type: DataType.TRANSACTION,
+          transactionType: "recharge",
+          toUserId, // 字段名改为 toUserId
+          amount,
+          reason,
+          timestamp: Date.now(),
+        };
+
+        await dispatch(
+          write({
+            data: transaction,
+            customKey: txId,
+          })
+        ).unwrap();
+
+        logger.info({ toUserId, amount, txId }, "Recharge successful");
+        onSuccess?.();
+      } catch (err) {
+        logger.error(
+          { err, toUserId, amount, txId },
+          "Recharge transaction failed"
+        );
+        throw new RechargeError("充值失败，请重试", err);
+      }
+    },
+    [dispatch, onSuccess]
+  );
+}

package/auth/index.ts

@@ -0,0 +1 @@
+console.log("Hello via Bun!");

package/auth/invite.ts

@@ -0,0 +1,19 @@
+export const INVITE_REWARD_REASON_PREFIX = "invite_reward_for_";
+export const INVITE_REWARD_TX_PREFIX = "invite_reward";
+
+export const buildInviteRewardReason = (inviteeUserId: string) =>
+  `${INVITE_REWARD_REASON_PREFIX}${inviteeUserId}`;
+
+export const parseInviteeIdFromRewardReason = (reason: string) =>
+  reason.startsWith(INVITE_REWARD_REASON_PREFIX)
+    ? reason.slice(INVITE_REWARD_REASON_PREFIX.length)
+    : "";
+
+export const buildInviteRewardTxId = (
+  inviteeUserId: string,
+  inviteeCreatedAt: number
+) =>
+  `${INVITE_REWARD_TX_PREFIX}_${String(Math.trunc(inviteeCreatedAt)).padStart(
+    13,
+    "0"
+  )}_${inviteeUserId}`;

package/auth/locale.ts

@@ -0,0 +1,84 @@
+const DEFAULT_AUTH_LOCALE = "en-US";
+
+const ZH_LOCALE_CANDIDATES = ["zh-CN", "zh-Hans-CN", "zh-Hans", "zh-SG", "zh-TW", "zh-HK", "zh"];
+const EN_LOCALE_CANDIDATES = ["en-US", "en-GB", "en"];
+
+const canonicalizeLocale = (value?: string | null): string | null => {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim().replace(/_/g, "-");
+  if (!trimmed) return null;
+
+  try {
+    if (typeof Intl !== "undefined" && typeof Intl.Locale === "function") {
+      return new Intl.Locale(trimmed).toString();
+    }
+  } catch {
+    // Fall through to manual normalization.
+  }
+
+  const [language, ...rest] = trimmed.split("-");
+  if (!language) return null;
+  const normalizedRest = rest.map((segment) => {
+    if (segment.length === 2) return segment.toUpperCase();
+    if (segment.length === 4) {
+      return segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase();
+    }
+    return segment;
+  });
+  return [language.toLowerCase(), ...normalizedRest].join("-");
+};
+
+const getLocaleFamily = (value?: string | null): string | null => {
+  const canonical = canonicalizeLocale(value);
+  if (!canonical) return null;
+  const [language] = canonical.split("-");
+  return language || null;
+};
+
+const addUniqueLocale = (target: string[], value?: string | null) => {
+  const canonical = canonicalizeLocale(value);
+  if (!canonical || target.includes(canonical)) return;
+  target.push(canonical);
+};
+
+const addLocaleFamilyFallbacks = (target: string[], family?: string | null) => {
+  if (family === "zh") {
+    ZH_LOCALE_CANDIDATES.forEach((locale) => addUniqueLocale(target, locale));
+    return;
+  }
+  if (family === "en") {
+    EN_LOCALE_CANDIDATES.forEach((locale) => addUniqueLocale(target, locale));
+    return;
+  }
+  addUniqueLocale(target, family);
+};
+
+export const buildAuthLoginLocaleCandidates = (
+  primaryLocale?: string | null,
+  extras: Array<string | null | undefined> = []
+): string[] => {
+  const candidates: string[] = [];
+  [primaryLocale, ...extras].forEach((locale) => addUniqueLocale(candidates, locale));
+
+  const families = [primaryLocale, ...extras]
+    .map((locale) => getLocaleFamily(locale))
+    .filter((locale): locale is string => Boolean(locale));
+
+  families.forEach((family) => addLocaleFamilyFallbacks(candidates, family));
+  if (candidates.length === 0) {
+    candidates.push(DEFAULT_AUTH_LOCALE);
+  }
+  return candidates;
+};
+
+export const resolvePreferredAuthLocale = (
+  primaryLocale?: string | null,
+  extras: Array<string | null | undefined> = []
+): string => {
+  const family = getLocaleFamily(primaryLocale) || extras.map((locale) => getLocaleFamily(locale)).find(Boolean);
+  if (family === "zh") return "zh-CN";
+  if (family === "en") return "en-US";
+
+  const candidates = buildAuthLoginLocaleCandidates(primaryLocale, extras);
+  return candidates[0] || DEFAULT_AUTH_LOCALE;
+};

package/auth/resetAuthScopedClientState.ts

@@ -0,0 +1,27 @@
+import { clearPlan } from "../ai/agent/planSlice";
+import { clearWorkflow } from "../ai/workflow/workflowSlice";
+import { resetFavorites } from "../app/favorite/favoriteSlice";
+import { clearDefaultSpaceId } from "../app/settings/settingSlice";
+import {
+  abortAllMessages,
+  clearDialogState,
+  clearPendingAttachments,
+  clearPendingUserInputQueue,
+} from "../chat/dialog/dialogSlice";
+import { resetMsgs } from "../chat/messages/messageSlice";
+import { resetSpace } from "../create/space/spaceSlice";
+
+export const resetAuthScopedClientState = async (dispatch: any) => {
+  await dispatch(abortAllMessages({ all: true })).unwrap();
+  // The remaining clears are synchronous slice reducers, so inline dispatch
+  // order is sufficient and intentionally not modeled as async work.
+  dispatch(clearPendingAttachments({ all: true }));
+  dispatch(clearDialogState());
+  dispatch(clearPendingUserInputQueue({ all: true }));
+  dispatch(resetMsgs({ all: true }));
+  dispatch(clearPlan());
+  dispatch(clearWorkflow());
+  dispatch(resetFavorites());
+  dispatch(resetSpace());
+  dispatch(clearDefaultSpaceId());
+};

package/auth/rn/tokenManager.ts

@@ -0,0 +1,72 @@
+// auth/rn/tokenManager.ts
+import * as Keychain from "react-native-keychain";
+import type { TokenManager } from "../types";
+import { safelyParseJSON } from "../types";
+import { parseToken } from "../token";
+
+const STORAGE_KEY = "app_tokens";
+
+function tokenUserId(token: string): string | null {
+  const parsed = parseToken(token);
+  return typeof parsed?.userId === "string" ? parsed.userId : null;
+}
+
+export const rnTokenManager: TokenManager = {
+  async getTokens() {
+    try {
+      const credentials = await Keychain.getGenericPassword({
+        service: STORAGE_KEY,
+      });
+      if (!credentials) return [];
+      const tokens = safelyParseJSON(credentials.password);
+      return Array.isArray(tokens) ? tokens : [tokens];
+    } catch (error) {
+      console.error("Failed to get tokens:", error);
+      return [];
+    }
+  },
+
+  async storeToken(newToken: string) {
+    if (!newToken) return;
+    try {
+      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);
+      await Keychain.setGenericPassword(STORAGE_KEY, JSON.stringify(filtered), {
+        service: STORAGE_KEY,
+      });
+    } catch (error) {
+      console.error("Failed to store tokens:", error);
+    }
+  },
+
+  async removeToken(tokenToRemove: string) {
+    if (!tokenToRemove) return;
+    try {
+      const tokens = await this.getTokens();
+      const filtered = tokens.filter((token) => token !== tokenToRemove);
+      await Keychain.setGenericPassword(STORAGE_KEY, JSON.stringify(filtered), {
+        service: STORAGE_KEY,
+      });
+    } catch (error) {
+      console.error("Failed to remove token:", error);
+    }
+  },
+
+  async initTokens() {
+    return this.getTokens();
+  },
+};
+
+// 可选: 如果需要清除所有token的功能
+export const clearAllTokens = async () => {
+  try {
+    await Keychain.resetGenericPassword({ service: STORAGE_KEY });
+  } catch (error) {
+    console.error("Failed to clear tokens:", error);
+  }
+};