@agentuity/cli 0.0.98 → 0.0.100

package/src/cmd/build/entry-generator.ts

@@ -76,23 +76,13 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 		`import { `,
 		...runtimeImports,
 		`} from '@agentuity/runtime';`,
+		`import type { Context } from 'hono';`,
 		`import { websocket } from 'hono/bun';`, // Always use Bun WebSocket (dev and prod)
 		!isDev && hasWebFrontend ? `import { serveStatic } from 'hono/bun';` : '',
 	].filter(Boolean);
 
 	imports.push(`import { type LogLevel } from '@agentuity/core';`);
-
-	// HMR setup (dev only)
-	const hmrSetup = isDev
-		? `
-// HMR restart handler
-if (typeof (globalThis as any).__AGENTUITY_RESTART__ === 'undefined') {
-	(globalThis as any).__AGENTUITY_RESTART__ = () => {
-		console.log('[HMR] Restart triggered but handler not ready yet');
-	};
-}
-`
-		: '';
+	imports.push(`import { bootstrapRuntimeEnv } from '@agentuity/cli/runtime-bootstrap';`);
 
 	// Generate route mounting code for all discovered routes
 	const routeImportsAndMounts: string[] = [];
@@ -146,7 +136,7 @@ app.route('/', workbenchRouter);
 // Asset proxy routes - Forward Vite-specific requests to asset server
 const VITE_ASSET_PORT = ${vitePort};
 
