nolo-cli 0.1.39 → 0.1.41

package/create/space/spaceThunks.ts

@@ -0,0 +1,410 @@
+// create/space/spaceThunks.ts
+import { asyncThunkCreator } from "@reduxjs/toolkit";
+import type { SpaceContent, SpaceData } from "../../app/types";
+import { patch, read } from "../../database/dbSlice";
+import { addSpaceAction } from "./addSpaceAction";
+import { deleteSpaceAction } from "./deleteSpaceAction";
+import { fetchSpaceAction } from "./fetchSpaceAction";
+import { loadDefaultSpaceAction } from "./loadDefaultSpaceAction";
+import { createSpaceKey, normalizeSpaceId } from "./spaceKeys";
+import { updateSpaceAction } from "./updateSpaceAction";
+import { fetchSpaceSidebarStateAction } from "./fetchSpaceSidebarStateAction";
+import { changeSpaceAction } from "./changeSpaceAction";
+import { type SpaceState } from "./types";
+
+type Create = ReturnType<typeof asyncThunkCreator<SpaceState>>;
+
+const parseUpdatedAt = (value: unknown): number => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const ts = Date.parse(value);
+    return Number.isFinite(ts) ? ts : 0;
+  }
+  return 0;
+};
+
+const dedupeMemberSpaces = <T extends { spaceId: string }>(memberSpaces: T[]): T[] => {
+  const membershipMap = new Map<string, T>();
+  memberSpaces.forEach((space) => {
+    const nextUpdatedAt = parseUpdatedAt(
+      (space as any).spaceUpdatedAt ??
+        (space as any).memberUpdatedAt ??
+        (space as any).updatedAt ??
+        (space as any).createdAt ??
+        (space as any).joinedAt
+    );
+    const prev = membershipMap.get(space.spaceId);
+    const prevUpdatedAt = prev
+      ? parseUpdatedAt(
+          (prev as any).spaceUpdatedAt ??
+            (prev as any).memberUpdatedAt ??
+            (prev as any).updatedAt ??
+            (prev as any).createdAt ??
+            (prev as any).joinedAt
+        )
+      : -1;
+    if (!prev || nextUpdatedAt >= prevUpdatedAt) {
+      membershipMap.set(space.spaceId, space);
+    }
+  });
+  return Array.from(membershipMap.values());
+};
+
+const extractTypedIdentityId = (key: string, type: string): string | null => {
+  if (!key || !type || !key.startsWith(`${type}-`)) return null;
+  const parts = key.split("-");
+  if (parts.length < 2) return null;
+  if (parts.length >= 3) return parts.slice(2).join("-");
+  return parts[1] || null;
+};
+
+const isCanonicalTypedDbKey = (key: string, type: string): boolean => {
+  if (!key || !type || !key.startsWith(`${type}-`)) return false;
+  const parts = key.split("-");
+  return parts.length >= 3;
+};
+
+const dedupeSpaceContents = (
+  contents: Record<string, SpaceContent | null> | undefined
+): {
+  contents: Record<string, SpaceContent | null>;
+  removedKeys: string[];
+  changed: boolean;
+} => {
+  if (!contents) return { contents: {}, removedKeys: [], changed: false };
+
+  const entries = Object.entries(contents);
+  const sorted = [...entries].sort((a, b) => {
+    const aItem = a[1];
+    const bItem = b[1];
+    const aType = String(aItem?.type || "").toLowerCase();
+    const bType = String(bItem?.type || "").toLowerCase();
+    const aCanonical =
+      isCanonicalTypedDbKey(a[0], aType) ||
+      isCanonicalTypedDbKey(String(aItem?.contentKey || ""), aType);
+    const bCanonical =
+      isCanonicalTypedDbKey(b[0], bType) ||
+      isCanonicalTypedDbKey(String(bItem?.contentKey || ""), bType);
+
+    if (aCanonical !== bCanonical) return aCanonical ? -1 : 1;
+
+    const aUpdated = parseUpdatedAt(aItem?.updatedAt);
+    const bUpdated = parseUpdatedAt(bItem?.updatedAt);
+    return bUpdated - aUpdated;
+  });
+
+  let changed = false;
+  const deduped: Record<string, SpaceContent | null> = {};
+  const seenIdentity = new Set<string>();
+
+  for (const [entryKey, item] of sorted) {
+    if (!item) {
+      if (Object.prototype.hasOwnProperty.call(deduped, entryKey)) changed = true;
+      else deduped[entryKey] = item;
+      continue;
+    }
+
+    const normalizedType = String(item.type || "").toLowerCase();
+    const currentContentKey = String(item.contentKey || entryKey);
+    const typedIdFromEntry = extractTypedIdentityId(entryKey, normalizedType);
+    const typedIdFromContent = extractTypedIdentityId(currentContentKey, normalizedType);
+    const identityId = typedIdFromEntry || typedIdFromContent || currentContentKey || entryKey;
+    const identity = `${normalizedType || "unknown"}:${identityId}`;
+
+    if (seenIdentity.has(identity)) {
+      changed = true;
+      continue;
+    }
+    seenIdentity.add(identity);
+
+    const contentKeyIsCanonical = isCanonicalTypedDbKey(
+      currentContentKey,
+      normalizedType
+    );
+    const entryKeyIsCanonical = isCanonicalTypedDbKey(entryKey, normalizedType);
+    const canonicalKey =
+      (contentKeyIsCanonical && currentContentKey) ||
+      (entryKeyIsCanonical && entryKey) ||
+      entryKey;
+    const canonicalContentKey =
+      (contentKeyIsCanonical && currentContentKey) ||
+      (entryKeyIsCanonical && entryKey) ||
+      currentContentKey;
+
+    if (canonicalKey !== entryKey || canonicalContentKey !== item.contentKey) {
+      changed = true;
+    }
+
+    deduped[canonicalKey] = {
+      ...item,
+      contentKey: canonicalContentKey,
+    };
+  }
+
+  const removedKeys = Object.keys(contents).filter(
+    (key) => !Object.prototype.hasOwnProperty.call(deduped, key)
+  );
+
+  if (!changed && removedKeys.length > 0) {
+    changed = true;
+  }
+
+  return { contents: deduped, removedKeys, changed };
+};
+
+/**
+ * 创建与 Space 操作相关的 Async Thunks
+ * @param create - 由 buildCreateSlice 提供的创建器对象
+ */
+export const createSpaceThunks = (create: Create) => ({
+  // --- 读取当前设备下的空间侧边栏状态 ---
+  fetchSpaceSidebarState: create.asyncThunk(fetchSpaceSidebarStateAction, {
+    fulfilled: (state, action) => {
+      state.collapsedCategories = action.payload.collapsedCategories;
+    },
+    rejected: (state, action) => {
+      console.error("获取空间侧边栏状态失败:", action.error.message);
+      state.collapsedCategories = {};
+    },
+  }),
+
+  // --- 切换空间 (核心操作) ---
+  changeSpace: create.asyncThunk(changeSpaceAction, {
+    pending: (state, action) => {
+      const newSpaceId = normalizeSpaceId(action.meta.arg);
+      if (state.currentSpaceId !== newSpaceId) {
+        state.loading = true;
+        // Wait until changeSpace.fulfilled before exposing the route space.
+        // Otherwise selectCurrentSpace can render stale local cache for a
+        // space the current user can no longer access.
+        state.currentSpace = null;
+      }
+      state.error = undefined;
+    },
+    fulfilled: (state, action) => {
+      state.currentSpaceId = action.payload.spaceId;
+      state.currentSpace = action.payload.spaceData;
+      // 原子更新：在内容显示的同一帧应用折叠状态
+      state.collapsedCategories =
+        action.payload.sidebarState?.collapsedCategories || {};
+      state.initialized = true;
+      state.loading = false;
+    },
+    rejected: (state, action) => {
+      state.error = action.error.message || "切换空间失败";
+      state.initialized = true;
+      state.loading = false;
+      state.currentSpaceId = null;
+      state.currentSpace = null;
+      state.collapsedCategories = {};
+    },
+  }),
+
+  // ... (保留后面的 actions 不变，只需对齐缩进)
+
+  // --- 其他核心空间操作 ---
+  addSpace: create.asyncThunk(addSpaceAction, {
+    fulfilled: (state, action) => {
+      state.memberSpaces = dedupeMemberSpaces([
+        ...(state.memberSpaces || []),
+        action.payload,
+      ]);
+    },
+    pending: (state) => {
+      state.loading = true;
+    },
+    rejected: (state, action) => {
+      state.loading = false;
+      state.error = action.error.message;
+    },
+  }),
+
+  deleteSpace: create.asyncThunk(deleteSpaceAction, {
+    fulfilled: (state, action) => {
+      const { spaceId } = action.payload;
+      if (state.memberSpaces) {
+        state.memberSpaces = state.memberSpaces.filter(
+          (space) => space.spaceId !== spaceId
+        );
+      }
+      if (spaceId === state.currentSpaceId) {
+        state.currentSpace = null;
+        state.currentSpaceId = null;
+        state.collapsedCategories = {};
+      }
+    },
+  }),
+
+  updateSpace: create.asyncThunk(updateSpaceAction, {
+    fulfilled: (state, action) => {
+      const { updatedSpace, spaceId } = action.payload;
+      if (spaceId === state.currentSpaceId) {
+        state.currentSpace = updatedSpace;
+      }
+      if (state.memberSpaces && updatedSpace.name) {
+        state.memberSpaces = state.memberSpaces.map((space) =>
+          space.spaceId === updatedSpace.id
+            ? { ...space, spaceName: updatedSpace.name }
+            : space
+        );
+      }
+    },
+  }),
+
+  loadDefaultSpace: create.asyncThunk(loadDefaultSpaceAction, {
+    pending: (state) => {
+      state.loading = true;
+      state.initialized = false;
+      state.error = undefined;
+    },
+    fulfilled: (state) => {
+      state.loading = false;
+      // 实际状态更新由内部派发的 changeSpace Thunk 处理
+      if (!state.currentSpaceId) {
+        state.initialized = true;
+        state.collapsedCategories = {};
+      }
+    },
+    rejected: (state, action) => {
+      state.loading = false;
+      state.initialized = true;
+      state.error = action.error.message || "加载默认空间失败";
+      state.currentSpaceId = null;
+      state.currentSpace = null;
+      state.collapsedCategories = {};
+    },
+  }),
+
+  fetchSpace: create.asyncThunk(fetchSpaceAction, {
+    fulfilled: (state, action) => {
+      const { spaceId, spaceData } = action.payload;
+      // 如果当前没有空间，或者 ID 匹配，则更新当前空间
+      if (!state.currentSpaceId || state.currentSpaceId === spaceId) {
+        state.currentSpaceId = spaceId;
+        state.currentSpace = spaceData;
+        state.initialized = true;
+      }
+    },
+  }),
+
+  fixSpace: create.asyncThunk(
+    async (spaceId: string, thunkAPI) => {
+      const spaceKey = createSpaceKey.space(spaceId);
+      const spaceData = (await thunkAPI.dispatch(
+        read({ dbKey: spaceKey })
+      ).unwrap()) as SpaceData | null;
+
+      if (!spaceData) {
+        throw new Error("空间不存在");
+      }
+
+      const changes: Partial<Pick<SpaceData, "id" | "contents" | "updatedAt">> = {};
+      const spaceDataId = String(spaceData.id || "");
+      if (spaceDataId.startsWith("space-")) {
+        changes.id = spaceDataId.slice(6);
+      }
+
+      const {
+        contents: dedupedContents,
+        removedKeys,
+        changed: deduped,
+      } = dedupeSpaceContents(spaceData.contents);
+
+      const agentReferenceEntries = Object.entries(dedupedContents).filter(
+        ([entryKey, item]) => {
+          if (!item) return false;
+          const normalizedType = String(item.type || "").toLowerCase();
+          const contentKey = String(item.contentKey || entryKey);
+          return (
+            normalizedType === "agent" ||
+            normalizedType === "cybot" ||
+            contentKey.startsWith("agent-") ||
+            contentKey.startsWith("cybot-") ||
+            entryKey.startsWith("agent-") ||
+            entryKey.startsWith("cybot-")
+          );
+        }
+      );
+
+      const orphanAgentEntryKeys = (
+        await Promise.all(
+          agentReferenceEntries.map(async ([entryKey, item]) => {
+            const dbKey = String(item?.contentKey || entryKey);
+            try {
+              const entity = await thunkAPI.dispatch(
+                read({ dbKey })
+              ).unwrap();
+              return entity ? null : entryKey;
+            } catch {
+              return entryKey;
+            }
+          })
+        )
+      ).filter((key): key is string => !!key);
+
+      let contentChanges: Record<string, SpaceContent | null> | null = null;
+      if (deduped) {
+        contentChanges = { ...dedupedContents };
+        for (const removedKey of removedKeys) {
+          if (!Object.prototype.hasOwnProperty.call(contentChanges, removedKey)) {
+            contentChanges[removedKey] = null;
+          }
+        }
+      }
+      if (orphanAgentEntryKeys.length > 0) {
+        if (!contentChanges) contentChanges = { ...dedupedContents };
+        orphanAgentEntryKeys.forEach((entryKey) => {
+          contentChanges![entryKey] = null;
+        });
+      }
+      if (contentChanges) {
+        changes.contents = contentChanges;
+      }
+
+      if (Object.keys(changes).length === 0) {
+        return {
+          repaired: false,
+          deduped: false,
+          prunedOrphanAgentRefs: 0,
+          spaceData,
+        };
+      }
+
+      changes.updatedAt = Math.max(
+        Date.now(),
+        parseUpdatedAt(spaceData.updatedAt) + 1
+      );
+
+      await thunkAPI.dispatch(
+        patch({ dbKey: spaceKey, changes })
+      ).unwrap();
+
+      const refreshedSpaceData = (await thunkAPI.dispatch(
+        read({ dbKey: spaceKey })
+      ).unwrap()) as SpaceData | null;
+
+      return {
+        repaired: true,
+        deduped,
+        prunedOrphanAgentRefs: orphanAgentEntryKeys.length,
+        spaceData: refreshedSpaceData || ({ ...spaceData, ...changes } as SpaceData),
+      };
+    },
+    {
+      fulfilled: (state, action) => {
+        if (state.currentSpaceId !== action.meta.arg) return;
+        const nextSpace = action.payload.spaceData;
+        if (!nextSpace) return;
+        if (!state.currentSpace) {
+          state.currentSpace = nextSpace;
+          return;
+        }
+        const currentUpdatedAt = parseUpdatedAt(state.currentSpace.updatedAt);
+        const nextUpdatedAt = parseUpdatedAt(nextSpace.updatedAt);
+        if (nextUpdatedAt > currentUpdatedAt) {
+          state.currentSpace = nextSpace;
+        }
+      },
+    }
+  ),
+});

