openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/app-gateway.ts

@@ -0,0 +1,349 @@
+import {
+  GATEWAY_EVENT_UPDATE_AVAILABLE,
+  type GatewayUpdateAvailableEventPayload,
+} from "../../../src/gateway/events.js";
+import { CHAT_SESSIONS_ACTIVE_MINUTES, flushChatQueueForEvent } from "./app-chat.ts";
+import type { EventLogEntry } from "./app-events.ts";
+import {
+  applySettings,
+  loadCron,
+  refreshActiveTab,
+  setLastActiveSessionKey,
+} from "./app-settings.ts";
+import { handleAgentEvent, resetToolStream, type AgentEventPayload } from "./app-tool-stream.ts";
+import type { OpenClawApp } from "./app.ts";
+import { shouldReloadHistoryForFinalEvent } from "./chat-event-reload.ts";
+import { loadAgents, loadToolsCatalog } from "./controllers/agents.ts";
+import { loadAssistantIdentity } from "./controllers/assistant-identity.ts";
+import { loadChatHistory } from "./controllers/chat.ts";
+import { handleChatEvent, type ChatEventPayload } from "./controllers/chat.ts";
+import { loadDevices } from "./controllers/devices.ts";
+import type { ExecApprovalRequest } from "./controllers/exec-approval.ts";
+import {
+  addExecApproval,
+  parseExecApprovalRequested,
+  parseExecApprovalResolved,
+  removeExecApproval,
+} from "./controllers/exec-approval.ts";
+import { loadNodes } from "./controllers/nodes.ts";
+import { loadSessions } from "./controllers/sessions.ts";
+import {
+  resolveGatewayErrorDetailCode,
+  type GatewayEventFrame,
+  type GatewayHelloOk,
+} from "./gateway.ts";
+import { GatewayBrowserClient } from "./gateway.ts";
+import type { Tab } from "./navigation.ts";
+import type { UiSettings } from "./storage.ts";
+import type {
+  AgentsListResult,
+  PresenceEntry,
+  HealthSnapshot,
+  StatusSummary,
+  UpdateAvailable,
+} from "./types.ts";
+
+type GatewayHost = {
+  settings: UiSettings;
+  password: string;
+  clientInstanceId: string;
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  hello: GatewayHelloOk | null;
+  lastError: string | null;
+  lastErrorCode: string | null;
+  onboarding?: boolean;
+  eventLogBuffer: EventLogEntry[];
+  eventLog: EventLogEntry[];
+  tab: Tab;
+  presenceEntries: PresenceEntry[];
+  presenceError: string | null;
+  presenceStatus: StatusSummary | null;
+  agentsLoading: boolean;
+  agentsList: AgentsListResult | null;
+  agentsError: string | null;
+  toolsCatalogLoading: boolean;
+  toolsCatalogError: string | null;
+  toolsCatalogResult: import("./types.ts").ToolsCatalogResult | null;
+  debugHealth: HealthSnapshot | null;
+  assistantName: string;
+  assistantAvatar: string | null;
+  assistantAgentId: string | null;
+  sessionKey: string;
+  chatRunId: string | null;
+  refreshSessionsAfterChat: Set<string>;
+  execApprovalQueue: ExecApprovalRequest[];
+  execApprovalError: string | null;
+  updateAvailable: UpdateAvailable | null;
+};
+
+type SessionDefaultsSnapshot = {
+  defaultAgentId?: string;
+  mainKey?: string;
+  mainSessionKey?: string;
+  scope?: string;
+};
+
+function normalizeSessionKeyForDefaults(
+  value: string | undefined,
+  defaults: SessionDefaultsSnapshot,
+): string {
+  const raw = (value ?? "").trim();
+  const mainSessionKey = defaults.mainSessionKey?.trim();
+  if (!mainSessionKey) {
+    return raw;
+  }
+  if (!raw) {
+    return mainSessionKey;
+  }
+  const mainKey = defaults.mainKey?.trim() || "main";
+  const defaultAgentId = defaults.defaultAgentId?.trim();
+  const isAlias =
+    raw === "main" ||
+    raw === mainKey ||
+    (defaultAgentId &&
+      (raw === `agent:${defaultAgentId}:main` || raw === `agent:${defaultAgentId}:${mainKey}`));
+  return isAlias ? mainSessionKey : raw;
+}
+
+function applySessionDefaults(host: GatewayHost, defaults?: SessionDefaultsSnapshot) {
+  if (!defaults?.mainSessionKey) {
+    return;
+  }
+  const resolvedSessionKey = normalizeSessionKeyForDefaults(host.sessionKey, defaults);
+  const resolvedSettingsSessionKey = normalizeSessionKeyForDefaults(
+    host.settings.sessionKey,
+    defaults,
+  );
+  const resolvedLastActiveSessionKey = normalizeSessionKeyForDefaults(
+    host.settings.lastActiveSessionKey,
+    defaults,
+  );
+  const nextSessionKey = resolvedSessionKey || resolvedSettingsSessionKey || host.sessionKey;
+  const nextSettings = {
+    ...host.settings,
+    sessionKey: resolvedSettingsSessionKey || nextSessionKey,
+    lastActiveSessionKey: resolvedLastActiveSessionKey || nextSessionKey,
+  };
+  const shouldUpdateSettings =
+    nextSettings.sessionKey !== host.settings.sessionKey ||
+    nextSettings.lastActiveSessionKey !== host.settings.lastActiveSessionKey;
+  if (nextSessionKey !== host.sessionKey) {
+    host.sessionKey = nextSessionKey;
+  }
+  if (shouldUpdateSettings) {
+    applySettings(host as unknown as Parameters<typeof applySettings>[0], nextSettings);
+  }
+}
+
+export function connectGateway(host: GatewayHost) {
+  host.lastError = null;
+  host.lastErrorCode = null;
+  host.hello = null;
+  host.connected = false;
+  host.execApprovalQueue = [];
+  host.execApprovalError = null;
+
+  const previousClient = host.client;
+  const client = new GatewayBrowserClient({
+    url: host.settings.gatewayUrl,
+    token: host.settings.token.trim() ? host.settings.token : undefined,
+    password: host.password.trim() ? host.password : undefined,
+    clientName: "openclaw-control-ui",
+    mode: "webchat",
+    instanceId: host.clientInstanceId,
+    onHello: (hello) => {
+      if (host.client !== client) {
+        return;
+      }
+      host.connected = true;
+      host.lastError = null;
+      host.lastErrorCode = null;
+      host.hello = hello;
+      applySnapshot(host, hello);
+      // Reset orphaned chat run state from before disconnect.
+      // Any in-flight run's final event was lost during the disconnect window.
+      host.chatRunId = null;
+      (host as unknown as { chatStream: string | null }).chatStream = null;
+      (host as unknown as { chatStreamStartedAt: number | null }).chatStreamStartedAt = null;
+      resetToolStream(host as unknown as Parameters<typeof resetToolStream>[0]);
+      void loadAssistantIdentity(host as unknown as OpenClawApp);
+      void loadAgents(host as unknown as OpenClawApp);
+      void loadToolsCatalog(host as unknown as OpenClawApp);
+      void loadNodes(host as unknown as OpenClawApp, { quiet: true });
+      void loadDevices(host as unknown as OpenClawApp, { quiet: true });
+      void refreshActiveTab(host as unknown as Parameters<typeof refreshActiveTab>[0]);
+    },
+    onClose: ({ code, reason, error }) => {
+      if (host.client !== client) {
+        return;
+      }
+      host.connected = false;
+      // Code 1012 = Service Restart (expected during config saves, don't show as error)
+      host.lastErrorCode =
+        resolveGatewayErrorDetailCode(error) ??
+        (typeof error?.code === "string" ? error.code : null);
+      if (code !== 1012) {
+        if (error?.message) {
+          host.lastError = error.message;
+          return;
+        }
+        host.lastError = `disconnected (${code}): ${reason || "no reason"}`;
+      } else {
+        host.lastError = null;
+        host.lastErrorCode = null;
+      }
+    },
+    onEvent: (evt) => {
+      if (host.client !== client) {
+        return;
+      }
+      handleGatewayEvent(host, evt);
+    },
+    onGap: ({ expected, received }) => {
+      if (host.client !== client) {
+        return;
+      }
+      host.lastError = `event gap detected (expected seq ${expected}, got ${received}); refresh recommended`;
+      host.lastErrorCode = null;
+    },
+  });
+  host.client = client;
+  previousClient?.stop();
+  client.start();
+}
+
+export function handleGatewayEvent(host: GatewayHost, evt: GatewayEventFrame) {
+  try {
+    handleGatewayEventUnsafe(host, evt);
+  } catch (err) {
+    console.error("[gateway] handleGatewayEvent error:", evt.event, err);
+  }
+}
+
+function handleTerminalChatEvent(
+  host: GatewayHost,
+  payload: ChatEventPayload | undefined,
+  state: ReturnType<typeof handleChatEvent>,
+) {
+  if (state !== "final" && state !== "error" && state !== "aborted") {
+    return;
+  }
+  resetToolStream(host as unknown as Parameters<typeof resetToolStream>[0]);
+  void flushChatQueueForEvent(host as unknown as Parameters<typeof flushChatQueueForEvent>[0]);
+  const runId = payload?.runId;
+  if (!runId || !host.refreshSessionsAfterChat.has(runId)) {
+    return;
+  }
+  host.refreshSessionsAfterChat.delete(runId);
+  if (state === "final") {
+    void loadSessions(host as unknown as OpenClawApp, {
+      activeMinutes: CHAT_SESSIONS_ACTIVE_MINUTES,
+    });
+  }
+}
+
+function handleChatGatewayEvent(host: GatewayHost, payload: ChatEventPayload | undefined) {
+  if (payload?.sessionKey) {
+    setLastActiveSessionKey(
+      host as unknown as Parameters<typeof setLastActiveSessionKey>[0],
+      payload.sessionKey,
+    );
+  }
+  const state = handleChatEvent(host as unknown as OpenClawApp, payload);
+  handleTerminalChatEvent(host, payload, state);
+  if (state === "final" && shouldReloadHistoryForFinalEvent(payload)) {
+    void loadChatHistory(host as unknown as OpenClawApp);
+  }
+}
+
+function handleGatewayEventUnsafe(host: GatewayHost, evt: GatewayEventFrame) {
+  host.eventLogBuffer = [
+    { ts: Date.now(), event: evt.event, payload: evt.payload },
+    ...host.eventLogBuffer,
+  ].slice(0, 250);
+  if (host.tab === "debug") {
+    host.eventLog = host.eventLogBuffer;
+  }
+
+  if (evt.event === "agent") {
+    if (host.onboarding) {
+      return;
+    }
+    handleAgentEvent(
+      host as unknown as Parameters<typeof handleAgentEvent>[0],
+      evt.payload as AgentEventPayload | undefined,
+    );
+    return;
+  }
+
+  if (evt.event === "chat") {
+    handleChatGatewayEvent(host, evt.payload as ChatEventPayload | undefined);
+    return;
+  }
+
+  if (evt.event === "presence") {
+    const payload = evt.payload as { presence?: PresenceEntry[] } | undefined;
+    if (payload?.presence && Array.isArray(payload.presence)) {
+      host.presenceEntries = payload.presence;
+      host.presenceError = null;
+      host.presenceStatus = null;
+    }
+    return;
+  }
+
+  if (evt.event === "cron" && host.tab === "cron") {
+    void loadCron(host as unknown as Parameters<typeof loadCron>[0]);
+  }
+
+  if (evt.event === "device.pair.requested" || evt.event === "device.pair.resolved") {
+    void loadDevices(host as unknown as OpenClawApp, { quiet: true });
+  }
+
+  if (evt.event === "exec.approval.requested") {
+    const entry = parseExecApprovalRequested(evt.payload);
+    if (entry) {
+      host.execApprovalQueue = addExecApproval(host.execApprovalQueue, entry);
+      host.execApprovalError = null;
+      const delay = Math.max(0, entry.expiresAtMs - Date.now() + 500);
+      window.setTimeout(() => {
+        host.execApprovalQueue = removeExecApproval(host.execApprovalQueue, entry.id);
+      }, delay);
+    }
+    return;
+  }
+
+  if (evt.event === "exec.approval.resolved") {
+    const resolved = parseExecApprovalResolved(evt.payload);
+    if (resolved) {
+      host.execApprovalQueue = removeExecApproval(host.execApprovalQueue, resolved.id);
+    }
+    return;
+  }
+
+  if (evt.event === GATEWAY_EVENT_UPDATE_AVAILABLE) {
+    const payload = evt.payload as GatewayUpdateAvailableEventPayload | undefined;
+    host.updateAvailable = payload?.updateAvailable ?? null;
+  }
+}
+
+export function applySnapshot(host: GatewayHost, hello: GatewayHelloOk) {
+  const snapshot = hello.snapshot as
+    | {
+        presence?: PresenceEntry[];
+        health?: HealthSnapshot;
+        sessionDefaults?: SessionDefaultsSnapshot;
+        updateAvailable?: UpdateAvailable;
+      }
+    | undefined;
+  if (snapshot?.presence && Array.isArray(snapshot.presence)) {
+    host.presenceEntries = snapshot.presence;
+  }
+  if (snapshot?.health) {
+    host.debugHealth = snapshot.health;
+  }
+  if (snapshot?.sessionDefaults) {
+    applySessionDefaults(host, snapshot.sessionDefaults);
+  }
+  host.updateAvailable = snapshot?.updateAvailable ?? null;
+}

