nolo-cli 0.1.40 → 0.1.42

package/app/utils/myContentItems.ts

@@ -0,0 +1,289 @@
+import type { AppSummary, AppSummaryRecord } from "../types/appSummary";
+import { toAppSummary } from "../types/appSummary";
+import { isAppRouteKey, resolveAppRouteKey } from "../utils/appKeys";
+import { normalizeAppRouteId } from "../../create/space/contentKeyUtils";
+import { DataType } from "../../create/types";
+import { ContentType } from "../types";
+
+export type ContentTab =
+  | "all"
+  | "app"
+  | "agent"
+  | "dialog"
+  | "page"
+  | "image"
+  | "document"
+  | "video"
+  | "audio"
+  | "table"
+  | "file";
+
+export type OwnedAppContentItem = {
+  source: "owned-app";
+  title: string;
+  type: ContentType.APP;
+  contentKey: string;
+  pinned: false;
+  createdAt: string | number;
+  updatedAt: string | number;
+  spaceId: string | null;
+  spaceName: string;
+  serverOrigin?: string;
+  app: AppSummary;
+};
+
+export type QueriedContentItem = {
+  source: "user-data";
+  title: string;
+  type: string;
+  fileCategory?: "image" | "document" | "video" | "audio" | "other";
+  mimeType?: string;
+  fileSize?: number;
+  originalName?: string;
+  contentKey: string;
+  pinned: boolean;
+  createdAt: string | number;
+  updatedAt: string | number;
+  spaceId: string | null;
+  spaceName: string;
+  serverOrigin?: string;
+};
+
+export type MyContentListItem = QueriedContentItem | OwnedAppContentItem;
+
+export const MY_CONTENT_USER_DATA_TYPES: DataType[] = [
+  DataType.APP,
+  DataType.DOC,
+  DataType.DIALOG,
+  DataType.IMAGE,
+  DataType.FILE,
+  DataType.TABLE,
+  DataType.AGENT,
+  DataType.CYBOT,
+];
+
+type UserContentRecord = Partial<AppSummaryRecord> & {
+  dbKey?: string;
+  contentKey?: string;
+  type?: string;
+  fileCategory?: "image" | "document" | "video" | "audio" | "other";
+  mimeType?: string;
+  fileSize?: number;
+  originalName?: string;
+  title?: string;
+  displayName?: string;
+  createdAt?: string | number;
+  updatedAt?: string | number;
+  created?: string | number;
+  updated_at?: string | number;
+  pinned?: boolean;
+  spaceId?: string | null;
+  serverOrigin?: string;
+};
+
+const normalizeText = (value: unknown): string =>
+  typeof value === "string" ? value.trim() : "";
+
+export const resolveUserContentRecordKey = (record: UserContentRecord): string => {
+  const contentKey = normalizeText(record.contentKey);
+  if (contentKey) return contentKey;
+  const dbKey = normalizeText(record.dbKey);
+  if (dbKey) return dbKey;
+  const appKey = normalizeText(record.appKey);
+  if (appKey) return appKey;
+  return resolveAppRouteKey(undefined, normalizeText(record.appId)) ?? "";
+};
+
+export const isUserContentAppRecord = (record: UserContentRecord): boolean => {
+  const normalizedType = normalizeText(record.type).toLowerCase();
+  const canonicalKey = resolveUserContentRecordKey(record);
+  return normalizedType === ContentType.APP || isAppRouteKey(canonicalKey);
+};
+
+export const resolveMyContentTab = (
+  item: Pick<MyContentListItem, "type" | "contentKey"> & {
+    fileCategory?: QueriedContentItem["fileCategory"];
+  }
+): ContentTab => {
+  const normalizedType = item.type?.toLowerCase();
+  const contentKey = item.contentKey;
+
+  if (normalizedType === ContentType.APP || contentKey.startsWith("app-")) return "app";
+  if (
+    normalizedType === ContentType.AGENT ||
+    normalizedType === "cybot" ||
+    contentKey.startsWith("agent-") ||
+    contentKey.startsWith("cybot-")
+  ) {
+    return "agent";
+  }
+  if (normalizedType === ContentType.DIALOG || contentKey.startsWith("dialog-")) return "dialog";
+  if (normalizedType === ContentType.DOC || contentKey.startsWith("page-")) return "page";
+  if (
+    normalizedType === ContentType.IMAGE ||
+    contentKey.startsWith("image-") ||
+    (normalizedType === ContentType.FILE && item.fileCategory === "image")
+  ) {
+    return "image";
+  }
+  if (normalizedType === ContentType.FILE && item.fileCategory === "document") {
+    return "document";
+  }
+  if (normalizedType === ContentType.FILE && item.fileCategory === "video") {
+    return "video";
+  }
+  if (normalizedType === ContentType.FILE && item.fileCategory === "audio") {
+    return "audio";
+  }
+  if (normalizedType === "table" || contentKey.startsWith("meta-")) return "table";
+  return "file";
+};
+
+const toTimestamp = (value: string | number) =>
+  typeof value === "number" ? value : Date.parse(value) || 0;
+
+const normalizeSpaceId = (spaceId: unknown): string | null => {
+  return typeof spaceId === "string" && spaceId.trim().length > 0 ? spaceId : null;
+};
+
+const resolveRecordTimestamp = (record: UserContentRecord): string | number =>
+  record.updatedAt ??
+  record.updated_at ??
+  record.createdAt ??
+  record.created ??
+  0;
+
+export function buildMyContentItemsFromUserData(
+  records: UserContentRecord[],
+  currentServer: string,
+  spaceNameById: Map<string, string>,
+  myAppsLabel: string,
+  fallbackSpaceLabel: string
+): MyContentListItem[] {
+  const items = records.flatMap((record): MyContentListItem[] => {
+    const contentKey = resolveUserContentRecordKey(record);
+    const normalizedType = normalizeText(record.type).toLowerCase();
+    const isAppRecord = isUserContentAppRecord(record);
+    const contentType = isAppRecord ? ContentType.APP : normalizedType;
+    const timestamp = resolveRecordTimestamp(record);
+    const spaceId = normalizeSpaceId(record.spaceId);
+    const spaceName = spaceId
+      ? spaceNameById.get(spaceId) ?? spaceId
+      : isAppRecord
+        ? myAppsLabel
+        : fallbackSpaceLabel;
+
+    if (isAppRecord) {
+      const app = toAppSummary(
+        {
+          ...record,
+          appKey:
+            typeof record.appKey === "string" && record.appKey.trim().length > 0
+              ? record.appKey
+              : contentKey,
+          dbKey: contentKey,
+        },
+        currentServer
+      );
+      if (!app || !(app.appKey || app.appId)) return [];
+      return [
+        {
+          source: "owned-app",
+          title: typeof app.name === "string" && app.name.trim() ? app.name : contentKey,
+          type: ContentType.APP,
+          contentKey: app.appKey ?? normalizeAppRouteId(app.appId ?? ""),
+          pinned: false,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          spaceId,
+          spaceName,
+          serverOrigin: app.serverOrigin,
+          app,
+        },
+      ];
+    }
+
+    if (!contentKey || !contentType) return [];
+
+    const title = normalizeText(record.title) ||
+      normalizeText(record.displayName) ||
+      normalizeText(record.name) ||
+      contentKey;
+
+    return [
+      {
+        source: "user-data",
+        title,
+        type: contentType,
+        fileCategory: record.fileCategory,
+        mimeType: typeof record.mimeType === "string" ? record.mimeType : undefined,
+        fileSize: typeof record.fileSize === "number" ? record.fileSize : undefined,
+        originalName:
+          typeof record.originalName === "string" && record.originalName.trim().length > 0
+            ? record.originalName
+            : undefined,
+        contentKey,
+        pinned: Boolean(record.pinned),
+        createdAt: record.createdAt ?? record.created ?? 0,
+        updatedAt: timestamp,
+        spaceId,
+        spaceName,
+        serverOrigin:
+          typeof record.serverOrigin === "string" && record.serverOrigin.trim().length > 0
+            ? record.serverOrigin
+            : undefined,
+      },
+    ];
+  });
+
+  return items.sort(
+    (left, right) => toTimestamp(right.updatedAt) - toTimestamp(left.updatedAt)
+  );
+}
+
+const previewItemKey = (item: MyContentListItem): string =>
+  `${item.source}:${item.contentKey}:${item.spaceId ?? "none"}`;
+
+export function buildMyContentPreviewItems(
+  items: MyContentListItem[],
+  limit?: number,
+  activeTab: ContentTab = "all"
+): MyContentListItem[] {
+  if (typeof limit !== "number") return items;
+  if (activeTab !== "all") return items.slice(0, limit);
+
+  const previewPriority: ContentTab[] = [
+    "app",
+    "agent",
+    "dialog",
+    "page",
+    "table",
+    "image",
+    "document",
+    "video",
+    "audio",
+    "file",
+  ];
+  const selected: MyContentListItem[] = [];
+  const selectedKeys = new Set<string>();
+
+  const pushIfNeeded = (item: MyContentListItem | undefined) => {
+    if (!item || selected.length >= limit) return;
+    const key = previewItemKey(item);
+    if (selectedKeys.has(key)) return;
+    selected.push(item);
+    selectedKeys.add(key);
+  };
+
+  for (const tab of previewPriority) {
+    pushIfNeeded(items.find((item) => resolveMyContentTab(item) === tab));
+    if (selected.length >= limit) return selected;
+  }
+
+  for (const item of items) {
+    pushIfNeeded(item);
+    if (selected.length >= limit) break;
+  }
+
+  return selected;
+}

