nolo-cli 0.1.40 → 0.1.42

package/app/favorite/type.ts

@@ -0,0 +1,43 @@
+export type FavoriteTargetType = "agent" | "content" | "page" | "doc" | "file";
+
+export interface ToggleFavoriteParams {
+  targetType: FavoriteTargetType;
+  /**
+   * 当前阶段约定为完整 dbKey（例如 "agent-xxx" / "page-xxx" / "meta-xxx" / "image-xxx"）。
+   * TODO: 如果以后要支持按逻辑 AgentId 收藏，可以新增一个字段：
+   *       - targetId?: string (逻辑ID)
+   *       或者再拆出一个单独的 RPC。
+   */
+  targetKey: string;
+}
+export interface ToggleFavoriteResult {
+  targetType: FavoriteTargetType;
+  targetKey: string;
+  isFavorite: boolean;
+  /** 当前该对象被多少人收藏（按 stats 计算） */
+  favoriteCount: number;
+}
+
+export interface SetFavoriteParams extends ToggleFavoriteParams {
+  isFavorite: boolean;
+  favoritedAt?: number;
+}
+
+export type SetFavoriteResult = ToggleFavoriteResult;
+
+export interface ListFavoritesParams {
+  targetType: FavoriteTargetType | FavoriteTargetType[];
+}
+
+export interface FavoriteListItem {
+  id: string;
+  favoritedAt: number;
+}
+
+export interface ListFavoritesResult {
+  targetType: FavoriteTargetType;
+  /** 当前用户收藏的该类型对象的 key 列表 */
+  ids: string[];
+  /** 收藏时间（毫秒时间戳） */
+  items?: FavoriteListItem[];
+}

package/app/hooks/deleteDbKey.ts

