openclaw-multi-auto 1.3.6 → 1.3.8

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

@@ -0,0 +1,266 @@
+import { parseAgentSessionKey } from "../../../src/sessions/session-key-utils.js";
+import { scheduleChatScroll } from "./app-scroll.ts";
+import { setLastActiveSessionKey } from "./app-settings.ts";
+import { resetToolStream } from "./app-tool-stream.ts";
+import type { OpenClawApp } from "./app.ts";
+import { abortChatRun, loadChatHistory, sendChatMessage } from "./controllers/chat.ts";
+import { loadSessions } from "./controllers/sessions.ts";
+import type { GatewayHelloOk } from "./gateway.ts";
+import { normalizeBasePath } from "./navigation.ts";
+import type { ChatAttachment, ChatQueueItem } from "./ui-types.ts";
+import { generateUUID } from "./uuid.ts";
+
+export type ChatHost = {
+  connected: boolean;
+  chatMessage: string;
+  chatAttachments: ChatAttachment[];
+  chatQueue: ChatQueueItem[];
+  chatRunId: string | null;
+  chatSending: boolean;
+  sessionKey: string;
+  basePath: string;
+  hello: GatewayHelloOk | null;
+  chatAvatarUrl: string | null;
+  refreshSessionsAfterChat: Set<string>;
+};
+
+export const CHAT_SESSIONS_ACTIVE_MINUTES = 120;
+
+export function isChatBusy(host: ChatHost) {
+  return host.chatSending || Boolean(host.chatRunId);
+}
+
+export function isChatStopCommand(text: string) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "/stop") {
+    return true;
+  }
+  return (
+    normalized === "stop" ||
+    normalized === "esc" ||
+    normalized === "abort" ||
+    normalized === "wait" ||
+    normalized === "exit"
+  );
+}
+
+function isChatResetCommand(text: string) {
+  const trimmed = text.trim();
+  if (!trimmed) {
+    return false;
+  }
+  const normalized = trimmed.toLowerCase();
+  if (normalized === "/new" || normalized === "/reset") {
+    return true;
+  }
+  return normalized.startsWith("/new ") || normalized.startsWith("/reset ");
+}
+
+export async function handleAbortChat(host: ChatHost) {
+  if (!host.connected) {
+    return;
+  }
+  host.chatMessage = "";
+  await abortChatRun(host as unknown as OpenClawApp);
+}
+
+function enqueueChatMessage(
+  host: ChatHost,
+  text: string,
+  attachments?: ChatAttachment[],
+  refreshSessions?: boolean,
+) {
+  const trimmed = text.trim();
+  const hasAttachments = Boolean(attachments && attachments.length > 0);
+  if (!trimmed && !hasAttachments) {
+    return;
+  }
+  host.chatQueue = [
+    ...host.chatQueue,
+    {
+      id: generateUUID(),
+      text: trimmed,
+      createdAt: Date.now(),
+      attachments: hasAttachments ? attachments?.map((att) => ({ ...att })) : undefined,
+      refreshSessions,
+    },
+  ];
+}
+
+async function sendChatMessageNow(
+  host: ChatHost,
+  message: string,
+  opts?: {
+    previousDraft?: string;
+    restoreDraft?: boolean;
+    attachments?: ChatAttachment[];
+    previousAttachments?: ChatAttachment[];
+    restoreAttachments?: boolean;
+    refreshSessions?: boolean;
+  },
+) {
+  resetToolStream(host as unknown as Parameters<typeof resetToolStream>[0]);
+  const runId = await sendChatMessage(host as unknown as OpenClawApp, message, opts?.attachments);
+  const ok = Boolean(runId);
+  if (!ok && opts?.previousDraft != null) {
+    host.chatMessage = opts.previousDraft;
+  }
+  if (!ok && opts?.previousAttachments) {
+    host.chatAttachments = opts.previousAttachments;
+  }
+  if (ok) {
+    setLastActiveSessionKey(
+      host as unknown as Parameters<typeof setLastActiveSessionKey>[0],
+      host.sessionKey,
+    );
+  }
+  if (ok && opts?.restoreDraft && opts.previousDraft?.trim()) {
+    host.chatMessage = opts.previousDraft;
+  }
+  if (ok && opts?.restoreAttachments && opts.previousAttachments?.length) {
+    host.chatAttachments = opts.previousAttachments;
+  }
+  scheduleChatScroll(host as unknown as Parameters<typeof scheduleChatScroll>[0]);
+  if (ok && !host.chatRunId) {
+    void flushChatQueue(host);
+  }
+  if (ok && opts?.refreshSessions && runId) {
+    host.refreshSessionsAfterChat.add(runId);
+  }
+  return ok;
+}
+
+async function flushChatQueue(host: ChatHost) {
+  if (!host.connected || isChatBusy(host)) {
+    return;
+  }
+  const [next, ...rest] = host.chatQueue;
+  if (!next) {
+    return;
+  }
+  host.chatQueue = rest;
+  const ok = await sendChatMessageNow(host, next.text, {
+    attachments: next.attachments,
+    refreshSessions: next.refreshSessions,
+  });
+  if (!ok) {
+    host.chatQueue = [next, ...host.chatQueue];
+  }
+}
+
+export function removeQueuedMessage(host: ChatHost, id: string) {
+  host.chatQueue = host.chatQueue.filter((item) => item.id !== id);
+}
+
+export async function handleSendChat(
+  host: ChatHost,
+  messageOverride?: string,
+  opts?: { restoreDraft?: boolean },
+) {
+  if (!host.connected) {
+    return;
+  }
+  const previousDraft = host.chatMessage;
+  const message = (messageOverride ?? host.chatMessage).trim();
+  const attachments = host.chatAttachments ?? [];
+  const attachmentsToSend = messageOverride == null ? attachments : [];
+  const hasAttachments = attachmentsToSend.length > 0;
+
+  // Allow sending with just attachments (no message text required)
+  if (!message && !hasAttachments) {
+    return;
+  }
+
+  if (isChatStopCommand(message)) {
+    await handleAbortChat(host);
+    return;
+  }
+
+  const refreshSessions = isChatResetCommand(message);
+  if (messageOverride == null) {
+    host.chatMessage = "";
+    // Clear attachments when sending
+    host.chatAttachments = [];
+  }
+
+  if (isChatBusy(host)) {
+    enqueueChatMessage(host, message, attachmentsToSend, refreshSessions);
+    return;
+  }
+
+  await sendChatMessageNow(host, message, {
+    previousDraft: messageOverride == null ? previousDraft : undefined,
+    restoreDraft: Boolean(messageOverride && opts?.restoreDraft),
+    attachments: hasAttachments ? attachmentsToSend : undefined,
+    previousAttachments: messageOverride == null ? attachments : undefined,
+    restoreAttachments: Boolean(messageOverride && opts?.restoreDraft),
+    refreshSessions,
+  });
+}
+
+export async function refreshChat(host: ChatHost, opts?: { scheduleScroll?: boolean }) {
+  await Promise.all([
+    loadChatHistory(host as unknown as OpenClawApp),
+    loadSessions(host as unknown as OpenClawApp, {
+      activeMinutes: CHAT_SESSIONS_ACTIVE_MINUTES,
+    }),
+    refreshChatAvatar(host),
+  ]);
+  if (opts?.scheduleScroll !== false) {
+    scheduleChatScroll(host as unknown as Parameters<typeof scheduleChatScroll>[0]);
+  }
+}
+
+export const flushChatQueueForEvent = flushChatQueue;
+
+type SessionDefaultsSnapshot = {
+  defaultAgentId?: string;
+};
+
+function resolveAgentIdForSession(host: ChatHost): string | null {
+  const parsed = parseAgentSessionKey(host.sessionKey);
+  if (parsed?.agentId) {
+    return parsed.agentId;
+  }
+  const snapshot = host.hello?.snapshot as
+    | { sessionDefaults?: SessionDefaultsSnapshot }
+    | undefined;
+  const fallback = snapshot?.sessionDefaults?.defaultAgentId?.trim();
+  return fallback || "main";
+}
+
+function buildAvatarMetaUrl(basePath: string, agentId: string): string {
+  const base = normalizeBasePath(basePath);
+  const encoded = encodeURIComponent(agentId);
+  return base ? `${base}/avatar/${encoded}?meta=1` : `/avatar/${encoded}?meta=1`;
+}
+
+export async function refreshChatAvatar(host: ChatHost) {
+  if (!host.connected) {
+    host.chatAvatarUrl = null;
+    return;
+  }
+  const agentId = resolveAgentIdForSession(host);
+  if (!agentId) {
+    host.chatAvatarUrl = null;
+    return;
+  }
+  host.chatAvatarUrl = null;
+  const url = buildAvatarMetaUrl(host.basePath, agentId);
+  try {
+    const res = await fetch(url, { method: "GET" });
+    if (!res.ok) {
+      host.chatAvatarUrl = null;
+      return;
+    }
+    const data = (await res.json()) as { avatarUrl?: unknown };
+    const avatarUrl = typeof data.avatarUrl === "string" ? data.avatarUrl.trim() : "";
+    host.chatAvatarUrl = avatarUrl || null;
+  } catch {
+    host.chatAvatarUrl = null;
+  }
+}

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

