@agentuity/cli 0.0.94 → 0.0.96

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

@@ -0,0 +1,258 @@
+/**
+ * Server bundler using Bun.build with external dependency management
+ * Handles installing externals into .agentuity/node_modules for production
+ */
+
+import { join } from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+import type { Logger } from '../../../types';
+
+export interface ServerBundleOptions {
+	rootDir: string;
+	dev: boolean;
+	logger: Logger;
+}
+
+/**
+ * Install external dependencies and build server bundle
+ * For production: installs externals into .agentuity/node_modules BEFORE bundling
+ */
+export async function installExternalsAndBuild(options: ServerBundleOptions): Promise<void> {
+	const { rootDir, dev, logger } = options;
+
+	logger.debug('[server-bundler] Starting server bundle process');
+
+	const entryPath = join(rootDir, '.agentuity/app.generated.ts');
+	const outDir = join(rootDir, '.agentuity');
+
+	logger.debug(`[server-bundler] Entry: ${entryPath}, OutDir: ${outDir}`);
+
+	// Runtime externals: native modules and packages that need to be external
+	// These WILL be installed into .agentuity/node_modules for production
+	const runtimeExternals = ['bun', 'fsevents', 'chromium-bidi', 'sharp', 'ws'];
+
+	// Build tool externals: packages that should be external but NOT installed
+	// These are devDependencies that may exist in node_modules but aren't needed at runtime
+	const buildToolExternals = ['@babel/*', 'lightningcss', '@vitejs/*', 'vite', 'esbuild'];
+
+	// Load custom externals from agentuity.config.ts if it exists
+	const customExternals: string[] = [];
+	const configPath = join(rootDir, 'agentuity.config.ts');
+	if (await Bun.file(configPath).exists()) {
+		try {
+			const config = await import(configPath);
+			const userConfig = config.default;
+			if (userConfig?.build?.external && Array.isArray(userConfig.build.external)) {
+				customExternals.push(
+					...userConfig.build.external.filter((e: unknown) => typeof e === 'string')
+				);
+			}
+		} catch (error) {
+			logger.info('Failed to load agentuity.config.ts for externals:', error);
+		}
+	}
+
+	// Combine runtime externals with custom externals for installation
+	const installPatterns = [...runtimeExternals, ...customExternals];
+
+	// All external patterns (runtime + build tools + custom) for Bun.build
+	const allExternalPatterns = [...runtimeExternals, ...buildToolExternals, ...customExternals];
+	let external = allExternalPatterns;
+
+	// For production builds: install ONLY runtime externals, then discover full dependency tree
+	if (!dev) {
+		logger.debug('Installing externalized packages to discover full dependency tree...');
+
+		// Step 1: Collect packages matching RUNTIME external patterns (skip build tools)
+		const externalInstalls: string[] = [];
+		for (const pattern of installPatterns) {
+			if (pattern.endsWith('/*')) {
+				// Pattern like @org/* - install all packages under that scope
+				const prefix = pattern.slice(0, -2);
+				const nmDir = join(rootDir, 'node_modules', prefix);
+				const nmDirExists = await stat(nmDir)
+					.then((s) => s.isDirectory())
+					.catch(() => false);
+				if (nmDirExists) {
+					const entries = await readdir(nmDir);
+					for (const entry of entries) {
+						const pkgName = `${prefix}/${entry}`;
+						const pkgJsonExists = await Bun.file(
+							join(rootDir, 'node_modules', pkgName, 'package.json')
+						).exists();
+						if (pkgJsonExists) {
+							externalInstalls.push(pkgName);
+						}
+					}
+				}
+			} else {
+				// Exact package name
+				const pkgJsonExists = await Bun.file(
+					join(rootDir, 'node_modules', pattern, 'package.json')
+				).exists();
+				if (pkgJsonExists) {
+					externalInstalls.push(pattern);
+				}
+			}
+		}
+
+		// Step 2: Write minimal package.json and install externals
+		if (externalInstalls.length > 0) {
+			const pkgPath = join(rootDir, 'package.json');
+			const pkgContents = await Bun.file(pkgPath).json();
+
+			await Bun.write(
+				join(outDir, 'package.json'),
+				JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+			);
+
+			logger.debug(
+				'Installing %d packages: %s',
+				externalInstalls.length,
+				externalInstalls.join(', ')
+			);
+
+			// Install with Bun (production mode, no scripts, linux target for deployment)
+			const proc = Bun.spawn(
+				[
+					'bun',
+					'install',
+					'--no-save',
+					'--ignore-scripts',
+					'--target=bun-linux-x64',
+					...externalInstalls,
+				],
+				{
+					cwd: outDir,
+					stdout: 'pipe',
+					stderr: 'pipe',
+				}
+			);
+
+			const exitCode = await proc.exited;
+
+			if (exitCode !== 0) {
+				const stderr = await new Response(proc.stderr).text();
+				throw new Error(
+					`Failed to install external dependencies (exit code ${exitCode}):\n${stderr}`
+				);
+			}
+
+			// Step 3: Scan what actually got installed (includes transitive dependencies)
+			const installedNmDir = join(outDir, 'node_modules');
+			const installedNmDirExists = await stat(installedNmDir)
+				.then((s) => s.isDirectory())
+				.catch(() => false);
+			if (installedNmDirExists) {
+				const allInstalled: string[] = [];
+
+				// Recursively find all installed packages
+				const scanDir = async (dir: string, prefix = '') => {
+					const entries = await readdir(dir, { withFileTypes: true });
+					for (const entry of entries) {
+						if (entry.isDirectory()) {
+							const pkgName = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+							// Check if this is a package (has package.json)
+							const pkgJsonExists = await Bun.file(
+								join(dir, entry.name, 'package.json')
+							).exists();
+							if (pkgJsonExists) {
+								allInstalled.push(pkgName);
+							}
+
+							// Recurse into scoped packages (@org/package)
+							if (entry.name.startsWith('@')) {
+								await scanDir(join(dir, entry.name), entry.name);
+							}
+						}
+					}
+				};
+
+				await scanDir(installedNmDir);
+				logger.debug(
+					'Discovered %d total packages (including transitive deps)',
+					allInstalled.length
+				);
+
+				// Step 4: Use ALL installed packages + build tool externals for bundling
+				external = [...allInstalled, ...buildToolExternals];
+			}
+		}
+	} else {
+		// Dev mode: just use all external patterns as-is
+		external = allExternalPatterns;
+	}
+
+	// Build server bundle
+	logger.debug('Building server with Bun.build...');
+	logger.debug(`External packages (${external.length}): ${external.join(', ')}`);
+
+	const buildConfig = {
+		entrypoints: [entryPath],
+		outdir: outDir, // Output to .agentuity/ directly (not .agentuity/server/)
+		target: 'bun' as const,
+		format: 'esm' as const,
+		splitting: false, // Disable splitting - causes issues with externalized CommonJS packages
+		minify: !dev,
+		sourcemap: (dev ? 'inline' : 'external') as 'inline' | 'external',
+		external,
+		naming: {
+			entry: 'app.js', // Output as app.js (not app.generated.js)
+		},
+	};
+
+	logger.debug(
+		`Bun.build config: ${JSON.stringify({ ...buildConfig, external: `[${external.length} packages]` }, null, 2)}`
+	);
+
+	// Verify entry point exists before building
+	if (!(await Bun.file(entryPath).exists())) {
+		throw new Error(`Entry point not found: ${entryPath}`);
+	}
+
+	logger.debug(`Entry point verified: ${entryPath}`);
+
+	let result;
+	try {
+		result = await Bun.build(buildConfig);
+	} catch (error: unknown) {
+		logger.error('Bun.build threw an exception');
+
+		// 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)}`);
+		}
+
+		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}`
+		);
+
+		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');
+			})
+			.join('\n');
+
+		throw new Error(errorMessages || 'Build failed with no error messages');
+	}
+
+	logger.debug(`Server build complete: ${result.outputs.length} files`);
+}

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

@@ -0,0 +1,134 @@
+/**
+ * Vite Asset Server Configuration
+ *
+ * Minimal Vite config for serving frontend assets with HMR only.
+ * Does NOT handle API routes, workbench, or WebSocket - that's the Bun server's job.
+ */
+
+import { join } from 'node:path';
+import type { Logger } from '../../../types';
+import type { InlineConfig } from 'vite';
+
+export interface GenerateAssetServerConfigOptions {
+	rootDir: string;
+	logger: Logger;
+	workbenchPath?: string;
+	port: number; // The port Vite will run on (for HMR client configuration)
+}
+
+/**
+ * Generate Vite config for asset-only server (HMR + React transformation)
+ */
+export async function generateAssetServerConfig(
+	options: GenerateAssetServerConfigOptions
+): Promise<InlineConfig> {
+	const { rootDir, logger, workbenchPath, port } = options;
+
+	// Load path aliases from tsconfig.json if available
+	const tsconfigPath = join(rootDir, 'tsconfig.json');
+	let alias = {};
+
+	try {
+		const tsconfig = JSON.parse(await Bun.file(tsconfigPath).text());
+		const paths = tsconfig?.compilerOptions?.paths || {};
+		alias = Object.fromEntries(
+			Object.entries(paths).map(([key, value]) => {
+				const pathArray = value as string[];
+				return [key.replace('/*', ''), join(rootDir, pathArray[0].replace('/*', ''))];
+			})
+		);
+	} catch {
+		// No tsconfig or no paths - that's fine
+	}
+
+	return {
+		root: rootDir,
+		base: '/',
+		clearScreen: false,
+		publicDir: false, // Don't serve public dir - Bun server handles that
+
+		resolve: {
+			alias,
+			// Deduplicate React to prevent multiple instances
+			dedupe: ['react', 'react-dom', 'react/jsx-runtime', 'react/jsx-dev-runtime'],
+		},
+
+		// Only allow frontend env vars (server uses process.env)
+		envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
+
+		server: {
+			// Use the port we selected
+			port,
+			strictPort: false, // Allow fallback if port is taken
+			host: '127.0.0.1',
+
+			// CORS headers to allow Bun server on port 3500 to proxy requests
+			cors: {
+				origin: 'http://127.0.0.1:3500',
+				credentials: true,
+			},
+
+			// HMR configuration - client must connect to Vite asset server directly
+			hmr: {
+				protocol: 'ws',
+				host: '127.0.0.1',
+				port, // HMR WebSocket on same port as HTTP
+				clientPort: port, // Tell client to connect to this port (not origin 3500)
+			},
+
+			// Don't open browser - Bun server will be the entry point
+			open: false,
+		},
+
+		// Define environment variables for browser
+		define: {
+			...(workbenchPath
+				? { 'import.meta.env.AGENTUITY_PUBLIC_WORKBENCH_PATH': JSON.stringify(workbenchPath) }
+				: {}),
+			'import.meta.env.AGENTUITY_PUBLIC_HAS_SDK_KEY': JSON.stringify(
+				process.env.AGENTUITY_SDK_KEY ? 'true' : 'false'
+			),
+			'process.env.NODE_ENV': JSON.stringify('development'),
+		},
+
+		// Minimal plugins - just React and HMR
+		plugins: [
+			// React plugin for JSX/TSX transformation and Fast Refresh
+			(await import('@vitejs/plugin-react')).default(),
+			// Browser env plugin to map process.env to import.meta.env
+			(await import('./browser-env-plugin')).browserEnvPlugin(),
+		],
+
+		// Suppress build-related options (this is dev-only)
+		build: {
+			rollupOptions: {
+				external: ['vite', '@agentuity/cli'],
+			},
+		},
+
+		// Custom logger to integrate with our logger
+		customLogger: {
+			info(msg: string) {
+				if (!msg.includes('[vite]')) {
+					logger.debug(`[Vite Asset] ${msg}`);
+				}
+			},
+			warn(msg: string) {
+				logger.warn(`[Vite Asset] ${msg}`);
+			},
+			warnOnce(msg: string) {
+				logger.warn(`[Vite Asset] ${msg}`);
+			},
+			error(msg: string) {
+				logger.error(`[Vite Asset] ${msg}`);
+			},
+			clearScreen() {
+				// No-op
+			},
+			hasErrorLogged: () => false,
+			hasWarned: false,
+		},
+
+		logLevel: 'info',
+	};
+}

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

@@ -0,0 +1,63 @@
+/**
+ * Vite Asset Server
+ *
+ * Starts a minimal Vite dev server for frontend asset transformation and HMR only.
+ * Does NOT handle API routes or WebSocket - the Bun server proxies to this.
+ */
+
+import { createServer, type ViteDevServer } from 'vite';
+import type { Logger } from '../../../types';
+import { generateAssetServerConfig } from './vite-asset-server-config';
+
+export interface ViteAssetServerResult {
+	server: ViteDevServer;
+	port: number;
+}
+
+export interface StartViteAssetServerOptions {
+	rootDir: string;
+	logger: Logger;
+	workbenchPath?: string;
+}
+
+/**
+ * Start Vite asset server on a dynamically-chosen port
+ * Returns the server instance and the actual port number
+ */
+export async function startViteAssetServer(
+	options: StartViteAssetServerOptions
+): Promise<ViteAssetServerResult> {
+	const { rootDir, logger, workbenchPath } = options;
+
+	logger.debug('Starting Vite asset server (HMR only)...');
+
+	// Pick a port for Vite asset server (try 5173 first, Vite default)
+	// strictPort: false allows Vite to choose alternate if 5173 is taken
+	const preferredPort = 5173;
+
+	// Generate minimal config with preferred port
+	const config = await generateAssetServerConfig({
+		rootDir,
+		logger,
+		workbenchPath,
+		port: preferredPort,
+	});
+
+	// Create Vite server with config
+	const server = await createServer(config);
+
+	// Start listening - Vite will choose alternate port if preferred is taken
+	await server.listen();
+
+	// Get the actual port Vite is using (may differ from preferred if port was taken)
+	const actualPort = server.config.server.port || preferredPort;
+
+	logger.info(`✅ Vite asset server started on port ${actualPort}`);
+	if (actualPort !== preferredPort) {
+		logger.debug(`Port ${preferredPort} was taken, using ${actualPort} instead`);
+	}
+	logger.debug(`Asset server will handle: HMR, React transformation, source maps`);
+	logger.debug(`HMR WebSocket configured to connect to ws://127.0.0.1:${actualPort}`);
+
+	return { server, port: actualPort };
+}