nolo-cli 0.1.23 → 0.1.29

package/app/hooks/useMyContentItems.ts

@@ -0,0 +1,91 @@
+import { useEffect, useMemo } from "react";
+import { useTranslation } from "react-i18next";
+import { useAppDispatch, useAppSelector } from "../store";
+import {
+  buildMyContentItemsFromUserData,
+  isUserContentAppRecord,
+  MY_CONTENT_USER_DATA_TYPES,
+  resolveUserContentRecordKey,
+  type MyContentListItem,
+} from "../utils/myContentItems";
+import {
+  fetchUserSpaceMemberships,
+  selectAllMemberSpaces,
+} from "../../create/space/spaceSlice";
+import { selectRemoteServer } from "../settings/settingSlice";
+import { selectUserId } from "../../auth/authSlice";
+import { DataType } from "../../create/types";
+import { useUserData } from "../../database/hooks/useUserData";
+
+export function useMyContentItems(): {
+  items: MyContentListItem[];
+  loading: boolean;
+} {
+  const { t } = useTranslation();
+  const currentServer = useAppSelector(selectRemoteServer);
+  const userId = useAppSelector(selectUserId) ?? "";
+  const hasUser = userId.trim().length > 0;
+  const shouldDebugLog =
+    typeof window !== "undefined" &&
+    /^(localhost|127\.0\.0\.1)$/.test(window.location.hostname);
+  const memberSpaces = useAppSelector(selectAllMemberSpaces);
+  const queriedTypes = useMemo(() => MY_CONTENT_USER_DATA_TYPES, []);
+  const { data: records, loading } = useUserData(queriedTypes, userId, 200, {
+    partialDataStrategy: "hydrated-cache",
+    remoteSummary: true,
+  });
+  const spaceNameById = useMemo(
+    () =>
+      new Map(
+        memberSpaces.map((space) => [space.spaceId, space.spaceName || space.spaceId] as const)
+      ),
+    [memberSpaces]
+  );
+
+  // “我的内容”的内容数据只来自统一的 useUserData(types[]) 查询；
+  // memberships 这里仅用于把记录里的 spaceId 映射成人类可读的 spaceName。
+  const items = useMemo(
+    () =>
+      buildMyContentItemsFromUserData(
+        records,
+        currentServer,
+        spaceNameById,
+        t("homeActions.myAppsTitle", "我的应用"),
+        t("homeTabs.myContent", "我的内容")
+      ),
+    [records, currentServer, spaceNameById, t]
+  );
+
+  useEffect(() => {
+    if (shouldDebugLog) {
+      const appLikeRecords = records.filter((record) => isUserContentAppRecord(record));
+      const appItems = items.filter((item) => item.type === DataType.APP);
+      console.debug("[my-content] merged items", {
+        userId,
+        queriedRecords: records.length,
+        appLikeRecords: appLikeRecords.length,
+        appLikeKeys: appLikeRecords
+          .slice(0, 12)
+          .map((record) => resolveUserContentRecordKey(record) || record.appId || "unknown"),
+        builtAppItems: appItems.length,
+        builtAppKeys: appItems.slice(0, 12).map((item) => item.contentKey),
+        memberships: memberSpaces.length,
+        totalItems: items.length,
+      });
+      (window as any).__myContentRecordsDebug = {
+        queriedRecords: records.length,
+        appLikeRecords: appLikeRecords.length,
+        appLikeKeys: appLikeRecords.map((record) =>
+          resolveUserContentRecordKey(record) || record.appId || "unknown"
+        ),
+        builtAppItems: appItems.length,
+        builtAppKeys: appItems.map((item) => item.contentKey),
+      };
+    }
+  }, [records, memberSpaces.length, items.length, shouldDebugLog, userId]);
+
+  return {
+    items,
+    loading: hasUser && loading,
+  };
+}

package/app/hooks/useNewMessageNotification.ts

