Skip to content

High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.

11.3 KB
Raw Blame
import type { ActivityEvent, Agent } from "../types";
import type * as api from "../services/api";
import { eventTsMs, withClearedSessionFilter } from "./helpers";
import type { ActivityFilters, DashboardActivityEvent } from "./types";

const ANONYMOUS_AGENT_ID = "anonymous";

function detailString(
  details: Record<string, unknown> | undefined,
  key: string,
): string {
  const value = details?.[key];
  return typeof value === "string" ? value : "";
}

function detailNumber(
  details: Record<string, unknown> | undefined,
  key: string,
): number {
  const value = details?.[key];
  return typeof value === "number" ? value : 0;
}

export function toDashboardActivityEvent(
  event: ActivityEvent,
): DashboardActivityEvent {
  const details = (event.details ?? {}) as Record<string, unknown>;
  return normalizeDashboardActivityEvent({
    channel: event.channel,
    message: event.message,
    progress: event.progress,
    total: event.total,
    timestamp: event.timestamp,
    source: detailString(details, "source"),
    requestId: detailString(details, "requestId") || event.id,
    sessionId: detailString(details, "sessionId"),
    agentId: event.agentId || "",
    method: event.method,
    path: event.path,
    status: detailNumber(details, "status"),
    durationMs: detailNumber(details, "durationMs"),
    instanceId: detailString(details, "instanceId"),
    profileId: detailString(details, "profileId"),
    profileName: detailString(details, "profileName"),
    tabId: detailString(details, "tabId"),
    url: detailString(details, "url"),
    action: detailString(details, "action"),
    ref: detailString(details, "ref"),
  });
}

export function normalizeDashboardActivityEvent(
  event: DashboardActivityEvent,
): DashboardActivityEvent {
  const source = (event.source || "").trim().toLowerCase();
  const agentId = (event.agentId || "").trim();
  return {
    ...event,
    source,
    agentId: source === "client" && !agentId ? ANONYMOUS_AGENT_ID : agentId,
    tsMs: Date.parse(event.timestamp),
  };
}

export function eventIdentity(event: DashboardActivityEvent): string {
  const agentId = (event.agentId || "").trim();
  if (agentId) {
    return agentId;
  }
  return "";
}

export function matchesVisibleEvent(
  event: DashboardActivityEvent,
  filters: ActivityFilters,
  hiddenSources: string[],
  requireAgentIdentity: boolean,
): boolean {
  const source = (event.source || "").trim().toLowerCase();
  const identity = eventIdentity(event);
  if (source !== "client") {
    return false;
  }
  if (hiddenSources.includes(source)) {
    return false;
  }
  if (requireAgentIdentity && !identity) {
    return false;
  }
  if (filters.agentId && event.agentId !== filters.agentId) {
    return false;
  }
  if (filters.tabId && event.tabId !== filters.tabId) {
    return false;
  }
  if (filters.instanceId && event.instanceId !== filters.instanceId) {
    return false;
  }
  if (filters.profileName && event.profileName !== filters.profileName) {
    return false;
  }
  if (filters.sessionId && event.sessionId !== filters.sessionId) {
    return false;
  }
  if (filters.action && event.action !== filters.action) {
    return false;
  }
  if (filters.pathPrefix && !event.path.startsWith(filters.pathPrefix)) {
    return false;
  }
  if (filters.ageSec) {
    const ageSec = Number(filters.ageSec);
    if (Number.isFinite(ageSec) && ageSec >= 0) {
      const cutoff = Date.now() - ageSec * 1000;
      if (eventTsMs(event) < cutoff) {
        return false;
      }
    }
  }
  return true;
}

export function mergeDashboardActivityEvents(
  first: DashboardActivityEvent[],
  second: DashboardActivityEvent[],
): DashboardActivityEvent[] {
  const merged = new Map<string, DashboardActivityEvent>();

  for (const event of first) {
    const key = event.requestId || `${event.timestamp}:${event.path}`;
    merged.set(key, event);
  }
  for (const event of second) {
    const key = event.requestId || `${event.timestamp}:${event.path}`;
    merged.set(key, event);
  }

  return [...merged.values()].sort(
    (left, right) => eventTsMs(left) - eventTsMs(right),
  );
}

