openclaw-multi-auto 1.3.7 → 1.3.8

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

@@ -0,0 +1,315 @@
+import type { GatewayBrowserClient } from "../gateway.ts";
+import type { SessionsUsageResult, CostUsageSummary, SessionUsageTimeSeries } from "../types.ts";
+import type { SessionLogEntry } from "../views/usage.ts";
+
+export type UsageState = {
+  client: GatewayBrowserClient | null;
+  connected: boolean;
+  usageLoading: boolean;
+  usageResult: SessionsUsageResult | null;
+  usageCostSummary: CostUsageSummary | null;
+  usageError: string | null;
+  usageStartDate: string;
+  usageEndDate: string;
+  usageSelectedSessions: string[];
+  usageSelectedDays: string[];
+  usageTimeSeries: SessionUsageTimeSeries | null;
+  usageTimeSeriesLoading: boolean;
+  usageTimeSeriesCursorStart: number | null;
+  usageTimeSeriesCursorEnd: number | null;
+  usageSessionLogs: SessionLogEntry[] | null;
+  usageSessionLogsLoading: boolean;
+  usageTimeZone: "local" | "utc";
+  settings?: { gatewayUrl?: string };
+};
+
+type DateInterpretationMode = "utc" | "gateway" | "specific";
+
+type UsageDateInterpretationParams = {
+  mode: DateInterpretationMode;
+  utcOffset?: string;
+};
+
+const LEGACY_USAGE_DATE_PARAMS_STORAGE_KEY = "openclaw.control.usage.date-params.v1";
+const LEGACY_USAGE_DATE_PARAMS_DEFAULT_GATEWAY_KEY = "__default__";
+const LEGACY_USAGE_DATE_PARAMS_MODE_RE = /unexpected property ['"]mode['"]/i;
+const LEGACY_USAGE_DATE_PARAMS_OFFSET_RE = /unexpected property ['"]utcoffset['"]/i;
+const LEGACY_USAGE_DATE_PARAMS_INVALID_RE = /invalid sessions\.usage params/i;
+
+let legacyUsageDateParamsCache: Set<string> | null = null;
+
+function getLocalStorage(): Storage | null {
+  // Support browser runtime and node tests (when localStorage is stubbed globally).
+  if (typeof window !== "undefined" && window.localStorage) {
+    return window.localStorage;
+  }
+  if (typeof localStorage !== "undefined") {
+    return localStorage;
+  }
+  return null;
+}
+
+function loadLegacyUsageDateParamsCache(): Set<string> {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return new Set<string>();
+  }
+  try {
+    const raw = storage.getItem(LEGACY_USAGE_DATE_PARAMS_STORAGE_KEY);
+    if (!raw) {
+      return new Set<string>();
+    }
+    const parsed = JSON.parse(raw) as { unsupportedGatewayKeys?: unknown } | null;
+    if (!parsed || !Array.isArray(parsed.unsupportedGatewayKeys)) {
+      return new Set<string>();
+    }
+    return new Set(
+      parsed.unsupportedGatewayKeys
+        .filter((entry): entry is string => typeof entry === "string")
+        .map((entry) => entry.trim())
+        .filter(Boolean),
+    );
+  } catch {
+    return new Set<string>();
+  }
+}
+
+function persistLegacyUsageDateParamsCache(cache: Set<string>) {
+  const storage = getLocalStorage();
+  if (!storage) {
+    return;
+  }
+  try {
+    storage.setItem(
+      LEGACY_USAGE_DATE_PARAMS_STORAGE_KEY,
+      JSON.stringify({ unsupportedGatewayKeys: Array.from(cache) }),
+    );
+  } catch {
+    // ignore quota/private-mode failures
+  }
+}
+
+function getLegacyUsageDateParamsCache(): Set<string> {
+  if (!legacyUsageDateParamsCache) {
+    legacyUsageDateParamsCache = loadLegacyUsageDateParamsCache();
+  }
+  return legacyUsageDateParamsCache;
+}
+
+function normalizeGatewayCompatibilityKey(gatewayUrl?: string): string {
+  const trimmed = gatewayUrl?.trim();
+  if (!trimmed) {
+    return LEGACY_USAGE_DATE_PARAMS_DEFAULT_GATEWAY_KEY;
+  }
+  try {
+    const parsed = new URL(trimmed);
+    const pathname = parsed.pathname === "/" ? "" : parsed.pathname;
+    return `${parsed.protocol}//${parsed.host}${pathname}`.toLowerCase();
+  } catch {
+    return trimmed.toLowerCase();
+  }
+}
+
+function resolveGatewayCompatibilityKey(state: UsageState): string {
+  return normalizeGatewayCompatibilityKey(state.settings?.gatewayUrl);
+}
+
+function shouldSendLegacyDateInterpretation(state: UsageState): boolean {
+  return !getLegacyUsageDateParamsCache().has(resolveGatewayCompatibilityKey(state));
+}
+
+function rememberLegacyDateInterpretation(state: UsageState) {
+  const cache = getLegacyUsageDateParamsCache();
+  cache.add(resolveGatewayCompatibilityKey(state));
+  persistLegacyUsageDateParamsCache(cache);
+}
+
+function isLegacyDateInterpretationUnsupportedError(err: unknown): boolean {
+  const message = toErrorMessage(err);
+  return (
+    LEGACY_USAGE_DATE_PARAMS_INVALID_RE.test(message) &&
+    (LEGACY_USAGE_DATE_PARAMS_MODE_RE.test(message) ||
+      LEGACY_USAGE_DATE_PARAMS_OFFSET_RE.test(message))
+  );
+}
+
+const formatUtcOffset = (timezoneOffsetMinutes: number): string => {
+  // `Date#getTimezoneOffset()` is minutes to add to local time to reach UTC.
+  // Convert to UTC±H[:MM] where positive means east of UTC.
+  const offsetFromUtcMinutes = -timezoneOffsetMinutes;
+  const sign = offsetFromUtcMinutes >= 0 ? "+" : "-";
+  const absMinutes = Math.abs(offsetFromUtcMinutes);
+  const hours = Math.floor(absMinutes / 60);
+  const minutes = absMinutes % 60;
+  return minutes === 0
+    ? `UTC${sign}${hours}`
+    : `UTC${sign}${hours}:${minutes.toString().padStart(2, "0")}`;
+};
+
+const buildDateInterpretationParams = (
+  timeZone: "local" | "utc",
+  includeDateInterpretation: boolean,
+): UsageDateInterpretationParams | undefined => {
+  if (!includeDateInterpretation) {
+    return undefined;
+  }
+  if (timeZone === "utc") {
+    return { mode: "utc" };
+  }
+  return {
+    mode: "specific",
+    utcOffset: formatUtcOffset(new Date().getTimezoneOffset()),
+  };
+};
+
+function toErrorMessage(err: unknown): string {
+  if (typeof err === "string") {
+    return err;
+  }
+  if (err instanceof Error && typeof err.message === "string" && err.message.trim()) {
+    return err.message;
+  }
+  if (err && typeof err === "object") {
+    try {
+      const serialized = JSON.stringify(err);
+      if (serialized) {
+        return serialized;
+      }
+    } catch {
+      // ignore
+    }
+  }
+  return "request failed";
+}
+
+export async function loadUsage(
+  state: UsageState,
+  overrides?: {
+    startDate?: string;
+    endDate?: string;
+  },
+) {
+  // Capture client for TS18047 work around on it being possibly null
+  const client = state.client;
+  if (!client || !state.connected) {
+    return;
+  }
+  if (state.usageLoading) {
+    return;
+  }
+  state.usageLoading = true;
+  state.usageError = null;
+  try {
+    const startDate = overrides?.startDate ?? state.usageStartDate;
+    const endDate = overrides?.endDate ?? state.usageEndDate;
+    const runUsageRequests = async (includeDateInterpretation: boolean) => {
+      const dateInterpretation = buildDateInterpretationParams(
+        state.usageTimeZone,
+        includeDateInterpretation,
+      );
+      return await Promise.all([
+        client.request("sessions.usage", {
+          startDate,
+          endDate,
+          ...dateInterpretation,
+          limit: 1000, // Cap at 1000 sessions
+          includeContextWeight: true,
+        }),
+        client.request("usage.cost", {
+          startDate,
+          endDate,
+          ...dateInterpretation,
+        }),
+      ]);
+    };
+
+    const applyUsageResults = (sessionsRes: unknown, costRes: unknown) => {
+      if (sessionsRes) {
+        state.usageResult = sessionsRes as SessionsUsageResult;
+      }
+      if (costRes) {
+        state.usageCostSummary = costRes as CostUsageSummary;
+      }
+    };
+
+    const includeDateInterpretation = shouldSendLegacyDateInterpretation(state);
+    try {
+      const [sessionsRes, costRes] = await runUsageRequests(includeDateInterpretation);
+      applyUsageResults(sessionsRes, costRes);
+    } catch (err) {
+      if (includeDateInterpretation && isLegacyDateInterpretationUnsupportedError(err)) {
+        // Older gateways reject `mode`/`utcOffset` in `sessions.usage`.
+        // Remember this per gateway and retry once without those fields.
+        rememberLegacyDateInterpretation(state);
+        const [sessionsRes, costRes] = await runUsageRequests(false);
+        applyUsageResults(sessionsRes, costRes);
+      } else {
+        throw err;
+      }
+    }
+  } catch (err) {
+    state.usageError = toErrorMessage(err);
+  } finally {
+    state.usageLoading = false;
+  }
+}
+
+export const __test = {
+  formatUtcOffset,
+  buildDateInterpretationParams,
+  toErrorMessage,
+  isLegacyDateInterpretationUnsupportedError,
+  normalizeGatewayCompatibilityKey,
+  shouldSendLegacyDateInterpretation,
+  rememberLegacyDateInterpretation,
+  resetLegacyUsageDateParamsCache: () => {
+    legacyUsageDateParamsCache = null;
+  },
+};
+
+export async function loadSessionTimeSeries(state: UsageState, sessionKey: string) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.usageTimeSeriesLoading) {
+    return;
+  }
+  state.usageTimeSeriesLoading = true;
+  state.usageTimeSeries = null;
+  try {
+    const res = await state.client.request("sessions.usage.timeseries", { key: sessionKey });
+    if (res) {
+      state.usageTimeSeries = res as SessionUsageTimeSeries;
+    }
+  } catch {
+    // Silently fail - time series is optional
+    state.usageTimeSeries = null;
+  } finally {
+    state.usageTimeSeriesLoading = false;
+  }
+}
+
+export async function loadSessionLogs(state: UsageState, sessionKey: string) {
+  if (!state.client || !state.connected) {
+    return;
+  }
+  if (state.usageSessionLogsLoading) {
+    return;
+  }
+  state.usageSessionLogsLoading = true;
+  state.usageSessionLogs = null;
+  try {
+    const res = await state.client.request("sessions.usage.logs", {
+      key: sessionKey,
+      limit: 1000,
+    });
+    if (res && Array.isArray((res as { logs: SessionLogEntry[] }).logs)) {
+      state.usageSessionLogs = (res as { logs: SessionLogEntry[] }).logs;
+    }
+  } catch {
+    // Silently fail - logs are optional
+    state.usageSessionLogs = null;
+  } finally {
+    state.usageSessionLogsLoading = false;
+  }
+}

