nolo-cli 0.1.12 → 0.1.14

package/database/actions/common.ts

@@ -0,0 +1,242 @@
+// 文件路径: database/actions/common.ts
+
+import pino from "pino";
+import { getIsDesktopApp } from "app/utils/env";
+import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS } from "../config";
+
+// RN 下 pino 的 browser 写法可能有兼容性问题
+// 使用简单的 console 封装作为 fallback
+const isRN = typeof navigator !== 'undefined' && (navigator as any).product === 'ReactNative';
+
+export const logger = isRN ? {
+  info: (...args: any[]) => console.log(...args),
+  warn: (...args: any[]) => console.warn(...args),
+  error: (...args: any[]) => console.error(...args),
+  debug: (...args: any[]) => console.log(...args), // console.debug in RN behaves like log
+  trace: (...args: any[]) => console.log(...args),
+  fatal: (...args: any[]) => console.error(...args),
+  child: () => logger // 简单返回自己
+} as unknown as pino.Logger : pino({
+  level: "info",
+  // transport: {
+  //   target: "pino-pretty",
+  // },
+});
+const normalizeServer = (server: string): string =>
+  server.trim().replace(/\/+$/, "");
+const isNoloClusterServer = (server: string): boolean =>
+  /^https?:\/\/(?:us\.)?nolo\.chat$/i.test(normalizeServer(server));
+
+export const mergeConfiguredServers = (
+  currentServer: string | undefined,
+  syncServers: string[] | undefined
+): string[] => {
+  const runtimeOrigin =
+    !getIsDesktopApp() &&
+      typeof window !== "undefined" &&
+      typeof window.location?.origin === "string" &&
+      /^https?:\/\//.test(window.location.origin)
+      ? window.location.origin
+      : undefined;
+
+  const raw = [
+    currentServer,
+    ...(Array.isArray(syncServers) ? syncServers : []),
+    runtimeOrigin,
+  ].filter(
+    (s): s is string => typeof s === "string" && s.trim().length > 0
+  );
+
+  const normalized = raw.map(normalizeServer);
+  if (normalized.some(isNoloClusterServer)) {
+    normalized.push(...NOLO_CLUSTER_SERVERS);
+  }
+  return Array.from(new Set(normalized));
+};
+// 全局缓存网络状态（仅 React Native 使用）
+let cachedNetworkState: boolean | null = null;
+let netInfoListenerInitialized = false;
+
+// 检测是否为 React Native 环境
+const isReactNative = (): boolean => {
+  return typeof navigator !== 'undefined' && (navigator as any).product === 'ReactNative';
+};
+
+// 初始化 NetInfo 监听器（仅在 React Native 环境调用）
+export const initNetworkListener = async () => {
+  if (!isReactNative() || netInfoListenerInitialized) return;
+
+  try {
+    // 动态导入 NetInfo，避免在 Web 环境下出错
+    const NetInfo = await import('@react-native-community/netinfo');
+    NetInfo.default.addEventListener(state => {
+      cachedNetworkState = state.isConnected ?? true;
+    });
+    netInfoListenerInitialized = true;
+    console.log('[NetInfo] Listener initialized');
+  } catch (error) {
+    console.warn('[NetInfo] Failed to initialize:', error);
+  }
+};
+
+// 改进的 isOnline 函数，兼容 Web 和 React Native
+export const isOnline = (): boolean => {
+  // React Native 环境：使用 NetInfo 缓存
+  if (isReactNative()) {
+    if (cachedNetworkState !== null) {
+      return cachedNetworkState;
+    }
+    // NetInfo 还未初始化，默认假设在线
+    return true;
+  }
+
+  // Web 环境：使用 navigator.onLine
+  if (typeof navigator !== "undefined" && typeof (navigator as any).onLine !== "undefined") {
+    return (navigator as any).onLine;
+  }
+
+  // 降级：默认假设在线
+  return true;
+};
+
+export const getAllServers = (
+  currentServer: string | undefined,
+  syncServers: string[] | undefined,
+  preferredServer?: string | null
+): string[] => {
+  const preferredNormalized =
+    typeof preferredServer === "string" && preferredServer.trim().length > 0
+      ? normalizeServer(preferredServer)
+      : null;
+  const servers = mergeConfiguredServers(
+    currentServer,
+    preferredNormalized && isNoloClusterServer(preferredNormalized)
+      ? [...(Array.isArray(syncServers) ? syncServers : []), preferredNormalized]
+      : syncServers
+  );
+  if (!preferredServer || typeof preferredServer !== "string") {
+    return servers;
+  }
+
+  const remaining = servers.filter(
+    (server) => normalizeServer(server) !== preferredNormalized
+  );
+  return preferredNormalized ? [preferredNormalized, ...remaining] : remaining;
+};
+
+const isLevelNotFoundError = (err: any): boolean => {
+  const code = err?.code;
+  return (
+    err?.notFound === true ||
+    err?.name === "NotFoundError" ||
+    code === "LEVEL_NOT_FOUND" ||
+    code === "LEVEL_NOT_FOUND_ERROR"
+  );
+};
+
+
+// 从客户端数据库获取数据 (无需改动)
+export const fetchFromClientDb = async (
+  clientDb: any,
+  dbKey: string
+): Promise<any> => {
+  if (!clientDb) {
+    logger.error(
+      { dbKey },
+      "Client database is undefined in fetchFromClientDb"
+    );
+    return null;
+  }
+  try {
+    return await clientDb.get(dbKey);
+  } catch (err) {
+    if (isLevelNotFoundError(err)) {
+      return null;
+    }
+    logger.error({ err, dbKey }, "Failed to get local data");
+    return null;
+  }
+};
+
+// ======================================================================
+// 【核心改造】: fetchFromServer 函数
+// ======================================================================
+const SERVER_TIMEOUT = 5000;
+export const READ_TIMEOUT_ERROR_NAME = "ReadTimeoutError";
+const isPublicFileDbKey = (dbKey: string): boolean => dbKey.startsWith("file-");
+// file-* 元数据接口对无 token 的 LLM/工具调用开放（仅 metadata）；
+// 常规 read 接口保留认证路径，避免普通业务数据被未授权盗链/枚举。
+const buildReadUrl = (dbKey: string): string =>
+  isPublicFileDbKey(dbKey)
+    ? `${API_ENDPOINTS.DATABASE}/file/metadata/${encodeURIComponent(dbKey)}`
+    : `${API_ENDPOINTS.DATABASE}/read/${encodeURIComponent(dbKey)}`;
+
+const createReadTimeoutError = (server: string, dbKey: string): Error => {
+  const error = new Error(
+    `Timed out reading key "${dbKey}" from ${normalizeServer(server)}.`
+  );
+  error.name = READ_TIMEOUT_ERROR_NAME;
+  return error;
+};
+
+export const isReadTimeoutError = (error: unknown): boolean =>
+  error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
+
+export const fetchFromServer = async (
+  server: string,
+  dbKey: string,
+  token?: string,
+  signal?: AbortSignal
+): Promise<any> => {
+  if (signal?.aborted) {
+    throw new DOMException("Aborted", "AbortError");
+  }
+
+  const controller = new AbortController();
+  let didTimeout = false;
+  const timeoutId = setTimeout(() => {
+    didTimeout = true;
+    controller.abort();
+  }, SERVER_TIMEOUT);
+  const onExternalAbort = () => controller.abort();
+  signal?.addEventListener("abort", onExternalAbort);
+
+  try {
+    const res = await fetch(
+      `${server}${buildReadUrl(dbKey)}`,
+      {
+        signal: controller.signal as any,
+        headers: {
+          "Content-Type": "application/json",
+          ...(token && { Authorization: `Bearer ${token}` }),
+        },
+      }
+    );
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+
+    if (res.status === 200) {
+      return await res.json();
+    }
+    return null;
+  } catch (err: any) {
+    clearTimeout(timeoutId);
+    signal?.removeEventListener("abort", onExternalAbort);
+    if (didTimeout) {
+      throw createReadTimeoutError(server, dbKey);
+    }
+    if (signal?.aborted || err.name === "AbortError") {
+      throw err;
+    }
+    return null;
+  }
+};
+
+// 规范化时间字段 (无需改动)
+export const normalizeTimeFields = (data: any): any => ({
+  ...data,
+  createdAt: data.createdAt || new Date().toISOString(),
+  updatedAt: new Date().toISOString(),
+  updated_at: undefined,
+  created_at: undefined,
+});

