openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/views/config-search.node.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import {
+  appendTagFilter,
+  getTagFilters,
+  hasTagFilter,
+  removeTagFilter,
+  replaceTagFilters,
+  toggleTagFilter,
+} from "./config-search.ts";
+
+describe("config search tag helper", () => {
+  it("adds a tag when query is empty", () => {
+    expect(appendTagFilter("", "security")).toBe("tag:security");
+  });
+
+  it("appends a tag to existing text query", () => {
+    expect(appendTagFilter("token", "security")).toBe("token tag:security");
+  });
+
+  it("deduplicates existing tag filters case-insensitively", () => {
+    expect(appendTagFilter("token tag:Security", "security")).toBe("token tag:Security");
+  });
+
+  it("detects exact tag terms", () => {
+    expect(hasTagFilter("tag:security token", "security")).toBe(true);
+    expect(hasTagFilter("tag:security-hard token", "security")).toBe(false);
+  });
+
+  it("removes only the selected active tag", () => {
+    expect(removeTagFilter("token tag:security tag:auth", "security")).toBe("token tag:auth");
+  });
+
+  it("toggle removes active tag and keeps text", () => {
+    expect(toggleTagFilter("token tag:security", "security")).toBe("token");
+  });
+
+  it("toggle adds missing tag", () => {
+    expect(toggleTagFilter("token", "channels")).toBe("token tag:channels");
+  });
+
+  it("extracts unique normalized tags from query", () => {
+    expect(getTagFilters("token tag:Security tag:auth tag:security")).toEqual(["security", "auth"]);
+  });
+
+  it("replaces only tag filters and preserves free text", () => {
+    expect(replaceTagFilters("token tag:security mode", ["auth", "channels"])).toBe(
+      "token mode tag:auth tag:channels",
+    );
+  });
+});

package/ui/src/ui/views/config-search.ts

