agentuity-vscode 0.1.7 → 0.1.9

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.7",
+	"version": "0.1.9",
 	"publisher": "agentuity",
 	"license": "Apache-2.0",
 	"repository": {
@@ -653,7 +653,7 @@
 				},
 				"agentuity.sandbox.defaultRemotePath": {
 					"type": "string",
-					"default": "/home/agentuity/app",
+					"default": "/home/agentuity",
 					"description": "Default path in sandbox for synced files"
 				}
 			}
@@ -978,8 +978,8 @@
 						},
 						"remotePath": {
 							"type": "string",
-							"description": "Remote path in sandbox (default: /home/agentuity/app)",
-							"default": "/home/agentuity/app"
+							"description": "Remote path in sandbox (default: /home/agentuity)",
+							"default": "/home/agentuity"
 						},
 						"respectGitignore": {
 							"type": "boolean",

package/src/core/cliClient.ts

@@ -521,7 +521,7 @@ export class CliClient {
 	}
 
 	/** Default home path in sandboxes */
-	static readonly SANDBOX_HOME = '/home/agentuity/app';
+	static readonly SANDBOX_HOME = '/home/agentuity';
 
 	/**
 	 * Create a new sandbox.
@@ -589,7 +589,9 @@ export class CliClient {
 		}
 
 		// CLI returns { sandboxes: [...], total: N }, extract the array
-		const result = await this.exec<{ sandboxes: SandboxInfo[]; total: number }>(args, { format: 'json' });
+		const result = await this.exec<{ sandboxes: SandboxInfo[]; total: number }>(args, {
+			format: 'json',
+		});
 		if (result.success && result.data) {
 			return { success: true, data: result.data.sandboxes || [], exitCode: result.exitCode };
 		}
@@ -611,7 +613,15 @@ export class CliClient {
 	 */
 	async sandboxDelete(sandboxId: string): Promise<CliResult<void>> {
 		return this.exec<void>(
-			['cloud', 'sandbox', 'delete', sandboxId, '--confirm', '--region', this.getSandboxRegion()],
+			[
+				'cloud',
+				'sandbox',
+				'delete',
+				sandboxId,
+				'--confirm',
+				'--region',
+				this.getSandboxRegion(),
+			],
 			{ format: 'json' }
 		);
 	}
@@ -652,9 +662,12 @@ export class CliClient {
 		args.push('-l', '--region', this.getSandboxRegion());
 
 		// 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 }>(args, { format: 'json' });
+		const result = await this.exec<{
+			files: Array<Omit<SandboxFileInfo, 'name'>>;
+			total: number;
+		}>(args, { format: 'json' });
 		if (result.success && result.data) {
-			const files = (result.data.files || []).map(f => ({
+			const files = (result.data.files || []).map((f) => ({
 				...f,
 				name: f.path.split('/').pop() || f.path, // Extract filename from path
 			}));
@@ -705,7 +718,15 @@ 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (destPath) {
 			args.push('--path', destPath);
 		}
@@ -720,7 +741,15 @@ 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (sourcePath) {
 			args.push('--path', sourcePath);
 		}
@@ -735,7 +764,15 @@ 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (recursive) {
 			args.push('-p');
 		}
@@ -760,7 +797,15 @@ 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (recursive) {
 			args.push('-r');
 		}
@@ -811,7 +856,15 @@ 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (tag) {
 			args.push('--tag', tag);
 		}
@@ -827,7 +880,9 @@ export class CliClient {
 			args.push('--sandbox', sandboxId);
 		}
 		// CLI returns { snapshots: [], total: N }
-		const result = await this.exec<{ snapshots: SnapshotInfo[]; total: number }>(args, { format: 'json' });
+		const result = await this.exec<{ snapshots: SnapshotInfo[]; total: number }>(args, {
+			format: 'json',
+		});
 		if (result.success && result.data) {
 			return { success: true, data: result.data.snapshots || [], exitCode: result.exitCode };
 		}
@@ -849,7 +904,16 @@ export class CliClient {
 	 */
 	async snapshotDelete(snapshotId: string): Promise<CliResult<void>> {
 		return this.exec<void>(
-			['cloud', 'sandbox', 'snapshot', 'delete', snapshotId, '--confirm', '--region', this.getSandboxRegion()],
+			[
+				'cloud',
+				'sandbox',
+				'snapshot',
+				'delete',
+				snapshotId,
+				'--confirm',
+				'--region',
+				this.getSandboxRegion(),
+			],
 			{ format: 'json' }
 		);
 	}
@@ -858,7 +922,15 @@ export class CliClient {
 	 * 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,
+			'--region',
+			this.getSandboxRegion(),
+		];
 		if (tag === null) {
 			args.push('--clear');
 		} else {
@@ -1174,8 +1246,14 @@ export interface SessionLog {
 }
 
 // Sandbox types
-export type SandboxStatus = 'creating' | 'idle' | 'running' | 'terminated' | 'failed';
-export type ExecutionStatus = 'queued' | 'running' | 'completed' | 'failed' | 'timeout' | 'cancelled';
+export type SandboxStatus = 'creating' | 'idle' | 'running' | 'terminated' | 'failed' | 'deleted';
+export type ExecutionStatus =
+	| 'queued'
+	| 'running'
+	| 'completed'
+	| 'failed'
+	| 'timeout'
+	| 'cancelled';
 
 export interface SandboxResources {
 	memory?: string;

package/src/core/sandboxManager.ts

@@ -176,7 +176,11 @@ export class SandboxManager {
 			const bytesTransferred = stats.size;
 
 			// Upload and extract
-			const uploadResult = await this.cliClient.sandboxUpload(sandboxId, archivePath, remotePath);
+			const uploadResult = await this.cliClient.sandboxUpload(
+				sandboxId,
+				archivePath,
+				remotePath
+			);
 			if (!uploadResult.success) {
 				throw new Error(`Failed to upload files: ${uploadResult.error}`);
 			}
@@ -207,7 +211,12 @@ export class SandboxManager {
 		remotePath: string,
 		localPath: string
 	): Promise<void> {
-		const result = await this.cliClient.sandboxCpFromSandbox(sandboxId, remotePath, localPath, true);
+		const result = await this.cliClient.sandboxCpFromSandbox(
+			sandboxId,
+			remotePath,
+			localPath,
+			true
+		);
 		if (!result.success) {
 			throw new Error(`Failed to download files: ${result.error}`);
 		}

package/src/features/chat/agentTools.ts

@@ -608,9 +608,7 @@ export class SyncToSandboxTool implements vscode.LanguageModelTool<SyncToSandbox
 				),
 			]);
 		} catch (err) {
-			throw new Error(
-				`Failed to sync: ${err instanceof Error ? err.message : 'Unknown error'}`
-			);
+			throw new Error(`Failed to sync: ${err instanceof Error ? err.message : 'Unknown error'}`);
 		}
 	}
 

package/src/features/sandboxExplorer/index.ts

@@ -41,9 +41,7 @@ let saveListener: vscode.Disposable | undefined;
 const uploadDebounceTimers: Map<string, NodeJS.Timeout> = new Map();
 const UPLOAD_DEBOUNCE_MS = 1000; // 1 second debounce
 
-export function registerSandboxExplorer(
-	context: vscode.ExtensionContext
-): SandboxTreeDataProvider {
+export function registerSandboxExplorer(context: vscode.ExtensionContext): SandboxTreeDataProvider {
 	// Initialize sandbox manager
 	initSandboxManager(context);
 
@@ -171,13 +169,10 @@ function registerCommands(
 
 	// Link sandbox
 	context.subscriptions.push(
-		vscode.commands.registerCommand(
-			'agentuity.sandbox.link',
-			async (item?: SandboxTreeItem) => {
-				if (!item?.sandboxData) return;
-				await linkSandbox(item.sandboxData.sandboxId, provider);
-			}
-		)
+		vscode.commands.registerCommand('agentuity.sandbox.link', async (item?: SandboxTreeItem) => {
+			if (!item?.sandboxData) return;
+			await linkSandbox(item.sandboxData.sandboxId, provider);
+		})
 	);
 
 	// Unlink sandbox
@@ -193,45 +188,42 @@ function registerCommands(
 
 	// Sync project to sandbox
 	context.subscriptions.push(
-		vscode.commands.registerCommand(
-			'agentuity.sandbox.sync',
-			async (item?: SandboxTreeItem) => {
-				let sandboxId: string | undefined;
+		vscode.commands.registerCommand('agentuity.sandbox.sync', async (item?: SandboxTreeItem) => {
+			let sandboxId: string | undefined;
 
-				if (item?.sandboxData) {
-					sandboxId = item.sandboxData.sandboxId;
+			if (item?.sandboxData) {
+				sandboxId = item.sandboxData.sandboxId;
+			} else {
+				// Try to get from linked sandboxes
+				const linked = getSandboxManager().getLinkedSandboxes();
+				if (linked.length === 0) {
+					vscode.window.showWarningMessage(
+						'No sandbox linked to this workspace. Link a sandbox first.'
+					);
+					return;
+				}
+				if (linked.length === 1) {
+					sandboxId = linked[0].sandboxId;
 				} else {
-					// Try to get from linked sandboxes
-					const linked = getSandboxManager().getLinkedSandboxes();
-					if (linked.length === 0) {
-						vscode.window.showWarningMessage(
-							'No sandbox linked to this workspace. Link a sandbox first.'
-						);
-						return;
-					}
-					if (linked.length === 1) {
-						sandboxId = linked[0].sandboxId;
-					} else {
-						// Pick one
-						const picked = await vscode.window.showQuickPick(
-							linked.map((l) => ({
-								label: l.name || l.sandboxId,
-								description: l.sandboxId,
-								sandboxId: l.sandboxId,
-							})),
-							{ placeHolder: 'Select sandbox to sync to' }
-						);
-						if (picked) {
-							sandboxId = picked.sandboxId;
-						}
+					// Pick one
+					const picked = await vscode.window.showQuickPick(
+						linked.map((l) => ({
+							label: l.name || l.sandboxId,
+							description: l.sandboxId,
+							sandboxId: l.sandboxId,
+						})),
+						{ placeHolder: 'Select sandbox to sync to' }
+					);
+					if (picked) {
+						sandboxId = picked.sandboxId;
 					}
 				}
+			}
 
-				if (sandboxId) {
-					await syncToSandbox(sandboxId, provider);
-				}
+			if (sandboxId) {
+				await syncToSandbox(sandboxId, provider);
 			}
-		)
+		})
 	);
 
 	// Execute command in sandbox
@@ -272,7 +264,11 @@ function registerCommands(
 			'agentuity.sandbox.download',
 			async (item?: SandboxTreeItem) => {
 				if (!item?.parentSandboxId || !item?.filePath) return;
-				await downloadFromSandbox(item.parentSandboxId, item.filePath, item.itemType === 'directory');
+				await downloadFromSandbox(
+					item.parentSandboxId,
+					item.filePath,
+					item.itemType === 'directory'
+				);
 			}
 		)
 	);
@@ -283,7 +279,12 @@ function registerCommands(
 			'agentuity.sandbox.deleteFile',
 			async (item?: SandboxTreeItem) => {
 				if (!item?.parentSandboxId || !item?.filePath) return;
-				await deleteFile(item.parentSandboxId, item.filePath, item.itemType === 'directory', provider);
+				await deleteFile(
+					item.parentSandboxId,
+					item.filePath,
+					item.itemType === 'directory',
+					provider
+				);
 			}
 		)
 	);
@@ -445,13 +446,10 @@ function registerCommands(
 
 	// Upload from explorer (context menu)
 	context.subscriptions.push(
-		vscode.commands.registerCommand(
-			'agentuity.sandbox.upload',
-			async (uri?: vscode.Uri) => {
-				if (!uri) return;
-				await uploadToSandbox(uri);
-			}
-		)
+		vscode.commands.registerCommand('agentuity.sandbox.upload', async (uri?: vscode.Uri) => {
+			if (!uri) return;
+			await uploadToSandbox(uri);
+		})
 	);
 }
 
@@ -677,10 +675,12 @@ async function syncToSandbox(sandboxId: string, provider: SandboxTreeDataProvide
 }
 
 async function execInSandbox(sandboxId: string, prefilledCommand?: string): Promise<void> {
-	const command = prefilledCommand ?? await vscode.window.showInputBox({
-		prompt: 'Enter command to execute',
-		placeHolder: 'npm test',
-	});
+	const command =
+		prefilledCommand ??
+		(await vscode.window.showInputBox({
+			prompt: 'Enter command to execute',
+			placeHolder: 'npm test',
+		}));
 
 	if (!command) return;
 
@@ -702,7 +702,9 @@ 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} --region ${cli.getSandboxRegion()} -- ${command}`
+	);
 }
 
 function disposeTerminals(): void {
@@ -813,9 +815,7 @@ async function createSandboxFile(
 	const doc = await vscode.workspace.openTextDocument(localPath);
 	await vscode.window.showTextDocument(doc, { preview: false });
 
-	vscode.window.showInformationMessage(
-		`New file will be created at ${remotePath} when you save`
-	);
+	vscode.window.showInformationMessage(`New file will be created at ${remotePath} when you save`);
 }
 
 async function createSandboxFolder(
@@ -960,7 +960,9 @@ async function viewExecution(executionId: string): Promise<void> {
 						const stdoutContent = await fetchStreamContent(exec.stdoutStreamUrl);
 						lines.push(stdoutContent || '(empty)');
 					} catch (err) {
-						lines.push(`(failed to fetch: ${err instanceof Error ? err.message : 'unknown error'})`);
+						lines.push(
+							`(failed to fetch: ${err instanceof Error ? err.message : 'unknown error'})`
+						);
 					}
 				}
 
@@ -971,11 +973,17 @@ async function viewExecution(executionId: string): Promise<void> {
 						const stderrContent = await fetchStreamContent(exec.stderrStreamUrl);
 						lines.push(stderrContent || '(empty)');
 					} catch (err) {
-						lines.push(`(failed to fetch: ${err instanceof Error ? err.message : 'unknown error'})`);
+						lines.push(
+							`(failed to fetch: ${err instanceof Error ? err.message : 'unknown error'})`
+						);
 					}
 				}
 
-				await openReadonlyDocument(lines.join('\n'), 'log', `execution-${executionId.slice(0, 8)}`);
+				await openReadonlyDocument(
+					lines.join('\n'),
+					'log',
+					`execution-${executionId.slice(0, 8)}`
+				);
 			} else {
 				vscode.window.showErrorMessage(`Failed to get execution: ${result.error}`);
 			}
@@ -1108,10 +1116,7 @@ async function syncEnvFile(sandboxId: string): Promise<void> {
 	}
 }
 
-async function createSnapshot(
-	sandboxId: string,
-	provider: SandboxTreeDataProvider
-): Promise<void> {
+async function createSnapshot(sandboxId: string, provider: SandboxTreeDataProvider): Promise<void> {
 	const tag = await vscode.window.showInputBox({
 		prompt: 'Enter a tag for this snapshot (optional)',
 		placeHolder: 'v1.0 or latest',
@@ -1218,7 +1223,11 @@ async function viewSnapshotFile(snapshot: SnapshotInfo, filePath: string): Promi
 		async () => {
 			try {
 				// Create temp directory for snapshot files
-				const snapshotTmpDir = path.join(os.tmpdir(), 'agentuity-snapshots', snapshot.snapshotId.slice(0, 12));
+				const snapshotTmpDir = path.join(
+					os.tmpdir(),
+					'agentuity-snapshots',
+					snapshot.snapshotId.slice(0, 12)
+				);
 				fs.mkdirSync(snapshotTmpDir, { recursive: true });
 
 				const archivePath = path.join(snapshotTmpDir, 'snapshot.tar.gz');
@@ -1301,14 +1310,22 @@ async function downloadFile(url: string, destPath: string): Promise<void> {
 
 		request.on('error', (err) => {
 			file.close();
-			try { fs.unlinkSync(destPath); } catch { /* ignore cleanup errors */ }
+			try {
+				fs.unlinkSync(destPath);
+			} catch {
+				/* ignore cleanup errors */
+			}
 			reject(err);
 		});
 
 		request.setTimeout(60000, () => {
 			request.destroy();
 			file.close();
-			try { fs.unlinkSync(destPath); } catch { /* ignore cleanup errors */ }
+			try {
+				fs.unlinkSync(destPath);
+			} catch {
+				/* ignore cleanup errors */
+			}
 			reject(new Error('Download timeout'));
 		});
 	});
@@ -1356,12 +1373,7 @@ async function uploadToSandbox(uri: vscode.Uri): Promise<void> {
 			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
-			);
+			const result = await cli.sandboxCpToSandbox(sandboxId, uri.fsPath, remotePath, isDir);
 
 			if (result.success) {
 				vscode.window.showInformationMessage(`Uploaded to ${remotePath}`);

package/src/features/sandboxExplorer/sandboxTreeData.ts

@@ -83,10 +83,7 @@ export class SandboxTreeItem extends vscode.TreeItem {
 		const isLinked = this.linkedData !== undefined;
 
 		// Set icon based on status
-		this.iconPath = new vscode.ThemeIcon(
-			this.getStatusIcon(status),
-			this.getStatusColor(status)
-		);
+		this.iconPath = new vscode.ThemeIcon(this.getStatusIcon(status), this.getStatusColor(status));
 
 		// Set context value for menu targeting
 		let contextValue = `sandbox.${status}`;
@@ -282,7 +279,9 @@ export class SandboxTreeItem extends vscode.TreeItem {
 		this.tooltip = [
 			`ID: ${this.executionData.executionId}`,
 			`Status: ${status}`,
-			this.executionData.exitCode !== undefined ? `Exit Code: ${this.executionData.exitCode}` : '',
+			this.executionData.exitCode !== undefined
+				? `Exit Code: ${this.executionData.exitCode}`
+				: '',
 			this.executionData.durationMs !== undefined
 				? `Duration: ${(this.executionData.durationMs / 1000).toFixed(2)}s`
 				: '',
@@ -347,7 +346,9 @@ export class SandboxTreeItem extends vscode.TreeItem {
  * Tree data provider for the sandbox explorer.
  */
 export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxTreeItem> {
-	private _onDidChangeTreeData = new vscode.EventEmitter<SandboxTreeItem | undefined | null | void>();
+	private _onDidChangeTreeData = new vscode.EventEmitter<
+		SandboxTreeItem | undefined | null | void
+	>();
 	readonly onDidChangeTreeData = this._onDidChangeTreeData.event;
 
 	private sandboxes: SandboxInfo[] = [];
@@ -410,13 +411,21 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 
 		if (authStatus.state === 'unknown') {
 			return [
-				new SandboxTreeItem('Checking auth...', vscode.TreeItemCollapsibleState.None, 'message'),
+				new SandboxTreeItem(
+					'Checking auth...',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
 			];
 		}
 
 		if (authStatus.state === 'cli-missing') {
 			return [
-				new SandboxTreeItem('CLI not installed', vscode.TreeItemCollapsibleState.None, 'message'),
+				new SandboxTreeItem(
+					'CLI not installed',
+					vscode.TreeItemCollapsibleState.None,
+					'message'
+				),
 			];
 		}
 
@@ -427,7 +436,9 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		}
 
 		if (this.loading) {
-			return [new SandboxTreeItem('Loading...', vscode.TreeItemCollapsibleState.None, 'message')];
+			return [
+				new SandboxTreeItem('Loading...', vscode.TreeItemCollapsibleState.None, 'message'),
+			];
 		}
 
 		if (this.error) {
@@ -500,10 +511,7 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		return items;
 	}
 
-	private getSandboxCategories(
-		sandbox: SandboxInfo,
-		linked?: LinkedSandbox
-	): SandboxTreeItem[] {
+	private getSandboxCategories(sandbox: SandboxInfo, linked?: LinkedSandbox): SandboxTreeItem[] {
 		return [
 			new SandboxTreeItem(
 				'Files',
@@ -589,9 +597,7 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 		});
 
 		if (directChildren.length === 0) {
-			return [
-				new SandboxTreeItem('(empty)', vscode.TreeItemCollapsibleState.None, 'message'),
-			];
+			return [new SandboxTreeItem('(empty)', vscode.TreeItemCollapsibleState.None, 'message')];
 		}
 
 		// Sort: directories first, then files, alphabetically
@@ -696,7 +702,14 @@ export class SandboxTreeDataProvider implements vscode.TreeDataProvider<SandboxT
 				vscode.TreeItemCollapsibleState.None,
 				'snapshotFile',
 				undefined,
-				{ path: file.path, name: fileName, size: file.size, isDir: false, mode: '', modTime: '' },
+				{
+					path: file.path,
+					name: fileName,
+					size: file.size,
+					isDir: false,
+					mode: '',
+					modTime: '',
+				},
 				snapshotData, // Pass snapshot data so we have access to downloadUrl
 				undefined,
 				undefined,