package/create/space/types.ts

@@ -0,0 +1,27 @@
+import { SpaceData, SpaceMemberWithSpaceInfo } from "../../app/types";
+
+export type SpaceId = string;
+
+export type SpaceViewMode = "all" | "categories";
+
+export interface CreateSpaceRequest { }
+
+export interface SpaceState {
+    currentSpaceId: string | null;
+    currentSpace: SpaceData | null;
+    memberSpaces: SpaceMemberWithSpaceInfo[] | null;
+    loading: boolean;
+    error?: string;
+    initialized: boolean;
+    collapsedCategories: Record<string, boolean>;
+    /** "全部"视图 vs "分类"视图 */
+    viewMode: SpaceViewMode;
+    /** 实时任务状态：dialogId → "running" | "done" | "failed" */
+    dialogStatuses: Record<string, string>;
+    /** 最近一次 dialog 事件时间，用于顶部通知排序 */
+    dialogEventTimestamps: Record<string, number>;
+    /** 运行时可用的 dialog 标题缓存 */
+    dialogTitles: Record<string, string>;
+    /** 第一层网页体验：后台完成/失败后给侧边栏一个未读提示点，进入该对话即清除 */
+    unreadDialogIds: Record<string, boolean>;
+}

package/create/space/updateSpaceAction.ts

