@agentuity/cli 1.0.59 → 1.0.61

package/src/cmd/build/ci.ts

@@ -7,7 +7,7 @@ import { ErrorCode } from '../../errors';
 import * as tui from '../../tui';
 
 export interface CIBuildOptions {
-	url: string;
+	url?: string;
 	directory?: string;
 	trigger?: string;
 	event?: string;
@@ -110,60 +110,72 @@ export async function runCIBuild(opts: CIBuildOptions, _logger: Logger): Promise
 	let pendingExitCode: number | undefined;
 
 	try {
-		tempDir = await mkdtemp(join(tmpdir(), 'agentuity-ci-build-'));
-		const sourceZipPath = join(tempDir, 'source.zip');
-		const extractPath = join(tempDir, 'build');
-
-		tui.info('1️⃣ Downloading source code from GitHub...');
-		await downloadSource(opts.url, sourceZipPath);
-
-		tui.info('2️⃣ Unzipping source code from GitHub...');
-		await mkdir(extractPath, { recursive: true });
-		const unzipExit = await runCommand(
-			['unzip', '-q', sourceZipPath, '-d', extractPath],
-			tempDir
-		);
-		if (unzipExit !== 0 && unzipExit !== 1) {
-			tui.error(`Failed to unzip source archive (exit ${unzipExit})`);
-			pendingExitCode = unzipExit;
-			return;
-		}
-
-		const extractedEntries = await readdir(extractPath, { withFileTypes: true });
-		const extractedDirs = extractedEntries.filter((entry) => entry.isDirectory());
-		if (extractedDirs.length !== 1) {
-			tui.fatal(
-				`Expected one root directory after unzip, found ${extractedDirs.length}`,
-				ErrorCode.BUILD_FAILED
+		let projectDir: string;
+
+		if (opts.url) {
+			// Download and extract source from URL
+			tempDir = await mkdtemp(join(tmpdir(), 'agentuity-ci-build-'));
+			const sourceZipPath = join(tempDir, 'source.zip');
+			const extractPath = join(tempDir, 'build');
+
+			tui.info('1️⃣ Downloading source code from GitHub...');
+			await downloadSource(opts.url, sourceZipPath);
+
+			tui.info('2️⃣ Unzipping source code from GitHub...');
+			await mkdir(extractPath, { recursive: true });
+			const unzipExit = await runCommand(
+				['unzip', '-q', sourceZipPath, '-d', extractPath],
+				tempDir
 			);
-		}
+			if (unzipExit !== 0 && unzipExit !== 1) {
+				tui.error(`Failed to unzip source archive (exit ${unzipExit})`);
+				pendingExitCode = unzipExit;
+				return;
+			}
 
-		const sourceRoot = extractedDirs.at(0);
-		if (!sourceRoot) {
-			tui.fatal('Could not determine extracted source directory', ErrorCode.BUILD_FAILED);
-		}
+			const extractedEntries = await readdir(extractPath, { withFileTypes: true });
+			const extractedDirs = extractedEntries.filter((entry) => entry.isDirectory());
+			if (extractedDirs.length !== 1) {
+				tui.fatal(
+					`Expected one root directory after unzip, found ${extractedDirs.length}`,
+					ErrorCode.BUILD_FAILED
+				);
+			}
 
-		const sourceRootDir = join(extractPath, sourceRoot.name);
-		let projectDir = sourceRootDir;
-		if (opts.directory) {
-			projectDir = join(sourceRootDir, opts.directory);
-		}
+			const sourceRoot = extractedDirs.at(0);
+			if (!sourceRoot) {
+				tui.fatal('Could not determine extracted source directory', ErrorCode.BUILD_FAILED);
+			}
 
-		const projectStats = await stat(projectDir).catch(() => null);
-		if (!projectStats?.isDirectory()) {
-			tui.fatal(`Build directory not found: ${projectDir}`, ErrorCode.CONFIG_INVALID);
-		}
+			const sourceRootDir = join(extractPath, sourceRoot.name);
+			projectDir = sourceRootDir;
+			if (opts.directory) {
+				projectDir = join(sourceRootDir, opts.directory);
+			}
 
-		// Resolve symlinks and verify the project dir is within the source root
-		const realProjectDir = await realpath(projectDir).catch(() => null);
-		const realSourceRoot = await realpath(sourceRootDir).catch(() => null);
-		if (!realProjectDir || !realSourceRoot || !realProjectDir.startsWith(realSourceRoot)) {
-			tui.fatal(
-				'Directory path escapes the source root (path traversal denied)',
-				ErrorCode.CONFIG_INVALID
-			);
+			const projectStats = await stat(projectDir).catch(() => null);
+			if (!projectStats?.isDirectory()) {
+				tui.fatal(`Build directory not found: ${projectDir}`, ErrorCode.CONFIG_INVALID);
+			}
+
+			// Resolve symlinks and verify the project dir is within the source root
+			const realProjectDir = await realpath(projectDir).catch(() => null);
+			const realSourceRoot = await realpath(sourceRootDir).catch(() => null);
+			if (!realProjectDir || !realSourceRoot || !realProjectDir.startsWith(realSourceRoot)) {
+				tui.fatal(
+					'Directory path escapes the source root (path traversal denied)',
+					ErrorCode.CONFIG_INVALID
+				);
+			}
+			projectDir = realProjectDir;
+		} else {
+			// No URL — use current working directory (source already present, e.g. snapshot-based deploy)
+			tui.info('1️⃣ Using local source (no download URL provided)...');
+			projectDir = process.cwd();
+			if (opts.directory) {
+				projectDir = join(projectDir, opts.directory);
+			}
 		}
-		projectDir = realProjectDir;
 
 		const sdkKey = process.env.AGENTUITY_SDK_KEY;
 		if (sdkKey) {

package/src/cmd/build/index.ts

@@ -57,10 +57,6 @@ export const command = createCommand({
 		const { opts, projectDir, project } = ctx;
 
 		if (opts.ci) {
-			if (!opts.url) {
-				tui.fatal('--url is required when using --ci mode', ErrorCode.CONFIG_INVALID);
-			}
-
 			const { runCIBuild } = await import('./ci');
 			await runCIBuild(
 				{

package/src/cmd/build/vite/static-render-worker.ts

@@ -0,0 +1,72 @@
+import { format } from 'node:util';
+import type { Logger } from '../../../types';
+import { runStaticRender } from './static-renderer';
+
+function createWorkerLogger(): Logger {
+	const write = (writer: (...args: unknown[]) => void, args: unknown[]) => {
+		writer(format(...args));
+	};
+	let loggerRef: Logger;
+
+	loggerRef = {
+		trace: (...args: unknown[]) => write(console.debug, args),
+		debug: (...args: unknown[]) => write(console.debug, args),
+		info: (...args: unknown[]) => write(console.log, args),
+		warn: (...args: unknown[]) => write(console.warn, args),
+		error: (...args: unknown[]) => write(console.error, args),
+		child: () => loggerRef,
+		fatal: (...args: unknown[]) => {
+			const message = format(...args);
+			console.error(message);
+			throw new Error(message);
+		},
+	};
+
+	return loggerRef;
+}
+
+export interface StaticRenderWorkerOptions {
+	rootDir: string;
+}
+
+async function main(): Promise<void> {
+	const optionsPath = process.argv[2];
+	if (!optionsPath) {
+		throw new Error('Missing worker options file path argument');
+	}
+
+	const optionsFile = Bun.file(optionsPath);
+	if (!(await optionsFile.exists())) {
+		throw new Error(`Worker options file does not exist: ${optionsPath}`);
+	}
+
+	const options = JSON.parse(await optionsFile.text()) as StaticRenderWorkerOptions;
+	const logger = createWorkerLogger();
+
+	// Load user plugins from agentuity.config.ts (can't serialize plugin functions)
+	const { loadAgentuityConfig } = await import('./config-loader');
+	const config = await loadAgentuityConfig(options.rootDir, logger);
+	const userPlugins = config?.plugins || [];
+
+	const result = await runStaticRender({
+		rootDir: options.rootDir,
+		logger,
+		userPlugins,
+	});
+
+	// Write result to stdout for parent to parse
+	console.log(JSON.stringify(result));
+}
+
+void main()
+	.then(() => {
+		process.exit(0);
+	})
+	.catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`[static-render-worker] ${message}`);
+		if (error instanceof Error && error.stack) {
+			console.error(error.stack);
+		}
+		process.exit(1);
+	});

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

@@ -0,0 +1,58 @@
+import { format } from 'node:util';
+import type { Logger } from '../../../types';
+import { runViteBuild, type ViteBuildWorkerOptions } from './vite-builder';
+
+function createWorkerLogger(): Logger {
+	const write = (writer: (...args: unknown[]) => void, args: unknown[]) => {
+		writer(format(...args));
+	};
+	let loggerRef: Logger;
+
+	loggerRef = {
+		trace: (...args: unknown[]) => write(console.debug, args),
+		debug: (...args: unknown[]) => write(console.debug, args),
+		info: (...args: unknown[]) => write(console.log, args),
+		warn: (...args: unknown[]) => write(console.warn, args),
+		error: (...args: unknown[]) => write(console.error, args),
+		child: () => loggerRef,
+		fatal: (...args: unknown[]) => {
+			const message = format(...args);
+			console.error(message);
+			throw new Error(message);
+		},
+	};
+
+	return loggerRef;
+}
+
+async function main(): Promise<void> {
+	const optionsPath = process.argv[2];
+	if (!optionsPath) {
+		throw new Error('Missing worker options file path argument');
+	}
+
+	const optionsFile = Bun.file(optionsPath);
+	if (!(await optionsFile.exists())) {
+		throw new Error(`Worker options file does not exist: ${optionsPath}`);
+	}
+
+	const options = JSON.parse(await optionsFile.text()) as ViteBuildWorkerOptions;
+
+	await runViteBuild({
+		...options,
+		logger: createWorkerLogger(),
+	});
+}
+
+void main()
+	.then(() => {
+		process.exit(0);
+	})
+	.catch((error) => {
+		const message = error instanceof Error ? error.message : String(error);
+		console.error(`[vite-build-worker] ${message}`);
+		if (error instanceof Error && error.stack) {
+			console.error(error.stack);
+		}
+		process.exit(1);
+	});

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

@@ -6,7 +6,11 @@
 
 import { join } from 'node:path';
 import { existsSync, renameSync, rmSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import { fileURLToPath } from 'node:url';
+import { StructuredError } from '@agentuity/core';
 import type { InlineConfig, Plugin } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
@@ -15,6 +19,8 @@ import { beaconPlugin } from './beacon-plugin';
 import { publicAssetPathPlugin } from './public-asset-path-plugin';
 import type { BuildReportCollector } from '../../../build-report';
 
+const BuildFailedError = StructuredError('BuildFailedError');
+
 /**
  * Vite plugin to flatten the output structure for index.html
  *
@@ -70,6 +76,232 @@ export interface ViteBuildOptions {
 	profile?: string;
 }
 
+export type ViteBuildWorkerOptions = Omit<ViteBuildOptions, 'logger' | 'collector'>;
+
+/**
+ * Drain a subprocess stream, forwarding each chunk to the callback
+ * without accumulating in memory. Only the last `tailBytes` of output
+ * are retained so we can include them in error messages on failure.
+ */
+async function drainSubprocessStream(
+	stream: ReadableStream<Uint8Array>,
+	onChunk: (chunk: string) => void,
+	tailBytes = 4096
+): Promise<string> {
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	// Ring buffer that keeps only the trailing output for error context
+	let tail = '';
+
+	while (true) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		const text = decoder.decode(value, { stream: true });
+		if (!text) continue;
+		onChunk(text);
+		tail = (tail + text).slice(-tailBytes);
+	}
+
+	const finalText = decoder.decode();
+	if (finalText) {
+		onChunk(finalText);
+		tail = (tail + finalText).slice(-tailBytes);
+	}
+
+	return tail;
+}
+
+/**
+ * Detect actually available memory for subprocess heap sizing.
+ * Reads cgroup v2/v1 max and current usage to compute free memory.
+ * Falls back to os.freemem() if cgroup files aren't available.
+ */
+async function detectAvailableMemory(
+	logger: Logger,
+	label: string
+): Promise<Record<string, string>> {
+	let cgroupMaxBytes = 0;
+	let cgroupCurrentBytes = 0;
+	let availableBytes = 0;
+	try {
+		if (process.platform === 'linux') {
+			// Try cgroup v2
+			const cgroupMax = Bun.file('/sys/fs/cgroup/memory.max');
+			const cgroupCurrent = Bun.file('/sys/fs/cgroup/memory.current');
+			if ((await cgroupMax.exists()) && (await cgroupCurrent.exists())) {
+				const maxStr = (await cgroupMax.text()).trim();
+				const currentStr = (await cgroupCurrent.text()).trim();
+				// "max" means unlimited — use total system memory
+				if (maxStr === 'max') {
+					const { totalmem } = await import('node:os');
+					cgroupMaxBytes = totalmem();
+				} else if (/^\d+$/.test(maxStr)) {
+					cgroupMaxBytes = Number(maxStr);
+				}
+				if (/^\d+$/.test(currentStr)) {
+					cgroupCurrentBytes = Number(currentStr);
+				}
+				if (cgroupMaxBytes > 0) {
+					availableBytes =
+						cgroupCurrentBytes > 0 ? cgroupMaxBytes - cgroupCurrentBytes : cgroupMaxBytes;
+				}
+			}
+			// Fallback to cgroup v1
+			if (!availableBytes) {
+				const v1Limit = Bun.file('/sys/fs/cgroup/memory/memory.limit_in_bytes');
+				const v1Usage = Bun.file('/sys/fs/cgroup/memory/memory.usage_in_bytes');
+				if ((await v1Limit.exists()) && (await v1Usage.exists())) {
+					const limitStr = (await v1Limit.text()).trim();
+					const usageStr = (await v1Usage.text()).trim();
+					if (/^\d+$/.test(limitStr) && /^\d+$/.test(usageStr)) {
+						cgroupMaxBytes = Number(limitStr);
+						cgroupCurrentBytes = Number(usageStr);
+						availableBytes = cgroupMaxBytes - cgroupCurrentBytes;
+					}
+				}
+			}
+		}
+		if (!availableBytes) {
+			const { freemem } = await import('node:os');
+			availableBytes = freemem();
+		}
+	} catch {
+		// If detection fails, let JSC use its own defaults
+	}
+
+	const jscEnv: Record<string, string> = {};
+	if (availableBytes > 0) {
+		const maxMb = Math.round(cgroupMaxBytes / 1024 / 1024);
+		const usedMb = Math.round(cgroupCurrentBytes / 1024 / 1024);
+		const availMb = Math.round(availableBytes / 1024 / 1024);
+		const maxHeap = Math.round(availableBytes * 0.8);
+		const maxHeapMb = Math.round(maxHeap / 1024 / 1024);
+		jscEnv.BUN_JSC_forceRAMSize = String(availableBytes);
+		jscEnv.BUN_JSC_gcMaxHeapSize = String(maxHeap);
+		logger.debug(
+			`[${label}] Memory: cgroup max=${maxMb} MiB, used=${usedMb} MiB, available=${availMb} MiB, gcMaxHeapSize=${maxHeapMb} MiB`
+		);
+	} else {
+		logger.debug(`[${label}] Could not detect available memory, using JSC defaults`);
+	}
+	return jscEnv;
+}
+
+function resolveWorkerScript(name: string): string {
+	const tsPath = fileURLToPath(new URL(`./${name}.ts`, import.meta.url));
+	const jsPath = fileURLToPath(new URL(`./${name}.js`, import.meta.url));
+	return existsSync(tsPath) ? tsPath : jsPath;
+}
+
+/**
+ * Spawn an isolated worker subprocess with JSC memory tuning.
+ * Returns the captured stdout tail (for parsing results) and throws on failure.
+ */
+async function spawnIsolatedWorker(opts: {
+	workerName: string;
+	label: string;
+	optionsJson: unknown;
+	cwd: string;
+	logger: Logger;
+}): Promise<string> {
+	const { workerName, label, optionsJson, cwd, logger } = opts;
+	const workerScript = resolveWorkerScript(workerName);
+	const optionsPath = join(tmpdir(), `agentuity-${label}-${randomUUID()}.json`);
+
+	try {
+		await Bun.write(optionsPath, JSON.stringify(optionsJson));
+		const jscEnv = await detectAvailableMemory(logger, label);
+
+		const proc = Bun.spawn({
+			cmd: [process.execPath, workerScript, optionsPath],
+			cwd,
+			env: { ...process.env, ...jscEnv },
+			stdin: 'ignore',
+			stdout: 'pipe',
+			stderr: 'pipe',
+		});
+
+		const stdoutPromise =
+			proc.stdout && typeof proc.stdout !== 'number'
+				? drainSubprocessStream(proc.stdout, (chunk) => {
+						const text = chunk.trim();
+						if (text) logger.debug(`[${label}] ${text}`);
+					})
+				: Promise.resolve('');
+
+		const stderrPromise =
+			proc.stderr && typeof proc.stderr !== 'number'
+				? drainSubprocessStream(proc.stderr, (chunk) => {
+						const text = chunk.trim();
+						if (text) logger.error(`[${label}] ${text}`);
+					})
+				: Promise.resolve('');
+
+		const [stdout, stderr, exitCode] = await Promise.all([
+			stdoutPromise,
+			stderrPromise,
+			proc.exited,
+		]);
+
+		if (exitCode !== 0) {
+			const errorOutput = stderr.trim() || stdout.trim();
+			const suffix = errorOutput ? `: ${errorOutput}` : '';
+			throw new BuildFailedError({
+				message: `${label} failed with exit code ${exitCode}${suffix}`,
+			});
+		}
+		return stdout;
+	} catch (error) {
+		if (error instanceof Error && error.name === 'BuildFailedError') throw error;
+		throw new BuildFailedError({
+			message: `Failed to run ${label}: ${error instanceof Error ? error.message : String(error)}`,
+		});
+	} finally {
+		rmSync(optionsPath, { force: true });
+	}
+}
+
+async function runViteBuildInSubprocess(
+	options: ViteBuildWorkerOptions,
+	logger: Logger
+): Promise<void> {
+	await spawnIsolatedWorker({
+		workerName: 'vite-build-worker',
+		label: `vite-build-worker:${options.mode}`,
+		optionsJson: options,
+		cwd: options.rootDir,
+		logger,
+	});
+}
+
+async function runStaticRenderInSubprocess(
+	rootDir: string,
+	logger: Logger
+): Promise<{ routes: number; duration: number }> {
+	const stdout = await spawnIsolatedWorker({
+		workerName: 'static-render-worker',
+		label: 'static-render-worker',
+		optionsJson: { rootDir },
+		cwd: rootDir,
+		logger,
+	});
+
+	// Worker writes JSON result as last line of stdout
+	try {
+		// Find the last JSON line in the tail
+		const lines = stdout.split('\n').filter((l) => l.trim());
+		for (let i = lines.length - 1; i >= 0; i--) {
+			const line = lines[i]!.trim();
+			if (line.startsWith('{')) {
+				return JSON.parse(line);
+			}
+		}
+	} catch {
+		// Parse failure — return defaults
+	}
+	return { routes: 0, duration: 0 };
+}
+
 /**
  * Run a Vite build for the specified mode
  * Uses inline Vite config (customizable via agentuity.config.ts)
@@ -256,6 +488,9 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 				// Copy public files to output for CDN upload (production builds only)
 				// In dev mode, Vite serves them directly from src/web/public/
 				copyPublicDir: !dev,
+				// Skip compressed size reporting to save memory — we measure
+				// sizes during the asset upload phase instead.
+				reportCompressedSize: false,
 			},
 			logLevel: isViteDebug ? 'info' : 'warn',
 		};
@@ -322,6 +557,7 @@ interface BuildResult {
  */
 export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Promise<BuildResult> {
 	const { rootDir, projectId = '', dev = false, logger, collector } = options;
+	const { logger: _logger, collector: _collector, ...workerBaseOptions } = options;
 
 	if (!dev) {
 		rmSync(join(rootDir, '.agentuity'), { force: true, recursive: true });
@@ -393,13 +629,26 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Building client assets...');
 		const endClientDiagnostic = collector?.startDiagnostic('client-build');
 		const started = Date.now();
-		await runViteBuild({
-			...options,
-			mode: 'client',
-			workbenchEnabled: workbenchConfig.enabled,
-			workbenchRoute: workbenchConfig.route,
-			analyticsEnabled,
-		});
+		if (dev) {
+			await runViteBuild({
+				...options,
+				mode: 'client',
+				workbenchEnabled: workbenchConfig.enabled,
+				workbenchRoute: workbenchConfig.route,
+				analyticsEnabled,
+			});
+		} else {
+			await runViteBuildInSubprocess(
+				{
+					...workerBaseOptions,
+					mode: 'client',
+					workbenchEnabled: workbenchConfig.enabled,
+					workbenchRoute: workbenchConfig.route,
+					analyticsEnabled,
+				},
+				logger
+			);
+		}
 		result.client.included = true;
 		result.client.duration = Date.now() - started;
 		endClientDiagnostic?.();
@@ -411,15 +660,22 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	if (config?.render === 'static' && hasWebFrontend) {
 		logger.debug('Running static rendering (pre-rendering all routes)...');
 		const endStaticDiagnostic = collector?.startDiagnostic('static-render');
-		const { runStaticRender } = await import('./static-renderer');
-		const staticResult = await runStaticRender({
-			rootDir,
-			logger,
-			userPlugins: config?.plugins || [],
-		});
-		result.static.included = true;
-		result.static.duration = staticResult.duration;
-		result.static.routes = staticResult.routes;
+		if (dev) {
+			const { runStaticRender } = await import('./static-renderer');
+			const staticResult = await runStaticRender({
+				rootDir,
+				logger,
+				userPlugins: config?.plugins || [],
+			});
+			result.static.included = true;
+			result.static.duration = staticResult.duration;
+			result.static.routes = staticResult.routes;
+		} else {
+			const staticResult = await runStaticRenderInSubprocess(rootDir, logger);
+			result.static.included = true;
+			result.static.duration = staticResult.duration;
+			result.static.routes = staticResult.routes;
+		}
 		endStaticDiagnostic?.();
 	}
 
@@ -428,12 +684,24 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Building workbench assets...');
 		const endWorkbenchDiagnostic = collector?.startDiagnostic('workbench-build');
 		const started = Date.now();
-		await runViteBuild({
-			...options,
-			mode: 'workbench',
-			workbenchRoute: workbenchConfig.route,
-			workbenchEnabled: true,
-		});
+		if (dev) {
+			await runViteBuild({
+				...options,
+				mode: 'workbench',
+				workbenchRoute: workbenchConfig.route,
+				workbenchEnabled: true,
+			});
+		} else {
+			await runViteBuildInSubprocess(
+				{
+					...workerBaseOptions,
+					mode: 'workbench',
+					workbenchRoute: workbenchConfig.route,
+					workbenchEnabled: true,
+				},
+				logger
+			);
+		}
 		result.workbench.included = true;
 		result.workbench.duration = Date.now() - started;
 		endWorkbenchDiagnostic?.();
@@ -443,7 +711,11 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	logger.debug('Building server...');
 	const endServerDiagnostic = collector?.startDiagnostic('server-build');
 	const serverStarted = Date.now();
-	await runViteBuild({ ...options, mode: 'server' });
+	if (dev) {
+		await runViteBuild({ ...options, mode: 'server' });
+	} else {
+		await runViteBuildInSubprocess({ ...workerBaseOptions, mode: 'server' }, logger);
+	}
 	result.server.included = true;
 	result.server.duration = Date.now() - serverStarted;
 	endServerDiagnostic?.();