agentuity-vscode 0.1.10 → 0.1.12

package/src/features/chat/agentTools.ts

@@ -507,7 +507,11 @@ export class ListSandboxesTool implements vscode.LanguageModelTool<ListSandboxes
 
 		const sandboxes = result.data.map((s) => ({
 			id: s.sandboxId,
+			name: s.name,
+			description: s.description,
 			status: s.status,
+			runtime: s.runtimeName ?? s.runtimeId,
+			runtimeId: s.runtimeId,
 			region: s.region,
 			createdAt: s.createdAt,
 			resources: s.resources,
@@ -529,12 +533,57 @@ export class ListSandboxesTool implements vscode.LanguageModelTool<ListSandboxes
 	}
 }
 
+export interface ListSandboxRuntimesInput {
+	limit?: number;
+}
+
+export class ListSandboxRuntimesTool implements vscode.LanguageModelTool<ListSandboxRuntimesInput> {
+	async invoke(
+		options: vscode.LanguageModelToolInvocationOptions<ListSandboxRuntimesInput>,
+		_token: vscode.CancellationToken
+	): Promise<vscode.LanguageModelToolResult> {
+		const cli = getCliClient();
+		const limit = options.input.limit ?? 50;
+		const result = await cli.sandboxRuntimeList({ limit });
+
+		if (!result.success || !result.data) {
+			throw new Error(`Failed to list runtimes: ${result.error || 'Unknown error'}`);
+		}
+
+		const output = result.data.runtimes.map((rt) => ({
+			id: rt.id,
+			name: rt.name,
+			description: rt.description,
+			tags: rt.tags,
+			url: rt.url,
+		}));
+
+		return new vscode.LanguageModelToolResult([
+			new vscode.LanguageModelTextPart(JSON.stringify(output, null, 2)),
+		]);
+	}
+
+	async prepareInvocation(
+		_options: vscode.LanguageModelToolInvocationPrepareOptions<ListSandboxRuntimesInput>,
+		_token: vscode.CancellationToken
+	): Promise<vscode.PreparedToolInvocation> {
+		return {
+			invocationMessage: 'Listing sandbox runtimes...',
+		};
+	}
+}
+
 export interface CreateSandboxInput {
 	memory?: string;
 	cpu?: string;
 	network?: boolean;
 	snapshot?: string;
 	dependencies?: string[];
+	// New fields
+	runtime?: string;
+	runtimeId?: string;
+	name?: string;
+	description?: string;
 }
 
 export class CreateSandboxTool implements vscode.LanguageModelTool<CreateSandboxInput> {
@@ -549,6 +598,10 @@ export class CreateSandboxTool implements vscode.LanguageModelTool<CreateSandbox
 			network: options.input.network,
 			snapshot: options.input.snapshot,
 			dependencies: options.input.dependencies,
+			runtime: options.input.runtime,
+			runtimeId: options.input.runtimeId,
+			name: options.input.name,
+			description: options.input.description,
 		};
 
 		const result = await cli.sandboxCreate(createOptions);
@@ -557,10 +610,20 @@ export class CreateSandboxTool implements vscode.LanguageModelTool<CreateSandbox
 			throw new Error(`Failed to create sandbox: ${result.error || 'Unknown error'}`);
 		}
 
+		const info = result.data;
+		const lines = [
+			'Sandbox created successfully!',
+			'',
+			`ID: ${info.sandboxId}`,
+			info.name ? `Name: ${info.name}` : '',
+			info.description ? `Description: ${info.description}` : '',
+			`Runtime: ${info.runtimeName ?? info.runtimeId ?? 'bun:1'}`,
+			`Status: ${info.status}`,
+			`Region: ${info.region}`,
+		].filter(Boolean);
+
 		return new vscode.LanguageModelToolResult([
-			new vscode.LanguageModelTextPart(
-				`Sandbox created successfully!\n\nID: ${result.data.sandboxId}\nStatus: ${result.data.status}\nRegion: ${result.data.region}`
-			),
+			new vscode.LanguageModelTextPart(lines.join('\n')),
 		]);
 	}
 
