feat(desktop): paginated branch picker with checkout + open actions

apps/desktop/src/renderer/routes/_authenticated/_dashboard/pending/$pendingId/buildIntentPayload.test.ts

@@ -0,0 +1,191 @@
+import { describe, expect, test } from "bun:test";
+import type { PendingWorkspaceRow } from "renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/schema";
+import {
+	buildAdoptPayload,
+	buildCheckoutPayload,
+	buildForkPayload,
+	mapLinkedContextFromPending,
+} from "./buildIntentPayload";
+
+function makePending(
+	overrides: Partial<PendingWorkspaceRow> = {},
+): PendingWorkspaceRow {
+	return {
+		id: "11111111-1111-1111-1111-111111111111",
+		projectId: "22222222-2222-2222-2222-222222222222",
+		hostTarget: { kind: "local" },
+		intent: "fork",
+		name: "my-workspace",
+		branchName: "feature-foo",
+		status: "creating",
+		error: null,
+		workspaceId: null,
+		warnings: [],
+		terminals: [],
+		createdAt: new Date("2026-04-13T00:00:00Z"),
+		prompt: "",
+		baseBranch: null,
+		baseBranchSource: null,
+		linkedIssues: [],
+		linkedPR: null,
+		attachmentCount: 0,
+		runSetupScript: true,
+		...overrides,
+	};
+}
+
+describe("mapLinkedContextFromPending", () => {
+	test("extracts internal task ids from linkedIssues", () => {
+		const mapped = mapLinkedContextFromPending({
+			linkedIssues: [
+				{ slug: "SUP-1", title: "a", source: "internal", taskId: "t1" },
+				{ slug: "SUP-2", title: "b", source: "internal", taskId: "t2" },
+			],
+			linkedPR: null,
+		});
+		expect(mapped.internalIssueIds).toEqual(["t1", "t2"]);
+		expect(mapped.githubIssueUrls).toBeUndefined();
+		expect(mapped.linkedPrUrl).toBeUndefined();
+	});
+
+	test("extracts github urls from linkedIssues", () => {
+		const mapped = mapLinkedContextFromPending({
+			linkedIssues: [
+				{
+					slug: "#1",
+					title: "a",
+					source: "github",
+					url: "https://github.com/o/r/issues/1",
+				},
+			],
+			linkedPR: null,
+		});
+		expect(mapped.githubIssueUrls).toEqual(["https://github.com/o/r/issues/1"]);
+		expect(mapped.internalIssueIds).toBeUndefined();
+	});
+
+	test("skips internal issues missing taskId and github issues missing url", () => {
+		const mapped = mapLinkedContextFromPending({
+			linkedIssues: [
+				{ slug: "SUP-1", title: "no task id", source: "internal" },
+				{ slug: "#1", title: "no url", source: "github" },
+			],
+			linkedPR: null,
+		});
+		expect(mapped.internalIssueIds).toBeUndefined();
+		expect(mapped.githubIssueUrls).toBeUndefined();
+	});
+
+	test("surfaces linkedPR.url", () => {
+		const mapped = mapLinkedContextFromPending({
+			linkedIssues: [],
+			linkedPR: {
+				prNumber: 42,
+				title: "PR 42",
+				url: "https://github.com/o/r/pull/42",
+				state: "open",
+			},
+		});
+		expect(mapped.linkedPrUrl).toBe("https://github.com/o/r/pull/42");
+	});
+
+	test("returns all undefined for empty input", () => {
+		const mapped = mapLinkedContextFromPending({
+			linkedIssues: [],
+			linkedPR: null,
+		});
+		expect(mapped).toEqual({
+			internalIssueIds: undefined,
+			githubIssueUrls: undefined,
+			linkedPrUrl: undefined,
+		});
+	});
+});
+
+describe("buildForkPayload", () => {
+	test("passes fork-specific fields and linked context", () => {
+		const pending = makePending({
+			intent: "fork",
+			prompt: "do the thing",
+			baseBranch: "main",
+			baseBranchSource: "local",
+			linkedIssues: [
+				{ slug: "SUP-1", title: "a", source: "internal", taskId: "t1" },
+			],
+			linkedPR: {
+				prNumber: 3,
+				title: "p",
+				url: "https://github.com/o/r/pull/3",
+				state: "open",
+			},
+		});
+		const payload = buildForkPayload("pid", pending, undefined);
+		expect(payload.pendingId).toBe("pid");
+		expect(payload.projectId).toBe(pending.projectId);
+		expect(payload.hostTarget).toEqual({ kind: "local" });
+		expect(payload.names).toEqual({
+			workspaceName: "my-workspace",
+			branchName: "feature-foo",
+		});
+		expect(payload.composer.prompt).toBe("do the thing");
+		expect(payload.composer.baseBranch).toBe("main");
+		expect(payload.composer.baseBranchSource).toBe("local");
+		expect(payload.linkedContext?.internalIssueIds).toEqual(["t1"]);
+		expect(payload.linkedContext?.linkedPrUrl).toBe(
+			"https://github.com/o/r/pull/3",
+		);
+	});
+
+	test("empty prompt/baseBranch become undefined, not empty strings", () => {
+		const pending = makePending({ prompt: "", baseBranch: null });
+		const payload = buildForkPayload("pid", pending, undefined);
+		expect(payload.composer.prompt).toBeUndefined();
+		expect(payload.composer.baseBranch).toBeUndefined();
+	});
+
+	test("attachments are plumbed through linkedContext", () => {
+		const pending = makePending();
+		const payload = buildForkPayload("pid", pending, [
+			{ data: "b64", mediaType: "image/png", filename: "a.png" },
+		]);
+		expect(payload.linkedContext?.attachments).toHaveLength(1);
+	});
+
+	test("host-tracking hostTarget survives the map", () => {
+		const pending = makePending({
+			hostTarget: { kind: "host", hostId: "h-1" },
+		});
+		const payload = buildForkPayload("pid", pending, undefined);
+		expect(payload.hostTarget).toEqual({ kind: "host", hostId: "h-1" });
+	});
+});
+
+describe("buildCheckoutPayload", () => {
+	test("sends branch + runSetupScript; no composer prompt/baseBranch", () => {
+		const pending = makePending({
+			intent: "checkout",
+			branchName: "feature-foo",
+			runSetupScript: false,
+		});
+		const payload = buildCheckoutPayload("pid", pending);
+		expect(payload.branch).toBe("feature-foo");
+		expect(payload.workspaceName).toBe("my-workspace");
+		expect(payload.composer).toEqual({ runSetupScript: false });
+	});
+});
+
+describe("buildAdoptPayload", () => {
+	test("minimal payload: projectId + host + name + branch", () => {
+		const pending = makePending({
+			intent: "adopt",
+			branchName: "agreeable-ermine",
+		});
+		const payload = buildAdoptPayload(pending);
+		expect(payload).toEqual({
+			projectId: pending.projectId,
+			hostTarget: { kind: "local" },
+			workspaceName: "my-workspace",
+			branch: "agreeable-ermine",
+		});
+	});
+});

