@agentuity/cli 2.0.11 → 2.0.12

package/src/cmd/cloud/sandbox/env.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 { sandboxSetEnv, sandboxResolve } from '@agentuity/server';
+import { sandboxSetEnv } from '@agentuity/server';
 
 export const envSubcommand = createCommand({
 	name: 'env',
@@ -44,9 +44,14 @@ export const envSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 

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

@@ -3,12 +3,14 @@ import { Writable } from 'node:stream';
 import { ErrorCode } from '../../../errors';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { createSandboxClient, detectNullStream, resolveSandboxTarget } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxExecute, executionGet, sandboxResolve } from '@agentuity/server';
+import { sandboxExecute, executionGet } from '@agentuity/server';
 import { streamUrlToWritable } from '../../../utils/stream-url';
 
 const EXECUTION_WAIT_DURATION = '5m';
+const EMPTY_STREAM_FAST_POLL_MS = 100;
+const EMPTY_STREAM_FAST_TIMEOUT_MS = 2000;
 
 const SandboxExecResponseSchema = z.object({
 	executionId: z.string().describe('Unique execution identifier'),
@@ -63,6 +65,11 @@ export const execSubcommand = createCommand({
 				.default(false)
 				.optional()
 				.describe('Include timestamps in output (default: false)'),
+			quiet: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Suppress output (do not create stdout/stderr streams)'),
 		}),
 		response: SandboxExecResponseSchema,
 	},
@@ -79,12 +86,46 @@ export const execSubcommand = createCommand({
 			}
 		}
 
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 		const started = Date.now();
 
+		// Detect if stdout/stderr are redirected to /dev/null
+		const stdoutIsNull = detectNullStream(1);
+		const stderrIsNull = detectNullStream(2);
+
+		// Build stream configuration
+		const streamConfig: {
+			timestamps?: boolean;
+			stdout?: string;
+			stderr?: string;
+		} = {
+			timestamps: opts.timestamps,
+		};
+
+		// --quiet: suppress all output streams (no server streams, no local capture)
+		if (opts.quiet) {
+			streamConfig.stdout = 'ignore';
+			streamConfig.stderr = 'ignore';
+		} else if (!options.json) {
+			// Auto-detect /dev/null redirection (only when not in JSON mode)
+			// In JSON mode we need output for the response, so keep streams even if redirected
+			if (stdoutIsNull) {
+				streamConfig.stdout = 'ignore';
+			}
+			if (stderrIsNull) {
+				streamConfig.stderr = 'ignore';
+			}
+		}
+
 		const abortController = new AbortController();
 		const handleSignal = () => {
 			abortController.abort();
@@ -100,7 +141,7 @@ export const execSubcommand = createCommand({
 				options: {
 					command: args.command,
 					timeout: opts.timeout,
-					stream: opts.timestamps !== undefined ? { timestamps: opts.timestamps } : undefined,
+					stream: streamConfig,
 				},
 				orgId,
 			});
@@ -119,7 +160,7 @@ export const execSubcommand = createCommand({
 			const stdoutStreamUrl = execution.stdoutStreamUrl;
 			const stderrStreamUrl = execution.stderrStreamUrl;
 			const streamAbortController = new AbortController();
-			const streamPromises: Promise<void>[] = [];
+			const streamPromises: Promise<{ bytesRead: number; chunks: number }>[] = [];
 			const streamLabels: string[] = [];
 
 			const isCombinedOutput =
@@ -135,27 +176,20 @@ export const execSubcommand = createCommand({
 			const stdoutChunks: string[] = [];
 			const stderrChunks: string[] = [];
 
-			let stdoutWritable: NodeJS.WritableStream;
-			let stderrWritable: NodeJS.WritableStream;
-
-			if (options.json) {
-				if (isCombinedOutput) {
-					stdoutWritable = createCaptureStream((chunk) => outputChunks.push(chunk));
-					stderrWritable = createCaptureStream((chunk) => outputChunks.push(chunk));
-				} else {
-					stdoutWritable = createCaptureStream((chunk) => {
-						stdoutChunks.push(chunk);
-						outputChunks.push(chunk);
-					});
-					stderrWritable = createCaptureStream((chunk) => {
-						stderrChunks.push(chunk);
-						outputChunks.push(chunk);
-					});
-				}
-			} else {
-				stdoutWritable = process.stdout;
-				stderrWritable = process.stderr;
-			}
+			const stdoutWritable: NodeJS.WritableStream =
+				options.json || stdoutIsNull
+					? createCaptureStream((chunk) => {
+							stdoutChunks.push(chunk);
+							outputChunks.push(chunk);
+						})
+					: process.stdout;
+			const stderrWritable: NodeJS.WritableStream =
+				options.json || stderrIsNull
+					? createCaptureStream((chunk) => {
+							stderrChunks.push(chunk);
+							outputChunks.push(chunk);
+						})
+					: process.stderr;
 
 			if (isCombinedOutput) {
 				logger.debug('[exec] starting combined stream: %s', stdoutStreamUrl);
@@ -166,7 +200,7 @@ export const execSubcommand = createCommand({
 						label: 'combined',
 						raw: true,
 						v2: true,
-					}).then(() => {})
+					})
 				);
 			} else {
 				if (stdoutStreamUrl) {
@@ -178,7 +212,7 @@ export const execSubcommand = createCommand({
 							label: 'stdout',
 							raw: true,
 							v2: true,
-						}).then(() => {})
+						})
 					);
 				}
 
@@ -191,7 +225,7 @@ export const execSubcommand = createCommand({
 							label: 'stderr',
 							raw: true,
 							v2: true,
-						}).then(() => {})
+						})
 					);
 				}
 			}