@@ -0,0 +1,81 @@
+// 文件路径: app/hooks/useNewMessageNotification.ts
+
+import { useEffect, useRef } from "react";
+import { useSelector } from "react-redux";
+import type { RootState } from "../store";
+import type { Message } from "../../chat/messages/types";
+import { selectLastAssistantMessage } from "../../chat/messages/messageSlice";
+
+const extractTextFromContent = (content: Message["content"]): string => {
+    if (typeof content === "string") return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter(
+                (part: any) =>
+                    part &&
+                    part.type === "text" &&
+                    typeof part.text === "string"
+            )
+            .map((part: any) => part.text as string)
+            .join("");
+    }
+    return "";
+};
+
+const buildBody = (msg?: Message, maxLen = 80): string => {
+    if (!msg) return "";
+    const text = extractTextFromContent(msg.content);
+    if (!text) return "";
+    if (text.length <= maxLen) return text;
+    return `${text.slice(0, maxLen)}…`;
+};
+
+const canUseNotification = () =>
+    typeof window !== "undefined" &&
+    typeof Notification !== "undefined";
+
+/**
+ * 主动去请求一次权限，在用户点击某个“开启通知”开关时调用
+ */
+export const requestNotificationPermission = async () => {
+    if (!canUseNotification()) return "unsupported" as const;
+    if (Notification.permission === "granted") return "granted" as const;
+    if (Notification.permission === "denied") return "denied" as const;
+    const result = await Notification.requestPermission();
+    return result;
+};
+
+/**
+ * 在页面不可见且有新的 assistant 消息时发送通知
+ */
+export const useNewMessageNotification = () => {
+    const lastAssistant = useSelector((state: RootState) =>
+        selectLastAssistantMessage(state)
+    );
+    const lastNotifiedIdRef = useRef<string | undefined>();
+
+    useEffect(() => {
+        if (!lastAssistant) return;
+
+        // 防止对同一条消息反复通知
+        if (lastNotifiedIdRef.current === lastAssistant.id) return;
+        lastNotifiedIdRef.current = lastAssistant.id;
+
+        if (!canUseNotification()) return;
+        if (Notification.permission !== "granted") return;
+
+        // 只有在标签页不在前台时才弹通知
+        if (typeof document !== "undefined" &&
+            document.visibilityState === "visible") {
+            return;
+        }
+
+        const body = buildBody(lastAssistant);
+        if (!body) return;
+
+        new Notification("有新的回复", {
+            body,
+            tag: lastAssistant.id, // 相同 tag 的通知会合并
+        });
+    }, [lastAssistant]);
+};

package/app/hooks/usePageMeta.ts

@@ -0,0 +1,107 @@
+import { useEffect } from "react";
+
+import type { PageMeta } from "../seo/pageMeta";
+
+const upsertMeta = (
+  selector: string,
+  factory: () => HTMLMetaElement,
+  content: string
+) => {
+  const existing = document.head.querySelector<HTMLMetaElement>(selector) ?? factory();
+  existing.setAttribute("content", content);
+  if (!existing.parentNode) {
+    document.head.appendChild(existing);
+  }
+};
+
+const upsertLink = (
+  selector: string,
+  factory: () => HTMLLinkElement,
+  href: string
+) => {
+  const existing = document.head.querySelector<HTMLLinkElement>(selector) ?? factory();
+  existing.setAttribute("href", href);
+  if (!existing.parentNode) {
+    document.head.appendChild(existing);
+  }
+};
+
+export const usePageMeta = ({ title, description, url, image, robots, type }: PageMeta) => {
+  useEffect(() => {
+    if (typeof document === "undefined") return;
+
+    document.title = title;
+
+    upsertMeta('meta[name="description"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "description");
+      return meta;
+    }, description);
+
+    upsertMeta('meta[name="robots"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "robots");
+      return meta;
+    }, robots);
+
+    upsertMeta('meta[property="og:title"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("property", "og:title");
+      return meta;
+    }, title);
+
+    upsertMeta('meta[property="og:description"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("property", "og:description");
+      return meta;
+    }, description);
+
+    upsertMeta('meta[property="og:url"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("property", "og:url");
+      return meta;
+    }, url);
+
+    upsertMeta('meta[property="og:image"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("property", "og:image");
+      return meta;
+    }, image);
+
+    upsertMeta('meta[property="og:type"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("property", "og:type");
+      return meta;
+    }, type);
+
+    upsertMeta('meta[name="twitter:card"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "twitter:card");
+      return meta;
+    }, "summary_large_image");
+
+    upsertMeta('meta[name="twitter:title"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "twitter:title");
+      return meta;
+    }, title);
+
+    upsertMeta('meta[name="twitter:description"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "twitter:description");
+      return meta;
+    }, description);
+
+    upsertMeta('meta[name="twitter:image"]', () => {
+      const meta = document.createElement("meta");
+      meta.setAttribute("name", "twitter:image");
+      return meta;
+    }, image);
+
+    upsertLink('link[rel="canonical"]', () => {
+      const link = document.createElement("link");
+      link.setAttribute("rel", "canonical");
+      return link;
+    }, url);
+  }, [description, image, robots, title, type, url]);
+};

package/app/hooks/useRecentlyOpened.ts

