openclaw-multi-auto 1.3.7 → 1.3.8

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

@@ -0,0 +1,104 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { deleteSession, deleteSessionAndRefresh, type SessionsState } from "./sessions.ts";
+
+type RequestFn = (method: string, params?: unknown) => Promise<unknown>;
+
+function createState(request: RequestFn, overrides: Partial<SessionsState> = {}): SessionsState {
+  return {
+    client: { request } as unknown as SessionsState["client"],
+    connected: true,
+    sessionsLoading: false,
+    sessionsResult: null,
+    sessionsError: null,
+    sessionsFilterActive: "0",
+    sessionsFilterLimit: "0",
+    sessionsIncludeGlobal: true,
+    sessionsIncludeUnknown: true,
+    ...overrides,
+  };
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+describe("deleteSessionAndRefresh", () => {
+  it("refreshes sessions after a successful delete", async () => {
+    const request = vi.fn(async (method: string) => {
+      if (method === "sessions.delete") {
+        return { ok: true };
+      }
+      if (method === "sessions.list") {
+        return undefined;
+      }
+      throw new Error(`unexpected method: ${method}`);
+    });
+    const state = createState(request);
+    vi.spyOn(window, "confirm").mockReturnValue(true);
+
+    const deleted = await deleteSessionAndRefresh(state, "agent:main:test");
+
+    expect(deleted).toBe(true);
+    expect(request).toHaveBeenCalledTimes(2);
+    expect(request).toHaveBeenNthCalledWith(1, "sessions.delete", {
+      key: "agent:main:test",
+      deleteTranscript: true,
+    });
+    expect(request).toHaveBeenNthCalledWith(2, "sessions.list", {
+      includeGlobal: true,
+      includeUnknown: true,
+    });
+    expect(state.sessionsError).toBeNull();
+    expect(state.sessionsLoading).toBe(false);
+  });
+
+  it("does not refresh sessions when user cancels delete", async () => {
+    const request = vi.fn(async () => undefined);
+    const state = createState(request, { sessionsError: "existing error" });
+    vi.spyOn(window, "confirm").mockReturnValue(false);
+
+    const deleted = await deleteSessionAndRefresh(state, "agent:main:test");
+
+    expect(deleted).toBe(false);
+    expect(request).not.toHaveBeenCalled();
+    expect(state.sessionsError).toBe("existing error");
+    expect(state.sessionsLoading).toBe(false);
+  });
+
+  it("does not refresh sessions when delete fails and preserves the delete error", async () => {
+    const request = vi.fn(async (method: string) => {
+      if (method === "sessions.delete") {
+        throw new Error("delete boom");
+      }
+      if (method === "sessions.list") {
+        return undefined;
+      }
+      throw new Error(`unexpected method: ${method}`);
+    });
+    const state = createState(request);
+    vi.spyOn(window, "confirm").mockReturnValue(true);
+
+    const deleted = await deleteSessionAndRefresh(state, "agent:main:test");
+
+    expect(deleted).toBe(false);
+    expect(request).toHaveBeenCalledTimes(1);
+    expect(request).toHaveBeenCalledWith("sessions.delete", {
+      key: "agent:main:test",
+      deleteTranscript: true,
+    });
+    expect(state.sessionsError).toContain("delete boom");
+    expect(state.sessionsLoading).toBe(false);
+  });
+});
+
+describe("deleteSession", () => {
+  it("returns false when already loading", async () => {
+    const request = vi.fn(async () => undefined);
+    const state = createState(request, { sessionsLoading: true });
+
+    const deleted = await deleteSession(state, "agent:main:test");
+
+    expect(deleted).toBe(false);
+    expect(request).not.toHaveBeenCalled();
+  });
+});

package/ui/src/ui/controllers/sessions.ts

@@ -0,0 +1,127 @@
+import { toNumber } from "../format.ts";
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { SessionsListResult } from "../types.ts";
+
+export type SessionsState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  sessionsLoading: boolean;
+  sessionsResult: SessionsListResult | null;
+  sessionsError: string | null;
+  sessionsFilterActive: string;
+  sessionsFilterLimit: string;
+  sessionsIncludeGlobal: boolean;
+  sessionsIncludeUnknown: boolean;
+};
+
+export async function loadSessions(
+  state: SessionsState,
+  overrides?: {
+    activeMinutes?: number;
+    limit?: number;
+    includeGlobal?: boolean;
+    includeUnknown?: boolean;
+  },
+) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.sessionsLoading) {
+    return;
+  }
+  state.sessionsLoading = true;
+  state.sessionsError = null;
+  try {
+    const includeGlobal = overrides?.includeGlobal ?? state.sessionsIncludeGlobal;
+    const includeUnknown = overrides?.includeUnknown ?? state.sessionsIncludeUnknown;
+    const activeMinutes = overrides?.activeMinutes ?? toNumber(state.sessionsFilterActive, 0);
+    const limit = overrides?.limit ?? toNumber(state.sessionsFilterLimit, 0);
+    const params: Record<string, unknown> = {
+      includeGlobal,
+      includeUnknown,
+    };
+    if (activeMinutes > 0) {
+      params.activeMinutes = activeMinutes;
+    }
+    if (limit > 0) {
+      params.limit = limit;
+    }
+    const res = await state.client.request<SessionsListResult | undefined>("sessions.list", params);
+    if (res) {
+      state.sessionsResult = res;
+    }
+  } catch (err) {
+    state.sessionsError = String(err);
+  } finally {
+    state.sessionsLoading = false;
+  }
+}
+
+export async function patchSession(
+  state: SessionsState,
+  key: string,
+  patch: {
+    label?: string | null;
+    thinkingLevel?: string | null;
+    verboseLevel?: string | null;
+    reasoningLevel?: string | null;
+  },
+) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  const params: Record<string, unknown> = { key };
+  if ("label" in patch) {
+    params.label = patch.label;
+  }
+  if ("thinkingLevel" in patch) {
+    params.thinkingLevel = patch.thinkingLevel;
+  }
+  if ("verboseLevel" in patch) {
+    params.verboseLevel = patch.verboseLevel;
+  }
+  if ("reasoningLevel" in patch) {
+    params.reasoningLevel = patch.reasoningLevel;
+  }
+  try {
+    await state.client.request("sessions.patch", params);
+    await loadSessions(state);
+  } catch (err) {
+    state.sessionsError = String(err);
+  }
+}
+
+export async function deleteSession(state: SessionsState, key: string): Promise<boolean> {
+  if (!state.client || !state.connected) {
+    return false;
+  }
+  if (state.sessionsLoading) {
+    return false;
+  }
+  const confirmed = window.confirm(
+    `Delete session "${key}"?\n\nDeletes the session entry and archives its transcript.`,
+  );
+  if (!confirmed) {
+    return false;
+  }
+  state.sessionsLoading = true;
+  state.sessionsError = null;
+  try {
+    await state.client.request("sessions.delete", { key, deleteTranscript: true });
+    return true;
+  } catch (err) {
+    state.sessionsError = String(err);
+    return false;
+  } finally {
+    state.sessionsLoading = false;
+  }
+}
+
+export async function deleteSessionAndRefresh(state: SessionsState, key: string): Promise<boolean> {
+  const deleted = await deleteSession(state, key);
+  if (!deleted) {
+    return false;
+  }
+  await loadSessions(state);
+  return true;
+}

