openclaw-multi-auto 1.3.7 → 1.3.9

package/ui/src/ui/controllers/config.test.ts

@@ -0,0 +1,289 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  applyConfigSnapshot,
+  applyConfig,
+  runUpdate,
+  saveConfig,
+  updateConfigFormValue,
+  type ConfigState,
+} from "./config.ts";
+
+function createState(): ConfigState {
+  return {
+    applySessionKey: "main",
+    client: null,
+    configActiveSection: null,
+    configActiveSubsection: null,
+    configApplying: false,
+    configForm: null,
+    configFormDirty: false,
+    configFormMode: "form",
+    configFormOriginal: null,
+    configIssues: [],
+    configLoading: false,
+    configRaw: "",
+    configRawOriginal: "",
+    configSaving: false,
+    configSchema: null,
+    configSchemaLoading: false,
+    configSchemaVersion: null,
+    configSearchQuery: "",
+    configSnapshot: null,
+    configUiHints: {},
+    configValid: null,
+    connected: false,
+    lastError: null,
+    updateRunning: false,
+  };
+}
+
+function createRequestWithConfigGet() {
+  return vi.fn().mockImplementation(async (method: string) => {
+    if (method === "config.get") {
+      return { config: {}, valid: true, issues: [], raw: "{\n}\n" };
+    }
+    return {};
+  });
+}
+
+describe("applyConfigSnapshot", () => {
+  it("does not clobber form edits while dirty", () => {
+    const state = createState();
+    state.configFormMode = "form";
+    state.configFormDirty = true;
+    state.configForm = { gateway: { mode: "local", port: 18789 } };
+    state.configRaw = "{\n}\n";
+
+    applyConfigSnapshot(state, {
+      config: { gateway: { mode: "remote", port: 9999 } },
+      valid: true,
+      issues: [],
+      raw: '{\n  "gateway": { "mode": "remote", "port": 9999 }\n}\n',
+    });
+
+    expect(state.configRaw).toBe(
+      '{\n  "gateway": {\n    "mode": "local",\n    "port": 18789\n  }\n}\n',
+    );
+  });
+
+  it("updates config form when clean", () => {
+    const state = createState();
+    applyConfigSnapshot(state, {
+      config: { gateway: { mode: "local" } },
+      valid: true,
+      issues: [],
+      raw: "{}",
+    });
+
+    expect(state.configForm).toEqual({ gateway: { mode: "local" } });
+  });
+
+  it("sets configRawOriginal when clean for change detection", () => {
+    const state = createState();
+    applyConfigSnapshot(state, {
+      config: { gateway: { mode: "local" } },
+      valid: true,
+      issues: [],
+      raw: '{ "gateway": { "mode": "local" } }',
+    });
+
+    expect(state.configRawOriginal).toBe('{ "gateway": { "mode": "local" } }');
+    expect(state.configFormOriginal).toEqual({ gateway: { mode: "local" } });
+  });
+
+  it("preserves configRawOriginal when dirty", () => {
+    const state = createState();
+    state.configFormDirty = true;
+    state.configRawOriginal = '{ "original": true }';
+    state.configFormOriginal = { original: true };
+
+    applyConfigSnapshot(state, {
+      config: { gateway: { mode: "local" } },
+      valid: true,
+      issues: [],
+      raw: '{ "gateway": { "mode": "local" } }',
+    });
+
+    // Original values should be preserved when dirty
+    expect(state.configRawOriginal).toBe('{ "original": true }');
+    expect(state.configFormOriginal).toEqual({ original: true });
+  });
+});
+
+describe("updateConfigFormValue", () => {
+  it("seeds from snapshot when form is null", () => {
+    const state = createState();
+    state.configSnapshot = {
+      config: { channels: { telegram: { botToken: "t" } }, gateway: { mode: "local" } },
+      valid: true,
+      issues: [],
+      raw: "{}",
+    };
+
+    updateConfigFormValue(state, ["gateway", "port"], 18789);
+
+    expect(state.configFormDirty).toBe(true);
+    expect(state.configForm).toEqual({
+      channels: { telegram: { botToken: "t" } },
+      gateway: { mode: "local", port: 18789 },
+    });
+  });
+
+  it("keeps raw in sync while editing the form", () => {
+    const state = createState();
+    state.configSnapshot = {
+      config: { gateway: { mode: "local" } },
+      valid: true,
+      issues: [],
+      raw: "{\n}\n",
+    };
+
+    updateConfigFormValue(state, ["gateway", "port"], 18789);
+
+    expect(state.configRaw).toBe(
+      '{\n  "gateway": {\n    "mode": "local",\n    "port": 18789\n  }\n}\n',
+    );
+  });
+});
+
+describe("applyConfig", () => {
+  it("sends config.apply with raw and session key", async () => {
+    const request = vi.fn().mockResolvedValue({});
+    const state = createState();
+    state.connected = true;
+    state.client = { request } as unknown as ConfigState["client"];
+    state.applySessionKey = "agent:main:whatsapp:dm:+15555550123";
+    state.configFormMode = "raw";
+    state.configRaw = '{\n  agent: { workspace: "~/openclaw" }\n}\n';
+    state.configSnapshot = {
+      hash: "hash-123",
+    };
+
+    await applyConfig(state);
+
+    expect(request).toHaveBeenCalledWith("config.apply", {
+      raw: '{\n  agent: { workspace: "~/openclaw" }\n}\n',
+      baseHash: "hash-123",
+      sessionKey: "agent:main:whatsapp:dm:+15555550123",
+    });
+  });
+
+  it("coerces schema-typed values before config.apply in form mode", async () => {
+    const request = createRequestWithConfigGet();
+    const state = createState();
+    state.connected = true;
+    state.client = { request } as unknown as ConfigState["client"];
+    state.applySessionKey = "agent:main:web:dm:test";
+    state.configFormMode = "form";
+    state.configForm = {
+      gateway: { port: "18789", debug: "true" },
+    };
+    state.configSchema = {
+      type: "object",
+      properties: {
+        gateway: {
+          type: "object",
+          properties: {
+            port: { type: "number" },
+            debug: { type: "boolean" },
+          },
+        },
+      },
+    };
+    state.configSnapshot = { hash: "hash-apply-1" };
+
+    await applyConfig(state);
+
+    expect(request.mock.calls[0]?.[0]).toBe("config.apply");
+    const params = request.mock.calls[0]?.[1] as {
+      raw: string;
+      baseHash: string;
+      sessionKey: string;
+    };
+    const parsed = JSON.parse(params.raw) as {
+      gateway: { port: unknown; debug: unknown };
+    };
+    expect(typeof parsed.gateway.port).toBe("number");
+    expect(parsed.gateway.port).toBe(18789);
+    expect(parsed.gateway.debug).toBe(true);
+    expect(params.baseHash).toBe("hash-apply-1");
+    expect(params.sessionKey).toBe("agent:main:web:dm:test");
+  });
+});
+
+describe("saveConfig", () => {
+  it("coerces schema-typed values before config.set in form mode", async () => {
+    const request = createRequestWithConfigGet();
+    const state = createState();
+    state.connected = true;
+    state.client = { request } as unknown as ConfigState["client"];
+    state.configFormMode = "form";
+    state.configForm = {
+      gateway: { port: "18789", enabled: "false" },
+    };
+    state.configSchema = {
+      type: "object",
+      properties: {
+        gateway: {
+          type: "object",
+          properties: {
+            port: { type: "number" },
+            enabled: { type: "boolean" },
+          },
+        },
+      },
+    };
+    state.configSnapshot = { hash: "hash-save-1" };
+
+    await saveConfig(state);
+
+    expect(request.mock.calls[0]?.[0]).toBe("config.set");
+    const params = request.mock.calls[0]?.[1] as { raw: string; baseHash: string };
+    const parsed = JSON.parse(params.raw) as {
+      gateway: { port: unknown; enabled: unknown };
+    };
+    expect(typeof parsed.gateway.port).toBe("number");
+    expect(parsed.gateway.port).toBe(18789);
+    expect(parsed.gateway.enabled).toBe(false);
+    expect(params.baseHash).toBe("hash-save-1");
+  });
+
+  it("skips coercion when schema is not an object", async () => {
+    const request = createRequestWithConfigGet();
+    const state = createState();
+    state.connected = true;
+    state.client = { request } as unknown as ConfigState["client"];
+    state.configFormMode = "form";
+    state.configForm = {
+      gateway: { port: "18789" },
+    };
+    state.configSchema = "invalid-schema";
+    state.configSnapshot = { hash: "hash-save-2" };
+
+    await saveConfig(state);
+
+    expect(request.mock.calls[0]?.[0]).toBe("config.set");
+    const params = request.mock.calls[0]?.[1] as { raw: string; baseHash: string };
+    const parsed = JSON.parse(params.raw) as {
+      gateway: { port: unknown };
+    };
+    expect(parsed.gateway.port).toBe("18789");
+    expect(params.baseHash).toBe("hash-save-2");
+  });
+});
+
+describe("runUpdate", () => {
+  it("sends update.run with session key", async () => {
+    const request = vi.fn().mockResolvedValue({});
+    const state = createState();
+    state.connected = true;
+    state.client = { request } as unknown as ConfigState["client"];
+    state.applySessionKey = "agent:main:whatsapp:dm:+15555550123";
+
+    await runUpdate(state);
+
+    expect(request).toHaveBeenCalledWith("update.run", {
+      sessionKey: "agent:main:whatsapp:dm:+15555550123",
+    });
+  });
+});