@@ -0,0 +1,92 @@
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function normalizeTag(tag: string): string {
+  return tag.trim().toLowerCase();
+}
+
+export function getTagFilters(query: string): string[] {
+  const seen = new Set<string>();
+  const tags: string[] = [];
+  const pattern = /(^|\s)tag:([^\s]+)/gi;
+  const raw = query.trim();
+  let match: RegExpExecArray | null = pattern.exec(raw);
+  while (match) {
+    const normalized = normalizeTag(match[2] ?? "");
+    if (normalized && !seen.has(normalized)) {
+      seen.add(normalized);
+      tags.push(normalized);
+    }
+    match = pattern.exec(raw);
+  }
+  return tags;
+}
+
+export function hasTagFilter(query: string, tag: string): boolean {
+  const normalizedTag = normalizeTag(tag);
+  if (!normalizedTag) {
+    return false;
+  }
+  const pattern = new RegExp(`(^|\\s)tag:${escapeRegExp(normalizedTag)}(?=\\s|$)`, "i");
+  return pattern.test(query.trim());
+}
+
+export function appendTagFilter(query: string, tag: string): string {
+  const normalizedTag = normalizeTag(tag);
+  const trimmed = query.trim();
+  if (!normalizedTag) {
+    return trimmed;
+  }
+  if (!trimmed) {
+    return `tag:${normalizedTag}`;
+  }
+  if (hasTagFilter(trimmed, normalizedTag)) {
+    return trimmed;
+  }
+  return `${trimmed} tag:${normalizedTag}`;
+}
+
+export function removeTagFilter(query: string, tag: string): string {
+  const normalizedTag = normalizeTag(tag);
+  const trimmed = query.trim();
+  if (!normalizedTag || !trimmed) {
+    return trimmed;
+  }
+  const pattern = new RegExp(`(^|\\s)tag:${escapeRegExp(normalizedTag)}(?=\\s|$)`, "ig");
+  return trimmed.replace(pattern, " ").replace(/\s+/g, " ").trim();
+}
+
+export function replaceTagFilters(query: string, tags: readonly string[]): string {
+  const uniqueTags: string[] = [];
+  const seen = new Set<string>();
+  for (const tag of tags) {
+    const normalized = normalizeTag(tag);
+    if (!normalized || seen.has(normalized)) {
+      continue;
+    }
+    seen.add(normalized);
+    uniqueTags.push(normalized);
+  }
+
+  const trimmed = query.trim();
+  const withoutTags = trimmed
+    .replace(/(^|\s)tag:([^\s]+)/gi, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+  const tagTokens = uniqueTags.map((tag) => `tag:${tag}`).join(" ");
+  if (withoutTags && tagTokens) {
+    return `${withoutTags} ${tagTokens}`;
+  }
+  if (withoutTags) {
+    return withoutTags;
+  }
+  return tagTokens;
+}
+
+export function toggleTagFilter(query: string, tag: string): string {
+  if (hasTagFilter(query, tag)) {
+    return removeTagFilter(query, tag);
+  }
+  return appendTagFilter(query, tag);
+}

package/ui/src/ui/views/config.browser.test.ts

@@ -0,0 +1,233 @@
+import { render } from "lit";
+import { describe, expect, it, vi } from "vitest";
+import { renderConfig } from "./config.ts";
+
+describe("config view", () => {
+  const baseProps = () => ({
+    raw: "{\n}\n",
+    originalRaw: "{\n}\n",
+    valid: true,
+    issues: [],
+    loading: false,
+    saving: false,
+    applying: false,
+    updating: false,
+    connected: true,
+    schema: {
+      type: "object",
+      properties: {},
+    },
+    schemaLoading: false,
+    uiHints: {},
+    formMode: "form" as const,
+    formValue: {},
+    originalValue: {},
+    searchQuery: "",
+    activeSection: null,
+    activeSubsection: null,
+    onRawChange: vi.fn(),
+    onFormModeChange: vi.fn(),
+    onFormPatch: vi.fn(),
+    onSearchChange: vi.fn(),
+    onSectionChange: vi.fn(),
+    onReload: vi.fn(),
+    onSave: vi.fn(),
+    onApply: vi.fn(),
+    onUpdate: vi.fn(),
+    onSubsectionChange: vi.fn(),
+  });
+
+  function findActionButtons(container: HTMLElement): {
+    saveButton?: HTMLButtonElement;
+    applyButton?: HTMLButtonElement;
+  } {
+    const buttons = Array.from(container.querySelectorAll("button"));
+    return {
+      saveButton: buttons.find((btn) => btn.textContent?.trim() === "Save"),
+      applyButton: buttons.find((btn) => btn.textContent?.trim() === "Apply"),
+    };
+  }
+
+  it("allows save when form is unsafe", () => {
+    const container = document.createElement("div");
+    render(
+      renderConfig({
+        ...baseProps(),
+        schema: {
+          type: "object",
+          properties: {
+            mixed: {
+              anyOf: [{ type: "string" }, { type: "object", properties: {} }],
+            },
+          },
+        },
+        schemaLoading: false,
+        uiHints: {},
+        formMode: "form",
+        formValue: { mixed: "x" },
+      }),
+      container,
+    );
+
+    const saveButton = Array.from(container.querySelectorAll("button")).find(
+      (btn) => btn.textContent?.trim() === "Save",
+    );
+    expect(saveButton).not.toBeUndefined();
+    expect(saveButton?.disabled).toBe(false);
+  });
+
+  it("disables save when schema is missing", () => {
+    const container = document.createElement("div");
+    render(
+      renderConfig({
+        ...baseProps(),
+        schema: null,
+        formMode: "form",
+        formValue: { gateway: { mode: "local" } },
+        originalValue: {},
+      }),
+      container,
+    );
+
+    const saveButton = Array.from(container.querySelectorAll("button")).find(
+      (btn) => btn.textContent?.trim() === "Save",
+    );
+    expect(saveButton).not.toBeUndefined();
+    expect(saveButton?.disabled).toBe(true);
+  });
+
+  it("disables save and apply when raw is unchanged", () => {
+    const container = document.createElement("div");
+    render(
+      renderConfig({
+        ...baseProps(),
+        formMode: "raw",
+        raw: "{\n}\n",
+        originalRaw: "{\n}\n",
+      }),
+      container,
+    );
+
+    const { saveButton, applyButton } = findActionButtons(container);
+    expect(saveButton).not.toBeUndefined();
+    expect(applyButton).not.toBeUndefined();
+    expect(saveButton?.disabled).toBe(true);
+    expect(applyButton?.disabled).toBe(true);
+  });
+
+  it("enables save and apply when raw changes", () => {
+    const container = document.createElement("div");
+    render(
+      renderConfig({
+        ...baseProps(),
+        formMode: "raw",
+        raw: '{\n  gateway: { mode: "local" }\n}\n',
+        originalRaw: "{\n}\n",
+      }),
+      container,
+    );
+
+    const { saveButton, applyButton } = findActionButtons(container);
+    expect(saveButton).not.toBeUndefined();
+    expect(applyButton).not.toBeUndefined();
+    expect(saveButton?.disabled).toBe(false);
+    expect(applyButton?.disabled).toBe(false);
+  });
+
+  it("switches mode via the sidebar toggle", () => {
+    const container = document.createElement("div");
+    const onFormModeChange = vi.fn();
+    render(
+      renderConfig({
+        ...baseProps(),
+        onFormModeChange,
+      }),
+      container,
+    );
+
+    const btn = Array.from(container.querySelectorAll("button")).find(
+      (b) => b.textContent?.trim() === "Raw",
+    );
+    expect(btn).toBeTruthy();
+    btn?.click();
+    expect(onFormModeChange).toHaveBeenCalledWith("raw");
+  });
+
+  it("switches sections from the sidebar", () => {
+    const container = document.createElement("div");
+    const onSectionChange = vi.fn();
+    render(
+      renderConfig({
+        ...baseProps(),
+        onSectionChange,
+        schema: {
+          type: "object",
+          properties: {
+            gateway: { type: "object", properties: {} },
+            agents: { type: "object", properties: {} },
+          },
+        },
+      }),
+      container,
+    );
+
+    const btn = Array.from(container.querySelectorAll("button")).find(
+      (b) => b.textContent?.trim() === "Gateway",
+    );
+    expect(btn).toBeTruthy();
+    btn?.click();
+    expect(onSectionChange).toHaveBeenCalledWith("gateway");
+  });
+
+  it("wires search input to onSearchChange", () => {
+    const container = document.createElement("div");
+    const onSearchChange = vi.fn();
+    render(
+      renderConfig({
+        ...baseProps(),
+        onSearchChange,
+      }),
+      container,
+    );
+
+    const input = container.querySelector(".config-search__input");
+    expect(input).not.toBeNull();
+    if (!input) {
+      return;
+    }
+    (input as HTMLInputElement).value = "gateway";
+    input.dispatchEvent(new Event("input", { bubbles: true }));
+    expect(onSearchChange).toHaveBeenCalledWith("gateway");
+  });
+
+  it("shows all tag options in compact tag picker", () => {
+    const container = document.createElement("div");
+    render(renderConfig(baseProps()), container);
+
+    const options = Array.from(container.querySelectorAll(".config-search__tag-option")).map(
+      (option) => option.textContent?.trim(),
+    );
+    expect(options).toContain("tag:security");
+    expect(options).toContain("tag:advanced");
+    expect(options).toHaveLength(15);
+  });
+
+  it("updates search query when toggling a tag option", () => {
+    const container = document.createElement("div");
+    const onSearchChange = vi.fn();
+    render(
+      renderConfig({
+        ...baseProps(),
+        onSearchChange,
+      }),
+      container,
+    );
+
+    const option = container.querySelector<HTMLButtonElement>(
+      '.config-search__tag-option[data-tag="security"]',
+    );
+    expect(option).toBeTruthy();
+    option?.click();
+    expect(onSearchChange).toHaveBeenCalledWith("tag:security");
+  });
+});