@tablestore/tablestore-agent-cli 0.2.11 → 0.3.1

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

@@ -8,23 +8,24 @@ import {
 import { fileMemoryQueryKeys } from "@/lib/query-keys";
 import { useDataScopeKey } from "@/providers/runtime-context-provider";
 import {
-  createFileMemory,
-  deleteFileMemory,
-  getFileMemoryVersion,
-  listFileMemories,
-  listFileMemoryVersions,
-  readFileMemory,
-  renameFileMemory,
-  updateFileMemory,
+  addItem,
+  deleteItem,
+  getItem,
+  getItemVersion,
+  listItems,
+  listItemVersions,
+  redactItemVersion,
+  updateItem,
 } from "@/services/file-memory";
 import type {
-  CreateFileMemoryRequest,
-  DeleteFileMemoryRequest,
+  AddItemRequest,
+  DeleteItemRequest,
   FileMemoryScope,
-  ListFileMemoriesRequest,
-  ListFileMemoryVersionsRequest,
-  RenameFileMemoryRequest,
-  UpdateFileMemoryRequest,
+  GetItemRequest,
+  ListItemsRequest,
+  ListItemVersionsRequest,
+  RedactItemVersionRequest,
+  UpdateItemRequest,
 } from "@/types/file-memory";
 
 export { fileMemoryQueryKeys };
@@ -42,10 +43,10 @@ function isExactScope(
   );
 }
 