package/ui/src/ui/controllers/config.ts

@@ -0,0 +1,219 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { ConfigSchemaResponse, ConfigSnapshot, ConfigUiHints } from "../types.ts";
+import type { JsonSchema } from "../views/config-form.shared.ts";
+import { coerceFormValues } from "./config/form-coerce.ts";
+import {
+  cloneConfigObject,
+  removePathValue,
+  serializeConfigForm,
+  setPathValue,
+} from "./config/form-utils.ts";
+
+export type ConfigState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  applySessionKey: string;
+  configLoading: boolean;
+  configRaw: string;
+  configRawOriginal: string;
+  configValid: boolean | null;
+  configIssues: unknown[];
+  configSaving: boolean;
+  configApplying: boolean;
+  updateRunning: boolean;
+  configSnapshot: ConfigSnapshot | null;
+  configSchema: unknown;
+  configSchemaVersion: string | null;
+  configSchemaLoading: boolean;
+  configUiHints: ConfigUiHints;
+  configForm: Record<string, unknown> | null;
+  configFormOriginal: Record<string, unknown> | null;
+  configFormDirty: boolean;
+  configFormMode: "form" | "raw";
+  configSearchQuery: string;
+  configActiveSection: string | null;
+  configActiveSubsection: string | null;
+  lastError: string | null;
+};
+
+export async function loadConfig(state: ConfigState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.configLoading = true;
+  state.lastError = null;
+  try {
+    const res = await state.client.request<ConfigSnapshot>("config.get", {});
+    applyConfigSnapshot(state, res);
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.configLoading = false;
+  }
+}
+
+export async function loadConfigSchema(state: ConfigState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.configSchemaLoading) {
+    return;
+  }
+  state.configSchemaLoading = true;
+  try {
+    const res = await state.client.request<ConfigSchemaResponse>("config.schema", {});
+    applyConfigSchema(state, res);
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.configSchemaLoading = false;
+  }
+}
+
+export function applyConfigSchema(state: ConfigState, res: ConfigSchemaResponse) {
+  state.configSchema = res.schema ?? null;
+  state.configUiHints = res.uiHints ?? {};
+  state.configSchemaVersion = res.version ?? null;
+}
+
+export function applyConfigSnapshot(state: ConfigState, snapshot: ConfigSnapshot) {
+  state.configSnapshot = snapshot;
+  const rawFromSnapshot =
+    typeof snapshot.raw === "string"
+      ? snapshot.raw
+      : snapshot.config && typeof snapshot.config === "object"
+        ? serializeConfigForm(snapshot.config)
+        : state.configRaw;
+  if (!state.configFormDirty || state.configFormMode === "raw") {
+    state.configRaw = rawFromSnapshot;
+  } else if (state.configForm) {
+    state.configRaw = serializeConfigForm(state.configForm);
+  } else {
+    state.configRaw = rawFromSnapshot;
+  }
+  state.configValid = typeof snapshot.valid === "boolean" ? snapshot.valid : null;
+  state.configIssues = Array.isArray(snapshot.issues) ? snapshot.issues : [];
+
+  if (!state.configFormDirty) {
+    state.configForm = cloneConfigObject(snapshot.config ?? {});
+    state.configFormOriginal = cloneConfigObject(snapshot.config ?? {});
+    state.configRawOriginal = rawFromSnapshot;
+  }
+}
+
+function asJsonSchema(value: unknown): JsonSchema | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  return value as JsonSchema;
+}
+
+/**
+ * Serialize the form state for submission to `config.set` / `config.apply`.
+ *
+ * HTML `<input>` elements produce string `.value` properties, so numeric and
+ * boolean config fields can leak into `configForm` as strings.  We coerce
+ * them back to their schema-defined types before JSON serialization so the
+ * gateway's Zod validation always sees correctly typed values.
+ */
+function serializeFormForSubmit(state: ConfigState): string {
+  if (state.configFormMode !== "form" || !state.configForm) {
+    return state.configRaw;
+  }
+  const schema = asJsonSchema(state.configSchema);
+  const form = schema
+    ? (coerceFormValues(state.configForm, schema) as Record<string, unknown>)
+    : state.configForm;
+  return serializeConfigForm(form);
+}
+
+export async function saveConfig(state: ConfigState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.configSaving = true;
+  state.lastError = null;
+  try {
+    const raw = serializeFormForSubmit(state);
+    const baseHash = state.configSnapshot?.hash;
+    if (!baseHash) {
+      state.lastError = "Config hash missing; reload and retry.";
+      return;
+    }
+    await state.client.request("config.set", { raw, baseHash });
+    state.configFormDirty = false;
+    await loadConfig(state);
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.configSaving = false;
+  }
+}
+
+export async function applyConfig(state: ConfigState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.configApplying = true;
+  state.lastError = null;
+  try {
+    const raw = serializeFormForSubmit(state);
+    const baseHash = state.configSnapshot?.hash;
+    if (!baseHash) {
+      state.lastError = "Config hash missing; reload and retry.";
+      return;
+    }
+    await state.client.request("config.apply", {
+      raw,
+      baseHash,
+      sessionKey: state.applySessionKey,
+    });
+    state.configFormDirty = false;
+    await loadConfig(state);
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.configApplying = false;
+  }
+}
+
+export async function runUpdate(state: ConfigState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.updateRunning = true;
+  state.lastError = null;
+  try {
+    await state.client.request("update.run", {
+      sessionKey: state.applySessionKey,
+    });
+  } catch (err) {
+    state.lastError = String(err);
+  } finally {
+    state.updateRunning = false;
+  }
+}
+
+export function updateConfigFormValue(
+  state: ConfigState,
+  path: Array<string | number>,
+  value: unknown,
+) {
+  const base = cloneConfigObject(state.configForm ?? state.configSnapshot?.config ?? {});
+  setPathValue(base, path, value);
+  state.configForm = base;
+  state.configFormDirty = true;
+  if (state.configFormMode === "form") {
+    state.configRaw = serializeConfigForm(base);
+  }
+}
+
+export function removeConfigFormValue(state: ConfigState, path: Array<string | number>) {
+  const base = cloneConfigObject(state.configForm ?? state.configSnapshot?.config ?? {});
+  removePathValue(base, path);
+  state.configForm = base;
+  state.configFormDirty = true;
+  if (state.configFormMode === "form") {
+    state.configRaw = serializeConfigForm(base);
+  }
+}

