@agentuity/cli 0.0.86 → 0.0.88

package/src/cmd/build/bundler.ts

@@ -1,6 +1,6 @@
 import { $, semver } from 'bun';
 import { join, relative, resolve, dirname, basename } from 'node:path';
-import { cpSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, rmSync, readdirSync, readFileSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import { StructuredError } from '@agentuity/core';
 import * as tui from '../../tui';
@@ -10,10 +10,12 @@ import { getFilesRecursively } from './file';
 import { getVersion } from '../../version';
 import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
-import type { Logger } from '../../types';
+import type { Logger, BuildContext } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench';
 import { analyzeWorkbench, type WorkbenchAnalysis } from './ast';
 import { type DeployOptions } from '../../schemas/deploy';
+import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
+import { loadBuildConfig, executeBuildConfig, mergeBuildConfig } from './config-loader';
 
 const minBunVersion = '>=1.3.3';
 
@@ -78,6 +80,77 @@ const InvalidBunVersion = StructuredError('InvalidBunVersion')<{
 	required: string;
 }>();
 
+/**
+ * Finds the workspace root by walking up the directory tree looking for a package.json with workspaces
+ */
+function findWorkspaceRoot(startDir: string): string | null {
+	let currentDir = startDir;
+	while (true) {
+		const pkgPath = join(currentDir, 'package.json');
+		if (existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+				if (pkg.workspaces) {
+					return currentDir;
+				}
+			} catch {
+				// Ignore parse errors, continue searching
+			}
+		}
+		const parent = resolve(currentDir, '..');
+		if (parent === currentDir) break; // reached filesystem root
+		currentDir = parent;
+	}
+	return null;
+}
+
+/**
+ * Finds a package by searching multiple locations:
+ * 1. App-level node_modules
+ * 2. Workspace root node_modules
+ * 3. Workspace packages directory (for workspace packages)
+ *
+ * @param rootDir - Root directory of the project
+ * @param packageName - Package name (e.g., '@agentuity/workbench')
+ * @param logger - Optional logger for debug messages
+ * @returns Path to the package directory, or null if not found
+ */
+function findPackagePath(rootDir: string, packageName: string, logger?: Logger): string | null {
+	const [scope, name] = packageName.startsWith('@')
+		? packageName.slice(1).split('/')
+		: [null, packageName];
+
+	// 1. Try app-level node_modules
+	const appLevelPath = scope
+		? join(rootDir, 'node_modules', `@${scope}`, name)
+		: join(rootDir, 'node_modules', name);
+	if (existsSync(appLevelPath)) {
+		logger?.debug(`Found ${packageName} at app level: ${appLevelPath}`);
+		return appLevelPath;
+	}
+
+	// 2. Try workspace root node_modules
+	const workspaceRoot = findWorkspaceRoot(rootDir);
+	if (workspaceRoot) {
+		const rootLevelPath = scope
+			? join(workspaceRoot, 'node_modules', `@${scope}`, name)
+			: join(workspaceRoot, 'node_modules', name);
+		if (existsSync(rootLevelPath)) {
+			logger?.debug(`Found ${packageName} at workspace root: ${rootLevelPath}`);
+			return rootLevelPath;
+		}
+
+		// 3. Try workspace packages directory
+		const workspacePackagePath = join(workspaceRoot, 'packages', name);
+		if (existsSync(workspacePackagePath)) {
+			logger?.debug(`Found ${packageName} in workspace packages: ${workspacePackagePath}`);
+			return workspacePackagePath;
+		}
+	}
+
+	return null;
+}
+
 const handleBuildFailure = (buildResult: BuildResult) => {
 	// Collect all build errors with full details
 	const errorMessages = buildResult.logs
@@ -130,6 +203,14 @@ export async function bundle({
 	const versionOutput = await checkBunVersion();
 	output.push(...versionOutput);
 
+	// Check and upgrade @agentuity/* dependencies if needed
+	const upgradeResult = await checkAndUpgradeDependencies(rootDir, logger);
+	if (upgradeResult.failed.length > 0 && process.stdin.isTTY) {
+		throw new BuildFailedError({
+			message: `Failed to upgrade dependencies: ${upgradeResult.failed.join(', ')}`,
+		});
+	}
+
 	const outDir = customOutDir ?? join(rootDir, '.agentuity');
 	const srcDir = join(rootDir, 'src');
 
@@ -293,8 +374,23 @@ export async function bundle({
 	const tsconfigPath = join(rootDir, 'tsconfig.json');
 	const hasTsconfig = existsSync(tsconfigPath);
 
+	// Load user build config (if it exists)
+	const buildConfigFunction = await loadBuildConfig(rootDir);
+
+	// Helper to create build context for config function
+	const createBuildContext = (): BuildContext => ({
+		rootDir,
+		dev,
+		outDir,
+		srcDir,
+		orgId,
+		projectId,
+		region,
+		logger,
+	});
+
 	await (async () => {
-		const config: Bun.BuildConfig = {
+		const baseConfig: Bun.BuildConfig = {
 			entrypoints: appEntrypoints,
 			root: rootDir,
 			outdir: outDir,
@@ -321,7 +417,19 @@ export async function bundle({
 			},
 			tsconfig: hasTsconfig ? tsconfigPath : undefined,
 		};
-		const buildResult = await Bun.build(config);
+
+		// Apply user config for 'api' phase
+		let finalConfig = baseConfig;
+		if (buildConfigFunction) {
+			const userConfig = await executeBuildConfig(
+				buildConfigFunction,
+				'api',
+				createBuildContext()
+			);
+			finalConfig = mergeBuildConfig(baseConfig, userConfig);
+		}
+
+		const buildResult = await Bun.build(finalConfig);
 		if (!buildResult.success) {
 			handleBuildFailure(buildResult);
 		}
@@ -376,6 +484,9 @@ export async function bundle({
 		}
 	}
 
+	// must always set for the template always
+	define['process.env.AGENTUITY_PUBLIC_WORKBENCH_PATH'] = JSON.stringify('');
+
 	// Analyze workbench config early to set environment variables for web build
 	if (existsSync(appFile)) {
 		if (!workbench) {
@@ -426,7 +537,7 @@ export async function bundle({
 				mkdirSync(join(webOutDir, 'asset'), { recursive: true });
 				const isLocalRegion = region === 'local' || region === 'l';
 
-				const config: Bun.BuildConfig = {
+				const baseConfig: Bun.BuildConfig = {
 					entrypoints: webEntrypoints,
 					root: webDir,
 					outdir: webOutDir,
@@ -455,7 +566,19 @@ export async function bundle({
 					},
 					tsconfig: hasTsconfig ? tsconfigPath : undefined,
 				};
-				const result = await Bun.build(config);
+
+				// Apply user config for 'web' phase
+				let finalConfig = baseConfig;
+				if (buildConfigFunction) {
+					const userConfig = await executeBuildConfig(
+						buildConfigFunction,
+						'web',
+						createBuildContext()
+					);
+					finalConfig = mergeBuildConfig(baseConfig, userConfig);
+				}
+
+				const result = await Bun.build(finalConfig);
 				if (result.success) {
 					// Fix duplicate exports caused by Bun splitting bug
 					// See: https://github.com/oven-sh/bun/issues/5344
@@ -495,12 +618,51 @@ export async function bundle({
 
 			// Generate files using templates
 			await Bun.write(join(tempWorkbenchDir, 'main.tsx'), generateWorkbenchMainTsx(config));
+
+			// Copy the pre-built standalone.css from workbench package instead of generating it
+			// This ensures we use the built version with Tailwind already processed
+			const workbenchPackagePath = findPackagePath(rootDir, '@agentuity/workbench', logger);
+			const workbenchStylesOut = join(tempWorkbenchDir, 'styles.css');
+
+			if (workbenchPackagePath) {
+				const workbenchStylesPath = join(workbenchPackagePath, 'dist', 'standalone.css');
+				const workbenchStylesSourcePath = join(workbenchPackagePath, 'src', 'standalone.css');
+
+				if (existsSync(workbenchStylesPath)) {
+					cpSync(workbenchStylesPath, workbenchStylesOut);
+					logger.debug('Copied workbench dist/standalone.css to temp workbench dir');
+				} else if (existsSync(workbenchStylesSourcePath)) {
+					// Fallback: copy source CSS file (contains Tailwind directives that need processing)
+					cpSync(workbenchStylesSourcePath, workbenchStylesOut);
+					logger.warn(
+						'Workbench dist/standalone.css not found, using source CSS. Ensure @agentuity/workbench is built.'
+					);
+				} else {
+					throw new BuildFailedError({
+						message: `Workbench styles not found in ${workbenchPackagePath}. Expected either:
+  - ${workbenchStylesPath}
+  - ${workbenchStylesSourcePath}
+  
+Make sure @agentuity/workbench is built.`,
+					});
+				}
+			} else {
+				throw new BuildFailedError({
+					message: `Workbench package not found. Searched in:
+  - App-level node_modules
+  - Workspace root node_modules
+  - Workspace packages directory
+  
+Make sure @agentuity/workbench is installed or available in the workspace.`,
+				});
+			}
+
 			const workbenchIndexFile = join(tempWorkbenchDir, 'index.html');
 			await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
 			// Bundle workbench using generated files
 			// Disable splitting to avoid CommonJS/ESM module resolution conflicts
-			const workbenchBuildConfig: Bun.BuildConfig = {
+			const workbenchBaseConfig: Bun.BuildConfig = {
 				entrypoints: [workbenchIndexFile],
 				outdir: join(outDir, 'workbench'),
 				sourcemap: dev ? 'inline' : 'linked',
@@ -519,7 +681,18 @@ export async function bundle({
 				},
 			};
 
-			const workbenchResult = await Bun.build(workbenchBuildConfig);
+			// Apply user config for 'workbench' phase
+			let finalWorkbenchConfig = workbenchBaseConfig;
+			if (buildConfigFunction) {
+				const userConfig = await executeBuildConfig(
+					buildConfigFunction,
+					'workbench',
+					createBuildContext()
+				);
+				finalWorkbenchConfig = mergeBuildConfig(workbenchBaseConfig, userConfig);
+			}
+
+			const workbenchResult = await Bun.build(finalWorkbenchConfig);
 			if (workbenchResult.success) {
 				logger.debug('Workbench bundled successfully');
 				// Clean up temp directory

package/src/cmd/build/config-loader.ts

@@ -0,0 +1,200 @@
+import { join } from 'node:path';
+import { StructuredError } from '@agentuity/core';
+import type { BuildConfigFunction, BuildPhase, BuildContext, BuildConfig } from '../../types';
+
+const BuildConfigLoadError = StructuredError('BuildConfigLoadError');
+const BuildConfigValidationError = StructuredError('BuildConfigValidationError');
+
+/**
+ * Reserved define keys that cannot be overridden by user config
+ */
+const RESERVED_DEFINE_PREFIXES = ['process.env.AGENTUITY_', 'process.env.NODE_ENV'];
+
+/**
+ * Load and validate agentuity.config.ts from the project root
+ */
+export async function loadBuildConfig(rootDir: string): Promise<BuildConfigFunction | null> {
+	const configPath = join(rootDir, 'agentuity.config.ts');
+
+	// Check if config file exists
+	const configFile = Bun.file(configPath);
+	if (!(await configFile.exists())) {
+		return null; // No config file is OK - it's optional
+	}
+
+	try {
+		// Import the config file (Bun handles TypeScript natively)
+		// Use file:// URL to ensure absolute path resolution
+		const configModule = await import(`file://${configPath}`);
+
+		// Get the default export
+		const configFunction = configModule.default;
+
+		// Validate it's a function
+		if (typeof configFunction !== 'function') {
+			throw new BuildConfigValidationError({
+				message: `agentuity.config.ts must export a default function, got ${typeof configFunction}`,
+			});
+		}
+
+		return configFunction as BuildConfigFunction;
+	} catch (error) {
+		// If it's already our error, re-throw
+		if (error instanceof BuildConfigValidationError || error instanceof BuildConfigLoadError) {
+			throw error;
+		}
+
+		// Wrap other errors
+		throw new BuildConfigLoadError({
+			message: `Failed to load agentuity.config.ts: ${error instanceof Error ? error.message : String(error)}`,
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+/**
+ * Execute the build config function for a specific phase and validate the result
+ */
+export async function executeBuildConfig(
+	configFunction: BuildConfigFunction,
+	phase: BuildPhase,
+	context: BuildContext
+): Promise<BuildConfig> {
+	try {
+		// Execute the config function (may be async)
+		const config = await configFunction(phase, context);
+
+		// Validate the result is an object
+		if (!config || typeof config !== 'object') {
+			throw new BuildConfigValidationError({
+				message: `Build config for phase "${phase}" must return an object, got ${typeof config}`,
+			});
+		}
+
+		// Validate plugins array if provided
+		if (config.plugins !== undefined) {
+			if (!Array.isArray(config.plugins)) {
+				throw new BuildConfigValidationError({
+					message: `Build config plugins for phase "${phase}" must be an array, got ${typeof config.plugins}`,
+				});
+			}
+			// Validate each plugin has a name property (basic BunPlugin check)
+			for (const plugin of config.plugins) {
+				if (!plugin || typeof plugin !== 'object' || !('name' in plugin)) {
+					throw new BuildConfigValidationError({
+						message: `Invalid plugin in phase "${phase}": plugins must be BunPlugin objects with a name property`,
+					});
+				}
+			}
+		}
+
+		// Validate external array if provided
+		if (config.external !== undefined) {
+			if (!Array.isArray(config.external)) {
+				throw new BuildConfigValidationError({
+					message: `Build config external for phase "${phase}" must be an array, got ${typeof config.external}`,
+				});
+			}
+			// Validate each external is a string
+			for (const ext of config.external) {
+				if (typeof ext !== 'string') {
+					throw new BuildConfigValidationError({
+						message: `Invalid external in phase "${phase}": all externals must be strings, got ${typeof ext}`,
+					});
+				}
+			}
+		}
+
+		// Validate and filter define object if provided
+		if (config.define !== undefined) {
+			if (typeof config.define !== 'object' || config.define === null) {
+				throw new BuildConfigValidationError({
+					message: `Build config define for phase "${phase}" must be an object, got ${typeof config.define}`,
+				});
+			}
+
+			// Check for reserved keys and filter them out
+			const filteredDefine: Record<string, string> = {};
+			const blockedKeys: string[] = [];
+
+			for (const [key, value] of Object.entries(config.define)) {
+				// Check if this key starts with any reserved prefix
+				const isReserved = RESERVED_DEFINE_PREFIXES.some((prefix) => key.startsWith(prefix));
+
+				if (isReserved) {
+					blockedKeys.push(key);
+					continue; // Skip reserved keys
+				}
+
+				// Validate value is a string
+				if (typeof value !== 'string') {
+					throw new BuildConfigValidationError({
+						message: `Build config define values for phase "${phase}" must be strings, got ${typeof value} for key "${key}"`,
+					});
+				}
+
+				filteredDefine[key] = value;
+			}
+
+			// Warn if we blocked any keys
+			if (blockedKeys.length > 0) {
+				context.logger.warn(
+					`Build config for phase "${phase}" attempted to override reserved define keys (ignored): ${blockedKeys.join(', ')}`
+				);
+			}
+
+			// Replace with filtered version
+			config.define = filteredDefine;
+		}
+
+		return config;
+	} catch (error) {
+		// If it's already our error, re-throw
+		if (error instanceof BuildConfigValidationError) {
+			throw error;
+		}
+
+		// Wrap other errors
+		throw new BuildConfigLoadError({
+			message: `Failed to execute build config for phase "${phase}": ${error instanceof Error ? error.message : String(error)}`,
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+/**
+ * Merge user build config with base Bun.BuildConfig
+ * User config is applied AFTER base config with safeguards
+ * Returns a complete Bun.BuildConfig with user overrides applied
+ */
+export function mergeBuildConfig(
+	baseConfig: import('bun').BuildConfig,
+	userConfig: BuildConfig
+): import('bun').BuildConfig {
+	const merged = { ...baseConfig };
+
+	// Merge plugins (user plugins come AFTER Agentuity plugin)
+	if (userConfig.plugins && userConfig.plugins.length > 0) {
+		merged.plugins = [...(baseConfig.plugins ?? []), ...userConfig.plugins];
+	}
+
+	// Merge external (combine arrays, dedupe)
+	if (userConfig.external && userConfig.external.length > 0) {
+		const existingExternal = Array.isArray(baseConfig.external)
+			? baseConfig.external
+			: baseConfig.external
+				? [baseConfig.external]
+				: [];
+		merged.external = [...new Set([...existingExternal, ...userConfig.external])];
+	}
+
+	// Merge define (user defines come last, but reserved keys already filtered)
+	if (userConfig.define && Object.keys(userConfig.define).length > 0) {
+		merged.define = {
+			...baseConfig.define,
+			...userConfig.define,
+		};
+	}
+
+	return merged;
+}

package/src/cmd/build/patch/_util.ts

@@ -44,13 +44,13 @@ export function generateGatewayEnvGuard(
 	provider: string
 ): string {
 	return `{
-    const apikey = process.env.AGENTUITY_SDK_KEY;
-    const url = process.env.AGENTUITY_AIGATEWAY_URL || process.env.AGENTUITY_TRANSPORT_URL || (apikey ? 'https://agentuity.ai' : '');
-    if (url && apikey) {
-        process.env.${apikey} = ${apikeyval};
-        process.env.${apibase} = url + '/gateway/${provider}';
+    const _agentuity_sdk_key = process.env.AGENTUITY_SDK_KEY;
+    const _agentuity_url = process.env.AGENTUITY_AIGATEWAY_URL || process.env.AGENTUITY_TRANSPORT_URL || (_agentuity_sdk_key ? 'https://agentuity.ai' : '');
+    if (_agentuity_url && _agentuity_sdk_key) {
+        process.env.${apikey} = _agentuity_sdk_key;
+        process.env.${apibase} = _agentuity_url + '/gateway/${provider}';
         console.debug('Enabled Agentuity AI Gateway for ${provider}');
-    } else {
+    } else if (!process.env.${apikey}) {
      ${generateEnvWarning(apikey)}
     }
 }

package/src/cmd/build/patch/llm.ts

@@ -24,7 +24,7 @@ export function generatePatches(): Map<string, PatchModule> {
 	const patches = new Map<string, PatchModule>();
 	registerLLMPatch(
 		patches,
-		'@anthropic-ai',
+		'@anthropic-ai/sdk',
 		'index',
 		'ANTHROPIC_API_KEY',
 		'ANTHROPIC_BASE_URL',

package/src/cmd/build/plugin.ts

@@ -336,8 +336,11 @@ const AgentuityBundler: BunPlugin = {
 				// Setup workbench configuration - evaluate fresh each time during builds
 				const workbenchConfig = await setupWorkbench(srcDir);
 
+				// Store web routes for later (must be registered AFTER API routes)
+				let webRoutesInsert: string | null = null;
+
 				if (existsSync(indexFile)) {
-					inserts.push(`import { serveStatic } from 'hono/bun';
+					webRoutesInsert = `import { serveStatic } from 'hono/bun';
 import { getRouter, registerDevModeRoutes } from '@agentuity/runtime';
 import { readFileSync, existsSync } from 'node:fs';
 
@@ -375,6 +378,8 @@ import { readFileSync, existsSync } from 'node:fs';
 			index += html;
 		}
 	}
+	// make paths absolute
+	index = index.replaceAll('./web/', '/web/');
 	const webstatic = serveStatic({ root: import.meta.dir + '/web' });
 	// In dev mode, serve from source; in prod, serve from build output
 	const publicRoot = ${isDevMode} ? ${JSON.stringify(join(srcDir, 'web', 'public'))} : import.meta.dir + '/web/public';
@@ -385,22 +390,22 @@ import { readFileSync, existsSync } from 'node:fs';
 	// Serve public assets at root (e.g., /favicon.ico) - must be last
 	router.get('/*', async (c, next) => {
 		const path = c.req.path;
+		// Skip API routes - let them 404 naturally
+		if (path === '/api' || path.startsWith('/api/')) {
+			return c.notFound();
+		}
 		// Prevent directory traversal attacks
 		if (path.includes('..') || path.includes('%2e%2e')) {
 			return c.notFound();
 		}
-		// Only serve from public folder at root (skip /web/* routes and /)
-		if (path !== '/' && !path.startsWith('/web/')) {
-			try {
-				// serveStatic calls next() internally if file not found
-				return await publicstatic(c, next);
-			} catch (err) {
-				return next();
-			}
+		// Don't catch workbench routes (already handled above)
+		if (path.startsWith('/workbench')) {
+			return c.notFound();
 		}
-		return next();
+		// serve default for any path not explicitly matched
+		return c.html(index);
 	});
-})();`);
+})();`;
 				}
 
 				// Build agentInfo from all discovered agents and track directories
@@ -495,6 +500,14 @@ import { readFileSync, existsSync } from 'node:fs';
 					}
 
 					for (const apiFile of apiFiles) {
+						// Quick check: skip files that don't contain createRouter or Hono
+						// This avoids expensive AST parsing for utility files
+						const fileContent = await Bun.file(apiFile).text();
+						if (!fileContent.includes('createRouter') && !fileContent.includes('new Hono')) {
+							logger.trace(`Skipping ${apiFile}: no createRouter or Hono found`);
+							continue;
+						}
+
 						try {
 							const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
 
@@ -574,12 +587,17 @@ import { readFileSync, existsSync } from 'node:fs';
 								});
 							}
 						} catch (error) {
-							// Skip files that don't have createRouter (they might be utilities)
-							if (
-								error instanceof Error &&
-								error.message.includes('could not find an proper createRouter')
-							) {
-								logger.trace(`Skipping ${apiFile}: no createRouter found`);
+							// Skip files that don't have proper router setup despite containing createRouter/Hono
+							// (e.g., files that import but don't use them, or have syntax errors)
+							if (error instanceof Error) {
+								if (
+									error.message.includes('could not find default export') ||
+									error.message.includes('could not find an proper createRouter')
+								) {
+									logger.trace(`Skipping ${apiFile}: ${error.message}`);
+								} else {
+									throw error;
+								}
 							} else {
 								throw error;
 							}
@@ -619,6 +637,11 @@ import { readFileSync, existsSync } from 'node:fs';
 })();`);
 				}
 
+				// Add web routes AFTER API routes (catch-all must be last)
+				if (webRoutesInsert) {
+					inserts.push(webRoutesInsert);
+				}
+
 				const file = Bun.file(args.path);
 				let contents = await file.text();
 				// Use AST-based parsing to reliably find createApp statement end

package/src/cmd/build/route-discovery.ts

@@ -19,17 +19,21 @@ export interface DiscoveredRouteFile {
 }
 
 /**
- * Recursively discover all TypeScript route files in an API directory
+ * Recursively discover all TypeScript files in an API directory.
+ * Any .ts file CAN be a route if it exports a router, but not all files MUST be routes.
+ * Files without router exports (utility files, types, helpers) are discovered but gracefully skipped during processing.
+ *
  * Supports nested structures like:
- * - src/api/index.ts (root API router)
+ * - src/api/index.ts (root API router - handled separately)
  * - src/api/auth/route.ts -> mounted at /api/auth
+ * - src/api/auth/login.ts -> mounted at /api/auth
  * - src/api/v1/users/route.ts -> mounted at /api/v1/users
- * - src/api/admin/users/login.ts -> mounted at /api/admin/users (any .ts file works)
+ * - src/api/auth/helpers.ts -> discovered but skipped if no router export
  *
  * @param apiDir - Absolute path to the src/api directory
  * @param currentDir - Current directory being scanned (used for recursion)
  * @param results - Accumulated results (used for recursion)
- * @returns Array of discovered route files with mount information
+ * @returns Array of discovered TypeScript files with mount information
  */
 export function discoverRouteFiles(
 	apiDir: string,
@@ -63,8 +67,9 @@ export function discoverRouteFiles(
 
 			// For subdirectory files, determine mount path
 			// src/api/auth/route.ts -> /api/auth
+			// src/api/auth/login.ts -> /api/auth
 			// src/api/v1/users/route.ts -> /api/v1/users
-			// src/api/admin/login.ts -> /api/admin
+			// src/api/admin/helpers.ts -> /api/admin (discovered but may be skipped during processing)
 			const pathParts = relativePath.split('/');
 			pathParts.pop(); // Remove filename
 

package/src/cmd/build/workbench.ts

@@ -8,7 +8,6 @@ export function generateWorkbenchMainTsx(config: WorkbenchConfig): string {
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 import { App } from '@agentuity/workbench';
-import '@agentuity/workbench/styles';
 
 // Root element
 const rootElement = document.getElementById('root');
@@ -23,6 +22,14 @@ root.render(<App configBase64="${encodedConfig}" />);
 `;
 }
 
+export function generateWorkbenchStylesCss(): string {
+	// This file will be replaced with the actual dist/styles.css content during build
+	// We use @import here as a placeholder, but the bundler should resolve it to the built file
+	return `/* Generated workbench styles - will be replaced with dist/styles.css */
+@import '@agentuity/workbench/styles-standalone';
+`;
+}
+
 export function generateWorkbenchIndexHtml(): string {
 	return `<!DOCTYPE html>
 <html lang="en">
@@ -30,6 +37,7 @@ export function generateWorkbenchIndexHtml(): string {
 	<meta charset="UTF-8">
 	<meta name="viewport" content="width=device-width, initial-scale=1.0">
 	<title>Agentuity Workbench</title>
+	<link rel="stylesheet" href="./styles.css">
 </head>
 <body>
 	<div id="root"></div>