nolo-cli 0.1.26 → 0.1.29

package/app/hooks/deleteDbKey.ts

@@ -0,0 +1,233 @@
+// 文件路径: 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 type { AppDispatch } from "../store";
+import type { RootState } from "../store";
+
+type DeleteDbKeyInput =
+    | string
+    | {
+        contentKey?: unknown;
+        dbKey?: unknown;
+        key?: unknown;
+        serverOrigin?: unknown;
+        preferredServerOrigin?: unknown;
+        spaceId?: unknown;
+    };
+
+type ResolvedDeleteInput = {
+    contentKey: string;
+    preferredServerOrigin?: string;
+    inputSpaceId?: string | null;
+};
+
+const performDirectDelete = async (
+    dispatch: AppDispatch,
+    contentKey: string,
+    preferredServerOrigin?: string
+): Promise<void> => {
+    if (isDialogKey(contentKey)) {
+        await (dispatch as any)(deleteDialog(contentKey)).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;
+        for (const candidate of candidates) {
+            if (typeof candidate === "string" && candidate.trim()) {
+                return {
+                    contentKey: candidate,
+                    preferredServerOrigin,
+                    inputSpaceId,
+                };
+            }
+        }
+    }
+
+    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,
+                } = 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);
+
+                // 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);
+                    });
+                }
+
+                if (typeof window !== "undefined") {
+                    window.dispatchEvent(new Event("nolo-user-data-updated"));
+                }
+
+                // 3. 返回值：让上层可以 await
+                return true;
+            } catch (error) {
+                throw normalizeDeleteError(error);
+            }
+        };

package/app/hooks/index.ts

@@ -0,0 +1,4 @@
+import type { AppDispatch } from "../store";
+import { useDispatch } from "react-redux";
+
+export const useAppDispatch: () => AppDispatch = useDispatch;

package/app/hooks/useAppDetail.ts

