A desktop coding agent with free access to frontier models.
TypeScript
import { useEffect, useMemo, useRef } from "react";
import type { OmniRushSessionGroupState } from "@/app/lib/omnirush-server";
import type { ResolvedWorkspaceEndpoint } from "@/app/lib/workspace-endpoint";
import {
applySessionGroupServerState,
beginSessionGroupServerSync,
setSessionGroupSyncHandler,
useSessionManagementStore,
type SessionGroupDefinition,
type SessionGroupServerState,
type WorkspaceGroupState,
} from "@/react-app/domains/session/sidebar/session-management-store";
import type { RouteWorkspace } from "./route-workspaces";
import { SessionGroupEventPoller } from "./session-group-event-poller";
const MIGRATION_PREFIX = "omnirush.sessionGroups.migrated.v2";
type UseSessionGroupSyncInput = {
workspaces: RouteWorkspace[];
endpointForWorkspace: (workspace: RouteWorkspace | null | undefined) => ResolvedWorkspaceEndpoint | null;
};
function hasGroupData(state: SessionGroupServerState | WorkspaceGroupState | undefined): boolean {
return Boolean(state && (state.groups.length > 0 || Object.keys(state.assignments).length > 0));
}
function serverStateFromWorkspaceState(state: WorkspaceGroupState): OmniRushSessionGroupState {
return {
groups: state.groups.map((group) => ({ id: group.id, label: group.label })),
assignments: { ...state.assignments },
};
}
function localGroupStateForWorkspace(
workspace: RouteWorkspace,
endpoint: ResolvedWorkspaceEndpoint,
): WorkspaceGroupState | undefined {
const byWorkspace = useSessionManagementStore.getState().groupsByWorkspace;
const ids = [workspace.id, endpoint.workspaceId, `rem_${endpoint.workspaceId}`];
for (const id of ids) {
const state = byWorkspace[id];
if (hasGroupData(state)) return state;
}
return undefined;
}
function migrationKey(endpoint: ResolvedWorkspaceEndpoint): string {
return `${MIGRATION_PREFIX}:${endpoint.baseUrl}:${endpoint.workspaceId}`;
}
function workspaceEndpointSyncKey(
workspaces: RouteWorkspace[],
endpointForWorkspace: UseSessionGroupSyncInput["endpointForWorkspace"],
): string {
return workspaces
.map((workspace) => {
const endpoint = endpointForWorkspace(workspace);
return JSON.stringify([
workspace.id.trim(),
endpoint?.baseUrl.trim() ?? "",
endpoint?.workspaceId.trim() ?? "",
endpoint?.token.trim() ?? "",
]);
})
.sort()
.join("|");
}
function readMigrationComplete(endpoint: ResolvedWorkspaceEndpoint): boolean {
try {
return window.localStorage.getItem(migrationKey(endpoint)) === "1";
} catch {
return false;
}
}
function writeMigrationComplete(endpoint: ResolvedWorkspaceEndpoint): void {
try {
window.localStorage.setItem(migrationKey(endpoint), "1");
} catch {
// ignore storage failures; the next launch can retry safely.
}
}
export function useSessionGroupSync(input: UseSessionGroupSyncInput): void {
const { workspaces, endpointForWorkspace } = input;
const workspacesRef = useRef(workspaces);
const endpointForWorkspaceRef = useRef(endpointForWorkspace);
const eventPollerRef = useRef(new SessionGroupEventPoller());
const pollInFlightRef = useRef(false);
const groupSyncKey = useMemo(
() => workspaceEndpointSyncKey(workspaces, endpointForWorkspace),
[endpointForWorkspace, workspaces],
);
useEffect(() => {
workspacesRef.current = workspaces;
}, [workspaces]);
useEffect(() => {
endpointForWorkspaceRef.current = endpointForWorkspace;
}, [endpointForWorkspace]);
useEffect(() => {
setSessionGroupSyncHandler({
createGroup: async (workspaceId: string, group: SessionGroupDefinition) => {
const workspace = workspacesRef.current.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return null;
const response = await endpoint.client.createSessionGroup(endpoint.workspaceId, group);
writeMigrationComplete(endpoint);
return response.state;
},
assignGroup: async (workspaceId: string, sessionId: string, groupId: string | null) => {
const workspace = workspacesRef.current.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return null;
const response = await endpoint.client.assignSessionGroup(endpoint.workspaceId, sessionId, groupId);
writeMigrationComplete(endpoint);
return response.state;
},
reorderGroups: async (workspaceId: string, groupIds: string[]) => {
const workspace = workspacesRef.current.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return null;
const response = await endpoint.client.reorderSessionGroups(endpoint.workspaceId, groupIds);
writeMigrationComplete(endpoint);
return response.state;
},
renameGroup: async (workspaceId: string, groupId: string, label: string) => {
const workspace = workspacesRef.current.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return null;
const response = await endpoint.client.renameSessionGroup(endpoint.workspaceId, groupId, label);
writeMigrationComplete(endpoint);
return response.state;
},
removeGroup: async (workspaceId, groupId, destinationGroupId) => {
const workspace = workspacesRef.current.find((item) => item.id === workspaceId);
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return null;
const response = await endpoint.client.removeSessionGroup(endpoint.workspaceId, groupId, destinationGroupId);
writeMigrationComplete(endpoint);
return response.state;
},
});
return () => setSessionGroupSyncHandler(null);
}, []);
useEffect(() => {
let cancelled = false;
const eventWorkspaceKeys: string[] = [];
for (const workspace of workspacesRef.current) {
const endpoint = endpointForWorkspaceRef.current(workspace);
if (endpoint) eventWorkspaceKeys.push(`${endpoint.baseUrl}:${endpoint.workspaceId}`);
}
eventPollerRef.current.setWorkspaces(eventWorkspaceKeys);
const syncWorkspace = async (workspace: RouteWorkspace, migrateLocal: boolean) => {
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) return;
const version = beginSessionGroupServerSync(workspace.id);
const response = await endpoint.client.getSessionGroups(endpoint.workspaceId);
if (cancelled) return;
let nextState = response.state;
const localState = localGroupStateForWorkspace(workspace, endpoint);
if (
migrateLocal &&
!readMigrationComplete(endpoint) &&
!hasGroupData(response.state) &&
localState !== undefined
) {
const migrated = await endpoint.client.putSessionGroups(
endpoint.workspaceId,
serverStateFromWorkspaceState(localState),
);
if (cancelled) return;
nextState = migrated.state;
}
writeMigrationComplete(endpoint);
applySessionGroupServerState(workspace.id, nextState, version);
};
for (const workspace of workspacesRef.current) {
void syncWorkspace(workspace, true).catch((error) => {
console.warn("[session-groups] initial sync failed", error);
});
}
const pollEvents = async () => {
if (pollInFlightRef.current) return;
pollInFlightRef.current = true;
try {
for (const workspace of workspacesRef.current) {
const endpoint = endpointForWorkspaceRef.current(workspace);
if (!endpoint) continue;
const key = `${endpoint.baseUrl}:${endpoint.workspaceId}`;
try {
await eventPollerRef.current.poll(
key,
(options) => endpoint.client.listSessionGroupEvents(endpoint.workspaceId, options),
() => syncWorkspace(workspace, false),
);
if (cancelled) return;
} catch {
// Best effort: normal workspace/session loading still surfaces connection issues.
}
}
} finally {
pollInFlightRef.current = false;
}
};
void pollEvents();
const interval = window.setInterval(() => void pollEvents(), 3000);
return () => {
cancelled = true;
window.clearInterval(interval);
};
}, [groupSyncKey]);
}