package/ui/src/ui/controllers/control-ui-bootstrap.test.ts

@@ -0,0 +1,82 @@
+/* @vitest-environment jsdom */
+
+import { describe, expect, it, vi } from "vitest";
+import { CONTROL_UI_BOOTSTRAP_CONFIG_PATH } from "../../../../src/gateway/control-ui-contract.js";
+import { loadControlUiBootstrapConfig } from "./control-ui-bootstrap.ts";
+
+describe("loadControlUiBootstrapConfig", () => {
+  it("loads assistant identity from the bootstrap endpoint", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        basePath: "/openclaw",
+        assistantName: "Ops",
+        assistantAvatar: "O",
+        assistantAgentId: "main",
+      }),
+    });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const state = {
+      basePath: "/openclaw",
+      assistantName: "Assistant",
+      assistantAvatar: null,
+      assistantAgentId: null,
+    };
+
+    await loadControlUiBootstrapConfig(state);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      `/openclaw${CONTROL_UI_BOOTSTRAP_CONFIG_PATH}`,
+      expect.objectContaining({ method: "GET" }),
+    );
+    expect(state.assistantName).toBe("Ops");
+    expect(state.assistantAvatar).toBe("O");
+    expect(state.assistantAgentId).toBe("main");
+
+    vi.unstubAllGlobals();
+  });
+
+  it("ignores failures", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: false });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const state = {
+      basePath: "",
+      assistantName: "Assistant",
+      assistantAvatar: null,
+      assistantAgentId: null,
+    };
+
+    await loadControlUiBootstrapConfig(state);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      CONTROL_UI_BOOTSTRAP_CONFIG_PATH,
+      expect.objectContaining({ method: "GET" }),
+    );
+    expect(state.assistantName).toBe("Assistant");
+
+    vi.unstubAllGlobals();
+  });
+
+  it("normalizes trailing slash basePath for bootstrap fetch path", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({ ok: false });
+    vi.stubGlobal("fetch", fetchMock as unknown as typeof fetch);
+
+    const state = {
+      basePath: "/openclaw/",
+      assistantName: "Assistant",
+      assistantAvatar: null,
+      assistantAgentId: null,
+    };
+
+    await loadControlUiBootstrapConfig(state);
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      `/openclaw${CONTROL_UI_BOOTSTRAP_CONFIG_PATH}`,
+      expect.objectContaining({ method: "GET" }),
+    );
+
+    vi.unstubAllGlobals();
+  });
+});