-export function useFileMemories(
+export function useItems(
   memoryStoreName: string | undefined,
   scope: FileMemoryScope | undefined,
-  options: Pick<ListFileMemoriesRequest, "pathPrefix" | "limit"> & {
+  options: Pick<ListItemsRequest, "pathPrefix" | "depth" | "view" | "limit"> & {
     enabled?: boolean;
   } = {},
 ) {
@@ -58,9 +59,11 @@ export function useFileMemories(
       options.pathPrefix,
     ),
     queryFn: ({ pageParam }) =>
-      listFileMemories(memoryStoreName!, {
+      listItems(memoryStoreName!, {
         scope: scope!,
         ...(options.pathPrefix ? { pathPrefix: options.pathPrefix } : {}),
+        ...(options.depth !== undefined ? { depth: options.depth } : {}),
+        ...(options.view ? { view: options.view } : {}),
         ...(options.limit ? { limit: options.limit } : {}),
         ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
       }),
@@ -71,31 +74,46 @@ export function useFileMemories(
   });
 }
 
-export function useFileMemory(
+type ItemAddress = Pick<GetItemRequest, "itemId" | "path">;
+
+export function useItem(
   memoryStoreName: string | undefined,
   scope: FileMemoryScope | undefined,
-  path: string | null,
+  address: ItemAddress | null,
 ) {
   const dataScopeKey = useDataScopeKey();
+  const addressKey = address?.itemId ?? address?.path ?? "";
   return useQuery({
-    queryKey: fileMemoryQueryKeys.file(
+    queryKey: fileMemoryQueryKeys.item(
       dataScopeKey,
       memoryStoreName ?? "",
       scope!,
-      path ?? "",
+      addressKey,
     ),
     queryFn: () =>
-      readFileMemory(memoryStoreName!, { scope: scope!, path: path! }),
-    enabled: !!memoryStoreName && isExactScope(scope) && !!path,
+      getItem(memoryStoreName!, {
+        scope: scope!,
+        ...address!,
+        view: "full",
+      }),
+    enabled: !!memoryStoreName && isExactScope(scope) && !!addressKey,
   });
 }
 
-export function useFileMemoryVersions(
+export function useItemVersions(
   memoryStoreName: string | undefined,
   scope: FileMemoryScope | undefined,
-  memoryId: string | undefined,
-  path?: string,
-  options: Pick<ListFileMemoryVersionsRequest, "limit" | "operation"> = {},
+  itemId: string | undefined,
+  options: Pick<
+    ListItemVersionsRequest,
+    | "sessionId"
+    | "apiKeyId"
+    | "createdAtGte"
+    | "createdAtLte"
+    | "operation"
+    | "view"
+    | "limit"
+  > = {},
 ) {
   const dataScopeKey = useDataScopeKey();
   return useInfiniteQuery({
@@ -103,30 +121,25 @@ export function useFileMemoryVersions(
       dataScopeKey,
       memoryStoreName ?? "",
       scope!,
-      memoryId ?? "",
-      path,
+      itemId ?? "",
     ),
     queryFn: ({ pageParam }) =>
-      listFileMemoryVersions(memoryStoreName!, {
+      listItemVersions(memoryStoreName!, {
         scope: scope!,
-        memoryId: memoryId!,
-        ...(path ? { path } : {}),
-        ...(options.limit ? { limit: options.limit } : {}),
-        ...(options.operation ? { operation: options.operation } : {}),
+        itemId: itemId!,
+        ...options,
         ...(typeof pageParam === "string" ? { nextToken: pageParam } : {}),
       }),
     getNextPageParam: (last) => last.nextToken ?? undefined,
     initialPageParam: undefined as string | undefined,
-    enabled: !!memoryStoreName && isExactScope(scope) && !!memoryId,
+    enabled: !!memoryStoreName && isExactScope(scope) && !!itemId,
   });
 }
 
-export function useFileMemoryVersion(
+export function useItemVersion(
   memoryStoreName: string | undefined,
   scope: FileMemoryScope | undefined,
-  memoryId: string | undefined,
-  memoryVersionId: string | undefined,
-  versionSeq: number | undefined,
+  versionId: string | undefined,
 ) {
   const dataScopeKey = useDataScopeKey();
   return useQuery({
@@ -134,32 +147,23 @@ export function useFileMemoryVersion(
       dataScopeKey,
       memoryStoreName ?? "",
       scope!,
-      memoryId ?? "",
-      memoryVersionId ?? "",
-      versionSeq ?? 0,
+      versionId ?? "",
     ),
     queryFn: () =>
-      getFileMemoryVersion(memoryStoreName!, {
+      getItemVersion(memoryStoreName!, {
         scope: scope!,
-        memoryId: memoryId!,
-        memoryVersionId: memoryVersionId!,
-        versionSeq: versionSeq!,
+        versionId: versionId!,
+        view: "full",
       }),
-    enabled:
-      !!memoryStoreName &&
-      isExactScope(scope) &&
-      !!memoryId &&
-      !!memoryVersionId &&
-      versionSeq !== undefined,
+    enabled: !!memoryStoreName && isExactScope(scope) && !!versionId,
   });
 }
 
 type MutationVariables<TRequest> = TRequest & { memoryStoreName: string };
 
-function useFileMemoryMutation<
-  TRequest extends { scope: FileMemoryScope },
-  TResult,
->(mutate: (memoryStoreName: string, request: TRequest) => Promise<TResult>) {
+function useItemMutation<TRequest extends { scope: FileMemoryScope }, TResult>(
+  mutate: (memoryStoreName: string, request: TRequest) => Promise<TResult>,
+) {
   const dataScopeKey = useDataScopeKey();
   const queryClient = useQueryClient();
   return useMutation({
@@ -179,27 +183,24 @@ function useFileMemoryMutation<
   });
 }
 
-export function useCreateFileMemory() {
-  return useFileMemoryMutation(createFileMemory);
+export function useAddItem() {
+  return useItemMutation(addItem);
 }
 
-export function useUpdateFileMemory() {
-  return useFileMemoryMutation(updateFileMemory);
+export function useUpdateItem() {
+  return useItemMutation(updateItem);
 }
 
-export function useRenameFileMemory() {
-  return useFileMemoryMutation(renameFileMemory);
+export function useDeleteItem() {
+  return useItemMutation(deleteItem);
 }
 
-export function useDeleteFileMemory() {
-  return useFileMemoryMutation(deleteFileMemory);
+export function useRedactItemVersion() {
+  return useItemMutation(redactItemVersion);
 }
 
-export type CreateFileMemoryVariables =
-  MutationVariables<CreateFileMemoryRequest>;
-export type UpdateFileMemoryVariables =
-  MutationVariables<UpdateFileMemoryRequest>;
-export type RenameFileMemoryVariables =
-  MutationVariables<RenameFileMemoryRequest>;
-export type DeleteFileMemoryVariables =
-  MutationVariables<DeleteFileMemoryRequest>;
+export type AddItemVariables = MutationVariables<AddItemRequest>;
+export type UpdateItemVariables = MutationVariables<UpdateItemRequest>;
+export type DeleteItemVariables = MutationVariables<DeleteItemRequest>;
+export type RedactItemVersionVariables =
+  MutationVariables<RedactItemVersionRequest>;

package/dist/dashboard-runtime/dashboard/src/hooks/use-instances.ts

@@ -11,6 +11,7 @@ import {
   deleteInstance,
   exportInstanceToken,
   getInstance,
+  getInstanceConnectivity,
   importInstance,
   listInstances,
   switchInstance,
@@ -32,9 +33,22 @@ import {
   useRuntimeContext,
 } from "@/providers/runtime-context-provider";
 import { useI18n } from "@/i18n/i18n-context";
+import type { RuntimeContext } from "@/types/runtime-context";
 
 export const INSTANCES_QUERY_KEY = ["instances"] as const;
 
+export function resolveDisplayedInstanceName(
+  context: Pick<
+    RuntimeContext,
+    "activeInstance" | "credentialSource" | "instanceName"
+  >,
+  configuredActiveInstance: string | null,
+): string | null {
+  return (
+    context.activeInstance ?? context.instanceName ?? configuredActiveInstance
+  );
+}
+
 /** Invalidate every cache whose data depends on the active instance.
  *  Used after non-switch mutations (connect / import / update / delete) where
  *  the current session can keep the existing data while a refetch lands. */
@@ -56,13 +70,35 @@ function refreshRuntimeContext(queryClient: QueryClient) {
   void queryClient.invalidateQueries({ queryKey: RUNTIME_CONTEXT_QUERY_KEY });
 }
 
+function invalidateInstanceConnectivity(queryClient: QueryClient) {
+  void queryClient.invalidateQueries({ queryKey: ["instance-connectivity"] });
+}
+
 export function useInstances() {
   const { context, ready } = useRuntimeContext();
   return useQuery({
     queryKey: queryKeys.instances(context.dataScopeKey),
     queryFn: listInstances,
+    select: (data) => ({
+      ...data,
+      activeInstance: resolveDisplayedInstanceName(
+        context,
+        data.activeInstance,
+      ),
+    }),
+    enabled: ready,
+    staleTime: 30 * 1000,
+  });
+}
+
+export function useInstanceConnectivity() {
+  const { context, ready } = useRuntimeContext();
+  return useQuery({
+    queryKey: queryKeys.instanceConnectivity(context.dataScopeKey),
+    queryFn: getInstanceConnectivity,
     enabled: ready,
     staleTime: 30 * 1000,
+    refetchInterval: 30 * 1000,
   });
 }
 
@@ -83,6 +119,7 @@ export function useConnectInstance() {
     mutationFn: (payload: ConnectInstancePayload) => connectInstance(payload),
     onSuccess: () => {
       resetInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.created"));
     },
@@ -103,6 +140,7 @@ export function useImportInstance() {
     mutationFn: (payload: ImportInstancePayload) => importInstance(payload),
     onSuccess: () => {
       resetInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.tokenImported"));
     },
@@ -124,6 +162,7 @@ export function useUpdateInstance(name: string) {
     onSuccess: () => {
       invalidateInstanceScopedCaches(queryClient);
       queryClient.invalidateQueries({ queryKey: ["instance"] });
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.updated"));
     },
@@ -144,6 +183,7 @@ export function useDeleteInstance() {
     mutationFn: (name: string) => deleteInstance(name),
     onSuccess: () => {
       invalidateInstanceScopedCaches(queryClient);
+      invalidateInstanceConnectivity(queryClient);
       refreshRuntimeContext(queryClient);
       toast.success(t("instance.toast.deleted"));
     },

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

@@ -1,75 +1,51 @@
 "use client";
 
 import { useCallback, useEffect, useState } from "react";
+import {
+  clearRecentSubspaces,
+  readRecentSubspaces,
+  rememberRecentSubspace,
+} from "@/lib/subspace-history";
 
-const MAX_HISTORY = 10;
-const HISTORY_KEY_PREFIX = "kb-subspace-history:";
-const ACTIVE_KEY_PREFIX = "kb-subspace-active:";
+type RecentSubspaceStorage = Pick<
+  Storage,
+  "getItem" | "setItem" | "removeItem"
+>;
 
-function getStorageKey(knowledgeBaseName: string): string {
-  return `${HISTORY_KEY_PREFIX}${knowledgeBaseName}`;
-}
+const unavailableLocalStorage: RecentSubspaceStorage = {
+  getItem: () => null,
+  setItem: () => {},
+  removeItem: () => {},
+};
 
-/**
- * Per-tab active subspace. Backed by sessionStorage so that two tabs viewing
- * the same KB can hold independent scopes without overwriting each other.
- */
-export function getActiveSubspace(knowledgeBaseName: string): string | null {
-  if (typeof window === "undefined") return null;
+export function getLocalStorage(): RecentSubspaceStorage {
   try {
-    return window.sessionStorage.getItem(ACTIVE_KEY_PREFIX + knowledgeBaseName);
+    return window.localStorage;
   } catch {
-    return null;
+    return unavailableLocalStorage;
   }
 }
 
-export function setActiveSubspace(
-  knowledgeBaseName: string,
-  subspace: string,
-): void {
-  if (typeof window === "undefined") return;
-  try {
-    window.sessionStorage.setItem(
-      ACTIVE_KEY_PREFIX + knowledgeBaseName,
-      subspace,
-    );
-  } catch {
-    // Quota exceeded / privacy mode — keep the in-memory state usable.
-  }
+export interface ScopedSubspaceHistory {
+  scopeId: string;
+  history: string[];
 }
 
-export function clearActiveSubspace(knowledgeBaseName: string): void {
-  if (typeof window === "undefined") return;
-  try {
-    window.sessionStorage.removeItem(ACTIVE_KEY_PREFIX + knowledgeBaseName);
-  } catch {
-    // Ignore.
-  }
-}
-
-function readHistory(knowledgeBaseName: string): string[] {
-  if (typeof window === "undefined") return [];
-  try {
-    const raw = window.localStorage.getItem(getStorageKey(knowledgeBaseName));
-    if (!raw) return [];
-    const parsed: unknown = JSON.parse(raw);
-    if (!Array.isArray(parsed)) return [];
-    return parsed.filter((item): item is string => typeof item === "string");
-  } catch {
-    return [];
-  }
+export function getSubspaceScopeId(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string {
+  return JSON.stringify([dataScopeKey, knowledgeBaseName]);
 }
 
-function writeHistory(knowledgeBaseName: string, history: string[]): void {
-  if (typeof window === "undefined") return;
-  try {
-    window.localStorage.setItem(
-      getStorageKey(knowledgeBaseName),
-      JSON.stringify(history),
-    );
-  } catch {
-    // Ignore quota / privacy mode errors silently.
-  }
+export function selectSubspaceHistory(
+  state: ScopedSubspaceHistory,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string[] {
+  return state.scopeId === getSubspaceScopeId(dataScopeKey, knowledgeBaseName)
+    ? state.history
+    : [];
 }
 
 /**
@@ -78,34 +54,47 @@ function writeHistory(knowledgeBaseName: string, history: string[]): void {
  * History is hydrated after mount to keep the SSR-rendered tree in sync
  * with the initial client tree.
  */
-export function useSubspaceHistory(knowledgeBaseName: string) {
-  const [history, setHistory] = useState<string[]>([]);
+export function useSubspaceHistory(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+) {
+  const scopeId = getSubspaceScopeId(dataScopeKey, knowledgeBaseName);
+  const [state, setState] = useState<ScopedSubspaceHistory>({
+    scopeId,
+    history: [],
+  });
+  const history = selectSubspaceHistory(state, dataScopeKey, knowledgeBaseName);
 
   useEffect(() => {
-    setHistory(readHistory(knowledgeBaseName));
-  }, [knowledgeBaseName]);
+    setState({
+      scopeId,
+      history: readRecentSubspaces(
+        getLocalStorage(),
+        dataScopeKey,
+        knowledgeBaseName,
+      ),
+    });
+  }, [scopeId, dataScopeKey, knowledgeBaseName]);
 
   const addToHistory = useCallback(
     (subspace: string) => {
-      if (!subspace) return;
-      setHistory((prev) => {
-        const next = [subspace, ...prev.filter((s) => s !== subspace)].slice(
-          0,
-          MAX_HISTORY,
-        );
-        writeHistory(knowledgeBaseName, next);
-        return next;
+      setState({
+        scopeId,
+        history: rememberRecentSubspace(
+          getLocalStorage(),
+          dataScopeKey,
+          knowledgeBaseName,
+          subspace,
+        ),
       });
     },
-    [knowledgeBaseName],
+    [scopeId, dataScopeKey, knowledgeBaseName],
   );
 
   const clearHistory = useCallback(() => {
-    if (typeof window !== "undefined") {
-      window.localStorage.removeItem(getStorageKey(knowledgeBaseName));
-    }
-    setHistory([]);
-  }, [knowledgeBaseName]);
+    clearRecentSubspaces(getLocalStorage(), dataScopeKey, knowledgeBaseName);
+    setState({ scopeId, history: [] });
+  }, [scopeId, dataScopeKey, knowledgeBaseName]);
 
   return { history, addToHistory, clearHistory };
 }