@agentuity/cli 0.0.100 → 0.0.102

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

@@ -9,6 +9,37 @@ import type { Logger } from '../../../types';
 import type { BunPlugin } from 'bun';
 import { generatePatches, applyPatch } from '../patch';
 
+/**
+ * Format a Bun build log (BuildMessage or ResolveMessage) into a readable string
+ */
+export function formatBuildLog(log: BuildMessage | ResolveMessage): string {
+	const parts: string[] = [];
+
+	// For ResolveMessage, format with specifier info
+	if (log.name === 'ResolveMessage') {
+		const resolveLog = log as ResolveMessage;
+		if (resolveLog.specifier) {
+			parts.push(`Could not resolve "${resolveLog.specifier}"`);
+			// Use referrer if available, otherwise fall back to position.file
+			const referrer = resolveLog.referrer || resolveLog.position?.file;
+			if (referrer) {
+				parts.push(`  imported from: ${referrer}`);
+			}
+		} else if (resolveLog.message) {
+			parts.push(resolveLog.message);
+		}
+	} else if (log.message) {
+		parts.push(log.message);
+	}
+
+	// Add position info if available (only if we haven't already shown referrer from position)
+	if (log.position && log.name !== 'ResolveMessage') {
+		parts.push(`  at ${log.position.file}:${log.position.line}:${log.position.column}`);
+	}
+
+	return parts.join('\n');
+}
+
 export interface ServerBundleOptions {
 	rootDir: string;
 	dev: boolean;
@@ -24,7 +55,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}`);
@@ -246,6 +277,10 @@ 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: {
@@ -257,6 +292,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}`);
@@ -268,38 +309,47 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 	try {
 		result = await Bun.build(buildConfig);
 	} catch (error: unknown) {
-		logger.error('Bun.build threw an exception');
+		// Restore NODE_ENV after build attempt
+		if (originalNodeEnv !== undefined) {
+			process.env.NODE_ENV = originalNodeEnv;
+		}
 
 		// Handle AggregateError with build/resolve messages
 		if (error instanceof AggregateError && error.errors) {
-			for (const err of error.errors) {
-				const parts = [err.message || err.text || 'Unknown error'];
-				if (err.position) {
-					parts.push(`  at ${err.position.file}:${err.position.line}:${err.position.column}`);
-				}
-				logger.error(parts.join('\n'));
-			}
-		} else {
-			logger.error(`  ${error instanceof Error ? error.message : String(error)}`);
+			const formattedErrors = error.errors
+				.map((err) => {
+					// Try to use formatBuildLog if it looks like a BuildMessage/ResolveMessage
+					if (err && typeof err === 'object' && 'name' in err) {
+						const formatted = formatBuildLog(err as BuildMessage | ResolveMessage);
+						if (formatted) return formatted;
+					}
+					// Fallback for other error types
+					const parts = [err.message || err.text || 'Unknown error'];
+					if (err.position) {
+						parts.push(
+							`  at ${err.position.file}:${err.position.line}:${err.position.column}`
+						);
+					}
+					return parts.join('\n');
+				})
+				.filter(Boolean)
+				.join('\n');
+
+			throw new Error(formattedErrors || 'Build failed');
 		}
 
 		throw error;
 	}
 
