A desktop coding agent with free access to frontier models.
TypeScript
import { browserScript } from "@omnirush/testkit";
import { expect } from "vitest";
import { evalIn, go, waitFor } from "@omnirush/behaviors";
import type { Surface } from "@omnirush/cdp";
import { screenshot } from "@omnirush/test-evidence";
import { spec } from "@omnirush/testkit";
import type { User } from "@omnirush/testkit";
import { bootCrossWorkspaceSplitView } from "../../worlds/cross-workspace-split-view.ts";
const test = spec.world(async (seed, { place }) => {
const stack = new AsyncDisposableStack();
const runId = `${Date.now().toString(36)}-${process.pid}`;
try {
const world = await bootCrossWorkspaceSplitView(stack, place, {
adminEmail: `split-view-admin-${runId}@omnirush.test`,
workspacePath: `/tmp/omnirush-cross-workspace-split-${runId}-a`,
sessionTitles: [`Primary workspace anchor ${runId}`, `Primary workspace peer ${runId}`],
});
const { workspaceId: workspaceB } = await seed.workspace(world.desktop, `/tmp/omnirush-cross-workspace-split-${runId}-b`, { create: true });
const crossWorkspacePeer = { workspaceId: workspaceB,
...await seed.session(world.desktop, { title: `Secondary workspace peer ${runId}` }) };
return { ...world, app: world.desktop, workspaceB, crossWorkspacePeer, [Symbol.asyncDispose]: () => stack.disposeAsync() };
} catch (error) {
await stack.disposeAsync();
throw error;
}
}, { timeout: 600_000 });
type SplitCandidate = {
workspaceId: string;
sessionId: string;
title: string;
};
type SplitFacts = {
layout: string;
primarySessionId: string;
secondarySessionId: string;
primaryLayoutWorkspaceId: string;
secondaryLayoutWorkspaceId: string;
primaryPaneWorkspaceId: string;
secondaryPaneWorkspaceId: string;
primarySurfaceWorkspaceId: string;
secondarySurfaceWorkspaceId: string;
primaryWorkspaceName: string;
secondaryWorkspaceName: string;
primaryResourceWorkspaceId: string;
secondaryResourceWorkspaceId: string;
primaryOwnsSecondarySurface: boolean;
secondaryOwnsPrimarySurface: boolean;
primaryUnavailable: boolean;
secondaryUnavailable: boolean;
};
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === "object" && value !== null && !Array.isArray(value);
}
function parseSplitFacts(value: unknown): SplitFacts {
if (!isRecord(value)) throw new Error(`Invalid split facts: ${JSON.stringify(value)}`);
const text = (key: string) => typeof value[key] === "string" ? value[key] : "";
return {
layout: text("layout"),
primarySessionId: text("primarySessionId"),
secondarySessionId: text("secondarySessionId"),
primaryLayoutWorkspaceId: text("primaryLayoutWorkspaceId"),
secondaryLayoutWorkspaceId: text("secondaryLayoutWorkspaceId"),
primaryPaneWorkspaceId: text("primaryPaneWorkspaceId"),
secondaryPaneWorkspaceId: text("secondaryPaneWorkspaceId"),
primarySurfaceWorkspaceId: text("primarySurfaceWorkspaceId"),
secondarySurfaceWorkspaceId: text("secondarySurfaceWorkspaceId"),
primaryWorkspaceName: text("primaryWorkspaceName"),
secondaryWorkspaceName: text("secondaryWorkspaceName"),
primaryResourceWorkspaceId: text("primaryResourceWorkspaceId"),
secondaryResourceWorkspaceId: text("secondaryResourceWorkspaceId"),
primaryOwnsSecondarySurface: value.primaryOwnsSecondarySurface === true,
secondaryOwnsPrimarySurface: value.secondaryOwnsPrimarySurface === true,
primaryUnavailable: value.primaryUnavailable === true,
secondaryUnavailable: value.secondaryUnavailable === true,
};
}
async function waitForSessionRow(app: Surface, candidate: SplitCandidate): Promise<void> {
await waitFor(app, browserScript((value) => (Boolean(document.querySelector<HTMLElement>(value))), [`[data-sidebar-session-id="${candidate.sessionId}"][data-sidebar-session-workspace-id="${candidate.workspaceId}"]`]), {
timeoutMs: 60_000,
label: `sidebar row for ${candidate.title}`,
});
}
async function openSessionRoute(app: Surface, candidate: SplitCandidate): Promise<void> {
await go(app, `/workspace/${candidate.workspaceId}/session/${candidate.sessionId}`, { timeoutMs: 60_000 });
await waitFor(app, browserScript((workspaceId, sessionId) => {
const surface = document.querySelector<HTMLElement>("[data-session-surface-id]");
return (localStorage.getItem("omnirush.react.activeWorkspace") ?? "") === workspaceId
&& surface?.getAttribute("data-session-surface-id") === sessionId;
}, [candidate.workspaceId, candidate.sessionId]), { timeoutMs: 60_000, label: `visible session ${candidate.title}` });
}
async function openContextMenuForSession(app: Surface, user: User, candidate: SplitCandidate): Promise<void> {
await user.press("Escape");
await user.rightClick({ text: candidate.title });
await waitFor(app, () => (Boolean(document.querySelector<HTMLElement>('[role="menu"]'))), {
timeoutMs: 15000, label: `context menu rendered for ${candidate.title}`,
});
}
async function splitMenuVisible(app: Surface): Promise<boolean> {
return await evalIn(app, () => (Boolean(document.querySelector<HTMLElement>("[data-session-menu-open-split]")))) === true;
}
async function clickOpenSplit(user: User): Promise<void> {
await user.click({ role: "menuitem", label: "Open as side chat" });
}
async function closeSecondaryPane(app: Surface, user: User, primary: SplitCandidate): Promise<void> {
await user.click({ role: "button", label: "Close side chat" });
await waitFor(app, browserScript((sessionId) => (!document.querySelector<HTMLElement>('[data-workbench-pane="secondary"]')
&& Boolean(document.querySelector<HTMLElement>(`[data-session-surface-id="${sessionId}"]`))), [primary.sessionId]), {
timeoutMs: 15000, label: "side chat closes and the main conversation remains visible",
});
}
async function openCrossWorkspaceSplitFromPalette(app: Surface, user: User, candidate: SplitCandidate): Promise<void> {
await user.press("Escape");
const mac = app.handle.hostKind !== "daytona" && process.platform === "darwin";
await user.press(mac ? "Meta+K" : "Control+K");
await user.click({ role: "option", label: /Open as side chat/ });
await user.click({ role: "option", label: new RegExp(candidate.title) });
}
async function readSplitFacts(app: Surface, primary: SplitCandidate, secondary: SplitCandidate): Promise<SplitFacts> {
return parseSplitFacts(await evalIn(app, browserScript((inputSessionId, inputSessionId2, inputSessionId3, inputSessionId4) => {
const context = window.__omnirushControl?.context?.();
const layout = context?.conversations?.layout;
const primaryPane = document.querySelector<HTMLElement>('[data-workbench-pane="primary"]');
const secondaryPane = document.querySelector<HTMLElement>('[data-workbench-pane="secondary"]');
const primarySurface = primaryPane?.querySelector<HTMLElement>(`[data-session-surface-id="${inputSessionId}"]`);
const secondarySurface = secondaryPane?.querySelector<HTMLElement>(`[data-session-surface-id="${inputSessionId2}"]`);
const resources = Array.isArray(context?.resources) ? context.resources : [];
const primaryResource = resources.find((resource) => resource?.kind === "session"
&& resource?.state?.pane === "primary" && resource?.state?.visible === true);
const secondaryResource = resources.find((resource) => resource?.kind === "session"
&& resource?.state?.pane === "secondary" && resource?.state?.visible === true);
return {
layout: layout?.kind ?? "",
primarySessionId: (layout?.kind === "split" ? layout.primarySessionId : undefined) ?? (layout?.kind === "single" ? layout.sessionId : undefined) ?? "",
secondarySessionId: (layout?.kind === "split" ? layout.secondarySessionId : undefined) ?? "",
primaryLayoutWorkspaceId: (layout?.kind === "split" ? layout.primaryWorkspaceId : undefined) ?? (layout?.kind === "single" ? layout.workspaceId : undefined) ?? "",
secondaryLayoutWorkspaceId: (layout?.kind === "split" ? layout.secondaryWorkspaceId : undefined) ?? "",
primaryPaneWorkspaceId: primaryPane?.getAttribute("data-workbench-workspace-id") ?? "",
secondaryPaneWorkspaceId: secondaryPane?.getAttribute("data-workbench-workspace-id") ?? "",
primarySurfaceWorkspaceId: primarySurface?.getAttribute("data-session-surface-workspace-id") ?? "",
secondarySurfaceWorkspaceId: secondarySurface?.getAttribute("data-session-surface-workspace-id") ?? "",
primaryWorkspaceName: primaryPane?.querySelector<HTMLElement>('[data-workbench-pane-header="primary"]')
?.getAttribute("data-workbench-pane-workspace-name") ?? "",
secondaryWorkspaceName: secondaryPane?.querySelector<HTMLElement>('[data-workbench-pane-header="secondary"]')
?.getAttribute("data-workbench-pane-workspace-name") ?? "",
primaryResourceWorkspaceId: primaryResource?.state?.workspaceId ?? "",
secondaryResourceWorkspaceId: secondaryResource?.state?.workspaceId ?? "",
primaryOwnsSecondarySurface: Boolean(primaryPane?.querySelector<HTMLElement>(
`[data-session-surface-id="${inputSessionId3}"]`,
)),
secondaryOwnsPrimarySurface: Boolean(secondaryPane?.querySelector<HTMLElement>(
`[data-session-surface-id="${inputSessionId4}"]`,
)),
primaryUnavailable: Boolean(primaryPane?.querySelector<HTMLElement>('[data-workbench-pane-unavailable]')),
secondaryUnavailable: Boolean(secondaryPane?.querySelector<HTMLElement>('[data-workbench-pane-unavailable]')),
};
}, [primary.sessionId, secondary.sessionId, secondary.sessionId, primary.sessionId])));
}
test("same-workspace and cross-workspace split sessions retain visible ownership", async ({ world, user, evidence }) => {
const { app, workspaceB, crossWorkspacePeer } = world;
const workspaceA = app.workspaceId;
if (!workspaceA) throw new Error("World app did not resolve a primary workspace id.");
const seededPrimary = world.sessions[0];
const seededSameWorkspacePeer = world.sessions[1];
if (!seededPrimary || !seededSameWorkspacePeer) {
throw new Error("The split-view world did not seed both primary-workspace sessions.");
}
const primary = { workspaceId: workspaceA, ...seededPrimary };
const sameWorkspacePeer = { workspaceId: workspaceA, ...seededSameWorkspacePeer };
expect(primary.workspaceId).not.toBe(crossWorkspacePeer.workspaceId);
await openSessionRoute(app, primary);
await waitForSessionRow(app, sameWorkspacePeer);
await waitForSessionRow(app, crossWorkspacePeer);
await openContextMenuForSession(app, user, sameWorkspacePeer);
expect(await splitMenuVisible(app)).toBe(true);
await clickOpenSplit(user);
await waitFor(app, browserScript((workspaceA, sessionId) => (Boolean(document.querySelector<HTMLElement>(
`[data-workbench-pane="secondary"][data-workbench-workspace-id="${workspaceA}"] [data-session-surface-id="${sessionId}"]`
))), [workspaceA, sameWorkspacePeer.sessionId]), { timeoutMs: 60_000, label: "same-workspace split renders" });
const sameWorkspaceFacts = await readSplitFacts(app, primary, sameWorkspacePeer);
expect(sameWorkspaceFacts.primaryPaneWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.secondaryPaneWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.primarySurfaceWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.secondarySurfaceWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.primaryLayoutWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.secondaryLayoutWorkspaceId).toBe(workspaceA);
expect(sameWorkspaceFacts.secondaryPaneWorkspaceId).not.toBe(workspaceB);
expect(sameWorkspaceFacts.primaryOwnsSecondarySurface).toBe(false);
expect(sameWorkspaceFacts.secondaryOwnsPrimarySurface).toBe(false);
expect(sameWorkspaceFacts.primaryUnavailable).toBe(false);
expect(sameWorkspaceFacts.secondaryUnavailable).toBe(false);
evidence.recordAssertionEvidence(
"Same-workspace split remains available and renders both sessions in their owning workspace",
JSON.stringify(sameWorkspaceFacts),
sameWorkspaceFacts.layout === "split"
&& sameWorkspaceFacts.primarySessionId === primary.sessionId
&& sameWorkspaceFacts.secondarySessionId === sameWorkspacePeer.sessionId
&& sameWorkspaceFacts.primaryPaneWorkspaceId === workspaceA
&& sameWorkspaceFacts.secondaryPaneWorkspaceId === workspaceA
&& sameWorkspaceFacts.primarySurfaceWorkspaceId === workspaceA
&& sameWorkspaceFacts.secondarySurfaceWorkspaceId === workspaceA
&& sameWorkspaceFacts.primaryLayoutWorkspaceId === workspaceA
&& sameWorkspaceFacts.secondaryLayoutWorkspaceId === workspaceA
&& sameWorkspaceFacts.secondaryPaneWorkspaceId !== workspaceB
&& !sameWorkspaceFacts.primaryOwnsSecondarySurface
&& !sameWorkspaceFacts.secondaryOwnsPrimarySurface
&& !sameWorkspaceFacts.primaryUnavailable
&& !sameWorkspaceFacts.secondaryUnavailable,
);
await closeSecondaryPane(app, user, primary);
expect(await evalIn(app, browserScript((sessionId) => (document.querySelector<HTMLElement>(`[data-session-surface-id="${sessionId}"]`) !== null), [primary.sessionId]))).toBe(true);
expect(await evalIn(app, browserScript((sessionId) => (document.querySelector<HTMLElement>(`[data-session-surface-id="${sessionId}"]`) === null), [sameWorkspacePeer.sessionId]))).toBe(true);
await openContextMenuForSession(app, user, crossWorkspacePeer);
expect(await splitMenuVisible(app)).toBe(true);
await openCrossWorkspaceSplitFromPalette(app, user, crossWorkspacePeer);
await waitFor(app, browserScript((workspaceB, sessionId) => (Boolean(document.querySelector<HTMLElement>(
`[data-workbench-pane="secondary"][data-workbench-workspace-id="${workspaceB}"] [data-session-surface-id="${sessionId}"]`
))), [workspaceB, crossWorkspacePeer.sessionId]), { timeoutMs: 60_000, label: "cross-workspace palette split renders" });
const crossWorkspaceFacts = await readSplitFacts(app, primary, crossWorkspacePeer);
expect(crossWorkspaceFacts.layout).toBe("split");
expect(crossWorkspaceFacts.primaryPaneWorkspaceId).toBe(workspaceA);
expect(crossWorkspaceFacts.primaryPaneWorkspaceId).not.toBe(workspaceB);
expect(crossWorkspaceFacts.secondaryPaneWorkspaceId).toBe(workspaceB);
expect(crossWorkspaceFacts.secondaryPaneWorkspaceId).not.toBe(workspaceA);
expect(crossWorkspaceFacts.primarySurfaceWorkspaceId).toBe(workspaceA);
expect(crossWorkspaceFacts.secondarySurfaceWorkspaceId).toBe(workspaceB);
expect(crossWorkspaceFacts.primaryLayoutWorkspaceId).toBe(workspaceA);
expect(crossWorkspaceFacts.secondaryLayoutWorkspaceId).toBe(workspaceB);
expect(crossWorkspaceFacts.primaryResourceWorkspaceId).toBe(workspaceA);
expect(crossWorkspaceFacts.secondaryResourceWorkspaceId).toBe(workspaceB);
expect(crossWorkspaceFacts.primaryOwnsSecondarySurface).toBe(false);
expect(crossWorkspaceFacts.secondaryOwnsPrimarySurface).toBe(false);
expect(crossWorkspaceFacts.primaryUnavailable).toBe(false);
expect(crossWorkspaceFacts.secondaryUnavailable).toBe(false);
expect(crossWorkspaceFacts.primaryWorkspaceName).not.toBe("");
expect(crossWorkspaceFacts.secondaryWorkspaceName).not.toBe("");
expect(crossWorkspaceFacts.primaryWorkspaceName).not.toBe(crossWorkspaceFacts.secondaryWorkspaceName);
evidence.recordAssertionEvidence(
"The command palette renders two sessions from different workspaces with correct visible ownership",
JSON.stringify(crossWorkspaceFacts),
crossWorkspaceFacts.layout === "split"
&& crossWorkspaceFacts.primarySessionId === primary.sessionId
&& crossWorkspaceFacts.secondarySessionId === crossWorkspacePeer.sessionId
&& crossWorkspaceFacts.primaryPaneWorkspaceId === workspaceA
&& crossWorkspaceFacts.primaryPaneWorkspaceId !== workspaceB
&& crossWorkspaceFacts.secondaryPaneWorkspaceId === workspaceB
&& crossWorkspaceFacts.secondaryPaneWorkspaceId !== workspaceA
&& crossWorkspaceFacts.primarySurfaceWorkspaceId === workspaceA
&& crossWorkspaceFacts.secondarySurfaceWorkspaceId === workspaceB
&& crossWorkspaceFacts.primaryLayoutWorkspaceId === workspaceA
&& crossWorkspaceFacts.secondaryLayoutWorkspaceId === workspaceB
&& crossWorkspaceFacts.primaryResourceWorkspaceId === workspaceA
&& crossWorkspaceFacts.secondaryResourceWorkspaceId === workspaceB
&& crossWorkspaceFacts.primaryWorkspaceName !== crossWorkspaceFacts.secondaryWorkspaceName
&& !crossWorkspaceFacts.primaryOwnsSecondarySurface
&& !crossWorkspaceFacts.secondaryOwnsPrimarySurface
&& !crossWorkspaceFacts.primaryUnavailable
&& !crossWorkspaceFacts.secondaryUnavailable,
);
await screenshot(app);
},
);