@agentuity/cli 0.0.69 → 0.0.71

package/src/cmd/build/bundler.ts

@@ -1,14 +1,13 @@
 import { $ } from 'bun';
 import { join, relative, resolve, dirname, basename } from 'node:path';
-import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
 import { getFilesRecursively } from './file';
 import { getVersion } from '../../version';
 import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
-import { createLogger } from '@agentuity/server';
-import type { LogLevel } from '../../types';
+import type { Logger } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
 import { analyzeWorkbench } from './ast';
 import { StructuredError } from '@agentuity/core';
@@ -27,6 +26,8 @@ export interface BundleOptions extends DeployOptions {
 	project?: Project;
 	port?: number;
 	outDir?: string;
+	region: string;
+	logger: Logger;
 }
 
 type BuildResult = Awaited<ReturnType<typeof Bun.build>>;
@@ -73,6 +74,8 @@ export async function bundle({
 	pullRequestURL,
 	message,
 	env,
+	region,
+	logger,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
@@ -148,6 +151,101 @@ export async function bundle({
 		}
 	}
 
+	// Common externals for native modules (same as legacy CLI)
+	const commonExternals = ['bun', 'fsevents', 'chromium-bidi', 'sharp'];
+
+	// OpenTelemetry packages need to be externalized due to CommonJS/ESM hybrid issues
+	const otelExternals = ['@opentelemetry/*', '@traceloop/*'];
+
+	// Allow projects to specify custom externals via package.json "externals" field
+	const customExternals: string[] = [];
+	if (pkgContents.externals && Array.isArray(pkgContents.externals)) {
+		customExternals.push(...pkgContents.externals.filter((e: unknown) => typeof e === 'string'));
+	}
+
+	const externalPatterns = [...commonExternals, ...otelExternals, ...customExternals];
+
+	// For production builds: install externals FIRST, then discover full dependency tree
+	// This prevents bundling dependencies that will be in node_modules anyway
+	let external = externalPatterns;
+	if (!dev) {
+		logger.debug('Installing externalized packages to discover full dependency tree...');
+
+		// Step 1: Collect packages matching external patterns
+		const externalInstalls: string[] = [];
+		for (const pattern of externalPatterns) {
+			if (pattern.endsWith('/*')) {
+				const prefix = pattern.slice(0, -2);
+				const nmDir = join(rootDir, 'node_modules', prefix);
+				if (existsSync(nmDir)) {
+					const entries = readdirSync(nmDir);
+					for (const entry of entries) {
+						const pkgName = `${prefix}/${entry}`;
+						if (existsSync(join(rootDir, 'node_modules', pkgName))) {
+							externalInstalls.push(pkgName);
+						}
+					}
+				}
+			} else {
+				if (existsSync(join(rootDir, 'node_modules', pattern))) {
+					externalInstalls.push(pattern);
+				}
+			}
+		}
+
+		// Step 2: Write minimal package.json and install externals
+		if (externalInstalls.length > 0) {
+			await Bun.write(
+				`${outDir}/package.json`,
+				JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+			);
+
+			logger.debug(
+				'Installing %d packages: %s',
+				externalInstalls.length,
+				externalInstalls.join(', ')
+			);
+			await $`bun install --no-save --ignore-scripts --target=bun-linux-x64 ${externalInstalls}`
+				.cwd(outDir)
+				.quiet();
+
+			// Step 3: Scan what actually got installed (includes transitive dependencies)
+			const installedNmDir = join(outDir, 'node_modules');
+			if (existsSync(installedNmDir)) {
+				const allInstalled: string[] = [];
+
+				// Recursively find all installed packages
+				const scanDir = (dir: string, prefix = '') => {
+					const entries = readdirSync(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)
+							if (existsSync(join(dir, entry.name, 'package.json'))) {
+								allInstalled.push(pkgName);
+							}
+
+							// Recurse into scoped packages (@org/package)
+							if (entry.name.startsWith('@')) {
+								scanDir(join(dir, entry.name), entry.name);
+							}
+						}
+					}
+				};
+
+				scanDir(installedNmDir);
+				logger.debug(
+					'Discovered %d total packages (including dependencies)',
+					allInstalled.length
+				);
+
+				// Step 4: Use ALL installed packages as externals for bundling
+				external = allInstalled;
+			}
+		}
+	}
+
 	await (async () => {
 		const config: Bun.BuildConfig = {
 			entrypoints: appEntrypoints,
@@ -166,6 +264,7 @@ export async function bundle({
 			drop: isProd ? ['debugger'] : undefined,
 			splitting: true,
 			conditions: [isProd ? 'production' : 'development', 'bun'],
+			external,
 			naming: {
 				entry: '[dir]/[name].[ext]',
 				chunk: 'chunk/[name]-[hash].[ext]',
@@ -259,6 +358,7 @@ export async function bundle({
 				mkdirSync(webOutDir, { recursive: true });
 				mkdirSync(join(webOutDir, 'chunk'), { recursive: true });
 				mkdirSync(join(webOutDir, 'asset'), { recursive: true });
+				const isLocalRegion = region === 'local' || region === 'l';
 
 				const config: Bun.BuildConfig = {
 					entrypoints: webEntrypoints,
@@ -276,8 +376,10 @@ export async function bundle({
 					splitting: true,
 					packages: 'bundle',
 					external: workspaceRoot !== rootDir ? [] : undefined,
+					// Ensure React is resolved from the consuming app's node_modules
+					conditions: ['browser', 'import', 'default'],
 					publicPath:
-						isProd && deploymentId
+						isProd && deploymentId && !isLocalRegion
 							? `https://static.agentuity.com/${deploymentId}/`
 							: undefined,
 					naming: {
@@ -323,7 +425,6 @@ export async function bundle({
 			// Create workbench config with proper defaults
 			const defaultConfig = { route: '/workbench', headers: {}, port: port || 3500 };
 			const config = { ...defaultConfig, ...analysis.config };
-			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			try {
 				// Generate workbench files on the fly instead of using files from package
 				const tempWorkbenchDir = join(outDir, 'temp-workbench');
@@ -564,13 +665,26 @@ export async function bundle({
 		}
 	}
 
-	await Bun.write(
-		`${outDir}/package.json`,
-		JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
-	);
+	// Write minimal package.json for dev mode (production already wrote it above)
+	if (dev) {
+		await Bun.write(
+			`${outDir}/package.json`,
+			JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+		);
+	}
 
 	await Bun.write(
 		`${outDir}/agentuity.metadata.json`,
 		dev ? JSON.stringify(buildmetadata, null, 2) : JSON.stringify(buildmetadata)
 	);
+
+	// Generate route mapping file for runtime route tracking
+	const routeMapping: Record<string, string> = {};
+	for (const route of buildmetadata.routes ?? []) {
+		routeMapping[`${route.method} ${route.path}`] = route.id;
+	}
+	await Bun.write(
+		`${outDir}/.routemapping.json`,
+		dev ? JSON.stringify(routeMapping, null, 2) : JSON.stringify(routeMapping)
+	);
 }

package/src/cmd/build/index.ts

@@ -56,7 +56,6 @@ export const command = createCommand({
 				env.set('AGENTUITY_TRANSPORT_URL', serviceUrls.catalyst);
 				env.set('AGENTUITY_CATALYST_URL', serviceUrls.catalyst);
 				env.set('AGENTUITY_VECTOR_URL', serviceUrls.vector);
-				env.set('AGENTUITY_OBJECTSTORE_URL', serviceUrls.objectstore);
 				env.set('AGENTUITY_KEYVALUE_URL', serviceUrls.keyvalue);
 				env.set('AGENTUITY_STREAM_URL', serviceUrls.stream);
 				env.set('AGENTUITY_CLOUD_ORG_ID', project.orgId);
@@ -74,6 +73,8 @@ export const command = createCommand({
 				orgId: project?.orgId,
 				projectId: project?.projectId,
 				env,
+				region: project?.region ?? 'local',
+				logger: ctx.logger,
 			});
 
 			// Run TypeScript type checking after registry generation (skip in dev mode)