@agentuity/cli 0.0.97 → 0.0.99

package/src/cmd/cloud/deploy.ts

@@ -4,6 +4,7 @@ import { createPublicKey } from 'node:crypto';
 import { createReadStream, createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { StructuredError } from '@agentuity/core';
+import { isRunningFromExecutable } from '../upgrade';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { saveProjectDir, getDefaultConfigDir } from '../../config';
@@ -335,33 +336,49 @@ export const deploySubcommand = createSubcommand({
 									);
 								}
 
-								const promises: Promise<Response>[] = [];
-								for (const asset of build.assets) {
-									const assetUrl = instructions.assets[asset.filename];
-									if (!assetUrl) {
-										return stepError(
-											`server did not provide upload URL for asset "${asset.filename}"; upload aborted`
-										);
-									}
+								// Workaround for Bun crash in compiled executables (https://github.com/agentuity/sdk/issues/191)
+								// Use limited concurrency (2 at a time) for executables to avoid parallel fetch crash
+								const isExecutable = isRunningFromExecutable();
+								const concurrency = isExecutable ? 2 : build.assets.length;
 
-									// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
-									const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
-									promises.push(
-										fetch(assetUrl, {
-											method: 'PUT',
-											duplex: 'half',
-											headers: {
-												'Content-Type': asset.contentType,
-											},
-											body: file,
-										})
+								if (isExecutable) {
+									ctx.logger.trace(
+										`Running from executable - using limited concurrency (${concurrency} uploads at a time)`
 									);
 								}
-								ctx.logger.trace('Waiting for asset uploads');
-								const resps = await Promise.all(promises);
-								for (const r of resps) {
-									if (!r.ok) {
-										return stepError(`error uploading asset: ${await r.text()}`);
+
+								// Process assets in batches with limited concurrency
+								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`
+											);
+										}
+
+										// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
+										const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
+										promises.push(
+											fetch(assetUrl, {
+												method: 'PUT',
+												duplex: 'half',
+												headers: {
+													'Content-Type': asset.contentType,
+												},
+												body: file,
+											})
+										);
+									}
+
+									const resps = await Promise.all(promises);
+									for (const r of resps) {
+										if (!r.ok) {
+											return stepError(`error uploading asset: ${await r.text()}`);
+										}
 									}
 								}
 								ctx.logger.trace('Asset uploads complete');

package/src/cmd/dev/file-watcher.ts

@@ -0,0 +1,234 @@
+/**
+ * File Watcher for Dev Server Hot Reload
+ *
+ * Watches source files and triggers server restart on changes.
+ * Handles both backend (API, agents, lib) and generates restart signals.
+ */
+
+import { watch, type FSWatcher } from 'node:fs';
+import { resolve } from 'node:path';
+import type { Logger } from '../../types';
+
+export interface FileWatcherOptions {
+	rootDir: string;
+	logger: Logger;
+	onRestart: () => void;
+	additionalPaths?: string[];
+}
+
+export interface FileWatcherManager {
+	start: () => void;
+	stop: () => void;
+	pause: () => void;
+	resume: () => void;
+}
+
+/**
+ * Create a file watcher manager for hot reload
+ */
+export function createFileWatcher(options: FileWatcherOptions): FileWatcherManager {
+	const { rootDir, logger, onRestart, additionalPaths = [] } = options;
+
+	const watchers: FSWatcher[] = [];
+	let paused = false;
+	let buildCooldownTimer: NodeJS.Timeout | null = null;
+
+	// Watch the entire root directory recursively
+	// This is simpler and more reliable than watching individual paths
+	const watchDirs = [rootDir];
+
+	// Directories to ignore
+	const ignorePaths = [
+		'.agentuity',
+		'node_modules',
+		'.git',
+		'dist',
+		'build',
+		'.next',
+		'.turbo',
+		'src/web', // Vite handles frontend with HMR - no backend restart needed
+	];
+
+	/**
+	 * Check if a path should be ignored
+	 */
+	function shouldIgnorePath(changedFile: string | null, watchDir: string): boolean {
+		if (!changedFile) return false;
+
+		const absPath = resolve(watchDir, changedFile);
+
+		// Check against ignore list - match both relative path and absolute path
+		for (const ignorePath of ignorePaths) {
+			// Check relative path from watchDir
+			if (
+				changedFile === ignorePath ||
+				changedFile.startsWith(`${ignorePath}/`) ||
+				changedFile.startsWith(`${ignorePath}\\`)
+			) {
+				logger.trace('File change ignored (%s): %s', ignorePath, changedFile);
+				return true;
+			}
+
+			// Check if absolute path contains the ignore pattern
+			const ignoreAbsPath = resolve(rootDir, ignorePath);
+			if (
+				absPath === ignoreAbsPath ||
+				absPath.startsWith(`${ignoreAbsPath}/`) ||
+				absPath.startsWith(`${ignoreAbsPath}\\`)
+			) {
+				logger.trace('File change ignored (%s): %s', ignorePath, changedFile);
+				return true;
+			}
+
+			// Also check if changedFile path includes the ignore pattern anywhere
+			// This handles cases like "some/path/.agentuity/file.js"
+			const normalizedChanged = changedFile.replace(/\\/g, '/');
+			const normalizedIgnore = ignorePath.replace(/\\/g, '/');
+			if (
+				normalizedChanged.includes(`/${normalizedIgnore}/`) ||
+				normalizedChanged.includes(`/${normalizedIgnore}`)
+			) {
+				logger.trace('File change ignored (%s in path): %s', ignorePath, changedFile);
+				return true;
+			}
+		}
+
+		// Ignore temp files from editors
+		if (changedFile.match(/\.(tmp|swp|swo|swx)$|~$/)) {
+			logger.trace('File change ignored (temp file): %s', changedFile);
+			return true;
+		}
+
+		// Ignore hidden files (except .env)
+		if (changedFile.startsWith('.') && !changedFile.startsWith('.env')) {
+			logger.trace('File change ignored (hidden file): %s', changedFile);
+			return true;
+		}
+
+		return false;
+	}
+
+	/**
+	 * Handle file change event
+	 */
+	function handleFileChange(eventType: string, changedFile: string | null, watchDir: string) {
+		if (paused) {
+			logger.trace('File change ignored (watcher paused): %s', changedFile);
+			return;
+		}
+
+		if (shouldIgnorePath(changedFile, watchDir)) {
+			return;
+		}
+
+		// During build cooldown, ignore changes (they're likely build outputs)
+		if (buildCooldownTimer) {
+			logger.trace('File change ignored (build cooldown): %s', changedFile);
+			return;
+		}
+
+		logger.debug('File changed (%s): %s', eventType, changedFile || watchDir);
+		onRestart();
+	}
+
+	/**
+	 * Start watching files
+	 */
+	function start() {
+		logger.debug('Starting file watchers for hot reload...');
+
+		// Watch root directory (already absolute path)
+		for (const watchPath of watchDirs) {
+			try {
+				logger.trace('Setting up watcher for: %s', watchPath);
+
+				const watcher = watch(watchPath, { recursive: true }, (eventType, changedFile) => {
+					handleFileChange(eventType, changedFile, watchPath);
+				});
+
+				watchers.push(watcher);
+				logger.trace('Watcher started for: %s', watchPath);
+			} catch (error) {
+				logger.warn('Failed to start watcher for %s: %s', watchPath, error);
+			}
+		}
+
+		// Watch additional paths if provided
+		if (additionalPaths && additionalPaths.length > 0) {
+			for (const additionalPath of additionalPaths) {
+				const fullPath = resolve(rootDir, additionalPath);
+				try {
+					logger.trace('Setting up watcher for additional path: %s', fullPath);
+
+					const watcher = watch(fullPath, { recursive: true }, (eventType, changedFile) => {
+						handleFileChange(eventType, changedFile, fullPath);
+					});
+
+					watchers.push(watcher);
+					logger.trace('Watcher started for additional path: %s', fullPath);
+				} catch (error) {
+					logger.warn('Failed to start watcher for %s: %s', fullPath, error);
+				}
+			}
+		}
+
+		logger.debug('File watchers started (%d paths)', watchers.length);
+	}
+
+	/**
+	 * Stop all watchers
+	 */
+	function stop() {
+		logger.debug('Stopping file watchers...');
+
+		for (const watcher of watchers) {
+			try {
+				watcher.close();
+			} catch (error) {
+				logger.trace('Error closing watcher: %s', error);
+			}
+		}
+
+		watchers.length = 0;
+
+		if (buildCooldownTimer) {
+			clearTimeout(buildCooldownTimer);
+			buildCooldownTimer = null;
+		}
+
+		logger.debug('File watchers stopped');
+	}
+
+	/**
+	 * Temporarily pause watching (e.g., during build)
+	 */
+	function pause() {
+		paused = true;
+		logger.trace('File watchers paused');
+
+		// Set cooldown timer to ignore changes for a bit after build
+		if (buildCooldownTimer) {
+			clearTimeout(buildCooldownTimer);
+		}
+
+		buildCooldownTimer = setTimeout(() => {
+			buildCooldownTimer = null;
+			logger.trace('Build cooldown expired');
+		}, 500); // 500ms cooldown
+	}
+
+	/**
+	 * Resume watching
+	 */
+	function resume() {
+		paused = false;
+		logger.trace('File watchers resumed');
+	}
+
+	return {
+		start,
+		stop,
+		pause,
+		resume,
+	};
+}

package/src/cmd/dev/index.ts

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs';
 import { internalExit } from '@agentuity/runtime';
 import { createCommand } from '../../types';
 import { startBunDevServer } from '../build/vite/bun-dev-server';
+import { startViteAssetServer } from '../build/vite/vite-asset-server';
 import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
 import { generateEndpoint, type DevmodeResponse } from './api';
@@ -13,6 +14,7 @@ import { createDevmodeSyncService } from './sync';
 import { getDevmodeDeploymentId } from '../build/ast';
 import { getDefaultConfigDir, saveConfig } from '../../config';
 import type { Config } from '../../types';
+import { createFileWatcher } from './file-watcher';
 
 const DEFAULT_PORT = 3500;
 const MIN_PORT = 1024;
@@ -220,9 +222,31 @@ export const command = createCommand({
 			centerTitle: false,
 		});
 
-		// Restart loop - allows server to restart on file changes
-		let shouldRestart = false;
+		// Start Vite asset server ONCE before restart loop
+		// Vite handles frontend HMR independently and stays running across backend restarts
+		let vitePort: number;
 		let viteServer: ServerLike | null = null;
+
+		try {
+			logger.debug('Starting Vite asset server...');
+			const viteResult = await startViteAssetServer({
+				rootDir,
+				logger,
+				workbenchPath: workbench.config?.route,
+			});
+			viteServer = viteResult.server;
+			vitePort = viteResult.port;
+			logger.debug(
+				`Vite asset server running on port ${vitePort} (stays running across backend restarts)`
+			);
+		} catch (error) {
+			tui.error(`Failed to start Vite asset server: ${error}`);
+			internalExit(1);
+		}
+
+		// Restart loop - allows BACKEND server to restart on file changes
+		// Vite stays running and handles frontend changes via HMR
+		let shouldRestart = false;
 		let gravityProcess: ProcessLike | null = null;
 
 		const restartServer = () => {
@@ -233,13 +257,23 @@ export const command = createCommand({
 			logger.info('DevMode ready 🚀');
 		};
 
-		// Make restart function available globally for HMR plugin
-		(globalThis as Record<string, unknown>).__AGENTUITY_RESTART__ = restartServer;
+		// Create file watcher for backend hot reload
+		const fileWatcher = createFileWatcher({
+			rootDir,
+			logger,
+			onRestart: restartServer,
+		});
+
+		// Start file watcher (will be paused during builds)
+		fileWatcher.start();
 
 		// Setup signal handlers once before the loop
 		const cleanup = async () => {
 			tui.info('Shutting down...');
 
+			// Stop file watcher
+			fileWatcher.stop();
+
 			// Close Vite asset server first
 			if (viteServer) {
 				await viteServer.close();
@@ -265,13 +299,24 @@ export const command = createCommand({
 		process.on('SIGINT', cleanup);
 		process.on('SIGTERM', cleanup);
 
-		// Ensure gravity client is always killed on exit (even if cleanup is bypassed)
-		// Use SIGKILL for immediate termination since the process is already exiting
+		// Ensure Vite and gravity are always killed on exit (even if cleanup is bypassed)
 		process.on('exit', () => {
+			// Close Vite server synchronously if possible
+			// Note: Vite's close() is async, but we can't await in 'exit' handler
+			// Most Vite implementations handle sync close gracefully
+			if (viteServer) {
+				try {
+					viteServer.close();
+				} catch {
+					// Ignore errors during exit cleanup
+				}
+			}
+
+			// Kill gravity client with SIGKILL for immediate termination
 			if (gravityProcess && gravityProcess.exitCode === null) {
 				try {
 					gravityProcess.kill('SIGKILL');
-				} catch (_err) {
+				} catch {
 					// Ignore errors during exit cleanup
 				}
 			}
@@ -280,6 +325,9 @@ export const command = createCommand({
 		while (true) {
 			shouldRestart = false;
 
+			// Pause file watcher during build to avoid loops
+			fileWatcher.pause();
+
 			try {
 				// Generate entry file for Vite before starting dev server
 				await tui.spinner({
@@ -300,6 +348,9 @@ export const command = createCommand({
 				tui.error(`Failed to generate entry file: ${error}`);
 				tui.warn('Waiting for file changes to retry...');
 
+				// Resume watcher to detect changes for retry
+				fileWatcher.resume();
+
 				// Wait for next restart trigger
 				await new Promise<void>((resolve) => {
 					const checkRestart = setInterval(() => {
@@ -313,17 +364,17 @@ export const command = createCommand({
 			}
 
 			try {
-				// Start Bun dev server (with Vite asset server for HMR)
-				const result = await startBunDevServer({
+				// Start Bun dev server (Vite already running, just start backend)
+				await startBunDevServer({
 					rootDir,
 					port: opts.port,
 					projectId: project?.projectId,
 					orgId: project?.orgId,
 					deploymentId,
 					logger,
+					vitePort, // Pass port of already-running Vite server
 				});
 
-				viteServer = result.viteAssetServer.server;
 				// Note: Bun server runs in-process, no separate app process needed
 
 				// Wait for app.ts to finish loading (Vite is ready but app may still be initializing)
@@ -441,7 +492,7 @@ export const command = createCommand({
 								internalExit(0);
 								break;
 							default:
-								console.log(data);
+								process.stdout.write(data);
 								break;
 						}
 					});
@@ -449,6 +500,9 @@ export const command = createCommand({
 
 				showWelcome();
 
+				// Start/resume file watcher now that server is ready
+				fileWatcher.resume();
+
 				// Wait for restart signal
 				await new Promise<void>((resolve) => {
 					const checkRestart = setInterval(() => {
@@ -459,14 +513,10 @@ export const command = createCommand({
 					}, 100);
 				});
 
-				// Restart triggered - cleanup and loop
-				tui.info('Restarting server...');
-
-				// Close Vite asset server
-				if (viteServer) {
-					await viteServer.close();
-				}
+				// Restart triggered - cleanup and loop (Vite stays running)
+				logger.debug('Restarting backend server...');
 
+				// Kill gravity client (if running)
 				if (gravityProcess) {
 					try {
 						gravityProcess.kill('SIGTERM');
@@ -485,11 +535,7 @@ export const command = createCommand({
 				tui.error(`Error during server operation: ${error}`);
 				tui.warn('Waiting for file changes to retry...');
 
-				// Cleanup on error - close Vite asset server
-				if (viteServer) {
-					await viteServer.close();
-				}
-
+				// Cleanup on error (Vite stays running)
 				if (gravityProcess) {
 					try {
 						gravityProcess.kill('SIGTERM');
@@ -501,7 +547,6 @@ export const command = createCommand({
 						logger.debug('Error killing gravity process on error: %s', err);
 					}
 				}
-				if (viteServer) await viteServer.close();
 
 				// Wait for next restart trigger
 				await new Promise<void>((resolve) => {

package/src/cmd/setup/index.ts

@@ -29,10 +29,14 @@ export const command = createCommand({
 			tui.output(`${tui.muted('To get started, run:')}`);
 			tui.newline();
 			tui.output(
-				`${getCommand('login')}        ${tui.muted('Login to an existing account (or signup)')}`
+				`${tui.colorPrimary(getCommand('login'))}        ${tui.muted('Login to an existing account (or signup)')}`
+			);
+			tui.output(
+				`${tui.colorPrimary(getCommand('create'))}       ${tui.muted('Create a project')}`
+			);
+			tui.output(
+				`${tui.colorPrimary(getCommand('help'))}         ${tui.muted('List commands and options')}`
 			);
-			tui.output(`${getCommand('create')}       ${tui.muted('Create a project')}`);
-			tui.output(`${getCommand('help')}         ${tui.muted('List commands and options')}`);
 		} else {
 			tui.success('Welcome back! 🙌');
 		}

package/src/repl.ts

@@ -236,7 +236,7 @@ async function loadHistory(name: string): Promise<string[]> {
 
 		const content = await Bun.file(historyFile).text();
 		return content.split('\n').filter((line) => line.trim());
-	} catch (_err) {
+	} catch {
 		return [];
 	}
 }
@@ -253,7 +253,7 @@ async function saveHistory(name: string, history: string[]): Promise<void> {
 
 		const historyFile = join(historyDir, `${name}.txt`);
 		await Bun.write(historyFile, history.join('\n'));
-	} catch (_err) {
+	} catch {
 		// Silently fail - history is not critical
 	}
 }

package/src/types.ts

@@ -137,6 +137,12 @@ export interface AgentuityConfig {
 	 * These are added AFTER Agentuity's built-in plugins
 	 */
 	plugins?: Array<import('vite').Plugin>;
+	/**
+	 * Additional define constants for code replacement in Vite builds
+	 * These are merged with Agentuity's default defines
+	 * Note: Cannot override AGENTUITY_PUBLIC_* or process.env.NODE_ENV
+	 */
+	define?: Record<string, string>;
 }
 
 /**