@tablestore/tablestore-agent-cli 0.2.10 → 0.2.11

package/dist/dashboard-runtime/dashboard/src/hooks/use-chat-history.ts

@@ -3,6 +3,10 @@
 import { useCallback, useMemo, useSyncExternalStore } from "react";
 
 import { newId } from "@/lib/random-id";
+import {
+  normalizeMemoryRunId,
+  type StorageMode,
+} from "@/lib/memory-storage-mode";
 import type { ChatMessage } from "@/types/llm-chat";
 
 /** Legacy global key kept for read-only migration. */
@@ -70,6 +74,7 @@ export interface ChatSessionMemoryScope {
 export interface ChatSessionMemoryBinding {
   id: string;
   memoryStoreName: string;
+  storageMode?: StorageMode;
   scope: ChatSessionMemoryScope;
   topK?: number;
   autoSave: boolean;
@@ -138,6 +143,32 @@ function belongsToScope(
   );
 }
 
+function sanitizeSessionMessages(messages: unknown[]): ChatMessage[] {
+  return messages.flatMap((message) => {
+    if (!message || typeof message !== "object") return [];
+    const candidate = message as ChatMessage;
+    if (candidate.memorySaveStatus !== "saving") return [candidate];
+    const sanitized = { ...candidate };
+    delete sanitized.memorySaveStatus;
+    delete sanitized.memorySavePath;
+    delete sanitized.memorySaveCount;
+    delete sanitized.memorySaveError;
+    return [sanitized];
+  });
+}
+
+const FNV64_OFFSET_BASIS = BigInt("14695981039346656037");
+const FNV64_PRIME = BigInt("1099511628211");
+
+function createLegacyRunId(seed: string): string {
+  let hash = FNV64_OFFSET_BASIS;
+  for (const byte of new TextEncoder().encode(seed)) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV64_PRIME);
+  }
+  return `run_legacy_${hash.toString(16).padStart(16, "0")}`;
+}
+
 function sanitizeSessions(parsed: unknown): ChatSession[] {
   if (!Array.isArray(parsed)) return [];
   const sessions = parsed.filter(
@@ -150,6 +181,7 @@ function sanitizeSessions(parsed: unknown): ChatSession[] {
   return sessions.map((s) => ({
     ...s,
     activeInstance: normalizeActiveInstance(s.activeInstance),
+    messages: sanitizeSessionMessages(s.messages),
     config: {
       ...s.config,
       mounts: (s.config?.mounts ?? []).map((m) => ({
@@ -159,13 +191,14 @@ function sanitizeSessions(parsed: unknown): ChatSession[] {
         ...(m.retrieval ? { retrieval: m.retrieval } : {}),
         ...(typeof m.topK === "number" ? { topK: m.topK } : {}),
       })),
-      memory: sanitizeMemoryBinding(s.config?.memory),
+      memory: sanitizeMemoryBinding(s.config?.memory, s.id),
     },
   }));
 }
 
 function sanitizeMemoryBinding(
   raw: unknown,
+  sessionId: string,
 ): ChatSessionMemoryBinding | undefined {
   if (!raw || typeof raw !== "object") return undefined;
   const r = raw as Partial<ChatSessionMemoryBinding>;
@@ -180,21 +213,36 @@ function sanitizeMemoryBinding(
     typeof s.runId !== "string" ||
     !s.appId ||
     !s.tenantId ||
-    !s.agentId ||
-    !s.runId
+    !s.agentId
   ) {
     return undefined;
   }
+  const runId = normalizeMemoryRunId(r.storageMode, s.runId, () =>
+    createLegacyRunId(
+      JSON.stringify([
+        sessionId,
+        r.memoryStoreName,
+        s.appId,
+        s.tenantId,
+        s.agentId,
+      ]),
+    ),
+  );
   return {
-    // 兜底分支只服务于"老快照 / 被手动改坏的数据"。正常路径的 binding 由 reducer
-    // 在 SET_MEMORY 时就铸了稳定 id；这里 newId() 每次重生属于可接受代价。
+    // 缺失 binding id 只可能来自老快照或手动损坏的数据；写 scope 的 runId
+    // 则在上方用会话与 scope seed 做确定性修复，不依赖这个临时 UI key。
     id: typeof r.id === "string" && r.id ? r.id : newId("memory"),
     memoryStoreName: r.memoryStoreName,
+    ...(r.storageMode === "ots" ||
+    r.storageMode === "file+ots" ||
+    r.storageMode === "filemem"
+      ? { storageMode: r.storageMode }
+      : {}),
     scope: {
       appId: s.appId,
       tenantId: s.tenantId,
       agentId: s.agentId,
-      runId: s.runId,
+      runId,
     },
     ...(Number.isInteger(r.topK) && (r.topK as number) > 0
       ? { topK: r.topK as number }
@@ -207,33 +255,57 @@ function sanitizeMemoryBinding(
   };
 }
 
-function readStorageKey(storageKey: string): ChatSession[] {
-  if (typeof window === "undefined") return [];
-  try {
-    const raw = window.localStorage.getItem(storageKey);
-    if (!raw) return [];
-    return sanitizeSessions(JSON.parse(raw));
-  } catch {
-    return [];
-  }
+interface ChatHistorySnapshotRead {
+  token: string;
+  sessions: ChatSession[];
 }
 
-function migrateLegacyIfNeeded(activeInstance: string | null): void {
-  if (typeof window === "undefined") return;
-  const scopedKey = getChatHistoryStorageKey(activeInstance);
-  if (window.localStorage.getItem(scopedKey) !== null) return;
-  const migrated = readStorageKey(CHAT_HISTORY_LEGACY_STORAGE_KEY).filter((s) =>
-    belongsToScope(s, activeInstance),
+function rawSessionBelongsToScope(
+  candidate: unknown,
+  activeInstance: string | null,
+): boolean {
+  if (!candidate || typeof candidate !== "object") return false;
+  return (
+    normalizeActiveInstance(
+      (candidate as Partial<ChatSession>).activeInstance,
+    ) === activeInstance
   );
-  if (migrated.length === 0) return;
-  writeStorageKey(scopedKey, migrated);
+}
+
+function readChatHistorySnapshot(
+  activeInstance: string | null,
+): ChatHistorySnapshotRead {
+  if (typeof window === "undefined") {
+    return { token: "server", sessions: [] };
+  }
+  const scopedKey = getChatHistoryStorageKey(activeInstance);
+  try {
+    const scopedRaw = window.localStorage.getItem(scopedKey);
+    const usesLegacy = scopedRaw === null;
+    const raw = usesLegacy
+      ? window.localStorage.getItem(CHAT_HISTORY_LEGACY_STORAGE_KEY)
+      : scopedRaw;
+    const parsed = raw ? JSON.parse(raw) : [];
+    const candidates = Array.isArray(parsed) ? parsed : [];
+    const scopedCandidates = usesLegacy
+      ? candidates.filter((candidate) =>
+          rawSessionBelongsToScope(candidate, activeInstance),
+        )
+      : candidates;
+    const sessions = sanitizeSessions(scopedCandidates)
+      .filter((candidate) => belongsToScope(candidate, activeInstance))
+      .sort((a, b) => b.updatedAt - a.updatedAt);
+    const token = usesLegacy
+      ? `legacy\0${JSON.stringify(scopedCandidates)}`
+      : `v2\0${raw ?? ""}`;
+    return { token, sessions };
+  } catch {
+    return { token: "storage-error", sessions: [] };
+  }
 }
 
 function readAll(activeInstance: string | null): ChatSession[] {
-  migrateLegacyIfNeeded(activeInstance);
-  return readStorageKey(getChatHistoryStorageKey(activeInstance)).filter((s) =>
-    belongsToScope(s, activeInstance),
-  );
+  return readChatHistorySnapshot(activeInstance).sessions;
 }
 
 function isQuotaError(err: unknown): boolean {
@@ -312,10 +384,7 @@ export function deriveSessionTitle(
 export function listSessions(
   activeInstance: string | null | undefined,
 ): ChatSession[] {
-  // Always return sorted by updatedAt desc so the sidebar can render directly.
-  return readAll(normalizeActiveInstance(activeInstance)).sort(
-    (a, b) => b.updatedAt - a.updatedAt,
-  );
+  return readAll(normalizeActiveInstance(activeInstance));
 }
 
 export function getSession(
@@ -375,13 +444,19 @@ export function clearAllSessions(
 
 type Listener = () => void;
 
-function subscribeToStorageKey(
+function subscribeToStorageKeys(
   storageKey: string | null,
   listener: Listener,
 ): () => void {
   if (!storageKey || typeof window === "undefined") return () => {};
   const handler = (event: StorageEvent) => {
-    if (event.key && event.key !== storageKey) return;
+    if (
+      event.key &&
+      event.key !== storageKey &&
+      event.key !== CHAT_HISTORY_LEGACY_STORAGE_KEY
+    ) {
+      return;
+    }
     listener();
   };
   window.addEventListener("storage", handler);
@@ -394,23 +469,25 @@ function subscribeToStorageKey(
 // stable reference when nothing changed.
 const snapshotCache = new Map<
   string,
-  { raw: string; snapshot: ChatSession[] }
+  { token: string; snapshot: ChatSession[] }
 >();
 const EMPTY_SESSIONS: ChatSession[] = [];
 
-function getSnapshotFor(
-  activeInstance: string | null,
-  ready: boolean,
+/**
+ * Cached read-only snapshot used by `useSyncExternalStore`. Exported so
+ * identity-sensitive consumers can verify that unrelated project changes do
+ * not replace a scope's array reference.
+ */
+export function getChatHistorySnapshot(
+  activeInstance: string | null | undefined,
 ): ChatSession[] {
-  if (!ready || typeof window === "undefined") return EMPTY_SESSIONS;
-  migrateLegacyIfNeeded(activeInstance);
-  const storageKey = getChatHistoryStorageKey(activeInstance);
-  const raw = window.localStorage.getItem(storageKey) ?? "";
+  const scope = normalizeActiveInstance(activeInstance);
+  const storageKey = getChatHistoryStorageKey(scope);
+  const { token, sessions } = readChatHistorySnapshot(scope);
   const cached = snapshotCache.get(storageKey);
-  if (cached?.raw === raw) return cached.snapshot;
-  const snapshot = listSessions(activeInstance);
-  snapshotCache.set(storageKey, { raw, snapshot });
-  return snapshot;
+  if (cached?.token === token) return cached.snapshot;
+  snapshotCache.set(storageKey, { token, snapshot: sessions });
+  return sessions;
 }
 
 function getServerSnapshot(): ChatSession[] {
@@ -432,11 +509,12 @@ export function useChatHistory(scope: ChatHistoryScope): UseChatHistoryResult {
     : null;
 
   const subscribe = useCallback(
-    (listener: Listener) => subscribeToStorageKey(storageKey, listener),
+    (listener: Listener) => subscribeToStorageKeys(storageKey, listener),
     [storageKey],
   );
   const getSnapshot = useCallback(
-    () => getSnapshotFor(activeInstance, scope.ready),
+    () =>
+      scope.ready ? getChatHistorySnapshot(activeInstance) : EMPTY_SESSIONS,
     [activeInstance, scope.ready],
   );
   const sessions = useSyncExternalStore(

package/dist/dashboard-runtime/dashboard/src/hooks/use-file-memory.ts

@@ -1,50 +1,205 @@
-import { useMutation, useQuery } from "@tanstack/react-query";
+import {
+  useInfiniteQuery,
+  useMutation,
+  useQuery,
+  useQueryClient,
+} from "@tanstack/react-query";
 
-import type { ChatMemoryWriteScope } from "@/components/chat/chat-config-context";
+import { fileMemoryQueryKeys } from "@/lib/query-keys";
+import { useDataScopeKey } from "@/providers/runtime-context-provider";
 import {
-  getFileMemoryFile,
-  getFileMemoryTree,
-  syncFileMemory,
+  createFileMemory,
+  deleteFileMemory,
+  getFileMemoryVersion,
+  listFileMemories,
+  listFileMemoryVersions,
+  readFileMemory,
+  renameFileMemory,
+  updateFileMemory,
 } from "@/services/file-memory";
+import type {
+  CreateFileMemoryRequest,
+  DeleteFileMemoryRequest,
+  FileMemoryScope,
+  ListFileMemoriesRequest,
+  ListFileMemoryVersionsRequest,
+  RenameFileMemoryRequest,
+  UpdateFileMemoryRequest,
+} from "@/types/file-memory";
+
+export { fileMemoryQueryKeys };
 
-// 文件记忆挂载只要求 appId（其余空字段由 BFF 归一为 __default__，与 openclaw
-// 一致）；通配符不受支持，由调用方在启用前排除。
-function scopeUsable(scope: ChatMemoryWriteScope): boolean {
-  return Boolean(scope.appId);
+function isExactScope(
+  scope: FileMemoryScope | undefined,
+): scope is FileMemoryScope {
+  return Boolean(
+    scope &&
+    scope.appId &&
+    scope.tenantId &&
+    scope.agentId &&
+    scope.runId &&
+    !Object.values(scope).includes("*"),
+  );
 }
 
-/** 只读本地镜像文件树。scope 不完整或未启用时不发请求。 */
-export function useFileMemoryTree(
+export function useFileMemories(
   memoryStoreName: string | undefined,
-  scope: ChatMemoryWriteScope | undefined,
-  enabled: boolean,
+  scope: FileMemoryScope | undefined,
+  options: Pick<ListFileMemoriesRequest, "pathPrefix" | "limit"> & {
+    enabled?: boolean;
+  } = {},
 ) {
+  const dataScopeKey = useDataScopeKey();
+  return useInfiniteQuery({
+    queryKey: fileMemoryQueryKeys.list(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      options.pathPrefix,
+    ),
+    queryFn: ({ pageParam }) =>
+      listFileMemories(memoryStoreName!, {
+        scope: scope!,
+        ...(options.pathPrefix ? { pathPrefix: options.pathPrefix } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+        ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
+      }),
+    getNextPageParam: (last) => last.nextToken ?? undefined,
+    initialPageParam: undefined as string | undefined,
+    enabled:
+      options.enabled !== false && !!memoryStoreName && isExactScope(scope),
+  });
+}
+
+export function useFileMemory(
+  memoryStoreName: string | undefined,
+  scope: FileMemoryScope | undefined,
+  path: string | null,
+) {
+  const dataScopeKey = useDataScopeKey();
   return useQuery({
-    queryKey: ["file-memory-tree", memoryStoreName, scope],
-    queryFn: () => getFileMemoryTree(memoryStoreName!, scope!),
-    enabled: enabled && !!memoryStoreName && !!scope && scopeUsable(scope),
+    queryKey: fileMemoryQueryKeys.file(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      path ?? "",
+    ),
+    queryFn: () =>
+      readFileMemory(memoryStoreName!, { scope: scope!, path: path! }),
+    enabled: !!memoryStoreName && isExactScope(scope) && !!path,
+  });
+}
+
+export function useFileMemoryVersions(
+  memoryStoreName: string | undefined,
+  scope: FileMemoryScope | undefined,
+  memoryId: string | undefined,
+  path?: string,
+  options: Pick<ListFileMemoryVersionsRequest, "limit" | "operation"> = {},
+) {
+  const dataScopeKey = useDataScopeKey();
+  return useInfiniteQuery({
+    queryKey: fileMemoryQueryKeys.versions(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      memoryId ?? "",
+      path,
+    ),
+    queryFn: ({ pageParam }) =>
+      listFileMemoryVersions(memoryStoreName!, {
+        scope: scope!,
+        memoryId: memoryId!,
+        ...(path ? { path } : {}),
+        ...(options.limit ? { limit: options.limit } : {}),
+        ...(options.operation ? { operation: options.operation } : {}),
+        ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
+      }),
+    getNextPageParam: (last) => last.nextToken ?? undefined,
+    initialPageParam: undefined as string | undefined,
+    enabled: !!memoryStoreName && isExactScope(scope) && !!memoryId,
   });
 }
 
-/** 读取单个文件内容。传入 null rel 时不发请求。 */
-export function useFileMemoryFile(
+export function useFileMemoryVersion(
   memoryStoreName: string | undefined,
-  scope: ChatMemoryWriteScope | undefined,
-  rel: string | null,
+  scope: FileMemoryScope | undefined,
+  memoryId: string | undefined,
+  memoryVersionId: string | undefined,
+  versionSeq: number | undefined,
 ) {
+  const dataScopeKey = useDataScopeKey();
   return useQuery({
-    queryKey: ["file-memory-file", memoryStoreName, scope, rel],
-    queryFn: () => getFileMemoryFile(memoryStoreName!, scope!, rel!),
-    enabled: !!memoryStoreName && !!scope && scopeUsable(scope) && !!rel,
+    queryKey: fileMemoryQueryKeys.version(
+      dataScopeKey,
+      memoryStoreName ?? "",
+      scope!,
+      memoryId ?? "",
+      memoryVersionId ?? "",
+      versionSeq ?? 0,
+    ),
+    queryFn: () =>
+      getFileMemoryVersion(memoryStoreName!, {
+        scope: scope!,
+        memoryId: memoryId!,
+        memoryVersionId: memoryVersionId!,
+        versionSeq: versionSeq!,
+      }),
+    enabled:
+      !!memoryStoreName &&
+      isExactScope(scope) &&
+      !!memoryId &&
+      !!memoryVersionId &&
+      versionSeq !== undefined,
   });
 }
 
-/** 手动触发一次远端→本地同步。 */
-export function useSyncFileMemory() {
+type MutationVariables<TRequest> = TRequest & { memoryStoreName: string };
+
+function useFileMemoryMutation<
+  TRequest extends { scope: FileMemoryScope },
+  TResult,
+>(mutate: (memoryStoreName: string, request: TRequest) => Promise<TResult>) {
+  const dataScopeKey = useDataScopeKey();
+  const queryClient = useQueryClient();
   return useMutation({
-    mutationFn: (vars: {
-      memoryStoreName: string;
-      scope: ChatMemoryWriteScope;
-    }) => syncFileMemory(vars.memoryStoreName, vars.scope),
+    mutationFn: ({
+      memoryStoreName,
+      ...request
+    }: MutationVariables<TRequest>) =>
+      mutate(memoryStoreName, request as unknown as TRequest),
+    onSuccess: (_data, variables) =>
+      queryClient.invalidateQueries({
+        queryKey: fileMemoryQueryKeys.root(
+          dataScopeKey,
+          variables.memoryStoreName,
+          variables.scope,
+        ),
+      }),
   });
 }
+
+export function useCreateFileMemory() {
+  return useFileMemoryMutation(createFileMemory);
+}
+
+export function useUpdateFileMemory() {
+  return useFileMemoryMutation(updateFileMemory);
+}
+
+export function useRenameFileMemory() {
+  return useFileMemoryMutation(renameFileMemory);
+}
+
+export function useDeleteFileMemory() {
+  return useFileMemoryMutation(deleteFileMemory);
+}
+
+export type CreateFileMemoryVariables =
+  MutationVariables<CreateFileMemoryRequest>;
+export type UpdateFileMemoryVariables =
+  MutationVariables<UpdateFileMemoryRequest>;
+export type RenameFileMemoryVariables =
+  MutationVariables<RenameFileMemoryRequest>;
+export type DeleteFileMemoryVariables =
+  MutationVariables<DeleteFileMemoryRequest>;

package/dist/dashboard-runtime/dashboard/src/hooks/use-memory-store-scopes.ts

@@ -48,6 +48,7 @@ export function useMemoryStoreScopes(
 export function useAllMemoryStoreScopes(
   memoryStoreName: string,
   scope: MemoryScope | null,
+  options: { enabled?: boolean } = {},
 ) {
   const { context, ready } = useRuntimeContext();
   const effective: MemoryScope = {
@@ -66,7 +67,7 @@ export function useAllMemoryStoreScopes(
       "all",
     ],
     queryFn: () => listAllMemoryStoreScopes(memoryStoreName, effective),
-    enabled: ready && !!memoryStoreName,
+    enabled: options.enabled !== false && ready && !!memoryStoreName,
     staleTime: 30 * 1000,
   });
 }