package/ui/src/ui/controllers/skills.ts

@@ -0,0 +1,157 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { SkillStatusReport } from "../types.ts";
+
+export type SkillsState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  skillsLoading: boolean;
+  skillsReport: SkillStatusReport | null;
+  skillsError: string | null;
+  skillsBusyKey: string | null;
+  skillEdits: Record<string, string>;
+  skillMessages: SkillMessageMap;
+};
+
+export type SkillMessage = {
+  kind: "success" | "error";
+  message: string;
+};
+
+export type SkillMessageMap = Record<string, SkillMessage>;
+
+type LoadSkillsOptions = {
+  clearMessages?: boolean;
+};
+
+function setSkillMessage(state: SkillsState, key: string, message?: SkillMessage) {
+  if (!key.trim()) {
+    return;
+  }
+  const next = { ...state.skillMessages };
+  if (message) {
+    next[key] = message;
+  } else {
+    delete next[key];
+  }
+  state.skillMessages = next;
+}
+
+function getErrorMessage(err: unknown) {
+  if (err instanceof Error) {
+    return err.message;
+  }
+  return String(err);
+}
+
+export async function loadSkills(state: SkillsState, options?: LoadSkillsOptions) {
+  if (options?.clearMessages && Object.keys(state.skillMessages).length > 0) {
+    state.skillMessages = {};
+  }
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.skillsLoading) {
+    return;
+  }
+  state.skillsLoading = true;
+  state.skillsError = null;
+  try {
+    const res = await state.client.request<SkillStatusReport | undefined>("skills.status", {});
+    if (res) {
+      state.skillsReport = res;
+    }
+  } catch (err) {
+    state.skillsError = getErrorMessage(err);
+  } finally {
+    state.skillsLoading = false;
+  }
+}
+
+export function updateSkillEdit(state: SkillsState, skillKey: string, value: string) {
+  state.skillEdits = { ...state.skillEdits, [skillKey]: value };
+}
+
+export async function updateSkillEnabled(state: SkillsState, skillKey: string, enabled: boolean) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.skillsBusyKey = skillKey;
+  state.skillsError = null;
+  try {
+    await state.client.request("skills.update", { skillKey, enabled });
+    await loadSkills(state);
+    setSkillMessage(state, skillKey, {
+      kind: "success",
+      message: enabled ? "Skill enabled" : "Skill disabled",
+    });
+  } catch (err) {
+    const message = getErrorMessage(err);
+    state.skillsError = message;
+    setSkillMessage(state, skillKey, {
+      kind: "error",
+      message,
+    });
+  } finally {
+    state.skillsBusyKey = null;
+  }
+}
+
+export async function saveSkillApiKey(state: SkillsState, skillKey: string) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.skillsBusyKey = skillKey;
+  state.skillsError = null;
+  try {
+    const apiKey = state.skillEdits[skillKey] ?? "";
+    await state.client.request("skills.update", { skillKey, apiKey });
+    await loadSkills(state);
+    setSkillMessage(state, skillKey, {
+      kind: "success",
+      message: "API key saved",
+    });
+  } catch (err) {
+    const message = getErrorMessage(err);
+    state.skillsError = message;
+    setSkillMessage(state, skillKey, {
+      kind: "error",
+      message,
+    });
+  } finally {
+    state.skillsBusyKey = null;
+  }
+}
+
+export async function installSkill(
+  state: SkillsState,
+  skillKey: string,
+  name: string,
+  installId: string,
+) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  state.skillsBusyKey = skillKey;
+  state.skillsError = null;
+  try {
+    const result = await state.client.request<{ message?: string }>("skills.install", {
+      name,
+      installId,
+      timeoutMs: 120000,
+    });
+    await loadSkills(state);
+    setSkillMessage(state, skillKey, {
+      kind: "success",
+      message: result?.message ?? "Installed",
+    });
+  } catch (err) {
+    const message = getErrorMessage(err);
+    state.skillsError = message;
+    setSkillMessage(state, skillKey, {
+      kind: "error",
+      message,
+    });
+  } finally {
+    state.skillsBusyKey = null;
+  }
+}