package/database/actions/deleteFile.ts

@@ -0,0 +1,40 @@
+
+import { removeAction } from "./remove";
+import { fetchFromClientDb } from "./common";
+import { deleteFileFromIndexedDb } from "../fileStorage";
+import { logger } from "./common";
+
+/**
+ * Delete File Action:
+ * 1. Retrieve metadata to get fileId (if different from dbKey, though usually dbKey maps to metadata which has the fileId)
+ * 2. Delete blob from IndexedDB (using fileId from metadata)
+ * 3. Call generic removeAction to delete metadata and notify servers
+ */
+export const deleteFileAction = async (
+    dbKey: string,
+    thunkApi: any
+): Promise<void> => {
+    const { db: clientDb } = thunkApi.extra;
+
+    try {
+        // 1. Get metadata to find the internal Blob ID (fileId)
+        const metadata = await fetchFromClientDb(clientDb, dbKey);
+
+        if (metadata && metadata.id) {
+            // 2. Delete blob from IndexedDB
+            try {
+                await deleteFileFromIndexedDb(metadata.id);
+                logger.debug({ fileId: metadata.id }, "Deleted file blob from IndexedDB");
+            } catch (err) {
+                logger.warn({ err, fileId: metadata.id }, "Failed to delete file blob from IndexedDB, proceeding to delete metadata");
+            }
+        }
+
+        // 3. Delete metadata and sync delete to servers
+        await removeAction(dbKey, thunkApi);
+
+    } catch (error) {
+        logger.error({ error, dbKey }, "Failed to delete file completely");
+        throw error;
+    }
+}

