nolo-cli 0.1.26 → 0.1.29

package/create/space/deleteSpaceAction.ts

@@ -0,0 +1,276 @@
+import { selectUserId } from "../../auth/authSlice";
+import { createSpaceKey } from "../space/spaceKeys";
+import { read, remove, patch } from "../../database/dbSlice";
+import { deleteDbKey } from "../../app/hooks/deleteDbKey";
+import {
+  persistDefaultSpacePreference,
+  readDefaultSpaceIdPreference,
+} from "../../app/settings/defaultSpacePreference";
+import {
+  isAgentKey,
+  isAppKey,
+  isDialogKey,
+  isFileKey,
+  isPageKey,
+  isTableMetaKey,
+  splitKey,
+} from "../../database/keys";
+import { normalizeSpaceId } from "./spaceKeys";
+
+// 定义ThunkAPI的通用类型（根据redux-thunk的用法）
+interface ThunkAPI {
+  dispatch: (action: any) => any;
+  getState: () => any; // 如果有RootState类型，可替换为RootState
+}
+
+export type DeleteSpaceStrategy =
+  | "delete-space-only"
+  | "move-owned-to-all"
+  | "delete-owned-content";
+
+type DeleteSpaceArgs =
+  | string
+  | {
+      spaceId: string;
+      strategy?: DeleteSpaceStrategy;
+    };
+
+const getCurrentUserId = (state: any): string => selectUserId(state);
+
+const fetchSpaceData = async (
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const spaceKey = createSpaceKey.space(spaceId);
+  try {
+    return await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (error) {
+    console.warn(`Failed to read space ${spaceId}:`, error);
+    return undefined;
+  }
+};
+
+const checkOwnerPermission = (spaceData: any | undefined, userId: string) => {
+  if (spaceData && spaceData.ownerId !== userId) {
+    throw new Error("Only owner can delete space");
+  }
+};
+
+const deleteSpaceData = async (
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const spaceKey = createSpaceKey.space(spaceId);
+  try {
+    await dispatch(remove(spaceKey)).unwrap();
+  } catch (error) {
+    console.warn(`Failed to delete space ${spaceId}:`, error);
+  }
+};
+
+const deleteAllMembers = async (
+  spaceData: any | undefined,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  if (spaceData?.members) {
+    for (const memberId of spaceData.members) {
+      const memberKey = createSpaceKey.member(memberId, spaceId);
+      await dispatch(remove(memberKey))
+        .unwrap()
+        .catch((err) =>
+          console.warn(
+            `Failed to delete member ${memberId} for space ${spaceId}:`,
+            err
+          )
+        );
+    }
+  }
+};
+
+const deleteCurrentUserMember = async (
+  userId: string,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const currentUserMemberKey = createSpaceKey.member(userId, spaceId);
+  await dispatch(remove(currentUserMemberKey))
+    .unwrap()
+    .catch((err) =>
+      console.warn(
+        `Failed to delete member key for user ${userId} in space ${spaceId}:`,
+        err
+      )
+    );
+};
+
+const clearDefaultSpacePreferenceIfNeeded = async (
+  userId: string,
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const defaultSpaceId = await readDefaultSpaceIdPreference(dispatch, userId);
+  if (defaultSpaceId && normalizeSpaceId(defaultSpaceId) === normalizeSpaceId(spaceId)) {
+    await persistDefaultSpacePreference(dispatch, userId, null);
+  }
+};
+
+const clearDeletedMemberDefaultSpacePreferences = async (
+  userIds: string[],
+  spaceId: string,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const uniqueUserIds = Array.from(new Set(userIds.filter(Boolean)));
+  for (const userId of uniqueUserIds) {
+    await clearDefaultSpacePreferenceIfNeeded(userId, spaceId, dispatch);
+  }
+};
+
+const resolveDeleteArgs = (
+  input: DeleteSpaceArgs
+): { spaceId: string; strategy: DeleteSpaceStrategy } => {
+  if (typeof input === "string") {
+    return { spaceId: input, strategy: "delete-space-only" };
+  }
+  return {
+    spaceId: input.spaceId,
+    strategy: input.strategy ?? "delete-space-only",
+  };
+};
+
+const isOwnedByUser = (entityKey: string, entity: any, userId: string): boolean => {
+  if (!entityKey || !userId) return false;
+
+  const keyParts = splitKey(entityKey);
+  const keyedOwner = keyParts[1];
+
+  if (
+    (isDialogKey(entityKey) ||
+      isPageKey(entityKey) ||
+      isFileKey(entityKey) ||
+      isTableMetaKey(entityKey)) &&
+    keyedOwner === userId
+  ) {
+    return true;
+  }
+
+  if ((isAgentKey(entityKey) || isAppKey(entityKey)) && entity?.userId === userId) {
+    return true;
+  }
+
+  if (entity?.tenantId === userId || entity?.userId === userId || entity?.ownerId === userId) {
+    return true;
+  }
+
+  return false;
+};
+
+const nextUpdatedAt = (entity: any): string => {
+  const source =
+    entity?.updatedAt ??
+    entity?.updated_at ??
+    entity?.createdAt ??
+    entity?.created ??
+    Date.now();
+  const timestamp =
+    typeof source === "number" ? source : Date.parse(String(source)) || Date.now();
+  return new Date(Math.max(Date.now(), timestamp + 1)).toISOString();
+};
+
+const listSpaceEntities = async (
+  spaceData: any | undefined,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  const results: Array<{ entityKey: string; entity: any }> = [];
+  const contents = Object.values(spaceData?.contents ?? {}).filter(Boolean) as Array<{
+    contentKey?: string;
+  }>;
+
+  for (const item of contents) {
+    const entityKey = typeof item.contentKey === "string" ? item.contentKey : "";
+    if (!entityKey) continue;
+
+    let entity: any = null;
+    try {
+      entity = await dispatch(read({ dbKey: entityKey })).unwrap();
+    } catch {
+      entity = null;
+    }
+
+    results.push({ entityKey, entity });
+  }
+
+  return results;
+};
+
+const clearEntitySpaceIds = async (
+  entities: Array<{ entityKey: string; entity: any }>,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  await Promise.all(
+    entities
+      .filter(({ entity }) => entity && typeof entity === "object")
+      .map(({ entityKey, entity }) =>
+      dispatch(
+        patch({
+          dbKey: entityKey,
+          changes: {
+            spaceId: null,
+            updatedAt: nextUpdatedAt(entity),
+          },
+        })
+      ).unwrap()
+      )
+  );
+};
+
+const deleteOwnedEntities = async (
+  ownedEntities: Array<{ entityKey: string; entity: any }>,
+  dispatch: ThunkAPI["dispatch"]
+) => {
+  for (const { entityKey } of ownedEntities) {
+    await dispatch(deleteDbKey(entityKey));
+  }
+};
+
+export const deleteSpaceAction = async (
+  input: DeleteSpaceArgs,
+  thunkAPI: ThunkAPI
+) => {
+  const { dispatch, getState } = thunkAPI;
+  const { spaceId, strategy } = resolveDeleteArgs(input);
+  const userId = getCurrentUserId(getState());
+  const spaceData = await fetchSpaceData(spaceId, dispatch);
+
+  checkOwnerPermission(spaceData, userId);
+
+  if (spaceData && strategy !== "delete-space-only") {
+    const allEntities = await listSpaceEntities(spaceData, dispatch);
+    const ownedEntities = allEntities.filter(({ entityKey, entity }) =>
+      isOwnedByUser(entityKey, entity, userId)
+    );
+    const unownedEntities = allEntities.filter(
+      ({ entityKey, entity }) => !isOwnedByUser(entityKey, entity, userId)
+    );
+
+    if (strategy === "move-owned-to-all") {
+      await clearEntitySpaceIds(allEntities, dispatch);
+    } else if (strategy === "delete-owned-content") {
+      await deleteOwnedEntities(ownedEntities, dispatch);
+      await clearEntitySpaceIds(unownedEntities, dispatch);
+    }
+  }
+
+  await deleteSpaceData(spaceId, dispatch);
+  await deleteAllMembers(spaceData, spaceId, dispatch);
+  await deleteCurrentUserMember(userId, spaceId, dispatch);
+  await clearDeletedMemberDefaultSpacePreferences(
+    [userId, ...(Array.isArray(spaceData?.members) ? spaceData.members : [])],
+    spaceId,
+    dispatch
+  );
+
+  return { spaceId, strategy };
+};

package/create/space/fetchSpaceAction.ts

@@ -0,0 +1,70 @@
+import type { SpaceId } from "../space/types";
+import type { SpaceData } from "../../app/types";
+import { createSpaceKey, normalizeSpaceId } from "../space/spaceKeys";
+import {
+  fetchAuthoritativeRemoteSpace,
+  selectSpaceRemoteAuth,
+} from "../space/spaceAccess";
+
+type FetchSpaceInput = SpaceId | { spaceId: SpaceId; fresh?: boolean };
+
+export const fetchSpaceAction = async (
+  input: FetchSpaceInput,
+  thunkAPI: any
+): Promise<{ spaceId: SpaceId; spaceData: SpaceData }> => {
+  const rawSpaceId = typeof input === "string" ? input : input?.spaceId;
+  const fresh = typeof input === "object" && input !== null ? !!input.fresh : false;
+  const { dispatch } = thunkAPI;
+
+  if (!rawSpaceId) {
+    throw new Error("spaceId is required");
+  }
+
+  // Normalize ID for fetching
+  const spaceId = normalizeSpaceId(rawSpaceId);
+  const spaceKey = createSpaceKey.space(spaceId);
+
+  if (fresh) {
+    const { token, userId, servers } = selectSpaceRemoteAuth(thunkAPI.getState());
+    if (token && userId && servers.length > 0) {
+      const remoteSpace = await fetchAuthoritativeRemoteSpace({
+        servers,
+        token,
+        userId,
+        spaceId,
+      });
+      if (remoteSpace) return { spaceId, spaceData: remoteSpace };
+      throw new Error(`Space not found: ${spaceId}`);
+    }
+  }
+
+  const readSpace = async (dbKey: string): Promise<SpaceData | null> => {
+    try {
+      const { read, readAndWait } = await import("../../database/dbSlice");
+      if (fresh) {
+        return await dispatch(readAndWait(dbKey)).unwrap();
+      }
+      return await dispatch(
+        read({
+          dbKey,
+        })
+      ).unwrap();
+    } catch {
+      return null;
+    }
+  };
+
+  let spaceData: SpaceData | null = await readSpace(spaceKey);
+
+  // If not found, try the raw ID as a fallback (maybe stored with the prefix)
+  if (!spaceData && rawSpaceId !== spaceKey) {
+    spaceData = await readSpace(rawSpaceId);
+  }
+
+  if (!spaceData) {
+    throw new Error(`Space not found: ${spaceId}`);
+  }
+
+  // Ensure returned ID is normalized
+  return { spaceId, spaceData };
+};

package/create/space/fetchSpaceSidebarStateAction.ts

@@ -0,0 +1,26 @@
+import { normalizeSpaceId } from "./spaceKeys";
+import { readStoredCollapsedCategories } from "./spaceCollapsedState";
+
+interface FetchSpaceSidebarStateResponse {
+  collapsedCategories: Record<string, boolean>;
+}
+
+export const fetchSpaceSidebarStateAction = async (
+  spaceId: string,
+  thunkAPI: any,
+): Promise<FetchSpaceSidebarStateResponse> => {
+  const { dispatch, getState } = thunkAPI;
+  const normalizedSpaceId = normalizeSpaceId(spaceId);
+  void dispatch;
+  void getState;
+
+  return {
+    collapsedCategories:
+      typeof window === "undefined"
+        ? {}
+        : readStoredCollapsedCategories(
+            normalizedSpaceId,
+            window.localStorage,
+          ),
+  };
+};

package/create/space/hooks/agentFetchRetry.ts

@@ -0,0 +1,19 @@
+export const FETCH_RETRY_BASE_MS = 1200;
+export const FETCH_RETRY_MAX_MS = 15000;
+export const FETCH_RETRY_JITTER_MS = 600;
+
+export const calculateRetryDelayMs = (
+  attempt: number,
+  randomValue: number
+) => {
+  const safeAttempt = Math.max(1, Math.min(attempt, 6));
+  const exponentialDelay = Math.min(
+    FETCH_RETRY_MAX_MS,
+    FETCH_RETRY_BASE_MS * 2 ** (safeAttempt - 1)
+  );
+  const jitter = Math.floor(
+    Math.max(0, Math.min(randomValue, 0.9999)) * FETCH_RETRY_JITTER_MS
+  );
+  return exponentialDelay + jitter;
+};
+

package/create/space/hooks/useAgentFetcher.ts

@@ -0,0 +1,149 @@
+import { useCallback, useEffect, useMemo, useRef } from "react";
+import { useAppDispatch, useAppSelector } from "../../../app/store";
+import { read, selectEntities } from "../../../database/dbSlice";
+import { SpaceContent, Agent, ContentType } from "../../../app/types";
+import { calculateRetryDelayMs } from "./agentFetchRetry";
+
+const FETCH_CONCURRENCY = 6;
+
+type RetryState = {
+  attempt: number;
+  nextRetryAt: number;
+};
+
+const isAgentItem = (item: SpaceContent) => {
+  const type = item.type?.toLowerCase();
+  const key = item.contentKey;
+  return (
+    type === ContentType.AGENT ||
+    type === "cybot" ||
+    key.startsWith("agent-") ||
+    key.startsWith("cybot-")
+  );
+};
+
+export const useAgentFetcher = (items: SpaceContent[] | undefined | null) => {
+  const dispatch = useAppDispatch();
+  const dbEntities = useAppSelector(selectEntities);
+  const inFlightKeysRef = useRef<Set<string>>(new Set());
+  const retryStateRef = useRef<Map<string, RetryState>>(new Map());
+  const visibleAgentKeysRef = useRef<string[]>([]);
+  const dbEntitiesRef = useRef(dbEntities);
+
+  const markReadFailure = useCallback((key: string) => {
+    const previous = retryStateRef.current.get(key);
+    const attempt = Math.min((previous?.attempt ?? 0) + 1, 6);
+    retryStateRef.current.set(key, {
+      attempt,
+      nextRetryAt: Date.now() + calculateRetryDelayMs(attempt, Math.random()),
+    });
+  }, []);
+
+  const visibleAgentKeys = useMemo(() => {
+    if (!items || items.length === 0) return [];
+    const keys: string[] = [];
+    const seen = new Set<string>();
+    items.forEach((item) => {
+      if (!item || !isAgentItem(item)) return;
+      const key = item.contentKey;
+      if (seen.has(key)) return;
+      seen.add(key);
+      keys.push(key);
+    });
+    return keys;
+  }, [items]);
+
+  const agentsMap = useMemo(() => {
+    const next = new Map<string, Agent>();
+    visibleAgentKeys.forEach((key) => {
+      const agent = dbEntities[key] as Agent | undefined;
+      if (agent) next.set(key, agent);
+    });
+    return next;
+  }, [visibleAgentKeys, dbEntities]);
+
+  useEffect(() => {
+    visibleAgentKeysRef.current = visibleAgentKeys;
+  }, [visibleAgentKeys]);
+
+  useEffect(() => {
+    dbEntitiesRef.current = dbEntities;
+  }, [dbEntities]);
+
+  useEffect(() => {
+    const visible = new Set(visibleAgentKeys);
+    for (const key of Array.from(inFlightKeysRef.current)) {
+      if (!visible.has(key)) inFlightKeysRef.current.delete(key);
+    }
+    for (const [key] of Array.from(retryStateRef.current.entries())) {
+      if (!visible.has(key)) {
+        retryStateRef.current.delete(key);
+      }
+    }
+  }, [visibleAgentKeys]);
+
+  const fetchAgents = useCallback(async () => {
+    const currentVisibleAgentKeys = visibleAgentKeysRef.current;
+    const currentDbEntities = dbEntitiesRef.current;
+
+    if (currentVisibleAgentKeys.length === 0) return;
+
+    const now = Date.now();
+    const queue: string[] = [];
+    currentVisibleAgentKeys.forEach((key) => {
+      if (currentDbEntities[key]) {
+        retryStateRef.current.delete(key);
+        return;
+      }
+      if (inFlightKeysRef.current.has(key)) return;
+      const retryState = retryStateRef.current.get(key);
+      if (
+        retryState &&
+        typeof retryState.nextRetryAt === "number" &&
+        now < retryState.nextRetryAt
+      ) {
+        return;
+      }
+      queue.push(key);
+    });
+
+    if (queue.length === 0) return;
+
+    const workers = Array.from(
+      { length: Math.min(FETCH_CONCURRENCY, queue.length) },
+      async () => {
+        while (queue.length > 0) {
+          const key = queue.shift();
+          if (!key) continue;
+
+          inFlightKeysRef.current.add(key);
+          try {
+            const agentData = await (dispatch as any)(
+              read({ dbKey: key })
+            ).unwrap();
+            if (agentData) {
+              retryStateRef.current.delete(key);
+            } else {
+              markReadFailure(key);
+            }
+          } catch {
+            markReadFailure(key);
+          } finally {
+            inFlightKeysRef.current.delete(key);
+          }
+        }
+      }
+    );
+
+    await Promise.all(workers);
+  }, [dispatch, markReadFailure]);
+
+  useEffect(() => {
+    void fetchAgents();
+  }, [fetchAgents, visibleAgentKeys, dbEntities]);
+
+  return {
+    agentsMap,
+    fetchAgents,
+  };
+};

package/create/space/hooks/useGroupedContent.ts

@@ -0,0 +1,118 @@
+// 文件路径: src/hooks/useGroupedContent.ts
+import React, { useMemo } from "react";
+import { Contents } from "../../../app/types";
+import { Category } from "../../../app/types";
+import { Categories } from "../../../app/types";
+import { SpaceContent, SpaceData } from "../../../app/types";
+
+interface ProcessedCategoryItem {
+  id: string;
+  name: string;
+  order: number;
+  updatedAt: number;
+}
+
+interface GroupedContentResult {
+  groupedData: {
+    categorized: Record<string, SpaceContent[]>;
+    uncategorized: SpaceContent[];
+  };
+  sortedCategories: ProcessedCategoryItem[];
+}
+
+function filterAndSortContentItems(
+  contents: Contents | null | undefined
+): SpaceContent[] {
+  if (!contents) return [];
+  return Object.values(contents)
+    .filter((item): item is SpaceContent => item !== null)
+    .sort((a, b) => {
+      const timeA = new Date(a.updatedAt).getTime();
+      const timeB = new Date(b.updatedAt).getTime();
+      return timeB - timeA;
+    });
+}
+
+function getValidCategoriesMap(
+  categories: Categories | null | undefined
+): Record<string, Category> {
+  const validCategoriesMap: Record<string, Category> = {};
+  if (!categories) return validCategoriesMap;
+  for (const categoryId in categories) {
+    if (
+      Object.prototype.hasOwnProperty.call(categories, categoryId) &&
+      categories[categoryId] !== null
+    ) {
+      validCategoriesMap[categoryId] = categories[categoryId] as Category;
+    }
+  }
+  return validCategoriesMap;
+}
+
+function isItemCategorized(
+  item: SpaceContent,
+  validCategoriesMap: Record<string, Category>
+): boolean {
+  return (
+    item.categoryId !== undefined &&
+    item.categoryId !== "" &&
+    validCategoriesMap.hasOwnProperty(item.categoryId)
+  );
+}
+
+function groupContentItems(
+  sortedContent: SpaceContent[],
+  validCategoriesMap: Record<string, Category>
+): GroupedContentResult["groupedData"] {
+  const categorized: Record<string, SpaceContent[]> = {};
+  const uncategorized: SpaceContent[] = [];
+  Object.keys(validCategoriesMap).forEach((categoryId) => {
+    categorized[categoryId] = [];
+  });
+  sortedContent.forEach((item) => {
+    if (isItemCategorized(item, validCategoriesMap)) {
+      categorized[item.categoryId!].push(item); // 使用 push 替代 unshift
+    } else {
+      uncategorized.push(item); // 使用 push 替代 unshift
+    }
+  });
+  // 反转数组以保持最新在前
+  // Object.values(categorized).forEach((arr) => arr.reverse());
+  // uncategorized.reverse();
+  return { categorized, uncategorized };
+}
+
+function sortValidCategories(
+  validCategoriesMap: Record<string, Category>
+): ProcessedCategoryItem[] {
+  return Object.entries(validCategoriesMap)
+    .map(
+      ([id, categoryData]): ProcessedCategoryItem => ({
+        id,
+        name: categoryData.name,
+        order: categoryData.order,
+        updatedAt: categoryData.updatedAt,
+      })
+    )
+    .sort((a, b) => a.order - b.order);
+}
+
+const DEFAULT_RESULT: GroupedContentResult = {
+  groupedData: { categorized: {}, uncategorized: [] },
+  sortedCategories: [],
+};
+
+export const useGroupedContent = (
+  space: SpaceData | null
+): GroupedContentResult => {
+  return useMemo((): GroupedContentResult => {
+    if (!space) return DEFAULT_RESULT;
+    const rawContents = space.contents;
+    const rawCategories = space.categories;
+    const sortedContent = filterAndSortContentItems(rawContents);
+    const validCategoriesMap = getValidCategoriesMap(rawCategories);
+    const groupedData = groupContentItems(sortedContent, validCategoriesMap);
+    const sortedCategories = sortValidCategories(validCategoriesMap);
+    return { groupedData, sortedCategories };
+  }, [space]); // 依赖 space 对象
+};

package/create/space/hooks/useSpaceEvents.ts

@@ -0,0 +1,43 @@
+// packages/create/space/hooks/useSpaceEvents.ts
+// 订阅 space SSE 频道，实时更新 Redux state。
+//
+// 核心设计：
+// - 整个 space 只需 1 条 SSE 连接，不管有多少个 running dialog
+// - space 频道携带 dialog.created / dialog.done / dialog.failed
+// - 直接 patch Redux state，不 re-fetch，刷新后 fetchSpace 重新读 DB
+//
+// 使用：在 SpaceLayout 或 SidebarContent 里调用一次即可
+//   useSpaceEvents();
+
+import { useEffect } from "react";
+import { useAppDispatch, useAppSelector } from "../../../app/store";
+import { selectCurrentSpaceId, applySpaceEvent } from "../spaceSlice";
+import { selectRuntimeSnapshot } from "../../../app/stateViews/runtime";
+import { subscribeSharedSse } from "../../../app/realtime/sharedSse";
+
+export function useSpaceEvents() {
+    const dispatch = useAppDispatch();
+    const spaceId = useAppSelector(selectCurrentSpaceId);
+    const { currentServer, currentToken: token } =
+        useAppSelector(selectRuntimeSnapshot);
+
+    useEffect(() => {
+        if (!spaceId || !currentServer) return;
+
+        const channel = `space-${spaceId}`;
+        const dispose = subscribeSharedSse({
+            key: `${currentServer}:${channel}`,
+            url: `${currentServer}/api/events/${channel}`,
+            headers: token ? { Authorization: `Bearer ${token}` } : undefined,
+            onEvent: (event) => {
+                if (typeof event.type === "string") {
+                    dispatch(applySpaceEvent(event as any));
+                }
+            },
+        });
+
+        return () => {
+            dispose();
+        };
+    }, [spaceId, currentServer, token, dispatch]);
+}