@agentuity/cli 1.0.58 → 1.0.60

package/src/cmd/cloud/deploy-fork.ts

@@ -34,6 +34,16 @@ export interface ForkDeployResult {
 	success: boolean;
 	exitCode: number;
 	diagnostics?: ClientDiagnostics;
+	/** Deploy result passed back from child process via temp file */
+	deployResult?: {
+		urls?: {
+			deployment: string;
+			latest: string;
+			custom?: string[];
+			dashboard: string;
+		};
+		logs?: string[];
+	};
 }
 
 /**
@@ -77,6 +87,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 	const reportFile = join(tmpdir(), `agentuity-deploy-${deploymentId}.json`);
 	const cleanLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-logs.txt`);
 	const rawLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-raw.txt`);
+	const deployResultFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-result.json`);
 	const rawLogsWriter = createWriteStream(rawLogsFile);
 	let proc: Subprocess | null = null;
 	let cancelled = false;
@@ -152,13 +163,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 	process.on('SIGTERM', sigtermHandler);
 
 	try {
-		const childArgs = [
-			'agentuity',
-			'deploy',
-			'--child-mode',
-			`--report-file=${reportFile}`,
-			...args,
-		];
+		const childArgs = ['deploy', '--child-mode', `--report-file=${reportFile}`, ...args];
 
 		// Pass the deployment info via environment variable (same format as CI builds)
 		const deploymentEnvValue = JSON.stringify({
@@ -167,14 +172,19 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 			publicKey: deployment.publicKey,
 		});
 
-		logger.debug('Spawning child deploy process: bunx %s', childArgs.join(' '));
+		// Re-exec the same entry point that the parent is running so that
+		// local/dev builds test the current code instead of a stale global
+		// install.  process.execPath is the bun binary; Bun.main is the
+		// script entry (e.g. bin/cli.ts or the compiled binary).
+		const cmd = [process.execPath, Bun.main, ...childArgs];
+		logger.debug('Spawning child deploy process: %s', cmd.join(' '));
 
 		// Get terminal dimensions to pass to child
 		const columns = process.stdout.columns || 80;
 		const rows = process.stdout.rows || 24;
 
 		proc = spawn({
-			cmd: ['bunx', ...childArgs],
+			cmd,
 			cwd: projectDir,
 			env: {
 				...process.env,
@@ -190,6 +200,8 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 				LINES: String(rows),
 				// Enable clean log collection for Pulse streaming
 				AGENTUITY_CLEAN_LOGS_FILE: cleanLogsFile,
+				// Pass result file path for child to write deploy URLs/logs back
+				AGENTUITY_DEPLOY_RESULT_FILE: deployResultFile,
 			},
 			stdin: 'inherit',
 			stdout: 'pipe',
@@ -246,20 +258,34 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 			}
 		}
 
+		// Read deploy result (URLs, logs) from child process
+		let deployResult: ForkDeployResult['deployResult'] | undefined;
+		if (existsSync(deployResultFile)) {
+			try {
+				const resultContent = readFileSync(deployResultFile, 'utf-8');
+				deployResult = JSON.parse(resultContent);
+				unlinkSync(deployResultFile);
+			} catch (err) {
+				logger.debug('Failed to read deploy result file: %s', err);
+			}
+		}
+
 		// Stream clean logs to Pulse (prefer clean logs over raw output)
 		if (buildLogsStreamURL) {
-			let logsContent = '';
+			let streamedCleanLogs = false;
 			if (existsSync(cleanLogsFile)) {
 				try {
-					logsContent = readFileSync(cleanLogsFile, 'utf-8');
+					const cleanLogs = Bun.file(cleanLogsFile);
+					if (cleanLogs.size > 0) {
+						await streamToPulse(buildLogsStreamURL, sdkKey, cleanLogs, logger);
+						streamedCleanLogs = true;
+					}
 					unlinkSync(cleanLogsFile);
 				} catch (err) {
-					logger.debug('Failed to read clean logs file: %s', err);
+					logger.debug('Failed to stream clean logs file: %s', err);
 				}
 			}
-			if (logsContent) {
-				await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
-			} else if (existsSync(rawLogsFile)) {
+			if (!streamedCleanLogs && existsSync(rawLogsFile)) {
 				// Stream raw logs file directly to Pulse without loading into memory
 				await streamToPulse(buildLogsStreamURL, sdkKey, Bun.file(rawLogsFile), logger);
 			}
@@ -299,24 +325,32 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 			return { success: false, exitCode, diagnostics };
 		}
 
-		return { success: true, exitCode, diagnostics };
+		return { success: true, exitCode, diagnostics, deployResult };
 	} catch (err) {
 		const errorMessage = err instanceof Error ? err.message : String(err);
 		logger.error('Fork deploy error: %s', errorMessage);
 
 		if (buildLogsStreamURL) {
-			let logsContent = '';
+			let streamedCleanLogs = false;
 			if (existsSync(cleanLogsFile)) {
 				try {
-					logsContent = readFileSync(cleanLogsFile, 'utf-8');
+					const cleanLogs = Bun.file(cleanLogsFile);
+					if (cleanLogs.size > 0) {
+						await streamToPulse(buildLogsStreamURL, sdkKey, cleanLogs, logger);
+						streamedCleanLogs = true;
+					}
 					unlinkSync(cleanLogsFile);
 				} catch {
 					// ignore
 				}
 			}
-			if (logsContent) {
-				logsContent += `\n\n--- FORK ERROR ---\n${errorMessage}\n`;
-				await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
+			if (streamedCleanLogs) {
+				await streamToPulse(
+					buildLogsStreamURL,
+					sdkKey,
+					`\n\n--- FORK ERROR ---\n${errorMessage}\n`,
+					logger
+				);
 			} else {
 				// Append error to raw logs file and stream it without loading into memory
 				try {
@@ -383,7 +417,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 		process.off('SIGTERM', sigtermHandler);
 
 		// Clean up temp files
-		for (const file of [reportFile, cleanLogsFile, rawLogsFile]) {
+		for (const file of [reportFile, cleanLogsFile, rawLogsFile, deployResultFile]) {
 			if (existsSync(file)) {
 				try {
 					unlinkSync(file);

package/src/cmd/cloud/deploy.ts

@@ -1,7 +1,16 @@
 import { createPublicKey } from 'node:crypto';
-import { createReadStream, createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import {
+	createReadStream,
+	createWriteStream,
+	existsSync,
+	mkdirSync,
+	unlinkSync,
+	writeFileSync,
+} from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
+import { pipeline } from 'node:stream/promises';
+import { createGzip } from 'node:zlib';
 import { StructuredError } from '@agentuity/core';
 import {
 	type BuildMetadata,
@@ -403,6 +412,8 @@ export const deploySubcommand = createSubcommand({
 				success: true,
 				deploymentId: initialDeployment.id,
 				projectId: project.projectId,
+				logs: result.deployResult?.logs,
+				urls: result.deployResult?.urls,
 			};
 		}
 		let useExistingDeployment = false;
@@ -821,9 +832,10 @@ export const deploySubcommand = createSubcommand({
 								endCodeUploadDiagnostic();
 
 								progress(70);
-								ctx.logger.trace('Consuming response body');
-								// Wait for response body to be consumed before deleting
-								await resp.arrayBuffer();
+								ctx.logger.trace('Cancelling upload response body');
+								// No response payload is needed for successful uploads.
+								// Cancel to release resources without buffering into memory.
+								await resp.body?.cancel();
 								ctx.logger.trace('Deleting encrypted zip');
 								await zipfile.delete();
 							} finally {
@@ -874,27 +886,48 @@ export const deploySubcommand = createSubcommand({
 
 										bytes += asset.size;
 
-										let body: Uint8Array | Blob;
+										let body: Blob;
+										let gzTempPath: string | undefined;
 										if (asset.contentEncoding === 'gzip') {
-											const file = Bun.file(filePath);
-											const ab = await file.arrayBuffer();
-											const gzipped = Bun.gzipSync(new Uint8Array(ab));
+											// Gzip to a temp file so Bun.file() can provide
+											// Content-Length to S3 (streaming bodies use chunked
+											// transfer encoding which S3 rejects).
+											gzTempPath = join(
+												tmpdir(),
+												`agentuity-asset-${deployment.id}-${Date.now()}-${asset.filename.replace(/\//g, '_')}.gz`
+											);
+											await pipeline(
+												createReadStream(filePath),
+												createGzip(),
+												createWriteStream(gzTempPath)
+											);
 											headers['Content-Encoding'] = 'gzip';
-											body = gzipped;
+											body = Bun.file(gzTempPath);
+											const compressedSize = body.size;
 											ctx.logger.trace(
-												`Compressing ${asset.filename} (${asset.size} -> ${gzipped.byteLength} bytes)`
+												`Gzip compressed ${asset.filename} (${asset.size} -> ${compressedSize} bytes)`
 											);
 										} else {
 											body = Bun.file(filePath);
 										}
 
+										const assetGzTempPath = gzTempPath;
 										promises.push(
 											fetch(assetUrl, {
 												method: 'PUT',
-												duplex: 'half',
 												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;
 											})
 										);
 									}
@@ -1194,7 +1227,7 @@ export const deploySubcommand = createSubcommand({
 			}
 
 			// Show deployment URLs
-			if (complete?.publicUrls) {
+			if (complete?.publicUrls && !options.json) {
 				const lines: string[] = [];
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
@@ -1237,6 +1270,29 @@ export const deploySubcommand = createSubcommand({
 			}
 			clearGlobalCollector();
 
+			// Write deploy result to file for fork parent to consume
+			const deployResultFile = process.env.AGENTUITY_DEPLOY_RESULT_FILE;
+			if (deployResultFile) {
+				try {
+					const resultData = {
+						urls: complete?.publicUrls
+							? {
+									deployment:
+										complete.publicUrls.vanityDeployment ??
+										complete.publicUrls.deployment,
+									latest: complete.publicUrls.vanityProject ?? complete.publicUrls.latest,
+									custom: complete.publicUrls.custom,
+									dashboard,
+								}
+							: undefined,
+						logs,
+					};
+					writeFileSync(deployResultFile, JSON.stringify(resultData));
+				} catch {
+					// Non-fatal: result file is optional
+				}
+			}
+
 			return {
 				success: true,
 				deploymentId: deployment.id,

package/src/cmd/project/show.ts

@@ -12,6 +12,14 @@ const ProjectShowResponseSchema = z.object({
 	orgId: z.string().describe('Organization ID'),
 	secrets: z.record(z.string(), z.string()).optional().describe('Project secrets (masked)'),
 	env: z.record(z.string(), z.string()).optional().describe('Environment variables'),
+	urls: z
+		.object({
+			dashboard: z.string().describe('Dashboard URL for the project'),
+			app: z.string().describe('Public URL for the latest deployment'),
+			custom: z.array(z.string()).describe('Custom domain URLs'),
+		})
+		.optional()
+		.describe('Project URLs'),
 });
 
 export const showSubcommand = createSubcommand({
@@ -60,6 +68,7 @@ export const showSubcommand = createSubcommand({
 			orgId: project.orgId,
 			secrets: project.secrets,
 			env: project.env,
+			urls: project.urls,
 		};
 	},
 });

package/src/cmd/support/report.ts

@@ -1,12 +1,12 @@
 import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { readFileSync } from 'node:fs';
+import { createWriteStream, readFileSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { tmpdir } from 'node:os';
 import { getLogSessionsInCurrentWindow } from '../../internal-logger';
 import * as tui from '../../tui';
 import { randomBytes } from 'node:crypto';
-import AdmZip from 'adm-zip';
+import archiver from 'archiver';
 import { APIResponseSchema } from '@agentuity/server';
 import { StructuredError } from '@agentuity/core';
 
@@ -61,10 +61,19 @@ async function createReportZip(sessionDirs: string[]): Promise<string> {
 		throw NoSessionDirectoriesError();
 	}
 
-	// Create zip in temp directory
+	// Create zip in temp directory, streaming to disk instead of buffering in memory
 	const tempZip = join(tmpdir(), `agentuity-report-${randomBytes(8).toString('hex')}.zip`);
 
-	const zip = new AdmZip();
+	const output = createWriteStream(tempZip);
+	const zip = archiver('zip', { zlib: { level: 9 } });
+
+	const writeDone = new Promise<void>((resolve, reject) => {
+		output.on('close', resolve);
+		output.on('error', reject);
+		zip.on('error', reject);
+	});
+
+	zip.pipe(output);
 
 	for (const sessionDir of sessionDirs) {
 		const sessionFile = join(sessionDir, 'session.json');
@@ -75,14 +84,15 @@ async function createReportZip(sessionDirs: string[]): Promise<string> {
 
 		// Add files with session ID prefix to avoid conflicts
 		if (await Bun.file(sessionFile).exists()) {
-			zip.addLocalFile(sessionFile, sessionId);
+			zip.file(sessionFile, { name: `${sessionId}/session.json` });
 		}
 		if (await Bun.file(logsFile).exists()) {
-			zip.addLocalFile(logsFile, sessionId);
+			zip.file(logsFile, { name: `${sessionId}/logs.jsonl` });
 		}
 	}
 
-	zip.writeZip(tempZip);
+	await zip.finalize();
+	await writeDone;
 
 	return tempZip;
 }
@@ -95,14 +105,15 @@ async function uploadReport(
 	zipPath: string,
 	logger: import('../../types').Logger
 ): Promise<void> {
-	const fileBuffer = readFileSync(zipPath);
+	// Use Bun.file() to stream the zip to S3 without loading it into memory.
+	// Bun automatically sets Content-Length from the file size.
+	const file = Bun.file(zipPath);
 
 	const response = await fetch(presignedUrl, {
 		method: 'PUT',
-		body: fileBuffer,
+		body: file,
 		headers: {
 			'Content-Type': 'application/zip',
-			'Content-Length': fileBuffer.length.toString(),
 		},
 	});
 

package/src/steps.ts

@@ -10,6 +10,7 @@ import type { LogLevel } from './types';
 import { ValidationInputError, ValidationOutputError, type IssuesType } from '@agentuity/server';
 import { clearLastLines, isTTYLike } from './tui';
 import { appendLog, isLogCollectionEnabled } from './log-collector';
+import { getOutputOptions, isJSONMode } from './output';
 
 /**
  * Error thrown when step execution is interrupted by a signal (e.g., Ctrl+C).
@@ -700,6 +701,43 @@ async function runStepsPlain(steps: Step[]): Promise<void> {
  * Run a series of steps with animated progress
  */
 export async function runSteps(steps: Step[], logLevel?: LogLevel): Promise<void> {
+	const outputOptions = getOutputOptions();
+
+	// In JSON mode, skip all UI rendering
+	if (outputOptions && isJSONMode(outputOptions)) {
+		const abortController = new AbortController();
+		for (const step of steps) {
+			if (abortController.signal.aborted) break;
+			if (step) {
+				const ctx: StepContext = {
+					signal: abortController.signal,
+					progress: () => {},
+				};
+				let outcome: StepOutcome;
+				try {
+					outcome = await step.run(ctx);
+				} catch (err) {
+					if (err instanceof Error && err.name === 'AbortError') {
+						throw new StepInterruptError();
+					}
+					outcome = {
+						status: 'error',
+						message: err instanceof Error ? err.message : String(err),
+						cause: err instanceof Error ? err : undefined,
+					};
+				}
+				if (outcome.status === 'error') {
+					if (outcome.cause instanceof Error && outcome.cause.name === 'AbortError') {
+						throw new StepInterruptError();
+					}
+					const errorMsg = outcome.message || 'An unknown error occurred';
+					throw new Error(errorMsg);
+				}
+			}
+		}
+		return;
+	}
+
 	const useTUI = isTTYLike() && (!logLevel || ['info', 'warn', 'error'].includes(logLevel));
 
 	if (useTUI) {

package/src/tui.ts

@@ -299,8 +299,13 @@ export function getSeverityColor(severity: string): (text: string) => string {
 export function success(message: string): void {
 	const color = getColor('success');
 	const reset = getColor('reset');
-	// Clear line first to ensure no leftover content from previous output
-	process.stderr.write(`\r\x1b[2K${color}${ICONS.success} ${message}${reset}\n`);
+	if (process.stderr.isTTY) {
+		// Clear line first to ensure no leftover content from previous output
+		process.stderr.write(`\r\x1b[2K${color}${ICONS.success} ${message}${reset}\n`);
+	} else {
+		// No ANSI control sequences for non-TTY streams (pipes, command substitution)
+		process.stderr.write(`${ICONS.success} ${message}\n`);
+	}
 }
 
 /**
@@ -1248,18 +1253,23 @@ export async function spinner<T>(
 	const { getOutputOptions, shouldDisableProgress } = await import('./output');
 	const outputOptions = getOutputOptions();
 	const noProgress = outputOptions ? shouldDisableProgress(outputOptions) : false;
+	const isJsonMode = outputOptions?.json === true;
 
-	// If no interactive TTY-like environment or progress disabled, just execute
-	// the callback without animation
-	if (!isTTYLike() || noProgress) {
+	// If stderr is not a real terminal or progress disabled, just execute
+	// the callback without animation. We check stderr specifically because
+	// the spinner writes ANSI sequences to stderr — isTTYLike() may return
+	// true when stdout is a TTY but stderr is piped (e.g. 2>&1 in $()).
+	if (!process.stderr.isTTY || noProgress) {
 		try {
 			const result =
 				options.type === 'progress'
 					? await options.callback(() => {})
 					: options.type === 'logger'
 						? await options.callback((logMessage: string) => {
-								// In non-TTY mode, just write logs directly to stdout
-								process.stdout.write(logMessage + '\n');
+								// In JSON mode, don't write logs to stdout
+								if (!isJsonMode) {
+									process.stdout.write(logMessage + '\n');
+								}
 							})
 						: options.type === 'countdown'
 							? await options.callback()
@@ -1269,7 +1279,6 @@ export async function spinner<T>(
 
 			// If clearOnSuccess is true, don't show success message
 			// Also skip success message in JSON mode
-			const isJsonMode = outputOptions?.json === true;
 			if (!options.clearOnSuccess && !isJsonMode) {
 				const successColor = getColor('success');
 				console.error(`${successColor}${ICONS.success} ${message}${reset}`);
@@ -1279,7 +1288,7 @@ export async function spinner<T>(
 		} catch (err) {
 			const clearOnError =
 				(options.type === 'progress' || options.type === 'simple') && options.clearOnError;
-			if (!clearOnError) {
+			if (!clearOnError && !isJsonMode) {
 				const errorColor = getColor('error');
 				console.error(`${errorColor}${ICONS.error} ${message}${reset}`);
 			}

package/src/utils/zip.ts

@@ -1,7 +1,8 @@
-import { readFileSync, lstatSync } from 'node:fs';
-import { relative } from 'node:path';
+import { createWriteStream, lstatSync } from 'node:fs';
+import { mkdir } from 'node:fs/promises';
+import { dirname, relative } from 'node:path';
 import { Glob } from 'bun';
-import AdmZip from 'adm-zip';
+import archiver from 'archiver';
 import { toForwardSlash } from './normalize-path';
 
 interface Options {
@@ -10,7 +11,20 @@ interface Options {
 }
 
 export async function zipDir(dir: string, outdir: string, options?: Options) {
-	const zip = new AdmZip();
+	await mkdir(dirname(outdir), { recursive: true });
+	const output = createWriteStream(outdir);
+	const zip = archiver('zip', {
+		zlib: { level: 9 },
+	});
+
+	const writeDone = new Promise<void>((resolve, reject) => {
+		output.on('close', resolve);
+		output.on('error', reject);
+		zip.on('error', reject);
+	});
+
+	zip.pipe(output);
+
 	const files = await Array.fromAsync(
 		new Glob('**/*').scan({ cwd: dir, absolute: true, dot: true, followSymlinks: false })
 	);
@@ -31,11 +45,8 @@ export async function zipDir(dir: string, outdir: string, options?: Options) {
 				// across machines and would cause EISDIR errors on extraction.
 				const stat = lstatSync(file);
 				if (!stat.isSymbolicLink() && !stat.isDirectory()) {
-					// Use addFile with explicit Unix permissions (0o644) instead of addLocalFile.
-					// On Windows, addLocalFile relies on OS file stats which may produce zip entries
-					// with incorrect Unix permission bits, causing EACCES errors when extracted on Linux.
-					const data = readFileSync(file);
-					zip.addFile(rel, data, '', 0o644);
+					// Set explicit Unix permissions (0o644) for portability across OSes.
+					zip.file(file, { name: rel, mode: 0o644 });
 				}
 			} catch (err) {
 				throw new Error(`Failed to add file to zip: ${rel} (${file})`, { cause: err });
@@ -48,7 +59,8 @@ export async function zipDir(dir: string, outdir: string, options?: Options) {
 			await Bun.sleep(10); // give some time for the progress bar to render
 		}
 	}
-	await zip.writeZip(outdir);
+	await zip.finalize();
+	await writeDone;
 	if (options?.progress) {
 		options.progress(100);
 		await Bun.sleep(100); // give some time for the progress bar to render