package/database/actions/fetchUserData.ts

@@ -0,0 +1,16 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import { fetchUserData } from "../client/fetchUserData";
+import { AppThunkApi } from "app/store";
+
+export const fetchUserDataThunk = createAsyncThunk<
+    any,
+    { types: string | string[]; userId: string; includeDeleted?: boolean },
+    AppThunkApi
+>("db/fetchUserData", async ({ types, userId, includeDeleted }, { extra }) => {
+    const { db } = extra;
+    if (!db) {
+        console.error("Database not available in fetchUserDataThunk");
+        throw new Error("Database not available");
+    }
+    return await fetchUserData(db, types, userId, { includeDeleted });
+});

package/database/actions/fileContent.ts

@@ -0,0 +1,125 @@
+// 文件路径: database/actions/fileContent.ts
+
+import type { AppThunkApi } from "app/store";
+import { API_ENDPOINTS } from "database/config";
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+import {
+    loadFileFromIndexedDb,
+    saveFileToIndexedDb,
+    StoredFileRecord,
+} from "../fileStorage";
+import { getFileIdFromKey } from "../keys";
+
+/**
+ * 从 dbKey 中提取裸 ULID（用于 IndexedDB 查找）
+ *
+ * 如果传入的是完整 dbKey（如 file-{userId}-{fileId}），返回 fileId（ULID）。
+ * 如果传入的已经是裸 ULID，则原样返回。
+ */
+const resolveLocalFileId = (fileId: string): string => {
+    if (fileId.startsWith("file-")) {
+        return getFileIdFromKey(fileId) || fileId;
+    }
+    return fileId;
+};
+
+/**
+ * 读取文件内容（优先本地 IndexedDB，缺失时从服务器拉取并写入本地缓存）
+ *
+ * fileId 支持两种格式：
+ * - 完整 dbKey：file-{userId}-{fileId}（推荐，服务端可直接查询）
+ * - 裸 ULID：{fileId}（需要服务端 file-id 索引）
+ *
+ * 返回：
+ * - fileId: string
+ * - blob: Blob
+ * - source: "local" | "remote"
+ */
+export const readFileContentAction = async (
+    {
+        fileId,
+        useServerFallback = true,
+    }: { fileId: string; useServerFallback?: boolean },
+    thunkApi: AppThunkApi
+): Promise<{ fileId: string; blob: Blob; source: "local" | "remote" }> => {
+    if (!fileId || typeof fileId !== "string") {
+        throw new Error("readFileContentAction requires a valid fileId string.");
+    }
+
+    // IndexedDB 以裸 ULID 为 key 存储文件
+    const localId = resolveLocalFileId(fileId);
+
+    // 1. 先尝试从 IndexedDB 读取（使用裸 ULID）
+    const localRecord: StoredFileRecord | null =
+        await loadFileFromIndexedDb(localId);
+    if (localRecord) {
+        return {
+            fileId: localId,
+            blob: localRecord.blob,
+            source: "local",
+        };
+    }
+
+    // 2. 根据参数决定是否回退到服务器
+    if (!useServerFallback) {
+        throw new Error(
+            `Local file not found for id "${fileId}", and server fallback is disabled.`
+        );
+    }
+
+    // 3. 从服务器拉取文件内容（使用原始 fileId，完整 dbKey 可直接查询）
+    const state = thunkApi.getState();
+    const { currentServer, remoteServers: serversToTry } =
+        getRuntimeServerContext(state);
+
+    if (!currentServer) {
+        throw new Error(
+            `No current server configured. Cannot fetch remote file for id "${fileId}".`
+        );
+    }
+
+    let lastError = "";
+
+    for (const server of serversToTry) {
+        const url = `${server}${API_ENDPOINTS.DATABASE}/file/content/${fileId}`;
+        console.debug("[readFileContentAction] trying server:", url);
+
+        try {
+            const res = await fetch(url);
+            if (!res.ok) {
+                lastError = `HTTP ${res.status} from ${server}`;
+                console.debug("[readFileContentAction] server returned:", lastError);
+                continue;
+            }
+
+            const blob = await res.blob();
+
+            // 将从服务器获取的文件写入 IndexedDB，以裸 ULID 为 key 缓存
+            if (typeof indexedDB !== "undefined") {
+                void saveFileToIndexedDb(localId, blob).catch((err) => {
+                    console.warn(
+                        "[readFileContentAction] Failed to cache remote file into IndexedDB:",
+                        err
+                    );
+                });
+            }
+
+            return {
+                fileId: localId,
+                blob,
+                source: "remote" as const,
+            };
+        } catch (err: any) {
+            lastError = err?.message || "Network error";
+            console.debug(
+                "[readFileContentAction] fetch error from",
+                server,
+                lastError
+            );
+        }
+    }
+
+    throw new Error(
+        `Failed to fetch remote file content from all servers for id "${fileId}". Last error: ${lastError}`
+    );
+};