export function filterMatchingEvents(
  events: DashboardActivityEvent[],
  filters: ActivityFilters,
  hiddenSources: string[],
  requireAgentIdentity: boolean,
): DashboardActivityEvent[] {
  return events.filter((event) =>
    matchesVisibleEvent(event, filters, hiddenSources, requireAgentIdentity),
  );
}

export function filterAgentThreadEvents(
  events: DashboardActivityEvent[],
  filters: ActivityFilters,
  hiddenSources: string[],
  requireAgentIdentity: boolean,
): DashboardActivityEvent[] {
  return events.filter((event) => {
    if (
      filters.agentId &&
      eventIdentity(event).toLowerCase() !== filters.agentId.toLowerCase()
    ) {
      return false;
    }
    return matchesVisibleEvent(
      event,
      filters,
      hiddenSources,
      requireAgentIdentity,
    );
  });
}

export interface CatalogPartition {
  visibleEvents: DashboardActivityEvent[];
  sessionCatalogEvents: DashboardActivityEvent[];
  agentCatalogEvents: DashboardActivityEvent[];
}

// partitionCatalogEvents does in ONE pass what three filterMatchingEvents calls
// did separately. The three sets nest (agentCatalog ⊇ sessionCatalog ⊇ visible)
// because they differ only in the agentId + sessionId checks:
//   agentCatalogEvents   = matchesVisibleEvent with agentId="" & sessionId=""
//   sessionCatalogEvents = agentCatalog + (filters.agentId match)
//   visibleEvents        = sessionCatalog + (filters.sessionId match)
export function partitionCatalogEvents(
  catalogEvents: DashboardActivityEvent[],
  filters: ActivityFilters,
  hiddenSources: string[],
  requireAgentIdentity: boolean,
): CatalogPartition {
  const base = { ...filters, agentId: "", sessionId: "" };
  const agentCatalogEvents: DashboardActivityEvent[] = [];
  const sessionCatalogEvents: DashboardActivityEvent[] = [];
  const visibleEvents: DashboardActivityEvent[] = [];

  for (const event of catalogEvents) {
    if (
      !matchesVisibleEvent(event, base, hiddenSources, requireAgentIdentity)
    ) {
      continue;
    }
    agentCatalogEvents.push(event);
    if (filters.agentId && event.agentId !== filters.agentId) {
      continue;
    }
    sessionCatalogEvents.push(event);
    if (filters.sessionId && event.sessionId !== filters.sessionId) {
      continue;
    }
    visibleEvents.push(event);
  }

  return { visibleEvents, sessionCatalogEvents, agentCatalogEvents };
}

export interface ThreadPartition {
  agentThreadEvents: DashboardActivityEvent[];
  agentThreadSessionCatalogEvents: DashboardActivityEvent[];
}

// partitionAgentThreadEvents does in ONE pass what two filterAgentThreadEvents
// calls did. The two sets differ only in the sessionId check:
//   agentThreadSessionCatalogEvents = filter with sessionId cleared
//   agentThreadEvents               = that + (filters.sessionId match)
export function partitionAgentThreadEvents(
  events: DashboardActivityEvent[],
  filters: ActivityFilters,
  hiddenSources: string[],
  requireAgentIdentity: boolean,
): ThreadPartition {
  const sessionCleared = withClearedSessionFilter(filters);
  const agentThreadEvents: DashboardActivityEvent[] = [];
  const agentThreadSessionCatalogEvents: DashboardActivityEvent[] = [];

  for (const event of events) {
    if (
      filters.agentId &&
      eventIdentity(event).toLowerCase() !== filters.agentId.toLowerCase()
    ) {
      continue;
    }
    if (
      !matchesVisibleEvent(
        event,
        sessionCleared,
        hiddenSources,
        requireAgentIdentity,
      )
    ) {
      continue;
    }
    agentThreadSessionCatalogEvents.push(event);
    if (filters.sessionId && event.sessionId !== filters.sessionId) {
      continue;
    }
    agentThreadEvents.push(event);
  }

  return { agentThreadEvents, agentThreadSessionCatalogEvents };
}