package/ui/src/ui/data/moonshot-kimi-k2.ts

@@ -0,0 +1,45 @@
+export const MOONSHOT_KIMI_K2_DEFAULT_ID = "kimi-k2.5";
+export const MOONSHOT_KIMI_K2_CONTEXT_WINDOW = 256000;
+export const MOONSHOT_KIMI_K2_MAX_TOKENS = 8192;
+export const MOONSHOT_KIMI_K2_INPUT = ["text"] as const;
+export const MOONSHOT_KIMI_K2_COST = {
+  input: 0,
+  output: 0,
+  cacheRead: 0,
+  cacheWrite: 0,
+} as const;
+
+export const MOONSHOT_KIMI_K2_MODELS = [
+  {
+    id: "kimi-k2.5",
+    name: "Kimi K2.5",
+    alias: "Kimi K2.5",
+    reasoning: false,
+  },
+  {
+    id: "kimi-k2-0905-preview",
+    name: "Kimi K2 0905 Preview",
+    alias: "Kimi K2",
+    reasoning: false,
+  },
+  {
+    id: "kimi-k2-turbo-preview",
+    name: "Kimi K2 Turbo",
+    alias: "Kimi K2 Turbo",
+    reasoning: false,
+  },
+  {
+    id: "kimi-k2-thinking",
+    name: "Kimi K2 Thinking",
+    alias: "Kimi K2 Thinking",
+    reasoning: true,
+  },
+  {
+    id: "kimi-k2-thinking-turbo",
+    name: "Kimi K2 Thinking Turbo",
+    alias: "Kimi K2 Thinking Turbo",
+    reasoning: true,
+  },
+] as const;
+
+export type MoonshotKimiK2Model = (typeof MOONSHOT_KIMI_K2_MODELS)[number];