package/app/utils/retryAfter.ts

@@ -0,0 +1,36 @@
+type HeaderLike = Pick<Headers, "get"> | null | undefined;
+
+const normalizePositiveMs = (value: unknown, fallbackMs: number) => {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed >= 0 ? Math.round(parsed) : fallbackMs;
+};
+
+export const parseRetryAfterHeaderMs = (
+  value: string | null | undefined,
+  nowMs = Date.now()
+) => {
+  if (typeof value !== "string" || !value.trim()) return null;
+
+  const trimmed = value.trim();
+  const seconds = Number(trimmed);
+  if (Number.isFinite(seconds) && seconds >= 0) {
+    return Math.round(seconds * 1_000);
+  }
+
+  const parsedDateMs = Date.parse(trimmed);
+  if (Number.isFinite(parsedDateMs)) {
+    return Math.max(0, parsedDateMs - nowMs);
+  }
+
+  return null;
+};
+
+export const resolveRetryAfterMs = (
+  headers: HeaderLike,
+  fallbackMs: number,
+  bodyRetryAfterMs?: unknown
+) => {
+  const headerDelayMs = parseRetryAfterHeaderMs(headers?.get("Retry-After"));
+  if (headerDelayMs !== null) return headerDelayMs;
+  return normalizePositiveMs(bodyRetryAfterMs, fallbackMs);
+};