@@ -0,0 +1,208 @@
+import { useCallback, useEffect, useState } from "react";
+import { useAppDispatch, useAppSelector } from "../store";
+import { selectCurrentToken, selectUserId } from "../../auth/authSlice";
+import { selectRemoteServer } from "../settings/settingSlice";
+import type { AppVisibility } from "../types/appSummary";
+import { syncAppRecord } from "../actions/syncAppRecord";
+import { syncRecentAppVersions } from "../../create/version/appVersionReplication";
+
+export interface AppSourceFile {
+  name: string;
+  code: string;
+}
+
+export interface AppDetail {
+  success: boolean;
+  appId: string;
+  appKey?: string;
+  serverOrigin?: string;
+  versionServerOrigin?: string;
+  userFriendlyName: string;
+  url: string;
+  customUrl?: string;
+  code: string;
+  files?: AppSourceFile[];
+  framework?: "worker" | "react-spa";
+  externalImports?: string[];
+  sourceStatus?: "ready" | "missing" | "artifact-only";
+  editSafety?: "safe" | "rebuild-risk";
+  prepared?: boolean;
+  spaceId?: string | null;
+  visibility?: AppVisibility;
+  modifiedOn?: string;
+  createdAt?: string;
+  appRecord?: Record<string, any>;
+}
+
+interface UseAppDetailOptions {
+  prepareEdit?: boolean;
+  serverOrigin?: string | null;
+}
+
+const normalizeCustomUrl = (customUrl?: string | null, url?: string | null) => {
+  const normalizedCustomUrl = typeof customUrl === "string" ? customUrl.trim() : "";
+  const normalizedUrl = typeof url === "string" ? url.trim() : "";
+  if (!normalizedCustomUrl) return undefined;
+  return normalizedCustomUrl === normalizedUrl ? undefined : normalizedCustomUrl;
+};
+
+const inferFallbackAppRecord = (
+  detail: AppDetail,
+  currentUserId?: string | null
+): Record<string, any> | null => {
+  if (!currentUserId || !detail.appId || !detail.appKey) return null;
+  if (!detail.appKey.startsWith(`app-${currentUserId}-`)) return null;
+
+  const files = Array.isArray(detail.files) ? detail.files : undefined;
+  const source =
+    detail.framework === "react-spa" && files && files.length > 0
+      ? {
+          kind: "react-spa",
+          files,
+          entryFile: files.find((file) => file.name === "main.tsx")?.name ?? files[0]?.name ?? "main.tsx",
+          externalImports: Array.isArray(detail.externalImports) ? detail.externalImports : [],
+        }
+      : files && files.length > 0
+        ? {
+            kind: "worker-files",
+            files,
+          }
+        : {
+            kind: "worker-code",
+            code: detail.code ?? "",
+          };
+
+  return {
+    appId: detail.appId,
+    appKey: detail.appKey,
+    userId: currentUserId,
+    name: detail.userFriendlyName,
+    code: detail.code ?? "",
+    framework: detail.framework ?? "worker",
+    source,
+    customUrl: normalizeCustomUrl(detail.customUrl, detail.url),
+    visibility: detail.visibility ?? "private",
+    spaceId: detail.spaceId ?? undefined,
+    versionServerOrigin: detail.versionServerOrigin ?? detail.serverOrigin,
+    updatedAt: detail.modifiedOn ? Date.parse(detail.modifiedOn) || Date.now() : Date.now(),
+    createdAt: detail.createdAt ? Date.parse(detail.createdAt) || undefined : undefined,
+  };
+};
+
+const resolveSyncRecord = (
+  detail: AppDetail,
+  currentUserId?: string | null
+): Record<string, any> | null => {
+  if (
+    detail.appRecord &&
+    typeof detail.appRecord === "object" &&
+    detail.appRecord.userId === currentUserId
+  ) {
+    return detail.appRecord;
+  }
+  return inferFallbackAppRecord(detail, currentUserId);
+};
+
+export function useAppDetail(appKey?: string, options: UseAppDetailOptions = {}) {
+  const dispatch = useAppDispatch();
+  const token = useAppSelector(selectCurrentToken);
+  const currentUserId = useAppSelector(selectUserId);
+  const server = useAppSelector(selectRemoteServer);
+  const [app, setApp] = useState<AppDetail | null>(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchApp = useCallback(async () => {
+    if (!appKey || !token) {
+      setApp(null);
+      setError(null);
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const requestPath = options.prepareEdit ? "/api/app/prepare-edit" : "/api/app/get";
+      const candidateServers = [
+        server?.trim(),
+        options.serverOrigin?.trim(),
+      ].filter((value, index, list): value is string =>
+        typeof value === "string" && value.length > 0 && list.indexOf(value) === index
+      );
+
+      let lastError: Error | null = null;
+      let fallbackApp: AppDetail | null = null;
+      for (let index = 0; index < candidateServers.length; index += 1) {
+        const targetServer = candidateServers[index];
+        const res = await fetch(`${targetServer}${requestPath}`, {
+          method: "POST",
+          headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+          },
+          body: JSON.stringify({ appKey }),
+        });
+
+        const json = await res.json().catch(() => null);
+        if (res.ok && json?.success) {
+          const detail = json as AppDetail;
+          const shouldTryFallbackForEditableSource =
+            options.prepareEdit === true &&
+            detail.editSafety !== "safe" &&
+            index < candidateServers.length - 1;
+          if (shouldTryFallbackForEditableSource) {
+            fallbackApp = detail;
+            continue;
+          }
+          const syncRecord = index > 0 ? resolveSyncRecord(json as AppDetail, currentUserId) : null;
+          if (index > 0 && json?.appKey && syncRecord) {
+            try {
+              await dispatch(
+                syncAppRecord(json.appKey, syncRecord, {
+                  includeCurrentServer: true,
+                })
+              );
+              if (detail.appId && detail.versionServerOrigin) {
+                void syncRecentAppVersions({
+                  currentServer: server,
+                  sourceServer: detail.versionServerOrigin,
+                  token,
+                  appId: detail.appId,
+                });
+              }
+            } catch {
+              // Keep remote detail usable even if current-server self-heal fails.
+            }
+          }
+          setApp(detail);
+          return;
+        }
+
+        lastError = new Error(json?.message ?? `加载应用失败 (${res.status})`);
+        const isNotFound =
+          res.status === 404 || json?.code === "NOT_FOUND";
+        const hasFallback = index < candidateServers.length - 1;
+        if (isNotFound && hasFallback) {
+          continue;
+        }
+        throw lastError;
+      }
+      if (fallbackApp) {
+        setApp(fallbackApp);
+        return;
+      }
+      throw lastError ?? new Error("加载应用失败");
+    } catch (err: any) {
+      setError(err?.message ?? "加载应用失败");
+    } finally {
+      setLoading(false);
+    }
+  }, [appKey, currentUserId, dispatch, options.prepareEdit, options.serverOrigin, server, token]);
+
+  useEffect(() => {
+    void fetchApp();
+  }, [fetchApp]);
+
+  return { app, loading, error, refetch: fetchApp };
+}