package/ui/src/ui/device-auth.ts

@@ -0,0 +1,73 @@
+import {
+  clearDeviceAuthTokenFromStore,
+  type DeviceAuthEntry,
+  loadDeviceAuthTokenFromStore,
+  storeDeviceAuthTokenInStore,
+} from "../../../src/shared/device-auth-store.js";
+import type { DeviceAuthStore } from "../../../src/shared/device-auth.js";
+
+const STORAGE_KEY = "openclaw.device.auth.v1";
+
+function readStore(): DeviceAuthStore | null {
+  try {
+    const raw = window.localStorage.getItem(STORAGE_KEY);
+    if (!raw) {
+      return null;
+    }
+    const parsed = JSON.parse(raw) as DeviceAuthStore;
+    if (!parsed || parsed.version !== 1) {
+      return null;
+    }
+    if (!parsed.deviceId || typeof parsed.deviceId !== "string") {
+      return null;
+    }
+    if (!parsed.tokens || typeof parsed.tokens !== "object") {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function writeStore(store: DeviceAuthStore) {
+  try {
+    window.localStorage.setItem(STORAGE_KEY, JSON.stringify(store));
+  } catch {
+    // best-effort
+  }
+}
+
+export function loadDeviceAuthToken(params: {
+  deviceId: string;
+  role: string;
+}): DeviceAuthEntry | null {
+  return loadDeviceAuthTokenFromStore({
+    adapter: { readStore, writeStore },
+    deviceId: params.deviceId,
+    role: params.role,
+  });
+}
+
+export function storeDeviceAuthToken(params: {
+  deviceId: string;
+  role: string;
+  token: string;
+  scopes?: string[];
+}): DeviceAuthEntry {
+  return storeDeviceAuthTokenInStore({
+    adapter: { readStore, writeStore },
+    deviceId: params.deviceId,
+    role: params.role,
+    token: params.token,
+    scopes: params.scopes,
+  });
+}
+
+export function clearDeviceAuthToken(params: { deviceId: string; role: string }) {
+  clearDeviceAuthTokenFromStore({
+    adapter: { readStore, writeStore },
+    deviceId: params.deviceId,
+    role: params.role,
+  });
+}

package/ui/src/ui/device-identity.ts

@@ -0,0 +1,112 @@
+import { getPublicKeyAsync, signAsync, utils } from "@noble/ed25519";
+
+type StoredIdentity = {
+  version: 1;
+  deviceId: string;
+  publicKey: string;
+  privateKey: string;
+  createdAtMs: number;
+};
+
+export type DeviceIdentity = {
+  deviceId: string;
+  publicKey: string;
+  privateKey: string;
+};
+
+const STORAGE_KEY = "openclaw-device-identity-v1";
+
+function base64UrlEncode(bytes: Uint8Array): string {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
+}
+
+function base64UrlDecode(input: string): Uint8Array {
+  const normalized = input.replaceAll("-", "+").replaceAll("_", "/");
+  const padded = normalized + "=".repeat((4 - (normalized.length % 4)) % 4);
+  const binary = atob(padded);
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) {
+    out[i] = binary.charCodeAt(i);
+  }
+  return out;
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+}
+
+async function fingerprintPublicKey(publicKey: Uint8Array): Promise<string> {
+  const hash = await crypto.subtle.digest("SHA-256", publicKey.slice().buffer);
+  return bytesToHex(new Uint8Array(hash));
+}
+
+async function generateIdentity(): Promise<DeviceIdentity> {
+  const privateKey = utils.randomSecretKey();
+  const publicKey = await getPublicKeyAsync(privateKey);
+  const deviceId = await fingerprintPublicKey(publicKey);
+  return {
+    deviceId,
+    publicKey: base64UrlEncode(publicKey),
+    privateKey: base64UrlEncode(privateKey),
+  };
+}
+
+export async function loadOrCreateDeviceIdentity(): Promise<DeviceIdentity> {
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY);
+    if (raw) {
+      const parsed = JSON.parse(raw) as StoredIdentity;
+      if (
+        parsed?.version === 1 &&
+        typeof parsed.deviceId === "string" &&
+        typeof parsed.publicKey === "string" &&
+        typeof parsed.privateKey === "string"
+      ) {
+        const derivedId = await fingerprintPublicKey(base64UrlDecode(parsed.publicKey));
+        if (derivedId !== parsed.deviceId) {
+          const updated: StoredIdentity = {
+            ...parsed,
+            deviceId: derivedId,
+          };
+          localStorage.setItem(STORAGE_KEY, JSON.stringify(updated));
+          return {
+            deviceId: derivedId,
+            publicKey: parsed.publicKey,
+            privateKey: parsed.privateKey,
+          };
+        }
+        return {
+          deviceId: parsed.deviceId,
+          publicKey: parsed.publicKey,
+          privateKey: parsed.privateKey,
+        };
+      }
+    }
+  } catch {
+    // fall through to regenerate
+  }
+
+  const identity = await generateIdentity();
+  const stored: StoredIdentity = {
+    version: 1,
+    deviceId: identity.deviceId,
+    publicKey: identity.publicKey,
+    privateKey: identity.privateKey,
+    createdAtMs: Date.now(),
+  };
+  localStorage.setItem(STORAGE_KEY, JSON.stringify(stored));
+  return identity;
+}
+
+export async function signDevicePayload(privateKeyBase64Url: string, payload: string) {
+  const key = base64UrlDecode(privateKeyBase64Url);
+  const data = new TextEncoder().encode(payload);
+  const sig = await signAsync(data, key);
+  return base64UrlEncode(sig);
+}