package/app/utils/retryFetch.ts

@@ -0,0 +1,61 @@
+export const TRANSIENT_READ_RETRY_STATUSES = new Set([502, 503, 504]);
+
+type RetryFetchOptions = {
+  delaysMs?: number[];
+  fetchImpl?: typeof fetch;
+  retryStatuses?: Set<number>;
+  sleep?: (ms: number) => Promise<void>;
+};
+
+const DEFAULT_RETRY_DELAYS_MS = [300, 1000];
+
+const sleep = (ms: number): Promise<void> =>
+  new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+
+const getRequestMethod = (input: RequestInfo | URL, init?: RequestInit): string => {
+  if (init?.method) return init.method.toUpperCase();
+  if (typeof Request !== "undefined" && input instanceof Request) {
+    return input.method.toUpperCase();
+  }
+  return "GET";
+};
+
+const isRetryableReadMethod = (method: string): boolean =>
+  method === "GET" || method === "HEAD";
+
+const isAbortError = (error: unknown): boolean =>
+  error instanceof DOMException
+    ? error.name === "AbortError"
+    : error instanceof Error && error.name === "AbortError";
+
+export const fetchWithTransientReadRetry = async (
+  input: RequestInfo | URL,
+  init?: RequestInit,
+  options: RetryFetchOptions = {}
+): Promise<Response> => {
+  const method = getRequestMethod(input, init);
+  const canRetry = isRetryableReadMethod(method);
+  const delaysMs = options.delaysMs ?? DEFAULT_RETRY_DELAYS_MS;
+  const retryStatuses = options.retryStatuses ?? TRANSIENT_READ_RETRY_STATUSES;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const wait = options.sleep ?? sleep;
+
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const response = await fetchImpl(input, init);
+      const shouldRetry =
+        canRetry &&
+        retryStatuses.has(response.status) &&
+        attempt < delaysMs.length;
+
+      if (!shouldRetry) return response;
+    } catch (error) {
+      const shouldRetry = canRetry && !isAbortError(error) && attempt < delaysMs.length;
+      if (!shouldRetry) throw error;
+    }
+
+    await wait(delaysMs[attempt]);
+  }
+};

package/app/utils/toast.ts

@@ -0,0 +1,3 @@
+import { toast as hotToast } from "react-hot-toast";
+export const toast = hotToast;
+export default hotToast;

package/auth/action/signUpAction.ts

