openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/controllers/agent-identity.ts

@@ -0,0 +1,59 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { AgentIdentityResult } from "../types.ts";
+
+export type AgentIdentityState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  agentIdentityLoading: boolean;
+  agentIdentityError: string | null;
+  agentIdentityById: Record<string, AgentIdentityResult>;
+};
+
+export async function loadAgentIdentity(state: AgentIdentityState, agentId: string) {
+  if (!state.client || !state.connected || state.agentIdentityLoading) {
+    return;
+  }
+  if (state.agentIdentityById[agentId]) {
+    return;
+  }
+  state.agentIdentityLoading = true;
+  state.agentIdentityError = null;
+  try {
+    const res = await state.client.request<AgentIdentityResult | null>("agent.identity.get", {
+      agentId,
+    });
+    if (res) {
+      state.agentIdentityById = { ...state.agentIdentityById, [agentId]: res };
+    }
+  } catch (err) {
+    state.agentIdentityError = String(err);
+  } finally {
+    state.agentIdentityLoading = false;
+  }
+}
+
+export async function loadAgentIdentities(state: AgentIdentityState, agentIds: string[]) {
+  if (!state.client || !state.connected || state.agentIdentityLoading) {
+    return;
+  }
+  const missing = agentIds.filter((id) => !state.agentIdentityById[id]);
+  if (missing.length === 0) {
+    return;
+  }
+  state.agentIdentityLoading = true;
+  state.agentIdentityError = null;
+  try {
+    for (const agentId of missing) {
+      const res = await state.client.request<AgentIdentityResult | null>("agent.identity.get", {
+        agentId,
+      });
+      if (res) {
+        state.agentIdentityById = { ...state.agentIdentityById, [agentId]: res };
+      }
+    }
+  } catch (err) {
+    state.agentIdentityError = String(err);
+  } finally {
+    state.agentIdentityLoading = false;
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { SkillStatusReport } from "../types.ts";
+
+export type AgentSkillsState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  agentSkillsLoading: boolean;
+  agentSkillsError: string | null;
+  agentSkillsReport: SkillStatusReport | null;
+  agentSkillsAgentId: string | null;
+};
+
+export async function loadAgentSkills(state: AgentSkillsState, agentId: string) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.agentSkillsLoading) {
+    return;
+  }
+  state.agentSkillsLoading = true;
+  state.agentSkillsError = null;
+  try {
+    const res = await state.client.request("skills.status", { agentId });
+    if (res) {
+      state.agentSkillsReport = res as SkillStatusReport;
+      state.agentSkillsAgentId = agentId;
+    }
+  } catch (err) {
+    state.agentSkillsError = String(err);
+  } finally {
+    state.agentSkillsLoading = false;
+  }
+}

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

@@ -0,0 +1,61 @@
+import { describe, expect, it, vi } from "vitest";
+import { loadToolsCatalog } from "./agents.ts";
+import type { AgentsState } from "./agents.ts";
+
+function createState(): { state: AgentsState; request: ReturnType<typeof vi.fn> } {
+  const request = vi.fn();
+  const state: AgentsState = {
+    client: {
+      request,
+    } as unknown as AgentsState["client"],
+    connected: true,
+    agentsLoading: false,
+    agentsError: null,
+    agentsList: null,
+    agentsSelectedId: "main",
+    toolsCatalogLoading: false,
+    toolsCatalogError: null,
+    toolsCatalogResult: null,
+  };
+  return { state, request };
+}
+
+describe("loadToolsCatalog", () => {
+  it("loads catalog and stores result", async () => {
+    const { state, request } = createState();
+    const payload = {
+      agentId: "main",
+      profiles: [{ id: "full", label: "Full" }],
+      groups: [
+        {
+          id: "media",
+          label: "Media",
+          source: "core",
+          tools: [{ id: "tts", label: "tts", description: "Text-to-speech", source: "core" }],
+        },
+      ],
+    };
+    request.mockResolvedValue(payload);
+
+    await loadToolsCatalog(state, "main");
+
+    expect(request).toHaveBeenCalledWith("tools.catalog", {
+      agentId: "main",
+      includePlugins: true,
+    });
+    expect(state.toolsCatalogResult).toEqual(payload);
+    expect(state.toolsCatalogError).toBeNull();
+    expect(state.toolsCatalogLoading).toBe(false);
+  });
+
+  it("captures request errors for fallback UI handling", async () => {
+    const { state, request } = createState();
+    request.mockRejectedValue(new Error("gateway unavailable"));
+
+    await loadToolsCatalog(state, "main");
+
+    expect(state.toolsCatalogResult).toBeNull();
+    expect(state.toolsCatalogError).toContain("gateway unavailable");
+    expect(state.toolsCatalogLoading).toBe(false);
+  });
+});

package/ui/src/ui/controllers/agents.ts

