nolo-cli 0.1.23 → 0.1.29

package/database/actions/agentReadResolution.ts

@@ -0,0 +1,33 @@
+import {
+  NOLO_CLUSTER_SERVERS,
+  normalizeKnownServerOrigin,
+} from "../config";
+import { BUILTIN_PLATFORM_AGENT_KEYS as CORE_BUILTIN_PLATFORM_AGENT_KEYS } from "../../core/builtinAgents";
+
+export const BUILTIN_PLATFORM_AGENT_KEYS = [
+  ...CORE_BUILTIN_PLATFORM_AGENT_KEYS,
+] as const;
+
+const BUILTIN_PLATFORM_AGENT_KEY_SET = new Set<string>(
+  BUILTIN_PLATFORM_AGENT_KEYS
+);
+
+const normalizeServer = (server: string): string =>
+  normalizeKnownServerOrigin(server) ?? server.trim().replace(/\/+$/, "");
+
+export const isBuiltinPlatformAgentKey = (dbKey: string): boolean =>
+  typeof dbKey === "string" && BUILTIN_PLATFORM_AGENT_KEY_SET.has(dbKey);
+
+export const resolveAgentReadServers = ({
+  dbKey,
+  configuredServers,
+}: {
+  dbKey: string;
+  configuredServers: string[];
+}): string[] => {
+  const normalized = configuredServers.map(normalizeServer);
+  if (!isBuiltinPlatformAgentKey(dbKey)) {
+    return Array.from(new Set(normalized));
+  }
+  return Array.from(new Set([...normalized, ...NOLO_CLUSTER_SERVERS]));
+};

package/database/actions/cacheMergedUserData.ts

@@ -1,6 +1,6 @@
 import { createAsyncThunk } from "@reduxjs/toolkit";
 
-import type { AppThunkApi } from "app/store";
+import type { AppThunkApi } from "../../app/store";
 
 import { fetchFromClientDb } from "./common";
 import { shouldReplaceWithNextRecord } from "../tombstones";

package/database/actions/common.ts

@@ -1,9 +1,10 @@
 // 文件路径: database/actions/common.ts
 
 import pino from "pino";
-import { getIsDesktopApp } from "app/utils/env";
-import { fetchWithTransientReadRetry } from "app/utils/retryFetch";
+import { getIsDesktopApp } from "../../app/utils/env";
+import { fetchWithTransientReadRetry } from "../../app/utils/retryFetch";
 import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../config";
+import { classifyRemoteReadStatus } from "./readOutcome";
 
 // RN 下 pino 的 browser 写法可能有兼容性问题
 // 使用简单的 console 封装作为 fallback