package/ui/src/ui/controllers/usage.node.test.ts

@@ -0,0 +1,181 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { __test, loadUsage, type UsageState } from "./usage.ts";
+
+type RequestFn = (method: string, params?: unknown) => Promise<unknown>;
+
+function createState(request: RequestFn, overrides: Partial<UsageState> = {}): UsageState {
+  return {
+    client: { request } as unknown as UsageState["client"],
+    connected: true,
+    usageLoading: false,
+    usageResult: null,
+    usageCostSummary: null,
+    usageError: null,
+    usageStartDate: "2026-02-16",
+    usageEndDate: "2026-02-16",
+    usageSelectedSessions: [],
+    usageSelectedDays: [],
+    usageTimeSeries: null,
+    usageTimeSeriesLoading: false,
+    usageTimeSeriesCursorStart: null,
+    usageTimeSeriesCursorEnd: null,
+    usageSessionLogs: null,
+    usageSessionLogsLoading: false,
+    usageTimeZone: "local",
+    ...overrides,
+  };
+}
+
+function expectSpecificTimezoneCalls(request: ReturnType<typeof vi.fn>, startCall: number): void {
+  expect(request).toHaveBeenNthCalledWith(startCall, "sessions.usage", {
+    startDate: "2026-02-16",
+    endDate: "2026-02-16",
+    mode: "specific",
+    utcOffset: "UTC+5:30",
+    limit: 1000,
+    includeContextWeight: true,
+  });
+  expect(request).toHaveBeenNthCalledWith(startCall + 1, "usage.cost", {
+    startDate: "2026-02-16",
+    endDate: "2026-02-16",
+    mode: "specific",
+    utcOffset: "UTC+5:30",
+  });
+}
+
+describe("usage controller date interpretation params", () => {
+  beforeEach(() => {
+    __test.resetLegacyUsageDateParamsCache();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("formats UTC offsets for whole and half-hour timezones", () => {
+    expect(__test.formatUtcOffset(240)).toBe("UTC-4");
+    expect(__test.formatUtcOffset(-330)).toBe("UTC+5:30");
+    expect(__test.formatUtcOffset(0)).toBe("UTC+0");
+  });
+
+  it("sends specific mode with browser offset when usage timezone is local", async () => {
+    const request = vi.fn(async () => ({}));
+    const state = createState(request, { usageTimeZone: "local" });
+    vi.spyOn(Date.prototype, "getTimezoneOffset").mockReturnValue(-330);
+
+    await loadUsage(state);
+
+    expectSpecificTimezoneCalls(request, 1);
+  });
+
+  it("sends utc mode without offset when usage timezone is utc", async () => {
+    const request = vi.fn(async () => ({}));
+    const state = createState(request, { usageTimeZone: "utc" });
+
+    await loadUsage(state);
+
+    expect(request).toHaveBeenNthCalledWith(1, "sessions.usage", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+      mode: "utc",
+      limit: 1000,
+      includeContextWeight: true,
+    });
+    expect(request).toHaveBeenNthCalledWith(2, "usage.cost", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+      mode: "utc",
+    });
+  });
+
+  it("captures useful error strings in loadUsage", async () => {
+    const request = vi.fn(async () => {
+      throw new Error("request failed");
+    });
+    const state = createState(request);
+
+    await loadUsage(state);
+
+    expect(state.usageError).toBe("request failed");
+  });
+
+  it("serializes non-Error objects without object-to-string coercion", () => {
+    expect(__test.toErrorMessage({ reason: "nope" })).toBe('{"reason":"nope"}');
+  });
+
+  it("falls back and remembers compatibility when sessions.usage rejects mode/utcOffset", async () => {
+    const storage = createStorageMock();
+    vi.stubGlobal("localStorage", storage as unknown as Storage);
+    vi.spyOn(Date.prototype, "getTimezoneOffset").mockReturnValue(-330);
+
+    const request = vi.fn(async (method: string, params?: unknown) => {
+      if (method === "sessions.usage") {
+        const record = (params ?? {}) as Record<string, unknown>;
+        if ("mode" in record || "utcOffset" in record) {
+          throw new Error(
+            "invalid sessions.usage params: at root: unexpected property 'mode'; at root: unexpected property 'utcOffset'",
+          );
+        }
+        return { sessions: [] };
+      }
+      return {};
+    });
+
+    const state = createState(request, {
+      usageTimeZone: "local",
+      settings: { gatewayUrl: "ws://127.0.0.1:18789" },
+    });
+
+    await loadUsage(state);
+
+    expectSpecificTimezoneCalls(request, 1);
+    expect(request).toHaveBeenNthCalledWith(3, "sessions.usage", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+      limit: 1000,
+      includeContextWeight: true,
+    });
+    expect(request).toHaveBeenNthCalledWith(4, "usage.cost", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+    });
+
+    // Subsequent loads for the same gateway should skip mode/utcOffset immediately.
+    await loadUsage(state);
+
+    expect(request).toHaveBeenNthCalledWith(5, "sessions.usage", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+      limit: 1000,
+      includeContextWeight: true,
+    });
+    expect(request).toHaveBeenNthCalledWith(6, "usage.cost", {
+      startDate: "2026-02-16",
+      endDate: "2026-02-16",
+    });
+
+    // Persisted flag should survive cache resets (simulating app reload).
+    __test.resetLegacyUsageDateParamsCache();
+    expect(__test.shouldSendLegacyDateInterpretation(state)).toBe(false);
+
+    vi.unstubAllGlobals();
+  });
+});
+
+function createStorageMock() {
+  const store = new Map<string, string>();
+  return {
+    getItem(key: string) {
+      return store.get(key) ?? null;
+    },
+    setItem(key: string, value: string) {
+      store.set(key, String(value));
+    },
+    removeItem(key: string) {
+      store.delete(key);
+    },
+    clear() {
+      store.clear();
+    },
+  };
+}