@tablestore/tablestore-agent-cli 0.4.0 → 0.4.1

package/dist/dashboard-runtime/dashboard/src/components/memory/scope-filter-builder.tsx

@@ -0,0 +1,393 @@
+"use client";
+
+import { useEffect, useRef, useState } from "react";
+import { Plus, Trash2 } from "lucide-react";
+
+import { Button } from "@/components/ui/button";
+import { Checkbox } from "@/components/ui/checkbox";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select";
+import { useI18n } from "@/i18n/i18n-context";
+import type {
+  ScopeDirectoryFilter,
+  ScopeDirectoryLeafFilter,
+} from "@/types/memory";
+
+export type ScopeFilterCombinator = "and" | "or";
+export type ScopeFilterOperator =
+  "eq" | "in" | "prefix" | "wildcard" | "range" | "exists";
+
+export interface ScopeFilterRule {
+  id: string;
+  field: string;
+  operator: ScopeFilterOperator;
+  value: string;
+  endValue: string;
+  negate: boolean;
+}
+
+const FILTER_FIELDS = [
+  "scopeType",
+  "appId",
+  "tenantId",
+  "agentId",
+  "runId",
+  "wikiId",
+  "scopeKey",
+] as const;
+
+const FILTER_OPERATORS: ScopeFilterOperator[] = [
+  "eq",
+  "in",
+  "prefix",
+  "wildcard",
+  "range",
+  "exists",
+];
+
+interface VisualScopeFilterState {
+  combinator: ScopeFilterCombinator;
+  rules: ScopeFilterRule[];
+  filter: ScopeDirectoryFilter;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function restoredRule(value: unknown, index: number): ScopeFilterRule | null {
+  let negate = false;
+  let leaf = value;
+  if (isRecord(value) && value.op === "not") {
+    negate = true;
+    leaf = value.condition;
+  }
+  if (!isRecord(leaf) || typeof leaf.op !== "string") return null;
+  if (
+    typeof leaf.field !== "string" ||
+    !(FILTER_FIELDS as readonly string[]).includes(leaf.field)
+  ) {
+    return null;
+  }
+
+  const base = newRule(`scope-filter-${index + 1}`);
+  base.field = leaf.field;
+  base.negate = negate;
+  if (
+    (leaf.op === "eq" || leaf.op === "prefix" || leaf.op === "wildcard") &&
+    typeof leaf.value === "string"
+  ) {
+    return { ...base, operator: leaf.op, value: leaf.value };
+  }
+  if (
+    leaf.op === "in" &&
+    Array.isArray(leaf.values) &&
+    leaf.values.length > 0 &&
+    leaf.values.every((item) => typeof item === "string")
+  ) {
+    return { ...base, operator: "in", value: leaf.values.join(", ") };
+  }
+  if (
+    leaf.op === "range" &&
+    (typeof leaf.gte === "string" || typeof leaf.lte === "string") &&
+    leaf.gt === undefined &&
+    leaf.lt === undefined
+  ) {
+    return {
+      ...base,
+      operator: "range",
+      value: typeof leaf.gte === "string" ? leaf.gte : "",
+      endValue: typeof leaf.lte === "string" ? leaf.lte : "",
+    };
+  }
+  if (leaf.op === "exists") {
+    return { ...base, operator: "exists" };
+  }
+  return null;
+}
+
+/** Restore only Filter shapes the visual builder itself can produce. Invalid
+ * or more deeply nested URL state is ignored instead of being submitted as an
+ * invisible constraint. */
+export function restoreVisualScopeFilter(
+  value: unknown,
+): VisualScopeFilterState | undefined {
+  const root = isRecord(value) ? value : null;
+  if (!root || typeof root.op !== "string") return undefined;
+  const combinator: ScopeFilterCombinator = root.op === "or" ? "or" : "and";
+  const conditions =
+    root.op === "and" || root.op === "or"
+      ? Array.isArray(root.conditions)
+        ? root.conditions
+        : []
+      : [value];
+  if (conditions.length === 0 || conditions.length > 64) return undefined;
+
+  const rules = conditions.map(restoredRule);
+  if (rules.some((rule) => rule === null)) return undefined;
+  const restoredRules = rules as ScopeFilterRule[];
+  const filter = buildVisualScopeFilter(restoredRules, combinator);
+  return filter ? { combinator, rules: restoredRules, filter } : undefined;
+}
+
+export function parseSerializedVisualScopeFilter(
+  value: string | null,
+): VisualScopeFilterState | undefined {
+  if (!value) return undefined;
+  try {
+    return restoreVisualScopeFilter(JSON.parse(value) as unknown);
+  } catch {
+    return undefined;
+  }
+}
+
+function buildLeaf(rule: ScopeFilterRule): ScopeDirectoryLeafFilter | null {
+  const field = rule.field.trim();
+  if (!field) return null;
+  if (rule.operator === "exists") return { op: "exists", field };
+
+  const value = rule.value.trim();
+  if (rule.operator === "in") {
+    const values = [
+      ...new Set(value.split(",").map((item) => item.trim())),
+    ].filter(Boolean);
+    return values.length > 0 ? { op: "in", field, values } : null;
+  }
+  if (rule.operator === "range") {
+    const endValue = rule.endValue.trim();
+    if (!value && !endValue) return null;
+    return {
+      op: "range",
+      field,
+      ...(value ? { gte: value } : {}),
+      ...(endValue ? { lte: endValue } : {}),
+    };
+  }
+  if (!value) return null;
+  return { op: rule.operator, field, value };
+}
+
+/** Convert the visual rule group into the server Filter AST. Blank rows are
+ * intentionally ignored so adding a row never changes a request until the
+ * user has selected a meaningful value. */
+export function buildVisualScopeFilter(
+  rules: ScopeFilterRule[],
+  combinator: ScopeFilterCombinator,
+): ScopeDirectoryFilter | undefined {
+  const conditions = rules.flatMap<ScopeDirectoryFilter>((rule) => {
+    const leaf = buildLeaf(rule);
+    if (!leaf) return [];
+    return [rule.negate ? { op: "not", condition: leaf } : leaf];
+  });
+  if (conditions.length === 0) return undefined;
+  if (conditions.length === 1) return conditions[0];
+  return { op: combinator, conditions };
+}
+
+function newRule(id: string): ScopeFilterRule {
+  return {
+    id,
+    field: "appId",
+    operator: "eq",
+    value: "",
+    endValue: "",
+    negate: false,
+  };
+}
+
+export function ScopeFilterBuilder({
+  initialFilter,
+  onChange,
+}: {
+  initialFilter?: ScopeDirectoryFilter;
+  onChange: (filter: ScopeDirectoryFilter | undefined) => void;
+}) {
+  const { t } = useI18n();
+  const [initialState] = useState(() =>
+    restoreVisualScopeFilter(initialFilter),
+  );
+  const nextId = useRef((initialState?.rules.length ?? 0) + 1);
+  const onChangeRef = useRef(onChange);
+  const [combinator, setCombinator] = useState<ScopeFilterCombinator>(
+    initialState?.combinator ?? "and",
+  );
+  const [rules, setRules] = useState<ScopeFilterRule[]>(
+    initialState?.rules ?? [],
+  );
+
+  useEffect(() => {
+    onChangeRef.current = onChange;
+  }, [onChange]);
+
+  useEffect(() => {
+    onChangeRef.current(buildVisualScopeFilter(rules, combinator));
+  }, [combinator, rules]);
+
+  function updateRule(id: string, patch: Partial<ScopeFilterRule>) {
+    setRules((current) =>
+      current.map((rule) => (rule.id === id ? { ...rule, ...patch } : rule)),
+    );
+  }
+
+  function addRule() {
+    const id = `scope-filter-${nextId.current}`;
+    nextId.current += 1;
+    setRules((current) => [...current, newRule(id)]);
+  }
+
+  function removeRule(id: string) {
+    setRules((current) => current.filter((rule) => rule.id !== id));
+  }
+
+  return (
+    <section
+      className="space-y-3 rounded-lg border border-[hsl(var(--border))] bg-[hsl(var(--muted)/0.2)] p-3"
+      data-testid="scope-filter-builder"
+    >
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <div>
+          <Label>{t("memory.search.scopeFilter")}</Label>
+          <p className="mt-1 text-xs text-muted-foreground">
+            {t("memory.search.scopeFilterHelp")}
+          </p>
+        </div>
+        {rules.length > 1 ? (
+          <Select
+            value={combinator}
+            onValueChange={(value) =>
+              setCombinator(value as ScopeFilterCombinator)
+            }
+          >
+            <SelectTrigger className="h-8 w-[132px]">
+              <SelectValue />
+            </SelectTrigger>
+            <SelectContent>
+              <SelectItem value="and">
+                {t("memory.search.scopeFilterMatchAll")}
+              </SelectItem>
+              <SelectItem value="or">
+                {t("memory.search.scopeFilterMatchAny")}
+              </SelectItem>
+            </SelectContent>
+          </Select>
+        ) : null}
+      </div>
+
+      <div className="space-y-2">
+        {rules.map((rule, index) => (
+          <div
+            key={rule.id}
+            className="space-y-2 rounded-md border bg-background p-2.5"
+          >
+            <div className="flex items-center justify-between gap-2">
+              <span className="text-xs font-medium text-muted-foreground">
+                {t("memory.search.scopeFilterCondition", { index: index + 1 })}
+              </span>
+              <Button
+                type="button"
+                variant="ghost"
+                size="icon"
+                className="h-7 w-7"
+                aria-label={t("memory.search.scopeFilterRemove")}
+                onClick={() => removeRule(rule.id)}
+              >
+                <Trash2 className="h-3.5 w-3.5" />
+              </Button>
+            </div>
+            <div className="grid gap-2">
+              <Select
+                value={rule.field}
+                onValueChange={(field) => updateRule(rule.id, { field })}
+              >
+                <SelectTrigger aria-label={t("memory.search.scopeFilterField")}>
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {FILTER_FIELDS.map((field) => (
+                    <SelectItem key={field} value={field}>
+                      {t(`memory.search.scopeFilterField_${field}`)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+              <Select
+                value={rule.operator}
+                onValueChange={(operator) =>
+                  updateRule(rule.id, {
+                    operator: operator as ScopeFilterOperator,
+                  })
+                }
+              >
+                <SelectTrigger
+                  aria-label={t("memory.search.scopeFilterOperator")}
+                >
+                  <SelectValue />
+                </SelectTrigger>
+                <SelectContent>
+                  {FILTER_OPERATORS.map((operator) => (
+                    <SelectItem key={operator} value={operator}>
+                      {t(`memory.search.scopeFilterOperator_${operator}`)}
+                    </SelectItem>
+                  ))}
+                </SelectContent>
+              </Select>
+            </div>
+
+            {rule.operator === "range" ? (
+              <div className="grid grid-cols-2 gap-2">
+                <Input
+                  value={rule.value}
+                  onChange={(event) =>
+                    updateRule(rule.id, { value: event.target.value })
+                  }
+                  placeholder={t("memory.search.scopeFilterRangeStart")}
+                />
+                <Input
+                  value={rule.endValue}
+                  onChange={(event) =>
+                    updateRule(rule.id, { endValue: event.target.value })
+                  }
+                  placeholder={t("memory.search.scopeFilterRangeEnd")}
+                />
+              </div>
+            ) : rule.operator !== "exists" ? (
+              <Input
+                value={rule.value}
+                onChange={(event) =>
+                  updateRule(rule.id, { value: event.target.value })
+                }
+                placeholder={
+                  rule.operator === "in"
+                    ? t("memory.search.scopeFilterValuesPlaceholder")
+                    : t("memory.search.scopeFilterValuePlaceholder")
+                }
+              />
+            ) : null}
+
+            <label className="flex items-center gap-2 text-xs text-muted-foreground">
+              <Checkbox
+                checked={rule.negate}
+                onCheckedChange={(checked) =>
+                  updateRule(rule.id, { negate: checked === true })
+                }
+              />
+              {t("memory.search.scopeFilterNegate")}
+            </label>
+          </div>
+        ))}
+      </div>
+
+      <Button type="button" variant="outline" size="sm" onClick={addRule}>
+        <Plus className="h-3.5 w-3.5" />
+        {t("memory.search.scopeFilterAdd")}
+      </Button>
+    </section>
+  );
+}

package/dist/dashboard-runtime/dashboard/src/components/memory/scope-workspace.tsx

@@ -71,7 +71,11 @@ export function ScopeWorkspace({
   }
 
   const storageMode = parseKnownStorageMode(store.data?.storageMode);
-  if (storageMode === null || storageMode === "filemem") {
+  if (
+    storageMode === null ||
+    storageMode === "filemem" ||
+    storageMode === "managed-file"
+  ) {
     return <ScopeWorkspaceGateState state="unsupported" />;
   }
 
@@ -111,7 +115,7 @@ function LoadedScopeWorkspace({
 }: {
   memoryStoreName: string;
   scope: FileMemoryScope;
-  storageMode: Exclude<StorageMode, "filemem">;
+  storageMode: Exclude<StorageMode, "filemem" | "managed-file">;
 }) {
   const { t } = useI18n();
   const scopeInventory = useMemoryStoreScopes(memoryStoreName, scope, {

package/dist/dashboard-runtime/dashboard/src/components/shared/copyable-id.tsx

@@ -0,0 +1,69 @@
+"use client";
+
+import { Copy } from "lucide-react";
+import { toast } from "sonner";
+
+import { useI18n } from "@/i18n/i18n-context";
+import { copyToClipboard } from "@/lib/clipboard";
+import { cn } from "@/lib/utils";
+
+interface CopyableIdProps {
+  value: string | null | undefined;
+  label?: string;
+  className?: string;
+  valueClassName?: string;
+  copyLabel?: string;
+}
+
+/** Compact, overflow-safe identifier with full-value tooltip and copy action. */
+export function CopyableId({
+  value,
+  label = "ID",
+  className,
+  valueClassName,
+  copyLabel,
+}: CopyableIdProps) {
+  const { t } = useI18n();
+  const copyable = value !== null && value !== undefined && value !== "";
+  const displayValue = copyable ? value : "-";
+  const accessibleLabel = copyLabel || label || "ID";
+
+  async function handleCopy(event: React.MouseEvent<HTMLButtonElement>) {
+    event.preventDefault();
+    event.stopPropagation();
+    try {
+      await copyToClipboard(displayValue);
+      toast.success(t("common.copied"));
+    } catch {
+      toast.error(t("common.copyFailed"));
+    }
+  }
+
+  return (
+    <div className={cn("flex min-w-0 items-center gap-1.5", className)}>
+      {label ? (
+        <span className="shrink-0 text-muted-foreground">{label}:</span>
+      ) : null}
+      <code
+        className={cn(
+          "min-w-0 flex-1 truncate font-mono text-xs text-foreground",
+          valueClassName,
+        )}
+        title={displayValue}
+      >
+        {displayValue}
+      </code>
+      {copyable ? (
+        <button
+          type="button"
+          onClick={handleCopy}
+          aria-label={`${t("common.copy")} ${accessibleLabel}`}
+          title={`${t("common.copy")} ${accessibleLabel}`}
+          className="inline-flex h-6 w-6 shrink-0 items-center justify-center rounded text-muted-foreground transition-colors hover:bg-accent hover:text-foreground focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-primary/30"
+        >
+          <Copy className="h-3.5 w-3.5" />
+        </button>
+      ) : null}
+    </div>
+  );
+}

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

@@ -4,6 +4,7 @@ import { useCallback, useMemo, useSyncExternalStore } from "react";
 
 import { newId } from "@/lib/random-id";
 import {
+  isKnownStorageMode,
   normalizeMemoryRunId,
   type StorageMode,
 } from "@/lib/memory-storage-mode";
@@ -800,9 +801,7 @@ function sanitizeMemoryBinding(
     // 则在上方用会话与 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"
+    ...(isKnownStorageMode(r.storageMode)
       ? { storageMode: r.storageMode }
       : {}),
     scope: {