-	if (!result.success) {
-		logger.error('Bun.build failed for server');
-		logger.error(
-			`Build result: success=${result.success}, outputs=${result.outputs.length}, logs=${result.logs.length}`
-		);
+	// Restore NODE_ENV after successful build
+	if (originalNodeEnv !== undefined) {
+		process.env.NODE_ENV = originalNodeEnv;
+	}
 
+	if (!result.success) {
 		const errorMessages = result.logs
-			.map((log) => {
-				const parts = [log.message];
-				if (log.position) {
-					parts.push(`  at ${log.position.file}:${log.position.line}:${log.position.column}`);
-				}
-				return parts.join('\n');
-			})
+			.map((log) => formatBuildLog(log))
+			.filter(Boolean)
 			.join('\n');
 
 		throw new Error(errorMessages || 'Build failed with no error messages');

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -69,6 +69,11 @@ export async function generateAssetServerConfig(
 			dedupe: ['react', 'react-dom', 'react/jsx-runtime', 'react/jsx-dev-runtime'],
 		},
 
+		// Pre-bundle @agentuity/workbench to avoid React preamble issues with pre-built JSX
+		optimizeDeps: {
+			include: ['@agentuity/workbench', '@agentuity/core', '@agentuity/react'],
+		},
+
 		// Only allow frontend env vars (server uses process.env)
 		envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
 

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

@@ -5,10 +5,43 @@
  */
 
 import { join } from 'node:path';
-import type { InlineConfig } from 'vite';
+import { existsSync, renameSync, rmSync } from 'node:fs';
+import type { InlineConfig, Plugin } from 'vite';
 import type { Logger } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
 
+/**
+ * Vite plugin to flatten the output structure for index.html
+ *
+ * When root is set to the project root (for TanStack Router compatibility),
+ * Vite outputs index.html to .agentuity/client/src/web/index.html instead of
+ * .agentuity/client/index.html. This plugin moves it to the expected location.
+ */
+function flattenHtmlOutputPlugin(outDir: string): Plugin {
+	return {
+		name: 'agentuity:flatten-html-output',
+		apply: 'build',
+		closeBundle() {
+			const nestedHtmlPath = join(outDir, 'src', 'web', 'index.html');
+			const targetHtmlPath = join(outDir, 'index.html');
+
+			if (existsSync(nestedHtmlPath)) {
+				renameSync(nestedHtmlPath, targetHtmlPath);
+
+				// Clean up empty src/web directory structure
+				const srcWebDir = join(outDir, 'src', 'web');
+				const srcDir = join(outDir, 'src');
+				try {
+					rmSync(srcWebDir, { recursive: true, force: true });
+					rmSync(srcDir, { recursive: true, force: true });
+				} catch {
+					// Ignore cleanup errors
+				}
+			}
+		},
+	};
+}
+
 export interface ViteBuildOptions {
 	rootDir: string;
 	mode: 'client' | 'server' | 'workbench';
@@ -25,7 +58,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;
@@ -34,28 +67,40 @@ 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 { generateEntryFile } = await import('../entry-generator');
-			await generateEntryFile({
-				rootDir,
-				projectId,
-				deploymentId: deploymentId || '',
-				logger,
-				mode: dev ? 'dev' : 'prod',
-			});
-
-			// Then, build with Bun.build
-			const { installExternalsAndBuild } = await import('./server-bundler');
-			await installExternalsAndBuild({
-				rootDir,
-				dev,
-				logger,
-			});
-		} catch (error) {
-			logger.error('server-bundler import or execution failed: %s', error);
-			throw error;
+		const srcDir = join(rootDir, 'src');
+
+		// Generate documentation files (if they don't exist)
+		const { generateDocumentation } = await import('./docs-generator');
+		await generateDocumentation(srcDir, logger);
+
+		// Generate/update prompt files in dev mode only (non-blocking)
+		if (dev) {
+			import('./prompt-generator')
+				.then(({ generatePromptFiles }) => generatePromptFiles(srcDir, logger))
+				.catch((err) => logger.warn('Failed to generate prompt files: %s', err.message));
 		}
+
+		// 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,
+			projectId,
+			deploymentId: deploymentId || '',
+			logger,
+			mode: dev ? 'dev' : 'prod',
+		});
+
+		// Finally, build with Bun.build
+		const { installExternalsAndBuild } = await import('./server-bundler');
+		await installExternalsAndBuild({
+			rootDir,
+			dev,
+			logger,
+		});
 		return;
 	}
 
@@ -75,7 +120,8 @@ 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()];
+		const clientOutDir = join(rootDir, '.agentuity/client');
+		const plugins = [react(), browserEnvPlugin(), flattenHtmlOutputPlugin(clientOutDir)];
 		const { loadAgentuityConfig } = await import('./config-loader');
 		const userConfig = await loadAgentuityConfig(rootDir, logger);
 		const userPlugins = userConfig?.plugins || [];
@@ -94,14 +140,18 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		}
 
 		// Determine CDN base URL for production builds
+		// Use CDN for all non-dev builds with a deploymentId (including local region)
 		const isLocalRegion = options.region === 'local';
+		const cdnDomain = isLocalRegion
+			? 'localstack-static-assets.t3.storage.dev'
+			: 'static.agentuity.com';
 		const cdnBaseUrl =
