@agentuity/cli 2.0.11 → 2.0.12

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -22,6 +22,37 @@ export interface GenerateAssetServerConfigOptions {
 	liveHostname?: string;
 }
 
+/**
+ * Shared proxy configuration for backend routes.
+ *
+ * Includes `configure` callback that gracefully handles ECONNREFUSED errors
+ * when the Bun backend isn't ready yet (startup race condition or brief
+ * disconnect during --hot reload). Instead of logging noisy errors, the
+ * proxy returns 503 Service Unavailable with a retry hint.
+ */
+function backendProxyOptions(backendPort: number) {
+	return {
+		target: `http://127.0.0.1:${backendPort}`,
+		changeOrigin: true,
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		configure: (proxy: any, _options: any) => {
+			proxy.on('error', (err: Error & { code?: string }, _req: any, res: any) => {
+				if (err.code === 'ECONNREFUSED' && res && !res.writableEnded) {
+					res.statusCode = 503;
+					res.setHeader('Content-Type', 'application/json');
+					res.end(
+						JSON.stringify({
+							error: 'Backend unavailable',
+							message: 'The Bun backend is not ready yet. Retrying shortly...',
+							retry: true,
+						})
+					);
+				}
+			});
+		},
+	};
+}
+
 /**
  * Vite plugin that injects analytics scripts in dev mode.
  *
@@ -95,7 +126,7 @@ function spaFallbackPlugin(rootDir: string, routePaths: string[], workbenchPath?
 				const isDocumentRequest = secFetchDest === 'document' || accept.includes('text/html');
 
 				// Skip file requests (have an extension)
-				if (pathname !== '/' && /\.[a-zA-Z0-9]+$/.test(pathname)) return next();
+				if (pathname !== '/' && /\.[\w-]+$/.test(pathname)) return next();
 
 				// For non-document requests, only allow root path fallback.
 				// (e.g. don't turn module/script fetches into HTML accidentally)
@@ -241,37 +272,19 @@ export async function generateAssetServerConfig(
 			proxy: {
 				// User-defined route mounts (from createApp({ router }))
 				...Object.fromEntries(
-					routePaths.map((routePath) => [
-						routePath,
-						{
-							target: `http://127.0.0.1:${backendPort}`,
-							changeOrigin: true,
-						},
-					])
+					routePaths.map((routePath) => [routePath, backendProxyOptions(backendPort)])
 				),
 				// Agentuity system routes (workbench API, health, analytics, etc.)
-				'/_agentuity': {
-					target: `http://127.0.0.1:${backendPort}`,
-					changeOrigin: true,
-				},
+				'/_agentuity': backendProxyOptions(backendPort),
 				// Workbench UI route (served by Bun, references /@fs/* paths handled by Vite)
 				...(workbenchPath
 					? {
-							[workbenchPath]: {
-								target: `http://127.0.0.1:${backendPort}`,
-								changeOrigin: true,
-							},
+							[workbenchPath]: backendProxyOptions(backendPort),
 						}
 					: {}),
 				// Legacy health check routes
-				'/_health': {
-					target: `http://127.0.0.1:${backendPort}`,
-					changeOrigin: true,
-				},
-				'/_idle': {
-					target: `http://127.0.0.1:${backendPort}`,
-					changeOrigin: true,
-				},
+				'/_health': backendProxyOptions(backendPort),
+				'/_idle': backendProxyOptions(backendPort),
 			},
 
 			// HMR works natively — Vite is the primary server, no proxy needed
@@ -296,13 +309,10 @@ export async function generateAssetServerConfig(
 		// Agentuity-specific plugins (Vite loads user plugins from vite.config.ts automatically)
 		plugins: await (async () => {
 			const { browserEnvPlugin } = await import('./browser-env-plugin');
-			const { publicAssetPathPlugin } = await import('./public-asset-path-plugin');
 
 			return [
 				// Browser env plugin to map process.env to import.meta.env
 				browserEnvPlugin(),
-				// Warn about incorrect public asset paths in dev mode
-				publicAssetPathPlugin({ warnInDev: true }),
 				// Inject analytics scripts in dev HTML
 				devAnalyticsPlugin(),
 				// SPA fallback: serve src/web/index.html for navigation requests

package/src/cmd/build/vite/vite-asset-server.ts

@@ -50,8 +50,12 @@ function isPortAvailable(port: number, host: string): Promise<boolean> {
 /**
  * Find an available port starting from the preferred port.
  * Tries incrementing ports up to maxAttempts times.
+ *
+ * Exported so the dev command can pre-resolve the Vite port before
+ * starting the Bun backend (env vars like AGENTUITY_BASE_URL need
+ * the real port before Bun initializes CORS).
  */