package/ui/src/ui/controllers/control-ui-bootstrap.ts

@@ -0,0 +1,49 @@
+import {
+  CONTROL_UI_BOOTSTRAP_CONFIG_PATH,
+  type ControlUiBootstrapConfig,
+} from "../../../../src/gateway/control-ui-contract.js";
+import { normalizeAssistantIdentity } from "../assistant-identity.ts";
+import { normalizeBasePath } from "../navigation.ts";
+
+export type ControlUiBootstrapState = {
+  basePath: string;
+  assistantName: string;
+  assistantAvatar: string | null;
+  assistantAgentId: string | null;
+};
+
+export async function loadControlUiBootstrapConfig(state: ControlUiBootstrapState) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (typeof fetch !== "function") {
+    return;
+  }
+
+  const basePath = normalizeBasePath(state.basePath ?? "");
+  const url = basePath
+    ? `${basePath}${CONTROL_UI_BOOTSTRAP_CONFIG_PATH}`
+    : CONTROL_UI_BOOTSTRAP_CONFIG_PATH;
+
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      credentials: "same-origin",
+    });
+    if (!res.ok) {
+      return;
+    }
+    const parsed = (await res.json()) as ControlUiBootstrapConfig;
+    const normalized = normalizeAssistantIdentity({
+      agentId: parsed.assistantAgentId ?? null,
+      name: parsed.assistantName,
+      avatar: parsed.assistantAvatar ?? null,
+    });
+    state.assistantName = normalized.name;
+    state.assistantAvatar = normalized.avatar;
+    state.assistantAgentId = normalized.agentId ?? null;
+  } catch {
+    // Ignore bootstrap failures; UI will update identity after connecting.
+  }
+}