@agentuity/cli 0.0.99 → 0.0.101

package/src/cmd/build/vite/route-discovery.ts

@@ -33,8 +33,12 @@ export interface RouteInfo {
 	routeType: 'api' | 'sms' | 'email' | 'cron' | 'websocket' | 'sse' | 'stream';
 	agentVariable?: string;
 	agentImportPath?: string;
+	agentName?: string;
+	agentDescription?: string;
 	inputSchemaVariable?: string;
 	outputSchemaVariable?: string;
+	inputSchemaCode?: string;
+	outputSchemaCode?: string;
 	stream?: boolean;
 }
 

package/src/cmd/build/vite/server-bundler.ts

@@ -6,6 +6,8 @@
 import { join } from 'node:path';
 import { readdir, stat } from 'node:fs/promises';
 import type { Logger } from '../../../types';
+import type { BunPlugin } from 'bun';
+import { generatePatches, applyPatch } from '../patch';
 
 export interface ServerBundleOptions {
 	rootDir: string;
@@ -22,7 +24,7 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 
 	logger.debug('[server-bundler] Starting server bundle process');
 
-	const entryPath = join(rootDir, '.agentuity/app.generated.ts');
+	const entryPath = join(rootDir, 'src/generated/app.ts');
 	const outDir = join(rootDir, '.agentuity');
 
 	logger.debug(`[server-bundler] Entry: ${entryPath}, OutDir: ${outDir}`);
@@ -202,6 +204,39 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 	logger.debug('Building server with Bun.build...');
 	logger.debug(`External packages (${external.length}): ${external.join(', ')}`);
 
+	// Create Bun plugin to apply LLM patches during bundling
+	const patches = generatePatches();
+	logger.debug(`Loaded ${patches.size} patch(es) for LLM providers`);
+
+	const patchPlugin: BunPlugin = {
+		name: 'agentuity:patch',
+		setup(build) {
+			for (const [, patch] of patches) {
+				let modulePath = join('node_modules', patch.module, '.*');
+				if (patch.filename) {
+					modulePath = join('node_modules', patch.module, patch.filename + '.*');
+				}
+				build.onLoad(
+					{
+						filter: new RegExp(modulePath),
+						namespace: 'file',
+					},
+					async (args) => {
+						if (build.config.target !== 'bun') {
+							return;
+						}
+						logger.trace(`Applying patch to: ${args.path}`);
+						const [contents, loader] = await applyPatch(args.path, patch);
+						return {
+							contents,
+							loader,
+						};
+					}
+				);
+			}
+		},
+	};
+
 	const buildConfig = {
 		entrypoints: [entryPath],
 		outdir: outDir, // Output to .agentuity/ directly (not .agentuity/server/)
@@ -211,7 +246,12 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		minify: !dev,
 		sourcemap: (dev ? 'inline' : 'external') as 'inline' | 'external',
 		external,
+		// CRITICAL: Disable environment variable inlining for server builds
+		// Server code must read process.env at RUNTIME, not have values baked in at build time
+		// Without this, NODE_ENV and other env vars get inlined as string literals
+		env: 'disable' as const,
 		define: userDefine, // Include custom define values from agentuity.config.ts
+		plugins: [patchPlugin],
 		naming: {
 			entry: 'app.js', // Output as app.js (not app.generated.js)
 		},
@@ -221,6 +261,12 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		`Bun.build config: ${JSON.stringify({ ...buildConfig, external: `[${external.length} packages]` }, null, 2)}`
 	);
 
+	// WORKAROUND: Temporarily delete NODE_ENV to prevent Bun.build from inlining it
+	// See: https://github.com/oven-sh/bun/issues/20183
+	// Even with env: 'disable', Bun.build still inlines NODE_ENV at build time
+	const originalNodeEnv = process.env.NODE_ENV;
+	delete process.env.NODE_ENV;
+
 	// Verify entry point exists before building
 	if (!(await Bun.file(entryPath).exists())) {
 		throw new Error(`Entry point not found: ${entryPath}`);
@@ -232,6 +278,10 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 	try {
 		result = await Bun.build(buildConfig);
 	} catch (error: unknown) {
+		// Restore NODE_ENV after build attempt
+		if (originalNodeEnv !== undefined) {
+			process.env.NODE_ENV = originalNodeEnv;
+		}
 		logger.error('Bun.build threw an exception');
 
 		// Handle AggregateError with build/resolve messages
@@ -250,6 +300,11 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		throw error;
 	}
 
+	// Restore NODE_ENV after successful build
+	if (originalNodeEnv !== undefined) {
+		process.env.NODE_ENV = originalNodeEnv;
+	}
+
 	if (!result.success) {
 		logger.error('Bun.build failed for server');
 		logger.error(

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

@@ -7,7 +7,6 @@
 import { join } from 'node:path';
 import type { InlineConfig } from 'vite';
 import type { Logger } from '../../../types';
-import { patchPlugin } from './patch-plugin';
 import { browserEnvPlugin } from './browser-env-plugin';
 
 export interface ViteBuildOptions {
@@ -26,7 +25,7 @@ export interface ViteBuildOptions {
 
 /**
  * Run a Vite build for the specified mode
- * Generates vite config in .agentuity/.vite/ and uses it
+ * Uses inline Vite config (customizable via agentuity.config.ts)
  */
 export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	const { rootDir, mode, dev = false, projectId = '', deploymentId = '', logger } = options;
@@ -36,7 +35,17 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	// For server mode, use Bun.build (preserves process.env at runtime)
 	if (mode === 'server') {
 		try {
-			// First, generate the entry file
+			const srcDir = join(rootDir, 'src');
+
+			// Generate documentation files (if they don't exist)
+			const { generateDocumentation } = await import('./docs-generator');
+			await generateDocumentation(srcDir, logger);
+
+			// Generate lifecycle types (if setup() exists)
+			const { generateLifecycleTypes } = await import('./lifecycle-generator');
+			await generateLifecycleTypes(rootDir, srcDir, logger);
+
+			// Then, generate the entry file
 			const { generateEntryFile } = await import('../entry-generator');
 			await generateEntryFile({
 				rootDir,
@@ -46,7 +55,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 				mode: dev ? 'dev' : 'prod',
 			});
 
-			// Then, build with Bun.build
+			// Finally, build with Bun.build
 			const { installExternalsAndBuild } = await import('./server-bundler');
 			await installExternalsAndBuild({
 				rootDir,
@@ -76,7 +85,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const { workbenchEnabled = false, workbenchRoute = '/workbench' } = options;
 
 		// Load custom user plugins from agentuity.config.ts if it exists
-		const plugins = [react(), browserEnvPlugin(), patchPlugin({ logger, dev })];
+		const plugins = [react(), browserEnvPlugin()];
 		const { loadAgentuityConfig } = await import('./config-loader');
 		const userConfig = await loadAgentuityConfig(rootDir, logger);
 		const userPlugins = userConfig?.plugins || [];
@@ -147,7 +156,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		viteConfig = {
 			root: join(rootDir, '.agentuity/workbench-src'), // Use generated workbench source
 			base, // All workbench assets are under the configured route
-			plugins: [react(), patchPlugin({ logger, dev })],
+			plugins: [react()],
 			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
 			define: {
 				// Merge user-defined constants
@@ -214,10 +223,36 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
 	}
 
+	// 1. Discover agents and routes BEFORE builds
+	logger.debug('Discovering agents and routes...');
+	const { generateAgentRegistry, generateRouteRegistry } = await import('./registry-generator');
+	const { discoverAgents } = await import('./agent-discovery');
+	const { discoverRoutes } = await import('./route-discovery');
+
+	const srcDir = join(rootDir, 'src');
+	const agentMetadata = await discoverAgents(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+	const { routes, routeInfoList } = await discoverRoutes(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+
+	// Generate agent and route registries for type augmentation BEFORE builds
+	// (TypeScript needs these files to exist during type checking)
+	generateAgentRegistry(srcDir, agentMetadata);
+	generateRouteRegistry(srcDir, routeInfoList);
+	logger.debug('Agent and route registries generated');
+
 	// Check if web frontend exists
 	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
 
-	// 1. Build client (only if web frontend exists)
+	// 2. Build client (only if web frontend exists)
 	if (hasWebFrontend) {
 		logger.debug('Building client assets...');
 		try {
@@ -238,7 +273,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Skipping client build - no src/web/index.html found');
 	}
 
-	// 2. Build workbench (if enabled in config)
+	// 3. Build workbench (if enabled in config)
 	if (workbenchConfig.enabled) {
 		logger.debug('Building workbench assets...');
 		try {
@@ -257,7 +292,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		}
 	}
 
-	// 3. Build server
+	// 4. Build server
 	logger.debug('Building server...');
 	try {
 		const started = Date.now();
@@ -269,31 +304,9 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		throw error;
 	}
 
-	// 4. Generate registry and metadata (after all builds complete)
-	logger.debug('Generating agent registry and metadata...');
+	// 5. Generate metadata (after all builds complete)
+	logger.debug('Generating metadata...');
 	const { generateMetadata, writeMetadataFile } = await import('./metadata-generator');
-	const { generateAgentRegistry, generateRouteRegistry } = await import('./registry-generator');
-	const { discoverAgents } = await import('./agent-discovery');
-	const { discoverRoutes } = await import('./route-discovery');
-
-	const srcDir = join(rootDir, 'src');
-	const agentMetadata = await discoverAgents(
-		srcDir,
-		projectId,
-		options.deploymentId || '',
-		logger
-	);
-	const { routes, routeInfoList } = await discoverRoutes(
-		srcDir,
-		projectId,
-		options.deploymentId || '',
-		logger
-	);
-
-	// Generate agent and route registries for type augmentation
-	generateAgentRegistry(srcDir, agentMetadata);
-	generateRouteRegistry(srcDir, routeInfoList);
-	logger.debug('Agent and route registries generated');
 
 	// Generate metadata
 	const metadata = await generateMetadata({

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

@@ -75,8 +75,8 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 	}
 
 	try {
-		// Run all Vite builds (client -> workbench -> server)
-		logger.debug('Starting Vite builds...');
+		// Run all builds (client -> workbench -> server)
+		logger.debug('Starting builds...');
 
 		const result = await runAllBuilds({
 			rootDir,
@@ -90,16 +90,16 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 		});
 
 		if (result.client.included) {
-			output.push(tui.muted(`✓ Client Built in ${result.client.duration}ms`));
+			output.push(tui.muted(`✓ Client built in ${result.client.duration}ms`));
 		}
 		if (result.workbench.included) {
-			output.push(tui.muted(`✓ Workbench Built in ${result.workbench.duration}ms`));
+			output.push(tui.muted(`✓ Workbench built in ${result.workbench.duration}ms`));
 		}
 		if (result.server.included) {
-			output.push(tui.muted(`✓ Server Built in ${result.server.duration}ms`));
+			output.push(tui.muted(`✓ Server built in ${result.server.duration}ms`));
 		}
 
-		logger.debug('Vite builds complete');
+		logger.debug('All builds complete');
 
 		return { output };
 	} catch (error) {

package/src/cmd/cloud/deploy.ts

@@ -6,8 +6,9 @@ import { tmpdir } from 'node:os';
 import { StructuredError } from '@agentuity/core';
 import { isRunningFromExecutable } from '../upgrade';
 import { createSubcommand } from '../../types';
+import { getUserAgent } from '../../api';
 import * as tui from '../../tui';
-import { saveProjectDir, getDefaultConfigDir } from '../../config';
+import { saveProjectDir, getDefaultConfigDir, loadProjectSDKKey } from '../../config';
 import {
 	runSteps,
 	stepSuccess,
@@ -106,6 +107,15 @@ export const deploySubcommand = createSubcommand({
 		let statusResult: DeploymentStatusResult | undefined;
 		const logs: string[] = [];
 
+		const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
+
+		// Ensure SDK key is present before proceeding
+		if (!sdkKey) {
+			ctx.logger.fatal(
+				'SDK key not found. Run "agentuity auth login" to authenticate or set AGENTUITY_SDK_KEY environment variable.'
+			);
+		}
+
 		try {
 			await saveProjectDir(projectDir);
 
@@ -241,10 +251,6 @@ export const deploySubcommand = createSubcommand({
 							const deploymentZip = join(tmpdir(), `${deployment.id}.zip`);
 							await zipDir(join(projectDir, '.agentuity'), deploymentZip, {
 								filter: (_filename: string, relative: string) => {
-									// Exclude Vite-specific build artifacts
-									if (relative.endsWith('.generated.ts')) {
-										return false;
-									}
 									if (relative.startsWith('.vite/')) {
 										return false;
 									}
@@ -444,6 +450,10 @@ export const deploySubcommand = createSubcommand({
 										logger.debug('fetching stream: %s/%s', streamsUrl, streamId);
 										const resp = await fetch(`${streamsUrl}/${streamId}`, {
 											signal: logStreamController.signal,
+											headers: {
+												Authorization: `Bearer ${sdkKey}`,
+												'User-Agent': getUserAgent(),
+											},
 										});
 										if (!resp.ok || !resp.body) {
 											ctx.logger.trace(

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

@@ -5,9 +5,10 @@
  * Handles both backend (API, agents, lib) and generates restart signals.
  */
 
-import { watch, type FSWatcher } from 'node:fs';
+import { watch, type FSWatcher, statSync, readdirSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Logger } from '../../types';
+import { createAgentTemplates, createAPITemplates } from './templates';
 
 export interface FileWatcherOptions {
 	rootDir: string;
@@ -127,6 +128,41 @@ export function createFileWatcher(options: FileWatcherOptions): FileWatcherManag
 			return;
 		}
 
+		// Check if an empty directory was created in src/agent/ or src/api/
+		// This helps with developer experience by auto-scaffolding template files
+		if (changedFile && eventType === 'rename') {
+			try {
+				const absPath = resolve(watchDir, changedFile);
+				// Normalize the path for comparison (use forward slashes)
+				const normalizedPath = changedFile.replace(/\\/g, '/');
+
+				// Check if it's a directory and empty
+				const stats = statSync(absPath);
+				if (stats.isDirectory()) {
+					const contents = readdirSync(absPath);
+					if (contents.length === 0) {
+						// Check if this is an agent or API directory
+						if (
+							normalizedPath.startsWith('src/agent/') ||
+							normalizedPath.includes('/src/agent/')
+						) {
+							logger.debug('Agent directory created: %s', changedFile);
+							createAgentTemplates(absPath);
+						} else if (
+							normalizedPath.startsWith('src/api/') ||
+							normalizedPath.includes('/src/api/')
+						) {
+							logger.debug('API directory created: %s', changedFile);
+							createAPITemplates(absPath);
+						}
+					}
+				}
+			} catch (error) {
+				// File might have been deleted or doesn't exist yet - this is normal
+				logger.trace('Unable to check directory for template creation: %s', error);
+			}
+		}
+
 		logger.debug('File changed (%s): %s', eventType, changedFile || watchDir);
 		onRestart();
 	}

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';
@@ -99,6 +99,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 +117,22 @@ export const command = createCommand({
 			for (const filename of missing) {
 				tui.bullet(`Missing ${filename}`);
 			}
-			internalExit(1);
+			originalExit(1);
 		}
 
 		// 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;
@@ -224,8 +236,8 @@ export const command = createCommand({
 
 		// 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 +253,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;
@@ -293,11 +307,22 @@ export const command = createCommand({
 				}
 			}
 
-			internalExit(0);
+			originalExit(0);
 		};
 
-		process.on('SIGINT', cleanup);
-		process.on('SIGTERM', cleanup);
+		// 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();
+		});
 
 		// Ensure Vite and gravity are always killed on exit (even if cleanup is bypassed)
 		process.on('exit', () => {
@@ -329,23 +354,76 @@ 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 () => {
-						const { generateEntryFile } = await import('../build/entry-generator');
-						await generateEntryFile({
-							rootDir,
-							projectId: project?.projectId ?? '',
-							deploymentId,
-							logger,
-							mode: 'dev',
-						});
+					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'
+					);
+
+					const srcDir = join(rootDir, 'src');
+					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 +442,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 +481,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 +558,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 +580,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 +600,7 @@ export const command = createCommand({
 								});
 								break;
 							case 'q':
-								internalExit(0);
+								originalExit(0);
 								break;
 							default:
 								process.stdout.write(data);