@@ -0,0 +1,227 @@
+// 文件路径: authSlice.ts（只包含与 signUpAction 相关部分）
+
+import {
+  selectRemoteServer,
+  selectRemoteSyncServers,
+} from "../../app/settings/settingSlice";
+import { resetAuthScopedClientState } from "../resetAuthScopedClientState";
+
+import { verifySignedMessage } from "../../core/crypto";
+import { generateUserIdV1 } from "../../core/generateMainKey";
+import { buildPersistentAuthTokenPayload, signToken, parseToken } from "../token";
+import { API_VERSION } from "../../database/config";
+import { hashPasswordV1 } from "../../core/password";
+import { generateKeyPairFromSeedV1 } from "../../core/generateKeyPairFromSeedV1";
+import { getAllServers } from "../../database/actions/common";
+
+const TIMEOUT = 5000;
+
+type SignUpSendData = {
+  username: string;
+  publicKey: string;
+  locale: string;
+  email?: string;
+  inviterId?: string;
+  clientIp?: string | null;
+};
+
+const getSignUpErrorMessage = async (response: Response): Promise<string> => {
+  try {
+    const payload = await response.clone().json();
+    if (typeof payload?.error === "string" && payload.error.trim()) {
+      return payload.error;
+    }
+    if (typeof payload?.message === "string" && payload.message.trim()) {
+      return payload.message;
+    }
+  } catch {
+    // Fall back to plain text below.
+  }
+
+  try {
+    const text = (await response.text()).trim();
+    if (text) return text;
+  } catch {
+    // Ignore text parsing errors and use the status fallback.
+  }
+
+  return `注册失败，服务器响应状态码：${response.status}`;
+};
+
+// 获取客户端公网 IP（失败时返回 null，不阻塞注册流程）
+const getPublicIp = async (): Promise<string | null> => {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), 1500);
+
+    const res = await fetch("https://api.ipify.org?format=json", {
+      signal: controller.signal,
+    });
+
+    clearTimeout(timer);
+
+    if (!res.ok) return null;
+
+    const data = await res.json();
+    return data?.ip || null;
+  } catch {
+    return null;
+  }
+};
+
+const signUpToServer = async (
+  server: string,
+  sendData: SignUpSendData,
+  nolotusPubKey: string,
+  signal?: AbortSignal
+) => {
+  const response = await fetch(`${server}${API_VERSION}/users/signup`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      ...(sendData?.clientIp
+        ? { "X-Client-IP": String(sendData.clientIp) }
+        : {}),
+    },
+    body: JSON.stringify(sendData),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(await getSignUpErrorMessage(response));
+  }
+
+  const { encryptedData } = await response.json();
+  const decryptedData = await verifySignedMessage(
+    encryptedData,
+    nolotusPubKey
+  );
+  const result = JSON.parse(decryptedData);
+  return result;
+};
+
+const signUpToBackupServers = (
+  servers: string[],
+  sendData: SignUpSendData,
+  nolotusPubKey: string
+) => {
+  servers.forEach((server) => {
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(
+      () => abortController.abort(),
+      TIMEOUT
+    );
+
+    signUpToServer(server, sendData, nolotusPubKey, abortController.signal)
+      .then((result) => {
+        clearTimeout(timeoutId);
+        if (!result) {
+          // 备份注册失败时，此处可按需记录日志或上报
+        }
+      })
+      .catch(() => {
+        clearTimeout(timeoutId);
+      });
+  });
+};
+
+export const signUpAction = async (user: any, thunkAPI: any) => {
+  const { username, locale, password, email, inviterId } = user;
+  const state = thunkAPI.getState();
+  const tokenManager = thunkAPI.extra.tokenManager;
+
+  // 1) 本地生成密钥对
+  const encryptionKey = await hashPasswordV1(password);
+  const { publicKey, secretKey } = generateKeyPairFromSeedV1(
+    username + encryptionKey + locale
+  );
+
+  // 2) 获取客户端公网 IP（失败则为 null）
+  const clientIp = await getPublicIp();
+
+  const sendData: SignUpSendData = {
+    username,
+    publicKey,
+    locale,
+    email,
+    inviterId,
+    clientIp,
+  };
+
+  const nolotusPubKey = "pqjbGua2Rp-wkh3Vip1EBV6p4ggZWtWvGyNC37kKPus";
+
+  const currentServer = selectRemoteServer(state);
+  const configuredSyncServers = selectRemoteSyncServers(state) ?? [];
+
+  // 3) 先在当前 server 上完成主注册
+  //    使用 getAllServers 只传当前服务器，做一次规范化 + 在线判断
+  const mainServers = getAllServers(currentServer, []);
+  const mainServer = mainServers[0];
+
+  if (!mainServer) {
+    throw new Error("No available server for sign up (possibly offline).");
+  }
+
+  const mainAbortController = new AbortController();
+  const mainTimeoutId = setTimeout(() => mainAbortController.abort(), TIMEOUT);
+  let remoteData: any;
+  try {
+    remoteData = await signUpToServer(
+      mainServer,
+      sendData,
+      nolotusPubKey,
+      mainAbortController.signal
+    );
+  } finally {
+    clearTimeout(mainTimeoutId);
+  }
+
+  if (!remoteData) {
+    throw new Error("Failed to register on current server");
+  }
+
+  // 4) 本地重新计算 userId，校验服务端回包一致性
+  const localUserId = generateUserIdV1(publicKey, username, locale);
+  const isValid =
+    remoteData.publicKey === publicKey &&
+    remoteData.username === username &&
+    remoteData.userId === localUserId;
+
+  if (!isValid) {
+    throw new Error("Server data does not match local data");
+  }
+
+  // 5) 异步向备份服务器同步注册
+  //    - 仅使用 settings.syncServers（去掉 currentServer）
+  //    - 使用 getAllServers(undefined, syncServers) 做去重和 URL 规范化
+  const backupCandidates = getAllServers(undefined, configuredSyncServers);
+  const backupServers = backupCandidates.filter((s) => s !== mainServer);
+
+  if (backupServers.length > 0) {
+    Promise.resolve().then(() => {
+      signUpToBackupServers(backupServers, sendData, nolotusPubKey);
+    });
+  }
+
+  // 6) 生成本地登录 token
+  const nowSec = Math.floor(Date.now() / 1000);
+  const token = signToken(
+    buildPersistentAuthTokenPayload(
+      {
+        userId: localUserId,
+        username,
+        publicKey,
+        tokenVersion: Number.isFinite(remoteData.tokenVersion)
+          ? Math.max(0, Math.floor(remoteData.tokenVersion))
+          : 0,
+      },
+      nowSec
+    ),
+    secretKey
+  );
+  await resetAuthScopedClientState(thunkAPI.dispatch);
+  await tokenManager.storeToken(token);
+  const parsedUser = parseToken(token);
+
+  return { user: parsedUser, token };
+};