@@ -183,12 +184,20 @@ const createReadTimeoutError = (server: string, dbKey: string): Error => {
 export const isReadTimeoutError = (error: unknown): boolean =>
   error instanceof Error && error.name === READ_TIMEOUT_ERROR_NAME;
 
-export const fetchFromServer = async (
+export type RemoteReadOutcome =
+  | { tag: "success"; data: any }
+  | { tag: "not_found" }
+  | { tag: "unauthorized" }
+  | { tag: "forbidden" }
+  | { tag: "transient_error"; status: number }
+  | { tag: "http_error"; status: number };
+
+export const fetchReadOutcomeFromServer = async (
   server: string,
   dbKey: string,
   token?: string,
   signal?: AbortSignal
-): Promise<any> => {
+): Promise<RemoteReadOutcome> => {
   if (signal?.aborted) {
     throw new DOMException("Aborted", "AbortError");
   }
@@ -216,10 +225,27 @@ export const fetchFromServer = async (
     clearTimeout(timeoutId);
     signal?.removeEventListener("abort", onExternalAbort);
 
-    if (res.status === 200) {
-      return await res.json();
+    const statusTag = classifyRemoteReadStatus(res.status);
+    if (statusTag === "success") {
+      return {
+        tag: "success",
+        data: await res.json(),
+      };
     }
-    return null;
+
+    if (statusTag === "not_found") {
+      return { tag: "not_found" };
+    }
+    if (statusTag === "unauthorized") {
+      return { tag: "unauthorized" };
+    }
+    if (statusTag === "forbidden") {
+      return { tag: "forbidden" };
+    }
+    if (statusTag === "transient_error") {
+      return { tag: "transient_error", status: res.status };
+    }
+    return { tag: "http_error", status: res.status };
   } catch (err: any) {
     clearTimeout(timeoutId);
     signal?.removeEventListener("abort", onExternalAbort);
@@ -229,10 +255,20 @@ export const fetchFromServer = async (
     if (signal?.aborted || err.name === "AbortError") {
       throw err;
     }
-    return null;
+    return { tag: "transient_error", status: 0 };
   }
 };
 
+export const fetchFromServer = async (
+  server: string,
+  dbKey: string,
+  token?: string,
+  signal?: AbortSignal
+): Promise<any> => {
+  const outcome = await fetchReadOutcomeFromServer(server, dbKey, token, signal);
+  return outcome.tag === "success" ? outcome.data : null;
+};
+
 // 规范化时间字段 (无需改动)
 export const normalizeTimeFields = (data: any): any => ({
   ...data,

package/database/actions/fetchUserData.ts

@@ -1,6 +1,6 @@
 import { createAsyncThunk } from "@reduxjs/toolkit";
 import { fetchUserData } from "../client/fetchUserData";
-import { AppThunkApi } from "app/store";
+import { AppThunkApi } from "../../app/store";
 
 export const fetchUserDataThunk = createAsyncThunk<
     any,

package/database/actions/fileContent.ts

@@ -1,8 +1,8 @@
 // 文件路径: database/actions/fileContent.ts
 
-import type { AppThunkApi } from "app/store";
-import { API_ENDPOINTS } from "database/config";
-import { getRuntimeServerContext } from "database/runtimeServerContext";
+import type { AppThunkApi } from "../../app/store";
+import { API_ENDPOINTS } from "../config";
+import { getRuntimeServerContext } from "../runtimeServerContext";
 import {
     loadFileFromIndexedDb,
     saveFileToIndexedDb,

package/database/actions/patch.ts

@@ -1,8 +1,8 @@
 // 文件路径: database/actions/patch.ts
 
-import type { AppThunkApi } from "app/store";
-import { getRuntimeServerContext } from "database/runtimeServerContext";
-import { toast } from "app/utils/toast";
+import type { AppThunkApi } from "../../app/store";
+import { getRuntimeServerContext } from "../runtimeServerContext";
+import { toast } from "../../app/utils/toast";
 import {
   scheduleConfiguredPatchReplication,
 } from "./replication";

package/database/actions/read.ts

@@ -1,16 +1,28 @@
 // 文件路径: database/actions/read.ts
 
-import type { AppThunkApi } from "app/store";
-import { getRuntimeServerContext } from "database/runtimeServerContext";
+import type { AppThunkApi } from "../../app/store";
+import { getRuntimeServerContext } from "../runtimeServerContext";
 import {
   fetchFromClientDb,
-  fetchFromServer,
+  fetchReadOutcomeFromServer,
   isReadTimeoutError,
   logger,
 } from "./common";
+import { buildReadMissError } from "./readOutcome";
+import { resolveAgentReadServers } from "./agentReadResolution";
+import {
+  partitionReadServers,
+  pickBestSettledRemoteRecord,
+  shouldReplaceLocalWithRemoteRecord,
+  shouldReplicateLocalRecord,
+} from "./readResolution";
 import { readRequestManager } from "./readRequestManager";
 import { shouldReplaceWithNextRecord } from "../tombstones";
 import { scheduleExistingRecordReplication } from "./replication";
+import {
+  BUILTIN_AGENT_CREATOR_AGENT_KEY,
+  buildBuiltinAgentCreatorRecord,
+} from "../../core/builtinAgents";
 
 // --- 辅助函数 ---
 
@@ -36,24 +48,22 @@ const isRemoteDataNewer = (remoteData: any, localData: any): boolean => {
   return shouldReplaceWithNextRecord(remoteData, localData);
 };
 
-const shouldSyncLocalToServer = (localData: any, remoteData: any): boolean => {
-  return !!localData && !remoteData;
-};
-
 const syncLocalDataToServer = async (
-  thunkApi: AppThunkApi,
+  replicationContext: {
+    currentServer: string | undefined;
+    syncServers: string[] | undefined;
+    state: unknown;
+  },
   dbKey: string,
   localData: any
 ): Promise<void> => {
   try {
-    const state = thunkApi.getState();
-    const { currentServer, syncServers } = getRuntimeServerContext(state);
     scheduleExistingRecordReplication({
-      currentServer,
-      syncServers,
+      currentServer: replicationContext.currentServer,
+      syncServers: replicationContext.syncServers,
       dbKey,
       localData,
-      state,
+      state: replicationContext.state,
     });
   } catch (err) {
     // Error ignored
@@ -82,49 +92,39 @@ const saveRemoteDataToClientDb = async (
   }
 };
 
-const getValidRemoteData = (
-  dbKey: string,
-  settledResults: PromiseSettledResult<any>[],
-  localData?: any
-): { data: any; index: number } | null => {
-  const validResults = settledResults
-    .map((result, index) => ({
-      data: result.status === "fulfilled" ? result.value : null,
-      index,
-    }))
-    .filter((item) => item.data !== null && typeof item.data === "object");
-
-  if (validResults.length === 0) return null;
-
-  const latest = validResults.reduce((latest, current) => {
-    return shouldReplaceWithNextRecord(current.data, latest.data) ? current : latest;
-  });
-
-  return {
-    ...latest,
-    data: latest.data,
-  };
-};
-
 const processRemoteDataInBackground = async (
   clientDb: any,
   dbKey: string,
   remotePromises: Promise<any>[],
   remoteServers: string[],
   localData: any,
-  thunkApi: AppThunkApi
+  replicationContext: {
+    currentServer: string | undefined;
+    syncServers: string[] | undefined;
+    state: unknown;
+  }
 ): Promise<void> => {
   if (!clientDb) return;
   try {
     const settledResults = await Promise.allSettled(remotePromises);
-    const remoteResult = getValidRemoteData(dbKey, settledResults, localData);
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) =>
+        shouldReplaceWithNextRecord(current, latest),
+    });
     const validRemoteData = remoteResult ? remoteResult.data : null;
     const serverOrigin =
       remoteResult && remoteServers[remoteResult.index]
         ? remoteServers[remoteResult.index]
         : undefined;
 
-    if (validRemoteData && localData) {
+    if (
+      shouldReplaceLocalWithRemoteRecord({
+        localData,
+        remoteData: validRemoteData,
+        isRemoteNewer,
+      })
+    ) {
       await updateClientDbIfNewer(
         clientDb,
         dbKey,
@@ -132,8 +132,14 @@ const processRemoteDataInBackground = async (
         localData
       );
     }
-    if (shouldSyncLocalToServer(localData, validRemoteData)) {
-      await syncLocalDataToServer(thunkApi, dbKey, localData);
+    if (
+      shouldReplicateLocalRecord({
+        localData,
+        remoteData: validRemoteData,
+        remoteTargetCount: remotePromises.length,
+      })
+    ) {
+      await syncLocalDataToServer(replicationContext, dbKey, localData);
     }
   } catch (err) {
     // Background sync errors ignored
@@ -170,11 +176,24 @@ export const readAction = async (
 
   const executeRead = async (): Promise<any> => {
     const state = thunkApi.getState();
-    const { currentToken, remoteServers: allServers } =
+    const { currentToken, remoteServers: configuredServers } =
       getRuntimeServerContext(state, preferredServerOrigin);
+    const { currentServer, syncServers } = getRuntimeServerContext(
+      state,
+      preferredServerOrigin
+    );
+    const allServers = resolveAgentReadServers({ dbKey, configuredServers });
     const isLoggedIn = !!currentToken;
     const now = Date.now();
     const localData = await fetchFromClientDb(clientDb, dbKey);
+    const {
+      preferredServer,
+      fallbackServers,
+      orderedServersForLocalHit,
+    } = partitionReadServers({
+      allServers,
+      preferredServerOrigin,
+    });
     readRequestManager.cleanupMisses(now);
     readRequestManager.cleanupLocalHitRevalidations(now);
 
@@ -187,7 +206,10 @@ export const readAction = async (
           { dbKey, retryInMs },
           "[readAction] Suppressing repeated miss read"
         );
-        throw new Error(`Read temporarily suppressed for missing key "${dbKey}".`);
+        throw buildReadMissError({
+          dbKey,
+          reason: "temporarily_suppressed",
+        });
       }
     }
 
@@ -197,19 +219,12 @@ export const readAction = async (
         return { ...localData, dbKey };
       }
       readRequestManager.markMiss(dbKey, now);
-      throw new Error(
-        `Failed to fetch data for key "${dbKey}" because network is offline and no local data is available.`
-      );
+      throw buildReadMissError({
+        dbKey,
+        reason: "offline_without_local_data",
+      });
     }
 
-    const preferredServer =
-      typeof preferredServerOrigin === "string" && preferredServerOrigin.trim().length > 0
-        ? preferredServerOrigin.trim().replace(/\/+$/, "")
-        : null;
-    const remainingServers = preferredServer
-      ? allServers.filter((server) => server.replace(/\/+$/, "") !== preferredServer)
-      : allServers;
-
     if (localData) {
       // Local-first: return durable local data immediately and only revalidate
       // against remote servers in the background. This avoids turning a
@@ -222,22 +237,24 @@ export const readAction = async (
         );
         if (retryInMs === null) {
           readRequestManager.markLocalHitRevalidated(dbKey, now);
-          const revalidationServers = preferredServer
-            ? [preferredServer, ...remainingServers]
-            : remainingServers;
-          const remotePromises = revalidationServers.map((server) =>
-            fetchFromServer(server, dbKey, isLoggedIn ? currentToken : undefined, signal)
-          );
-          void (async () => {
-            await processRemoteDataInBackground(
-              clientDb,
+          const remotePromises = orderedServersForLocalHit.map(async (server) => {
+            const outcome = await fetchReadOutcomeFromServer(
+              server,
               dbKey,
-              remotePromises,
-              revalidationServers,
-              localData,
-              thunkApi
+              isLoggedIn ? currentToken : undefined,
+              signal
             );
-          })();
+            return outcome.tag === "success" ? outcome.data : null;
+          }
+          );
+          void processRemoteDataInBackground(
+            clientDb,
+            dbKey,
+            remotePromises,
+            orderedServersForLocalHit,
+            localData,
+            { currentServer, syncServers, state }
+          );
         } else {
           logger.debug(
             { dbKey, retryInMs },
@@ -250,14 +267,15 @@ export const readAction = async (
 
     if (preferredServer) {
       try {
-        const preferredRemoteData = await fetchFromServer(
+        const preferredOutcome = await fetchReadOutcomeFromServer(
           preferredServer,
           dbKey,
           isLoggedIn ? currentToken : undefined,
           signal
         );
 
-        if (preferredRemoteData) {
+        if (preferredOutcome.tag === "success") {
+          const preferredRemoteData = preferredOutcome.data;
           await saveRemoteDataToClientDb(
             clientDb,
             dbKey,
@@ -286,8 +304,15 @@ export const readAction = async (
     }
 
     // 3. 将 signal 传递给所有网络请求
-    const remotePromises = remainingServers.map((server) =>
-      fetchFromServer(server, dbKey, isLoggedIn ? currentToken : undefined, signal)
+    const remotePromises = fallbackServers.map(async (server) => {
+      const outcome = await fetchReadOutcomeFromServer(
+        server,
+        dbKey,
+        isLoggedIn ? currentToken : undefined,
+        signal
+      );
+      return outcome.tag === "success" ? outcome.data : null;
+    }
     );
 
     // 如果本地没有数据，则等待网络请求结果
@@ -298,10 +323,14 @@ export const readAction = async (
       throw new DOMException("Aborted", "AbortError");
     }
 
-    const remoteResult = getValidRemoteData(dbKey, settledResults, localData);
+    const remoteResult = pickBestSettledRemoteRecord({
+      settledResults,
+      isBetterCandidate: (current, latest) =>
+        shouldReplaceWithNextRecord(current, latest),
+    });
     if (remoteResult) {
       const { data: validRemoteData } = remoteResult;
-      const serverOrigin = remainingServers[remoteResult.index];
+      const serverOrigin = fallbackServers[remoteResult.index];
       if (!signal?.aborted) {
         await saveRemoteDataToClientDb(
           clientDb,
@@ -316,8 +345,18 @@ export const readAction = async (
         : { ...validRemoteData, dbKey };
     }
 
+    if (dbKey === BUILTIN_AGENT_CREATOR_AGENT_KEY) {
+      const builtinRecord = buildBuiltinAgentCreatorRecord();
+      await saveRemoteDataToClientDb(clientDb, dbKey, builtinRecord);
+      readRequestManager.clearMiss(dbKey);
+      return builtinRecord;
+    }
+
     readRequestManager.markMiss(dbKey, Date.now());
-    throw new Error(`Failed to fetch data for key "${dbKey}" from all sources.`);
+    throw buildReadMissError({
+      dbKey,
+      reason: "all_sources_failed",
+    });
   };
 
   const canDedup = !signal;