@agentuity/cli 0.0.22 → 0.0.24

package/dist/cmd/dev/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmd/dev/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,OAAO,mCAgKlB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/cmd/dev/index.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,OAAO,mCA8TlB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "0.0.22",
+	"version": "0.0.24",
 	"type": "module",
 	"main": "./src/index.ts",
 	"types": "./dist/index.d.ts",

package/src/cmd/dev/index.ts

@@ -41,13 +41,18 @@ export const command = createCommand({
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
-		const watches = [appTs, srcDir];
+		// Watch directories instead of files to survive atomic replacements (sed -i, cp)
+		const watches = [rootDir];
 		const watchers: FSWatcher[] = [];
 		let failures = 0;
 		let running = false;
 		let pid = 0;
 		let failed = false;
 		let devServer: Bun.Subprocess | undefined;
+		let exitPromise: Promise<number> | undefined;
+		let restarting = false;
+		let shuttingDownForRestart = false;
+		let pendingRestart = false;
 
 		function failure(msg: string) {
 			failed = true;
@@ -60,23 +65,42 @@ export const command = createCommand({
 			}
 		}
 
-		const kill = () => {
+		const kill = async () => {
+			if (!running || !devServer) {
+				logger.trace('kill() called but server not running');
+				return;
+			}
+
+			logger.trace('Killing dev server (pid: %d)', pid);
+			shuttingDownForRestart = true;
 			running = false;
 			try {
 				// Kill the process group (negative PID kills entire group)
 				process.kill(-pid, 'SIGTERM');
+				logger.trace('Sent SIGTERM to process group');
 			} catch {
 				// Fallback: kill the direct process
 				try {
 					if (devServer) {
 						devServer.kill();
+						logger.trace('Killed dev server process directly');
 					}
 				} catch {
 					// Ignore if already dead
+					logger.trace('Process already dead');
 				}
-			} finally {
-				devServer = undefined;
 			}
+
+			// Wait for the server to actually exit
+			if (exitPromise) {
+				logger.trace('Waiting for dev server to exit...');
+				await exitPromise;
+				logger.trace('Dev server exited');
+			}
+
+			devServer = undefined;
+			exitPromise = undefined;
+			shuttingDownForRestart = false;
 		};
 
 		// Handle signals to ensure entire process tree is killed
@@ -95,11 +119,26 @@ export const command = createCommand({
 		process.on('SIGTERM', cleanup);
 
 		async function restart() {
+			// Queue restart if already restarting
+			if (restarting) {
+				logger.trace('Restart already in progress, queuing another restart');
+				pendingRestart = true;
+				return;
+			}
+
+			logger.trace('restart() called, restarting=%s, running=%s', restarting, running);
+			restarting = true;
+			pendingRestart = false;
+			failed = false;
 			try {
 				if (running) {
+					logger.trace('Server is running, killing before restart');
 					tui.info('Restarting on file change');
-					kill();
-					return;
+					await kill();
+					logger.trace('Server killed, continuing with restart');
+					// Continue with restart after kill completes
+				} else {
+					logger.trace('Initial server start');
 				}
 				await Promise.all([
 					tui.runCommand({
@@ -108,7 +147,7 @@ export const command = createCommand({
 						cwd: rootDir,
 						clearOnSuccess: true,
 						truncate: false,
-						maxLinesOutput: 1,
+						maxLinesOutput: 2,
 						maxLinesOnFailure: 15,
 					}),
 					tui.spinner('Building project', async () => {
@@ -132,9 +171,10 @@ export const command = createCommand({
 					return;
 				}
 
+				logger.trace('Starting dev server: %s', appPath);
 				// Use shell to run in a process group for proper cleanup
 				// The 'exec' ensures the shell is replaced by the actual process
-				const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
+				devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
 					cwd: rootDir,
 					stdout: 'inherit',
 					stderr: 'inherit',
@@ -144,25 +184,143 @@ export const command = createCommand({
 				running = true;
 				failed = false;
 				pid = devServer.pid;
+				exitPromise = devServer.exited;
+				logger.trace('Dev server started (pid: %d)', pid);
 
-				const exitCode = await devServer.exited;
-				if (exitCode === 0) {
-					process.exit(exitCode);
-				}
+				// Attach non-blocking exit handler
+				exitPromise
+					.then((exitCode) => {
+						logger.trace(
+							'Dev server exited with code %d (shuttingDownForRestart=%s)',
+							exitCode,
+							shuttingDownForRestart
+						);
+						running = false;
+						devServer = undefined;
+						exitPromise = undefined;
+						// Only exit the CLI if this is a clean exit AND not a restart
+						if (exitCode === 0 && !shuttingDownForRestart) {
+							logger.trace('Clean exit, stopping CLI');
+							process.exit(exitCode);
+						}
+						// Non-zero exit codes are treated as restartable failures
+					})
+					.catch((error) => {
+						logger.trace(
+							'Dev server exit error (shuttingDownForRestart=%s): %s',
+							shuttingDownForRestart,
+							error
+						);
+						running = false;
+						devServer = undefined;
+						exitPromise = undefined;
+						if (!shuttingDownForRestart) {
+							if (error instanceof Error) {
+								failure(`Dev server failed: ${error.message}`);
+							} else {
+								failure('Dev server failed');
+							}
+						}
+					});
 			} catch (error) {
 				if (error instanceof Error) {
 					failure(`Dev server failed: ${error.message}`);
 				} else {
 					failure('Dev server failed');
 				}
-			} finally {
 				running = false;
+				devServer = undefined;
+			} finally {
+				const hadPendingRestart = pendingRestart;
+				restarting = false;
+				pendingRestart = false;
+				logger.trace(
+					'restart() completed, restarting=%s, hadPendingRestart=%s',
+					restarting,
+					hadPendingRestart
+				);
+
+				// If another restart was queued while we were restarting, trigger it now
+				if (hadPendingRestart) {
+					logger.trace('Triggering queued restart');
+					setImmediate(restart);
+				}
 			}
 		}
+
+		logger.trace('Starting initial build and server');
 		await restart();
-		for (const filename of watches) {
-			logger.trace('watching %s', filename);
-			watchers.push(watch(filename, { recursive: true }, restart));
+		logger.trace('Initial restart completed, setting up watchers');
+
+		// Patterns to ignore (generated files that change during build)
+		const ignorePatterns = [
+			/\.generated\.(js|ts|d\.ts)$/,
+			/registry\.generated\.ts$/,
+			/types\.generated\.d\.ts$/,
+			/client\.generated\.js$/,
+		];
+
+		logger.trace('Setting up file watchers for: %s', watches.join(', '));
+		for (const watchDir of watches) {
+			try {
+				logger.trace('Setting up watcher for %s', watchDir);
+				const watcher = watch(watchDir, { recursive: true }, (eventType, changedFile) => {
+					const absPath = changedFile ? join(watchDir, changedFile) : watchDir;
+
+					// Ignore node_modules folder
+					if (absPath.includes('node_modules')) {
+						logger.trace(
+							'File change ignored (node_modules): %s (event: %s, file: %s)',
+							watchDir,
+							eventType,
+							changedFile
+						);
+						return;
+					}
+
+					// Ignore changes in .agentuity directory (build output)
+					if (absPath.startsWith(agentuityDir)) {
+						logger.trace(
+							'File change ignored (.agentuity dir): %s (event: %s, file: %s)',
+							watchDir,
+							eventType,
+							changedFile
+						);
+						return;
+					}
+
+					// Ignore generated files to prevent restart loops
+					if (changedFile) {
+						for (const pattern of ignorePatterns) {
+							if (pattern.test(changedFile)) {
+								logger.trace(
+									'File change ignored (generated file): %s (event: %s, file: %s)',
+									watchDir,
+									eventType,
+									changedFile
+								);
+								return;
+							}
+						}
+					}
+
+					logger.trace(
+						'File change detected: %s (event: %s, file: %s)',
+						absPath,
+						eventType,
+						changedFile
+					);
+					restart();
+				});
+				watchers.push(watcher);
+				logger.trace('✓ Watcher added for %s', watchDir);
+			} catch (error) {
+				logger.error('Failed to setup watcher for %s: %s', watchDir, error);
+			}
 		}
+		logger.debug('Dev server watching for changes');
+
+		// Keep the handler alive indefinitely
+		await new Promise(() => {});
 	},
 });

package/src/tui.ts

@@ -890,7 +890,7 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 					for (const line of lines) {
 						if (line.trim()) {
 							allOutputLines.push(line);
-							renderOutput(3); // Show last 3 lines while streaming
+							renderOutput(maxLinesOutput); // Show last N lines while streaming
 						}
 					}
 				}