@agentuity/cli 0.0.101 → 0.0.103

package/src/cmd/dev/index.ts

@@ -15,6 +15,7 @@ import { getDevmodeDeploymentId } from '../build/ast';
 import { getDefaultConfigDir, saveConfig } from '../../config';
 import type { Config } from '../../types';
 import { createFileWatcher } from './file-watcher';
+import { regenerateSkillsAsync } from './skills';
 
 const DEFAULT_PORT = 3500;
 const MIN_PORT = 1024;
@@ -32,6 +33,81 @@ interface ServerLike {
 	close: () => void;
 }
 
+interface BunServer {
+	stop: (closeActiveConnections?: boolean) => void;
+	port: number;
+}
+
+/**
+ * Kill any lingering gravity processes from previous dev sessions.
+ * This is a defensive measure to clean up orphaned processes.
+ */
+async function killLingeringGravityProcesses(logger: {
+	debug: (msg: string, ...args: unknown[]) => void;
+}): Promise<void> {
+	// Only attempt on Unix-like systems (macOS, Linux)
+	if (process.platform === 'win32') {
+		return;
+	}
+
+	try {
+		// Use pkill to kill gravity processes owned by current user
+		// The -f flag matches against full command line
+		// We specifically match the gravity binary name to avoid killing unrelated processes
+		const result = Bun.spawnSync(['pkill', '-f', 'gravity.*--endpoint-id'], {
+			stdout: 'ignore',
+			stderr: 'ignore',
+		});
+
+		// Exit code 0 = processes killed, 1 = no matching processes, other = error
+		if (result.exitCode === 0) {
+			logger.debug('Killed lingering gravity processes from previous session');
+			// Brief pause to let processes fully terminate
+			await new Promise((resolve) => setTimeout(resolve, 100));
+		}
+	} catch {
+		// pkill not available or failed - not critical, continue
+	}
+}
+
+/**
+ * Stop the existing Bun server if one is running.
+ * Waits for the port to become available before returning.
+ */
+async function stopBunServer(
+	port: number,
+	logger: { debug: (msg: string, ...args: unknown[]) => void }
+): Promise<void> {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const globalAny = globalThis as any;
+	const server = globalAny.__AGENTUITY_SERVER__ as BunServer | undefined;
+	if (!server) return;
+
+	try {
+		logger.debug('Stopping previous Bun server...');
+		server.stop(true); // Close active connections immediately
+	} catch (err) {
+		logger.debug('Error stopping previous Bun server: %s', err);
+	}
+
+	// Wait for socket to close to avoid EADDRINUSE races
+	for (let i = 0; i < 20; i++) {
+		try {
+			await fetch(`http://127.0.0.1:${port}/`, {
+				method: 'HEAD',
+				signal: AbortSignal.timeout(200),
+			});
+			// Still responding, wait a bit more
+			await new Promise((r) => setTimeout(r, 50));
+		} catch {
+			// Connection refused or timeout => server is down
+			break;
+		}
+	}
+
+	globalAny.__AGENTUITY_SERVER__ = undefined;
+}
+
 const getDefaultPort = (): number => {
 	const envPort = process.env.PORT;
 	if (!envPort) {
@@ -120,6 +196,10 @@ export const command = createCommand({
 			originalExit(1);
 		}
 
+		// Kill any lingering gravity processes from previous dev sessions
+		// This prevents "zombie" gravity clients from blocking the public URL
+		await killLingeringGravityProcesses(logger);
+
 		// Setup devmode and gravity (if using public URL)
 		const useMockService = process.env.DEVMODE_SYNC_SERVICE_MOCK === 'true';
 		const apiClient = auth ? new APIClient(getAPIBaseURL(config), logger, config) : null;
@@ -132,7 +212,9 @@ export const command = createCommand({
 			: null;
 
 		// Track previous metadata for sync diffing
-		let previousMetadata: Awaited<ReturnType<typeof import('../build/vite/metadata-generator').generateMetadata>> | undefined;
+		let previousMetadata:
+			| Awaited<ReturnType<typeof import('../build/vite/metadata-generator').generateMetadata>>
+			| undefined;
 
 		let devmode: DevmodeResponse | undefined;
 		let gravityBin: string | undefined;
@@ -234,6 +316,12 @@ export const command = createCommand({
 			centerTitle: false,
 		});
 
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		const cliVersion = ((global as any).__CLI_SCHEMA__?.version as string) ?? '';
+		if (cliVersion) {
+			regenerateSkillsAsync(rootDir, cliVersion, logger).catch(() => {});
+		}
+
 		// Start Vite asset server ONCE before restart loop
 		// Vite handles frontend HMR independently and stays running across backend restarts
 		let viteServer: ServerLike | null = null;
@@ -281,16 +369,38 @@ export const command = createCommand({
 		// Start file watcher (will be paused during builds)
 		fileWatcher.start();
 
-		// Setup signal handlers once before the loop
-		const cleanup = async () => {
-			tui.info('Shutting down...');
+		// Track if cleanup is in progress to avoid duplicate cleanup
+		let cleaningUp = false;
+		// Track if shutdown was requested (SIGINT/SIGTERM) to break the main loop
+		let shutdownRequested = false;
+
+		/**
+		 * Centralized cleanup function for all resources.
+		 * Called on restart, shutdown, and fatal errors.
+		 * @param exitAfter - If true, exit the process after cleanup
+		 * @param exitCode - Exit code to use if exitAfter is true
+		 * @param silent - If true, don't show "Shutting down" message
+		 */
+		const cleanup = async (exitAfter = false, exitCode = 0, silent = false) => {
+			if (cleaningUp) return;
+			cleaningUp = true;
+
+			if (!silent) {
+				tui.info('Shutting down...');
+			}
 
-			// Stop file watcher
-			fileWatcher.stop();
+			// Stop file watcher first to prevent restart triggers during cleanup
+			try {
+				fileWatcher.stop();
+			} catch (err) {
+				logger.debug('Error stopping file watcher: %s', err);
+			}
 
-			// Close Vite asset server first
-			if (viteServer) {
-				await viteServer.close();
+			// Stop Bun server
+			try {
+				await stopBunServer(opts.port, logger);
+			} catch (err) {
+				logger.debug('Error stopping Bun server during cleanup: %s', err);
 			}
 
 			// Kill gravity client with SIGTERM first, then SIGKILL as fallback
@@ -298,37 +408,115 @@ export const command = createCommand({
 				try {
 					gravityProcess.kill('SIGTERM');
 					// Give it a moment to gracefully shutdown
-					await new Promise((resolve) => setTimeout(resolve, 100));
+					await new Promise((resolve) => setTimeout(resolve, 150));
 					if (gravityProcess.exitCode === null) {
 						gravityProcess.kill('SIGKILL');
 					}
 				} catch (err) {
 					logger.debug('Error killing gravity process: %s', err);
+				} finally {
+					gravityProcess = null;
 				}
 			}
 
-			originalExit(0);
+			// Close Vite asset server last (it handles frontend, should stay up longest)
+			if (viteServer) {
+				try {
+					await viteServer.close();
+				} catch (err) {
+					logger.debug('Error closing Vite server: %s', err);
+				} finally {
+					viteServer = null;
+				}
+			}
+
+			// Reset cleanup flag if not exiting (allows restart)
+			if (!exitAfter) {
+				cleaningUp = false;
+			} else {
+				originalExit(exitCode);
+			}
+		};
+
+		/**
+		 * Cleanup for restart: stops Bun server and Gravity, keeps Vite running
+		 */
+		const cleanupForRestart = async () => {
+			logger.debug('Cleaning up for restart...');
+
+			// Stop Bun server
+			try {
+				await stopBunServer(opts.port, logger);
+			} catch (err) {
+				logger.debug('Error stopping Bun server for restart: %s', err);
+			}
+
+			// Kill gravity client
+			if (gravityProcess) {
+				try {
+					gravityProcess.kill('SIGTERM');
+					await new Promise((resolve) => setTimeout(resolve, 150));
+					if (gravityProcess.exitCode === null) {
+						gravityProcess.kill('SIGKILL');
+					}
+				} catch (err) {
+					logger.debug('Error killing gravity process for restart: %s', err);
+				} finally {
+					gravityProcess = null;
+				}
+			}
 		};
 
 		// SIGINT/SIGTERM: coordinate shutdown between bundle and dev resources
-		let devShutdownHandled = false;
-		process.on('SIGINT', async () => {
-			if (devShutdownHandled) return;
-			devShutdownHandled = true;
-			// The bundle handles its own shutdown, we clean up dev resources
-			await cleanup();
-		});
-		process.on('SIGTERM', async () => {
-			if (devShutdownHandled) return;
-			devShutdownHandled = true;
-			await cleanup();
-		});
+		let signalHandlersRegistered = false;
+		if (!signalHandlersRegistered) {
+			signalHandlersRegistered = true;
 
-		// Ensure Vite and gravity are always killed on exit (even if cleanup is bypassed)
+			const safeExit = async (code: number, reason?: string) => {
+				if (reason) {
+					logger.debug('DevMode terminating (%d) due to: %s', code, reason);
+				}
+				shutdownRequested = true;
+				await cleanup(true, code);
+			};
+
+			process.on('SIGINT', () => {
+				void safeExit(0, 'SIGINT');
+			});
+
+			process.on('SIGTERM', () => {
+				void safeExit(0, 'SIGTERM');
+			});
+
+			// Handle uncaught exceptions - clean up and exit rather than limping on
+			process.on('uncaughtException', (err) => {
+				tui.error(
+					`Uncaught exception: ${err instanceof Error ? (err.stack ?? err.message) : String(err)}`
+				);
+				void safeExit(1, 'uncaughtException');
+			});
+
+			// Handle unhandled rejections - log but don't exit (usually recoverable)
+			process.on('unhandledRejection', (reason) => {
+				logger.warn(
+					'Unhandled promise rejection: %s',
+					reason instanceof Error ? (reason.stack ?? reason.message) : String(reason)
+				);
+			});
+		}
+
+		// Ensure resources are always cleaned up on exit (synchronous fallback)
 		process.on('exit', () => {
+			// Kill gravity client with SIGKILL for immediate termination
+			if (gravityProcess && gravityProcess.exitCode === null) {
+				try {
+					gravityProcess.kill('SIGKILL');
+				} catch {
+					// Ignore errors during exit cleanup
+				}
+			}
+
 			// 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();
@@ -337,17 +525,19 @@ export const command = createCommand({
 				}
 			}
 
-			// Kill gravity client with SIGKILL for immediate termination
-			if (gravityProcess && gravityProcess.exitCode === null) {
+			// Stop Bun server synchronously (best effort)
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const server = (globalThis as any).__AGENTUITY_SERVER__;
+			if (server?.stop) {
 				try {
-					gravityProcess.kill('SIGKILL');
+					server.stop(true);
 				} catch {
 					// Ignore errors during exit cleanup
 				}
 			}
 		});
 
-		while (true) {
+		while (!shutdownRequested) {
 			shouldRestart = false;
 
 			// Pause file watcher during build to avoid loops
@@ -358,67 +548,99 @@ export const command = createCommand({
 				await tui.spinner({
 					message: 'Building dev bundle',
 					callback: async () => {
-					const { generateEntryFile } = await import('../build/entry-generator');
-					await generateEntryFile({
-						rootDir,
-						projectId: project?.projectId ?? '',
-						deploymentId,
-						logger,
-						mode: 'dev',
-					});
-
-					// Bundle the app with LLM patches (dev mode = no minification)
-					const { installExternalsAndBuild } = await import('../build/vite/server-bundler');
-					await installExternalsAndBuild({
-						rootDir,
-						dev: true, // DevMode: no minification, inline sourcemaps
-						logger,
-					});
-
-					// Generate metadata file (needed for eval ID lookup at runtime)
-					const { discoverAgents } = await import('../build/vite/agent-discovery');
-					const { discoverRoutes } = await import('../build/vite/route-discovery');
-					const { generateMetadata, writeMetadataFile } = await import(
-						'../build/vite/metadata-generator'
-					);
+						// Step 1: Generate workbench files if enabled (must be done before entry generation)
+						if (workbenchConfigData.enabled) {
+							logger.debug('Workbench enabled, generating source files before bundle...');
+							const { generateWorkbenchFiles } = await import(
+								'../build/vite/workbench-generator'
+							);
+							await generateWorkbenchFiles(
+								rootDir,
+								project?.projectId ?? '',
+								workbenchConfigData,
+								logger
+							);
+						}
 
-					const srcDir = join(rootDir, 'src');
-					const agents = await discoverAgents(
-						srcDir,
-						project?.projectId ?? '',
-						deploymentId,
-						logger
-					);
-					const { routes } = await discoverRoutes(
-						srcDir,
-						project?.projectId ?? '',
-						deploymentId,
-						logger
-					);
+						// Step 2: Generate entry file with workbench config
+						// Note: vitePort is NOT passed here - the app reads process.env.VITE_PORT at runtime
+						const { generateEntryFile } = await import('../build/entry-generator');
+						await generateEntryFile({
+							rootDir,
+							projectId: project?.projectId ?? '',
+							deploymentId,
+							logger,
+							mode: 'dev',
+							workbench: workbenchConfigData.enabled ? workbenchConfigData : undefined,
+						});
+
+						// Step 3: Bundle the app with LLM patches (dev mode = no minification)
+						// This produces .agentuity/app.js with AI Gateway routing patches applied
+						const { installExternalsAndBuild } = await import('../build/vite/server-bundler');
+						await installExternalsAndBuild({
+							rootDir,
+							dev: true, // DevMode: no minification, inline sourcemaps
+							logger,
+						});
+
+						// Generate metadata file (needed for eval ID lookup at runtime)
+						const { discoverAgents } = await import('../build/vite/agent-discovery');
+						const { discoverRoutes } = await import('../build/vite/route-discovery');
+						const { generateMetadata, writeMetadataFile } = await import(
+							'../build/vite/metadata-generator'
+						);
 
-					const metadata = await generateMetadata({
-						rootDir,
-						projectId: project?.projectId ?? '',
-						orgId: project?.orgId ?? '',
-						deploymentId,
-						agents,
-						routes,
-						dev: true,
-						logger,
-					});
+						const srcDir = join(rootDir, 'src');
 
-					writeMetadataFile(rootDir, metadata, true, logger);
+						const promises: Promise<void>[] = [];
 
-					// Sync metadata with backend (creates agents and evals in the database)
-					if (syncService && project?.projectId) {
-						await syncService.sync(
-							metadata,
-							previousMetadata,
-							project.projectId,
-							deploymentId
+						// Generate/update prompt files (non-blocking)
+						promises.push(
+							import('../build/vite/prompt-generator')
+								.then(({ generatePromptFiles }) => generatePromptFiles(srcDir, logger))
+								.catch((err) =>
+									logger.warn('Failed to generate prompt files: %s', err.message)
+								)
 						);
-						previousMetadata = metadata;
-					}
+						const agents = await discoverAgents(
+							srcDir,
+							project?.projectId ?? '',
+							deploymentId,
+							logger
+						);
+						const { routes } = await discoverRoutes(
+							srcDir,
+							project?.projectId ?? '',
+							deploymentId,
+							logger
+						);
+
+						const metadata = await generateMetadata({
+							rootDir,
+							projectId: project?.projectId ?? '',
+							orgId: project?.orgId ?? '',
+							deploymentId,
+							agents,
+							routes,
+							dev: true,
+							logger,
+						});
+
+						writeMetadataFile(rootDir, metadata, true, logger);
+
+						// Sync metadata with backend (creates agents and evals in the database)
+						if (syncService && project?.projectId) {
+							promises.push(
+								syncService.sync(
+									metadata,
+									previousMetadata,
+									project.projectId,
+									deploymentId
+								)
+							);
+							previousMetadata = metadata;
+						}
+						await promises;
 					},
 					clearOnSuccess: true,
 				});
@@ -484,22 +706,35 @@ export const command = createCommand({
 				// Wait for app.ts to finish loading (Vite is ready but app may still be initializing)
 				// Give it 2 seconds to ensure app initialization completes
 				await new Promise((resolve) => setTimeout(resolve, 2000));
+
+				// Check if shutdown was requested during startup
+				if (shutdownRequested) {
+					break;
+				}
 			} catch (error) {
 				tui.error(`Failed to start dev server: ${error}`);
 				tui.warn('Waiting for file changes to retry...');
 
-				// Wait for next restart trigger
+				// Wait for next restart trigger or shutdown
 				await new Promise<void>((resolve) => {
 					const checkRestart = setInterval(() => {
-						if (shouldRestart) {
+						if (shouldRestart || shutdownRequested) {
 							clearInterval(checkRestart);
 							resolve();
 						}
 					}, 100);
 				});
+				if (shutdownRequested) {
+					break;
+				}
 				continue;
 			}
 
+			// Exit early if shutdown was requested
+			if (shutdownRequested) {
+				break;
+			}
+
 			try {
 				// Start gravity client if we have devmode
 				if (gravityBin && gravityURL && devmode) {
@@ -600,7 +835,7 @@ export const command = createCommand({
 								});
 								break;
 							case 'q':
-								originalExit(0);
+								void cleanup(true, 0);
 								break;
 							default:
 								process.stdout.write(data);
@@ -614,31 +849,26 @@ export const command = createCommand({
 				// Start/resume file watcher now that server is ready
 				fileWatcher.resume();
 
-				// Wait for restart signal
+				// Wait for restart signal or shutdown
 				await new Promise<void>((resolve) => {
 					const checkRestart = setInterval(() => {
-						if (shouldRestart) {
+						if (shouldRestart || shutdownRequested) {
 							clearInterval(checkRestart);
 							resolve();
 						}
 					}, 100);
 				});
 
+				// Exit loop if shutdown was requested
+				if (shutdownRequested) {
+					break;
+				}
+
 				// Restart triggered - cleanup and loop (Vite stays running)
 				logger.debug('Restarting backend server...');
 
-				// Kill gravity client (if running)
-				if (gravityProcess) {
-					try {
-						gravityProcess.kill('SIGTERM');
-						await new Promise((resolve) => setTimeout(resolve, 100));
-						if (gravityProcess.exitCode === null) {
-							gravityProcess.kill('SIGKILL');
-						}
-					} catch (err) {
-						logger.debug('Error killing gravity process during restart: %s', err);
-					}
-				}
+				// Clean up Bun server and Gravity (Vite stays running)
+				await cleanupForRestart();
 
 				// Brief pause before restart
 				await new Promise((resolve) => setTimeout(resolve, 500));
@@ -647,22 +877,20 @@ export const command = createCommand({
 				tui.warn('Waiting for file changes to retry...');
 
 				// Cleanup on error (Vite stays running)
-				if (gravityProcess) {
-					try {
-						gravityProcess.kill('SIGTERM');
-						await new Promise((resolve) => setTimeout(resolve, 100));
-						if (gravityProcess.exitCode === null) {
-							gravityProcess.kill('SIGKILL');
-						}
-					} catch (err) {
-						logger.debug('Error killing gravity process on error: %s', err);
-					}
+				await cleanupForRestart();
+
+				// Exit if shutdown was requested during error handling
+				if (shutdownRequested) {
+					break;
 				}
 
-				// Wait for next restart trigger
+				// Resume file watcher to detect changes for retry
+				fileWatcher.resume();
+
+				// Wait for next restart trigger or shutdown
 				await new Promise<void>((resolve) => {
 					const checkRestart = setInterval(() => {
-						if (shouldRestart) {
+						if (shouldRestart || shutdownRequested) {
 							clearInterval(checkRestart);
 							resolve();
 						}

package/src/cmd/dev/skills.ts

@@ -0,0 +1,82 @@
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { semver } from 'bun';
+import type { Logger } from '@agentuity/core';
+
+const SKILLS_DIR = '.agents/skills/agentuity/cli';
+const VERSION_FILE = 'version.txt';
+
+interface SkillsCheckResult {
+	needsRegeneration: boolean;
+	reason?: 'missing' | 'outdated' | 'version-missing';
+	currentVersion?: string;
+}
+
+export async function checkSkillsVersion(
+	projectDir: string,
+	cliVersion: string
+): Promise<SkillsCheckResult> {
+	const skillsDir = join(projectDir, SKILLS_DIR);
+	const versionFile = join(skillsDir, VERSION_FILE);
+
+	if (!existsSync(skillsDir)) {
+		return { needsRegeneration: true, reason: 'missing' };
+	}
+
+	if (!existsSync(versionFile)) {
+		return { needsRegeneration: true, reason: 'version-missing' };
+	}
+
+	const currentVersion = (await Bun.file(versionFile).text()).trim();
+	if (!currentVersion) {
+		return { needsRegeneration: true, reason: 'version-missing' };
+	}
+
+	try {
+		const order = semver.order(currentVersion, cliVersion);
+		if (order < 0) {
+			return { needsRegeneration: true, reason: 'outdated', currentVersion };
+		}
+	} catch {
+		return { needsRegeneration: true, reason: 'outdated', currentVersion };
+	}
+
+	return { needsRegeneration: false, currentVersion };
+}
+
+export async function regenerateSkillsAsync(
+	projectDir: string,
+	cliVersion: string,
+	logger: Logger
+): Promise<void> {
+	const result = await checkSkillsVersion(projectDir, cliVersion);
+
+	if (!result.needsRegeneration) {
+		return;
+	}
+
+	const reasonMsg =
+		result.reason === 'missing'
+			? 'Skills not found'
+			: result.reason === 'version-missing'
+				? 'Skills version unknown'
+				: `Skills outdated (${result.currentVersion} < ${cliVersion})`;
+
+	logger.debug(`${reasonMsg}, regenerating...`);
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const schema = (global as any).__CLI_SCHEMA__;
+	if (!schema) {
+		logger.debug('CLI schema not available, skipping skill regeneration');
+		return;
+	}
+
+	try {
+		const outputDir = join(projectDir, '.agents');
+		const { generateSkills } = await import('../ai/skills/generator');
+		await generateSkills(schema, outputDir, false);
+		logger.debug(`Skills regenerated to ${outputDir}/skills/agentuity/cli`);
+	} catch (error) {
+		logger.debug(`Failed to regenerate skills: ${error}`);
+	}
+}