316 lines
8.6 KiB
TypeScript
316 lines
8.6 KiB
TypeScript
import { get, put, subscribe, type AgentSession, type ByreEvent, type Focus, type InboxItem, type Project, type Snapshot, type Task, type TaskTab, type User } from "./api.js";
|
|
|
|
export type Topic =
|
|
| "me"
|
|
| "projects"
|
|
| "tasks"
|
|
| "sessions"
|
|
| "inbox"
|
|
| "selection"
|
|
| "transcript"
|
|
| "stream"
|
|
| "connection"
|
|
| "event"
|
|
| "pin"
|
|
| "focus"
|
|
| "lead.sessions"
|
|
| "lead.transcript"
|
|
| "lead.stream";
|
|
|
|
export const tabs: TaskTab[] = ["transcript", "changes", "files", "inbox", "project"];
|
|
|
|
export const state = {
|
|
me: undefined as User | undefined,
|
|
projects: [] as Project[],
|
|
tasks: new Map<string, Task[]>(),
|
|
sessions: new Map<string, AgentSession[]>(),
|
|
inbox: [] as InboxItem[],
|
|
selectedTaskId: undefined as string | undefined,
|
|
transcript: [] as ByreEvent[],
|
|
pinned: undefined as number | undefined,
|
|
connected: false,
|
|
focus: { tabs: ["transcript"], tab: "transcript" } as Focus,
|
|
leadSessions: [] as AgentSession[],
|
|
leadTranscript: [] as ByreEvent[],
|
|
};
|
|
|
|
const listeners = new Map<Topic, Set<(detail?: unknown) => void>>();
|
|
|
|
export function on(topic: Topic, fn: (detail?: unknown) => void): () => void {
|
|
let set = listeners.get(topic);
|
|
if (!set) {
|
|
set = new Set();
|
|
listeners.set(topic, set);
|
|
}
|
|
set.add(fn);
|
|
return () => set.delete(fn);
|
|
}
|
|
|
|
export function onEach(topics: Topic[], fn: (detail?: unknown) => void): () => void {
|
|
const offs = topics.map((t) => on(t, fn));
|
|
return () => {
|
|
for (const off of offs) {
|
|
off();
|
|
}
|
|
};
|
|
}
|
|
|
|
export function activeTasks(): { project: Project; task: Task }[] {
|
|
return state.projects.flatMap((project) => (state.tasks.get(project.id) ?? []).filter((t) => t.status === "active").map((task) => ({ project, task })));
|
|
}
|
|
|
|
export function notify(topic: Topic, detail?: unknown): void {
|
|
for (const fn of listeners.get(topic) ?? []) {
|
|
fn(detail);
|
|
}
|
|
}
|
|
|
|
export function findTask(id: string): Task | undefined {
|
|
for (const tasks of state.tasks.values()) {
|
|
const task = tasks.find((t) => t.id === id);
|
|
if (task) {
|
|
return task;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
export function currentSession(taskId: string): AgentSession | undefined {
|
|
return state.sessions.get(taskId)?.findLast((s) => s.state !== "completed") ?? state.sessions.get(taskId)?.at(-1);
|
|
}
|
|
|
|
export function currentLead(): AgentSession | undefined {
|
|
return state.leadSessions.findLast((s) => s.state !== "completed") ?? state.leadSessions.at(-1);
|
|
}
|
|
|
|
export function snapshots(): Snapshot[] {
|
|
return state.transcript.filter((e) => e.kind === "snapshot.created").map((e) => e.payload as unknown as Snapshot);
|
|
}
|
|
|
|
export function pinSnapshot(n: number | undefined): void {
|
|
state.pinned = n;
|
|
notify("pin");
|
|
}
|
|
|
|
export async function loadMe(): Promise<void> {
|
|
state.me = await get("/api/me");
|
|
notify("me");
|
|
}
|
|
|
|
export async function loadProjects(): Promise<void> {
|
|
state.projects = await get("/api/projects");
|
|
await Promise.all(state.projects.map((p) => loadTasks(p.id)));
|
|
notify("projects");
|
|
}
|
|
|
|
export async function loadTasks(projectId: string): Promise<void> {
|
|
const tasks = await get("/api/projects/{projectId}/tasks", { path: { projectId } });
|
|
state.tasks.set(projectId, tasks);
|
|
await Promise.all(tasks.filter((t) => t.status === "active").map((t) => loadSessions(t.id)));
|
|
notify("tasks");
|
|
}
|
|
|
|
export async function loadSessions(taskId: string): Promise<void> {
|
|
state.sessions.set(taskId, await get("/api/tasks/{taskId}/sessions", { path: { taskId } }));
|
|
notify("sessions", taskId);
|
|
}
|
|
|
|
export async function loadInbox(): Promise<void> {
|
|
state.inbox = await get("/api/inbox");
|
|
notify("inbox");
|
|
}
|
|
|
|
export async function loadLeadSessions(): Promise<void> {
|
|
state.leadSessions = await get("/api/me/lead/sessions");
|
|
notify("lead.sessions");
|
|
}
|
|
|
|
export async function loadFocus(): Promise<void> {
|
|
applyFocus(await get("/api/me/focus"));
|
|
}
|
|
|
|
export function applyFocus(f: Focus): void {
|
|
state.focus = f;
|
|
const hash = f.task_id ? `#/task/${f.task_id}` : f.project_id ? `#/project/${f.project_id}` : "#/";
|
|
if (location.hash !== hash && !(hash === "#/" && location.hash === "")) {
|
|
location.hash = hash;
|
|
}
|
|
notify("focus");
|
|
}
|
|
|
|
export function focusedProject(): Project | undefined {
|
|
return state.projects.find((p) => p.id === state.focus.project_id);
|
|
}
|
|
|
|
export async function setFocus(change: { task_id?: string | null; project_id?: string | null; tab?: TaskTab }): Promise<void> {
|
|
const taskId = change.task_id === undefined ? state.focus.task_id : (change.task_id ?? undefined);
|
|
const projectId = taskId ? findTask(taskId)?.project_id : change.project_id === undefined ? state.focus.project_id : (change.project_id ?? undefined);
|
|
const next: Focus = { tabs: state.focus.tabs, tab: change.tab ?? state.focus.tab };
|
|
if (taskId) {
|
|
next.task_id = taskId;
|
|
}
|
|
if (projectId) {
|
|
next.project_id = projectId;
|
|
}
|
|
applyFocus(next);
|
|
applyFocus(await put("/api/me/focus", { body: next }));
|
|
}
|
|
|
|
export function focusTask(taskId: string, tab: TaskTab = "transcript"): void {
|
|
setFocus({ task_id: taskId, tab }).catch((err: unknown) => console.error("set focus", err));
|
|
}
|
|
|
|
export function focusProject(projectId: string): void {
|
|
setFocus({ task_id: null, project_id: projectId, tab: "project" }).catch((err: unknown) => console.error("set focus", err));
|
|
}
|
|
|
|
export function focusTab(tab: TaskTab): void {
|
|
setFocus({ tab }).catch((err: unknown) => console.error("set focus", err));
|
|
}
|
|
|
|
class Feed {
|
|
events: ByreEvent[] = [];
|
|
private last = 0;
|
|
private buffer: ByreEvent[] = [];
|
|
private timer = 0;
|
|
|
|
constructor(
|
|
private readonly transcriptTopic: Topic,
|
|
private readonly streamTopic: Topic,
|
|
private readonly store: (events: ByreEvent[]) => void,
|
|
) {}
|
|
|
|
reset(): void {
|
|
clearTimeout(this.timer);
|
|
this.timer = 0;
|
|
this.buffer = [];
|
|
this.events = [];
|
|
this.last = 0;
|
|
this.store(this.events);
|
|
}
|
|
|
|
readonly push = (ev: ByreEvent): void => {
|
|
this.buffer.push(ev);
|
|
if (!this.timer) {
|
|
this.timer = setTimeout(() => this.flush(), 0);
|
|
}
|
|
};
|
|
|
|
private flush(): void {
|
|
const events = this.buffer;
|
|
this.buffer = [];
|
|
this.timer = 0;
|
|
let stored: ByreEvent[] = [];
|
|
for (const ev of events) {
|
|
if (ev.seq !== 0) {
|
|
stored.push(ev);
|
|
continue;
|
|
}
|
|
this.append(stored);
|
|
stored = [];
|
|
notify(this.streamTopic, ev);
|
|
}
|
|
this.append(stored);
|
|
}
|
|
|
|
private append(events: ByreEvent[]): void {
|
|
const fresh = events.filter((ev) => ev.seq > this.last);
|
|
if (fresh.length === 0) {
|
|
return;
|
|
}
|
|
this.events.push(...fresh);
|
|
this.last = fresh.at(-1)!.seq;
|
|
notify(this.transcriptTopic, fresh);
|
|
}
|
|
}
|
|
|
|
const taskFeed = new Feed("transcript", "stream", (events) => {
|
|
state.transcript = events;
|
|
});
|
|
const leadFeed = new Feed("lead.transcript", "lead.stream", (events) => {
|
|
state.leadTranscript = events;
|
|
});
|
|
|
|
let closeTaskStream: (() => void) | undefined;
|
|
|
|
const visitsKey = "byre.visits";
|
|
|
|
export function lastVisits(): Record<string, number> {
|
|
return JSON.parse(localStorage.getItem(visitsKey) ?? "{}") as Record<string, number>;
|
|
}
|
|
|
|
function markVisited(taskId: string | undefined): void {
|
|
if (!taskId) {
|
|
return;
|
|
}
|
|
localStorage.setItem(visitsKey, JSON.stringify({ ...lastVisits(), [taskId]: Date.now() }));
|
|
}
|
|
|
|
export function selectTask(taskId: string | undefined): void {
|
|
markVisited(state.selectedTaskId);
|
|
markVisited(taskId);
|
|
closeTaskStream?.();
|
|
closeTaskStream = undefined;
|
|
taskFeed.reset();
|
|
state.selectedTaskId = taskId;
|
|
state.pinned = undefined;
|
|
notify("selection");
|
|
|
|
if (!taskId) {
|
|
return;
|
|
}
|
|
|
|
closeTaskStream = subscribe(0, { task_id: taskId }, taskFeed.push, () => undefined);
|
|
}
|
|
|
|
export function startLeadStream(): void {
|
|
leadFeed.reset();
|
|
subscribe(0, { lead: true }, leadFeed.push, () => undefined);
|
|
}
|
|
|
|
export function handleEvent(ev: ByreEvent): void {
|
|
if (ev.seq === 0) {
|
|
notify("event", ev);
|
|
return;
|
|
}
|
|
|
|
switch (ev.kind) {
|
|
case "user.updated":
|
|
if (ev.payload["login"] === state.me?.login) {
|
|
void loadMe();
|
|
}
|
|
break;
|
|
case "project.created":
|
|
void loadProjects();
|
|
break;
|
|
case "task.created":
|
|
case "task.merge_title":
|
|
case "task.merged":
|
|
case "task.discarded":
|
|
if (ev.project_id) {
|
|
void loadTasks(ev.project_id);
|
|
}
|
|
break;
|
|
case "session.created":
|
|
case "session.state":
|
|
case "session.model":
|
|
if (ev.owner) {
|
|
void loadLeadSessions();
|
|
} else if (ev.task_id) {
|
|
void loadSessions(ev.task_id);
|
|
}
|
|
break;
|
|
case "inbox.created":
|
|
case "inbox.updated":
|
|
void loadInbox();
|
|
break;
|
|
case "focus.updated":
|
|
if (ev.actor !== state.me?.login) {
|
|
applyFocus(ev.payload as unknown as Focus);
|
|
}
|
|
break;
|
|
}
|
|
|
|
notify("event", ev);
|
|
}
|