-async function findAvailablePort(
+export async function findAvailablePort(
 	preferredPort: number,
 	host: string = '127.0.0.1',
 	maxAttempts: number = 20

package/src/cmd/build/vite/vite-builder.ts

@@ -227,6 +227,7 @@ import { join } from 'node:path';
 export default defineConfig({
 	plugins: [react()],
 	root: '.',
+	publicDir: 'src/web/public',
 	build: {
 		rollupOptions: {
 			input: join(__dirname, 'src/web/index.html'),
@@ -244,17 +245,27 @@ export default defineConfig({
 				? `https://${options.region === 'local' ? 'localstack-static-assets.t3.storageapi.dev' : 'cdn.agentuity.com'}/${options.deploymentId}/client/`
 				: undefined;
 
+		// Pass the user's vite.config.ts directly to the subprocess. We used to
+		// wrap it in an auto-generated `.agentuity/vite.client.config.ts` to
+		// merge a lint plugin in, but that wrapper added complexity (plugin-path
+		// resolution, a junk file in the deploy bundle) for a warning-only
+		// linter. If we need to inject plugins again, expose them as a published
+		// CLI export and have users add them in their own vite.config.ts.
 		const args = [
 			'bun',
 			'x',
 			'vite',
 			'build',
+			'--config',
+			viteConfigPath,
 			'--mode',
 			buildMode,
 			'--outDir',
 			clientOutDir,
+			// `warn` surfaces Vite warnings (e.g. large-chunk notices) without
+			// adding its own info-level chatter.
 			'--logLevel',
-			'error',
+			'warn',
 			'--clearScreen',
 			'false',
 		];

package/src/cmd/build/vite/ws-proxy.ts

@@ -33,7 +33,7 @@
  * ```
  */
 
-import { createServer, connect, type Server } from 'node:net';
+import { createServer, connect, type Server, type Socket } from 'node:net';
 import type { Logger } from '../../../types';
 
 export interface WsProxyOptions {
@@ -48,18 +48,44 @@ export interface WsProxyOptions {
 	logger: Logger;
 }
 
+/**
+ * Front-door TCP proxy server.
+ *
+ * Extends `net.Server` with a `closeAll()` method that destroys all live
+ * client + upstream sockets and waits for the listening socket to close.
+ * The native `Server.close()` only stops accepting new connections — long-
+ * lived piped sockets (Vite HMR WebSocket, backend WS) keep the listener
+ * bound until they close on their own. During dev-mode shutdown we want
+ * the user-facing port released immediately, so cleanup paths should
+ * prefer `closeAll()` over `close()`.
+ */
+export interface WsProxyServer extends Server {
+	closeAll(): Promise<void>;
+}
+
 /**
  * Start a front-door TCP proxy that routes WebSocket upgrades to the Bun
  * backend and everything else to Vite. Returns the `net.Server` instance.
  */
-export function startWsProxy(options: WsProxyOptions): Promise<Server> {
+export function startWsProxy(options: WsProxyOptions): Promise<WsProxyServer> {
 	const { port, vitePort, backendPort, routePaths, logger } = options;
 
 	// Prefixes whose WebSocket upgrades go to Bun instead of Vite
 	const wsPathPrefixes = ['/_agentuity', ...routePaths];
 
+	// Track every live socket pair so shutdown can drop them. Without this,
+	// `server.close()` waits for active connections to terminate by themselves
+	// (e.g. browser HMR WebSockets), which can keep the user-facing port bound
+	// for many seconds after dev mode exits.
+	const liveSockets = new Set<Socket>();
+	const trackSocket = (sock: Socket) => {
+		liveSockets.add(sock);
+		sock.once('close', () => liveSockets.delete(sock));
+	};
+
 	return new Promise((resolve, reject) => {
 		const server = createServer((socket) => {
+			trackSocket(socket);
 			let handled = false;
 
 			// Peek at the first chunk to decide where to route
@@ -87,6 +113,7 @@ export function startWsProxy(options: WsProxyOptions): Promise<Server> {
 				}
 
 				const target = connect(targetPort, '127.0.0.1');
+				trackSocket(target);
 
 				target.on('connect', () => {
 					target.write(firstChunk);
@@ -109,7 +136,29 @@ export function startWsProxy(options: WsProxyOptions): Promise<Server> {
 			socket.on('error', () => {
 				if (!handled) socket.destroy();
 			});
-		});
+		}) as WsProxyServer;
+
+		// Async close that destroys live sockets first, then waits for the
+		// listener to close. Idempotent: safe to call after the server has
+		// already been closed by other means.
+		server.closeAll = () => {
+			return new Promise<void>((resolveClose) => {
+				for (const sock of liveSockets) {
+					try {
+						if (!sock.destroyed) sock.destroy();
+					} catch {
+						// Best effort
+					}
+				}
+				liveSockets.clear();
+
+				if (!server.listening) {
+					resolveClose();
+					return;
+				}
+				server.close(() => resolveClose());
+			});
+		};
 
 		server.on('error', reject);
 

package/src/cmd/cloud/deploy.ts

@@ -95,6 +95,21 @@ const DeployResponseSchema = z.object({
 		.describe('Deployment URLs'),
 });
 
+/**
+ * Render the final "Uploaded N assets ..." line after a successful CDN
+ * upload pass. Reports both the original and on-the-wire totals when gzip
+ * compressed at least one file, so the user can see the real transfer cost.
+ */
+function formatUploadSummary(count: number, rawBytes: number, transferredBytes: number): string {
+	const noun = tui.plural(count, 'asset', 'assets');
+	// When no compression happened (icons, fonts, binaries), rawBytes ===
+	// transferredBytes and the extra detail would just be noise.
+	if (transferredBytes === rawBytes) {
+		return `✓ Uploaded ${count} ${noun} (${tui.formatBytes(rawBytes)}) to CDN`;
+	}
+	return `✓ Uploaded ${count} ${noun} (${tui.formatBytes(transferredBytes)} on wire, ${tui.formatBytes(rawBytes)} raw) to CDN`;
+}
+
 export const deploySubcommand = createSubcommand({
 	name: 'deploy',
 	description: 'Deploy project to the Agentuity Cloud',
@@ -848,8 +863,12 @@ export const deploySubcommand = createSubcommand({
 							}
 
 							progress(80);
-							let bytes = 0;
-							if (build?.assets) {
+							// Track both the raw on-disk size and the actual bytes we put on
+							// the wire. For gzipped assets these differ significantly; reporting
+							// the transferred total gives the user an honest view of CDN cost.
+							let rawBytes = 0;
+							let transferredBytes = 0;
+							if (build?.assets && build.assets.length > 0) {
 								// Start CDN upload diagnostic
 								const endCdnUploadDiagnostic = collector.startDiagnostic('cdn-upload');
 								ctx.logger.trace(`Uploading ${build.assets.length} assets`);
@@ -863,31 +882,64 @@ export const deploySubcommand = createSubcommand({
 									return stepError(errorMsg);
 								}
 
-								// Process assets in batches with limited concurrency
-								const concurrency = Math.min(4, build.assets.length);
-								for (let i = 0; i < build.assets.length; i += concurrency) {
-									const batch = build.assets.slice(i, i + concurrency);
-									const promises: Promise<Response>[] = [];
-
-									for (const asset of batch) {
-										const assetUrl = instructions.assets[asset.filename];
-										if (!assetUrl) {
-											return stepError(
-												`server did not provide upload URL for asset "${asset.filename}"; upload aborted`
-											);
+								// Pre-flight: every asset the build emitted must have a signed
+								// PUT URL from the backend. Failing up-front gives a single
+								// clear error instead of aborting mid-batch with partial uploads.
+								for (const asset of build.assets) {
+									if (!instructions.assets[asset.filename]) {
+										const errorMsg = `server did not provide upload URL for asset "${asset.filename}"; upload aborted`;
+										collector.addGeneralError('deploy', errorMsg, 'DEPLOY006');
+										if (opts.reportFile) {
+											await collector.forceWrite();
 										}
+										return stepError(errorMsg);
+									}
+									rawBytes += asset.size;
+								}
 
-										// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
+								// Track every temp gzip file we create so we can clean them up
+								// even if the deploy is aborted mid-upload (e.g. Ctrl+C).
+								const tempFiles = new Set<string>();
+								const cleanupTempFiles = () => {
+									for (const p of tempFiles) {
+										try {
+											unlinkSync(p);
+										} catch {
+											// ignore — may already be gone
+										}
+									}
+									tempFiles.clear();
+								};
+
+								// Hoist narrowed locals for use inside the async upload closure;
+								// TS doesn't propagate narrowings of `build` / `instructions`
+								// across async callbacks, and we've already null-checked both
+								// above.
+								const assets = build.assets;
+								const assetUrls = instructions.assets;
+
+								try {
+									// Upload each asset with bounded concurrency. gzip compression
+									// runs inside the per-asset task, so compressible files
+									// compress in parallel (up to `concurrency`) rather than
+									// serially — a meaningful win for builds with many JS/CSS
+									// chunks since gzip is single-threaded per call.
+									const uploadOne = async (
+										asset: (typeof assets)[number]
+									): Promise<void> => {
+										const assetUrl = assetUrls[asset.filename]!;
+										// Asset filename already includes the subdirectory
+										// (e.g., "client/assets/main-abc123.js").
 										const filePath = join(projectDir, '.agentuity', asset.filename);
 
 										const headers: Record<string, string> = {
 											'Content-Type': asset.contentType,
 										};
 
-										bytes += asset.size;
-
 										let body: Blob;
 										let gzTempPath: string | undefined;
+										let onWireSize = asset.size;
+
 										if (asset.contentEncoding === 'gzip') {
 											// Gzip to a temp file so Bun.file() can provide
 											// Content-Length to S3 (streaming bodies use chunked
@@ -896,6 +948,7 @@ export const deploySubcommand = createSubcommand({
 												tmpdir(),
 												`agentuity-asset-${deployment.id}-${Date.now()}-${asset.filename.replace(/\//g, '_')}.gz`
 											);
+											tempFiles.add(gzTempPath);
 											await pipeline(
 												createReadStream(filePath),
 												createGzip(),
@@ -903,57 +956,72 @@ export const deploySubcommand = createSubcommand({
 											);
 											headers['Content-Encoding'] = 'gzip';
 											body = Bun.file(gzTempPath);
-											const compressedSize = body.size;
+											onWireSize = body.size;
 											ctx.logger.trace(
-												`Gzip compressed ${asset.filename} (${asset.size} -> ${compressedSize} bytes)`
+												`Gzip compressed ${asset.filename} (${asset.size} -> ${onWireSize} bytes)`
 											);
 										} else {
 											body = Bun.file(filePath);
 										}
 
-										const assetGzTempPath = gzTempPath;
-										promises.push(
-											fetch(assetUrl, {
-												method: 'PUT',
-												headers,
-												body,
-												signal: stepCtx.signal,
-											}).then((response) => {
-												// Clean up temp gzip file after upload completes
-												if (assetGzTempPath) {
-													try {
-														unlinkSync(assetGzTempPath);
-													} catch {
-														// ignore — file may already be cleaned up
-													}
-												}
-												return response;
-											})
-										);
-									}
+										const response = await fetch(assetUrl, {
+											method: 'PUT',
+											headers,
+											body,
+											signal: stepCtx.signal,
+										});
 
-									const resps = await Promise.all(promises);
-									for (const r of resps) {
-										if (!r.ok) {
-											const errorMsg = `error uploading asset: ${await r.text()}`;
-											collector.addGeneralError('deploy', errorMsg, 'DEPLOY006');
-											if (opts.reportFile) {
-												await collector.forceWrite();
+										if (gzTempPath) {
+											try {
+												unlinkSync(gzTempPath);
+											} catch {
+												// ignore
 											}
-											return stepError(errorMsg);
+											tempFiles.delete(gzTempPath);
 										}
+
+										if (!response.ok) {
+											throw new Error(
+												`asset "${asset.filename}" upload failed: ${response.status} ${await response.text()}`
+											);
+										}
+
+										transferredBytes += onWireSize;
+									};
+
+									const concurrency = Math.min(4, assets.length);
+									for (let i = 0; i < assets.length; i += concurrency) {
+										const batch = assets.slice(i, i + concurrency);
+										await Promise.all(batch.map(uploadOne));
 									}
+								} catch (error) {
+									cleanupTempFiles();
+									const errorMsg = error instanceof Error ? error.message : String(error);
+									collector.addGeneralError('deploy', errorMsg, 'DEPLOY006');
+									if (opts.reportFile) {
+										await collector.forceWrite();
+									}
+									return stepError(errorMsg);
 								}
-								ctx.logger.trace('Asset uploads complete');
+
+								ctx.logger.trace(
+									`Asset uploads complete: ${build.assets.length} files, raw=${rawBytes}B, on-wire=${transferredBytes}B`
+								);
 								endCdnUploadDiagnostic();
 								progress(95);
+							} else {
+								ctx.logger.debug('No assets to upload to CDN');
 							}
 
 							progress(100);
 							const output = build?.assets.length
 								? [
 										tui.muted(
-											`✓ Uploaded ${build.assets.length} ${tui.plural(build.assets.length, 'asset', 'assets')} (${tui.formatBytes(bytes)}) to CDN`
+											formatUploadSummary(
+												build.assets.length,
+												rawBytes,
+												transferredBytes
+											)
 										),
 									]
 								: undefined;

package/src/cmd/cloud/sandbox/checkpoint/create.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxResolve, diskCheckpointCreate } from '@agentuity/server';
+import { diskCheckpointCreate } from '@agentuity/server';
 
 const CheckpointCreateResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -42,8 +42,14 @@ export const createSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 

package/src/cmd/cloud/sandbox/checkpoint/delete.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxResolve, diskCheckpointDelete } from '@agentuity/server';
+import { diskCheckpointDelete } from '@agentuity/server';
 
 const CheckpointDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -63,8 +63,14 @@ export const deleteSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 

package/src/cmd/cloud/sandbox/checkpoint/list.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxResolve, diskCheckpointList } from '@agentuity/server';
+import { diskCheckpointList } from '@agentuity/server';
 
 const CheckpointInfoSchema = z.object({
 	id: z.string(),
@@ -40,8 +40,14 @@ export const listSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 

package/src/cmd/cloud/sandbox/checkpoint/restore.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../../types';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
-import { sandboxResolve, diskCheckpointRestore } from '@agentuity/server';
+import { diskCheckpointRestore } from '@agentuity/server';
 
 const CheckpointRestoreResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -42,8 +42,14 @@ export const restoreSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);
 

package/src/cmd/cloud/sandbox/create.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, parseFileArgs, cacheSandboxRegion } from './util';
+import { createSandboxClient, parseFileArgs, cacheSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxCreate } from '@agentuity/server';
 import { StructuredError } from '@agentuity/core';
@@ -72,6 +72,10 @@ export const createSubcommand = createCommand({
 				.string()
 				.optional()
 				.describe('Idle timeout before sandbox is reaped (e.g., "10m", "1h")'),
+			pausedTimeout: z
+				.string()
+				.optional()
+				.describe('Maximum time sandbox can remain paused before termination (e.g., "24h")'),
 			env: z.array(z.string()).optional().describe('Environment variables (KEY=VALUE)'),
 			file: z
 				.array(z.string())
@@ -195,7 +199,13 @@ export const createSubcommand = createCommand({
 					opts.network || opts.port
 						? { enabled: opts.network || opts.port !== undefined, port: opts.port }
 						: undefined,
-				timeout: opts.idleTimeout ? { idle: opts.idleTimeout } : undefined,
+				timeout:
+					opts.idleTimeout || opts.pausedTimeout
+						? {
+								idle: opts.idleTimeout,
+								paused: opts.pausedTimeout,
+							}
+						: undefined,
 				env: Object.keys(envMap).length > 0 ? envMap : undefined,
 				files: hasFiles ? files : undefined,
 				snapshot: opts.snapshot,
@@ -206,8 +216,8 @@ export const createSubcommand = createCommand({
 			orgId,
 		});
 
-		// Cache the region for future lookups
-		await cacheSandboxRegion(config?.name, result.sandboxId, region);
+		// Cache routing context for future sandbox commands.
+		await cacheSandboxTarget(config?.name, result.sandboxId, region, orgId);
 
 		if (!options.json) {
 			const duration = Date.now() - started;

package/src/cmd/cloud/sandbox/delete.ts

@@ -1,9 +1,9 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, clearSandboxRegionCache } from './util';
+import { createSandboxClient, clearSandboxRegionCache, resolveSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxDestroy, sandboxResolve } from '@agentuity/server';
+import { sandboxDestroy } from '@agentuity/server';
 
 const SandboxDeleteResponseSchema = z.object({
 	success: z.boolean().describe('Whether the operation succeeded'),
@@ -57,8 +57,14 @@ export const deleteSubcommand = createCommand({
 
 		const started = Date.now();
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const sandboxInfo = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			config?.name ?? 'production',
+			config
+		);
 
 		const client = createSandboxClient(logger, auth, sandboxInfo.region);