nolo-cli 0.1.10 → 0.1.12

package/ai/agent/hooks/usePublicAgents.ts

@@ -1,473 +0,0 @@
-// 文件路径: 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

@@ -1,37 +0,0 @@
-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
-    );
-  }
-}