-			!dev && deploymentId && !isLocalRegion
-				? `https://static.agentuity.com/${deploymentId}/client/`
-				: undefined;
+			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;
 
 		viteConfig = {
-			root: join(rootDir, 'src', 'web'), // Set web dir as root
+			// Use project root as Vite root so plugins (e.g., TanStack Router) resolve paths
+			// from the repo root, matching where agentuity.config.ts is located
+			root: rootDir,
 			plugins,
 			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
 			publicDir: join(rootDir, 'src', 'web', 'public'),
@@ -116,7 +166,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 					: 'undefined',
 			},
 			build: {
-				outDir: join(rootDir, '.agentuity/client'),
+				outDir: clientOutDir,
 				rollupOptions: {
 					input: htmlPath,
 				},
@@ -167,20 +217,15 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	}
 
 	// Build with Vite
-	try {
-		// Force the build to use the correct mode
-		const buildMode = dev ? 'development' : 'production';
+	// Force the build to use the correct mode
+	const buildMode = dev ? 'development' : 'production';
 
-		await viteBuild({
-			...viteConfig,
-			mode: buildMode,
-		});
+	await viteBuild({
+		...viteConfig,
+		mode: buildMode,
+	});
 
-		logger.debug(`Vite build complete for mode: ${mode}`);
-	} catch (error) {
-		logger.error(`Vite build failed for mode ${mode}:`, error);
-		throw error;
-	}
+	logger.debug(`Vite build complete for mode: ${mode}`);
 }
 
 interface BuildResult {
@@ -213,64 +258,8 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
 	}
 
-	// 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)
-	if (hasWebFrontend) {
-		logger.debug('Building client assets...');
-		try {
-			const started = Date.now();
-			await runViteBuild({
-				...options,
-				mode: 'client',
-				workbenchEnabled: workbenchConfig.enabled,
-				workbenchRoute: workbenchConfig.route,
-			});
-			result.client.included = true;
-			result.client.duration = Date.now() - started;
-		} catch (error) {
-			logger.error('Client build failed:', error);
-			throw error;
-		}
-	} else {
-		logger.debug('Skipping client build - no src/web/index.html found');
-	}
-
-	// 2. Build workbench (if enabled in config)
-	if (workbenchConfig.enabled) {
-		logger.debug('Building workbench assets...');
-		try {
-			const started = Date.now();
-			await runViteBuild({
-				...options,
-				mode: 'workbench',
-				workbenchRoute: workbenchConfig.route,
-				workbenchEnabled: true,
-			});
-			result.workbench.included = true;
-			result.workbench.duration = Date.now() - started;
-		} catch (error) {
-			logger.error('Workbench build failed:', error);
-			throw error;
-		}
-	}
-
-	// 3. Build server
-	logger.debug('Building server...');
-	try {
-		const started = Date.now();
-		await runViteBuild({ ...options, mode: 'server' });
-		result.server.included = true;
-		result.server.duration = Date.now() - started;
-	} catch (error) {
-		logger.error('Server build failed:', error);
-		throw error;
-	}
-
-	// 4. Generate registry and metadata (after all builds complete)
-	logger.debug('Generating agent registry and metadata...');
-	const { generateMetadata, writeMetadataFile } = await import('./metadata-generator');
+	// 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');
@@ -289,11 +278,56 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger
 	);
 
-	// Generate agent and route registries for type augmentation
+	// 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();
+
+	// 2. Build client (only if web frontend exists)
+	if (hasWebFrontend) {
+		logger.debug('Building client assets...');
+		const started = Date.now();
+		await runViteBuild({
+			...options,
+			mode: 'client',
+			workbenchEnabled: workbenchConfig.enabled,
+			workbenchRoute: workbenchConfig.route,
+		});
+		result.client.included = true;
+		result.client.duration = Date.now() - started;
+	} else {
+		logger.debug('Skipping client build - no src/web/index.html found');
+	}
+
+	// 3. Build workbench (if enabled in config)
+	if (workbenchConfig.enabled) {
+		logger.debug('Building workbench assets...');
+		const started = Date.now();
+		await runViteBuild({
+			...options,
+			mode: 'workbench',
+			workbenchRoute: workbenchConfig.route,
+			workbenchEnabled: true,
+		});
+		result.workbench.included = true;
+		result.workbench.duration = Date.now() - started;
+	}
+
+	// 4. Build server
+	logger.debug('Building server...');
+	const serverStarted = Date.now();
+	await runViteBuild({ ...options, mode: 'server' });
+	result.server.included = true;
+	result.server.duration = Date.now() - serverStarted;
+
+	// 5. Generate metadata (after all builds complete)
+	logger.debug('Generating metadata...');
+	const { generateMetadata, writeMetadataFile } = await import('./metadata-generator');
+
 	// Generate metadata
 	const metadata = await generateMetadata({
 		rootDir,

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) {