-const proxyToVite = async (c) => {
+const proxyToVite = async (c: Context) => {
 	const viteUrl = \`http://127.0.0.1:\${VITE_ASSET_PORT}\${c.req.path}\`;
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), 10000); // 10s timeout
@@ -206,54 +196,82 @@ app.get('/*.css', proxyToVite);
 	let webRoutes = '';
 	if (hasWebFrontend) {
 		if (isDev) {
-			const htmlPath = join(srcDir, 'web', 'index.html');
 			webRoutes = `
 // Web routes (dev mode with Vite HMR via proxy)
-const devHtmlHandler = async (c) => {
-	const html = await Bun.file('${htmlPath}').text();
-	const withHmr = html
-		// Fix relative paths to use proxy routes (with or without ./)
-		.replace(/src=["'](?:\\.\\/)?([^"'\\/]+\\.tsx?)["']/g, 'src="/src/web/$1"')
-		// Inject Vite HMR scripts - point directly to Vite asset server for WebSocket
-		.replace(
-			'</head>',
-			\`<script type="module">
-				import RefreshRuntime from '/@react-refresh'
-				RefreshRuntime.injectIntoGlobalHook(window)
-				window.$RefreshReg$ = () => {}
-				window.$RefreshSig$ = () => (type) => type
-			</script>
-			<script type="module">
-				// Configure Vite client to connect to asset server for HMR WebSocket
-				window.__VITE_HMR_BASE_URL__ = 'http://127.0.0.1:${vitePort}';
-			</script>
-			<script type="module" src="http://127.0.0.1:${vitePort}/@vite/client"></script>
-			</head>\`
-		);
-	return c.html(withHmr);
+// Proxy HTML from Vite to let @vitejs/plugin-react handle React Fast Refresh preamble
+const devHtmlHandler = async (c: Context) => {
+	const viteUrl = \`http://127.0.0.1:${vitePort}/src/web/index.html\`;
+
+	try {
+		otel.logger.debug('[Proxy] GET /src/web/index.html -> Vite:%d', ${vitePort});
+		const res = await fetch(viteUrl, { signal: AbortSignal.timeout(10000) });
+
+		// Get HTML text and transform relative paths to absolute
+		const html = await res.text();
+		const transformedHtml = html
+			.replace(/src="\\.\\//g, 'src="/src/web/')
+			.replace(/href="\\.\\//g, 'href="/src/web/');
+
+		return new Response(transformedHtml, {
+			status: res.status,
+			headers: res.headers,
+		});
+	} catch (err) {
+		otel.logger.error('Failed to proxy HTML to Vite: %s', err instanceof Error ? err.message : String(err));
+		return c.text('Vite asset server error (HTML)', 500);
+	}
 };
 app.get('/', devHtmlHandler);
 // 404 for unmatched API/system routes
-app.all('/_agentuity/*', (c) => c.notFound());
-app.all('/api/*', (c) => c.notFound());
-${hasWorkbench ? '' : `app.all('/workbench/*', (c) => c.notFound());`}
-// SPA fallback - serve index.html for all other GET requests
-// This is last so user routes, API routes, and workbench routes match first
-app.get('*', devHtmlHandler);
+app.all('/_agentuity/*', (c: Context) => c.notFound());
+app.all('/api/*', (c: Context) => c.notFound());
+${hasWorkbench ? '' : `app.all('/workbench/*', (c: Context) => c.notFound());`}
+// SPA fallback - serve index.html for client-side routing
+// Asset requests (/*.js, /*.tsx, /*.css, etc.) are handled by Vite proxy routes if present,
+// otherwise we check for file extensions to avoid returning HTML for missing assets
+app.get('*', (c: Context) => {
+	const path = c.req.path;
+	// If path has a file extension and Vite proxy isn't handling it, return 404
+	// This prevents returning HTML for missing assets like /foo.js
+	if (${!vitePort} && /\\.[a-zA-Z0-9]+$/.test(path)) {
+		return c.notFound();
+	}
+	return devHtmlHandler(c);
+});
 `;
 		} else {
 			webRoutes = `
 // Web routes (production - static files)
 import { readFileSync } from 'node:fs';
 const indexHtml = readFileSync(import.meta.dir + '/client/index.html', 'utf-8');
+
+app.get('/', (c: Context) => c.html(indexHtml));
+
+// Serve static assets from /assets/* (Vite bundled output)
 app.use('/assets/*', serveStatic({ root: import.meta.dir + '/client' }));
-app.get('/', (c) => c.html(indexHtml));
-// 404 for unmatched API/system routes
-app.all('/_agentuity/*', (c) => c.notFound());
-app.all('/api/*', (c) => c.notFound());
-${hasWorkbench ? '' : `app.all('/workbench/*', (c) => c.notFound());`}
-// SPA fallback - serve index.html for all other GET requests
-app.get('*', (c) => c.html(indexHtml));
+
+// Serve static public assets (favicon.ico, robots.txt, etc. from Vite's public folder)
+app.use('/*', serveStatic({ root: import.meta.dir + '/client', rewriteRequestPath: (path) => path }));
+
+// 404 for unmatched API/system routes (IMPORTANT: comes before SPA fallback)
+app.all('/_agentuity/*', (c: Context) => c.notFound());
+app.all('/api/*', (c: Context) => c.notFound());
+${hasWorkbench ? '' : `app.all('/workbench/*', (c: Context) => c.notFound());`}
+
+// SPA fallback with asset protection
+// In production, we need to distinguish between:
+//   - SPA routes like /dashboard, /users/123 (should return HTML)
+//   - Missing assets like /foo.js, /bar.css (should return 404)
+// We check for file extensions to detect asset requests
+app.get('*', (c: Context) => {
+	const path = c.req.path;
+	// If path has a file extension, it's likely an asset request
+	// Return 404 instead of serving HTML
+	if (/\\.[a-zA-Z0-9]+$/.test(path)) {
+		return c.notFound();
+	}
+	return c.html(indexHtml);
+});
 `;
 		}
 	}
@@ -265,7 +283,7 @@ app.get('*', (c) => c.html(indexHtml));
 		? isDev
 			? `
 // Workbench route (dev mode - let Vite serve source files with HMR)
-app.get('${workbenchRoute}', async (c) => {
+app.get('${workbenchRoute}', async (c: Context) => {
 	const html = await Bun.file('${workbenchSrcDir}/index.html').text();
 	// Rewrite script/css paths to use Vite's @fs protocol
 	const withVite = html
@@ -281,7 +299,7 @@ import { readFileSync, existsSync } from 'node:fs';
 const workbenchIndexPath = import.meta.dir + '/workbench/index.html';
 if (existsSync(workbenchIndexPath)) {
 	const workbenchIndex = readFileSync(workbenchIndexPath, 'utf-8');
-	app.get('${workbenchRoute}', (c) => c.html(workbenchIndex));
+	app.get('${workbenchRoute}', (c: Context) => c.html(workbenchIndex));
 	app.get('${workbenchRoute}/*', serveStatic({ root: import.meta.dir + '/workbench' }));
 }
 `
@@ -311,16 +329,25 @@ if (typeof Bun !== 'undefined') {
 
 	const code = `// Auto-generated by Agentuity for ${mode} mode
 // DO NOT EDIT - This file is regenerated on every build
-// NOTE: Bun auto-loads .env files from CWD before executing JavaScript
-
 ${imports.join('\n')}
 
-${hmrSetup}
+// Step 0: Bootstrap runtime environment (load profile-specific .env files)
+// Only in development - production env vars are injected by platform
+// This must happen BEFORE any imports that depend on environment variables
+if (process.env.NODE_ENV !== 'production') {
+	// Pass project directory (parent of .agentuity/) so .env files are loaded correctly
+	await bootstrapRuntimeEnv({ projectDir: import.meta.dir + '/..' });
+}
 
 // Step 1: Initialize telemetry and services
 const serverUrl = \`http://127.0.0.1:\${process.env.PORT || '3500'}\`;
 const otel = register({ processors: [], logLevel: (process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel });
-const servicesResult = createServices(otel.logger, undefined, serverUrl);
+
+// Get app state and config for use below
+const appState = getAppState();
+const appConfig = getAppConfig();
+
+createServices(otel.logger, appConfig, serverUrl);
 
 // Make logger and tracer globally available for user's app.ts
 setGlobalLogger(otel.logger);
@@ -350,10 +377,6 @@ app.use('/api/*', createAgentMiddleware(''));
 // Step 4: Import user's app.ts (runs createApp, gets state/config)
 await import('../app.ts');
 
-// Get app state and config for use below
-const appState = getAppState();
-const appConfig = getAppConfig();
-
 // Step 5: Initialize providers
 const threadProvider = getThreadProvider();
 const sessionProvider = getSessionProvider();
@@ -364,8 +387,8 @@ await sessionProvider.initialize(appState);
 // Step 6: Mount routes (AFTER middleware is applied)
 
 // System health/idle endpoints
-const healthHandler = (c: any) => c.text('OK');
-const idleHandler = (c: any) => {
+const healthHandler = (c: Context) => c.text('OK');
+const idleHandler = (c: Context) => {
 	// Check if server is idle (no pending requests/connections)
 	const server = (globalThis as any).__AGENTUITY_SERVER__;
 	if (!server) return c.text('NO', { status: 200 });
@@ -379,7 +402,6 @@ const idleHandler = (c: any) => {
 	return c.text('OK', { status: 200 });
 };
 
-// Mount on both /_agentuity/* and /* for backwards compatibility
 app.get('/_agentuity/health', healthHandler);
 app.get('/_health', healthHandler);
 app.get('/_agentuity/idle', idleHandler);

package/src/cmd/build/vite/bun-dev-server.ts

@@ -6,7 +6,6 @@
  */
 
 import type { Logger } from '../../../types';
-import { startViteAssetServer } from './vite-asset-server';
 
 export interface BunDevServerOptions {
 	rootDir: string;
@@ -15,20 +14,21 @@ export interface BunDevServerOptions {
 	orgId?: string;
 	deploymentId?: string;
 	logger: Logger;
+	vitePort: number; // Port of already-running Vite asset server
 }
 
 export interface BunDevServerResult {
-	viteAssetServer: { server: { close: () => void | Promise<void> }; port: number };
 	bunServerPort: number;
 }
 
 /**
- * Start Bun dev server with Vite asset server for HMR
+ * Start Bun dev server (Vite asset server must already be running)
+ * Generates entry file with proxy routes pointing to Vite
  */
 export async function startBunDevServer(options: BunDevServerOptions): Promise<BunDevServerResult> {
-	const { rootDir, port = 3500, projectId = '', deploymentId = '', logger } = options;
+	const { rootDir, port = 3500, projectId = '', deploymentId = '', logger, vitePort } = options;
 
-	logger.debug('Starting Bun dev server with Vite asset server for HMR...');
+	logger.debug('Starting Bun dev server (Vite already running on port %d)...', vitePort);
 
 	// Generate workbench source files if enabled (dev mode)
 	const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
@@ -41,15 +41,6 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
 	}
 
-	// Step 1: Start Vite asset server FIRST and get its dynamic port
-	logger.debug('🎨 Starting Vite asset server for HMR...');
-	const viteAssetServer = await startViteAssetServer({
-		rootDir,
-		logger,
-		workbenchPath: workbenchConfig.enabled ? workbenchConfig.route : undefined,
-	});
-	const vitePort = viteAssetServer.port;
-
 	// Step 2: Generate entry file with Vite port for asset proxying
 	logger.debug('📝 Generating entry file with asset proxy configuration...');
 	const { generateEntryFile } = await import('../entry-generator');
@@ -66,10 +57,10 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 	// Step 3: Load the generated app - this will start Bun.serve() internally
 	logger.debug('📦 Loading generated app (Bun server will start)...');
 	const appPath = `${rootDir}/.agentuity/app.generated.ts`;
-	
+
 	// Set PORT env var so the generated app uses the correct port
 	process.env.PORT = String(port);
-	
+
 	await import(appPath);
 
 	// Wait for server to actually start listening
@@ -105,11 +96,10 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 		);
 	}
 
-	logger.info(`✅ Bun dev server started on http://127.0.0.1:${port}`);
+	logger.debug(`Bun dev server started on http://127.0.0.1:${port}`);
 	logger.debug(`Asset requests (/@vite/*, /src/web/*, etc.) proxied to Vite:${vitePort}`);
 
 	return {
-		viteAssetServer,
 		bunServerPort: port,
 	};
 }

package/src/cmd/build/vite/index.ts

@@ -11,7 +11,6 @@ import { generateEntryFile } from '../entry-generator';
 import { loadAgentuityConfig, getWorkbenchConfig } from './config-loader';
 
 // Re-export plugins
-export { patchPlugin } from './patch-plugin';
 export { browserEnvPlugin } from './browser-env-plugin';
 
 export interface AgentuityPluginOptions {

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;
@@ -35,18 +37,32 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 	// 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
+	// Load custom externals and define from agentuity.config.ts if it exists
 	const customExternals: string[] = [];
+	let userDefine: Record<string, string> = {};
 	const configPath = join(rootDir, 'agentuity.config.ts');
 	if (await Bun.file(configPath).exists()) {
 		try {
 			const config = await import(configPath);
 			const userConfig = config.default;
+
+			// Load custom externals (legacy build.external support)
 			if (userConfig?.build?.external && Array.isArray(userConfig.build.external)) {
 				customExternals.push(
 					...userConfig.build.external.filter((e: unknown) => typeof e === 'string')
 				);
 			}
+
+			// Load custom define values
+			if (userConfig?.define && typeof userConfig.define === 'object') {
+				userDefine = userConfig.define;
+				if (Object.keys(userDefine).length > 0) {
+					logger.debug(
+						'Loaded %d custom define(s) from agentuity.config.ts for server bundle',
+						Object.keys(userDefine).length
+					);
+				}
+			}
 		} catch (error) {
 			logger.info('Failed to load agentuity.config.ts for externals:', error);
 		}
@@ -188,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/)
@@ -197,6 +246,8 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		minify: !dev,
 		sourcemap: (dev ? 'inline' : 'external') as 'inline' | 'external',
 		external,
+		define: userDefine, // Include custom define values from agentuity.config.ts
+		plugins: [patchPlugin],
 		naming: {
 			entry: 'app.js', // Output as app.js (not app.generated.js)
 		},

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

@@ -24,6 +24,22 @@ export async function generateAssetServerConfig(
 ): Promise<InlineConfig> {
 	const { rootDir, logger, workbenchPath, port } = options;
 
+	// Load custom user config for define values and plugins
+	const { loadAgentuityConfig } = await import('./config-loader');
+	const userConfig = await loadAgentuityConfig(rootDir, logger);
+	const userDefine = userConfig?.define || {};
+	const userPlugins = userConfig?.plugins || [];
+
+	if (Object.keys(userDefine).length > 0) {
+		logger.debug(
+			'Loaded %d custom define(s) from agentuity.config.ts',
+			Object.keys(userDefine).length
+		);
+	}
+	if (userPlugins.length > 0) {
+		logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
+	}
+
 	// Load path aliases from tsconfig.json if available
 	const tsconfigPath = join(rootDir, 'tsconfig.json');
 	let alias = {};
@@ -82,6 +98,9 @@ export async function generateAssetServerConfig(
 
 		// Define environment variables for browser
 		define: {
+			// Merge user-defined constants first
+			...userDefine,
+			// Then add default defines (these will override any user-defined protected keys)
 			...(workbenchPath
 				? { 'import.meta.env.AGENTUITY_PUBLIC_WORKBENCH_PATH': JSON.stringify(workbenchPath) }
 				: {}),
@@ -91,8 +110,10 @@ export async function generateAssetServerConfig(
 			'process.env.NODE_ENV': JSON.stringify('development'),
 		},
 
-		// Minimal plugins - just React and HMR
+		// Plugins: User plugins first (e.g., Tailwind), then React and browser env
 		plugins: [
+			// User-defined plugins from agentuity.config.ts (e.g., Tailwind CSS)
+			...userPlugins,
 			// 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

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

@@ -55,7 +55,7 @@ export async function startViteAssetServer(
 	// 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}`);
+	logger.debug(`✅ Vite asset server started on port ${actualPort}`);
 	if (actualPort !== preferredPort) {
 		logger.debug(`Port ${preferredPort} was taken, using ${actualPort} instead`);
 	}

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 {
@@ -54,7 +53,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 				logger,
 			});
 		} catch (error) {
-			logger.error('server-bundler import or execution failed:', error);
+			logger.error('server-bundler import or execution failed: %s', error);
 			throw error;
 		}
 		return;
@@ -76,7 +75,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 || [];
@@ -85,6 +84,15 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
 		}
 
+		// Merge custom define values from user config
+		const userDefine = userConfig?.define || {};
+		if (Object.keys(userDefine).length > 0) {
+			logger.debug(
+				'Loaded %d custom define(s) from agentuity.config.ts',
+				Object.keys(userDefine).length
+			);
+		}
+
 		// Determine CDN base URL for production builds
 		const isLocalRegion = options.region === 'local';
 		const cdnBaseUrl =
@@ -99,6 +107,9 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			publicDir: join(rootDir, 'src', 'web', 'public'),
 			base: cdnBaseUrl, // CDN URL for production assets
 			define: {
+				// Merge user-defined constants first
+				...userDefine,
+				// Then add default defines (these will override any user-defined protected keys)
 				// Set workbench path if enabled (use import.meta.env for client code)
 				'import.meta.env.AGENTUITY_PUBLIC_WORKBENCH_PATH': workbenchEnabled
 					? JSON.stringify(workbenchRoute)
@@ -121,11 +132,26 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		// Ensure route ends with / for Vite base
 		const base = workbenchRoute.endsWith('/') ? workbenchRoute : `${workbenchRoute}/`;
 
+		// Load custom user config for define values (same as client mode)
+		const { loadAgentuityConfig } = await import('./config-loader');
+		const userConfig = await loadAgentuityConfig(rootDir, logger);
+		const userDefine = userConfig?.define || {};
+		if (Object.keys(userDefine).length > 0) {
+			logger.debug(
+				'Loaded %d custom define(s) from agentuity.config.ts for workbench',
+				Object.keys(userDefine).length
+			);
+		}
+
 		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
+				...userDefine,
+			},
 			build: {
 				outDir: join(rootDir, '.agentuity/workbench'),
 				rollupOptions: {

package/src/cmd/cloud/deploy.ts

@@ -4,6 +4,7 @@ import { createPublicKey } from 'node:crypto';
 import { createReadStream, createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { StructuredError } from '@agentuity/core';
+import { isRunningFromExecutable } from '../upgrade';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { saveProjectDir, getDefaultConfigDir } from '../../config';
@@ -335,33 +336,49 @@ export const deploySubcommand = createSubcommand({
 									);
 								}
 
-								const promises: Promise<Response>[] = [];
-								for (const asset of build.assets) {
-									const assetUrl = instructions.assets[asset.filename];
-									if (!assetUrl) {
-										return stepError(
-											`server did not provide upload URL for asset "${asset.filename}"; upload aborted`
-										);
-									}
+								// Workaround for Bun crash in compiled executables (https://github.com/agentuity/sdk/issues/191)
+								// Use limited concurrency (2 at a time) for executables to avoid parallel fetch crash
+								const isExecutable = isRunningFromExecutable();
+								const concurrency = isExecutable ? 2 : build.assets.length;
 
-									// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
-									const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
-									promises.push(
-										fetch(assetUrl, {
-											method: 'PUT',
-											duplex: 'half',
-											headers: {
-												'Content-Type': asset.contentType,
-											},
-											body: file,
-										})
+								if (isExecutable) {
+									ctx.logger.trace(
+										`Running from executable - using limited concurrency (${concurrency} uploads at a time)`
 									);
 								}
-								ctx.logger.trace('Waiting for asset uploads');
-								const resps = await Promise.all(promises);
-								for (const r of resps) {
-									if (!r.ok) {
-										return stepError(`error uploading asset: ${await r.text()}`);
+
+								// Process assets in batches with limited concurrency
+								for (let i = 0; i < build.assets.length; i += concurrency) {
+									const batch = build.assets.slice(i, i + concurrency);
+									const promises: Promise<Response>[] = [];
+
+									for (const asset of batch) {
+										const assetUrl = instructions.assets[asset.filename];
+										if (!assetUrl) {
+											return stepError(
+												`server did not provide upload URL for asset "${asset.filename}"; upload aborted`
+											);
+										}
+
+										// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
+										const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
+										promises.push(
+											fetch(assetUrl, {
+												method: 'PUT',
+												duplex: 'half',
+												headers: {
+													'Content-Type': asset.contentType,
+												},
+												body: file,
+											})
+										);
+									}
+
+									const resps = await Promise.all(promises);
+									for (const r of resps) {
+										if (!r.ok) {
+											return stepError(`error uploading asset: ${await r.text()}`);
+										}
 									}
 								}
 								ctx.logger.trace('Asset uploads complete');