nolo-cli 0.1.26 → 0.1.29

package/create/space/member/removeMemberAction.ts

@@ -0,0 +1,67 @@
+import type { ULID } from "../../../app/types";
+import type { SpaceData } from "../../../app/types";
+import { selectUserId } from "../../../auth/authSlice";
+import { createSpaceKey, normalizeSpaceId } from "../../space/spaceKeys";
+import { read, write, remove } from "../../../database/dbSlice"; // 使用 remove
+import {
+  persistDefaultSpacePreference,
+  readDefaultSpaceIdPreference,
+} from "../../../app/settings/defaultSpacePreference";
+
+/**
+ * 从空间中删除成员
+ *
+ * 说明：
+ * 1. 当前用户必须是该空间的 owner，才能进行删除操作；
+ * 2. 待删除的成员必须存在于空间中，否则直接报错；
+ * 3. 更新 SpaceData.members 数组，删除对应的 SpaceMemberWithSpaceInfo 数据，并更新 updatedAt 字段。
+ */
+export const removeMemberAction = async (
+  input: { spaceId: ULID; memberId: string },
+  thunkAPI: any
+): Promise<{ spaceId: ULID; updatedSpaceData: SpaceData }> => {
+  const { spaceId, memberId } = input;
+  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("Space not found");
+  }
+
+  // 检查当前用户是否是 owner
+  if (spaceData.ownerId !== currentUserId) {
+    throw new Error("只有空间所有者才能删除成员");
+  }
+
+  // 检查待删除的成员是否存在
+  if (!spaceData.members.includes(memberId)) {
+    throw new Error("待删除的成员不存在");
+  }
+
+  // 更新 SpaceData，移除成员
+  const updatedSpaceData: SpaceData = {
+    ...spaceData,
+    members: spaceData.members.filter((id) => id !== memberId),
+    updatedAt: Date.now(),
+  };
+
+  // 删除对应的 SpaceMemberWithSpaceInfo 数据
+  const memberKey = createSpaceKey.member(memberId, spaceId);
+  await Promise.all([
+    dispatch(write({ data: updatedSpaceData, customKey: spaceKey })).unwrap(),
+    dispatch(remove(memberKey)).unwrap(), // 使用 remove 替代 del
+  ]);
+
+  const defaultSpaceId = await readDefaultSpaceIdPreference(dispatch, memberId);
+  if (defaultSpaceId && normalizeSpaceId(defaultSpaceId) === normalizeSpaceId(spaceId)) {
+    await persistDefaultSpacePreference(dispatch, memberId, null);
+  }
+
+  return { spaceId, updatedSpaceData };
+};

package/create/space/publicCatalogSpace.ts

@@ -0,0 +1,39 @@
+import {
+  normalizeSidebarVisibleTypes,
+  type SidebarVisibleType,
+} from "./sidebarVisibleTypes";
+
+export const PUBLIC_CATALOG_SPACE_ID = "01KKY77TT0DA9NY7TNW3R7255N";
+
+export function isPublicCatalogSpace(spaceId?: string | null): boolean {
+  return typeof spaceId === "string" && spaceId.trim() === PUBLIC_CATALOG_SPACE_ID;
+}
+
+export function ensurePublicCatalogVisibleTypes(
+  spaceId: string | null | undefined,
+  visibleTypes: readonly SidebarVisibleType[],
+): SidebarVisibleType[] {
+  const normalized = normalizeSidebarVisibleTypes(visibleTypes);
+  if (!isPublicCatalogSpace(spaceId) || normalized.includes("agent")) {
+    return normalized;
+  }
+  return normalizeSidebarVisibleTypes([...normalized, "agent"]);
+}
+
+export function resolvePersistedCatalogVisibleTypes(
+  spaceId: string | null | undefined,
+  nextVisibleTypes: readonly SidebarVisibleType[],
+  persistedVisibleTypes: readonly SidebarVisibleType[],
+): SidebarVisibleType[] {
+  const normalizedNext = normalizeSidebarVisibleTypes(nextVisibleTypes);
+  if (!isPublicCatalogSpace(spaceId)) {
+    return normalizedNext;
+  }
+
+  const normalizedPersisted = normalizeSidebarVisibleTypes(persistedVisibleTypes);
+  if (normalizedPersisted.includes("agent")) {
+    return normalizedNext;
+  }
+
+  return normalizedNext.filter((type) => type !== "agent");
+}

package/create/space/resolvePreferredSpaceId.ts

