@agentuity/cli 0.0.52 → 0.0.54

package/src/cmd/build/ast.ts

@@ -897,3 +897,206 @@ export async function parseRoute(
 	}
 	return routes;
 }
+
+/**
+ * Configuration extracted from createWorkbench call
+ */
+export interface WorkbenchConfig {
+	route: string;
+	headers?: Record<string, string>;
+}
+
+/**
+ * Result of workbench analysis
+ */
+export interface WorkbenchAnalysis {
+	hasWorkbench: boolean;
+	config: WorkbenchConfig | null;
+}
+
+/**
+ * Check if a TypeScript file actively uses a specific function
+ * (ignores comments and unused imports)
+ *
+ * @param content - The TypeScript source code
+ * @param functionName - The function name to check for (e.g., 'createWorkbench')
+ * @returns true if the function is both imported and called
+ */
+export async function checkFunctionUsage(content: string, functionName: string): Promise<boolean> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasImport = false;
+		let hasUsage = false;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for import declarations with the function
+			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
+				if (ts.isNamedImports(node.importClause.namedBindings)) {
+					for (const element of node.importClause.namedBindings.elements) {
+						if (element.name.text === functionName) {
+							hasImport = true;
+						}
+					}
+				}
+			}
+			// Check for function calls
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+				if (node.expression.text === functionName) {
+					hasUsage = true;
+				}
+			}
+			// Recursively visit child nodes
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+		// Only return true if both import and usage are present
+		return hasImport && hasUsage;
+	} catch (error) {
+		// Fallback to string check if AST parsing fails
+		console.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
+		return content.includes(functionName);
+	}
+}
+
+/**
+ * Check if app.ts contains conflicting routes for a given endpoint
+ */
+export async function checkRouteConflicts(
+	content: string,
+	workbenchEndpoint: string
+): Promise<boolean> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasConflict = false;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for router.get calls
+			if (
+				ts.isCallExpression(node) &&
+				ts.isPropertyAccessExpression(node.expression) &&
+				ts.isIdentifier(node.expression.name) &&
+				node.expression.name.text === 'get'
+			) {
+				// Check if first argument is the workbench endpoint
+				if (node.arguments.length > 0 && ts.isStringLiteral(node.arguments[0])) {
+					if (node.arguments[0].text === workbenchEndpoint) {
+						hasConflict = true;
+					}
+				}
+			}
+
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+		return hasConflict;
+	} catch (_error) {
+		return false;
+	}
+}
+
+/**
+ * Analyze workbench usage and extract configuration
+ *
+ * @param content - The TypeScript source code
+ * @returns workbench analysis including usage and config
+ */
+export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalysis> {
+	try {
+		const ts = await import('typescript');
+		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
+
+		let hasImport = false;
+		let hasUsage = false;
+		let config: WorkbenchConfig | null = null;
+
+		function visitNode(node: import('typescript').Node): void {
+			// Check for import declarations with createWorkbench
+			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
+				if (ts.isNamedImports(node.importClause.namedBindings)) {
+					for (const element of node.importClause.namedBindings.elements) {
+						if (element.name.text === 'createWorkbench') {
+							hasImport = true;
+						}
+					}
+				}
+			}
+
+			// Check for createWorkbench function calls and extract config
+			if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+				if (node.expression.text === 'createWorkbench') {
+					hasUsage = true;
+
+					// Extract configuration from the first argument (if any)
+					if (node.arguments.length > 0) {
+						const configArg = node.arguments[0];
+						config = parseConfigObject(configArg, ts);
+					} else {
+						// Default config if no arguments provided
+						config = { route: '/workbench' };
+					}
+				}
+			}
+
+			// Recursively visit child nodes
+			ts.forEachChild(node, visitNode);
+		}
+
+		visitNode(sourceFile);
+
+		// Set default config if workbench is used but no config was parsed
+		if (hasImport && hasUsage && !config) {
+			config = { route: '/workbench' };
+		}
+
+		return {
+			hasWorkbench: hasImport && hasUsage,
+			config: config,
+		};
+	} catch (error) {
+		// Fallback to simple check if AST parsing fails
+		console.warn('Workbench AST parsing failed, falling back to string check:', error);
+		const hasWorkbench = content.includes('createWorkbench');
+		return {
+			hasWorkbench,
+			config: hasWorkbench ? { route: '/workbench' } : null,
+		};
+	}
+}
+
+/**
+ * Parse a TypeScript object literal to extract configuration
+ */
+function parseConfigObject(
+	node: import('typescript').Node,
+	ts: typeof import('typescript')
+): WorkbenchConfig | null {
+	if (!ts.isObjectLiteralExpression(node)) {
+		return { route: '/workbench' }; // Default config
+	}
+
+	const config: WorkbenchConfig = { route: '/workbench' };
+
+	for (const property of node.properties) {
+		if (ts.isPropertyAssignment(property) && ts.isIdentifier(property.name)) {
+			const propertyName = property.name.text;
+
+			if (propertyName === 'route' && ts.isStringLiteral(property.initializer)) {
+				config.route = property.initializer.text;
+			} else if (
+				propertyName === 'headers' &&
+				ts.isObjectLiteralExpression(property.initializer)
+			) {
+				// Parse headers object if needed (not implemented for now)
+				config.headers = {};
+			}
+		}
+	}
+
+	return config;
+}