@@ -203,13 +237,53 @@ export const execSubcommand = createCommand({
 			);
 
 			let finalExecution: Awaited<ReturnType<typeof executionGet>>;
+			let streamResults: { bytesRead: number; chunks: number }[] | undefined;
 			const pollStart = Date.now();
+			const executionWaitAbortController = new AbortController();
 			try {
-				finalExecution = await executionGet(client, {
+				const executionWaitPromise = executionGet(client, {
 					executionId: execution.executionId,
 					orgId,
 					wait: EXECUTION_WAIT_DURATION,
+					signal: executionWaitAbortController.signal,
 				});
+
+				if (streamPromises.length > 0) {
+					const winner = await Promise.race([
+						executionWaitPromise.then((result) => ({ type: 'execution' as const, result })),
+						Promise.all(streamPromises).then((results) => ({
+							type: 'streams' as const,
+							results,
+						})),
+					]);
+
+					if (winner.type === 'execution') {
+						finalExecution = winner.result;
+					} else {
+						streamResults = winner.results;
+						const bytesRead = streamResults.reduce(
+							(sum, result) => sum + result.bytesRead,
+							0
+						);
+						if (bytesRead === 0) {
+							logger.debug(
+								'[exec] all streams EOF with 0 bytes before executionGet completed — switching to fast terminal poll'
+							);
+							void executionWaitPromise.catch(() => undefined);
+							executionWaitAbortController.abort();
+							finalExecution = await waitForTerminalExecutionFast(
+								client,
+								execution.executionId,
+								orgId,
+								logger
+							);
+						} else {
+							finalExecution = await executionWaitPromise;
+						}
+					}
+				} else {
+					finalExecution = await executionWaitPromise;
+				}
 			} catch (err) {
 				streamAbortController.abort();
 				throw err;
@@ -225,17 +299,21 @@ export const execSubcommand = createCommand({
 				logger.debug('[exec] waiting for %d stream(s) to EOF', streamPromises.length);
 				const streamWaitStart = Date.now();
 				let graceTriggered = false;
-				const streamGrace = setTimeout(() => {
-					graceTriggered = true;
-					logger.debug(
-						'[exec] stream grace period (5s) expired after execution complete — aborting streams'
-					);
-					streamAbortController.abort();
-				}, 5_000);
-				try {
-					await Promise.all(streamPromises);
-				} finally {
-					clearTimeout(streamGrace);
+				if (!streamResults) {
+					const streamGraceMs = 500;
+					const streamGrace = setTimeout(() => {
+						graceTriggered = true;
+						logger.debug(
+							'[exec] stream grace period (%dms) expired after execution complete — aborting streams',
+							streamGraceMs
+						);
+						streamAbortController.abort();
+					}, streamGraceMs);
+					try {
+						streamResults = await Promise.all(streamPromises);
+					} finally {
+						clearTimeout(streamGrace);
+					}
 				}
 				logger.debug(
 					'[exec] all streams done in %dms (graceTriggered=%s)',
@@ -314,4 +392,41 @@ function createCaptureStream(onChunk: (chunk: string) => void): NodeJS.WritableS
 	});
 }
 
+const TERMINAL_EXECUTION_STATUSES = new Set([
+	'completed',
+	'failed',
+	'error',
+	'timeout',
+	'killed',
+	'cancelled',
+]);
+
+async function waitForTerminalExecutionFast(
+	client: Parameters<typeof executionGet>[0],
+	executionId: string,
+	orgId: string,
+	logger: Parameters<typeof streamUrlToWritable>[2]
+) {
+	const deadline = Date.now() + EMPTY_STREAM_FAST_TIMEOUT_MS;
+	while (Date.now() < deadline) {
+		const info = await executionGet(client, { executionId, orgId });
+		if (TERMINAL_EXECUTION_STATUSES.has(info.status)) {
+			logger.debug(
+				'[exec] fast terminal poll observed status=%s for executionId=%s',
+				info.status,
+				executionId
+			);
+			return info;
+		}
+		await new Promise((resolve) => setTimeout(resolve, EMPTY_STREAM_FAST_POLL_MS));
+	}
+
+	logger.debug(
+		'[exec] fast terminal poll timed out after %dms for executionId=%s, falling back to long-poll',
+		EMPTY_STREAM_FAST_TIMEOUT_MS,
+		executionId
+	);
+	return executionGet(client, { executionId, orgId, wait: EXECUTION_WAIT_DURATION });
+}
+
 export default execSubcommand;

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

@@ -1,9 +1,9 @@
-import { executionList, sandboxResolve } from '@agentuity/server';
+import { executionList } from '@agentuity/server';
 import { z } from 'zod';
 import { getCommand } from '../../../../command-prefix';
 import * as tui from '../../../../tui';
 import { createCommand } from '../../../../types';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 
 const ExecutionInfoSchema = z.object({
 	executionId: z.string().describe('Execution ID'),
@@ -54,9 +54,14 @@ export const listSubcommand = createCommand({
 	async handler(ctx) {
 		const { args, opts, options, auth, logger, apiClient } = ctx;
 
-		// Resolve sandbox to get region and orgId (like exec.ts does)
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId: resolvedOrgId } = sandboxInfo;
+		const { region, orgId: resolvedOrgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			args.sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 		const effectiveOrgId = opts?.orgId || resolvedOrgId;
 		const client = createSandboxClient(logger, auth, region);
 

package/src/cmd/cloud/sandbox/fs/cp.ts

@@ -1,17 +1,30 @@
 import { z } from 'zod';
-import { readFileSync, writeFileSync, mkdirSync, statSync, readdirSync } from 'node:fs';
+import {
+	readFileSync,
+	mkdirSync,
+	statSync,
+	readdirSync,
+	createWriteStream,
+	mkdtempSync,
+	rmSync,
+} from 'node:fs';
 import { dirname, resolve, basename, join, relative } from 'node:path';
+import { tmpdir } from 'node:os';
+import { pipeline } from 'node:stream/promises';
+import { Readable } from 'node:stream';
+import * as tar from 'tar';
 import { createCommand } from '../../../../types';
 import { toForwardSlash } from '../../../../utils/normalize-path';
 import * as tui from '../../../../tui';
-import { createSandboxClient } from '../util';
+import { createSandboxClient, resolveSandboxTarget } from '../util';
 import { getCommand } from '../../../../command-prefix';
 import {
 	sandboxWriteFiles,
 	sandboxReadFile,
 	sandboxExecute,
 	executionGet,
-	sandboxResolve,
+	sandboxDownloadArchive,
+	sandboxUploadArchive,
 	type APIClient,
 } from '@agentuity/server';
 import type { Logger, FileToWrite } from '@agentuity/core';
@@ -125,9 +138,14 @@ export const cpSubcommand = createCommand({
 
 		const sandboxId = source.sandboxId ?? destination.sandboxId!;
 
-		// Resolve sandbox to get region and orgId using CLI API
-		const sandboxInfo = await sandboxResolve(apiClient, sandboxId);
-		const { region, orgId } = sandboxInfo;
+		const { region, orgId } = await resolveSandboxTarget(
+			logger,
+			auth,
+			apiClient,
+			sandboxId,
+			ctx.config?.name ?? 'production',
+			ctx.config
+		);
 
 		const client = createSandboxClient(logger, auth, region);
 		const recursive = opts.recursive ?? false;
@@ -337,7 +355,6 @@ async function uploadDirectory(
 		logger.fatal(`Directory is empty: ${localDir}`);
 	}
 
-	const files: FileToWrite[] = [];
 	let totalBytes = 0;
 	const effectiveRemotePath = remotePath || basename(localDir);
 	const baseRemotePath = effectiveRemotePath.endsWith('/')
@@ -371,14 +388,23 @@ async function uploadDirectory(
 	}
 
 	for (const filePath of allFiles) {
-		const relativePath = toForwardSlash(relative(localDir, filePath));
-		const targetPath = `${baseRemotePath}/${relativePath}`;
-		const buffer = readFileSync(filePath);
-		files.push({ path: targetPath, content: buffer });
-		totalBytes += buffer.length;
+		totalBytes += statSync(filePath).size;
 	}
 
-	await sandboxWriteFiles(client, { sandboxId, files, orgId });
+	const tempDir = mkdtempSync(join(tmpdir(), 'agentuity-fs-cp-'));
+	const archivePath = join(tempDir, 'upload.tar.gz');
+	try {
+		await createTarGzArchive(localDir, allFiles, archivePath);
+		await sandboxUploadArchive(client, {
+			sandboxId,
+			archive: Bun.file(archivePath).stream(),
+			path: baseRemotePath,
+			format: 'tar.gz',
+			orgId,
+		});
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
+	}
 
 	if (!jsonOutput) {
 		tui.success(
@@ -386,7 +412,11 @@ async function uploadDirectory(
 		);
 	}
 
-	const implicitDirs = getImplicitDirectories(files.map((f) => f.path));
+	const implicitDirs = getImplicitDirectories(
+		allFiles.map(
+			(filePath) => `${baseRemotePath}/${toForwardSlash(relative(localDir, filePath))}`
+		)
+	);
 	return {
 		source: localDir,
 		destination: `${sandboxId}:${baseRemotePath}`,
@@ -444,15 +474,6 @@ async function downloadSingleFile(
 ): Promise<z.infer<typeof SandboxCpResponseSchema>> {
 	const stream = await sandboxReadFile(client, { sandboxId, path: remotePath, orgId });
 
-	const chunks: Uint8Array[] = [];
-	const reader = stream.getReader();
-	while (true) {
-		const { done, value } = await reader.read();
-		if (done) break;
-		if (value) chunks.push(value);
-	}
-	const buffer = Buffer.concat(chunks);
-
 	let targetPath = localPath;
 	if (localPath.endsWith('/') || localPath === '.') {
 		targetPath = resolve(localPath, basename(remotePath));
@@ -462,101 +483,70 @@ async function downloadSingleFile(
 
 	const dir = dirname(targetPath);
 	mkdirSync(dir, { recursive: true });
-
-	writeFileSync(targetPath, buffer);
+	await pipeline(
+		Readable.fromWeb(stream as unknown as globalThis.ReadableStream<ArrayBufferView>),
+		createWriteStream(targetPath)
+	);
+	const buffer = Bun.file(targetPath);
 
 	if (!jsonOutput) {
-		tui.success(`Copied ${sandboxId}:${remotePath} → ${targetPath} (${buffer.length} bytes)`);
+		tui.success(`Copied ${sandboxId}:${remotePath} → ${targetPath} (${buffer.size} bytes)`);
 	}
 
 	return {
 		source: `${sandboxId}:${remotePath}`,
 		destination: targetPath,
-		bytesTransferred: buffer.length,
+		bytesTransferred: buffer.size,
 		filesTransferred: 1,
 	};
 }
 
 async function downloadDirectory(
 	client: APIClient,
-	logger: Logger,
+	_logger: Logger,
 	orgId: string,
 	sandboxId: string,
 	remotePath: string,
 	localPath: string,
-	timeout: string | undefined,
+	_timeout: string | undefined,
 	jsonOutput: boolean
 ): Promise<z.infer<typeof SandboxCpResponseSchema>> {
-	const listExecution = await sandboxExecute(client, {
-		sandboxId,
-		options: {
-			command: ['find', remotePath, '-type', 'f'],
-			timeout,
-		},
-		orgId,
-	});
-
-	const listChunks: Buffer[] = [];
-	if (listExecution.stdoutStreamUrl) {
-		await streamToBuffer(listExecution.stdoutStreamUrl, listChunks, logger);
-	}
-
-	await waitForExecution(client, orgId, listExecution.executionId, logger);
-
-	const fileList = Buffer.concat(listChunks)
-		.toString('utf-8')
-		.trim()
-		.split('\n')
-		.filter((f) => f.length > 0);
-
-	if (fileList.length === 0) {
-		logger.fatal(`No files found in directory: ${remotePath}`);
-	}
-
-	const baseRemotePath = remotePath.endsWith('/') ? remotePath.slice(0, -1) : remotePath;
 	const baseLocalPath = resolve(localPath);
-	let totalBytes = 0;
-
-	for (const remoteFile of fileList) {
-		const relativePath = remoteFile.startsWith(baseRemotePath + '/')
-			? remoteFile.slice(baseRemotePath.length + 1)
-			: basename(remoteFile);
-
-		const localFilePath = join(baseLocalPath, relativePath);
-
-		try {
-			const stream = await sandboxReadFile(client, { sandboxId, path: remoteFile, orgId });
-			const chunks: Uint8Array[] = [];
-			const reader = stream.getReader();
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				if (value) chunks.push(value);
-			}
-			const buffer = Buffer.concat(chunks);
-			totalBytes += buffer.length;
-
-			const dir = dirname(localFilePath);
-			mkdirSync(dir, { recursive: true });
-			writeFileSync(localFilePath, buffer);
-
-			if (!jsonOutput) {
-				logger.info(`Downloaded ${remoteFile} (${buffer.length} bytes)`);
-			}
-		} catch (err) {
-			logger.warn(`Failed to read file: ${remoteFile}, skipping: ${err}`);
-			continue;
-		}
+	mkdirSync(baseLocalPath, { recursive: true });
+	const tempDir = mkdtempSync(join(tmpdir(), 'agentuity-fs-cp-'));
+	const archivePath = join(tempDir, 'download.tar.gz');
+	try {
+		const archiveStream = await sandboxDownloadArchive(client, {
+			sandboxId,
+			path: remotePath,
+			format: 'tar.gz',
+			orgId,
+		});
+		await pipeline(
+			Readable.fromWeb(archiveStream as unknown as globalThis.ReadableStream<ArrayBufferView>),
+			createWriteStream(archivePath)
+		);
+		await tar.extract({
+			file: archivePath,
+			cwd: baseLocalPath,
+			preservePaths: false,
+			strict: true,
+		});
+	} finally {
+		rmSync(tempDir, { recursive: true, force: true });
 	}
 
+	const fileList = getAllFiles(baseLocalPath);
+	const totalBytes = fileList.reduce((sum, filePath) => sum + statSync(filePath).size, 0);
+
 	if (!jsonOutput) {
 		tui.success(
-			`Copied ${sandboxId}:${baseRemotePath} → ${baseLocalPath} (${fileList.length} files, ${totalBytes} bytes)`
+			`Copied ${sandboxId}:${remotePath} → ${baseLocalPath} (${fileList.length} files, ${totalBytes} bytes)`
 		);
 	}
 
 	return {
-		source: `${sandboxId}:${baseRemotePath}`,
+		source: `${sandboxId}:${remotePath}`,
 		destination: baseLocalPath,
 		bytesTransferred: totalBytes,
 		filesTransferred: fileList.length,
@@ -601,42 +591,20 @@ async function waitForExecution(
 	logger.fatal('Execution timed out waiting for completion');
 }
 
-async function streamToBuffer(url: string, chunks: Buffer[], logger: Logger): Promise<void> {
-	const maxRetries = 10;
-	const retryDelay = 200;
-
-	for (let attempt = 0; attempt < maxRetries; attempt++) {
-		try {
-			if (attempt > 0) {
-				logger.debug('stream retry attempt %d', attempt + 1);
-				await sleep(retryDelay);
-			}
-
-			const response = await fetch(url);
-
-			if (!response.ok || !response.body) {
-				continue;
-			}
-
-			const reader = response.body.getReader();
-
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					return;
-				}
-
-				if (value) {
-					chunks.push(Buffer.from(value));
-				}
-			}
-		} catch (err) {
-			if (err instanceof Error && err.name === 'AbortError') {
-				throw err;
-			}
-			logger.debug('stream error: %s', err);
-		}
-	}
+async function createTarGzArchive(
+	localDir: string,
+	allFiles: string[],
+	archivePath: string
+): Promise<void> {
+	const relativePaths = allFiles.map((filePath) => toForwardSlash(relative(localDir, filePath)));
+	await tar.create(
+		{
+			gzip: true,
+			file: archivePath,
+			cwd: localDir,
+		},
+		relativePaths
+	);
 }
 
 function sleep(ms: number): Promise<void> {