@@ -0,0 +1,107 @@
+import { selectUserId } from "../../auth/authSlice";
+import { read, patch } from "../../database/dbSlice";
+import { createSpaceKey } from "../space/spaceKeys";
+import type { SpaceMember, SpaceVisibility, SpaceData } from "../../app/types";
+import type { AppDispatch, RootState } from "../../app/store";
+
+export const updateSpaceAction = async (
+  input: {
+    spaceId: string;
+    name?: string;
+    description?: string;
+    visibility?: SpaceVisibility;
+  },
+  thunkAPI: { dispatch: AppDispatch; getState: () => RootState }
+) => {
+  const { spaceId, name, description, visibility } = input;
+  const { dispatch, getState } = thunkAPI;
+  const state = getState();
+  const userId = selectUserId(state);
+  const spaceKey = createSpaceKey.space(spaceId);
+  let spaceData: SpaceData | null = null;
+
+  try {
+    spaceData = await dispatch(read({
+      dbKey: spaceKey
+    })).unwrap();
+  } catch (readError) {
+    throw new Error(
+      `无法加载空间数据: ${spaceId}, 原因: ${readError.message || "未知错误"}`
+    );
+  }
+
+  if (!spaceData.members || !spaceData.members.includes(userId)) {
+    throw new Error("当前用户不是空间成员，无法更新空间设置。");
+  }
+
+  const changes: Partial<SpaceData> & { updatedAt?: number } = {};
+  let hasChanges = false;
+  if (name !== undefined && name !== spaceData.name) {
+    changes.name = name.trim();
+    hasChanges = true;
+  }
+  if (description !== undefined && description !== spaceData.description) {
+    changes.description = description;
+    hasChanges = true;
+  }
+  if (visibility !== undefined && visibility !== spaceData.visibility) {
+    changes.visibility = visibility;
+    hasChanges = true;
+  }
+
+  // 如果没有实际的值变化，直接返回，避免不必要的写入操作
+  if (!hasChanges) {
+    return { updatedSpace: spaceData, spaceId };
+  }
+
+  const now = Date.now();
+  changes.updatedAt = now;
+
+  let updatedSpaceData: SpaceData;
+  try {
+    updatedSpaceData = await dispatch(
+      patch({
+        dbKey: spaceKey,
+        changes,
+      })
+    ).unwrap();
+  } catch (patchError) {
+    throw new Error(`更新空间设置失败: ${patchError.message || "未知错误"}`);
+  }
+
+  // 如果更新了名称，同步更新当前用户的 space-member 数据
+  if (changes.name !== undefined) {
+    const memberKey = createSpaceKey.member(userId, spaceId);
+    try {
+      const memberData = (await dispatch(
+        read({
+          dbKey: memberKey
+        })
+      ).unwrap()) as SpaceMember | null;
+
+      if (memberData) {
+        const memberChanges = {
+          spaceName: changes.name,
+          updatedAt: now, // 为 member 数据也设置 updatedAt
+        };
+        await dispatch(
+          patch({
+            dbKey: memberKey,
+            changes: memberChanges,
+          })
+        ).unwrap();
+      }
+    } catch (memberError) {
+      // 此处捕获错误，确保即使成员信息更新失败，空间本身的更新也能成功返回
+      console.error(
+        `Failed to update member data ${memberKey} for space name change:`,
+        memberError
+      );
+    }
+  }
+
+  return {
+    updatedSpace: updatedSpaceData,
+    spaceId,
+  };
+};

