openclaw-multi-auto 1.3.6 → 1.3.8

package/ui/src/ui/usage-helpers.ts

@@ -0,0 +1,321 @@
+export type UsageQueryTerm = {
+  key?: string;
+  value: string;
+  raw: string;
+};
+
+export type UsageQueryResult<TSession> = {
+  sessions: TSession[];
+  warnings: string[];
+};
+
+// Minimal shape required for query filtering. The usage view's real session type contains more fields.
+export type UsageSessionQueryTarget = {
+  key: string;
+  label?: string;
+  sessionId?: string;
+  agentId?: string;
+  channel?: string;
+  chatType?: string;
+  modelProvider?: string;
+  providerOverride?: string;
+  origin?: { provider?: string };
+  model?: string;
+  contextWeight?: unknown;
+  usage?: {
+    totalTokens?: number;
+    totalCost?: number;
+    messageCounts?: { total?: number; errors?: number };
+    toolUsage?: { totalCalls?: number; tools?: Array<{ name: string }> };
+    modelUsage?: Array<{ provider?: string; model?: string }>;
+  } | null;
+};
+
+const QUERY_KEYS = new Set([
+  "agent",
+  "channel",
+  "chat",
+  "provider",
+  "model",
+  "tool",
+  "label",
+  "key",
+  "session",
+  "id",
+  "has",
+  "mintokens",
+  "maxtokens",
+  "mincost",
+  "maxcost",
+  "minmessages",
+  "maxmessages",
+]);
+
+const normalizeQueryText = (value: string): string => value.trim().toLowerCase();
+
+const globToRegex = (pattern: string): RegExp => {
+  const escaped = pattern
+    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
+    .replace(/\*/g, ".*")
+    .replace(/\?/g, ".");
+  return new RegExp(`^${escaped}$`, "i");
+};
+
+const parseQueryNumber = (value: string): number | null => {
+  let raw = value.trim().toLowerCase();
+  if (!raw) {
+    return null;
+  }
+  if (raw.startsWith("$")) {
+    raw = raw.slice(1);
+  }
+  let multiplier = 1;
+  if (raw.endsWith("k")) {
+    multiplier = 1_000;
+    raw = raw.slice(0, -1);
+  } else if (raw.endsWith("m")) {
+    multiplier = 1_000_000;
+    raw = raw.slice(0, -1);
+  }
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed)) {
+    return null;
+  }
+  return parsed * multiplier;
+};
+
+export const extractQueryTerms = (query: string): UsageQueryTerm[] => {
+  // Tokenize by whitespace, but allow quoted values with spaces.
+  const rawTokens = query.match(/"[^"]+"|\S+/g) ?? [];
+  return rawTokens.map((token) => {
+    const cleaned = token.replace(/^"|"$/g, "");
+    const idx = cleaned.indexOf(":");
+    if (idx > 0) {
+      const key = cleaned.slice(0, idx);
+      const value = cleaned.slice(idx + 1);
+      return { key, value, raw: cleaned };
+    }
+    return { value: cleaned, raw: cleaned };
+  });
+};
+
+const getSessionText = (session: UsageSessionQueryTarget): string[] => {
+  const items: Array<string | undefined> = [session.label, session.key, session.sessionId];
+  return items.filter((item): item is string => Boolean(item)).map((item) => item.toLowerCase());
+};
+
+const getSessionProviders = (session: UsageSessionQueryTarget): string[] => {
+  const providers = new Set<string>();
+  if (session.modelProvider) {
+    providers.add(session.modelProvider.toLowerCase());
+  }
+  if (session.providerOverride) {
+    providers.add(session.providerOverride.toLowerCase());
+  }
+  if (session.origin?.provider) {
+    providers.add(session.origin.provider.toLowerCase());
+  }
+  for (const entry of session.usage?.modelUsage ?? []) {
+    if (entry.provider) {
+      providers.add(entry.provider.toLowerCase());
+    }
+  }
+  return Array.from(providers);
+};
+
+const getSessionModels = (session: UsageSessionQueryTarget): string[] => {
+  const models = new Set<string>();
+  if (session.model) {
+    models.add(session.model.toLowerCase());
+  }
+  for (const entry of session.usage?.modelUsage ?? []) {
+    if (entry.model) {
+      models.add(entry.model.toLowerCase());
+    }
+  }
+  return Array.from(models);
+};
+
+const getSessionTools = (session: UsageSessionQueryTarget): string[] =>
+  (session.usage?.toolUsage?.tools ?? []).map((tool) => tool.name.toLowerCase());
+
+export const matchesUsageQuery = (
+  session: UsageSessionQueryTarget,
+  term: UsageQueryTerm,
+): boolean => {
+  const value = normalizeQueryText(term.value ?? "");
+  if (!value) {
+    return true;
+  }
+  if (!term.key) {
+    return getSessionText(session).some((text) => text.includes(value));
+  }
+
+  const key = normalizeQueryText(term.key);
+  switch (key) {
+    case "agent":
+      return session.agentId?.toLowerCase().includes(value) ?? false;
+    case "channel":
+      return session.channel?.toLowerCase().includes(value) ?? false;
+    case "chat":
+      return session.chatType?.toLowerCase().includes(value) ?? false;
+    case "provider":
+      return getSessionProviders(session).some((provider) => provider.includes(value));
+    case "model":
+      return getSessionModels(session).some((model) => model.includes(value));
+    case "tool":
+      return getSessionTools(session).some((tool) => tool.includes(value));
+    case "label":
+      return session.label?.toLowerCase().includes(value) ?? false;
+    case "key":
+    case "session":
+    case "id":
+      if (value.includes("*") || value.includes("?")) {
+        const regex = globToRegex(value);
+        return (
+          regex.test(session.key) || (session.sessionId ? regex.test(session.sessionId) : false)
+        );
+      }
+      return (
+        session.key.toLowerCase().includes(value) ||
+        (session.sessionId?.toLowerCase().includes(value) ?? false)
+      );
+    case "has":
+      switch (value) {
+        case "tools":
+          return (session.usage?.toolUsage?.totalCalls ?? 0) > 0;
+        case "errors":
+          return (session.usage?.messageCounts?.errors ?? 0) > 0;
+        case "context":
+          return Boolean(session.contextWeight);
+        case "usage":
+          return Boolean(session.usage);
+        case "model":
+          return getSessionModels(session).length > 0;
+        case "provider":
+          return getSessionProviders(session).length > 0;
+        default:
+          return true;
+      }
+    case "mintokens": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.totalTokens ?? 0) >= threshold;
+    }
+    case "maxtokens": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.totalTokens ?? 0) <= threshold;
+    }
+    case "mincost": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.totalCost ?? 0) >= threshold;
+    }
+    case "maxcost": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.totalCost ?? 0) <= threshold;
+    }
+    case "minmessages": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.messageCounts?.total ?? 0) >= threshold;
+    }
+    case "maxmessages": {
+      const threshold = parseQueryNumber(value);
+      if (threshold === null) {
+        return true;
+      }
+      return (session.usage?.messageCounts?.total ?? 0) <= threshold;
+    }
+    default:
+      return true;
+  }
+};
+
+export const filterSessionsByQuery = <TSession extends UsageSessionQueryTarget>(
+  sessions: TSession[],
+  query: string,
+): UsageQueryResult<TSession> => {
+  const terms = extractQueryTerms(query);
+  if (terms.length === 0) {
+    return { sessions, warnings: [] };
+  }
+
+  const warnings: string[] = [];
+  for (const term of terms) {
+    if (!term.key) {
+      continue;
+    }
+    const normalizedKey = normalizeQueryText(term.key);
+    if (!QUERY_KEYS.has(normalizedKey)) {
+      warnings.push(`Unknown filter: ${term.key}`);
+      continue;
+    }
+    if (term.value === "") {
+      warnings.push(`Missing value for ${term.key}`);
+    }
+    if (normalizedKey === "has") {
+      const allowed = new Set(["tools", "errors", "context", "usage", "model", "provider"]);
+      if (term.value && !allowed.has(normalizeQueryText(term.value))) {
+        warnings.push(`Unknown has:${term.value}`);
+      }
+    }
+    if (
+      ["mintokens", "maxtokens", "mincost", "maxcost", "minmessages", "maxmessages"].includes(
+        normalizedKey,
+      )
+    ) {
+      if (term.value && parseQueryNumber(term.value) === null) {
+        warnings.push(`Invalid number for ${term.key}`);
+      }
+    }
+  }
+
+  const filtered = sessions.filter((session) =>
+    terms.every((term) => matchesUsageQuery(session, term)),
+  );
+  return { sessions: filtered, warnings };
+};
+
+export function parseToolSummary(content: string) {
+  const lines = content.split("\n");
+  const toolCounts = new Map<string, number>();
+  const nonToolLines: string[] = [];
+  for (const line of lines) {
+    const match = /^\[Tool:\s*([^\]]+)\]/.exec(line.trim());
+    if (match) {
+      const name = match[1];
+      toolCounts.set(name, (toolCounts.get(name) ?? 0) + 1);
+      continue;
+    }
+    if (line.trim().startsWith("[Tool Result]")) {
+      continue;
+    }
+    nonToolLines.push(line);
+  }
+  const sortedTools = Array.from(toolCounts.entries()).toSorted((a, b) => b[1] - a[1]);
+  const totalCalls = sortedTools.reduce((sum, [, count]) => sum + count, 0);
+  const summary =
+    sortedTools.length > 0
+      ? `Tools: ${sortedTools
+          .map(([name, count]) => `${name}×${count}`)
+          .join(", ")} (${totalCalls} calls)`
+      : "";
+  return {
+    tools: sortedTools,
+    summary,
+    cleanContent: nonToolLines.join("\n").trim(),
+  };
+}