export function deriveAgentOptions(
  catalogEvents: DashboardActivityEvent[],
): string[] {
  const ids = new Set<string>();
  for (const event of catalogEvents) {
    const agentId = (event.agentId || "").trim();
    if (agentId) {
      ids.add(agentId);
    }
  }
  return Array.from(ids).sort();
}

export function deriveSessions(
  agentSessions: api.Session[],
  sourceEvents: DashboardActivityEvent[],
): api.Session[] {
  const bySession = new Map<
    string,
    {
      agentId: string;
      label?: string;
      earliest: string;
      earliestMs: number;
      latest: string;
      latestMs: number;
    }
  >();

  for (const s of agentSessions) {
    const latest = s.lastSeenAt || s.createdAt;
    bySession.set(s.id, {
      agentId: s.agentId,
      label: s.label,
      earliest: s.createdAt,
      earliestMs: Date.parse(s.createdAt),
      latest,
      latestMs: Date.parse(latest),
    });
  }

  for (const event of sourceEvents) {
    const sid = event.sessionId?.trim();
    if (!sid) continue;
    const identity = eventIdentity(event);
    const ts = eventTsMs(event);

    const existing = bySession.get(sid);
    if (!existing) {
      bySession.set(sid, {
        agentId: identity,
        earliest: event.timestamp,
        earliestMs: ts,
        latest: event.timestamp,
        latestMs: ts,
      });
      continue;
    }

    if (ts < existing.earliestMs) {
      existing.earliest = event.timestamp;
      existing.earliestMs = ts;
    }
    if (ts > existing.latestMs) {
      existing.latest = event.timestamp;
      existing.latestMs = ts;
    }
  }

  return [...bySession.entries()]
    .map(([id, info]) => ({
      id,
      agentId: info.agentId,
      label: info.label,
      createdAt: info.earliest,
      lastSeenAt: info.latest,
      expiresAt: "",
      status: "active",
    }))
    .sort(
      (a, b) =>
        new Date(b.lastSeenAt).getTime() - new Date(a.lastSeenAt).getTime(),
    );
}

export function deriveAgents(
  agentCatalogEvents: DashboardActivityEvent[],
): Agent[] {
  const byId = new Map<string, Agent>();

  for (const event of agentCatalogEvents) {
    const identity = eventIdentity(event);
    if (!identity) {
      continue;
    }

    const existing = byId.get(identity);
    if (!existing) {
      byId.set(identity, {
        id: identity,
        name: identity,
        connectedAt: event.timestamp,
        lastActivity: event.timestamp,
        requestCount: 1,
      });
      continue;
    }

    existing.requestCount += 1;
    if (
      eventTsMs(event) >
      new Date(existing.lastActivity || existing.connectedAt).getTime()
    ) {
      existing.lastActivity = event.timestamp;
    }
  }

  return [...byId.values()].sort(
    (left, right) =>
      new Date(right.lastActivity || right.connectedAt).getTime() -
      new Date(left.lastActivity || left.connectedAt).getTime(),
  );
}

export function mergeVisibleAgents(
  derivedAgents: Agent[],
  knownAgents: Agent[],
  preferKnownAgents: boolean,
  requireAgentIdentity: boolean,
): Agent[] {
  if (!preferKnownAgents) {
    return derivedAgents;
  }

  const merged = new Map<string, Agent>();
  for (const agent of derivedAgents) {
    merged.set(agent.id, agent);
  }
  for (const agent of knownAgents) {
    merged.set(agent.id, {
      ...merged.get(agent.id),
      ...agent,
    });
  }

  return [...merged.values()]
    .filter((agent) =>
      !requireAgentIdentity ? true : !!(agent.id || "").trim(),
    )
    .sort(
      (left, right) =>
        new Date(right.lastActivity || right.connectedAt).getTime() -
        new Date(left.lastActivity || left.connectedAt).getTime(),
    );
}

export { withClearedSessionFilter };