nolo-cli 0.1.30 → 0.1.31

package/ai/agent/hooks/usePublicAgents.ts

@@ -11,38 +11,31 @@ import {
 import { selectUserId } from "../../../auth/authSlice";
 
 import { fetchPublicAgents as fetchLocal } from "../../agent/hooks/fetchPublicAgents";
-import { remove } from "../../../database/dbSlice";
-import { getAllServers } from "../../../database/actions/common";
 import {
-  getRecordTimestamp,
-  isTombstoneRecord,
-} from "../../../database/tombstones";
+  dedupeRemotePublicAgents,
+  maskRemoteAgentsByLocalTombstones,
+  planPublicAgentCatalogView,
+  type PublicAgentFilterOptions,
+  type PublicAgentListOptions,
+  shouldPruneStalePublicAgentCache as shouldPruneStalePublicAgentCacheImpl,
+} from "../../agent/publicAgentCatalog";
 import {
-  buildSortMeta,
-  sortAgents,
-  toTimeMs,
-  MAgent
-} from "../../agent/utils/sortUtils";
+  getPublicAgentId,
+  getPublicAgentPruneDbKey,
+  matchesPublicAgentIdentifiers,
+} from "../../agent/publicAgentIdentity";
+import { remove } from "../../../database/dbSlice";
+import { getAllServers } from "../../../database/actions/common";
+import { isTombstoneRecord } from "../../../database/tombstones";
 
 /* -------------------------------------------------------------------------- */
 /* 类型定义                                                                   */
 /* -------------------------------------------------------------------------- */
 
