nolo-cli 0.1.23 → 0.1.29

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/favorite/useAgentFavorite.ts

@@ -0,0 +1,43 @@
+// 文件路径: app/favorite/useAgentFavorite.ts
+
+import { useCallback } from "react";
+import type React from "react";
+import { useTranslation } from "react-i18next";
+import toast from "react-hot-toast";
+
+import { useAppDispatch, useAppSelector } from "../store";
+import {
+  selectIsAgentFavorited,
+  toggleFavorite,
+} from "../favorite/favoriteSlice";
+
+export function useAgentFavorite(agentKey: string) {
+  const { t } = useTranslation("ai");
+  const dispatch = useAppDispatch();
+
+  const isFavorited = useAppSelector((state) =>
+    selectIsAgentFavorited(state, agentKey)
+  );
+
+  const handleToggleFavorite = useCallback(
+    async (e?: React.MouseEvent) => {
+      if (e) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+      try {
+        await dispatch(toggleFavorite(agentKey)).unwrap();
+      } catch (err) {
+        console.error(err);
+        toast.error(
+          t("toggleFavoriteError", {
+            defaultValue: "操作失败，请稍后重试",
+          })
+        );
+      }
+    },
+    [agentKey, dispatch, t]
+  );
+
+  return { isFavorited, toggleFavorite: handleToggleFavorite };
+}

package/app/favorite/useContentFavorite.ts

@@ -0,0 +1,41 @@
+import { useCallback } from "react";
+import type React from "react";
+import { useTranslation } from "react-i18next";
+import toast from "react-hot-toast";
+
+import { useAppDispatch, useAppSelector } from "../store";
+import {
+  selectIsContentFavorited,
+  toggleContentFavorite,
+} from "../favorite/favoriteSlice";
+
+export function useContentFavorite(contentKey: string) {
+  const { t } = useTranslation("ai");
+  const dispatch = useAppDispatch();
+
+  const isFavorited = useAppSelector((state) =>
+    selectIsContentFavorited(state, contentKey)
+  );
+
+  const handleToggleFavorite = useCallback(
+    async (e?: React.MouseEvent) => {
+      if (e) {
+        e.preventDefault();
+        e.stopPropagation();
+      }
+      try {
+        await dispatch(toggleContentFavorite(contentKey)).unwrap();
+      } catch (err) {
+        console.error(err);
+        toast.error(
+          t("toggleFavoriteError", {
+            defaultValue: "操作失败，请稍后重试",
+          })
+        );
+      }
+    },
+    [contentKey, dispatch, t]
+  );
+
+  return { isFavorited, toggleFavorite: handleToggleFavorite };
+}

package/app/fetchOwnedApps.ts