apps/desktop/src/renderer/routes/_authenticated/_dashboard/pending/$pendingId/buildIntentPayload.ts

@@ -0,0 +1,88 @@
+import type { AdoptWorktreeInput } from "renderer/routes/_authenticated/components/DashboardNewWorkspaceModal/hooks/useAdoptWorktree/useAdoptWorktree";
+import type { CheckoutWorkspaceInput } from "renderer/routes/_authenticated/components/DashboardNewWorkspaceModal/hooks/useCheckoutDashboardWorkspace/useCheckoutDashboardWorkspace";
+import type { CreateWorkspaceInput } from "renderer/routes/_authenticated/components/DashboardNewWorkspaceModal/hooks/useCreateDashboardWorkspace/useCreateDashboardWorkspace";
+import type { PendingWorkspaceRow } from "renderer/routes/_authenticated/providers/CollectionsProvider/dashboardSidebarLocal/schema";
+
+/**
+ * Pure builders that translate a `PendingWorkspaceRow` into the input shape
+ * each host-service mutation expects. Kept pure (no React, no IO) so the
+ * dispatch logic in the pending page is testable in isolation. See
+ * `buildIntentPayload.test.ts` for the contract suite.
+ */
+
+type Attachment = { data: string; mediaType: string; filename: string };
+
+export function mapLinkedContextFromPending(
+	pending: Pick<PendingWorkspaceRow, "linkedIssues" | "linkedPR">,
+): {
+	internalIssueIds: string[] | undefined;
+	githubIssueUrls: string[] | undefined;
+	linkedPrUrl: string | undefined;
+} {
+	const internalIssueIds = pending.linkedIssues
+		.filter((i) => i.source === "internal" && i.taskId)
+		.map((i) => i.taskId as string);
+	const githubIssueUrls = pending.linkedIssues
+		.filter((i) => i.source === "github" && i.url)
+		.map((i) => i.url as string);
+	return {
+		internalIssueIds:
+			internalIssueIds.length > 0 ? internalIssueIds : undefined,
+		githubIssueUrls: githubIssueUrls.length > 0 ? githubIssueUrls : undefined,
+		linkedPrUrl: pending.linkedPR?.url,
+	};
+}
+
+export function buildForkPayload(
+	pendingId: string,
+	pending: PendingWorkspaceRow,
+	attachments: Attachment[] | undefined,
+): CreateWorkspaceInput {
+	const linked = mapLinkedContextFromPending(pending);
+	return {
+		pendingId,
+		projectId: pending.projectId,
+		hostTarget: pending.hostTarget,
+		names: {
+			workspaceName: pending.name,
+			branchName: pending.branchName,
+		},
+		composer: {
+			prompt: pending.prompt || undefined,
+			baseBranch: pending.baseBranch || undefined,
+			baseBranchSource: pending.baseBranchSource ?? undefined,
+			runSetupScript: pending.runSetupScript,
+		},
+		linkedContext: {
+			internalIssueIds: linked.internalIssueIds,
+			githubIssueUrls: linked.githubIssueUrls,
+			linkedPrUrl: linked.linkedPrUrl,
+			attachments,
+		},
+	};
+}
+
+export function buildCheckoutPayload(
+	pendingId: string,
+	pending: PendingWorkspaceRow,
+): CheckoutWorkspaceInput {
+	return {
+		pendingId,
+		projectId: pending.projectId,
+		hostTarget: pending.hostTarget,
+		workspaceName: pending.name,
+		branch: pending.branchName,
+		composer: { runSetupScript: pending.runSetupScript },
+	};
+}
+
+export function buildAdoptPayload(
+	pending: PendingWorkspaceRow,
+): AdoptWorktreeInput {
+	return {
+		projectId: pending.projectId,
+		hostTarget: pending.hostTarget,
+		workspaceName: pending.name,
+		branch: pending.branchName,
+	};
+}