@@ -0,0 +1,254 @@
+// 文件路径: app/hooks/deleteDbKey.ts
+
+import {
+    isDialogKey,
+    isPageKey,
+    isTableMetaKey,
+    isFileKey,
+    isAgentKey,
+    isAppKey,
+    isTaskKey,
+} from "../../database/keys";
+import { deleteDialog } from "../../chat/dialog/dialogSlice";
+import { deleteTable } from "../../render/table/tableSlice";
+import { deleteContentFromSpace } from "../../create/space/spaceSlice";
+import { remove } from "../../database/dbSlice";
+import { removeFavoriteLocally } from "../favorite/favoriteSlice";
+import { resolveDeletedFavoriteProjectionRemoval } from "../favorite/deletedFavoriteProjection";
+import type { AppDispatch } from "../store";
+import type { RootState } from "../store";
+
+type DeleteDbKeyInput =
+    | string
+    | {
+        contentKey?: unknown;
+        dbKey?: unknown;
+        key?: unknown;
+        serverOrigin?: unknown;
+        preferredServerOrigin?: unknown;
+        spaceId?: unknown;
+        includeAttachments?: unknown;
+    };
+
+type ResolvedDeleteInput = {
+    contentKey: string;
+    preferredServerOrigin?: string;
+    inputSpaceId?: string | null;
+    includeAttachments?: boolean;
+};
+
+const performDirectDelete = async (
+    dispatch: AppDispatch,
+    contentKey: string,
+    preferredServerOrigin?: string,
+    includeAttachments?: boolean
+): Promise<void> => {
+    if (isDialogKey(contentKey)) {
+        await (dispatch as any)(
+            deleteDialog({ dialogKey: contentKey, includeAttachments })
+        ).unwrap();
+        return;
+    }
+
+    if (isTableMetaKey(contentKey)) {
+        await (dispatch as any)(deleteTable({ dbKey: contentKey })).unwrap();
+        return;
+    }
+
+    if (
+        isAppKey(contentKey) ||
+        isPageKey(contentKey) ||
+        isFileKey(contentKey) ||
+        isAgentKey(contentKey) ||
+        isTaskKey(contentKey)
+    ) {
+        await (dispatch as any)(
+            remove({
+                dbKey: contentKey,
+                preferredServerOrigin,
+            })
+        ).unwrap();
+    }
+};
+
+const resolveDeleteInput = (input: DeleteDbKeyInput): ResolvedDeleteInput => {
+    if (typeof input === "string" && input.trim()) {
+        return { contentKey: input };
+    }
+
+    if (input && typeof input === "object") {
+        const candidates = [input.contentKey, input.dbKey, input.key];
+        const preferredCandidates = [input.preferredServerOrigin, input.serverOrigin];
+        const preferredServerOrigin = preferredCandidates.find(
+            (candidate): candidate is string =>
+                typeof candidate === "string" && candidate.trim().length > 0
+        );
+        const inputSpaceId =
+            typeof input.spaceId === "string" && input.spaceId.trim().length > 0
+                ? input.spaceId
+                : null;
+        const includeAttachments = input.includeAttachments === true;
+        for (const candidate of candidates) {
+            if (typeof candidate === "string" && candidate.trim()) {
+                return {
+                    contentKey: candidate,
+                    preferredServerOrigin,
+                    inputSpaceId,
+                    includeAttachments,
+                };
+            }
+        }
+    }
+
+    throw new Error("Invalid delete key");
+};
+
+const extractDeleteErrorMessage = (
+    error: unknown,
+    seen = new Set<object>(),
+    depth = 0
+): string | null => {
+    if (depth > 8) {
+        return null;
+    }
+
+    if (error instanceof Error && error.message.trim()) {
+        return error.message;
+    }
+
+    if (typeof error === "string" && error.trim()) {
+        return error;
+    }
+
+    if (!error || typeof error !== "object") {
+        return null;
+    }
+
+    if (seen.has(error)) {
+        return null;
+    }
+
+    seen.add(error);
+
+    const record = error as Record<string, unknown>;
+    const directKeys = ["message", "error", "detail", "title"] as const;
+    for (const key of directKeys) {
+        const value = record[key];
+        if (typeof value === "string" && value.trim()) {
+            return value;
+        }
+    }
+
+    const nestedKeys = ["payload", "data", "cause"] as const;
+    for (const key of nestedKeys) {
+        const message = extractDeleteErrorMessage(record[key], seen, depth + 1);
+        if (message) {
+            return message;
+        }
+    }
+
+    if (Array.isArray(record.errors)) {
+        const messages = record.errors
+            .map((item) => extractDeleteErrorMessage(item, seen, depth + 1))
+            .filter((item): item is string => Boolean(item));
+        if (messages.length > 0) {
+            return messages.join("\n");
+        }
+    }
+
+    try {
+        const serialized = JSON.stringify(error);
+        if (serialized && serialized !== "{}") {
+            return serialized;
+        }
+    } catch {
+        return null;
+    }
+
+    return null;
+};
+
+export const getDeleteErrorMessage = (
+    error: unknown,
+    fallback = "Delete failed"
+): string => {
+    return extractDeleteErrorMessage(error) ?? fallback;
+};
+
+const normalizeDeleteError = (error: unknown): Error => {
+    if (error instanceof Error && error.message.trim()) {
+        return error;
+    }
+
+    return new Error(getDeleteErrorMessage(error));
+};
+
+/**
+ * 根据 db key 删除对应资源，并同步移除 space 中的引用
+ */
+export const deleteDbKey =
+    (input: DeleteDbKeyInput, spaceId?: string | null) =>
+        async (dispatch: AppDispatch, getState: () => RootState): Promise<boolean> => {
+            try {
+                const {
+                    contentKey,
+                    preferredServerOrigin,
+                    inputSpaceId,
+                    includeAttachments,
+                } = resolveDeleteInput(input);
+                const effectiveSpaceId =
+                    typeof spaceId === "string" && spaceId.trim().length > 0
+                        ? spaceId
+                        : inputSpaceId ?? null;
+                console.log("[deleteDbKey] START", {
+                    contentKey,
+                    preferredServerOrigin,
+                    effectiveSpaceId,
+                    rawInput: typeof input === "string" ? input : JSON.stringify(input),
+                });
+                // 1. 始终先执行实体的直接删除（写 tombstone + 尝试服务器删除）
+                // 无论 space 操作结果如何，实体都必须被标记为已删除，
+                // 否则 deleteContentFromSpace 成功但跳过实体删除时，
+                // 远端活记录会在下一次 merge 时回流。
+                await performDirectDelete(
+                    dispatch,
+                    contentKey,
+                    preferredServerOrigin,
+                    includeAttachments
+                );
+
+                // 2. 如果有 spaceId，先完成本地 space 引用清理，再返回给 UI。
+                // 这仍然是 local-first 语义：
+                // - 实体 tombstone 已先写入
+                // - space.contents 的本地 patch 也要在导航前落稳
+                // 但不要求等待远端强一致。
+                if (effectiveSpaceId) {
+                    await (dispatch as any)(
+                        deleteContentFromSpace({
+                            contentKey,
+                            spaceId: effectiveSpaceId,
+                            ...(preferredServerOrigin
+                                ? { sourceServerOrigin: preferredServerOrigin }
+                                : {}),
+                        })
+                    ).unwrap().catch((err: unknown) => {
+                        console.warn("[deleteDbKey] space cleanup failed (entity already tombstoned):", err);
+                    });
+                }
+
+                const favoriteProjectionRemoval =
+                    resolveDeletedFavoriteProjectionRemoval(contentKey);
+                if (favoriteProjectionRemoval) {
+                    dispatch(removeFavoriteLocally(favoriteProjectionRemoval));
+                }
+
+                if (typeof window !== "undefined") {
+                    window.dispatchEvent(new Event("nolo-user-data-updated"));
+                }
+
+                // 3. 返回值：让上层可以 await
+                return true;
+            } catch (error) {
+                throw normalizeDeleteError(error);
+            }
+        };

package/app/i18n/client.ts

@@ -0,0 +1,13 @@
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import { Language } from "../i18n/types";
+import { i18nBaseConfig } from "./i18n.base";
+
+i18n.use(initReactI18next).init({
+  ...i18nBaseConfig,
+  lng: Language.ZH_CN,
+  fallbackLng: Language.ZH_CN,
+  compatibilityJSON: "v3",
+});
+
+export default i18n;

package/app/i18n/i18n.base.ts