@@ -0,0 +1,84 @@
+import { useState, useEffect } from "react";
+
+const STORAGE_KEY = "nolo-recently-opened-v1";
+const MAX_STORED = 20;
+
+export type RecentItem = {
+  key: string;
+  type: string;
+  title: string;
+  spaceId?: string;
+  accessedAt: number;
+};
+
+function readItems(): RecentItem[] {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (!raw) return [];
+    return JSON.parse(raw) as RecentItem[];
+  } catch {
+    return [];
+  }
+}
+
+export function recordRecentVisit(
+  item: Omit<RecentItem, "accessedAt">
+): void {
+  try {
+    const existing = readItems();
+    const filtered = existing.filter((i) => i.key !== item.key);
+    const updated = [
+      { ...item, accessedAt: Date.now() },
+      ...filtered,
+    ].slice(0, MAX_STORED);
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+    // 通知同 tab 的其他 hook 实例刷新
+    window.dispatchEvent(new Event("nolo-recent-updated"));
+  } catch {
+    // localStorage 不可用时静默忽略
+  }
+}
+
+export function updateRecentVisitTitle(key: string, title: string): void {
+  try {
+    const nextTitle = title.trim();
+    if (!key || !nextTitle) return;
+
+    const existing = readItems();
+    let changed = false;
+    const updated = existing.map((item) => {
+      if (item.key !== key || item.title === nextTitle) return item;
+      changed = true;
+      return {
+        ...item,
+        title: nextTitle,
+      };
+    });
+
+    if (!changed) return;
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+    window.dispatchEvent(new Event("nolo-recent-updated"));
+  } catch {
+    // localStorage 不可用时静默忽略
+  }
+}
+
+export function useRecentlyOpened(limit = 12): RecentItem[] {
+  const [items, setItems] = useState<RecentItem[]>(() =>
+    readItems().slice(0, limit)
+  );
+
+  useEffect(() => {
+    const refresh = () => setItems(readItems().slice(0, limit));
+    window.addEventListener("focus", refresh);
+    window.addEventListener("storage", refresh);
+    window.addEventListener("nolo-recent-updated", refresh);
+    return () => {
+      window.removeEventListener("focus", refresh);
+      window.removeEventListener("storage", refresh);
+      window.removeEventListener("nolo-recent-updated", refresh);
+    };
+  }, [limit]);
+
+  return items;
+}

package/app/hooks/useUnifiedStore.ts

@@ -0,0 +1,11 @@
+// packages/app/hooks/useUnifiedStore.ts
+import { useSelector, useDispatch, TypedUseSelectorHook } from "react-redux";
+import type { RootState, AppDispatch } from "../store";
+
+// Web 和 Native 的 RootState 结构虽然略有不同（Web多了table/plan，Native目前还没加），
+// 但 settings/db/auth 等核心 slice 是一致的。
+// 在这里统一导出 hooks，供业务组件使用。
+// 注意：Native 端目前需要确保它的 RootState 类型兼容 Web 端，或者在这里定义一个交集类型。
+
+export const useUnifiedSelector: TypedUseSelectorHook<RootState> = useSelector;
+export const useUnifiedDispatch = () => useDispatch<AppDispatch>();

package/app/hooks/useUserNotifications.ts

