Skip to content

A desktop coding agent with free access to frontier models.

TypeScript
16.5 KB
Raw Blame
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);
  },
);