@@ -0,0 +1,50 @@
+import type { LogLevel } from "./types.ts";
+import type { CronFormState } from "./ui-types.ts";
+
+export const DEFAULT_LOG_LEVEL_FILTERS: Record<LogLevel, boolean> = {
+  trace: true,
+  debug: true,
+  info: true,
+  warn: true,
+  error: true,
+  fatal: true,
+};
+
+export const DEFAULT_CRON_FORM: CronFormState = {
+  name: "",
+  description: "",
+  agentId: "",
+  sessionKey: "",
+  clearAgent: false,
+  enabled: true,
+  deleteAfterRun: true,
+  scheduleKind: "every",
+  scheduleAt: "",
+  everyAmount: "30",
+  everyUnit: "minutes",
+  cronExpr: "0 7 * * *",
+  cronTz: "",
+  scheduleExact: false,
+  staggerAmount: "",
+  staggerUnit: "seconds",
+  sessionTarget: "isolated",
+  wakeMode: "now",
+  payloadKind: "agentTurn",
+  payloadText: "",
+  payloadModel: "",
+  payloadThinking: "",
+  payloadLightContext: false,
+  deliveryMode: "announce",
+  deliveryChannel: "last",
+  deliveryTo: "",
+  deliveryAccountId: "",
+  deliveryBestEffort: false,
+  failureAlertMode: "inherit",
+  failureAlertAfter: "2",
+  failureAlertCooldownSeconds: "3600",
+  failureAlertChannel: "last",
+  failureAlertTo: "",
+  failureAlertDeliveryMode: "announce",
+  failureAlertAccountId: "",
+  timeoutSeconds: "",
+};

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