@@ -0,0 +1,197 @@
+import { useCallback, useEffect } from "react";
+import { useTranslation } from "react-i18next";
+import { subscribeSharedSse } from "../realtime/sharedSse";
+import { selectRuntimeRemoteServers, selectRuntimeSnapshot } from "../stateViews/runtime";
+import { useAppDispatch, useAppSelector } from "../store";
+import { fetchUserDataThunk } from "../../database/actions/fetchUserData";
+import { cacheMergedUserDataThunk } from "../../database/actions/cacheMergedUserData";
+import { DataType } from "../../create/types";
+import { mergeAndDedupUserData } from "../../database/userDataMerge";
+import {
+  NOTIFICATION_LIMIT,
+  createNotificationRecord,
+  type NotificationEventPayload,
+  type NotificationRecord,
+} from "../notifications/model";
+import {
+  addNotification,
+  replaceNotifications,
+} from "../notifications/notificationSlice";
+import {
+  notificationRecordToAppNotification,
+  normalizeNotificationTimestamp,
+} from "../notifications/formatNotification";
+
+const isNotificationRecord = (value: unknown): value is NotificationRecord => {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    typeof (value as NotificationRecord).notificationId === "string" &&
+    typeof (value as NotificationRecord).userId === "string" &&
+    typeof (value as NotificationRecord).dbKey === "string" &&
+    typeof (value as NotificationRecord).kind === "string"
+  );
+};
+
+const isNotificationEventPayload = (
+  value: Record<string, unknown>
+): value is NotificationEventPayload =>
+  value.type === "notification.upsert" && isNotificationRecord(value.notification);
+
+const loadRemoteNotifications = async ({
+  serverOrigin,
+  token,
+}: {
+  serverOrigin: string;
+  token?: string;
+}) => {
+  const response = await fetch(
+    `${serverOrigin}/api/notifications?limit=${NOTIFICATION_LIMIT}`,
+    {
+      headers: {
+        Accept: "application/json",
+        ...(token ? { Authorization: `Bearer ${token}` } : {}),
+      },
+    }
+  );
+  if (!response.ok) {
+    if (response.status === 401 || response.status === 403) {
+      return { data: { data: [] as NotificationRecord[] } };
+    }
+    throw new Error(`Failed to load notifications from ${serverOrigin}`);
+  }
+  const json = (await response.json()) as { data?: NotificationRecord[] };
+  const data = Array.isArray(json.data)
+    ? json.data.map((record) => ({ ...record, serverOrigin }))
+    : [];
+  return { data: { data } };
+};
+
+const buildLegacySpaceMemberRecord = (
+  event: Record<string, unknown>
+): NotificationRecord | null => {
+  const notificationId =
+    typeof event.notificationId === "string" ? event.notificationId : null;
+  const spaceId = typeof event.spaceId === "string" ? event.spaceId : null;
+  const userId =
+    typeof event.memberUserId === "string" ? event.memberUserId : null;
+  if (!notificationId || !spaceId || !userId) return null;
+  const createdAt = normalizeNotificationTimestamp(event.createdAt);
+  return createNotificationRecord({
+    userId,
+    notificationId,
+    kind: "space_member_added",
+    createdAt,
+    updatedAt: createdAt,
+    href: `/space/${encodeURIComponent(spaceId)}`,
+    spaceId,
+    sourceUserId:
+      typeof event.addedByUserId === "string" ? event.addedByUserId : undefined,
+    payload: {
+      role: event.role,
+      spaceName:
+        typeof event.spaceName === "string" ? event.spaceName : spaceId,
+    },
+  });
+};
+
+export function useUserNotifications() {
+  const dispatch = useAppDispatch();
+  const { t } = useTranslation();
+  const { currentServer, currentToken, currentUserId } =
+    useAppSelector(selectRuntimeSnapshot);
+  const remoteServers = useAppSelector(selectRuntimeRemoteServers);
+
+  const hydrateNotifications = useCallback(async () => {
+    if (!currentUserId) {
+      dispatch(replaceNotifications([]));
+      return;
+    }
+
+    const localRecords = (await dispatch(
+      fetchUserDataThunk({
+        types: DataType.NOTIFICATION,
+        userId: currentUserId,
+      })
+    ).unwrap()) as NotificationRecord[];
+
+    const remoteResults = await Promise.all(
+      remoteServers.map((serverOrigin) =>
+        loadRemoteNotifications({ serverOrigin, token: currentToken }).catch(
+          (error) => {
+            console.warn(
+              "[notifications] failed to load remote notifications",
+              serverOrigin,
+              error
+            );
+            return { data: { data: [] as NotificationRecord[] } };
+          }
+        )
+      )
+    );
+
+    const merged = mergeAndDedupUserData(localRecords, remoteResults)
+      .filter(isNotificationRecord)
+      .sort(
+        (left, right) =>
+          normalizeNotificationTimestamp(right.updatedAt) -
+          normalizeNotificationTimestamp(left.updatedAt)
+      )
+      .slice(0, NOTIFICATION_LIMIT);
+
+    if (merged.length > 0) {
+      await dispatch(cacheMergedUserDataThunk({ records: merged })).unwrap();
+    }
+
+    dispatch(
+      replaceNotifications(
+        merged.map((record) => notificationRecordToAppNotification(record, t as any))
+      )
+    );
+  }, [currentToken, currentUserId, dispatch, remoteServers, t]);
+
+  useEffect(() => {
+    void hydrateNotifications().catch((error) => {
+      console.warn("[notifications] failed to hydrate notifications", error);
+    });
+  }, [hydrateNotifications]);
+
+  useEffect(() => {
+    if (!currentUserId || !currentServer) return;
+
+    const channel = `user-${currentUserId}`;
+    const dispose = subscribeSharedSse({
+      key: `${currentServer}:${channel}`,
+      url: `${currentServer}/api/events/${channel}`,
+      headers: currentToken ? { Authorization: `Bearer ${currentToken}` } : undefined,
+      onEvent: (event) => {
+        let notificationRecord: NotificationRecord | null = null;
+        if (isNotificationEventPayload(event)) {
+          notificationRecord = event.notification;
+        } else if (event.type === "space.member_added") {
+          notificationRecord = buildLegacySpaceMemberRecord(event);
+        }
+        if (!notificationRecord) return;
+        void (async () => {
+          await dispatch(cacheMergedUserDataThunk({ records: [notificationRecord] }))
+            .unwrap()
+            .catch((error) => {
+              console.warn(
+                "[notifications] failed to cache live notification",
+                error
+              );
+            });
+          dispatch(
+            addNotification(
+              notificationRecordToAppNotification(notificationRecord, t as any)
+            )
+          );
+        })();
+      },
+    });
+
+    return () => {
+      dispose();
+    };
+  }, [currentServer, currentToken, currentUserId, dispatch, t]);
+}