package/database/actions/patch.ts

@@ -0,0 +1,155 @@
+// 文件路径: database/actions/patch.ts
+
+import type { AppThunkApi } from "app/store";
+import { getRuntimeServerContext } from "database/runtimeServerContext";
+import { toast } from "app/utils/toast";
+import {
+  scheduleConfiguredPatchReplication,
+} from "./replication";
+
+/**
+ * 深度合并两个对象。源对象中的 null 值会删除目标对象中对应的键。
+ * @param target - 目标对象。
+ * @param source - 源对象，包含要应用的更改。
+ * @returns {any} - 合并后的新对象。
+ */
+const deepMerge = (target: any, source: any): any => {
+  const output = { ...target };
+  for (const key in source) {
+    if (Object.prototype.hasOwnProperty.call(source, key)) {
+      if (source[key] === null && key in output) {
+        delete output[key]; // null 值用于删除键
+      } else if (
+        source[key] &&
+        typeof source[key] === "object" &&
+        !Array.isArray(source[key])
+      ) {
+        output[key] = deepMerge(output[key] || {}, source[key]); // 递归合并
+      } else {
+        output[key] = source[key]; // 直接赋值
+      }
+    }
+  }
+  return output;
+};
+
+const toTimestamp = (value: unknown): number => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+};
+
+const inferNextUpdatedAt = (currentData: any): number | string | undefined => {
+  const previousUpdatedAt = currentData?.updatedAt;
+  const previousCreatedAt = currentData?.createdAt;
+  const previousMetaCreatedAt = currentData?.meta?.createdAt;
+  const previousTimestamp = Math.max(
+    toTimestamp(previousUpdatedAt),
+    toTimestamp(previousCreatedAt),
+    toTimestamp(previousMetaCreatedAt)
+  );
+  const nextTimestamp = Math.max(Date.now(), previousTimestamp + 1);
+
+  if (
+    typeof previousUpdatedAt === "number" ||
+    typeof previousCreatedAt === "number" ||
+    typeof previousMetaCreatedAt === "number"
+  ) {
+    return nextTimestamp;
+  }
+
+  if (
+    typeof previousUpdatedAt === "string" ||
+    typeof previousCreatedAt === "string"
+  ) {
+    return new Date(nextTimestamp).toISOString();
+  }
+
+  return undefined;
+};
+
+/**
+ * Patch Action: 对现有数据项应用增量更新。
+ * 1. 从本地数据库读取现有数据。
+ * 2. 将传入的 'changes' 对象与现有数据进行深度合并。
+ * 3. 将合并后的新数据写回本地数据库。
+ * 4. 异步地将 'changes' 对象同步到所有相关服务器。
+ * @param payload - 包含 dbKey 和 changes 的对象。
+ * @param {string} payload.dbKey - 要更新的数据的键。
+ * @param {object} payload.changes - 要应用的更改。
+ * @param thunkApi - Redux Thunk API，包含 state 和 extra arugments。
+ * @returns {Promise<any>} 更新后的完整数据对象。
+ * @throws 如果本地数据不存在或更新过程中发生任何错误，则抛出异常。
+ */
+export const patchAction = async (
+  {
+    dbKey,
+    changes,
+    preferredServerOrigin,
+  }: { dbKey: string; changes: any; preferredServerOrigin?: string | null },
+  thunkApi: AppThunkApi
+): Promise<any> => {
+  // 1. 从 thunkApi.extra 中获取数据库实例
+  const { db } = thunkApi.extra;
+  if (!db) {
+    const errorMsg = "Database instance is not available.";
+    toast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  // 2. 验证输入参数
+  if (!dbKey || !changes || typeof changes !== "object") {
+    const errorMsg = "Patch action requires a valid dbKey and changes object.";
+    toast.error(errorMsg);
+    throw new Error(errorMsg);
+  }
+
+  const state = thunkApi.getState();
+  const { currentServer, syncServers: configuredSyncServers } =
+    getRuntimeServerContext(state);
+
+  try {
+    // 3. 使用注入的 db 实例读取当前数据
+    const currentData = await db.get(dbKey);
+    if (!currentData) {
+      throw new Error(
+        `Cannot apply patch: Data not found locally for key: ${dbKey}.`
+      );
+    }
+
+    const patchChanges = Object.prototype.hasOwnProperty.call(changes, "updatedAt")
+      ? changes
+      : {
+          ...changes,
+          ...(inferNextUpdatedAt(currentData) !== undefined
+            ? { updatedAt: inferNextUpdatedAt(currentData) }
+            : {}),
+        };
+
+    // 4. 合并数据并写回本地数据库
+    const newData = deepMerge(currentData, patchChanges);
+    const persistedData =
+      newData && typeof newData === "object" ? { ...newData, dbKey } : { dbKey };
+    await db.put(dbKey, persistedData);
+
+    // 5. 异步触发对远程服务器的同步（即发即忘）
+    scheduleConfiguredPatchReplication({
+      currentServer,
+      syncServers: configuredSyncServers,
+      preferredServerOrigin,
+      dbKey,
+      changes: patchChanges,
+      state,
+    });
+
+    // 6. 乐观地返回更新后的数据
+    return persistedData;
+  } catch (error: any) {
+    const errorMessage = `Failed to update data for ${dbKey}.`;
+    toast.error(errorMessage);
+    throw new Error(error.message || errorMessage);
+  }
+};