@@ -0,0 +1,113 @@
+import type { RootState } from "../../app/store";
+import { readDefaultSpaceIdPreference } from "../../app/settings/defaultSpacePreference";
+import { read, readAndWait } from "../../database/dbSlice";
+
+import { createSpaceKey } from "./spaceKeys";
+
+const isAbortError = (error: unknown): boolean =>
+  error instanceof DOMException
+    ? error.name === "AbortError"
+    : typeof error === "object" &&
+        error !== null &&
+        "name" in error &&
+        error.name === "AbortError";
+
+const isSuppressedMissError = (error: unknown): boolean =>
+  typeof error === "object" &&
+  error !== null &&
+  "message" in error &&
+  typeof error.message === "string" &&
+  (error.message.includes("temporarily suppressed") ||
+    error.message.includes("miss suppressed"));
+
+export const readSpaceIfExists = async (
+  dispatch: any,
+  spaceId?: string | null
+): Promise<string | null> => {
+  if (!spaceId) {
+    return null;
+  }
+
+  try {
+    const result = await dispatch(
+      read({
+        dbKey: createSpaceKey.space(spaceId),
+      })
+    ).unwrap();
+
+    if (result) {
+      return spaceId;
+    }
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+
+    if (!isSuppressedMissError(error)) {
+      console.info(
+        `[resolvePreferredSpaceId] Optimistic read failed for ${spaceId}, retrying with readAndWait:`,
+        error
+      );
+    }
+  }
+
+  try {
+    const result = await dispatch(
+      readAndWait(createSpaceKey.space(spaceId))
+    ).unwrap();
+    return result ? spaceId : null;
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
+    }
+
+    console.info(
+      `[resolvePreferredSpaceId] Confirming space existence failed for ${spaceId}:`,
+      error
+    );
+    return null;
+  }
+};
+
+export const resolvePreferredSpaceId = async ({
+  dispatch,
+  getState,
+  userId,
+}: {
+  dispatch: any;
+  getState: () => RootState;
+  userId?: string | null;
+}): Promise<string | null> => {
+  const state = getState();
+
+  if (state.space.currentSpaceId) {
+    return state.space.currentSpaceId;
+  }
+
+  const candidates: string[] = [];
+  const pushCandidate = (spaceId?: string | null) => {
+    if (!spaceId) return;
+    if (candidates.includes(spaceId)) return;
+    candidates.push(spaceId);
+  };
+
+  pushCandidate(
+    await readDefaultSpaceIdPreference(
+      dispatch,
+      userId ?? state.auth?.currentUser?.userId ?? null
+    )
+  );
+
+  for (const memberSpace of state.space.memberSpaces || []) {
+    pushCandidate(memberSpace?.spaceId);
+  }
+
+  for (const candidate of candidates) {
+    const readableSpaceId = await readSpaceIfExists(dispatch, candidate);
+    if (readableSpaceId) {
+      return readableSpaceId;
+    }
+  }
+
+  return null;
+};

package/create/space/sidebarVisibleTypes.ts