@@ -0,0 +1,14 @@
+import { Language } from "../i18n/types";
+
+export const i18nBaseConfig = {
+  defaultNS: "common",
+  ns: ["common", "space", "ai", "chat"],
+  interpolation: { escapeValue: false },
+  fallbackLng: {
+    zh: [Language.ZH_CN, Language.EN],
+    "zh-TW": [Language.ZH_HANT],
+    "zh-HK": [Language.ZH_HANT],
+    "zh-MO": [Language.ZH_HANT],
+    default: [Language.EN],
+  },
+};

package/app/i18n/i18n.config.ts

@@ -0,0 +1,77 @@
+// src/app/i18n/i18n.config.ts
+import { Language } from "../i18n/types";
+import { i18nBaseConfig } from "./i18n.base";
+import aiLocale from "../../ai/ai.locale";
+import chatLocale from "../../chat/chat.locale";
+import spaceLocale from "../../create/space/space.locale";
+import interfaceLocale from "./translations/interface.locale";
+import errorLocale from "./translations/error.locale";
+import seoLocale from "./translations/seo.locale";
+import appBuilderLocale from "./translations/appBuilder.locale";
+import pricingLocale from "./translations/pricing.locale";
+import privacyLocale from "./translations/privacy.locale";
+import termsLocale from "./translations/terms.locale";
+
+export const resources = {
+  [Language.EN]: {
+    common: {
+      ...interfaceLocale[Language.EN].translation,
+      ...errorLocale[Language.EN].translation,
+      ...appBuilderLocale[Language.EN].translation,
+      ...pricingLocale[Language.EN].translation,
+      ...privacyLocale[Language.EN].translation,
+      ...termsLocale[Language.EN].translation,
+      seo: seoLocale[Language.EN],
+    },
+    space: spaceLocale[Language.EN].translation,
+    ai: aiLocale[Language.EN].translation,
+    chat: chatLocale[Language.EN].translation,
+  },
+  [Language.ZH_CN]: {
+    common: {
+      ...interfaceLocale[Language.ZH_CN].translation,
+      ...errorLocale[Language.ZH_CN].translation,
+      ...appBuilderLocale[Language.ZH_CN].translation,
+      ...pricingLocale[Language.ZH_CN].translation,
+      ...privacyLocale[Language.ZH_CN].translation,
+      ...termsLocale[Language.ZH_CN].translation,
+      seo: seoLocale[Language.ZH_CN],
+    },
+    space: spaceLocale[Language.ZH_CN].translation,
+    ai: aiLocale[Language.ZH_CN].translation,
+    chat: chatLocale[Language.ZH_CN].translation,
+  },
+  [Language.ZH_HANT]: {
+    common: {
+      ...interfaceLocale[Language.ZH_HANT].translation,
+      ...errorLocale[Language.ZH_HANT].translation,
+      ...appBuilderLocale[Language.ZH_HANT].translation,
+      ...pricingLocale[Language.ZH_HANT].translation,
+      ...privacyLocale[Language.ZH_HANT].translation,
+      ...termsLocale[Language.ZH_HANT].translation,
+      seo: seoLocale[Language.ZH_HANT],
+    },
+    space: spaceLocale[Language.ZH_HANT].translation,
+    ai: aiLocale[Language.ZH_HANT].translation,
+    chat: chatLocale[Language.ZH_HANT].translation,
+  },
+  [Language.JA]: {
+    common: {
+      ...interfaceLocale[Language.JA].translation,
+      ...errorLocale[Language.JA].translation,
+      ...appBuilderLocale[Language.JA].translation,
+      ...pricingLocale[Language.JA].translation,
+      ...privacyLocale[Language.JA].translation,
+      ...termsLocale[Language.JA].translation,
+      seo: seoLocale[Language.JA],
+    },
+    space: spaceLocale[Language.JA].translation,
+    ai: aiLocale[Language.JA].translation,
+    chat: chatLocale[Language.JA].translation,
+  },
+};
+
+export const i18nConfig = {
+  ...i18nBaseConfig,
+  resources,
+};

package/app/i18n/index.ts

@@ -0,0 +1,15 @@
+// app/i18n/index.ts
+
+import i18n from "i18next";
+import { initReactI18next } from "react-i18next";
+import { Language } from "../i18n/types";
+import { i18nConfig } from "./i18n.config";
+
+i18n.use(initReactI18next).init({
+  ...i18nConfig,
+  lng: Language.ZH_CN, // 💡 强制设置为中文 (简体)
+  fallbackLng: Language.ZH_CN, // 💡 失败回退也设为中文
+  compatibilityJSON: 'v3', // Fixes "Intl not found" error on Android/RN
+});
+
+export default i18n;

package/app/i18n/mapLanguage.ts

@@ -0,0 +1,11 @@
+export const languageMap = {
+  "en-US": "English",
+  "zh-CN": "Simplified Chinese",
+  "zh-TW": "Traditional Chinese",
+  "ja-JP": "Japanese",
+  // Add more mappings as needed
+};
+
+export const mapLanguage = (responseLanguage: string) => {
+  return languageMap[responseLanguage] || responseLanguage;
+};