feat: manage tab lifecycle

Author: caffeinum

apps/desktop/src/lib/trpc/routers/workspaces/workspaces.ts

@@ -1,5 +1,6 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { cloudApiClient } from "main/lib/cloud-api-client";
 import { db } from "main/lib/db";
 import { nanoid } from "nanoid";
 import { SUPERSET_DIR_NAME, WORKTREES_DIR_NAME } from "shared/constants";
@@ -114,11 +115,17 @@ export const createWorkspacesRouter = () => {
 			return db.data.workspaces.slice().sort((a, b) => a.tabOrder - b.tabOrder);
 		}),
 
-		getAllGrouped: publicProcedure.query(() => {
+		getAllGrouped: publicProcedure.query(async () => {
 			const activeProjects = db.data.projects.filter(
 				(p) => p.tabOrder !== null,
 			);
 
+			// Fetch live sandbox statuses
+			const sandboxResult = await cloudApiClient.listSandboxes();
+			const liveSandboxes = new Map(
+				(sandboxResult.sandboxes ?? []).map((s) => [s.id, s.status]),
+			);
+
 			const groupsMap = new Map<
 				string,
 				{
@@ -138,6 +145,8 @@ export const createWorkspacesRouter = () => {
 						createdAt: number;
 						updatedAt: number;
 						lastOpenedAt: number;
+						cloudSandboxId?: string;
+						cloudSandboxStatus?: string;
 					}>;
 				}
 			>();
@@ -161,9 +170,24 @@ export const createWorkspacesRouter = () => {
 
 			for (const workspace of workspaces) {
 				if (groupsMap.has(workspace.projectId)) {
+					const worktree = db.data.worktrees.find(
+						(wt) => wt.id === workspace.worktreeId,
+					);
+					const sandboxId = worktree?.cloudSandbox?.id;
+					// Use live status if available, fallback to stored status
+					const liveStatus = sandboxId
+						? liveSandboxes.get(sandboxId)
+						: undefined;
+					// If sandbox exists in db but not in live list, it's stopped/deleted
+					const status = sandboxId
+						? (liveStatus ?? "stopped")
+						: worktree?.cloudSandbox?.status;
+
 					groupsMap.get(workspace.projectId)?.workspaces.push({
 						...workspace,
 						worktreePath: getWorktreePath(workspace.worktreeId) ?? "",
+						cloudSandboxId: sandboxId,
+						cloudSandboxStatus: status,
 					});
 				}
 			}
@@ -295,6 +319,19 @@ export const createWorkspacesRouter = () => {
 					(p) => p.id === workspace.projectId,
 				);
 
+				// Kill cloud sandbox if present
+				if (worktree?.cloudSandbox?.id) {
+					try {
+						console.log(
+							`Deleting cloud sandbox ${worktree.cloudSandbox.id} for worktree ${worktree.id}`,
+						);
+						await cloudApiClient.deleteSandbox(worktree.cloudSandbox.id);
+					} catch (error) {
+						console.error("Failed to delete cloud sandbox:", error);
+						// Continue with deletion even if sandbox deletion fails
+					}
+				}
+
 				if (worktree && project) {
 					try {
 						const exists = await worktreeExists(
@@ -408,6 +445,26 @@ export const createWorkspacesRouter = () => {
 
 				return { success: true };
 			}),
+
+		getDanglingSandboxes: publicProcedure.query(async () => {
+			// Get all sandboxes from the cloud API
+			const result = await cloudApiClient.listSandboxes();
+			if (!result.success || !result.sandboxes) {
+				return [];
+			}
+
+			// Get all sandbox IDs that are linked to worktrees
+			const linkedSandboxIds = new Set(
+				db.data.worktrees
+					.filter((wt) => wt.cloudSandbox?.id)
+					.map((wt) => wt.cloudSandbox?.id),
+			);
+
+			// Return only running sandboxes that are not linked to any worktree
+			return result.sandboxes.filter(
+				(s) => !linkedSandboxIds.has(s.id) && s.status === "running",
+			);
+		}),
 	});
 };
 

apps/desktop/src/main/lib/cloud-api-client.ts

@@ -29,6 +29,15 @@ interface CreateSandboxResponse {
 	claudeHost: string;
 }
 
+interface ListSandboxResponse {
+	id: string;
+	name: string;
+	status: string;
+	websshHost?: string;
+	claudeHost?: string;
+	createdAt: string;
+}
+
 /**
  * Client for interacting with yolocode cloud API
  * Uses GitHub token for authentication
@@ -180,6 +189,85 @@ class CloudApiClient {
 			};
 		}
 	}
+
+	/**
+	 * List all sandboxes for the current user
+	 */
+	async listSandboxes(): Promise<{
+		success: boolean;
+		sandboxes?: CloudSandbox[];
+		error?: string;
+	}> {
+		const token = this.getGithubToken();
+		if (!token) {
+			return {
+				success: false,
+				error: "GitHub authentication required",
+			};
+		}
+
+		try {
+			const response = await fetch(this.baseUrl, {
+				method: "GET",
+				headers: {
+					Authorization: `Bearer ${token}`,
+				},
+			});
+
+			if (!response.ok) {
+				return {
+					success: false,
+					error: `Failed to list sandboxes: ${response.statusText}`,
+				};
+			}
+
+			const data: ListSandboxResponse[] = await response.json();
+
+			const sandboxes: CloudSandbox[] = data.map((s) => ({
+				id: s.id,
+				name: s.name,
+				status: s.status === "running" ? "running" : "stopped",
+				websshHost: s.websshHost,
+				claudeHost: s.claudeHost?.replace(/https:\/\/\d+-/, (match) =>
+					match.replace(/\d+/, "7030"),
+				),
+				createdAt: s.createdAt,
+			}));
+
+			return { success: true, sandboxes };
+		} catch (error) {
+			console.error("Failed to list sandboxes:", error);
+			return {
+				success: false,
+				error: error instanceof Error ? error.message : String(error),
+			};
+		}
+	}
+
+	/**
+	 * Get status of a specific sandbox
+	 */
+	async getSandboxStatus(sandboxId: string): Promise<{
+		success: boolean;
+		status?: "running" | "stopped" | "error";
+		error?: string;
+	}> {
+		const result = await this.listSandboxes();
+		if (!result.success || !result.sandboxes) {
+			return { success: false, error: result.error };
+		}
+
+		const sandbox = result.sandboxes.find((s) => s.id === sandboxId);
+		if (!sandbox) {
+			// Sandbox not found - might have been deleted
+			return { success: true, status: "stopped" };
+		}
+
+		return {
+			success: true,
+			status: sandbox.status as "running" | "stopped",
+		};
+	}
 }
 
 export const cloudApiClient = new CloudApiClient();

apps/desktop/src/main/lib/cloud-ipcs.ts

@@ -2,6 +2,7 @@ import { execSync } from "node:child_process";
 import { ipcMain } from "electron";
 import { cloudApiClient } from "./cloud-api-client";
 import { db } from "./db";
+import type { CloudSandbox } from "./db/schemas";
 
 /**
  * Extract GitHub repo URL from a local git repository path
@@ -78,4 +79,41 @@ export function registerCloudHandlers() {
 			return cloudApiClient.deleteSandbox(input.sandboxId);
 		},
 	);
+
+	ipcMain.handle("cloud-sandbox-list", async () => {
+		return cloudApiClient.listSandboxes();
+	});
+
+	ipcMain.handle(
+		"cloud-sandbox-status",
+		async (_event, input: { sandboxId: string }) => {
+			return cloudApiClient.getSandboxStatus(input.sandboxId);
+		},
+	);
+
+	ipcMain.handle(
+		"worktree-set-cloud-sandbox",
+		async (
+			_event,
+			input: { worktreeId: string; cloudSandbox: CloudSandbox | null },
+		) => {
+			try {
+				await db.update((data) => {
+					const worktree = data.worktrees.find(
+						(wt) => wt.id === input.worktreeId,
+					);
+					if (worktree) {
+						worktree.cloudSandbox = input.cloudSandbox ?? undefined;
+					}
+				});
+				return { success: true };
+			} catch (error) {
+				console.error("Failed to update worktree sandbox:", error);
+				return {
+					success: false,
+					error: error instanceof Error ? error.message : String(error),
+				};
+			}
+		},
+	);
 }

apps/desktop/src/main/lib/db/schemas.ts

@@ -8,12 +8,23 @@ export interface Project {
 	createdAt: number;
 }
 
+export interface CloudSandbox {
+	id: string;
+	name: string;
+	status: "creating" | "running" | "stopped" | "error";
+	websshHost?: string;
+	claudeHost?: string;
+	createdAt: string;
+	error?: string;
+}
+
 export interface Worktree {
 	id: string;
 	projectId: string;
 	path: string;
 	branch: string;
 	createdAt: number;
+	cloudSandbox?: CloudSandbox;
 }
 
 export interface Workspace {

apps/desktop/src/renderer/screens/main/components/TopBar/WorkspaceTabs/CloudWorkspaceButton.tsx

@@ -66,6 +66,7 @@ export function CloudWorkspaceButton({ className }: CloudWorkspaceButtonProps) {
 			// 1. Create local workspace first
 			const workspaceResult = await createWorkspace.mutateAsync({ projectId });
 			const workspaceId = workspaceResult.workspace.id;
+			const worktreeId = workspaceResult.workspace.worktreeId;
 
 			// 2. Create cloud sandbox
 			const sandboxName = generateSandboxName();
@@ -81,7 +82,15 @@ export function CloudWorkspaceButton({ className }: CloudWorkspaceButtonProps) {
 
 			const sandbox = result.sandbox;
 
-			// 3. Add two webview tabs: Claude chat (7030) and WebSSH (8888)
+			// 3. Save sandbox to worktree
+			if (sandbox) {
+				await window.ipcRenderer.invoke("worktree-set-cloud-sandbox", {
+					worktreeId,
+					cloudSandbox: sandbox,
+				});
+			}
+
+			// 4. Add two webview tabs: Claude chat (7030) and WebSSH (8888)
 			if (sandbox?.claudeHost) {
 				const claudeUrl = sandbox.claudeHost.startsWith("http")
 					? sandbox.claudeHost