@@ -0,0 +1,214 @@
+import type { SpaceContent } from "../../app/types";
+
+export type SidebarVisibleType =
+  | "dialog"
+  | "page"
+  | "image"
+  | "document"
+  | "video"
+  | "audio"
+  | "table"
+  | "file"
+  | "app"
+  | "agent"
+  | "scheduled";
+
+export const ALL_SIDEBAR_VISIBLE_TYPES: SidebarVisibleType[] = [
+  "dialog",
+  "page",
+  "image",
+  "document",
+  "video",
+  "audio",
+  "table",
+  "file",
+  "app",
+  "agent",
+  "scheduled",
+];
+
+export const SIDEBAR_VISIBLE_TYPES_SEARCH_PARAM = "types";
+
+export const LEGACY_DEFAULT_SIDEBAR_VISIBLE_TYPES: SidebarVisibleType[] = [
+  "dialog",
+  "page",
+  "table",
+];
+
+export const DEFAULT_SIDEBAR_VISIBLE_TYPES: SidebarVisibleType[] = [
+  ...LEGACY_DEFAULT_SIDEBAR_VISIBLE_TYPES,
+  "app",
+];
+
+export const isSidebarVisibleType = (
+  value: string | null | undefined
+): value is SidebarVisibleType =>
+  value === "dialog" ||
+  value === "page" ||
+  value === "image" ||
+  value === "document" ||
+  value === "video" ||
+  value === "audio" ||
+  value === "table" ||
+  value === "file" ||
+  value === "app" ||
+  value === "agent" ||
+  value === "scheduled";
+
+export const collectSidebarVisibleTypes = (
+  values: readonly string[]
+): SidebarVisibleType[] => {
+  const valueSet = new Set(values);
+  return ALL_SIDEBAR_VISIBLE_TYPES.filter((type) => valueSet.has(type));
+};
+
+export const normalizeSidebarVisibleTypes = (
+  values: Iterable<string | null | undefined> | null | undefined,
+  fallback: readonly SidebarVisibleType[] = DEFAULT_SIDEBAR_VISIBLE_TYPES
+): SidebarVisibleType[] => {
+  const normalizedFallback = collectSidebarVisibleTypes([...fallback]);
+  const safeFallback =
+    normalizedFallback.length > 0
+      ? normalizedFallback
+      : [...DEFAULT_SIDEBAR_VISIBLE_TYPES];
+
+  if (!values) {
+    return [...safeFallback];
+  }
+
+  const tokens: string[] = [];
+  for (const value of values) {
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed.length > 0) {
+        tokens.push(trimmed);
+      }
+    }
+  }
+
+  if (tokens.length === 0) {
+    return [...safeFallback];
+  }
+
+  if (tokens.includes("all")) {
+    return [...ALL_SIDEBAR_VISIBLE_TYPES];
+  }
+
+  const normalized = collectSidebarVisibleTypes(tokens);
+  return normalized.length > 0 ? normalized : [...safeFallback];
+};
+
+export const parseSidebarVisibleTypesSearchParam = (
+  rawValue: string | null | undefined
+): SidebarVisibleType[] | null => {
+  if (typeof rawValue !== "string") {
+    return null;
+  }
+
+  const tokens = rawValue
+    .split(",")
+    .map((token) => token.trim())
+    .filter((token) => token.length > 0);
+
+  if (tokens.length === 0) {
+    return null;
+  }
+
+  if (tokens.includes("all")) {
+    return [...ALL_SIDEBAR_VISIBLE_TYPES];
+  }
+
+  const normalized = collectSidebarVisibleTypes(tokens);
+  return normalized.length > 0 ? normalized : null;
+};
+
+export const serializeSidebarVisibleTypesSearchParam = (
+  visibleTypes: readonly SidebarVisibleType[]
+): string | null => {
+  const normalized = collectSidebarVisibleTypes([...visibleTypes]);
+  if (normalized.length === 0) {
+    return null;
+  }
+
+  return areSidebarVisibleTypesEqual(normalized, ALL_SIDEBAR_VISIBLE_TYPES)
+    ? "all"
+    : normalized.join(",");
+};
+
+export const areSidebarVisibleTypesEqual = (
+  left: readonly SidebarVisibleType[],
+  right: readonly SidebarVisibleType[]
+): boolean =>
+  left.length === right.length && left.every((value, index) => value === right[index]);
+
+export const isAllSidebarVisibleTypesSelected = (
+  visibleTypes: readonly SidebarVisibleType[]
+): boolean =>
+  areSidebarVisibleTypesEqual(
+    normalizeSidebarVisibleTypes(visibleTypes, ALL_SIDEBAR_VISIBLE_TYPES),
+    ALL_SIDEBAR_VISIBLE_TYPES
+  );
+
+export const withToggledSidebarVisibleType = (
+  current: readonly SidebarVisibleType[],
+  type: SidebarVisibleType,
+  fallback: readonly SidebarVisibleType[] = DEFAULT_SIDEBAR_VISIBLE_TYPES
+): SidebarVisibleType[] => {
+  const normalizedCurrent = normalizeSidebarVisibleTypes(current, fallback);
+  if (normalizedCurrent.includes(type)) {
+    if (normalizedCurrent.length === 1) {
+      return normalizedCurrent;
+    }
+    return normalizedCurrent.filter((value) => value !== type);
+  }
+
+  return normalizeSidebarVisibleTypes([...normalizedCurrent, type], fallback);
+};
+
+export const matchesSidebarVisibleType = (
+  item: SpaceContent,
+  type: SidebarVisibleType
+): boolean => {
+  const itemType = (item.type as string | undefined)?.toLowerCase();
+  const contentKey = typeof item.contentKey === "string" ? item.contentKey : "";
+  if (type === "agent") {
+    return itemType === "agent" || itemType === "cybot";
+  }
+  if (type === "app") {
+    return itemType === "app" || contentKey.startsWith("app-");
+  }
+  if (type === "scheduled") {
+    return itemType === "task" || contentKey.startsWith("task-");
+  }
+  if (type === "dialog") {
+    return itemType === type && item.triggerType !== "scheduled_run";
+  }
+  if (type === "file") {
+    return itemType === "file" || itemType === "image";
+  }
+  if (type === "image") {
+    return (
+      itemType === "image" ||
+      (itemType === "file" && item.fileCategory === "image") ||
+      contentKey.startsWith("image-")
+    );
+  }
+  if (type === "document") {
+    return itemType === "file" && item.fileCategory === "document";
+  }
+  if (type === "video") {
+    return itemType === "file" && item.fileCategory === "video";
+  }
+  if (type === "audio") {
+    return itemType === "file" && item.fileCategory === "audio";
+  }
+  return itemType === type;
+};
+
+export const matchesSidebarVisibleTypes = (
+  item: SpaceContent,
+  visibleTypes: readonly SidebarVisibleType[]
+): boolean =>
+  normalizeSidebarVisibleTypes(visibleTypes).some((type) =>
+    matchesSidebarVisibleType(item, type)
+  );