package/ui/src/ui/external-link.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import { buildExternalLinkRel } from "./external-link.ts";
+
+describe("buildExternalLinkRel", () => {
+  it("always includes required security tokens", () => {
+    expect(buildExternalLinkRel()).toBe("noopener noreferrer");
+  });
+
+  it("preserves extra rel tokens while deduping required ones", () => {
+    expect(buildExternalLinkRel("noreferrer nofollow NOOPENER")).toBe(
+      "noopener noreferrer nofollow",
+    );
+  });
+
+  it("ignores whitespace-only rel input", () => {
+    expect(buildExternalLinkRel("   ")).toBe("noopener noreferrer");
+  });
+});

package/ui/src/ui/external-link.ts

@@ -0,0 +1,19 @@
+const REQUIRED_EXTERNAL_REL_TOKENS = ["noopener", "noreferrer"] as const;
+
+export const EXTERNAL_LINK_TARGET = "_blank";
+
+export function buildExternalLinkRel(currentRel?: string): string {
+  const extraTokens: string[] = [];
+  const seen = new Set<string>(REQUIRED_EXTERNAL_REL_TOKENS);
+
+  for (const rawToken of (currentRel ?? "").split(/\s+/)) {
+    const token = rawToken.trim().toLowerCase();
+    if (!token || seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    extraTokens.push(token);
+  }
+
+  return [...REQUIRED_EXTERNAL_REL_TOKENS, ...extraTokens].join(" ");
+}

package/ui/src/ui/focus-mode.browser.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from "vitest";
+import { mountApp, registerAppMountHooks } from "./test-helpers/app-mount.ts";
+
+registerAppMountHooks();
+
+describe("chat focus mode", () => {
+  it("collapses header + sidebar on chat tab only", async () => {
+    const app = mountApp("/chat");
+    await app.updateComplete;
+
+    const shell = app.querySelector(".shell");
+    expect(shell).not.toBeNull();
+    expect(shell?.classList.contains("shell--chat-focus")).toBe(false);
+
+    const toggle = app.querySelector<HTMLButtonElement>('button[title^="Toggle focus mode"]');
+    expect(toggle).not.toBeNull();
+    toggle?.click();
+
+    await app.updateComplete;
+    expect(shell?.classList.contains("shell--chat-focus")).toBe(true);
+
+    const link = app.querySelector<HTMLAnchorElement>('a.nav-item[href="/channels"]');
+    expect(link).not.toBeNull();
+    link?.dispatchEvent(new MouseEvent("click", { bubbles: true, cancelable: true, button: 0 }));
+
+    await app.updateComplete;
+    expect(app.tab).toBe("channels");
+    expect(shell?.classList.contains("shell--chat-focus")).toBe(false);
+
+    const chatLink = app.querySelector<HTMLAnchorElement>('a.nav-item[href="/chat"]');
+    chatLink?.dispatchEvent(
+      new MouseEvent("click", { bubbles: true, cancelable: true, button: 0 }),
+    );
+
+    await app.updateComplete;
+    expect(app.tab).toBe("chat");
+    expect(shell?.classList.contains("shell--chat-focus")).toBe(true);
+  });
+});