nolo-cli 0.1.31 → 0.1.32

package/create/space/spaceThunks.ts

@@ -1,410 +0,0 @@
-// 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

@@ -1,27 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,47 +0,0 @@
-// 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/space/validateSpacePermission.ts

@@ -1,38 +0,0 @@
-import type { SpaceId } from "../space/types";
-import type { SpaceData } from "../../app/types";
-import { selectUserId } from "../../auth/authSlice";
-import { createSpaceKey } from "../space/spaceKeys";
-import { read } from "../../database/dbSlice";
-
-/**
- * 校验当前用户是否为目标空间的成员，并返回空间数据、当前用户ID和空间键。
- *
- * @param spaceId - 空间 ID
- * @param thunkAPI - thunk API 对象，包含 dispatch 和 getState
- * @returns 包含 spaceData、currentUserId 和 spaceKey
- * @throws 如果没有找到空间或当前用户不在空间的成员列表中，将抛出异常
- */
-export const validateSpacePermission = async (
-  spaceId: SpaceId,
-  thunkAPI: any
-): Promise<{
-  spaceData: SpaceData;
-  currentUserId: string;
-  spaceKey: string;
-}> => {
-  const { dispatch, getState } = thunkAPI;
-  const state = getState();
-  const currentUserId = selectUserId(state);
-  const spaceKey = createSpaceKey.space(spaceId);
-  const spaceData: SpaceData | null = await dispatch(read({
-    dbKey: spaceKey
-  })).unwrap();
-
-  if (!spaceData) {
-    throw new Error("空间不存在");
-  }
-  if (!spaceData.members.includes(currentUserId)) {
-    throw new Error("当前用户不是空间成员，无法执行该操作");
-  }
-  return { spaceData, currentUserId, spaceKey };
-};