openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/format.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { formatRelativeTimestamp, stripThinkingTags } from "./format.ts";
+
+describe("formatAgo", () => {
+  it("returns 'in <1m' for timestamps less than 60s in the future", () => {
+    expect(formatRelativeTimestamp(Date.now() + 30_000)).toBe("in <1m");
+  });
+
+  it("returns 'Xm from now' for future timestamps", () => {
+    expect(formatRelativeTimestamp(Date.now() + 5 * 60_000)).toBe("in 5m");
+  });
+
+  it("returns 'Xh from now' for future timestamps", () => {
+    expect(formatRelativeTimestamp(Date.now() + 3 * 60 * 60_000)).toBe("in 3h");
+  });
+
+  it("returns 'Xd from now' for future timestamps beyond 48h", () => {
+    expect(formatRelativeTimestamp(Date.now() + 3 * 24 * 60 * 60_000)).toBe("in 3d");
+  });
+
+  it("returns 'Xs ago' for recent past timestamps", () => {
+    expect(formatRelativeTimestamp(Date.now() - 10_000)).toBe("just now");
+  });
+
+  it("returns 'Xm ago' for past timestamps", () => {
+    expect(formatRelativeTimestamp(Date.now() - 5 * 60_000)).toBe("5m ago");
+  });
+
+  it("returns 'n/a' for null/undefined", () => {
+    expect(formatRelativeTimestamp(null)).toBe("n/a");
+    expect(formatRelativeTimestamp(undefined)).toBe("n/a");
+  });
+});
+
+describe("stripThinkingTags", () => {
+  it("strips <think>…</think> segments", () => {
+    const input = ["<think>", "secret", "</think>", "", "Hello"].join("\n");
+    expect(stripThinkingTags(input)).toBe("Hello");
+  });
+
+  it("strips <thinking>…</thinking> segments", () => {
+    const input = ["<thinking>", "secret", "</thinking>", "", "Hello"].join("\n");
+    expect(stripThinkingTags(input)).toBe("Hello");
+  });
+
+  it("keeps text when tags are unpaired", () => {
+    expect(stripThinkingTags("<think>\nsecret\nHello")).toBe("secret\nHello");
+    expect(stripThinkingTags("Hello\n</think>")).toBe("Hello\n");
+  });
+
+  it("returns original text when no tags exist", () => {
+    expect(stripThinkingTags("Hello")).toBe("Hello");
+  });
+
+  it("strips <final>…</final> segments", () => {
+    const input = "<final>\n\nHello there\n\n</final>";
+    expect(stripThinkingTags(input)).toBe("Hello there\n\n");
+  });
+
+  it("strips mixed <think> and <final> tags", () => {
+    const input = "<think>reasoning</think>\n\n<final>Hello</final>";
+    expect(stripThinkingTags(input)).toBe("Hello");
+  });
+
+  it("handles incomplete <final tag gracefully", () => {
+    // When streaming splits mid-tag, we may see "<final" without closing ">"
+    // This should not crash and should handle gracefully
+    expect(stripThinkingTags("<final\nHello")).toBe("<final\nHello");
+    expect(stripThinkingTags("Hello</final>")).toBe("Hello");
+  });
+
+  it("strips <relevant-memories> blocks", () => {
+    const input = [
+      "<relevant-memories>",
+      "The following memories may be relevant to this conversation:",
+      "- Internal memory note",
+      "</relevant-memories>",
+      "",
+      "User-visible answer",
+    ].join("\n");
+    expect(stripThinkingTags(input)).toBe("User-visible answer");
+  });
+
+  it("keeps relevant-memories tags in fenced code blocks", () => {
+    const input = [
+      "```xml",
+      "<relevant-memories>",
+      "sample",
+      "</relevant-memories>",
+      "```",
+      "",
+      "Visible text",
+    ].join("\n");
+    expect(stripThinkingTags(input)).toBe(input);
+  });
+
+  it("hides unfinished <relevant-memories> block tails", () => {
+    const input = ["Hello", "<relevant-memories>", "internal-only"].join("\n");
+    expect(stripThinkingTags(input)).toBe("Hello\n");
+  });
+});

package/ui/src/ui/format.ts