package/ui/src/ui/app-lifecycle.node.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it, vi } from "vitest";
+import { handleDisconnected } from "./app-lifecycle.ts";
+
+function createHost() {
+  return {
+    basePath: "",
+    client: { stop: vi.fn() },
+    connected: true,
+    tab: "chat",
+    assistantName: "OpenClaw",
+    assistantAvatar: null,
+    assistantAgentId: null,
+    chatHasAutoScrolled: false,
+    chatManualRefreshInFlight: false,
+    chatLoading: false,
+    chatMessages: [],
+    chatToolMessages: [],
+    chatStream: null,
+    logsAutoFollow: false,
+    logsAtBottom: true,
+    logsEntries: [],
+    popStateHandler: vi.fn(),
+    topbarObserver: { disconnect: vi.fn() } as unknown as ResizeObserver,
+  };
+}
+
+describe("handleDisconnected", () => {
+  it("stops and clears gateway client on teardown", () => {
+    const removeSpy = vi.spyOn(window, "removeEventListener").mockImplementation(() => undefined);
+    const host = createHost();
+    const disconnectSpy = (
+      host.topbarObserver as unknown as { disconnect: ReturnType<typeof vi.fn> }
+    ).disconnect;
+
+    handleDisconnected(host as unknown as Parameters<typeof handleDisconnected>[0]);
+
+    expect(removeSpy).toHaveBeenCalledWith("popstate", host.popStateHandler);
+    expect(host.client).toBeNull();
+    expect(host.connected).toBe(false);
+    expect(disconnectSpy).toHaveBeenCalledTimes(1);
+    expect(host.topbarObserver).toBeNull();
+    removeSpy.mockRestore();
+  });
+});

