@agentuity/cli 1.0.59 → 2.0.0-beta.1

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

@@ -5,48 +5,11 @@
  */
 
 import { join } from 'node:path';
-import { existsSync, renameSync, rmSync } from 'node:fs';
-import { createRequire } from 'node:module';
-import type { InlineConfig, Plugin } from 'vite';
+import { existsSync, rmSync } from 'node:fs';
+import type { InlineConfig } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
-import { browserEnvPlugin } from './browser-env-plugin';
-import { tailwindSourcePlugin } from './tailwind-source-plugin';
-import { beaconPlugin } from './beacon-plugin';
-import { publicAssetPathPlugin } from './public-asset-path-plugin';
 import type { BuildReportCollector } from '../../../build-report';
 
-/**
- * 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';
@@ -75,25 +38,7 @@ export interface ViteBuildOptions {
  * 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,
-		profile,
-	} = options;
-
-	const isViteDebug =
-		process.env.AGENTUITY_VITE_DEBUG === '1' || process.env.AGENTUITY_VITE_DEBUG === 'true';
-	if (isViteDebug) {
-		logger.debug('Vite debug logging enabled via AGENTUITY_VITE_DEBUG');
-		const existing = process.env.DEBUG || '';
-		if (!existing.includes('vite:')) {
-			process.env.DEBUG = existing ? `${existing},vite:*` : 'vite:*';
-		}
-	}
+	const { rootDir, mode, dev = false, logger, profile } = options;
 
 	logger.debug(`Running Vite build for mode: ${mode}`);
 
@@ -126,24 +71,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			profile,
 		});
 
-		// Load workbench config for entry file generation
-		const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
-		const config = await loadAgentuityConfig(rootDir, logger);
-		const workbenchConfig = getWorkbenchConfig(config, dev);
-
-		// Then, generate the entry file
-		const { generateEntryFile } = await import('../entry-generator');
-		await generateEntryFile({
-			rootDir,
-			projectId,
-			deploymentId: deploymentId || '',
-			logger,
-			mode: dev ? 'dev' : 'prod',
-			workbench: workbenchConfig.configured ? workbenchConfig : undefined,
-			analytics: config?.analytics,
-		});
-
-		// Finally, build with Bun.build
+		// Build with Bun.build (app.ts is the entrypoint)
 		const { installExternalsAndBuild } = await import('./server-bundler');
 		await installExternalsAndBuild({
 			rootDir,
@@ -153,137 +81,56 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		return;
 	}
 
-	// Dynamically import vite and react plugin
-	// Try project's node_modules first (for custom vite configs), fall back to CLI's
-	const projectRequire = createRequire(join(rootDir, 'package.json'));
-	let vitePath = 'vite';
-	let reactPluginPath = '@vitejs/plugin-react';
-	try {
-		vitePath = projectRequire.resolve('vite');
-		reactPluginPath = projectRequire.resolve('@vitejs/plugin-react');
-	} catch {
-		// Project doesn't have vite, use CLI's bundled version
-	}
-	const { build: viteBuild } = await import(vitePath);
-	const reactModule = await import(reactPluginPath);
-	const react = reactModule.default;
+	// Dynamically import vite for workbench builds
+	const { build: viteBuild } = await import('vite');
 
-	// For client/workbench, use inline config (no agentuity plugin needed)
+	// For client/workbench, use inline config with vite.config.ts loading
 	let viteConfig: InlineConfig;
 
 	if (mode === 'client') {
-		// Vite needs index.html as entry point for web apps
-		const htmlPath = join(rootDir, 'src', 'web', 'index.html');
-
-		// Use workbench config passed from runAllBuilds
-		const {
-			workbenchEnabled = false,
-			workbenchRoute = '/workbench',
-			analyticsEnabled = false,
-		} = options;
-
-		// 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.storageapi.dev'
-			: 'cdn.agentuity.com';
-		const cdnBaseUrl =
-			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;
-
-		// Load custom user plugins from agentuity.config.ts if it exists
+		// For client builds, spawn vite as a subprocess.
+		// This avoids issues with Bun's module loading that cause problems
+		// with certain plugins like @sveltejs/vite-plugin-svelte.
+		// The vite.config.ts in the project handles all configuration.
+		const buildMode = dev ? 'development' : 'production';
 		const clientOutDir = join(rootDir, '.agentuity/client');
-		const { loadAgentuityConfig, hasFrameworkPlugin } = await import('./config-loader');
-		const userConfig = await loadAgentuityConfig(rootDir, logger);
-		const userPlugins = userConfig?.plugins || [];
-
-		// Auto-add React plugin if no framework plugin is present (backwards compatibility)
-		if (userPlugins.length === 0 || !hasFrameworkPlugin(userPlugins)) {
-			logger.debug(
-				'No framework plugin found in agentuity.config.ts plugins, adding React automatically'
-			);
-			userPlugins.unshift(react());
-		}
 
-		if (userPlugins.length > 0) {
-			logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
-		}
+		logger.debug('Spawning vite build for client (subprocess mode)');
+		logger.debug('  outDir: %s', clientOutDir);
+		logger.debug('  mode: %s', buildMode);
+
+		const viteProcess = Bun.spawn(
+			['bun', 'x', 'vite', 'build', '--mode', buildMode, '--outDir', clientOutDir],
+			{
+				cwd: rootDir,
+				stdout: 'inherit',
+				stderr: 'inherit',
+			}
+		);
 
-		const plugins = [
-			tailwindSourcePlugin(),
-			...userPlugins,
-			browserEnvPlugin(),
-			// Fix incorrect public asset paths and rewrite to CDN URLs
-			publicAssetPathPlugin({ cdnBaseUrl }),
-			flattenHtmlOutputPlugin(clientOutDir),
-			// Emit analytics beacon as hashed CDN asset (prod builds only)
-			beaconPlugin({ enabled: analyticsEnabled && !dev }),
-		];
-
-		// 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
-			);
+		const exitCode = await viteProcess.exited;
+
+		if (exitCode !== 0) {
+			throw new Error(`Vite build exited with code ${exitCode}`);
 		}
 
-		viteConfig = {
-			// 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'),
-			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)
-					: 'undefined',
-			},
-			build: {
-				outDir: clientOutDir,
-				rollupOptions: {
-					input: htmlPath,
-				},
-				manifest: true,
-				emptyOutDir: true,
-				// Copy public files to output for CDN upload (production builds only)
-				// In dev mode, Vite serves them directly from src/web/public/
-				copyPublicDir: !dev,
-			},
-			logLevel: isViteDebug ? 'info' : 'warn',
-		};
+		logger.debug('Vite build complete for mode: client');
+		return;
 	} else if (mode === 'workbench') {
 		const { workbenchRoute = '/workbench' } = options;
 		// 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
-			);
-		}
+		// Workbench is built with React (internal UI)
+		// Use CLI's bundled React plugin since workbench is our code
+		const reactModule = await import('@vitejs/plugin-react');
+		const react = reactModule.default;
 
 		viteConfig = {
 			root: join(rootDir, '.agentuity/workbench-src'), // Use generated workbench source
 			base, // All workbench assets are under the configured route
 			plugins: [react()],
 			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
-			define: {
-				// Merge user-defined constants
-				...userDefine,
-			},
 			build: {
 				outDir: join(rootDir, '.agentuity/workbench'),
 				rollupOptions: {
@@ -292,14 +139,13 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 				manifest: true,
 				emptyOutDir: true,
 			},
-			logLevel: isViteDebug ? 'info' : 'warn',
+			logLevel: 'warn',
 		};
 	} else {
 		throw new Error(`Unknown build mode: ${mode}`);
 	}
 
-	// Build with Vite
-	// Force the build to use the correct mode
+	// For workbench mode, use programmatic vite build
 	const buildMode = dev ? 'development' : 'production';
 
 	await viteBuild({
@@ -334,21 +180,11 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		static: { included: false, duration: 0, routes: 0 },
 	};
 
-	// Load config to check if workbench is enabled (dev mode only)
-	const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
-	const config = await loadAgentuityConfig(rootDir, logger);
-
-	// Copy bundle files if configured (before build so build output takes priority)
-	if (config?.bundle?.length) {
-		const { copyBundleFiles } = await import('./bundle-files');
-		const outDir = join(rootDir, '.agentuity');
-		const count = await copyBundleFiles(rootDir, outDir, config.bundle, logger);
-		if (count > 0) {
-			logger.debug(`Copied ${count} bundle file(s) to .agentuity`);
-		}
-	}
+	// Load runtime config from createApp() in app.ts (v2 approach)
+	const { getWorkbenchConfig, loadRuntimeConfig } = await import('./config-loader');
+	const runtimeConfig = await loadRuntimeConfig(rootDir, logger);
 
-	const workbenchConfig = getWorkbenchConfig(config, dev);
+	const workbenchConfig = getWorkbenchConfig(dev, runtimeConfig);
 	// Generate workbench files BEFORE any builds if enabled (dev mode only)
 	if (workbenchConfig.enabled) {
 		logger.debug('Workbench enabled (dev mode), generating files before build...');
@@ -358,7 +194,6 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 
 	// 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');
 
@@ -369,24 +204,18 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		options.deploymentId || '',
 		logger
 	);
-	const { routes, routeInfoList } = await discoverRoutes(
-		srcDir,
-		projectId,
-		options.deploymentId || '',
-		logger
-	);
+	const { routes } = 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);
-	await generateRouteRegistry(srcDir, routeInfoList);
-	logger.debug('Agent and route registries generated');
+	// Agent metadata is used for metadata.json generation (no registry codegen needed)
 
 	// Check if web frontend exists
 	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
 
 	// Check if analytics is enabled
-	const analyticsEnabled = config?.analytics !== false;
+	// v2: analytics config comes from createApp()
+	const analyticsFromRuntime = runtimeConfig?.analytics;
+	const analyticsEnabled =
+		analyticsFromRuntime !== undefined ? analyticsFromRuntime !== false : true;
 
 	// 2. Build client (only if web frontend exists)
 	if (hasWebFrontend) {
@@ -407,15 +236,15 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Skipping client build - no src/web/index.html found');
 	}
 
-	// 2b. Static rendering (if configured)
-	if (config?.render === 'static' && hasWebFrontend) {
+	// 2b. Static rendering (if entry-server.tsx exists)
+	const entryServerPath = join(rootDir, 'src', 'web', 'entry-server.tsx');
+	if (existsSync(entryServerPath) && hasWebFrontend) {
 		logger.debug('Running static rendering (pre-rendering all routes)...');
 		const endStaticDiagnostic = collector?.startDiagnostic('static-render');
 		const { runStaticRender } = await import('./static-renderer');
 		const staticResult = await runStaticRender({
 			rootDir,
 			logger,
-			userPlugins: config?.plugins || [],
 		});
 		result.static.included = true;
 		result.static.duration = staticResult.duration;

package/src/cmd/build/vite/ws-proxy.ts

@@ -0,0 +1,126 @@
+/**
+ * WebSocket-aware front-door TCP proxy for dev mode.
+ *
+ * Bun's node:http has several bugs that prevent Vite's built-in http-proxy
+ * from proxying WebSocket upgrades (see linked PRs). Rather than polyfilling
+ * those bugs, this module places a lightweight `net.createServer` on the
+ * user-facing port. It inspects the first bytes of each TCP connection and
+ * routes accordingly:
+ *
+ * - **WebSocket upgrades to backend paths** → piped directly to Bun backend
+ *   (Bun's native `server.upgrade()` works perfectly over raw TCP)
+ * - **Everything else** (HTTP requests, Vite HMR WebSocket) → piped to Vite
+ *
+ * From the browser's perspective there is only one port. Vite and Bun both
+ * listen on internal ports that are never exposed.
+ *
+ * Bun bugs this works around:
+ * - https://github.com/oven-sh/bun/pull/27237 (socket.write drops data)
+ * - https://github.com/oven-sh/bun/pull/26264 (missing destroySoon)
+ * - https://github.com/oven-sh/bun/pull/27859 (http.request upgrade event)
+ * - Server-side upgrade socket read broken (HTTP parser doesn't hand off)
+ *
+ * This entire module can be removed once those Bun PRs are merged and the
+ * Vite `ws: true` proxy works natively under Bun.
+ *
+ * ```
+ * Browser ──TCP──▶ net.Server (:3500, user-facing)
+ *                     │
+ *         ┌───────────┴───────────┐
+ *         ▼ (WS upgrade to       ▼ (everything else)
+ *          backend paths)
+ *   Bun backend (:3501)    Vite server (:3502)
+ * ```
+ */
+
+import { createServer, connect, type Server } from 'node:net';
+import type { Logger } from '../../../types';
+
+export interface WsProxyOptions {
+	/** Port the front-door proxy listens on (user-facing) */
+	port: number;
+	/** Port of the Vite dev server (internal) */
+	vitePort: number;
+	/** Port of the Bun backend server (internal) */
+	backendPort: number;
+	/** Route path prefixes that should be proxied to the backend */
+	routePaths: string[];
+	logger: Logger;
+}
+
+/**
+ * Start a front-door TCP proxy that routes WebSocket upgrades to the Bun
+ * backend and everything else to Vite. Returns the `net.Server` instance.
+ */
+export function startWsProxy(options: WsProxyOptions): Promise<Server> {
+	const { port, vitePort, backendPort, routePaths, logger } = options;
+
+	// Prefixes whose WebSocket upgrades go to Bun instead of Vite
+	const wsPathPrefixes = ['/_agentuity', ...routePaths];
+
+	return new Promise((resolve, reject) => {
+		const server = createServer((socket) => {
+			let handled = false;
+
+			// Peek at the first chunk to decide where to route
+			socket.once('data', (firstChunk) => {
+				handled = true;
+
+				const header = firstChunk.toString('utf8', 0, Math.min(firstChunk.length, 4096));
+
+				// Detect: is this a WebSocket upgrade for a backend path?
+				const isUpgrade = /upgrade:\s*websocket/i.test(header);
+				let targetPort = vitePort;
+
+				if (isUpgrade) {
+					const pathMatch = header.match(/^(?:GET|POST)\s+(\S+)/);
+					const pathname = (pathMatch?.[1] ?? '/').split('?')[0] ?? '/';
+
+					const isBackendPath = wsPathPrefixes.some(
+						(prefix) => pathname === prefix || pathname.startsWith(prefix + '/')
+					);
+
+					if (isBackendPath) {
+						targetPort = backendPort;
+						logger.debug('WS upgrade %s → Bun :%d', pathname, backendPort);
+					}
+				}
+
+				const target = connect(targetPort, '127.0.0.1');
+
+				target.on('connect', () => {
+					target.write(firstChunk);
+					socket.pipe(target);
+					target.pipe(socket);
+				});
+
+				target.on('error', () => {
+					if (!socket.destroyed) socket.destroy();
+				});
+				socket.on('error', () => {
+					if (!target.destroyed) target.destroy();
+				});
+			});
+
+			// Client disconnected before sending anything
+			socket.on('close', () => {
+				if (!handled) socket.destroy();
+			});
+			socket.on('error', () => {
+				if (!handled) socket.destroy();
+			});
+		});
+
+		server.on('error', reject);
+
+		server.listen(port, '127.0.0.1', () => {
+			logger.debug(
+				'WS front-door proxy on :%d (Vite :%d, Bun :%d)',
+				port,
+				vitePort,
+				backendPort
+			);
+			resolve(server);
+		});
+	});
+}

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