@@ -0,0 +1,60 @@
+import { formatDurationHuman } from "../../../src/infra/format-time/format-duration.ts";
+import { formatRelativeTimestamp } from "../../../src/infra/format-time/format-relative.ts";
+import { stripAssistantInternalScaffolding } from "../../../src/shared/text/assistant-visible-text.js";
+
+export { formatRelativeTimestamp, formatDurationHuman };
+
+export function formatMs(ms?: number | null): string {
+  if (!ms && ms !== 0) {
+    return "n/a";
+  }
+  return new Date(ms).toLocaleString();
+}
+
+export function formatList(values?: Array<string | null | undefined>): string {
+  if (!values || values.length === 0) {
+    return "none";
+  }
+  return values.filter((v): v is string => Boolean(v && v.trim())).join(", ");
+}
+
+export function clampText(value: string, max = 120): string {
+  if (value.length <= max) {
+    return value;
+  }
+  return `${value.slice(0, Math.max(0, max - 1))}…`;
+}
+
+export function truncateText(
+  value: string,
+  max: number,
+): {
+  text: string;
+  truncated: boolean;
+  total: number;
+} {
+  if (value.length <= max) {
+    return { text: value, truncated: false, total: value.length };
+  }
+  return {
+    text: value.slice(0, Math.max(0, max)),
+    truncated: true,
+    total: value.length,
+  };
+}
+
+export function toNumber(value: string, fallback: number): number {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}
+
+export function parseList(input: string): string[] {
+  return input
+    .split(/[,\n]/)
+    .map((v) => v.trim())
+    .filter((v) => v.length > 0);
+}
+
+export function stripThinkingTags(value: string): string {
+  return stripAssistantInternalScaffolding(value);
+}

package/ui/src/ui/gateway.ts