package/app/hooks.ts

@@ -0,0 +1,55 @@
+import { useState, useEffect } from "react";
+import { useAppDispatch } from "./store";
+import { read, readAndWait } from "../database/dbSlice";
+
+export function useFetchData<T>(dbKey: string | null | undefined) {
+  const dispatch = useAppDispatch();
+  const [data, setData] = useState<T | undefined>();
+  const [isLoading, setLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
+
+  useEffect(() => {
+    if (!dbKey) return;
+    let mounted = true;
+
+    const getData = async () => {
+      try {
+        setLoading(true);
+        const readAction = await dispatch(readAndWait(dbKey)).unwrap();
+        if (mounted) {
+          setData(readAction);
+        }
+      } catch (err) {
+        if (mounted) {
+          setError(err instanceof Error ? err : new Error("Unknown error"));
+        }
+      } finally {
+        if (mounted) {
+          setLoading(false);
+        }
+      }
+    };
+
+    getData();
+
+    return () => {
+      mounted = false;
+    };
+  }, [dispatch, dbKey]);
+
+  const reload = async () => {
+    if (!dbKey) return;
+    try {
+      setLoading(true);
+      const readAction = await dispatch(readAndWait(dbKey)).unwrap();
+      setData(readAction);
+      setError(null);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Unknown error"));
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  return { data, isLoading, error, reload };
+}

package/app/i18n/clientResources.ts

@@ -0,0 +1,65 @@
+import type { i18n as I18nInstance } from "i18next";
+import { Language } from "../i18n/types";
+
+const supportedLanguages = new Set<string>([
+  Language.EN,
+  Language.ZH_CN,
+  Language.ZH_HANT,
+  Language.JA,
+]);
+
+const loadedLanguages = new Set<string>();
+
+export const normalizeClientLanguage = (rawLanguage?: string) => {
+  const language = rawLanguage || Language.ZH_CN;
+  if (supportedLanguages.has(language)) return language;
+  const lower = language.toLowerCase();
+  if (lower.startsWith("zh-tw") || lower.startsWith("zh-hk") || lower.startsWith("zh-mo")) {
+    return Language.ZH_HANT;
+  }
+  if (lower.startsWith("zh")) return Language.ZH_CN;
+  if (lower.startsWith("ja")) return Language.JA;
+  return Language.EN;
+};
+
+const fetchLanguageResources = async (language: string) => {
+  const version =
+    typeof window !== "undefined"
+      ? (window as Window & { __NOLO_ASSETS__?: { timestamp?: string } }).__NOLO_ASSETS__
+          ?.timestamp
+      : "";
+  const versionQuery = version ? `?v=${encodeURIComponent(version)}` : "";
+  const response = await fetch(`/public/locales/${encodeURIComponent(language)}.json${versionQuery}`, {
+    credentials: "same-origin",
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to load ${language} locale: ${response.status}`);
+  }
+  return response.json();
+};
+
+export const loadClientLanguage = async (
+  i18n: I18nInstance,
+  rawLanguage?: string
+) => {
+  let language = normalizeClientLanguage(rawLanguage);
+
+  if (!loadedLanguages.has(language)) {
+    const resources = await fetchLanguageResources(language).catch(async (error) => {
+      if (language === Language.ZH_CN) throw error;
+      console.warn("[i18n] Falling back to zh-CN locale", error);
+      language = Language.ZH_CN;
+      return fetchLanguageResources(Language.ZH_CN);
+    });
+    for (const [namespace, bundle] of Object.entries(resources)) {
+      i18n.addResourceBundle(language, namespace, bundle, true, true);
+    }
+    loadedLanguages.add(language);
+  }
+
+  if (i18n.language !== language) {
+    await i18n.changeLanguage(language);
+  }
+
+  return language;
+};