package/ui/src/ui/usage-types.ts

@@ -0,0 +1,22 @@
+import type {
+  SessionUsageTimePoint as SharedSessionUsageTimePoint,
+  SessionUsageTimeSeries as SharedSessionUsageTimeSeries,
+} from "../../../src/shared/session-usage-timeseries-types.js";
+import type { SessionsUsageResult as SharedSessionsUsageResult } from "../../../src/shared/usage-types.js";
+
+export type SessionsUsageEntry = SharedSessionsUsageResult["sessions"][number];
+export type SessionsUsageTotals = SharedSessionsUsageResult["totals"];
+export type SessionsUsageResult = SharedSessionsUsageResult;
+
+export type CostUsageDailyEntry = SessionsUsageTotals & { date: string };
+
+export type CostUsageSummary = {
+  updatedAt: number;
+  days: number;
+  daily: CostUsageDailyEntry[];
+  totals: SessionsUsageTotals;
+};
+
+export type SessionUsageTimePoint = SharedSessionUsageTimePoint;
+
+export type SessionUsageTimeSeries = SharedSessionUsageTimeSeries;

package/ui/src/ui/uuid.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it, vi } from "vitest";
+import { generateUUID } from "./uuid.ts";
+
+describe("generateUUID", () => {
+  it("uses crypto.randomUUID when available", () => {
+    const id = generateUUID({
+      randomUUID: () => "randomuuid",
+      getRandomValues: () => {
+        throw new Error("should not be called");
+      },
+    });
+
+    expect(id).toBe("randomuuid");
+  });
+
+  it("falls back to crypto.getRandomValues", () => {
+    const id = generateUUID({
+      getRandomValues: (bytes) => {
+        // @ts-expect-error
+        for (let i = 0; i < bytes.length; i++) {
+          // @ts-expect-error
+          bytes[i] = i;
+        }
+        return bytes;
+      },
+    });
+
+    expect(id).toBe("00010203-0405-4607-8809-0a0b0c0d0e0f");
+  });
+
+  it("still returns a v4 UUID when crypto is missing", () => {
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const id = generateUUID(null);
+      expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+      expect(warnSpy).toHaveBeenCalled();
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+});

package/ui/src/ui/uuid.ts

@@ -0,0 +1,57 @@
+export type CryptoLike = {
+  randomUUID?: (() => string) | undefined;
+  getRandomValues?: (<T extends Exclude<BufferSource, ArrayBuffer>>(array: T) => T) | undefined;
+};
+
+let warnedWeakCrypto = false;
+
+function uuidFromBytes(bytes: Uint8Array): string {
+  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
+  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 1
+
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(
+    16,
+    20,
+  )}-${hex.slice(20)}`;
+}
+
+function weakRandomBytes(): Uint8Array {
+  const bytes = new Uint8Array(16);
+  const now = Date.now();
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[0] ^= now & 0xff;
+  bytes[1] ^= (now >>> 8) & 0xff;
+  bytes[2] ^= (now >>> 16) & 0xff;
+  bytes[3] ^= (now >>> 24) & 0xff;
+  return bytes;
+}
+
+function warnWeakCryptoOnce() {
+  if (warnedWeakCrypto) {
+    return;
+  }
+  warnedWeakCrypto = true;
+  console.warn("[uuid] crypto API missing; falling back to weak randomness");
+}
+
+export function generateUUID(cryptoLike: CryptoLike | null = globalThis.crypto): string {
+  if (cryptoLike && typeof cryptoLike.randomUUID === "function") {
+    return cryptoLike.randomUUID();
+  }
+
+  if (cryptoLike && typeof cryptoLike.getRandomValues === "function") {
+    const bytes = new Uint8Array(16);
+    cryptoLike.getRandomValues(bytes);
+    return uuidFromBytes(bytes);
+  }
+
+  warnWeakCryptoOnce();
+  return uuidFromBytes(weakRandomBytes());
+}