package/src/cmd/build/bundler.ts

@@ -1,5 +1,6 @@
 import { $ } from 'bun';
 import { join, relative, resolve, dirname } from 'node:path';
+import { createRequire } from 'node:module';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
@@ -7,6 +8,8 @@ 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';
 
 export interface BundleOptions {
 	rootDir: string;
@@ -16,6 +19,7 @@ export interface BundleOptions {
 	projectId?: string;
 	deploymentId?: string;
 	project?: Project;
+	port?: number;
 }
 
 export async function bundle({
@@ -25,6 +29,7 @@ export async function bundle({
 	dev = false,
 	rootDir,
 	project,
+	port,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
@@ -246,26 +251,87 @@ export async function bundle({
 				}
 			}
 		})();
+	}
 
-		if (!dev && buildmetadata) {
-			const webPublicDir = join(webDir, 'public');
-			if (existsSync(webPublicDir)) {
-				const assets = buildmetadata.assets;
-				const webOutPublicDir = join(outDir, 'web', 'public');
-				cpSync(webPublicDir, webOutPublicDir, { recursive: true });
-				[...new Bun.Glob('**.*').scanSync(webOutPublicDir)].forEach((f) => {
-					const bf = Bun.file(join(webOutPublicDir, f));
-					assets.push({
-						filename: join('public', f),
-						kind: 'static',
-						contentType: bf.type,
-						size: bf.size,
-					});
-				});
+	// Bundle workbench app if detected via setupWorkbench
+	const { analyzeWorkbench } = await import('./ast');
+	if (existsSync(appFile)) {
+		const appContent = await Bun.file(appFile).text();
+		const analysis = await analyzeWorkbench(appContent);
+
+		if (analysis.hasWorkbench) {
+			// Encode workbench config for environment variable
+			const { encodeWorkbenchConfig } = await import('@agentuity/core');
+			const config = analysis.config || { route: '/workbench', headers: {} };
+			// Add port to config (defaults to 3500 if not provided)
+			const configWithPort = { ...config, port: port || 3500 };
+			const encodedConfig = encodeWorkbenchConfig(configWithPort);
+			const workbenchDefine = {
+				...define,
+				AGENTUITY_WORKBENCH_CONFIG_INLINE: JSON.stringify(encodedConfig),
+			};
+			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
+			try {
+				const projectRequire = createRequire(resolve(rootDir, 'package.json'));
+				const workbenchPkgPath = projectRequire.resolve('@agentuity/workbench/package.json');
+				const workbenchAppDir = join(dirname(workbenchPkgPath), 'src', 'app');
+
+				if (existsSync(workbenchAppDir)) {
+					const workbenchIndexFile = join(workbenchAppDir, 'index.html');
+					if (existsSync(workbenchIndexFile)) {
+						// Bundle workbench using same config as main web app
+						const workbenchBuildConfig: Bun.BuildConfig = {
+							entrypoints: [workbenchIndexFile],
+							root: workbenchAppDir,
+							outdir: join(outDir, 'workbench'),
+							define: workbenchDefine,
+							sourcemap: dev ? 'inline' : 'linked',
+							plugins: [AgentuityBundler],
+							target: 'browser',
+							format: 'esm',
+							banner: `// Generated file. DO NOT EDIT`,
+							minify: true,
+							splitting: true,
+							packages: 'bundle',
+							naming: {
+								entry: '[dir]/[name].[ext]',
+								chunk: 'workbench/chunk/[name]-[hash].[ext]',
+								asset: 'workbench/asset/[name]-[hash].[ext]',
+							},
+						};
+
+						const workbenchResult = await Bun.build(workbenchBuildConfig);
+						if (workbenchResult.success) {
+							logger.debug('Workbench bundled successfully');
+						} else {
+							logger.error('Workbench bundling failed:', workbenchResult.logs.join('\n'));
+						}
+					}
+				}
+			} catch (error) {
+				logger.error('Failed to bundle workbench:', error);
 			}
 		}
 	}
 
+	if (!dev && buildmetadata) {
+		const webPublicDir = join(webDir, 'public');
+		if (existsSync(webPublicDir)) {
+			const assets = buildmetadata.assets;
+			const webOutPublicDir = join(outDir, 'web', 'public');
+			cpSync(webPublicDir, webOutPublicDir, { recursive: true });
+			[...new Bun.Glob('**.*').scanSync(webOutPublicDir)].forEach((f) => {
+				const bf = Bun.file(join(webOutPublicDir, f));
+				assets.push({
+					filename: join('public', f),
+					kind: 'static',
+					contentType: bf.type,
+					size: bf.size,
+				});
+			});
+		}
+	}
+
 	if (!dev && Bun.which('git') && buildmetadata?.deployment) {
 		buildmetadata.deployment.git = {
 			commit: process.env.GIT_SHA || process.env.GITHUB_SHA,

package/src/cmd/build/index.ts

@@ -47,7 +47,9 @@ export const command = createCommand({
 					tui.info('Running type check...');
 					const { resolve } = await import('node:path');
 					const absoluteProjectDir = resolve(projectDir);
-					const result = await Bun.$`bunx tsc --noEmit --skipLibCheck`.cwd(absoluteProjectDir).nothrow();
+					const result = await Bun.$`bunx tsc --noEmit --skipLibCheck`
+						.cwd(absoluteProjectDir)
+						.nothrow();
 
 					if (result.exitCode === 0) {
 						tui.success('Type check passed');

package/src/cmd/build/plugin.ts

@@ -1,8 +1,15 @@
 import type { BunPlugin } from 'bun';
 import { dirname, basename, join, resolve } from 'node:path';
-import { existsSync, writeFileSync, mkdirSync } from 'node:fs';
+import { existsSync, writeFileSync, mkdirSync, unlinkSync } from 'node:fs';
 import type { BuildMetadata } from '@agentuity/server';
-import { parseAgentMetadata, parseRoute, parseEvalMetadata } from './ast';
+import {
+	parseAgentMetadata,
+	parseRoute,
+	parseEvalMetadata,
+	analyzeWorkbench,
+	checkRouteConflicts,
+	type WorkbenchConfig,
+} from './ast';
 import { applyPatch, generatePatches } from './patch';
 import { detectSubagent } from '../../utils/detectSubagent';
 import { createLogger } from '@agentuity/server';
@@ -19,6 +26,50 @@ function toPascalCase(str: string): string {
 	return camel.charAt(0).toUpperCase() + camel.slice(1);
 }
 
+/**
+ * Setup workbench configuration by analyzing app.ts file
+ */
+async function setupWorkbench(srcDir: string): Promise<WorkbenchConfig | null> {
+	// Look for app.ts in both root and src directories
+	const rootAppFile = join(dirname(srcDir), 'app.ts');
+	const srcAppFile = join(srcDir, 'app.ts');
+
+	let appFile = '';
+	if (existsSync(rootAppFile)) {
+		appFile = rootAppFile;
+	} else if (existsSync(srcAppFile)) {
+		appFile = srcAppFile;
+	}
+
+	if (!appFile || !existsSync(appFile)) {
+		return null;
+	}
+
+	const appContent = await Bun.file(appFile).text();
+	const analysis = await analyzeWorkbench(appContent);
+
+	if (!analysis.hasWorkbench) {
+		return null;
+	}
+
+	const workbenchConfig = analysis.config;
+
+	// Check for route conflicts if workbench is being used
+	if (workbenchConfig?.route) {
+		const hasConflict = await checkRouteConflicts(appContent, workbenchConfig.route);
+		if (hasConflict) {
+			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
+			logger.error(`🚨 Route conflict detected!\n`);
+			logger.error(
+				`   Workbench route '${workbenchConfig.route}' conflicts with existing application route`
+			);
+			logger.error(`   Please use a different route or remove the conflicting route.\n`);
+		}
+	}
+
+	return workbenchConfig;
+}
+
 function generateAgentRegistry(srcDir: string, agentInfo: Array<Record<string, string>>) {
 	// Separate parent agents and subagents
 	const parentAgents = agentInfo.filter((a) => !a.parent);
@@ -123,87 +174,63 @@ function generateAgentRegistry(srcDir: string, agentInfo: Array<Record<string, s
 		})
 		.join('\n');
 
-	// Generate nested agent type definitions
-	const agentTypeLines: string[] = [];
+	// Generate nested agent type definitions for Hono Context augmentation
+	const honoAgentTypeLines: string[] = [];
 	for (const parentAgent of parentAgents) {
 		const parentCamelName = toCamelCase(parentAgent.name);
 		const children = subagentsByParent.get(parentAgent.name) || [];
 
 		if (children.length === 0) {
 			// No subagents
-			agentTypeLines.push(
-				`	   ${parentCamelName}: AgentRunner<AgentRegistry['${parentCamelName}']['inputSchema'], AgentRegistry['${parentCamelName}']['outputSchema'], AgentRegistry['${parentCamelName}']['stream'] extends true ? true : false>;`
+			honoAgentTypeLines.push(
+				`	   ${parentCamelName}: AgentRunner<LocalAgentRegistry['${parentCamelName}']['inputSchema'], LocalAgentRegistry['${parentCamelName}']['outputSchema'], LocalAgentRegistry['${parentCamelName}']['stream'] extends true ? true : false>;`
 			);
 		} else {
 			// Has subagents - create intersection type
-			agentTypeLines.push(
-				`	   ${parentCamelName}: AgentRunner<AgentRegistry['${parentCamelName}']['inputSchema'], AgentRegistry['${parentCamelName}']['outputSchema'], AgentRegistry['${parentCamelName}']['stream'] extends true ? true : false> & {`
+			honoAgentTypeLines.push(
+				`	   ${parentCamelName}: AgentRunner<LocalAgentRegistry['${parentCamelName}']['inputSchema'], LocalAgentRegistry['${parentCamelName}']['outputSchema'], LocalAgentRegistry['${parentCamelName}']['stream'] extends true ? true : false> & {`
 			);
 			for (const child of children) {
 				const childCamelName = toCamelCase(child.name);
 				const fullChildName = toCamelCase(`${parentAgent.name}_${child.name}`);
-				agentTypeLines.push(
+				honoAgentTypeLines.push(
 					`	     ${childCamelName}: AgentRunner<typeof ${fullChildName}Agent['inputSchema'], typeof ${fullChildName}Agent['outputSchema'], typeof ${fullChildName}Agent['stream'] extends true ? true : false>;`
 				);
 			}
-			agentTypeLines.push(`	   };`);
+			honoAgentTypeLines.push(`	   };`);
 		}
 	}
-	const agentTypes = agentTypeLines.join('\n');
-
-	const generatedContent = `/// <reference types="hono" />
-// Auto-generated by Agentuity - do not edit manually
-${imports}${evalsImportsStr}
-import type { AgentRunner, Logger } from '@agentuity/runtime';
-import type { KeyValueStorage, ObjectStorage, StreamStorage, VectorStorage } from '@agentuity/core';
-
-export const agentRegistry = {
-${registry}
-} as const;
-
-export type AgentName = keyof typeof agentRegistry;
-export type AgentRegistry = typeof agentRegistry;
+	const honoAgentTypes = honoAgentTypeLines.join('\n');
 
-// Typed runners for each agent
-${typeExports}
-
-// Augment Context to provide strongly-typed agents
-declare module "hono" {
-	interface Context {
-	   agentName: AgentName;
-	   agent: {
-${agentTypes}
-	   };
-	   waitUntil: (promise: Promise<void> | (() => void | Promise<void>)) => void;
-	   logger: Logger;
-	   kv: KeyValueStorage;
-	   objectstore: ObjectStorage;
-	   stream: StreamStorage;
-	   vector: VectorStorage;
-  }
-}
-`;
-
-	const agentsDir = join(srcDir, 'agents');
-	const registryPath = join(agentsDir, 'registry.generated.ts');
+	// Generate agent type definitions for AgentRegistry interface augmentation
+	const runtimeAgentTypeLines: string[] = [];
+	for (const parentAgent of parentAgents) {
+		const parentCamelName = toCamelCase(parentAgent.name);
+		const children = subagentsByParent.get(parentAgent.name) || [];
 
-	// Ensure agents directory exists
-	if (!existsSync(agentsDir)) {
-		mkdirSync(agentsDir, { recursive: true });
+		if (children.length === 0) {
+			// No subagents - use typeof the imported agent
+			runtimeAgentTypeLines.push(
+				`		${parentCamelName}: AgentRunner<typeof ${parentCamelName}Agent['inputSchema'], typeof ${parentCamelName}Agent['outputSchema'], typeof ${parentCamelName}Agent['stream'] extends true ? true : false>;`
+			);
+		} else {
+			// Has subagents - create intersection type using typeof
+			runtimeAgentTypeLines.push(
+				`		${parentCamelName}: AgentRunner<typeof ${parentCamelName}Agent['inputSchema'], typeof ${parentCamelName}Agent['outputSchema'], typeof ${parentCamelName}Agent['stream'] extends true ? true : false> & {`
+			);
+			for (const child of children) {
+				const childCamelName = toCamelCase(child.name);
+				const fullChildName = toCamelCase(`${parentAgent.name}_${child.name}`);
+				runtimeAgentTypeLines.push(
+					`			${childCamelName}: AgentRunner<typeof ${fullChildName}Agent['inputSchema'], typeof ${fullChildName}Agent['outputSchema'], typeof ${fullChildName}Agent['stream'] extends true ? true : false>;`
+				);
+			}
+			runtimeAgentTypeLines.push(`		};`);
+		}
 	}
-
-	writeFileSync(registryPath, generatedContent, 'utf-8');
+	const runtimeAgentTypes = runtimeAgentTypeLines.join('\n');
 
 	// Generate React client types with nested structure
-	const clientImports = agentInfo
-		.map(({ name, path, parent }) => {
-			const fullName = parent ? `${parent}_${name}` : name;
-			const camelName = toCamelCase(fullName);
-			const relativePath = path.replace(/^\.\/agents\//, './');
-			return `import type ${camelName}Agent from '${relativePath}';`;
-		})
-		.join('\n');
-
 	const clientAgentTypeLines: string[] = [];
 	for (const parentAgent of parentAgents) {
 		const parentCamelName = toCamelCase(parentAgent.name);
@@ -227,21 +254,74 @@ ${agentTypes}
 			}
 		}
 	}
+	const reactAgentTypes = clientAgentTypeLines.join('\n');
 
-	const clientTypesContent = `// Auto-generated by Agentuity - do not edit manually
-// This file augments @agentuity/react with your project's agent types
-${clientImports}
+	const generatedContent = `/// <reference types="hono" />
+// Auto-generated by Agentuity - do not edit manually
+${imports}${evalsImportsStr}
+import type { AgentRunner, Logger } from '@agentuity/runtime';
+import type { KeyValueStorage, ObjectStorage, StreamStorage, VectorStorage } from '@agentuity/core';
 import type { Agent } from '@agentuity/react';
 
+export const agentRegistry = {
+${registry}
+} as const;
+
+// Local type aliases for Hono augmentation
+type LocalAgentName = keyof typeof agentRegistry;
+type LocalAgentRegistry = typeof agentRegistry;
+
+// Typed runners for each agent
+${typeExports}
+
+// Augment @agentuity/runtime types with strongly-typed agents from this project
+declare module "@agentuity/runtime" {
+	// Augment the AgentRegistry interface with project-specific strongly-typed agents
+	export interface AgentRegistry {
+${runtimeAgentTypes}
+	}
+}
+
+// Augment Hono Context to provide strongly-typed agents and runtime services
+// Note: Properties are added to Context via middleware in @agentuity/runtime
+declare module "hono" {
+	interface Context {
+		agentName: LocalAgentName;
+		agent: {
+${honoAgentTypes}
+		};
+		waitUntil: (promise: Promise<void> | (() => void | Promise<void>)) => void;
+		logger: Logger;
+		kv: KeyValueStorage;
+		objectstore: ObjectStorage;
+		stream: StreamStorage;
+		vector: VectorStorage;
+	}
+}
+
+// Augment @agentuity/react types with strongly-typed agents from this project
 declare module '@agentuity/react' {
 	interface AgentRegistry {
-${clientAgentTypeLines.join('\n')}
+${reactAgentTypes}
 	}
 }
 `;
 
-	const clientTypesPath = join(agentsDir, 'types.generated.d.ts');
-	writeFileSync(clientTypesPath, clientTypesContent, 'utf-8');
+	const agentsDir = join(srcDir, 'agents');
+	const registryPath = join(agentsDir, 'registry.generated.ts');
+	const legacyTypesPath = join(agentsDir, 'types.generated.d.ts');
+
+	// Ensure agents directory exists
+	if (!existsSync(agentsDir)) {
+		mkdirSync(agentsDir, { recursive: true });
+	}
+
+	writeFileSync(registryPath, generatedContent, 'utf-8');
+
+	// Remove legacy types.generated.d.ts if it exists (now consolidated into registry.generated.ts)
+	if (existsSync(legacyTypesPath)) {
+		unlinkSync(legacyTypesPath);
+	}
 }
 
 let metadata: Partial<BuildMetadata>;
@@ -261,6 +341,10 @@ const AgentuityBundler: BunPlugin = {
 		const deploymentId = build.config.define?.['process.env.AGENTUITY_CLOUD_DEPLOYMENT_ID']
 			? JSON.parse(build.config.define['process.env.AGENTUITY_CLOUD_DEPLOYMENT_ID'])
 			: '';
+		const isDevMode =
+			(build.config.define?.['process.env.NODE_ENV']
+				? JSON.parse(build.config.define['process.env.NODE_ENV'])
+				: 'production') === 'development';
 		const routes: Set<string> = new Set();
 		const agentInfo: Array<Record<string, string>> = [];
 		const agentMetadata: Map<string, Map<string, string>> = new Map<
@@ -463,11 +547,45 @@ const AgentuityBundler: BunPlugin = {
 				const indexFile = join(srcDir, 'web', 'index.html');
 
 				if (existsSync(indexFile)) {
+					// Setup workbench configuration - evaluate fresh each time during builds
+					const workbenchConfig = await setupWorkbench(srcDir);
+
 					inserts.unshift(`await (async () => {
     const { serveStatic } = require('hono/bun');
-    const { getRouter } = await import('@agentuity/runtime');
+    const { getRouter, registerDevModeRoutes } = await import('@agentuity/runtime');
     const router = getRouter()!;
-	const index = await Bun.file(import.meta.dir + '/web/index.html').text();
+	
+	// Setup workbench routes if workbench was bundled
+	const workbenchIndexPath = import.meta.dir + '/workbench/index.html';
+	if (await Bun.file(workbenchIndexPath).exists()) {
+		let workbenchIndex = await Bun.file(workbenchIndexPath).text();
+		
+		// Always serve assets at /workbench/* regardless of HTML route
+		const workbenchStatic = serveStatic({ root: import.meta.dir + '/workbench' });
+		router.get('/workbench/*', workbenchStatic);
+		
+		// Use the workbench config determined at build time
+		const route = ${JSON.stringify(workbenchConfig?.route || '/workbench')};
+
+// If using custom route, update HTML to point to absolute /workbench/ paths
+if (route !== '/workbench') {
+			workbenchIndex = workbenchIndex.replace(new RegExp('src="\\\\.\\\\/workbench\\\\/', 'g'), 'src="/workbench/');
+		}
+		
+		// Serve HTML at the configured route
+		router.get(route, (c) => c.html(workbenchIndex));
+	}
+	
+	let index = await Bun.file(import.meta.dir + '/web/index.html').text();
+	if (${isDevMode}) {
+		const end = index.lastIndexOf('</html>');
+		const html = registerDevModeRoutes(router);
+		if (end > 0) {
+			index = index.substring(0,end) + html + index.substring(end);
+		} else {
+			index += html;
+		}
+	}
 	const webstatic = serveStatic({ root: import.meta.dir + '/web' });
 	router.get('/', (c) => c.html(index));
     router.get('/web/chunk/*', webstatic);