-export interface UsePublicAgentsOptions {
-  limit?: number;
-  sortBy?:
-  | "recommended"
-  | "newest"
-  | "popular"
-  | "rating"
-  | "outputPriceAsc"
-  | "outputPriceDesc"
-  | "favorite"; // 按收藏数排序
-  searchName?: string;
-  userId?: string;
-  imageOutputOnly?: boolean;
+export interface UsePublicAgentsOptions
+  extends PublicAgentFilterOptions,
+    PublicAgentListOptions {
   /** Filter agents that include this tool in their tools array */
-  toolName?: string;
   /** Return list-card metadata only from remote public-agent APIs. */
   summary?: boolean;
   initialData?: Agent[];
@@ -55,79 +48,19 @@ interface PublicAgentsState {
   data: Agent[];
 }
 
-const matchesExcludedAgent = (agent: Agent, excludedIds: Set<string>) => {
-  const identifiers = [(agent as any)?.dbKey, agent?.id]
-    .filter(Boolean)
-    .map((value) => String(value));
-  return identifiers.some((identifier) => excludedIds.has(identifier));
-};
-
-const getAgentIdentifiers = (agent: Partial<Agent> | Record<string, any>) =>
-  [agent?.dbKey, agent?.id]
-    .filter(Boolean)
-    .map((value) => String(value));
-
 /* -------------------------------------------------------------------------- */
 /* 删除策略：最低投入档——误删抑制开关                                          */
 /* -------------------------------------------------------------------------- */
 
-const PRUNE_ONLY_WHEN_NO_SEARCH = true;
-const PRUNE_ONLY_WHEN_SORT_NEWEST = true;
 const PRUNE_LIMIT_MULTIPLIER = 5;
 const PRUNE_LIMIT_CAP = 500;
 
-/* -------------------------------------------------------------------------- */
-/* 工具函数                                                                   */
-/* -------------------------------------------------------------------------- */
-
-// Local helpers removed, using shared utils from ai/agent/utils/sortUtils.ts
-
-/* -------------------------------------------------------------------------- */
-/* 合并 + 差集删除计算                                                        */
-/* -------------------------------------------------------------------------- */
-
-function mergeAgents(localData: Agent[], remoteData: Agent[]) {
-  const remoteIdSet = new Set(remoteData.map((a) => String(a.id)));
-  const merged: MAgent[] = [];
-  const toDelete: string[] = [];
-
-  // 本地优先
-  for (const local of localData) {
-    const id = String(local.id);
-    const remote = remoteIdSet.has(id)
-      ? remoteData.find((r) => String(r.id) === id)
-      : undefined;
-
-    if (remote) {
-      const localTimestamp = getRecordTimestamp(local);
-      const remoteTimestamp = getRecordTimestamp(remote);
-      const newest =
-        remoteTimestamp >= localTimestamp
-          ? { ...(local as any), ...(remote as any) }
-          : { ...(remote as any), ...(local as any) };
-      merged.push({
-        ...newest,
-        __sort: buildSortMeta(local, remote),
-      });
-    } else {
-      toDelete.push(id);
-      merged.push({
-        ...(local as any),
-        __sort: buildSortMeta(local, undefined),
-      });
-    }
-  }
-
-  // 再补仅远程有的
-  for (const r of remoteData) {
-    const id = String(r.id);
-    const exists = merged.some((m) => String(m.id) === id);
-    if (!exists) {
-      merged.push({ ...(r as any), __sort: buildSortMeta(undefined, r) });
-    }
-  }
-
-  return { merged, toDelete };
+export function shouldPruneStalePublicAgentCache({
+  searchName,
+}: {
+  searchName?: string;
+}) {
+  return shouldPruneStalePublicAgentCacheImpl({ searchName });
 }
 
 /* -------------------------------------------------------------------------- */
@@ -209,6 +142,8 @@ export function usePublicAgents({
     }));
 
     const excludedIds = pendingExcludedIdsRef.current;
+    const servers = getAllServers(currentServer, syncServers);
+    const hasRemoteServers = servers.length > 0;
 
     /* -------------------------- 1) 本地优先渲染 -------------------------- */
 
@@ -217,47 +152,43 @@ export function usePublicAgents({
       tombstones: [],
     };
     let localDataForUi: Agent[] = [];
+    let localSortedForFallback: Agent[] = [];
 
     try {
       localResult = await fetchLocal(uiOptions);
       localDataForUi =
         excludedIds.size > 0
-          ? localResult.data.filter((agent) => !matchesExcludedAgent(agent, excludedIds))
+          ? localResult.data.filter(
+              (agent) => !matchesPublicAgentIdentifiers(agent, excludedIds)
+            )
           : localResult.data;
 
       if (myReqId !== requestIdRef.current) return;
 
-      const localDecorated = localDataForUi.map((a) => ({
-        ...(a as any),
-        __sort: buildSortMeta(a, undefined),
-      }));
+      localSortedForFallback = planPublicAgentCatalogView({
+        localAgents: localDataForUi,
+        remoteAgents: [],
+        hasAuthoritativeRemoteResult: false,
+        currentUserId,
+        options: uiOptions,
+      }).localFallbackAgents;
 
-      let localFiltered = localDecorated as Agent[];
-      if (toolName) {
-        const kw = toolName.toLowerCase();
-        localFiltered = localFiltered.filter((a) =>
-          (a as any).tools?.some((t: string) => t.toLowerCase().includes(kw))
-        );
+      if (!hasRemoteServers) {
+        setState((prev) => ({ ...prev, data: localSortedForFallback }));
       }
-
-      const localSorted = sortAgents(localFiltered, sortBy).slice(0, limit);
-
-      setState((prev) => ({ ...prev, data: localSorted }));
     } catch {
       // 本地失败不阻塞远程
     }
 
     /* -------------------------- 2) 构造远程服务器列表 --------------------- */
 
-    const servers = getAllServers(currentServer, syncServers);
-
     // 若没有任何可用远程（离线或未配置），则结束（只保留本地）
     if (servers.length === 0) {
       if (excludedIds.size > 0) {
         const stillPending = new Set(
           Array.from(excludedIds).filter((identifier) =>
             localResult.data.some((agent) =>
-              matchesExcludedAgent(agent, new Set([identifier]))
+              matchesPublicAgentIdentifiers(agent, new Set([identifier]))
             )
           )
         );
@@ -290,97 +221,59 @@ export function usePublicAgents({
 
       if (myReqId !== requestIdRef.current) return;
 
-      const remoteMap = new Map<string, Agent>();
-
-      remoteResults.forEach((res) => {
-        if (res.status !== "fulfilled") return;
-        const list: Agent[] = (res.value?.data ?? []).filter(
-          (agent: Agent) => !isTombstoneRecord(agent)
-        );
-        for (const agent of list) {
-          const id = String(agent.id);
-          if (!remoteMap.has(id)) {
-            remoteMap.set(id, agent);
-          }
-        }
-      });
-
-      const localTombstoneMap = new Map<string, Record<string, any>>();
-      for (const tombstone of localResult.tombstones ?? []) {
-        for (const identifier of getAgentIdentifiers(tombstone)) {
-          const existing = localTombstoneMap.get(identifier);
-          if (!existing || getRecordTimestamp(tombstone) > getRecordTimestamp(existing)) {
-            localTombstoneMap.set(identifier, tombstone);
-          }
-        }
-      }
-
-      const remoteData: Agent[] = Array.from(remoteMap.values()).filter((agent) => {
-        const matchingTombstones = getAgentIdentifiers(agent)
-          .map((identifier) => localTombstoneMap.get(identifier))
-          .filter(Boolean) as Array<Record<string, any>>;
-        if (matchingTombstones.length === 0) return true;
-        const newestLocalTombstone = matchingTombstones.reduce((latest, current) =>
-          getRecordTimestamp(current) > getRecordTimestamp(latest) ? current : latest
-        );
-        return getRecordTimestamp(agent) > getRecordTimestamp(newestLocalTombstone);
-      });
+      const hasAuthoritativeRemoteResult = remoteResults.some(
+        (res) => res.status === "fulfilled"
+      );
+      const remoteData = maskRemoteAgentsByLocalTombstones(
+        dedupeRemotePublicAgents(
+          remoteResults.flatMap((res, index) => {
+            if (res.status !== "fulfilled") return [];
+            const originServer = servers[index];
+            return (res.value?.data ?? [])
+              .filter((agent: Agent) => !isTombstoneRecord(agent))
+              .map((agent: Agent) => ({
+                ...agent,
+                originServer,
+              }));
+          })
+        ),
+        localResult.tombstones ?? []
+      );
       const remoteDataForUi =
         excludedIds.size > 0
-          ? remoteData.filter((agent) => !matchesExcludedAgent(agent, excludedIds))
+          ? remoteData.filter(
+              (agent) => !matchesPublicAgentIdentifiers(agent, excludedIds)
+            )
           : remoteData;
 
-      const { merged, toDelete } = mergeAgents(
-        localDataForUi ?? [],
-        remoteDataForUi
-      );
-
-      /* -------------------------- 4) 计算删除建议（带保护） -------------------- */
-
-      const toDeleteFiltered = toDelete.filter((id) => {
-        const localItem = localResult.data.find((a) => String(a.id) === id) as any;
-
-        // 1. 主权保护：如果是我的 Agent，绝对不准自动删除
-        if (currentUserId && localItem?.userId === currentUserId) return false;
-
-        // 2. 时间宽限期：如果是最近 5 分钟内创建的，处于同步风险期，不准删除
-        const isRecentlyCreated =
-          Date.now() - toTimeMs(localItem?.createdAt) < 5 * 60 * 1000;
-        if (isRecentlyCreated) return false;
-
-        const origin = localItem?.meta?.origin; // "remote" | "local" | "both" | undefined
-        if (origin === "local") return false;
-        return true;
+      const viewPlan = planPublicAgentCatalogView({
+        localAgents: localDataForUi ?? [],
+        remoteAgents: remoteDataForUi,
+        hasAuthoritativeRemoteResult,
+        currentUserId,
+        options: uiOptions,
       });
 
-      const toDeleteFilteredSet = new Set(toDeleteFiltered);
-      let filteredForUI = (merged as Agent[]).filter(
-        (a) => !toDeleteFilteredSet.has(String(a.id))
-      );
-
-      // Client-side toolName filter applied after merge — guards against servers
-      // that don't yet support the toolName param (e.g. old code still running).
-      if (toolName) {
-        const kw = toolName.toLowerCase();
-        filteredForUI = filteredForUI.filter((a) =>
-          (a as any).tools?.some((t: string) => t.toLowerCase().includes(kw))
-        );
-      }
-
-      const finalSorted = sortAgents(filteredForUI, sortBy).slice(0, limit);
-
       /* -------------------------- 5) 条件化删除本地缓存 -------------------- */
 
-      const canPruneScene =
-        (!PRUNE_ONLY_WHEN_NO_SEARCH || !searchName) &&
-        (!PRUNE_ONLY_WHEN_SORT_NEWEST || sortBy === "newest");
+      const canPruneScene = shouldPruneStalePublicAgentCache({
+        searchName,
+      });
 
       if (
         canPruneScene &&
-        toDeleteFiltered.length > 0 &&
+        viewPlan.pruneIds.length > 0 &&
         myReqId === requestIdRef.current
       ) {
-        toDeleteFiltered.forEach((id) => dispatch(remove(id)));
+        viewPlan.pruneIds.forEach((id) => {
+          const localItem = localResult.data.find(
+            (agent) => getPublicAgentId(agent) === id
+          );
+          const dbKey = getPublicAgentPruneDbKey(localItem);
+          if (dbKey) {
+            dispatch(remove(dbKey));
+          }
+        });
       }
 
       if (myReqId !== requestIdRef.current) return;
@@ -391,10 +284,10 @@ export function usePublicAgents({
             const identifierSet = new Set([identifier]);
             return (
               localResult.data.some((agent) =>
-                matchesExcludedAgent(agent, identifierSet)
+                matchesPublicAgentIdentifiers(agent, identifierSet)
               ) ||
               remoteData.some((agent) =>
-                matchesExcludedAgent(agent, identifierSet)
+                matchesPublicAgentIdentifiers(agent, identifierSet)
               )
             );
           })
@@ -402,13 +295,18 @@ export function usePublicAgents({
         pendingExcludedIdsRef.current = stillPending;
       }
 
-      setState({ loading: false, error: null, data: finalSorted });
+      setState({ loading: false, error: null, data: viewPlan.visibleAgents });
     } catch (err: any) {
       if (err?.name === "AbortError") return;
       if (myReqId !== requestIdRef.current) return;
 
-      // 远程失败：保留本地阶段结果
-      setState((prev) => ({ ...prev, loading: false, error: null }));
+      // 远程失败：没有已渲染数据时回退到本地缓存。
+      setState((prev) => ({
+        ...prev,
+        data: prev.data.length > 0 ? prev.data : localSortedForFallback,
+        loading: false,
+        error: null,
+      }));
     }
   }, [
     limit,
@@ -454,7 +352,7 @@ export function usePublicAgents({
         excludedAgentIds.length > 0
           ? prev.data.filter(
               (agent) =>
-                !matchesExcludedAgent(
+                !matchesPublicAgentIdentifiers(
                   agent,
                   new Set(excludedAgentIds.map((value) => String(value)))
                 )