nolo-cli 0.1.13 → 0.1.14

package/ai/agent/hooks/usePublicAgents.ts

@@ -0,0 +1,473 @@
+// 文件路径: ai/agent/hooks/usePublicAgents.ts
+
+import { useEffect, useState, useCallback, useRef } from "react";
+import { useAppDispatch, useAppSelector } from "app/store";
+
+import type { Agent } from "app/types";
+import {
+  selectCurrentServer,
+  selectSyncServers,
+} from "app/settings/settingSlice";
+import { selectUserId } from "auth/authSlice";
+
+import { fetchPublicAgents as fetchLocal } from "ai/agent/hooks/fetchPublicAgents";
+import { remove } from "database/dbSlice";
+import { getAllServers } from "database/actions/common";
+import {
+  getRecordTimestamp,
+  isTombstoneRecord,
+} from "database/tombstones";
+import {
+  buildSortMeta,
+  sortAgents,
+  toTimeMs,
+  MAgent
+} from "ai/agent/utils/sortUtils";
+
+/* -------------------------------------------------------------------------- */
+/* 类型定义                                                                   */
+/* -------------------------------------------------------------------------- */
+
+export interface UsePublicAgentsOptions {
+  limit?: number;
+  sortBy?:
+  | "recommended"
+  | "newest"
+  | "popular"
+  | "rating"
+  | "outputPriceAsc"
+  | "outputPriceDesc"
+  | "favorite"; // 按收藏数排序
+  searchName?: string;
+  userId?: string;
+  imageOutputOnly?: boolean;
+  /** Filter agents that include this tool in their tools array */
+  toolName?: string;
+  initialData?: Agent[];
+  reloadMode?: "preview" | "catalog";
+}
+
+interface PublicAgentsState {
+  loading: boolean;
+  error: Error | null;
+  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 };
+}
+
+/* -------------------------------------------------------------------------- */
+/* 远程获取（支持 Abort）                                                     */
+/* -------------------------------------------------------------------------- */
+
+async function fetchRemoteAgents(
+  serverUrl: string,
+  options: UsePublicAgentsOptions,
+  signal?: AbortSignal
+): Promise<{ data: Agent[] }> {
+  const response = await fetch(`${serverUrl}/rpc/getPublicAgents`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(options),
+    signal,
+  });
+
+  if (!response.ok) {
+    throw new Error(`Remote fetch failed with status ${response.status}`);
+  }
+
+  const data = await response.json();
+  return data as { data: Agent[] };
+}
+
+/* -------------------------------------------------------------------------- */
+/* Hook 主体                                                                  */
+/* -------------------------------------------------------------------------- */
+
+export function usePublicAgents({
+  limit = 20,
+  sortBy = "recommended",
+  searchName = "",
+  userId,
+  imageOutputOnly = false,
+  toolName,
+  initialData = [],
+  reloadMode = "catalog",
+}: UsePublicAgentsOptions = {}) {
+  // Intentionally still uses the raw configured server selectors instead of the
+  // newer content/runtime helpers. Public-agent discovery is a mixed path:
+  // local cache hydration + marketplace-style remote aggregation across the
+  // currently configured peers. Keep it out of the local-first content CRUD
+  // refactor until the agent marketplace/server-ownership phase.
+  const currentServer = useAppSelector(selectCurrentServer);
+  const syncServers = useAppSelector(selectSyncServers);
+  const currentUserId = useAppSelector(selectUserId);
+  const dispatch = useAppDispatch();
+
+  const [state, setState] = useState<PublicAgentsState>({
+    loading: initialData.length === 0,
+    error: null,
+    data: initialData,
+  });
+
+  const requestIdRef = useRef(0);
+  const abortRef = useRef<AbortController | null>(null);
+  const pendingExcludedIdsRef = useRef<Set<string>>(new Set());
+
+  const fetchData = useCallback(async () => {
+    const uiOptions: UsePublicAgentsOptions = {
+      limit,
+      sortBy,
+      searchName,
+      userId,
+      imageOutputOnly,
+      toolName,
+    };
+    const myReqId = ++requestIdRef.current;
+
+    // 进入 loading，但保留现有数据；已有数据时不强制 loading，避免 SSR 首屏抖动
+    setState((prev) => ({
+      ...prev,
+      loading: prev.data.length === 0,
+      error: null,
+    }));
+
+    const excludedIds = pendingExcludedIdsRef.current;
+
+    /* -------------------------- 1) 本地优先渲染 -------------------------- */
+
+    let localResult: { data: Agent[]; tombstones: Array<Record<string, any>> } = {
+      data: [],
+      tombstones: [],
+    };
+    let localDataForUi: Agent[] = [];
+
+    try {
+      localResult = await fetchLocal(uiOptions);
+      localDataForUi =
+        excludedIds.size > 0
+          ? localResult.data.filter((agent) => !matchesExcludedAgent(agent, excludedIds))
+          : localResult.data;
+
+      if (myReqId !== requestIdRef.current) return;
+
+      const localDecorated = localDataForUi.map((a) => ({
+        ...(a as any),
+        __sort: buildSortMeta(a, undefined),
+      }));
+
+      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))
+        );
+      }
+
+      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]))
+            )
+          )
+        );
+        pendingExcludedIdsRef.current = stillPending;
+      }
+      setState((prev) => ({ ...prev, loading: false }));
+      return;
+    }
+
+    /* -------------------------- 3) 远程请求 + 合并 ------------------------ */
+
+    try {
+      abortRef.current?.abort();
+      abortRef.current = new AbortController();
+
+      const pruneLimit = Math.min(
+        PRUNE_LIMIT_CAP,
+        Math.max(limit, limit * PRUNE_LIMIT_MULTIPLIER)
+      );
+      const remoteOptions: UsePublicAgentsOptions = {
+        ...uiOptions,
+        limit: pruneLimit,
+      };
+
+      const remoteResults = await Promise.allSettled(
+        servers.map((server) =>
+          fetchRemoteAgents(server, remoteOptions, abortRef.current!.signal)
+        )
+      );
+
+      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 remoteDataForUi =
+        excludedIds.size > 0
+          ? remoteData.filter((agent) => !matchesExcludedAgent(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 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");
+
+      if (
+        canPruneScene &&
+        toDeleteFiltered.length > 0 &&
+        myReqId === requestIdRef.current
+      ) {
+        toDeleteFiltered.forEach((id) => dispatch(remove(id)));
+      }
+
+      if (myReqId !== requestIdRef.current) return;
+
+      if (excludedIds.size > 0) {
+        const stillPending = new Set(
+          Array.from(excludedIds).filter((identifier) => {
+            const identifierSet = new Set([identifier]);
+            return (
+              localResult.data.some((agent) =>
+                matchesExcludedAgent(agent, identifierSet)
+              ) ||
+              remoteData.some((agent) =>
+                matchesExcludedAgent(agent, identifierSet)
+              )
+            );
+          })
+        );
+        pendingExcludedIdsRef.current = stillPending;
+      }
+
+      setState({ loading: false, error: null, data: finalSorted });
+    } catch (err: any) {
+      if (err?.name === "AbortError") return;
+      if (myReqId !== requestIdRef.current) return;
+
+      // 远程失败：保留本地阶段结果
+      setState((prev) => ({ ...prev, loading: false, error: null }));
+    }
+  }, [
+    limit,
+    sortBy,
+    searchName,
+    userId,
+    imageOutputOnly,
+    toolName,
+    currentServer,
+    syncServers,
+    currentUserId,
+    dispatch,
+  ]);
+
+  useEffect(() => {
+    fetchData();
+    return () => {
+      abortRef.current?.abort();
+    };
+  }, [
+    fetchData,
+    imageOutputOnly,
+    initialData.length,
+    reloadMode,
+    searchName,
+    sortBy,
+    toolName,
+    userId,
+  ]);
+
+  const retry = useCallback((excludedAgentIds: string[] = []) => {
+    if (excludedAgentIds.length > 0) {
+      pendingExcludedIdsRef.current = new Set([
+        ...pendingExcludedIdsRef.current,
+        ...excludedAgentIds.map((value) => String(value)),
+      ]);
+    }
+
+    setState((prev) => {
+      const nextData =
+        excludedAgentIds.length > 0
+          ? prev.data.filter(
+              (agent) =>
+                !matchesExcludedAgent(
+                  agent,
+                  new Set(excludedAgentIds.map((value) => String(value)))
+                )
+            )
+          : prev.data;
+      return {
+        ...prev,
+        data: nextData,
+        loading:
+          reloadMode === "catalog" &&
+          excludedAgentIds.length === 0 &&
+          nextData.length === 0,
+        error: null,
+      };
+    });
+    if (reloadMode === "catalog") {
+      fetchData();
+    }
+  }, [fetchData]);
+
+  return { ...state, retry };
+}

package/ai/agent/persistMessageWithFixedId.ts

@@ -0,0 +1,37 @@
+import { DataType } from "create/types";
+import { write } from "database/dbSlice";
+import { addUserMessage } from "chat/messages/messageSlice";
+import type { Message } from "chat/messages/types";
+
+export async function persistMessageWithFixedId(
+  dispatch: any,
+  message: Message
+): Promise<void> {
+  dispatch(addUserMessage(message));
+
+  const { controller, ...messageToWrite } = message;
+
+  try {
+    const writeRequest = dispatch(
+      write({
+        data: {
+          ...messageToWrite,
+          type: DataType.MSG,
+        },
+        customKey: message.dbKey,
+      })
+    );
+
+    if (writeRequest && typeof writeRequest.unwrap === "function") {
+      await writeRequest.unwrap();
+      return;
+    }
+
+    await writeRequest;
+  } catch (error) {
+    console.error(
+      "[persistMessageWithFixedId] Failed to persist fixed-id message:",
+      error
+    );
+  }
+}