High-performance browser automation bridge and multi-instance orchestrator with advanced stealth injection and real-time dashboard.
import { useDeferredValue, useEffect, useMemo, useRef, useState } from "react";
import { Select } from "../components/atoms";
import { SidebarPanel, SidebarPanelHeader } from "../components/molecules";
import { useAppStore } from "../stores/useAppStore";
import * as api from "../services/api";
import { fetchActivity } from "./api";
import {
ActivityFilterActions,
ActivityFilterFields,
} from "./ActivityFilterMenu";
import ActivityTimeline from "./ActivityTimeline";
import {
applyLockedFilters,
buildActivityQuery,
defaultActivityFilters,
sameActivityFilters,
} from "./helpers";
import { useAllTabs } from "./hooks/useAllTabs";
import { normalizeDashboardActivityEvent } from "./selectors";
import type { ActivityFilters, DashboardActivityEvent } from "./types";
interface Props {
initialFilters?: Partial<ActivityFilters>;
lockedFilters?: Partial<ActivityFilters>;
showFilterMenu?: boolean;
title?: string;
summaryLabel?: string;
embedded?: boolean;
}
export default function ActivityExplorer({
initialFilters,
lockedFilters,
showFilterMenu = true,
title = "Request timeline",
summaryLabel = "Activity",
embedded = false,
}: Props) {
const { instances, profiles } = useAppStore();
const [filters, setFilters] = useState<ActivityFilters>({
...defaultActivityFilters,
...initialFilters,
...lockedFilters,
});
const [events, setEvents] = useState<DashboardActivityEvent[]>([]);
const tabs = useAllTabs();
const [count, setCount] = useState(0);
const [loading, setLoading] = useState(true);
const [error, setError] = useState("");
const deferredFilters = useDeferredValue(filters);
const effectiveFilters = useMemo(
() => applyLockedFilters(deferredFilters, lockedFilters),
[deferredFilters, lockedFilters],
);
const query = useMemo(() => {
const q = buildActivityQuery(effectiveFilters);
if (embedded) {
q.source = "client";
}
return q;
}, [effectiveFilters, embedded]);
const queryKey = JSON.stringify(query);
const stableQuery = useRef(query);
stableQuery.current = query;
const [sessions, setSessions] = useState<api.Session[]>([]);
useEffect(() => {
if (!embedded) return;
let cancelled = false;
void api
.fetchSessions()
.then((s) => {
if (!cancelled) setSessions(s);
})
.catch(() => {});
return () => {
cancelled = true;
};
}, [embedded]);
useEffect(() => {
setFilters((current) => {
const next = {
...current,
...initialFilters,
...lockedFilters,
};
return sameActivityFilters(current, next) ? current : next;
});
}, [initialFilters, lockedFilters]);
useEffect(() => {
let cancelled = false;
const load = async () => {
setLoading(true);
setError("");
try {
const response = await fetchActivity(stableQuery.current);
if (cancelled) return;
setEvents(response.events.map(normalizeDashboardActivityEvent));
setCount(response.count);
} catch (err) {
if (cancelled) return;
setError(
err instanceof Error ? err.message : "Failed to load activity",
);
} finally {
if (!cancelled) {
setLoading(false);
}
}
};
void load();
return () => {
cancelled = true;
};
}, [queryKey]);
const stats = useMemo(() => {
const agents = new Set(
events.map((event) => event.agentId).filter(Boolean),
);
const tabsSeen = new Set(
events.map((event) => event.tabId).filter(Boolean),
);
const instancesSeen = new Set(
events.map((event) => event.instanceId).filter(Boolean),
);
return {
agents: agents.size,
tabs: tabsSeen.size,
instances: instancesSeen.size,
};
}, [events]);
const filteredInstances = useMemo(
() =>
effectiveFilters.profileName === ""
? instances
: instances.filter(
(instance) => instance.profileName === effectiveFilters.profileName,
),
[effectiveFilters.profileName, instances],
);
const visibleTabs = useMemo(
() =>
effectiveFilters.instanceId === ""
? tabs
: tabs.filter((tab) => tab.instanceId === effectiveFilters.instanceId),
[effectiveFilters.instanceId, tabs],
);
const summary = useMemo(
() =>
embedded
? `${count} events • ${stats.agents} agents`
: `${count} events • ${stats.agents} agents • ${stats.tabs} tabs • ${stats.instances} instances`,
[count, stats.agents, stats.instances, stats.tabs, embedded],
);
const agentOptions = useMemo(() => {
const ids = new Set<string>();
for (const e of events) {
const agentId = (e.agentId || "").trim();
if (agentId) ids.add(agentId);
}
return Array.from(ids).sort();
}, [events]);
const sessionOptions = useMemo(() => {
if (!effectiveFilters.agentId) return [];
return sessions
.filter((s) => s.agentId === effectiveFilters.agentId)
.sort(
(a, b) =>
new Date(b.lastSeenAt).getTime() - new Date(a.lastSeenAt).getTime(),
);
}, [sessions, effectiveFilters.agentId]);
const updateFilter = (key: keyof ActivityFilters, value: string) => {
if (lockedFilters?.[key] !== undefined) {
return;
}
setFilters((current) => ({ ...current, [key]: value }));
};
const handleProfileChange = (value: string) => {
if (lockedFilters?.profileName !== undefined) {
return;
}
setFilters((current) => ({
...current,
profileName: value,
instanceId:
value === "" ||
filteredInstances.some((instance) => instance.id === current.instanceId)
? current.instanceId
: "",
tabId: value === "" ? current.tabId : "",
}));
};
const handleInstanceChange = (value: string) => {
if (lockedFilters?.instanceId !== undefined) {
return;
}
setFilters((current) => ({
...current,
instanceId: value,
tabId:
value === "" || visibleTabs.some((tab) => tab.id === current.tabId)
? current.tabId
: "",
}));
};
const clearFilters = () =>
setFilters({
...defaultActivityFilters,
...lockedFilters,
});
const layoutClass = embedded
? "flex h-full min-h-0 flex-col overflow-hidden"
: "flex h-full min-h-0 flex-col gap-4 overflow-hidden p-4 lg:flex-row";
return (
<div className={layoutClass}>
{showFilterMenu && (
<SidebarPanel
as="aside"
surface="panel"
width="wide"
headerPadding="lg"
header={
<SidebarPanelHeader
eyebrow={summaryLabel}
title={title}
description={summary}
/>
}
footer={
<ActivityFilterActions
loading={loading}
onClear={clearFilters}
onRefresh={() => setFilters((current) => ({ ...current }))}
/>
}
>
<ActivityFilterFields
filters={effectiveFilters}
profileOptions={profiles}
instanceOptions={filteredInstances}
tabOptions={visibleTabs}
agentOptions={agentOptions}
onFilterChange={updateFilter}
onProfileChange={handleProfileChange}
onInstanceChange={handleInstanceChange}
/>
</SidebarPanel>
)}
{embedded && agentOptions.length > 0 && (
<div className="flex items-center gap-2 border-b border-border-subtle px-4 py-1.5">
<label className="flex items-center gap-1.5 text-xs text-text-muted">
Agent
<Select
value={effectiveFilters.agentId}
onChange={(e) => {
updateFilter("agentId", e.target.value);
if (!e.target.value) updateFilter("sessionId", "");
}}
variant="compact"
>
<option value="">All</option>
{agentOptions.map((id) => (
<option key={id} value={id}>
{id}
</option>
))}
</Select>
</label>
<label className="flex items-center gap-1.5 text-xs text-text-muted">
Session
<Select
value={effectiveFilters.sessionId}
onChange={(e) => updateFilter("sessionId", e.target.value)}
disabled={!effectiveFilters.agentId}
variant="compact"
>
<option value="">All</option>
{sessionOptions.map((s) => (
<option key={s.id} value={s.id}>
{s.label || s.id}
</option>
))}
</Select>
</label>
<span className="ml-auto text-[0.68rem] text-text-muted">
{summary}
</span>
</div>
)}
<ActivityTimeline
events={events}
loading={loading}
error={error}
summary={summary}
embedded={embedded}
showTab={!embedded}
onFilterChange={updateFilter}
/>
</div>
);
}