@@ -680,6 +743,7 @@ export class ExecuteInSandboxTool implements vscode.LanguageModelTool<ExecuteInS
 export interface CreateSnapshotInput {
 	sandboxId: string;
 	tag?: string;
+	region?: string;
 }
 
 export class CreateSnapshotTool implements vscode.LanguageModelTool<CreateSnapshotInput> {
@@ -759,6 +823,10 @@ export function registerAgentTools(context: vscode.ExtensionContext): void {
 			vscode.lm.registerTool('agentuity_list_sandboxes', new ListSandboxesTool())
 		);
 
+		context.subscriptions.push(
+			vscode.lm.registerTool('agentuity_list_sandbox_runtimes', new ListSandboxRuntimesTool())
+		);
+
 		context.subscriptions.push(
 			vscode.lm.registerTool('agentuity_create_sandbox', new CreateSandboxTool())
 		);

package/src/features/sandboxExplorer/index.ts

@@ -455,6 +455,59 @@ function registerCommands(
 
 // ==================== Command Implementations ====================
 
+interface RuntimePickItem extends vscode.QuickPickItem {
+	runtime?: string;
+	runtimeId?: string;
+}
+
+/**
+ * Show a quick pick to select a sandbox runtime.
+ * Returns undefined if cancelled, or the selected runtime info.
+ */
+async function pickSandboxRuntime(): Promise<{ runtime?: string; runtimeId?: string } | undefined> {
+	const cli = getCliClient();
+
+	// Show progress while loading runtimes
+	const result = await vscode.window.withProgress(
+		{
+			location: vscode.ProgressLocation.Notification,
+			title: 'Loading runtimes...',
+			cancellable: false,
+		},
+		async () => cli.sandboxRuntimeList({ limit: 50 })
+	);
+
+	if (!result.success || !result.data || !result.data.runtimes.length) {
+		// Fall back to default runtime if listing fails
+		const choice = await vscode.window.showQuickPick<RuntimePickItem>(
+			[
+				{ label: 'Use default runtime (base:latest)', runtime: undefined },
+				{ label: 'Cancel', runtime: '__cancel__' },
+			],
+			{ placeHolder: 'Runtime selection (runtime list unavailable)' }
+		);
+		if (!choice || choice.runtime === '__cancel__') {
+			return undefined;
+		}
+		return {}; // no runtime specified => CLI default
+	}
+
+	const items: RuntimePickItem[] = result.data.runtimes.map((rt) => ({
+		label: rt.name,
+		description: rt.description,
+		detail: rt.tags?.length ? rt.tags.join(', ') : undefined,
+		runtime: rt.name,
+		runtimeId: rt.id,
+	}));
+
+	const picked = await vscode.window.showQuickPick(items, {
+		placeHolder: 'Select a sandbox runtime',
+	});
+
+	if (!picked) return undefined;
+	return { runtime: picked.runtime, runtimeId: picked.runtimeId };
+}
+
 async function createSandbox(provider: SandboxTreeDataProvider): Promise<void> {
 	const config = vscode.workspace.getConfiguration('agentuity');
 	const defaultMemory = config.get<string>('sandbox.defaultMemory', '512Mi');
@@ -464,8 +517,8 @@ async function createSandbox(provider: SandboxTreeDataProvider): Promise<void> {
 	// Quick pick for basic vs advanced
 	const mode = await vscode.window.showQuickPick(
 		[
-			{ label: 'Quick Create', description: 'Use default settings' },
-			{ label: 'Custom', description: 'Configure resources and options' },
+			{ label: 'Quick Create', description: 'bun:1 runtime with default settings' },
+			{ label: 'Custom', description: 'Configure runtime, resources and options' },
 		],
 		{ placeHolder: 'How do you want to create the sandbox?' }
 	);
@@ -475,6 +528,28 @@ async function createSandbox(provider: SandboxTreeDataProvider): Promise<void> {
 	let options: SandboxCreateOptions = {};
 
 	if (mode.label === 'Custom') {
+		// Name (optional)
+		const name = await vscode.window.showInputBox({
+			prompt: 'Sandbox name (optional)',
+			placeHolder: 'e.g., my-feature-env',
+		});
+		if (name === undefined) return;
+		options.name = name || undefined;
+
+		// Description (optional)
+		const description = await vscode.window.showInputBox({
+			prompt: 'Sandbox description (optional)',
+			placeHolder: 'e.g., Sandbox for feature-xyz integration tests',
+		});
+		if (description === undefined) return;
+		options.description = description || undefined;
+
+		// Runtime selection
+		const runtimeSelection = await pickSandboxRuntime();
+		if (runtimeSelection === undefined) return;
+		options.runtime = runtimeSelection.runtime;
+		options.runtimeId = runtimeSelection.runtimeId;
+
 		// Memory
 		const memory = await vscode.window.showInputBox({
 			prompt: 'Memory limit',
@@ -513,7 +588,9 @@ async function createSandbox(provider: SandboxTreeDataProvider): Promise<void> {
 			options.dependencies = deps.split(/\s+/).filter(Boolean);
 		}
 	} else {
+		// Quick create uses bun:1 runtime
 		options = {
+			runtime: 'bun:1',
 			memory: defaultMemory,
 			cpu: defaultCpu,
 			network: defaultNetwork,
@@ -531,7 +608,12 @@ async function createSandbox(provider: SandboxTreeDataProvider): Promise<void> {
 			const result = await cli.sandboxCreate(options);
 
 			if (result.success && result.data) {
-				vscode.window.showInformationMessage(`Sandbox created: ${result.data.sandboxId}`);
+				const info = result.data;
+				const displayName = info.name || info.sandboxId.slice(0, 12);
+				const runtimeDisplay = info.runtimeName ?? info.runtimeId ?? 'bun:1';
+				vscode.window.showInformationMessage(
+					`Sandbox "${displayName}" created with runtime ${runtimeDisplay}`
+				);
 				await provider.forceRefresh();
 			} else {
 				vscode.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
@@ -544,6 +626,23 @@ async function createSandboxFromSnapshot(
 	snapshotId: string,
 	provider: SandboxTreeDataProvider
 ): Promise<void> {
+	// Optional: prompt for name/description when creating from snapshot
+	const name = await vscode.window.showInputBox({
+		prompt: 'Sandbox name (optional)',
+		placeHolder: 'e.g., my-feature-env',
+	});
+	if (name === undefined) return;
+
+	const description = await vscode.window.showInputBox({
+		prompt: 'Sandbox description (optional)',
+		placeHolder: 'e.g., Restored from snapshot for testing',
+	});
+	if (description === undefined) return;
+
+	// Runtime selection
+	const runtimeSelection = await pickSandboxRuntime();
+	if (runtimeSelection === undefined) return;
+
 	await vscode.window.withProgress(
 		{
 			location: vscode.ProgressLocation.Notification,
@@ -552,10 +651,21 @@ async function createSandboxFromSnapshot(
 		},
 		async () => {
 			const cli = getCliClient();
-			const result = await cli.sandboxCreate({ snapshot: snapshotId });
+			const result = await cli.sandboxCreate({
+				snapshot: snapshotId,
+				name: name || undefined,
+				description: description || undefined,
+				runtime: runtimeSelection.runtime,
+				runtimeId: runtimeSelection.runtimeId,
+			});
 
 			if (result.success && result.data) {
-				vscode.window.showInformationMessage(`Sandbox created: ${result.data.sandboxId}`);
+				const info = result.data;
+				const displayName = info.name || info.sandboxId.slice(0, 12);
+				const runtimeDisplay = info.runtimeName ?? info.runtimeId ?? 'bun:1';
+				vscode.window.showInformationMessage(
+					`Sandbox "${displayName}" created from snapshot with runtime ${runtimeDisplay}`
+				);
 				await provider.forceRefresh();
 			} else {
 				vscode.window.showErrorMessage(`Failed to create sandbox: ${result.error}`);
@@ -702,9 +812,7 @@ function executeInTerminal(sandboxId: string, command: string): void {
 	}
 
 	terminal.show();
-	terminal.sendText(
-		`${cliPath} cloud sandbox exec ${sandboxId} --region ${cli.getSandboxRegion()} -- ${command}`
-	);
+	terminal.sendText(`${cliPath} cloud sandbox exec ${sandboxId} -- ${command}`);
 }
 
 function disposeTerminals(): void {
@@ -723,22 +831,19 @@ async function viewSandboxFile(sandboxId: string, filePath: string): Promise<voi
 		},
 		async () => {
 			const cli = getCliClient();
-			// Use a stable temp directory for sandbox files
 			const sandboxTmpDir = path.join(os.tmpdir(), 'agentuity-sandbox', sandboxId.slice(0, 12));
 			fs.mkdirSync(sandboxTmpDir, { recursive: true });
 
 			const fileName = path.basename(filePath);
 			const localPath = path.join(sandboxTmpDir, fileName);
 
-			// Build full remote path under sandbox home
 			const fullRemotePath = filePath.startsWith('/')
 				? filePath
 				: `${CliClient.SANDBOX_HOME}/${filePath}`;
 
-			const result = await cli.sandboxCpFromSandbox(sandboxId, fullRemotePath, localPath);
+			const result = await cli.sandboxCpFromSandbox(sandboxId, fullRemotePath, localPath, false);
 
 			if (result.success) {
-				// Track this file for save-back
 				sandboxFileMap.set(localPath, {
 					sandboxId,
 					remotePath: fullRemotePath,
@@ -760,7 +865,7 @@ async function uploadSavedFile(
 	provider: SandboxTreeDataProvider
 ): Promise<void> {
 	const cli = getCliClient();
-	const result = await cli.sandboxCpToSandbox(sandboxId, localPath, remotePath);
+	const result = await cli.sandboxCpToSandbox(sandboxId, localPath, remotePath, false);
 
 	if (result.success) {
 		vscode.window.showInformationMessage(`Saved to sandbox: ${path.basename(remotePath)}`);
@@ -1057,8 +1162,7 @@ async function viewEnv(sandboxId: string): Promise<void> {
 		},
 		async () => {
 			const cli = getCliClient();
-			// Use exec to run 'env' command to get actual runtime environment
-			const result = await cli.sandboxExec(sandboxId, ['env']);
+			const result = await cli.sandboxExec(sandboxId, ['env'], {});
 
 			if (result.success && result.data) {
 				const content = result.data.output || '(no environment variables)';
@@ -1332,32 +1436,42 @@ async function downloadFile(url: string, destPath: string): Promise<void> {
 }
 
 async function uploadToSandbox(uri: vscode.Uri): Promise<void> {
-	const linked = getSandboxManager().getLinkedSandboxes();
+	const cli = getCliClient();
 
-	if (linked.length === 0) {
-		vscode.window.showWarningMessage('No sandbox linked. Link a sandbox first.');
+	// Fetch all sandboxes
+	const listResult = await vscode.window.withProgress(
+		{
+			location: vscode.ProgressLocation.Notification,
+			title: 'Loading sandboxes...',
+			cancellable: false,
+		},
+		async () => cli.sandboxList()
+	);
+
+	if (!listResult.success || !listResult.data || listResult.data.length === 0) {
+		vscode.window.showWarningMessage('No sandboxes available. Create a sandbox first.');
 		return;
 	}
 
-	let sandboxId: string;
-	if (linked.length === 1) {
-		sandboxId = linked[0].sandboxId;
-	} else {
-		const picked = await vscode.window.showQuickPick(
-			linked.map((l) => ({
-				label: l.name || l.sandboxId,
-				description: l.sandboxId,
-				sandboxId: l.sandboxId,
-			})),
-			{ placeHolder: 'Select sandbox to upload to' }
-		);
-		if (!picked) return;
-		sandboxId = picked.sandboxId;
-	}
+	const sandboxes = listResult.data;
+
+	// Pick a sandbox
+	const picked = await vscode.window.showQuickPick(
+		sandboxes.map((s) => ({
+			label: s.name || s.sandboxId.slice(0, 12),
+			description: `${s.status} · ${s.runtimeName ?? s.runtimeId ?? 'base'}`,
+			detail: s.sandboxId,
+			sandbox: s,
+		})),
+		{ placeHolder: 'Select sandbox to upload to' }
+	);
+
+	if (!picked) return;
+	const selectedSandbox = picked.sandbox;
 
 	const remotePath = await vscode.window.showInputBox({
 		prompt: 'Remote path',
-		value: linked.find((l) => l.sandboxId === sandboxId)?.remotePath || DEFAULT_SANDBOX_PATH,
+		value: DEFAULT_SANDBOX_PATH,
 	});
 
 	if (!remotePath) return;
@@ -1369,11 +1483,21 @@ async function uploadToSandbox(uri: vscode.Uri): Promise<void> {
 			cancellable: false,
 		},
 		async () => {
-			const cli = getCliClient();
 			const stats = await vscode.workspace.fs.stat(uri);
 			const isDir = stats.type === vscode.FileType.Directory;
 
-			const result = await cli.sandboxCpToSandbox(sandboxId, uri.fsPath, remotePath, isDir);
+			// Build full remote path including filename
+			const fileName = path.basename(uri.fsPath);
+			const fullRemotePath = remotePath.endsWith('/')
+				? `${remotePath}${fileName}`
+				: `${remotePath}/${fileName}`;
+
+			const result = await cli.sandboxCpToSandbox(
+				selectedSandbox.sandboxId,
+				uri.fsPath,
+				fullRemotePath,
+				isDir
+			);
 
 			if (result.success) {
 				vscode.window.showInformationMessage(`Uploaded to ${remotePath}`);

package/src/features/sandboxExplorer/sandboxTreeData.ts

@@ -39,7 +39,8 @@ export class SandboxTreeItem extends vscode.TreeItem {
 		public readonly parentSandboxId?: string,
 		public readonly categoryType?: 'files' | 'snapshots' | 'executions',
 		public readonly linkedData?: LinkedSandbox,
-		public readonly filePath?: string
+		public readonly filePath?: string,
+		public readonly region?: string
 	) {
 		super(label, collapsibleState);
 		this.setupItem();
@@ -92,9 +93,17 @@ export class SandboxTreeItem extends vscode.TreeItem {
 		}
 		this.contextValue = contextValue;
 
-		// Set description
+		// Set description with status and runtime
 		const statusLabel = status.charAt(0).toUpperCase() + status.slice(1);
-		this.description = isLinked ? `${statusLabel} [linked]` : statusLabel;
+		const runtimeLabel = this.sandboxData.runtimeName ?? this.sandboxData.runtimeId ?? 'bun:1';
+		let desc = `${statusLabel} · ${runtimeLabel}`;
+		if (this.sandboxData.url) {
+			desc += ' 🌐';
+		}
+		if (isLinked) {
+			desc += ' [linked]';
+		}
+		this.description = desc;
 
 		// Set tooltip
 		this.tooltip = this.formatSandboxTooltip();
@@ -135,12 +144,35 @@ export class SandboxTreeItem extends vscode.TreeItem {
 	private formatSandboxTooltip(): string {
 		if (!this.sandboxData) return '';
 
-		const lines = [
-			`ID: ${this.sandboxData.sandboxId}`,
-			`Status: ${this.sandboxData.status}`,
-			`Region: ${this.sandboxData.region}`,
-			`Created: ${new Date(this.sandboxData.createdAt).toLocaleString()}`,
-		];
+		const lines: string[] = [];
+
+		// Name and description first if present
+		if (this.sandboxData.name) {
+			lines.push(`Name: ${this.sandboxData.name}`);
+		}
+		if (this.sandboxData.description) {
+			lines.push(`Description: ${this.sandboxData.description}`);
+		}
+
+		lines.push(`ID: ${this.sandboxData.sandboxId}`);
+		lines.push(`Status: ${this.sandboxData.status}`);
+
+		// Runtime info
+		const runtimeDisplay = this.sandboxData.runtimeName ?? this.sandboxData.runtimeId ?? 'bun:1';
+		lines.push(`Runtime: ${runtimeDisplay}`);
+
+		if (this.sandboxData.region) {
+			lines.push(`Region: ${this.sandboxData.region}`);
+		}
+		lines.push(`Created: ${new Date(this.sandboxData.createdAt).toLocaleString()}`);
+
+		// Network/URL info
+		if (this.sandboxData.url) {
+			lines.push(`URL: ${this.sandboxData.url}`);
+		}
+		if (this.sandboxData.networkPort) {
+			lines.push(`Port: ${this.sandboxData.networkPort}`);
+		}
 
 		if (this.sandboxData.resources) {
 			const r = this.sandboxData.resources;
@@ -382,20 +414,21 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 
 		// Category children
 		if (element.itemType === 'category' && element.parentSandboxId) {
+			const region = element.sandboxData?.region;
 			switch (element.categoryType) {
 				case 'files':
 					// Pass undefined for root listing (CLI defaults to sandbox home)
-					return this.getFilesChildren(element.parentSandboxId, undefined);
+					return this.getFilesChildren(element.parentSandboxId, undefined, region);
 				case 'snapshots':
-					return this.getSnapshotsChildren(element.parentSandboxId);
+					return this.getSnapshotsChildren(element.parentSandboxId, region);
 				case 'executions':
-					return this.getExecutionsChildren(element.parentSandboxId);
+					return this.getExecutionsChildren(element.parentSandboxId, region);
 			}
 		}
 
 		// Directory children
 		if (element.itemType === 'directory' && element.parentSandboxId && element.filePath) {
-			return this.getFilesChildren(element.parentSandboxId, element.filePath);
+			return this.getFilesChildren(element.parentSandboxId, element.filePath, element.region);
 		}
 
 		// Snapshot children (files from snapshot get)
@@ -469,7 +502,11 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		// Add sandbox items
 		for (const sandbox of this.sandboxes) {
 			const linked = linkedSandboxes.find((l) => l.sandboxId === sandbox.sandboxId);
-			const displayName = linked?.name || sandbox.sandboxId;
+			// Prefer server-side name, then linked alias, then short ID
+			const displayName =
+				sandbox.name && sandbox.name.trim().length > 0
+					? sandbox.name
+					: linked?.name || sandbox.sandboxId.slice(0, 12);
 
 			items.push(
 				new SandboxTreeItem(
@@ -552,15 +589,18 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		];
 	}
 
-	private async getFilesChildren(sandboxId: string, dirPath?: string): Promise<SandboxTreeItem[]> {
+	private async getFilesChildren(
+		sandboxId: string,
+		dirPath?: string,
+		region?: string
+	): Promise<SandboxTreeItem[]> {
 		// Always fetch from root to get full file list, then filter
 		const cacheKey = `${sandboxId}:root`;
 
 		// Check cache first - always cache from root
 		if (!this.filesCache.has(cacheKey)) {
 			const cli = getCliClient();
-			// Always fetch from root (no path) to get complete file list
-			const result = await cli.sandboxLs(sandboxId);
+			const result = await cli.sandboxLs(sandboxId, undefined);
 
 			if (result.success && result.data) {
 				this.filesCache.set(cacheKey, result.data);
@@ -621,12 +661,16 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 				sandboxId,
 				undefined,
 				undefined,
-				file.path // Use the full path from CLI
+				file.path, // Use the full path from CLI
+				region // Pass region to child items
 			);
 		});
 	}
 
-	private async getSnapshotsChildren(sandboxId: string): Promise<SandboxTreeItem[]> {
+	private async getSnapshotsChildren(
+		sandboxId: string,
+		region?: string
+	): Promise<SandboxTreeItem[]> {
 		if (!this.snapshotsCache.has(sandboxId)) {
 			const cli = getCliClient();
 			const result = await cli.snapshotList(sandboxId);
@@ -663,7 +707,11 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 					undefined,
 					snap,
 					undefined,
-					sandboxId
+					sandboxId,
+					undefined,
+					undefined,
+					undefined,
+					region
 				)
 		);
 	}
@@ -720,7 +768,10 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		});
 	}
 
-	private async getExecutionsChildren(sandboxId: string): Promise<SandboxTreeItem[]> {
+	private async getExecutionsChildren(
+		sandboxId: string,
+		region?: string
+	): Promise<SandboxTreeItem[]> {
 		if (!this.executionsCache.has(sandboxId)) {
 			const cli = getCliClient();
 			const result = await cli.executionList(sandboxId);
@@ -756,7 +807,11 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 					undefined,
 					undefined,
 					exec,
-					sandboxId
+					sandboxId,
+					undefined,
+					undefined,
+					undefined,
+					region
 				)
 		);
 	}

package/src/features/sandboxExplorer/statusBar.ts

@@ -40,8 +40,20 @@ export function updateStatusBar(): void {
 	} else if (linked.length === 1) {
 		const sandbox = linked[0];
 		const name = sandbox.name || sandbox.sandboxId.slice(0, 8);
+		const runtime = sandbox.runtimeName ?? sandbox.runtimeId ?? 'bun:1';
 		statusBarItem.text = `$(vm) ${name}`;
-		statusBarItem.tooltip = `Sandbox: ${sandbox.sandboxId}\nLinked: ${new Date(sandbox.linkedAt).toLocaleDateString()}\nLast sync: ${sandbox.lastSyncedAt ? new Date(sandbox.lastSyncedAt).toLocaleString() : 'Never'}\n\nClick for sandbox options`;
+
+		const tooltipLines = [
+			`Sandbox: ${sandbox.sandboxId}`,
+			`Runtime: ${runtime}`,
+			`Linked: ${new Date(sandbox.linkedAt).toLocaleDateString()}`,
+			`Last sync: ${sandbox.lastSyncedAt ? new Date(sandbox.lastSyncedAt).toLocaleString() : 'Never'}`,
+		];
+		if (sandbox.description) {
+			tooltipLines.unshift(`Description: ${sandbox.description}`);
+		}
+		tooltipLines.push('', 'Click for sandbox options');
+		statusBarItem.tooltip = tooltipLines.join('\n');
 		statusBarItem.backgroundColor = undefined;
 	} else {
 		statusBarItem.text = `$(vm) ${linked.length} Sandboxes`;
@@ -125,9 +137,10 @@ async function showSandboxQuickPick(): Promise<void> {
 
 		for (const sandbox of linked) {
 			const name = sandbox.name || sandbox.sandboxId.slice(0, 8);
+			const runtime = sandbox.runtimeName ?? sandbox.runtimeId ?? 'bun:1';
 			items.push({
 				label: `$(vm) ${name}`,
-				description: sandbox.sandboxId,
+				description: `${runtime} · ${sandbox.sandboxId.slice(0, 8)}`,
 				detail: sandbox.lastSyncedAt
 					? `Last synced: ${new Date(sandbox.lastSyncedAt).toLocaleString()}`
 					: 'Never synced',