package/auth/adminPermissions.ts

@@ -0,0 +1,78 @@
+export const ADMIN_PERMISSION_DEFINITIONS = [
+  {
+    key: "usageManagement",
+    label: "用量管理",
+    shortLabel: "用量",
+    description: "查看用量报表、模型与提供商用量相关数据",
+  },
+  {
+    key: "growthStats",
+    label: "增长统计",
+    shortLabel: "增长",
+    description: "查看 7 天/30 天活跃、新增用户与增长趋势",
+  },
+] as const;
+
+export type AdminPermissionKey = (typeof ADMIN_PERMISSION_DEFINITIONS)[number]["key"];
+
+export type AdminPermissions = Partial<Record<AdminPermissionKey, boolean>>;
+
+const ADMIN_PERMISSION_KEYS = new Set<AdminPermissionKey>(
+  ADMIN_PERMISSION_DEFINITIONS.map((definition) => definition.key)
+);
+
+export const isAdminPermissionKey = (value: string): value is AdminPermissionKey =>
+  ADMIN_PERMISSION_KEYS.has(value as AdminPermissionKey);
+
+export const hasUsageManagementPermission = (value: unknown): boolean => {
+  return hasAdminPermission(value, "usageManagement");
+};
+
+export const hasGrowthStatsPermission = (value: unknown): boolean => {
+  return hasAdminPermission(value, "growthStats");
+};
+
+export const hasAdminPermission = (
+  value: unknown,
+  permissionKey: AdminPermissionKey
+): boolean => {
+  if (!value || typeof value !== "object") return false;
+  const permissions = (value as { adminPermissions?: AdminPermissions | null })
+    .adminPermissions;
+  return permissions?.[permissionKey] === true;
+};
+
+export const mergeAdminPermissions = (
+  current: unknown,
+  patch: Partial<AdminPermissions>
+): AdminPermissions => ({
+  ...(current && typeof current === "object" ? (current as AdminPermissions) : {}),
+  ...patch,
+});
+
+export const parseAdminPermissionsPatch = (
+  value: unknown
+):
+  | { ok: true; patch: Partial<AdminPermissions> }
+  | { ok: false; error: string } => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return { ok: false, error: "admin permissions patch must be an object" };
+  }
+
+  const patch: Partial<AdminPermissions> = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (!isAdminPermissionKey(key)) {
+      return { ok: false, error: `Unsupported admin permission: ${key}` };
+    }
+    if (typeof rawValue !== "boolean") {
+      return { ok: false, error: `${key} must be boolean` };
+    }
+    patch[key] = rawValue;
+  }
+
+  if (Object.keys(patch).length === 0) {
+    return { ok: false, error: "admin permissions patch cannot be empty" };
+  }
+
+  return { ok: true, patch };
+};