package/ui/src/ui/app-lifecycle.ts

@@ -0,0 +1,109 @@
+import { connectGateway } from "./app-gateway.ts";
+import {
+  startLogsPolling,
+  startNodesPolling,
+  stopLogsPolling,
+  stopNodesPolling,
+  startDebugPolling,
+  stopDebugPolling,
+} from "./app-polling.ts";
+import { observeTopbar, scheduleChatScroll, scheduleLogsScroll } from "./app-scroll.ts";
+import {
+  applySettingsFromUrl,
+  attachThemeListener,
+  detachThemeListener,
+  inferBasePath,
+  syncTabWithLocation,
+  syncThemeWithSettings,
+} from "./app-settings.ts";
+import { loadControlUiBootstrapConfig } from "./controllers/control-ui-bootstrap.ts";
+import type { Tab } from "./navigation.ts";
+
+type LifecycleHost = {
+  basePath: string;
+  client?: { stop: () => void } | null;
+  connected?: boolean;
+  tab: Tab;
+  assistantName: string;
+  assistantAvatar: string | null;
+  assistantAgentId: string | null;
+  chatHasAutoScrolled: boolean;
+  chatManualRefreshInFlight: boolean;
+  chatLoading: boolean;
+  chatMessages: unknown[];
+  chatToolMessages: unknown[];
+  chatStream: string;
+  logsAutoFollow: boolean;
+  logsAtBottom: boolean;
+  logsEntries: unknown[];
+  popStateHandler: () => void;
+  topbarObserver: ResizeObserver | null;
+};
+
+export function handleConnected(host: LifecycleHost) {
+  host.basePath = inferBasePath();
+  void loadControlUiBootstrapConfig(host);
+  applySettingsFromUrl(host as unknown as Parameters<typeof applySettingsFromUrl>[0]);
+  syncTabWithLocation(host as unknown as Parameters<typeof syncTabWithLocation>[0], true);
+  syncThemeWithSettings(host as unknown as Parameters<typeof syncThemeWithSettings>[0]);
+  attachThemeListener(host as unknown as Parameters<typeof attachThemeListener>[0]);
+  window.addEventListener("popstate", host.popStateHandler);
+  connectGateway(host as unknown as Parameters<typeof connectGateway>[0]);
+  startNodesPolling(host as unknown as Parameters<typeof startNodesPolling>[0]);
+  if (host.tab === "logs") {
+    startLogsPolling(host as unknown as Parameters<typeof startLogsPolling>[0]);
+  }
+  if (host.tab === "debug") {
+    startDebugPolling(host as unknown as Parameters<typeof startDebugPolling>[0]);
+  }
+}
+
+export function handleFirstUpdated(host: LifecycleHost) {
+  observeTopbar(host as unknown as Parameters<typeof observeTopbar>[0]);
+}
+
+export function handleDisconnected(host: LifecycleHost) {
+  window.removeEventListener("popstate", host.popStateHandler);
+  stopNodesPolling(host as unknown as Parameters<typeof stopNodesPolling>[0]);
+  stopLogsPolling(host as unknown as Parameters<typeof stopLogsPolling>[0]);
+  stopDebugPolling(host as unknown as Parameters<typeof stopDebugPolling>[0]);
+  host.client?.stop();
+  host.client = null;
+  host.connected = false;
+  detachThemeListener(host as unknown as Parameters<typeof detachThemeListener>[0]);
+  host.topbarObserver?.disconnect();
+  host.topbarObserver = null;
+}
+
+export function handleUpdated(host: LifecycleHost, changed: Map<PropertyKey, unknown>) {
+  if (host.tab === "chat" && host.chatManualRefreshInFlight) {
+    return;
+  }
+  if (
+    host.tab === "chat" &&
+    (changed.has("chatMessages") ||
+      changed.has("chatToolMessages") ||
+      changed.has("chatStream") ||
+      changed.has("chatLoading") ||
+      changed.has("tab"))
+  ) {
+    const forcedByTab = changed.has("tab");
+    const forcedByLoad =
+      changed.has("chatLoading") && changed.get("chatLoading") === true && !host.chatLoading;
+    scheduleChatScroll(
+      host as unknown as Parameters<typeof scheduleChatScroll>[0],
+      forcedByTab || forcedByLoad || !host.chatHasAutoScrolled,
+    );
+  }
+  if (
+    host.tab === "logs" &&
+    (changed.has("logsEntries") || changed.has("logsAutoFollow") || changed.has("tab"))
+  ) {
+    if (host.logsAutoFollow && host.logsAtBottom) {
+      scheduleLogsScroll(
+        host as unknown as Parameters<typeof scheduleLogsScroll>[0],
+        changed.has("tab") || changed.has("logsAutoFollow"),
+      );
+    }
+  }
+}