@@ -0,0 +1,360 @@
+import { buildDeviceAuthPayload } from "../../../src/gateway/device-auth.js";
+import {
+  GATEWAY_CLIENT_MODES,
+  GATEWAY_CLIENT_NAMES,
+  type GatewayClientMode,
+  type GatewayClientName,
+} from "../../../src/gateway/protocol/client-info.js";
+import { readConnectErrorDetailCode } from "../../../src/gateway/protocol/connect-error-details.js";
+import { clearDeviceAuthToken, loadDeviceAuthToken, storeDeviceAuthToken } from "./device-auth.ts";
+import { loadOrCreateDeviceIdentity, signDevicePayload } from "./device-identity.ts";
+import { generateUUID } from "./uuid.ts";
+
+export type GatewayEventFrame = {
+  type: "event";
+  event: string;
+  payload?: unknown;
+  seq?: number;
+  stateVersion?: { presence: number; health: number };
+};
+
+export type GatewayResponseFrame = {
+  type: "res";
+  id: string;
+  ok: boolean;
+  payload?: unknown;
+  error?: { code: string; message: string; details?: unknown };
+};
+
+export type GatewayErrorInfo = {
+  code: string;
+  message: string;
+  details?: unknown;
+};
+
+export class GatewayRequestError extends Error {
+  readonly gatewayCode: string;
+  readonly details?: unknown;
+
+  constructor(error: GatewayErrorInfo) {
+    super(error.message);
+    this.name = "GatewayRequestError";
+    this.gatewayCode = error.code;
+    this.details = error.details;
+  }
+}
+
+export function resolveGatewayErrorDetailCode(
+  error: { details?: unknown } | null | undefined,
+): string | null {
+  return readConnectErrorDetailCode(error?.details);
+}
+
+export type GatewayHelloOk = {
+  type: "hello-ok";
+  protocol: number;
+  server?: {
+    version?: string;
+    connId?: string;
+  };
+  features?: { methods?: string[]; events?: string[] };
+  snapshot?: unknown;
+  auth?: {
+    deviceToken?: string;
+    role?: string;
+    scopes?: string[];
+    issuedAtMs?: number;
+  };
+  policy?: { tickIntervalMs?: number };
+};
+
+type Pending = {
+  resolve: (value: unknown) => void;
+  reject: (err: unknown) => void;
+};
+
+export type GatewayBrowserClientOptions = {
+  url: string;
+  token?: string;
+  password?: string;
+  clientName?: GatewayClientName;
+  clientVersion?: string;
+  platform?: string;
+  mode?: GatewayClientMode;
+  instanceId?: string;
+  onHello?: (hello: GatewayHelloOk) => void;
+  onEvent?: (evt: GatewayEventFrame) => void;
+  onClose?: (info: { code: number; reason: string; error?: GatewayErrorInfo }) => void;
+  onGap?: (info: { expected: number; received: number }) => void;
+};
+
+// 4008 = application-defined code (browser rejects 1008 "Policy Violation")
+const CONNECT_FAILED_CLOSE_CODE = 4008;
+
+export class GatewayBrowserClient {
+  private ws: WebSocket | null = null;
+  private pending = new Map<string, Pending>();
+  private closed = false;
+  private lastSeq: number | null = null;
+  private connectNonce: string | null = null;
+  private connectSent = false;
+  private connectTimer: number | null = null;
+  private backoffMs = 800;
+  private pendingConnectError: GatewayErrorInfo | undefined;
+
+  constructor(private opts: GatewayBrowserClientOptions) {}
+
+  start() {
+    this.closed = false;
+    this.connect();
+  }
+
+  stop() {
+    this.closed = true;
+    this.ws?.close();
+    this.ws = null;
+    this.pendingConnectError = undefined;
+    this.flushPending(new Error("gateway client stopped"));
+  }
+
+  get connected() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+
+  private connect() {
+    if (this.closed) {
+      return;
+    }
+    this.ws = new WebSocket(this.opts.url);
+    this.ws.addEventListener("open", () => this.queueConnect());
+    this.ws.addEventListener("message", (ev) => this.handleMessage(String(ev.data ?? "")));
+    this.ws.addEventListener("close", (ev) => {
+      const reason = String(ev.reason ?? "");
+      const connectError = this.pendingConnectError;
+      this.pendingConnectError = undefined;
+      this.ws = null;
+      this.flushPending(new Error(`gateway closed (${ev.code}): ${reason}`));
+      this.opts.onClose?.({ code: ev.code, reason, error: connectError });
+      this.scheduleReconnect();
+    });
+    this.ws.addEventListener("error", () => {
+      // ignored; close handler will fire
+    });
+  }
+
+  private scheduleReconnect() {
+    if (this.closed) {
+      return;
+    }
+    const delay = this.backoffMs;
+    this.backoffMs = Math.min(this.backoffMs * 1.7, 15_000);
+    window.setTimeout(() => this.connect(), delay);
+  }
+
+  private flushPending(err: Error) {
+    for (const [, p] of this.pending) {
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+
+  private async sendConnect() {
+    if (this.connectSent) {
+      return;
+    }
+    this.connectSent = true;
+    if (this.connectTimer !== null) {
+      window.clearTimeout(this.connectTimer);
+      this.connectTimer = null;
+    }
+
+    // crypto.subtle is only available in secure contexts (HTTPS, localhost).
+    // Over plain HTTP, we skip device identity and fall back to token-only auth.
+    // Gateways may reject this unless gateway.controlUi.allowInsecureAuth is enabled.
+    const isSecureContext = typeof crypto !== "undefined" && !!crypto.subtle;
+
+    const scopes = ["operator.admin", "operator.approvals", "operator.pairing"];
+    const role = "operator";
+    let deviceIdentity: Awaited<ReturnType<typeof loadOrCreateDeviceIdentity>> | null = null;
+    let canFallbackToShared = false;
+    let authToken = this.opts.token;
+
+    if (isSecureContext) {
+      deviceIdentity = await loadOrCreateDeviceIdentity();
+      const storedToken = loadDeviceAuthToken({
+        deviceId: deviceIdentity.deviceId,
+        role,
+      })?.token;
+      authToken = storedToken ?? this.opts.token;
+      canFallbackToShared = Boolean(storedToken && this.opts.token);
+    }
+    const auth =
+      authToken || this.opts.password
+        ? {
+            token: authToken,
+            password: this.opts.password,
+          }
+        : undefined;
+
+    let device:
+      | {
+          id: string;
+          publicKey: string;
+          signature: string;
+          signedAt: number;
+          nonce: string;
+        }
+      | undefined;
+
+    if (isSecureContext && deviceIdentity) {
+      const signedAtMs = Date.now();
+      const nonce = this.connectNonce ?? "";
+      const payload = buildDeviceAuthPayload({
+        deviceId: deviceIdentity.deviceId,
+        clientId: this.opts.clientName ?? GATEWAY_CLIENT_NAMES.CONTROL_UI,
+        clientMode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
+        role,
+        scopes,
+        signedAtMs,
+        token: authToken ?? null,
+        nonce,
+      });
+      const signature = await signDevicePayload(deviceIdentity.privateKey, payload);
+      device = {
+        id: deviceIdentity.deviceId,
+        publicKey: deviceIdentity.publicKey,
+        signature,
+        signedAt: signedAtMs,
+        nonce,
+      };
+    }
+    const params = {
+      minProtocol: 3,
+      maxProtocol: 3,
+      client: {
+        id: this.opts.clientName ?? GATEWAY_CLIENT_NAMES.CONTROL_UI,
+        version: this.opts.clientVersion ?? "dev",
+        platform: this.opts.platform ?? navigator.platform ?? "web",
+        mode: this.opts.mode ?? GATEWAY_CLIENT_MODES.WEBCHAT,
+        instanceId: this.opts.instanceId,
+      },
+      role,
+      scopes,
+      device,
+      caps: [],
+      auth,
+      userAgent: navigator.userAgent,
+      locale: navigator.language,
+    };
+
+    void this.request<GatewayHelloOk>("connect", params)
+      .then((hello) => {
+        if (hello?.auth?.deviceToken && deviceIdentity) {
+          storeDeviceAuthToken({
+            deviceId: deviceIdentity.deviceId,
+            role: hello.auth.role ?? role,
+            token: hello.auth.deviceToken,
+            scopes: hello.auth.scopes ?? [],
+          });
+        }
+        this.backoffMs = 800;
+        this.opts.onHello?.(hello);
+      })
+      .catch((err: unknown) => {
+        if (err instanceof GatewayRequestError) {
+          this.pendingConnectError = {
+            code: err.gatewayCode,
+            message: err.message,
+            details: err.details,
+          };
+        } else {
+          this.pendingConnectError = undefined;
+        }
+        if (canFallbackToShared && deviceIdentity) {
+          clearDeviceAuthToken({ deviceId: deviceIdentity.deviceId, role });
+        }
+        this.ws?.close(CONNECT_FAILED_CLOSE_CODE, "connect failed");
+      });
+  }
+
+  private handleMessage(raw: string) {
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+
+    const frame = parsed as { type?: unknown };
+    if (frame.type === "event") {
+      const evt = parsed as GatewayEventFrame;
+      if (evt.event === "connect.challenge") {
+        const payload = evt.payload as { nonce?: unknown } | undefined;
+        const nonce = payload && typeof payload.nonce === "string" ? payload.nonce : null;
+        if (nonce) {
+          this.connectNonce = nonce;
+          void this.sendConnect();
+        }
+        return;
+      }
+      const seq = typeof evt.seq === "number" ? evt.seq : null;
+      if (seq !== null) {
+        if (this.lastSeq !== null && seq > this.lastSeq + 1) {
+          this.opts.onGap?.({ expected: this.lastSeq + 1, received: seq });
+        }
+        this.lastSeq = seq;
+      }
+      try {
+        this.opts.onEvent?.(evt);
+      } catch (err) {
+        console.error("[gateway] event handler error:", err);
+      }
+      return;
+    }
+
+    if (frame.type === "res") {
+      const res = parsed as GatewayResponseFrame;
+      const pending = this.pending.get(res.id);
+      if (!pending) {
+        return;
+      }
+      this.pending.delete(res.id);
+      if (res.ok) {
+        pending.resolve(res.payload);
+      } else {
+        pending.reject(
+          new GatewayRequestError({
+            code: res.error?.code ?? "UNAVAILABLE",
+            message: res.error?.message ?? "request failed",
+            details: res.error?.details,
+          }),
+        );
+      }
+      return;
+    }
+  }
+
+  request<T = unknown>(method: string, params?: unknown): Promise<T> {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return Promise.reject(new Error("gateway not connected"));
+    }
+    const id = generateUUID();
+    const frame = { type: "req", id, method, params };
+    const p = new Promise<T>((resolve, reject) => {
+      this.pending.set(id, { resolve: (v) => resolve(v as T), reject });
+    });
+    this.ws.send(JSON.stringify(frame));
+    return p;
+  }
+
+  private queueConnect() {
+    this.connectNonce = null;
+    this.connectSent = false;
+    if (this.connectTimer !== null) {
+      window.clearTimeout(this.connectTimer);
+    }
+    this.connectTimer = window.setTimeout(() => {
+      void this.sendConnect();
+    }, 750);
+  }
+}