package/create/space/utils/permissions.ts

@@ -0,0 +1,47 @@
+// create/space/utils/permissions.ts (新文件)
+
+import type { SpaceData } from "../../../app/types";
+
+/**
+ * 检查用户是否是指定空间的成员。
+ * 如果检查不通过，则抛出错误。
+ * @param spaceData - 要检查的空间数据对象，可以为 null。
+ * @param userId - 要检查的用户 ID，可以为 null。
+ * @throws {Error} 如果空间数据缺失、用户 ID 缺失或用户不是成员。
+ */
+export const checkSpaceMembership = (
+  spaceData: SpaceData | null,
+  userId: string | null
+): void => {
+  if (!spaceData) {
+    // 在调用此函数前，通常应该确保 spaceData 已加载
+    // 但添加此检查以防万一
+    console.error("[Permission Check] Space data is missing.");
+    throw new Error("无法执行权限检查：空间数据缺失。");
+  }
+  if (!userId) {
+    console.error("[Permission Check] User ID is missing.");
+    throw new Error("无法执行权限检查：用户 ID 缺失。");
+  }
+
+  // 检查 members 数组是否存在且包含 userId
+  if (
+    !spaceData.members ||
+    !Array.isArray(spaceData.members) ||
+    !spaceData.members.includes(userId)
+  ) {
+    // 记录警告日志，但抛出统一的、用户友好的错误信息
+    console.warn(
+      `[Permission Check] User ${userId} attempt to operate on space ${spaceData.id} without membership.`
+    );
+    throw new Error("当前用户不是空间成员");
+  }
+
+  // 未来可以在这里添加更多的权限检查逻辑，例如：
+  // if (requiredRole === 'admin' && spaceData.roles[userId] !== 'admin') {
+  //     throw new Error("需要管理员权限");
+  // }
+};
+
+// 你可以在这个文件中添加其他与 Space 权限相关的辅助函数
+// export const checkSpaceOwner = (...) => { ... };

package/create/types.ts

@@ -0,0 +1,21 @@
+// create/types.ts
+export enum DataType {
+  AGENT = "agent",
+  CYBOT = "cybot",
+  DOC = "page",
+  DIALOG = "dialog",
+  NOTIFICATION = "notification",
+  MSG = "msg",
+  TOKEN = "token",
+  SPACE = "space",
+  TRANSACTION = "transaction",
+  SETTING = "setting",
+  TASK = "task",
+
+  TABLE = "table",
+  TABLE_ROW = "table_row",
+  FILE = "file",
+  IMAGE = "image",
+  APP = "app",
+  EMAIL = "email",
+}

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]));
+};