@agentuity/cli 2.0.0-beta.1 → 2.0.1

package/src/cmd/build/vite/static-renderer.ts

@@ -1,8 +1,8 @@
 /**
  * Static Renderer
  *
- * When `render: 'static'` is set in agentuity.config.ts, this module:
- * 1. Runs a Vite SSR build to create a server-side entry point
+ * When `src/web/entry-server.tsx` exists, this module:
+ * 1. Runs a Vite SSR build (as a subprocess to avoid in-process Bun/Vite issues)
  * 2. Imports the built entry-server.js
  * 3. Discovers routes to pre-render:
  *    - If `routeTree` is exported: auto-discovers all non-parameterized routes
@@ -14,7 +14,6 @@
  */
 
 import { join } from 'node:path';
-import { createRequire } from 'node:module';
 import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
 import type { Logger } from '../../../types';
 
@@ -74,6 +73,7 @@ function extractRoutePaths(node: RouteTreeNode): string[] {
 export interface StaticRenderOptions {
 	rootDir: string;
 	logger: Logger;
+	dev?: boolean;
 }
 
 export interface StaticRenderResult {
@@ -82,7 +82,7 @@ export interface StaticRenderResult {
 }
 
 export async function runStaticRender(options: StaticRenderOptions): Promise<StaticRenderResult> {
-	const { rootDir, logger } = options;
+	const { rootDir, logger, dev = false } = options;
 	const started = Date.now();
 
 	const clientDir = join(rootDir, '.agentuity/client');
@@ -106,71 +106,40 @@ export async function runStaticRender(options: StaticRenderOptions): Promise<Sta
 		);
 	}
 
-	const isViteDebug =
-		process.env.AGENTUITY_VITE_DEBUG === '1' || process.env.AGENTUITY_VITE_DEBUG === 'true';
-	if (isViteDebug) {
-		logger.debug('Vite debug logging enabled via AGENTUITY_VITE_DEBUG');
-		const existing = process.env.DEBUG || '';
-		if (!existing.includes('vite:')) {
-			process.env.DEBUG = existing ? `${existing},vite:*` : 'vite:*';
+	// Step 1: Vite SSR build (subprocess)
+	// Run as a subprocess to avoid in-process Bun/Vite module resolution issues
+	// that cause @mdx-js/rollup and other plugins to fail during SSR builds.
+	// This matches the approach used for client builds in vite-builder.ts.
+	logger.debug('Running Vite SSR build for static rendering (subprocess)...');
+
+	const buildMode = dev ? 'development' : 'production';
+
+	const viteProcess = Bun.spawn(
+		[
+			'bun',
+			'x',
+			'vite',
+			'build',
+			'--ssr',
+			entryServerPath,
+			'--outDir',
+			ssrOutDir,
+			'--mode',
+			buildMode,
+		],
+		{
+			cwd: rootDir,
+			stdout: 'inherit',
+			stderr: 'inherit',
 		}
-	}
-
-	// Step 1: Vite SSR build
-	// This resolves import.meta.glob, MDX imports, and other Vite-specific APIs
-	logger.debug('Running Vite SSR build for static rendering...');
-
-	const projectRequire = createRequire(join(rootDir, 'package.json'));
-	let vitePath = 'vite';
-	try {
-		vitePath = projectRequire.resolve('vite');
-	} catch {
-		// Use CLI's bundled version
-	}
+	);
 
-	const { build: viteBuild, loadConfigFromFile, mergeConfig } = await import(vitePath);
+	const exitCode = await viteProcess.exited;
 
-	// Load vite.config.ts if it exists (v2 approach)
-	let userConfig: import('vite').InlineConfig = {};
-	const viteConfigPath = join(rootDir, 'vite.config.ts');
-
-	if (await Bun.file(viteConfigPath).exists()) {
-		try {
-			const loaded = await loadConfigFromFile(
-				{ command: 'build', mode: 'production' },
-				viteConfigPath
-			);
-			if (loaded?.config) {
-				userConfig = loaded.config as import('vite').InlineConfig;
-				logger.debug('Loaded vite.config.ts for SSR build');
-			}
-		} catch (error) {
-			logger.warn('Failed to load vite.config.ts: %s', error);
-		}
+	if (exitCode !== 0) {
+		throw new Error(`Vite SSR build exited with code ${exitCode}`);
 	}
 
-	// Merge user config with SSR build settings
-	const ssrConfig = mergeConfig(userConfig, {
-		root: rootDir,
-		build: {
-			ssr: entryServerPath,
-			outDir: ssrOutDir,
-			rollupOptions: {
-				output: {
-					format: 'esm',
-				},
-			},
-		},
-		ssr: {
-			// Bundle all dependencies for SSR — we need import.meta.glob, MDX, etc.
-			// resolved at build time. Node built-ins are still externalized.
-			noExternal: true,
-		},
-		logLevel: isViteDebug ? 'info' : 'warn',
-	});
-
-	await viteBuild(ssrConfig);
-
 	// Steps 2–4: wrapped in try-finally so SSR artifacts are always cleaned up,
 	// even if an exception is thrown during module import, validation, or rendering.
 	let routeCount = 0;

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

@@ -95,6 +95,27 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const buildMode = dev ? 'development' : 'production';
 		const clientOutDir = join(rootDir, '.agentuity/client');
 
+		// Ensure vite.config.ts exists (fallback for projects created before v2 template update)
+		const viteConfigPath = join(rootDir, 'vite.config.ts');
+		if (!existsSync(viteConfigPath)) {
+			logger.debug('Generating fallback vite.config.ts');
+			const fallbackConfig = `import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+import { join } from 'node:path';
+
+export default defineConfig({
+	plugins: [react()],
+	root: '.',
+	build: {
+		rollupOptions: {
+			input: join(__dirname, 'src/web/index.html'),
+		},
+	},
+});
+`;
+			await Bun.write(viteConfigPath, fallbackConfig);
+		}
+
 		logger.debug('Spawning vite build for client (subprocess mode)');
 		logger.debug('  outDir: %s', clientOutDir);
 		logger.debug('  mode: %s', buildMode);
@@ -229,6 +250,20 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 			workbenchRoute: workbenchConfig.route,
 			analyticsEnabled,
 		});
+
+		// Normalize index.html location: vite may output to src/web/index.html
+		// depending on the project's vite.config.ts configuration
+		const clientDir = join(rootDir, '.agentuity/client');
+		const nestedIndexHtml = join(clientDir, 'src/web/index.html');
+		const rootIndexHtml = join(clientDir, 'index.html');
+		if (existsSync(nestedIndexHtml) && !existsSync(rootIndexHtml)) {
+			const { renameSync, mkdirSync: mkdirSyncFs } = await import('node:fs');
+			// Ensure target directory exists
+			mkdirSyncFs(clientDir, { recursive: true });
+			renameSync(nestedIndexHtml, rootIndexHtml);
+			logger.debug('Moved index.html from src/web/ to client root');
+		}
+
 		result.client.included = true;
 		result.client.duration = Date.now() - started;
 		endClientDiagnostic?.();
@@ -245,6 +280,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		const staticResult = await runStaticRender({
 			rootDir,
 			logger,
+			dev,
 		});
 		result.static.included = true;
 		result.static.duration = staticResult.duration;

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

@@ -13,7 +13,7 @@
 import { spawn, type Subprocess } from 'bun';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { existsSync, readFileSync, unlinkSync } from 'node:fs';
+import { appendFileSync, createWriteStream, existsSync, readFileSync, unlinkSync } from 'node:fs';
 import type { APIClient } from '../../api';
 import { getUserAgent } from '../../api';
 import { isUnicode } from '../../tui/symbols';
@@ -34,15 +34,27 @@ 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[];
+	};
 }
 
 /**
- * Stream data to a Pulse stream URL
+ * Stream data to a Pulse stream URL.
+ * Accepts a string, Blob/BunFile, or ReadableStream as the body to avoid
+ * loading large outputs into memory.
  */
 async function streamToPulse(
 	streamURL: string,
 	sdkKey: string,
-	data: string,
+	data: string | Blob | ReadableStream<Uint8Array>,
 	logger: Logger
 ): Promise<void> {
 	try {
@@ -74,7 +86,9 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 	const buildLogsStreamURL = deployment.buildLogsStreamURL;
 	const reportFile = join(tmpdir(), `agentuity-deploy-${deploymentId}.json`);
 	const cleanLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-logs.txt`);
-	let outputBuffer = '';
+	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;
 
@@ -149,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({
@@ -164,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,
@@ -187,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',
@@ -195,7 +210,6 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 
 		const handleOutput = async (stream: ReadableStream<Uint8Array>, isStderr: boolean) => {
 			const reader = stream.getReader();
-			const decoder = new TextDecoder();
 			const target = isStderr ? process.stderr : process.stdout;
 
 			try {
@@ -203,8 +217,9 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 					const { done, value } = await reader.read();
 					if (done) break;
 
-					const text = decoder.decode(value, { stream: true });
-					outputBuffer += text;
+					// Stream raw bytes to disk instead of accumulating in memory.
+					// This prevents OOM / ERR_STRING_TOO_LONG crashes on large builds.
+					rawLogsWriter.write(value);
 					target.write(value);
 				}
 			} catch (err) {
@@ -223,6 +238,11 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 
 		await Promise.all([stdoutPromise, stderrPromise]);
 
+		// Close the raw logs writer so the file is fully flushed before reading
+		await new Promise<void>((resolve) => {
+			rawLogsWriter.end(resolve);
+		});
+
 		const exitCode = await proc.exited;
 		logger.debug('Child process exited with code: %d', exitCode);
 
@@ -238,23 +258,36 @@ 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);
 				}
 			}
-			// Fall back to raw output if no clean logs
-			if (!logsContent && outputBuffer) {
-				logsContent = outputBuffer;
-			}
-			if (logsContent) {
-				await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
+			if (!streamedCleanLogs && existsSync(rawLogsFile)) {
+				// Stream raw logs file directly to Pulse without loading into memory
+				await streamToPulse(buildLogsStreamURL, sdkKey, Bun.file(rawLogsFile), logger);
 			}
 		}
 
@@ -292,26 +325,50 @@ 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 = outputBuffer;
+			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 {
+					appendFileSync(rawLogsFile, `\n\n--- FORK ERROR ---\n${errorMessage}\n`);
+				} catch {
+					// ignore — file may not exist if child never produced output
+				}
+				if (existsSync(rawLogsFile)) {
+					await streamToPulse(buildLogsStreamURL, sdkKey, Bun.file(rawLogsFile), logger);
+				} else {
+					await streamToPulse(
+						buildLogsStreamURL,
+						sdkKey,
+						`--- FORK ERROR ---\n${errorMessage}\n`,
+						logger
+					);
+				}
 			}
-			logsContent += `\n\n--- FORK ERROR ---\n${errorMessage}\n`;
-			await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
 		}
 
 		try {
@@ -360,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]) {
+		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/cloud/sandbox/create.ts

@@ -83,6 +83,12 @@ export const createSubcommand = createCommand({
 				.optional()
 				.describe('Apt packages to install (can be specified multiple times)'),
 			metadata: z.string().optional().describe('JSON object of user-defined metadata'),
+			scope: z
+				.array(z.string())
+				.optional()
+				.describe(
+					'Permission scopes for service access (e.g., kv:read, aigateway, services:write)'
+				),
 			port: z
 				.number()
 				.int()
@@ -195,6 +201,7 @@ export const createSubcommand = createCommand({
 				snapshot: opts.snapshot,
 				dependencies: opts.dependency,
 				metadata,
+				scopes: opts.scope,
 			},
 			orgId,
 		});