package/app/hooks/useAppVersions.ts

@@ -0,0 +1,52 @@
+import { useCallback, useEffect, useState } from "react";
+import { useAppSelector } from "../store";
+import { selectRemoteServer } from "../settings/settingSlice";
+import { selectCurrentToken } from "../../auth/authSlice";
+import { fetchAppVersionsCurrentServerFirst } from "../../create/version/appVersionReplication";
+
+export interface AppVersionEntry {
+  versionId: string;
+  entityId: string;
+  type: "app";
+  snapshot: any;
+  label?: string;
+  pinned?: boolean;
+  createdAt: string;
+}
+
+export function useAppVersions(appId?: string, sourceServerOrigin?: string | null) {
+  const server = useAppSelector(selectRemoteServer);
+  const token = useAppSelector(selectCurrentToken);
+  const [versions, setVersions] = useState<AppVersionEntry[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchVersions = useCallback(async () => {
+    if (!appId || !token) {
+      setVersions([]);
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+    try {
+      const data = await fetchAppVersionsCurrentServerFirst({
+        currentServer: server,
+        sourceServer: sourceServerOrigin,
+        token,
+        appId,
+      });
+      setVersions(Array.isArray(data) ? (data as AppVersionEntry[]) : []);
+    } catch (err: any) {
+      setError(err?.message ?? "加载版本失败");
+    } finally {
+      setLoading(false);
+    }
+  }, [appId, server, sourceServerOrigin, token]);
+
+  useEffect(() => {
+    void fetchVersions();
+  }, [fetchVersions]);
+
+  return { versions, loading, error, refetch: fetchVersions };
+}

package/app/hooks/useAutoResizeTextarea.ts

@@ -0,0 +1,29 @@
+// 文件路径: app/hooks/useAutoResizeTextarea.ts
+import { useCallback } from "react";
+
+interface UseAutoResizeTextareaParams {
+    maxHeight: number;
+    onTextChange: (value: string) => void;
+}
+
+export function useAutoResizeTextarea({
+    maxHeight,
+    onTextChange,
+}: UseAutoResizeTextareaParams) {
+    const handleChange: React.ChangeEventHandler<HTMLTextAreaElement> =
+        useCallback(
+            (event) => {
+                const value = event.target.value;
+                onTextChange(value);
+
+                event.target.style.height = "auto";
+                event.target.style.height = `${Math.min(
+                    event.target.scrollHeight,
+                    maxHeight
+                )}px`;
+            },
+            [maxHeight, onTextChange]
+        );
+
+    return { handleChange };
+}

package/app/hooks/useChatPageTitle.ts

@@ -0,0 +1,85 @@
+// 文件路径: app/hooks/useChatPageTitle.ts
+
+import { useEffect, useRef } from "react";
+import { useSelector } from "react-redux";
+import type { RootState } from "../store";
+import type { Message } from "../../chat/messages/types";
+import {
+    selectHasStreamingMessage,
+    selectLastAssistantMessage,
+} from "../../chat/messages/messageSlice";
+
+const BASE_TITLE = "Cybot";
+
+/**
+ * 从 Message.content 中提取纯文本，用于标题预览
+ */
+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 buildPreview = (msg?: Message, maxLen = 20): string => {
+    if (!msg) return "";
+    const text = extractTextFromContent(msg.content);
+    if (!text) return "";
+    if (text.length <= maxLen) return text;
+    return `${text.slice(0, maxLen)}…`;
+};
+
+/**
+ * 根据消息 streaming 状态和最新回复更新 document.title
+ */
+export const useChatPageTitle = () => {
+    const hasStreaming = useSelector((state: RootState) =>
+        selectHasStreamingMessage(state)
+    );
+    const lastAssistant = useSelector((state: RootState) =>
+        selectLastAssistantMessage(state)
+    );
+
+    // 记录进入页面时的原始标题
+    const originTitleRef = useRef<string | null>(null);
+
+    useEffect(() => {
+        if (typeof document === "undefined") return;
+        if (originTitleRef.current == null) {
+            originTitleRef.current = document.title || BASE_TITLE;
+        }
+    }, []);
+
+    useEffect(() => {
+        if (typeof document === "undefined") return;
+
+        const origin = originTitleRef.current || BASE_TITLE;
+
+        if (hasStreaming) {
+            // 流式生成中
+            document.title = `生成中… · ${origin}`;
+            return;
+        }
+
+        // 已结束，展示最后一条 assistant 回复的预览
+        const preview = buildPreview(lastAssistant);
+        if (preview) {
+            document.title = `${preview} · ${origin}`;
+        } else {
+            document.title = origin;
+        }
+    }, [hasStreaming, lastAssistant]);
+};

package/app/hooks/useClipboardFiles.ts

@@ -0,0 +1,20 @@
+// 文件路径: packages/chat/hooks/useClipboardFiles.ts
+
+import { useCallback } from "react";
+import type { ClipboardEvent, ClipboardEventHandler } from "react";
+
+export function useClipboardFiles<T extends HTMLElement = HTMLElement>(
+    onFiles: (files: FileList) => void
+) {
+    const handlePaste: ClipboardEventHandler<T> = useCallback(
+        (event: ClipboardEvent<T>) => {
+            const files = event.clipboardData?.files;
+            if (files && files.length > 0) {
+                onFiles(files);
+            }
+        },
+        [onFiles]
+    );
+
+    return { handlePaste };
+}

package/app/hooks/useDesktopLocalConnectorAutostart.ts

@@ -0,0 +1,38 @@
+import { useEffect } from "react";
+import { selectCurrentToken } from "../../auth/authSlice";
+import { selectCurrentServer } from "../settings/settingSlice";
+import { useAppSelector } from "../store";
+import { getIsDesktopApp } from "../utils/env";
+import {
+  startDesktopLocalConnectorFromSession,
+  type DesktopLocalConnectorStartResult,
+} from "../utils/desktopLocalConnectorClient";
+
+type UseDesktopLocalConnectorAutostartOptions = {
+  onResult?: (result: DesktopLocalConnectorStartResult) => void;
+};
+
+export function useDesktopLocalConnectorAutostart(
+  options: UseDesktopLocalConnectorAutostartOptions = {}
+) {
+  const onResult = options.onResult;
+  const currentToken = useAppSelector(selectCurrentToken);
+  const currentServer = useAppSelector(selectCurrentServer);
+  const serverBase =
+    currentServer?.trim().replace(/\/+$/, "") ||
+    (typeof window !== "undefined" ? window.location.origin : "");
+
+  useEffect(() => {
+    if (!getIsDesktopApp() || !currentToken || !serverBase) return;
+    let cancelled = false;
+    void startDesktopLocalConnectorFromSession({
+      serverUrl: serverBase,
+      authToken: currentToken,
+    }).then((result) => {
+      if (!cancelled) onResult?.(result);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [currentToken, onResult, serverBase]);
+}