@@ -0,0 +1,64 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { AgentsListResult, ToolsCatalogResult } from "../types.ts";
+
+export type AgentsState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  agentsLoading: boolean;
+  agentsError: string | null;
+  agentsList: AgentsListResult | null;
+  agentsSelectedId: string | null;
+  toolsCatalogLoading: boolean;
+  toolsCatalogError: string | null;
+  toolsCatalogResult: ToolsCatalogResult | null;
+};
+
+export async function loadAgents(state: AgentsState) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.agentsLoading) {
+    return;
+  }
+  state.agentsLoading = true;
+  state.agentsError = null;
+  try {
+    const res = await state.client.request<AgentsListResult>("agents.list", {});
+    if (res) {
+      state.agentsList = res;
+      const selected = state.agentsSelectedId;
+      const known = res.agents.some((entry) => entry.id === selected);
+      if (!selected || !known) {
+        state.agentsSelectedId = res.defaultId ?? res.agents[0]?.id ?? null;
+      }
+    }
+  } catch (err) {
+    state.agentsError = String(err);
+  } finally {
+    state.agentsLoading = false;
+  }
+}
+
+export async function loadToolsCatalog(state: AgentsState, agentId?: string | null) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.toolsCatalogLoading) {
+    return;
+  }
+  state.toolsCatalogLoading = true;
+  state.toolsCatalogError = null;
+  try {
+    const res = await state.client.request<ToolsCatalogResult>("tools.catalog", {
+      agentId: agentId ?? state.agentsSelectedId ?? undefined,
+      includePlugins: true,
+    });
+    if (res) {
+      state.toolsCatalogResult = res;
+    }
+  } catch (err) {
+    state.toolsCatalogError = String(err);
+  } finally {
+    state.toolsCatalogLoading = false;
+  }
+}

package/ui/src/ui/controllers/assistant-identity.ts

@@ -0,0 +1,34 @@
+import { normalizeAssistantIdentity } from "../assistant-identity.ts";
+import type { GatewayBrowserClient } from "../gateway.ts";
+
+export type AssistantIdentityState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  sessionKey: string;
+  assistantName: string;
+  assistantAvatar: string | null;
+  assistantAgentId: string | null;
+};
+
+export async function loadAssistantIdentity(
+  state: AssistantIdentityState,
+  opts?: { sessionKey?: string },
+) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  const sessionKey = opts?.sessionKey?.trim() || state.sessionKey.trim();
+  const params = sessionKey ? { sessionKey } : {};
+  try {
+    const res = await state.client.request("agent.identity.get", params);
+    if (!res) {
+      return;
+    }
+    const normalized = normalizeAssistantIdentity(res);
+    state.assistantName = normalized.name;
+    state.assistantAvatar = normalized.avatar;
+    state.assistantAgentId = normalized.agentId ?? null;
+  } catch {
+    // Ignore errors; keep last known identity.
+  }
+}

package/ui/src/ui/controllers/channels.ts

@@ -0,0 +1,94 @@
+import { ChannelsStatusSnapshot } from "../types.ts";
+import type { ChannelsState } from "./channels.types.ts";
+
+export type { ChannelsState };
+
+export async function loadChannels(state: ChannelsState, probe: boolean) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.channelsLoading) {
+    return;
+  }
+  state.channelsLoading = true;
+  state.channelsError = null;
+  try {
+    const res = await state.client.request<ChannelsStatusSnapshot | null>("channels.status", {
+      probe,
+      timeoutMs: 8000,
+    });
+    state.channelsSnapshot = res;
+    state.channelsLastSuccess = Date.now();
+  } catch (err) {
+    state.channelsError = String(err);
+  } finally {
+    state.channelsLoading = false;
+  }
+}
+
+export async function startWhatsAppLogin(state: ChannelsState, force: boolean) {
+  if (!state.client || !state.connected || state.whatsappBusy) {
+    return;
+  }
+  state.whatsappBusy = true;
+  try {
+    const res = await state.client.request<{ message?: string; qrDataUrl?: string }>(
+      "web.login.start",
+      {
+        force,
+        timeoutMs: 30000,
+      },
+    );
+    state.whatsappLoginMessage = res.message ?? null;
+    state.whatsappLoginQrDataUrl = res.qrDataUrl ?? null;
+    state.whatsappLoginConnected = null;
+  } catch (err) {
+    state.whatsappLoginMessage = String(err);
+    state.whatsappLoginQrDataUrl = null;
+    state.whatsappLoginConnected = null;
+  } finally {
+    state.whatsappBusy = false;
+  }
+}
+
+export async function waitWhatsAppLogin(state: ChannelsState) {
+  if (!state.client || !state.connected || state.whatsappBusy) {
+    return;
+  }
+  state.whatsappBusy = true;
+  try {
+    const res = await state.client.request<{ message?: string; connected?: boolean }>(
+      "web.login.wait",
+      {
+        timeoutMs: 120000,
+      },
+    );
+    state.whatsappLoginMessage = res.message ?? null;
+    state.whatsappLoginConnected = res.connected ?? null;
+    if (res.connected) {
+      state.whatsappLoginQrDataUrl = null;
+    }
+  } catch (err) {
+    state.whatsappLoginMessage = String(err);
+    state.whatsappLoginConnected = null;
+  } finally {
+    state.whatsappBusy = false;
+  }
+}
+
+export async function logoutWhatsApp(state: ChannelsState) {
+  if (!state.client || !state.connected || state.whatsappBusy) {
+    return;
+  }
+  state.whatsappBusy = true;
+  try {
+    await state.client.request("channels.logout", { channel: "whatsapp" });
+    state.whatsappLoginMessage = "Logged out.";
+    state.whatsappLoginQrDataUrl = null;
+    state.whatsappLoginConnected = null;
+  } catch (err) {
+    state.whatsappLoginMessage = String(err);
+  } finally {
+    state.whatsappBusy = false;
+  }
+}

package/ui/src/ui/controllers/channels.types.ts

@@ -0,0 +1,15 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { ChannelsStatusSnapshot } from "../types.ts";
+
+export type ChannelsState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  channelsLoading: boolean;
+  channelsSnapshot: ChannelsStatusSnapshot | null;
+  channelsError: string | null;
+  channelsLastSuccess: number | null;
+  whatsappLoginMessage: string | null;
+  whatsappLoginQrDataUrl: string | null;
+  whatsappLoginConnected: boolean | null;
+  whatsappBusy: boolean;
+};