@@ -0,0 +1,5 @@
+export type EventLogEntry = {
+  ts: number;
+  event: string;
+  payload?: unknown;
+};

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

@@ -0,0 +1,229 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { GATEWAY_EVENT_UPDATE_AVAILABLE } from "../../../src/gateway/events.js";
+import { connectGateway } from "./app-gateway.ts";
+
+type GatewayClientMock = {
+  start: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+  emitClose: (info: {
+    code: number;
+    reason?: string;
+    error?: { code: string; message: string; details?: unknown };
+  }) => void;
+  emitGap: (expected: number, received: number) => void;
+  emitEvent: (evt: { event: string; payload?: unknown; seq?: number }) => void;
+};
+
+const gatewayClientInstances: GatewayClientMock[] = [];
+
+vi.mock("./gateway.ts", () => {
+  function resolveGatewayErrorDetailCode(
+    error: { details?: unknown } | null | undefined,
+  ): string | null {
+    const details = error?.details;
+    if (!details || typeof details !== "object") {
+      return null;
+    }
+    const code = (details as { code?: unknown }).code;
+    return typeof code === "string" ? code : null;
+  }
+
+  class GatewayBrowserClient {
+    readonly start = vi.fn();
+    readonly stop = vi.fn();
+
+    constructor(
+      private opts: {
+        onClose?: (info: {
+          code: number;
+          reason: string;
+          error?: { code: string; message: string; details?: unknown };
+        }) => void;
+        onGap?: (info: { expected: number; received: number }) => void;
+        onEvent?: (evt: { event: string; payload?: unknown; seq?: number }) => void;
+      },
+    ) {
+      gatewayClientInstances.push({
+        start: this.start,
+        stop: this.stop,
+        emitClose: (info) => {
+          this.opts.onClose?.({
+            code: info.code,
+            reason: info.reason ?? "",
+            error: info.error,
+          });
+        },
+        emitGap: (expected, received) => {
+          this.opts.onGap?.({ expected, received });
+        },
+        emitEvent: (evt) => {
+          this.opts.onEvent?.(evt);
+        },
+      });
+    }
+  }
+
+  return { GatewayBrowserClient, resolveGatewayErrorDetailCode };
+});
+
+function createHost() {
+  return {
+    settings: {
+      gatewayUrl: "ws://127.0.0.1:18789",
+      token: "",
+      sessionKey: "main",
+      lastActiveSessionKey: "main",
+      theme: "system",
+      chatFocusMode: false,
+      chatShowThinking: true,
+      splitRatio: 0.6,
+      navCollapsed: false,
+      navGroupsCollapsed: {},
+    },
+    password: "",
+    clientInstanceId: "instance-test",
+    client: null,
+    connected: false,
+    hello: null,
+    lastError: null,
+    lastErrorCode: null,
+    eventLogBuffer: [],
+    eventLog: [],
+    tab: "overview",
+    presenceEntries: [],
+    presenceError: null,
+    presenceStatus: null,
+    agentsLoading: false,
+    agentsList: null,
+    agentsError: null,
+    debugHealth: null,
+    assistantName: "OpenClaw",
+    assistantAvatar: null,
+    assistantAgentId: null,
+    sessionKey: "main",
+    chatRunId: null,
+    refreshSessionsAfterChat: new Set<string>(),
+    execApprovalQueue: [],
+    execApprovalError: null,
+    updateAvailable: null,
+  } as unknown as Parameters<typeof connectGateway>[0];
+}
+
+describe("connectGateway", () => {
+  beforeEach(() => {
+    gatewayClientInstances.length = 0;
+  });
+
+  it("ignores stale client onGap callbacks after reconnect", () => {
+    const host = createHost();
+
+    connectGateway(host);
+    const firstClient = gatewayClientInstances[0];
+    expect(firstClient).toBeDefined();
+
+    connectGateway(host);
+    const secondClient = gatewayClientInstances[1];
+    expect(secondClient).toBeDefined();
+
+    firstClient.emitGap(10, 13);
+    expect(host.lastError).toBeNull();
+
+    secondClient.emitGap(20, 24);
+    expect(host.lastError).toBe(
+      "event gap detected (expected seq 20, got 24); refresh recommended",
+    );
+  });
+
+  it("ignores stale client onEvent callbacks after reconnect", () => {
+    const host = createHost();
+
+    connectGateway(host);
+    const firstClient = gatewayClientInstances[0];
+    expect(firstClient).toBeDefined();
+
+    connectGateway(host);
+    const secondClient = gatewayClientInstances[1];
+    expect(secondClient).toBeDefined();
+
+    firstClient.emitEvent({ event: "presence", payload: { presence: [{ host: "stale" }] } });
+    expect(host.eventLogBuffer).toHaveLength(0);
+
+    secondClient.emitEvent({ event: "presence", payload: { presence: [{ host: "active" }] } });
+    expect(host.eventLogBuffer).toHaveLength(1);
+    expect(host.eventLogBuffer[0]?.event).toBe("presence");
+  });
+
+  it("applies update.available only from active client", () => {
+    const host = createHost();
+
+    connectGateway(host);
+    const firstClient = gatewayClientInstances[0];
+    expect(firstClient).toBeDefined();
+
+    connectGateway(host);
+    const secondClient = gatewayClientInstances[1];
+    expect(secondClient).toBeDefined();
+
+    firstClient.emitEvent({
+      event: GATEWAY_EVENT_UPDATE_AVAILABLE,
+      payload: {
+        updateAvailable: { currentVersion: "1.0.0", latestVersion: "9.9.9", channel: "latest" },
+      },
+    });
+    expect(host.updateAvailable).toBeNull();
+
+    secondClient.emitEvent({
+      event: GATEWAY_EVENT_UPDATE_AVAILABLE,
+      payload: {
+        updateAvailable: { currentVersion: "1.0.0", latestVersion: "2.0.0", channel: "latest" },
+      },
+    });
+    expect(host.updateAvailable).toEqual({
+      currentVersion: "1.0.0",
+      latestVersion: "2.0.0",
+      channel: "latest",
+    });
+  });
+
+  it("ignores stale client onClose callbacks after reconnect", () => {
+    const host = createHost();
+
+    connectGateway(host);
+    const firstClient = gatewayClientInstances[0];
+    expect(firstClient).toBeDefined();
+
+    connectGateway(host);
+    const secondClient = gatewayClientInstances[1];
+    expect(secondClient).toBeDefined();
+
+    firstClient.emitClose({ code: 1005 });
+    expect(host.lastError).toBeNull();
+    expect(host.lastErrorCode).toBeNull();
+
+    secondClient.emitClose({ code: 1005 });
+    expect(host.lastError).toBe("disconnected (1005): no reason");
+    expect(host.lastErrorCode).toBeNull();
+  });
+
+  it("prefers structured connect errors over close reason", () => {
+    const host = createHost();
+
+    connectGateway(host);
+    const client = gatewayClientInstances[0];
+    expect(client).toBeDefined();
+
+    client.emitClose({
+      code: 4008,
+      reason: "connect failed",
+      error: {
+        code: "INVALID_REQUEST",
+        message:
+          "unauthorized: gateway token mismatch (open the dashboard URL and paste the token in Control UI settings)",
+        details: { code: "AUTH_TOKEN_MISMATCH" },
+      },
+    });
+
+    expect(host.lastError).toContain("gateway token mismatch");
+    expect(host.lastErrorCode).toBe("AUTH_TOKEN_MISMATCH");
+  });
+});