@agentuity/cli 0.0.100 → 0.0.102

package/src/cmd/dev/index.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { resolve, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { internalExit } from '@agentuity/runtime';
+import { getServiceUrls } from '@agentuity/server';
 import { createCommand } from '../../types';
 import { startBunDevServer } from '../build/vite/bun-dev-server';
 import { startViteAssetServer } from '../build/vite/vite-asset-server';
@@ -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) {
@@ -99,6 +175,13 @@ export const command = createCommand({
 
 		const interactive = !shouldDisableInteractive(opts.interactive);
 
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let originalExit = (globalThis as any).AGENTUITY_PROCESS_EXIT;
+
+		if (!originalExit) {
+			originalExit = process.exit.bind(process);
+		}
+
 		for (const filename of mustHaves) {
 			if (!existsSync(filename)) {
 				missing.push(filename);
@@ -110,17 +193,28 @@ export const command = createCommand({
 			for (const filename of missing) {
 				tui.bullet(`Missing ${filename}`);
 			}
-			internalExit(1);
+			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;
-		createDevmodeSyncService({
-			logger,
-			apiClient,
-			mock: useMockService,
-		});
+		const syncService = apiClient
+			? createDevmodeSyncService({
+					logger,
+					apiClient,
+					mock: useMockService,
+				})
+			: null;
+
+		// Track previous metadata for sync diffing
+		let previousMetadata:
+			| Awaited<ReturnType<typeof import('../build/vite/metadata-generator').generateMetadata>>
+			| undefined;
 
 		let devmode: DevmodeResponse | undefined;
 		let gravityBin: string | undefined;
@@ -222,10 +316,16 @@ 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 vitePort: number;
 		let viteServer: ServerLike | null = null;
+		let vitePort: number;
 
 		try {
 			logger.debug('Starting Vite asset server...');
@@ -241,13 +341,15 @@ export const command = createCommand({
 			);
 		} catch (error) {
 			tui.error(`Failed to start Vite asset server: ${error}`);
-			internalExit(1);
+			originalExit(1);
+			return;
 		}
 
 		// 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;
+		let stdinListenerRegistered = false; // Track if stdin listener is already registered
 
 		const restartServer = () => {
 			shouldRestart = true;
@@ -267,16 +369,36 @@ 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;
+
+		/**
+		 * 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
@@ -284,26 +406,114 @@ 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;
 				}
 			}
 
-			internalExit(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);
+			}
 		};
 
-		process.on('SIGINT', cleanup);
-		process.on('SIGTERM', cleanup);
+		/**
+		 * 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;
+				}
+			}
+		};
 
-		// Ensure Vite and gravity are always killed on exit (even if cleanup is bypassed)
+		// SIGINT/SIGTERM: coordinate shutdown between bundle and dev resources
+		let signalHandlersRegistered = false;
+		if (!signalHandlersRegistered) {
+			signalHandlersRegistered = true;
+
+			const safeExit = async (code: number, reason?: string) => {
+				if (reason) {
+					logger.debug('DevMode terminating (%d) due to: %s', code, reason);
+				}
+				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();
@@ -312,10 +522,12 @@ 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
 				}
@@ -329,10 +541,26 @@ export const command = createCommand({
 			fileWatcher.pause();
 
 			try {
-				// Generate entry file for Vite before starting dev server
+				// Generate entry file and bundle for dev server (with LLM patches)
 				await tui.spinner({
-					message: 'Generating entry file',
+					message: 'Building dev bundle',
 					callback: async () => {
+						// 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
+							);
+						}
+
+						// 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,
@@ -340,12 +568,72 @@ export const command = createCommand({
 							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 srcDir = join(rootDir, 'src');
+
+						// Generate/update prompt files (non-blocking)
+						import('../build/vite/prompt-generator')
+							.then(({ generatePromptFiles }) => generatePromptFiles(srcDir, logger))
+							.catch((err) => logger.warn('Failed to generate prompt files: %s', err.message));
+						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) {
+							await syncService.sync(
+								metadata,
+								previousMetadata,
+								project.projectId,
+								deploymentId
+							);
+							previousMetadata = metadata;
+						}
 					},
 					clearOnSuccess: true,
 				});
 			} catch (error) {
-				tui.error(`Failed to generate entry file: ${error}`);
+				tui.error(`Failed to build dev bundle: ${error}`);
 				tui.warn('Waiting for file changes to retry...');
 
 				// Resume watcher to detect changes for retry
@@ -364,6 +652,34 @@ export const command = createCommand({
 			}
 
 			try {
+				// Set environment variables for LLM provider patches BEFORE starting server
+				// These must be set so the bundled patches can route LLM calls through AI Gateway
+				const serviceUrls = getServiceUrls(project?.region);
+
+				process.env.AGENTUITY_SDK_DEV_MODE = 'true';
+				process.env.AGENTUITY_ENV = 'development';
+				process.env.NODE_ENV = 'development';
+				if (project?.region) {
+					process.env.AGENTUITY_REGION = project.region;
+				}
+				process.env.PORT = String(opts.port);
+				process.env.AGENTUITY_PORT = process.env.PORT;
+
+				if (project) {
+					process.env.AGENTUITY_TRANSPORT_URL = serviceUrls.catalyst;
+					process.env.AGENTUITY_CATALYST_URL = serviceUrls.catalyst;
+					process.env.AGENTUITY_VECTOR_URL = serviceUrls.vector;
+					process.env.AGENTUITY_KEYVALUE_URL = serviceUrls.keyvalue;
+					process.env.AGENTUITY_STREAM_URL = serviceUrls.stream;
+					process.env.AGENTUITY_CLOUD_ORG_ID = project.orgId;
+					process.env.AGENTUITY_CLOUD_PROJECT_ID = project.projectId;
+				}
+
+				// Set Vite port for asset proxying in bundled app
+				process.env.VITE_PORT = String(vitePort);
+
+				logger.debug('Set VITE_PORT=%s for asset proxying', process.env.VITE_PORT);
+
 				// Start Bun dev server (Vite already running, just start backend)
 				await startBunDevServer({
 					rootDir,
@@ -375,8 +691,6 @@ export const command = createCommand({
 					vitePort, // Pass port of already-running Vite 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)
 				// Give it 2 seconds to ensure app initialization completes
 				await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -454,8 +768,14 @@ export const command = createCommand({
 				// TODO: Integrate sync service with Vite's buildStart/buildEnd hooks
 				// The sync service will be called when metadata changes are detected
 
-				// Handle keyboard shortcuts
-				if (interactive && process.stdin.isTTY && process.stdout.isTTY) {
+				// Handle keyboard shortcuts - only register listener once
+				if (
+					interactive &&
+					process.stdin.isTTY &&
+					process.stdout.isTTY &&
+					!stdinListenerRegistered
+				) {
+					stdinListenerRegistered = true;
 					process.stdin.setRawMode(true);
 					process.stdin.resume();
 					process.stdin.setEncoding('utf8');
@@ -470,9 +790,10 @@ export const command = createCommand({
 					process.stdin.on('data', (data) => {
 						const key = data.toString();
 
-						// Handle Ctrl+C
+						// Handle Ctrl+C - send SIGINT to trigger graceful shutdown
 						if (key === '\u0003') {
-							internalExit(0);
+							process.kill(process.pid, 'SIGINT');
+							return;
 						}
 
 						switch (key) {
@@ -489,7 +810,7 @@ export const command = createCommand({
 								});
 								break;
 							case 'q':
-								internalExit(0);
+								void cleanup(true, 0);
 								break;
 							default:
 								process.stdout.write(data);
@@ -516,18 +837,8 @@ export const command = createCommand({
 				// 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));
@@ -536,17 +847,10 @@ 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();
+
+				// Resume file watcher to detect changes for retry
+				fileWatcher.resume();
 
 				// Wait for next restart trigger
 				await new Promise<void>((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}`);
+	}
+}