@@ -0,0 +1,269 @@
+import { createAsyncThunk } from "@reduxjs/toolkit";
+import type { AppThunkApi } from ".//store";
+import { DataType } from "../create/types";
+import { fetchUserData } from "../database/client/fetchUserData";
+import { noloQueryRequest } from "../database/client/queryRequest";
+import { isTombstoneRecord, shouldReplaceWithNextRecord } from "../database/tombstones";
+import {
+  deriveAppIdFromRouteKey,
+  isAppRouteKey,
+  resolveAppRouteKey,
+} from ".//utils/appKeys";
+import { toAppSummary, type AppSummary } from ".//types/appSummary";
+import { syncAppRecord } from "./actions/syncAppRecord";
+
+export type CachedOwnedAppRecord = {
+  dbKey: string;
+  type: DataType.APP;
+  userId: string;
+  appId?: string;
+  appKey?: string;
+  name: string;
+  customUrl?: string | null;
+  visibility?: "private" | "unlisted" | "public";
+  deployMode?: "platform";
+  spaceId?: string | null;
+  updatedAt?: string | number;
+  createdAt?: string | number;
+  serverOrigin?: string;
+  code?: string;
+  source?: unknown;
+  framework?: "worker" | "react-spa";
+};
+
+const toTimestamp = (value: unknown): number => {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string") {
+    const parsed = Date.parse(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+};
+
+const normalizeCachedRecord = (
+  value: Partial<CachedOwnedAppRecord> | null | undefined,
+  userId: string,
+  fallbackServerOrigin?: string
+): CachedOwnedAppRecord | null => {
+  if (!value || typeof value !== "object") return null;
+  const recordDbKey =
+    typeof value.dbKey === "string" && value.dbKey.trim().length > 0
+      ? value.dbKey
+      : undefined;
+  const explicitAppId =
+    typeof value.appId === "string" && value.appId.trim().length > 0
+      ? value.appId
+      : undefined;
+  const appKey = resolveAppRouteKey(
+    typeof value.appKey === "string"
+      ? value.appKey
+      : isAppRouteKey(recordDbKey)
+        ? recordDbKey
+        : undefined,
+    explicitAppId
+  );
+  if (!appKey) return null;
+  const appId =
+    explicitAppId ??
+    deriveAppIdFromRouteKey(
+      appKey,
+      typeof value.userId === "string" && value.userId.trim().length > 0
+        ? value.userId
+        : userId
+    );
+  const name =
+    typeof value.name === "string" && value.name.trim().length > 0
+      ? value.name
+      : appId ?? appKey;
+  return {
+    ...value,
+    dbKey: appKey,
+    type: DataType.APP,
+    userId,
+    appId,
+    appKey,
+    name,
+    customUrl:
+      typeof value.customUrl === "string" && value.customUrl.trim().length > 0
+        ? value.customUrl
+        : undefined,
+    visibility: value.visibility ?? "private",
+    deployMode: value.deployMode ?? "platform",
+    spaceId:
+      typeof value.spaceId === "string" && value.spaceId.trim().length > 0
+        ? value.spaceId
+        : null,
+    updatedAt: value.updatedAt ?? value.createdAt ?? 0,
+    createdAt: value.createdAt ?? value.updatedAt ?? 0,
+    serverOrigin:
+      typeof value.serverOrigin === "string" && value.serverOrigin.trim().length > 0
+        ? value.serverOrigin
+        : fallbackServerOrigin,
+  };
+};
+
+const buildCacheRecordFromRemote = (
+  value: Partial<CachedOwnedAppRecord>,
+  userId: string,
+  serverOrigin: string
+): CachedOwnedAppRecord | null => {
+  return normalizeCachedRecord(
+    {
+      ...value,
+      serverOrigin,
+    },
+    userId,
+    serverOrigin
+  );
+};
+
+const mergeOwnedAppRecords = (
+  localRecords: CachedOwnedAppRecord[],
+  remoteRecords: CachedOwnedAppRecord[],
+  fetchedServers: Set<string>
+): { mergedRecords: CachedOwnedAppRecord[]; cacheWrites: CachedOwnedAppRecord[] } => {
+  const mergedByKey = new Map<string, CachedOwnedAppRecord>();
+  const localByKey = new Map<string, CachedOwnedAppRecord>();
+  const remoteKeysByServer = new Map<string, Set<string>>();
+
+  for (const record of localRecords) {
+    mergedByKey.set(record.dbKey, record);
+    localByKey.set(record.dbKey, record);
+  }
+
+  for (const remoteRecord of remoteRecords) {
+    const remoteServer = remoteRecord.serverOrigin?.trim();
+    if (remoteServer) {
+      const keys = remoteKeysByServer.get(remoteServer) ?? new Set<string>();
+      keys.add(remoteRecord.dbKey);
+      remoteKeysByServer.set(remoteServer, keys);
+    }
+    const existing = mergedByKey.get(remoteRecord.dbKey);
+    if (!existing || shouldReplaceWithNextRecord(remoteRecord, existing)) {
+      mergedByKey.set(remoteRecord.dbKey, {
+        ...existing,
+        ...remoteRecord,
+      });
+    }
+  }
+
+  for (const localRecord of localRecords) {
+    const localServer = localRecord.serverOrigin?.trim();
+    if (!localServer || !fetchedServers.has(localServer)) continue;
+    const remoteKeys = remoteKeysByServer.get(localServer) ?? new Set<string>();
+    if (!remoteKeys.has(localRecord.dbKey)) {
+      mergedByKey.delete(localRecord.dbKey);
+    }
+  }
+
+  const mergedRecords = [...mergedByKey.values()]
+    .filter((record) => !isTombstoneRecord(record))
+    .sort((left, right) => toTimestamp(right.updatedAt) - toTimestamp(left.updatedAt));
+
+  const cacheWrites = mergedRecords.filter((record) => {
+    const localRecord = localByKey.get(record.dbKey);
+    return !localRecord || toTimestamp(record.updatedAt) > toTimestamp(localRecord.updatedAt);
+  });
+
+  return { mergedRecords, cacheWrites };
+};
+
+const buildAppUrl = (serverOrigin: string | undefined, appId?: string): string | null => {
+  if (!serverOrigin || !appId) return null;
+  return `${serverOrigin.replace(/\/+$/, "")}/apps/${appId}/`;
+};
+
+export const toOwnedAppSummary = (
+  record: CachedOwnedAppRecord,
+  fallbackServerOrigin: string
+): AppSummary => {
+  const summary = toAppSummary(record, fallbackServerOrigin);
+  if (!summary) {
+    throw new Error(`Invalid app summary record: ${record.dbKey}`);
+  }
+  return summary;
+};
+
+const fetchRemoteOwnedApps = async (
+  serverOrigin: string,
+  userId: string,
+  limit?: number
+): Promise<{ records: CachedOwnedAppRecord[]; fetched: boolean }> => {
+  try {
+    const response = await noloQueryRequest({
+      server: serverOrigin,
+      queryUserId: userId,
+      options: {
+        limit,
+        condition: { type: DataType.APP },
+      },
+    });
+    if (!response.ok) return { records: [], fetched: false };
+    const json = await response.json().catch(() => ({ data: { data: [] } }));
+    const items = Array.isArray(json?.data?.data) ? json.data.data : [];
+    return {
+      records: items
+        .map((record) => buildCacheRecordFromRemote(record, userId, serverOrigin))
+        .filter((record): record is CachedOwnedAppRecord => !!record),
+      fetched: true,
+    };
+  } catch {
+    return { records: [], fetched: false };
+  }
+};
+
+export const fetchOwnedApps = createAsyncThunk<
+  AppSummary[],
+  { userId: string; server: string; servers: string[]; limit?: number },
+  AppThunkApi
+>("app/fetchOwnedApps", async ({ userId, server, servers, limit }, { dispatch, extra }) => {
+  const db = extra.db;
+  const localRecordsRaw = db
+    ? await fetchUserData(db, DataType.APP, userId, { includeDeleted: true }).catch(() => [])
+    : [];
+  const localRecords = (Array.isArray(localRecordsRaw) ? localRecordsRaw : [])
+    .map((record) => normalizeCachedRecord(record, userId, server))
+    .filter((record): record is CachedOwnedAppRecord => !!record);
+
+  const remoteResults = await Promise.all(
+    (Array.isArray(servers) && servers.length > 0 ? servers : [server]).map((serverOrigin) =>
+      fetchRemoteOwnedApps(serverOrigin, userId, limit)
+    )
+  );
+  const remoteRecords = remoteResults.flatMap((result) => result.records);
+  const fetchedServers = new Set(
+    remoteResults
+      .map((result, index) =>
+        result.fetched ? (Array.isArray(servers) && servers.length > 0 ? servers : [server])[index] : null
+      )
+      .filter((serverOrigin): serverOrigin is string => !!serverOrigin)
+  );
+  const { mergedRecords, cacheWrites } = mergeOwnedAppRecords(
+    localRecords,
+    remoteRecords,
+    fetchedServers
+  );
+
+  if (db) {
+    await Promise.all(
+      cacheWrites.map((record) =>
+        db.put(record.dbKey, {
+          ...record,
+          dbKey: record.dbKey,
+          type: DataType.APP,
+        })
+      )
+    ).catch(() => undefined);
+  }
+
+  const normalizedCurrentServer = server.trim().replace(/\/+$/, "");
+  for (const record of cacheWrites) {
+    const recordOrigin = record.serverOrigin?.trim().replace(/\/+$/, "");
+    if (!recordOrigin || recordOrigin === normalizedCurrentServer) continue;
+    if (record.userId !== userId) continue;
+    if (typeof record.code !== "string" || !record.code.trim()) continue;
+    void dispatch(syncAppRecord(record.dbKey, record, { includeCurrentServer: true }));
+  }
+
+  return mergedRecords.map((record) => toOwnedAppSummary(record, server));
+});

package/app/guide/quickStartGuide.ts

@@ -0,0 +1,128 @@
+import { DataType } from "../../create/types";
+
+export const QUICK_START_GUIDE_DB_KEY = "builtin-guide-quick-start";
+
+export type QuickStartGuideTranslate = (
+  key: string,
+  fallback: string
+) => string;
+
+export type QuickStartGuideSection = {
+  title: string;
+  items: string[];
+};
+
+export type QuickStartGuideContent = {
+  title: string;
+  description: string;
+  sections: QuickStartGuideSection[];
+};
+
+const createText = (text: string) => ({ text });
+
+const createParagraph = (text: string) => ({
+  type: "paragraph",
+  children: [createText(text)],
+});
+
+const createHeading = (text: string) => ({
+  type: "heading-two",
+  children: [createText(text)],
+});
+
+const createBulletedList = (items: string[]) => ({
+  type: "bulleted-list",
+  children: items.map((item) => ({
+    type: "list-item",
+    children: [createParagraph(item)],
+  })),
+});
+
+export const buildQuickStartGuideContent = (
+  t: QuickStartGuideTranslate
+): QuickStartGuideContent => ({
+  title: t("quickStartGuide.title", "Quick Start Guide"),
+  description: t(
+    "quickStartGuide.description",
+    "Use these three checks to get oriented quickly when you open nolo."
+  ),
+  sections: [
+    {
+      title: t("quickStartGuide.setupTitle", "1. Confirm your current environment"),
+      items: [
+        t(
+          "quickStartGuide.setupItem1",
+          "The login target is always the current server and language shown on the auth screen."
+        ),
+        t(
+          "quickStartGuide.setupItem2",
+          "If an account was created on another server or locale, switch first before signing in."
+        ),
+        t(
+          "quickStartGuide.setupItem3",
+          "For RN smoke checks, verify the environment before testing content fetches or chat writes."
+        ),
+      ],
+    },
+    {
+      title: t("quickStartGuide.shortcutsTitle", "2. Start from the three fastest entry points"),
+      items: [
+        t(
+          "quickStartGuide.shortcutsItem1",
+          "Quick Note captures an idea immediately and saves it as a page."
+        ),
+        t(
+          "quickStartGuide.shortcutsItem2",
+          "New Chat creates a fresh dialog with the default assistant."
+        ),
+        t(
+          "quickStartGuide.shortcutsItem3",
+          "Create AI is the fastest way to customize a dedicated assistant."
+        ),
+      ],
+    },
+    {
+      title: t("quickStartGuide.nextStepsTitle", "3. When something looks off"),
+      items: [
+        t(
+          "quickStartGuide.nextStepsItem1",
+          "If login fails, re-check that the server and locale match the original registration."
+        ),
+        t(
+          "quickStartGuide.nextStepsItem2",
+          "If recent content looks stale, give sync a moment and then reopen the target page."
+        ),
+        t(
+          "quickStartGuide.nextStepsItem3",
+          "Use Feedback to report missing data or confusing behavior directly from the home screen."
+        ),
+      ],
+    },
+  ],
+});
+
+export const buildQuickStartGuideDoc = (t: QuickStartGuideTranslate) => {
+  const guide = buildQuickStartGuideContent(t);
+  const slateData = [
+    createParagraph(guide.description),
+    ...guide.sections.flatMap((section) => [
+      createHeading(section.title),
+      createBulletedList(section.items),
+    ]),
+  ];
+
+  return {
+    id: QUICK_START_GUIDE_DB_KEY,
+    dbKey: QUICK_START_GUIDE_DB_KEY,
+    type: DataType.DOC,
+    title: guide.title,
+    content: [
+      guide.description,
+      ...guide.sections.flatMap((section) => [
+        section.title,
+        ...section.items.map((item) => `- ${item}`),
+      ]),
+    ].join("\n\n"),
+    slateData,
+  };
+};