agentuity-vscode 0.1.9 → 0.1.11

package/package.json

@@ -2,7 +2,7 @@
 	"name": "agentuity-vscode",
 	"displayName": "Agentuity VSCode Extension",
 	"description": "Build, deploy, and manage AI agents with Agentuity",
-	"version": "0.1.9",
+	"version": "0.1.11",
 	"publisher": "agentuity",
 	"license": "Apache-2.0",
 	"repository": {

package/src/core/cliClient.ts

@@ -103,19 +103,6 @@ export class CliClient {
 		return args;
 	}
 
-	/**
-	 * Append --region flag to args using region from agentuity.json.
-	 * Used for commands that require region but don't accept --dir.
-	 * The --region flag is a subcommand option, so it must come after the command.
-	 */
-	private withRegion(args: string[]): string[] {
-		const region = this.getProjectRegion();
-		if (region) {
-			return [...args, '--region', region];
-		}
-		return args;
-	}
-
 	/**
 	 * Get the environment variables for CLI execution.
 	 * Sets TERM_PROGRAM=vscode to ensure CLI disables interactive mode.
@@ -329,15 +316,14 @@ export class CliClient {
 		return this.exec<string>(['ai', 'prompt', 'llm'], { format: 'text' });
 	}
 
-	// Database methods (require region - pass --region from agentuity.json)
 	async listDatabases(): Promise<CliResult<DbListResponse>> {
-		return this.exec<DbListResponse>(this.withRegion(['cloud', 'db', 'list']), {
+		return this.exec<DbListResponse>(['cloud', 'db', 'list'], {
 			format: 'json',
 		});
 	}
 
 	async getDatabase(name: string): Promise<CliResult<DbInfo>> {
-		return this.exec<DbInfo>(this.withRegion(['cloud', 'db', 'get', name]), {
+		return this.exec<DbInfo>(['cloud', 'db', 'get', name], {
 			format: 'json',
 		});
 	}
@@ -356,12 +342,11 @@ export class CliClient {
 		if (opts?.sessionId) {
 			args.push('--session-id', opts.sessionId);
 		}
-		return this.exec<DbQueryLog[]>(this.withRegion(args), { format: 'json', timeout: 60000 });
+		return this.exec<DbQueryLog[]>(args, { format: 'json', timeout: 60000 });
 	}
 
-	// Storage methods (require region - pass --region from agentuity.json)
 	async listStorageBuckets(): Promise<CliResult<StorageListResponse>> {
-		return this.exec<StorageListResponse>(this.withRegion(['cloud', 'storage', 'list']), {
+		return this.exec<StorageListResponse>(['cloud', 'storage', 'list'], {
 			format: 'json',
 		});
 	}
@@ -374,7 +359,7 @@ export class CliClient {
 		if (prefix) {
 			args.push(prefix);
 		}
-		return this.exec<StorageListResponse>(this.withRegion(args), { format: 'json' });
+		return this.exec<StorageListResponse>(args, { format: 'json' });
 	}
 
 	async getStorageFileMetadata(
@@ -382,7 +367,7 @@ export class CliClient {
 		filename: string
 	): Promise<CliResult<StorageFileMetadataResponse>> {
 		return this.exec<StorageFileMetadataResponse>(
-			this.withRegion(['cloud', 'storage', 'download', bucket, filename, '--metadata']),
+			['cloud', 'storage', 'download', bucket, filename, '--metadata'],
 			{ format: 'json' }
 		);
 	}
@@ -509,17 +494,6 @@ export class CliClient {
 
 	// ==================== Sandbox Methods ====================
 
-	/** Default region for sandbox operations when no agentuity.json is present */
-	private readonly defaultSandboxRegion = 'usc';
-
-	/**
-	 * Get the region for sandbox operations.
-	 * Uses region from agentuity.json if present, otherwise falls back to default.
-	 */
-	getSandboxRegion(): string {
-		return this.getProjectRegion() ?? this.defaultSandboxRegion;
-	}
-
 	/** Default home path in sandboxes */
 	static readonly SANDBOX_HOME = '/home/agentuity';
 
@@ -527,8 +501,23 @@ export class CliClient {
 	 * Create a new sandbox.
 	 */
 	async sandboxCreate(options: SandboxCreateOptions = {}): Promise<CliResult<SandboxInfo>> {
-		const args = ['cloud', 'sandbox', 'create', '--region', this.getSandboxRegion()];
+		const region = this.getProjectRegion() ?? 'usc';
+		const args = ['cloud', 'sandbox', 'create', '--region', region];
 
+		// New runtime/name/description options
+		if (options.runtime) {
+			args.push('--runtime', options.runtime);
+		}
+		if (options.runtimeId) {
+			args.push('--runtime-id', options.runtimeId);
+		}
+		if (options.name) {
+			args.push('--name', options.name);
+		}
+		if (options.description) {
+			args.push('--description', options.description);
+		}
+		// Existing options
 		if (options.memory) {
 			args.push('--memory', options.memory);
 		}
@@ -569,11 +558,31 @@ export class CliClient {
 		return this.exec<SandboxInfo>(args, { format: 'json', timeout: 120000 });
 	}
 
+	/**
+	 * List available sandbox runtimes.
+	 */
+	async sandboxRuntimeList(
+		params: SandboxRuntimeListParams = {}
+	): Promise<CliResult<SandboxRuntimeListResponse>> {
+		const args = ['cloud', 'sandbox', 'runtime', 'list'];
+
+		if (params.limit !== undefined) {
+			args.push('--limit', String(params.limit));
+		}
+		if (params.offset !== undefined) {
+			args.push('--offset', String(params.offset));
+		}
+
+		return this.exec<SandboxRuntimeListResponse>(args, { format: 'json' });
+	}
+
 	/**
 	 * List sandboxes with optional filtering.
+	 * Runs from home directory to list all sandboxes since sandbox create
+	 * doesn't currently support project association.
 	 */
 	async sandboxList(filter: SandboxListFilter = {}): Promise<CliResult<SandboxInfo[]>> {
-		const args = ['cloud', 'sandbox', 'list', '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'list'];
 
 		if (filter.status) {
 			args.push('--status', filter.status);
@@ -588,9 +597,12 @@ export class CliClient {
 			args.push('--offset', String(filter.offset));
 		}
 
-		// CLI returns { sandboxes: [...], total: N }, extract the array
+		// Run from home directory to list all sandboxes
+		// CLI filters by project when run from project dir, but sandbox create
+		// doesn't support project association yet
 		const result = await this.exec<{ sandboxes: SandboxInfo[]; total: number }>(args, {
 			format: 'json',
+			cwd: os.homedir(),
 		});
 		if (result.success && result.data) {
 			return { success: true, data: result.data.sandboxes || [], exitCode: result.exitCode };
@@ -602,28 +614,16 @@ export class CliClient {
 	 * Get detailed information about a sandbox.
 	 */
 	async sandboxGet(sandboxId: string): Promise<CliResult<SandboxInfo>> {
-		return this.exec<SandboxInfo>(
-			['cloud', 'sandbox', 'get', sandboxId, '--region', this.getSandboxRegion()],
-			{ format: 'json' }
-		);
+		return this.exec<SandboxInfo>(['cloud', 'sandbox', 'get', sandboxId], { format: 'json' });
 	}
 
 	/**
 	 * Delete a sandbox.
 	 */
 	async sandboxDelete(sandboxId: string): Promise<CliResult<void>> {
-		return this.exec<void>(
-			[
-				'cloud',
-				'sandbox',
-				'delete',
-				sandboxId,
-				'--confirm',
-				'--region',
-				this.getSandboxRegion(),
-			],
-			{ format: 'json' }
-		);
+		return this.exec<void>(['cloud', 'sandbox', 'delete', sandboxId, '--confirm'], {
+			format: 'json',
+		});
 	}
 
 	/**
@@ -635,7 +635,7 @@ export class CliClient {
 		command: string[],
 		options: SandboxExecOptions = {}
 	): Promise<CliResult<ExecutionInfo>> {
-		const args = ['cloud', 'sandbox', 'exec', sandboxId, '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'exec', sandboxId];
 
 		if (options.timeout) {
 			args.push('--timeout', String(options.timeout));
@@ -655,13 +655,11 @@ export class CliClient {
 	 */
 	async sandboxLs(sandboxId: string, remotePath?: string): Promise<CliResult<SandboxFileInfo[]>> {
 		const args = ['cloud', 'sandbox', 'files', sandboxId];
-		// Only add path if specified (omit for root listing)
 		if (remotePath) {
 			args.push(remotePath);
 		}
-		args.push('-l', '--region', this.getSandboxRegion());
+		args.push('-l');
 
-		// CLI returns { files: [...], total: N }, extract the array and add name from path
 		const result = await this.exec<{
 			files: Array<Omit<SandboxFileInfo, 'name'>>;
 			total: number;
@@ -669,7 +667,7 @@ export class CliClient {
 		if (result.success && result.data) {
 			const files = (result.data.files || []).map((f) => ({
 				...f,
-				name: f.path.split('/').pop() || f.path, // Extract filename from path
+				name: f.path.split('/').pop() || f.path,
 			}));
 			return { success: true, data: files, exitCode: result.exitCode };
 		}
@@ -685,7 +683,7 @@ export class CliClient {
 		remotePath: string,
 		recursive = false
 	): Promise<CliResult<SandboxCpResult>> {
-		const args = ['cloud', 'sandbox', 'cp', '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'cp'];
 		if (recursive) {
 			args.push('-r');
 		}
@@ -702,7 +700,7 @@ export class CliClient {
 		localPath: string,
 		recursive = false
 	): Promise<CliResult<SandboxCpResult>> {
-		const args = ['cloud', 'sandbox', 'cp', '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'cp'];
 		if (recursive) {
 			args.push('-r');
 		}
@@ -718,15 +716,7 @@ export class CliClient {
 		archivePath: string,
 		destPath?: string
 	): Promise<CliResult<void>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'upload',
-			sandboxId,
-			archivePath,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'upload', sandboxId, archivePath];
 		if (destPath) {
 			args.push('--path', destPath);
 		}
@@ -741,15 +731,7 @@ export class CliClient {
 		outputPath: string,
 		sourcePath?: string
 	): Promise<CliResult<void>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'download',
-			sandboxId,
-			outputPath,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'download', sandboxId, outputPath];
 		if (sourcePath) {
 			args.push('--path', sourcePath);
 		}
@@ -764,15 +746,7 @@ export class CliClient {
 		remotePath: string,
 		recursive = false
 	): Promise<CliResult<void>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'mkdir',
-			sandboxId,
-			remotePath,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'mkdir', sandboxId, remotePath];
 		if (recursive) {
 			args.push('-p');
 		}
@@ -783,10 +757,7 @@ export class CliClient {
 	 * Remove a file from a sandbox.
 	 */
 	async sandboxRm(sandboxId: string, remotePath: string): Promise<CliResult<void>> {
-		return this.exec<void>(
-			['cloud', 'sandbox', 'rm', sandboxId, remotePath, '--region', this.getSandboxRegion()],
-			{ format: 'json' }
-		);
+		return this.exec<void>(['cloud', 'sandbox', 'rm', sandboxId, remotePath], { format: 'json' });
 	}
 
 	/**
@@ -797,15 +768,7 @@ export class CliClient {
 		remotePath: string,
 		recursive = false
 	): Promise<CliResult<void>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'rmdir',
-			sandboxId,
-			remotePath,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'rmdir', sandboxId, remotePath];
 		if (recursive) {
 			args.push('-r');
 		}
@@ -819,7 +782,7 @@ export class CliClient {
 		sandboxId: string,
 		vars: Record<string, string>
 	): Promise<CliResult<SandboxEnvResult>> {
-		const args = ['cloud', 'sandbox', 'env', sandboxId, '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'env', sandboxId];
 		for (const [key, value] of Object.entries(vars)) {
 			args.push(`${key}=${value}`);
 		}
@@ -833,7 +796,7 @@ export class CliClient {
 		sandboxId: string,
 		varNames: string[]
 	): Promise<CliResult<SandboxEnvResult>> {
-		const args = ['cloud', 'sandbox', 'env', sandboxId, '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'env', sandboxId];
 		for (const name of varNames) {
 			args.push('--delete', name);
 		}
@@ -844,10 +807,9 @@ export class CliClient {
 	 * Get environment variables from a sandbox.
 	 */
 	async sandboxEnvGet(sandboxId: string): Promise<CliResult<SandboxEnvResult>> {
-		return this.exec<SandboxEnvResult>(
-			['cloud', 'sandbox', 'env', sandboxId, '--region', this.getSandboxRegion()],
-			{ format: 'json' }
-		);
+		return this.exec<SandboxEnvResult>(['cloud', 'sandbox', 'env', sandboxId], {
+			format: 'json',
+		});
 	}
 
 	// ==================== Snapshot Methods ====================
@@ -856,15 +818,7 @@ export class CliClient {
 	 * Create a snapshot of a sandbox.
 	 */
 	async snapshotCreate(sandboxId: string, tag?: string): Promise<CliResult<SnapshotInfo>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'snapshot',
-			'create',
-			sandboxId,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'snapshot', 'create', sandboxId];
 		if (tag) {
 			args.push('--tag', tag);
 		}
@@ -875,11 +829,10 @@ export class CliClient {
 	 * List snapshots with optional sandbox filter.
 	 */
 	async snapshotList(sandboxId?: string): Promise<CliResult<SnapshotInfo[]>> {
-		const args = ['cloud', 'sandbox', 'snapshot', 'list', '--region', this.getSandboxRegion()];
+		const args = ['cloud', 'sandbox', 'snapshot', 'list'];
 		if (sandboxId) {
 			args.push('--sandbox', sandboxId);
 		}
-		// CLI returns { snapshots: [], total: N }
 		const result = await this.exec<{ snapshots: SnapshotInfo[]; total: number }>(args, {
 			format: 'json',
 		});
@@ -893,44 +846,25 @@ export class CliClient {
 	 * Get detailed information about a snapshot.
 	 */
 	async snapshotGet(snapshotId: string): Promise<CliResult<SnapshotInfo>> {
-		return this.exec<SnapshotInfo>(
-			['cloud', 'sandbox', 'snapshot', 'get', snapshotId, '--region', this.getSandboxRegion()],
-			{ format: 'json' }
-		);
+		return this.exec<SnapshotInfo>(['cloud', 'sandbox', 'snapshot', 'get', snapshotId], {
+			format: 'json',
+		});
 	}
 
 	/**
 	 * Delete a snapshot.
 	 */
 	async snapshotDelete(snapshotId: string): Promise<CliResult<void>> {
-		return this.exec<void>(
-			[
-				'cloud',
-				'sandbox',
-				'snapshot',
-				'delete',
-				snapshotId,
-				'--confirm',
-				'--region',
-				this.getSandboxRegion(),
-			],
-			{ format: 'json' }
-		);
+		return this.exec<void>(['cloud', 'sandbox', 'snapshot', 'delete', snapshotId, '--confirm'], {
+			format: 'json',
+		});
 	}
 
 	/**
 	 * Tag or untag a snapshot.
 	 */
 	async snapshotTag(snapshotId: string, tag: string | null): Promise<CliResult<void>> {
-		const args = [
-			'cloud',
-			'sandbox',
-			'snapshot',
-			'tag',
-			snapshotId,
-			'--region',
-			this.getSandboxRegion(),
-		];
+		const args = ['cloud', 'sandbox', 'snapshot', 'tag', snapshotId];
 		if (tag === null) {
 			args.push('--clear');
 		} else {
@@ -945,9 +879,8 @@ export class CliClient {
 	 * List executions for a sandbox.
 	 */
 	async executionList(sandboxId: string): Promise<CliResult<ExecutionInfo[]>> {
-		// CLI returns { executions: [] }
 		const result = await this.exec<{ executions: ExecutionInfo[] }>(
-			['cloud', 'sandbox', 'execution', 'list', sandboxId, '--region', this.getSandboxRegion()],
+			['cloud', 'sandbox', 'execution', 'list', sandboxId],
 			{ format: 'json' }
 		);
 		if (result.success && result.data) {
@@ -960,10 +893,9 @@ export class CliClient {
 	 * Get detailed information about an execution.
 	 */
 	async executionGet(executionId: string): Promise<CliResult<ExecutionInfo>> {
-		return this.exec<ExecutionInfo>(
-			['cloud', 'sandbox', 'execution', 'get', executionId, '--region', this.getSandboxRegion()],
-			{ format: 'json' }
-		);
+		return this.exec<ExecutionInfo>(['cloud', 'sandbox', 'execution', 'get', executionId], {
+			format: 'json',
+		});
 	}
 
 	dispose(): void {
@@ -1270,9 +1202,20 @@ export interface SandboxInfo {
 	resources?: SandboxResources;
 	stdoutStreamUrl?: string;
 	stderrStreamUrl?: string;
+	// New fields from sandbox improvements
+	name?: string;
+	description?: string;
+	runtimeId?: string;
+	runtimeName?: string;
 }
 
 export interface SandboxCreateOptions {
+	// New fields from sandbox improvements
+	runtime?: string;
+	runtimeId?: string;
+	name?: string;
+	description?: string;
+	// Existing fields
 	memory?: string;
 	cpu?: string;
 	disk?: string;
@@ -1341,6 +1284,26 @@ export interface SandboxEnvResult {
 	env: Record<string, string>;
 }
 
+// Sandbox runtime types
+export interface SandboxRuntime {
+	id: string;
+	name: string;
+	description?: string;
+	iconUrl?: string;
+	url?: string;
+	tags?: string[];
+}
+
+export interface SandboxRuntimeListParams {
+	limit?: number;
+	offset?: number;
+}
+
+export interface SandboxRuntimeListResponse {
+	runtimes: SandboxRuntime[];
+	total: number;
+}
+
 // Singleton
 let _cliClient: CliClient | undefined;
 

package/src/core/sandboxManager.ts

@@ -17,6 +17,11 @@ export interface LinkedSandbox {
 	linkedAt: string;
 	lastSyncedAt?: string;
 	remotePath: string;
+	// New fields from sandbox improvements
+	description?: string;
+	runtimeId?: string;
+	runtimeName?: string;
+	region?: string;
 }
 
 /**
@@ -80,11 +85,12 @@ export class SandboxManager {
 			throw new Error('No workspace folder open');
 		}
 
-		// Verify sandbox exists
+		// Verify sandbox exists and get its info
 		const result = await this.cliClient.sandboxGet(sandboxId);
-		if (!result.success) {
+		if (!result.success || !result.data) {
 			throw new Error(`Failed to verify sandbox: ${result.error}`);
 		}
+		const sandboxInfo = result.data;
 
 		const allLinked = this.context.workspaceState.get<Record<string, LinkedSandbox[]>>(
 			LINKED_SANDBOXES_KEY,
@@ -100,6 +106,7 @@ export class SandboxManager {
 				...workspaceLinks[existingIndex],
 				name: options.name ?? workspaceLinks[existingIndex].name,
 				remotePath: options.remotePath ?? workspaceLinks[existingIndex].remotePath,
+				region: sandboxInfo.region ?? workspaceLinks[existingIndex].region,
 			};
 		} else {
 			// Add new link
@@ -108,6 +115,7 @@ export class SandboxManager {
 				name: options.name,
 				linkedAt: new Date().toISOString(),
 				remotePath: options.remotePath ?? DEFAULT_SANDBOX_PATH,
+				region: sandboxInfo.region,
 			});
 		}
 
@@ -428,20 +436,53 @@ export class SandboxManager {
 	/**
 	 * Refresh sandbox info for all linked sandboxes.
 	 * Returns info about which sandboxes are still valid.
+	 * Also updates linked sandbox metadata with new fields from the API.
 	 */
 	async refreshLinkedSandboxes(): Promise<Map<string, SandboxInfo | null>> {
-		const linked = this.getLinkedSandboxes();
+		const workspaceKey = this.getWorkspaceKey();
+		if (!workspaceKey) {
+			return new Map();
+		}
+
+		const allLinked = this.context.workspaceState.get<Record<string, LinkedSandbox[]>>(
+			LINKED_SANDBOXES_KEY,
+			{}
+		);
+		const workspaceLinks = allLinked[workspaceKey] || [];
 		const results = new Map<string, SandboxInfo | null>();
+		let needsUpdate = false;
 
-		for (const link of linked) {
+		for (const link of workspaceLinks) {
 			const result = await this.cliClient.sandboxGet(link.sandboxId);
 			if (result.success && result.data) {
-				results.set(link.sandboxId, result.data);
+				const info = result.data;
+				results.set(link.sandboxId, info);
+
+				// Update linked sandbox with new fields from API
+				if (
+					info.name !== link.name ||
+					info.description !== link.description ||
+					info.runtimeId !== link.runtimeId ||
+					info.runtimeName !== link.runtimeName
+				) {
+					link.name = info.name ?? link.name;
+					link.description = info.description;
+					link.runtimeId = info.runtimeId;
+					link.runtimeName = info.runtimeName;
+					needsUpdate = true;
+				}
 			} else {
 				results.set(link.sandboxId, null);
 			}
 		}
 
+		// Persist updated metadata if changed
+		if (needsUpdate) {
+			allLinked[workspaceKey] = workspaceLinks;
+			await this.context.workspaceState.update(LINKED_SANDBOXES_KEY, allLinked);
+			_onLinkedSandboxesChanged.fire(workspaceLinks);
+		}
+
 		return results;
 	}
 

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

@@ -230,7 +230,9 @@ function registerCommands(
 	context.subscriptions.push(
 		vscode.commands.registerCommand(
 			'agentuity.sandbox.exec',
-			async (itemOrOptions?: SandboxTreeItem | { sandboxId: string; command?: string }) => {
+			async (
+				itemOrOptions?: SandboxTreeItem | { sandboxId: string; command?: string }
+			) => {
 				let sandboxId: string | undefined;
 				let command: string | undefined;
 
@@ -455,6 +457,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 +519,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 +530,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 +590,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 +610,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 +628,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 +653,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 +814,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 +833,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 +867,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 +1164,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 +1438,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 +1485,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,14 @@ 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 (isLinked) {
+			desc += ' [linked]';
+		}
+		this.description = desc;
 
 		// Set tooltip
 		this.tooltip = this.formatSandboxTooltip();
@@ -135,12 +141,27 @@ 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()}`);
 
 		if (this.sandboxData.resources) {
 			const r = this.sandboxData.resources;
@@ -382,20 +403,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 +491,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 +578,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 +650,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 +696,11 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 					undefined,
 					snap,
 					undefined,
-					sandboxId
+					sandboxId,
+					undefined,
+					undefined,
+					undefined,
+					region
 				)
 		);
 	}
@@ -720,7 +757,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 +796,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',