@@ -10,7 +10,6 @@ import { StructuredError } from '@agentuity/core';
 import type { Logger, DeployOptions } from '../../types';
 import { runAllBuilds } from './vite/vite-builder';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
-import { promptRouteMigration } from '../../utils/route-migration';
 import { checkBunVersion } from '../../utils/bun-version-checker';
 import * as tui from '../../tui';
 import type { BuildReportCollector } from '../../build-report';
@@ -90,9 +89,6 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 		});
 	}
 
-	// Check if project can migrate from file-based to explicit routing
-	await promptRouteMigration(rootDir, logger);
-
 	try {
 		// Run all builds (client -> workbench -> server)
 		logger.debug('Starting builds...');

package/src/cmd/cloud/deploy-fork.ts

@@ -13,7 +13,7 @@
 import { spawn, type Subprocess } from 'bun';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
-import { appendFileSync, createWriteStream, existsSync, readFileSync, unlinkSync } from 'node:fs';
+import { existsSync, readFileSync, unlinkSync } from 'node:fs';
 import type { APIClient } from '../../api';
 import { getUserAgent } from '../../api';
 import { isUnicode } from '../../tui/symbols';
@@ -37,14 +37,12 @@ export interface ForkDeployResult {
 }
 
 /**
- * Stream data to a Pulse stream URL.
- * Accepts a string, Blob/BunFile, or ReadableStream as the body to avoid
- * loading large outputs into memory.
+ * Stream data to a Pulse stream URL
  */
 async function streamToPulse(
 	streamURL: string,
 	sdkKey: string,
-	data: string | Blob | ReadableStream<Uint8Array>,
+	data: string,
 	logger: Logger
 ): Promise<void> {
 	try {
@@ -76,8 +74,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 	const buildLogsStreamURL = deployment.buildLogsStreamURL;
 	const reportFile = join(tmpdir(), `agentuity-deploy-${deploymentId}.json`);
 	const cleanLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-logs.txt`);
-	const rawLogsFile = join(tmpdir(), `agentuity-deploy-${deploymentId}-raw.txt`);
-	const rawLogsWriter = createWriteStream(rawLogsFile);
+	let outputBuffer = '';
 	let proc: Subprocess | null = null;
 	let cancelled = false;
 
@@ -198,6 +195,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 
 		const handleOutput = async (stream: ReadableStream<Uint8Array>, isStderr: boolean) => {
 			const reader = stream.getReader();
+			const decoder = new TextDecoder();
 			const target = isStderr ? process.stderr : process.stdout;
 
 			try {
@@ -205,9 +203,8 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 					const { done, value } = await reader.read();
 					if (done) break;
 
-					// Stream raw bytes to disk instead of accumulating in memory.
-					// This prevents OOM / ERR_STRING_TOO_LONG crashes on large builds.
-					rawLogsWriter.write(value);
+					const text = decoder.decode(value, { stream: true });
+					outputBuffer += text;
 					target.write(value);
 				}
 			} catch (err) {
@@ -226,11 +223,6 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 
 		await Promise.all([stdoutPromise, stderrPromise]);
 
-		// Close the raw logs writer so the file is fully flushed before reading
-		await new Promise<void>((resolve) => {
-			rawLogsWriter.end(resolve);
-		});
-
 		const exitCode = await proc.exited;
 		logger.debug('Child process exited with code: %d', exitCode);
 
@@ -257,11 +249,12 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 					logger.debug('Failed to read clean logs file: %s', err);
 				}
 			}
+			// Fall back to raw output if no clean logs
+			if (!logsContent && outputBuffer) {
+				logsContent = outputBuffer;
+			}
 			if (logsContent) {
 				await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
-			} else if (existsSync(rawLogsFile)) {
-				// Stream raw logs file directly to Pulse without loading into memory
-				await streamToPulse(buildLogsStreamURL, sdkKey, Bun.file(rawLogsFile), logger);
 			}
 		}
 
@@ -314,27 +307,11 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 					// ignore
 				}
 			}
-			if (logsContent) {
-				logsContent += `\n\n--- FORK ERROR ---\n${errorMessage}\n`;
-				await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
-			} else {
-				// Append error to raw logs file and stream it without loading into memory
-				try {
-					appendFileSync(rawLogsFile, `\n\n--- FORK ERROR ---\n${errorMessage}\n`);
-				} catch {
-					// ignore — file may not exist if child never produced output
-				}
-				if (existsSync(rawLogsFile)) {
-					await streamToPulse(buildLogsStreamURL, sdkKey, Bun.file(rawLogsFile), logger);
-				} else {
-					await streamToPulse(
-						buildLogsStreamURL,
-						sdkKey,
-						`--- FORK ERROR ---\n${errorMessage}\n`,
-						logger
-					);
-				}
+			if (!logsContent) {
+				logsContent = outputBuffer;
 			}
+			logsContent += `\n\n--- FORK ERROR ---\n${errorMessage}\n`;
+			await streamToPulse(buildLogsStreamURL, sdkKey, logsContent, logger);
 		}
 
 		try {
@@ -383,7 +360,7 @@ export async function runForkedDeploy(options: ForkDeployOptions): Promise<ForkD
 		process.off('SIGTERM', sigtermHandler);
 
 		// Clean up temp files
-		for (const file of [reportFile, cleanLogsFile, rawLogsFile]) {
+		for (const file of [reportFile, cleanLogsFile]) {
 			if (existsSync(file)) {
 				try {
 					unlinkSync(file);