package/ui/src/ui/app-polling.ts

@@ -0,0 +1,69 @@
+import type { OpenClawApp } from "./app.ts";
+import { loadDebug } from "./controllers/debug.ts";
+import { loadLogs } from "./controllers/logs.ts";
+import { loadNodes } from "./controllers/nodes.ts";
+
+type PollingHost = {
+  nodesPollInterval: number | null;
+  logsPollInterval: number | null;
+  debugPollInterval: number | null;
+  tab: string;
+};
+
+export function startNodesPolling(host: PollingHost) {
+  if (host.nodesPollInterval != null) {
+    return;
+  }
+  host.nodesPollInterval = window.setInterval(
+    () => void loadNodes(host as unknown as OpenClawApp, { quiet: true }),
+    5000,
+  );
+}
+
+export function stopNodesPolling(host: PollingHost) {
+  if (host.nodesPollInterval == null) {
+    return;
+  }
+  clearInterval(host.nodesPollInterval);
+  host.nodesPollInterval = null;
+}
+
+export function startLogsPolling(host: PollingHost) {
+  if (host.logsPollInterval != null) {
+    return;
+  }
+  host.logsPollInterval = window.setInterval(() => {
+    if (host.tab !== "logs") {
+      return;
+    }
+    void loadLogs(host as unknown as OpenClawApp, { quiet: true });
+  }, 2000);
+}
+
+export function stopLogsPolling(host: PollingHost) {
+  if (host.logsPollInterval == null) {
+    return;
+  }
+  clearInterval(host.logsPollInterval);
+  host.logsPollInterval = null;
+}
+
+export function startDebugPolling(host: PollingHost) {
+  if (host.debugPollInterval != null) {
+    return;
+  }
+  host.debugPollInterval = window.setInterval(() => {
+    if (host.tab !== "debug") {
+      return;
+    }
+    void loadDebug(host as unknown as OpenClawApp);
+  }, 3000);
+}
+
+export function stopDebugPolling(host: PollingHost) {
+  if (host.debugPollInterval == null) {
+    return;
+  }
+  clearInterval(host.debugPollInterval);
+  host.debugPollInterval = null;
+}