@agentuity/cli 1.0.38 → 1.0.40

package/src/cmd/build/ast.ts

@@ -1520,16 +1520,124 @@ function resolveImportPath(fromDir: string, importPath: string): string | null {
 	return null;
 }
 
+/**
+ * Check if a CallExpression is a chained router initializer.
+ * Walks up the callee chain looking for createRouter() or new Hono() at the root.
+ *
+ * Example AST for `createRouter().get('/foo', handler).post('/bar', handler)`:
+ * ```
+ * CallExpression (.post)
+ *   callee: MemberExpression
+ *     object: CallExpression (.get)
+ *       callee: MemberExpression
+ *         object: CallExpression (createRouter)
+ *     property: "post"
+ * ```
+ */
+function isChainedRouterInit(node: ASTNode): boolean {
+	let current: ASTNode = node;
+
+	// Walk down the chain: each link is CallExpression → MemberExpression → CallExpression
+	while (current.type === 'CallExpression') {
+		const callee = (current as ASTCallExpression).callee as ASTNode;
+		if (!callee) return false;
+
+		// Direct createRouter()
+		if (callee.type === 'Identifier' && (callee as ASTNodeIdentifier).name === 'createRouter')
+			return true;
+
+		// Chained: .method() → MemberExpression
+		if (callee.type === 'MemberExpression' && (callee as ASTMemberExpression).object) {
+			current = (callee as ASTMemberExpression).object as ASTNode;
+			continue;
+		}
+
+		break;
+	}
+
+	// Check if we landed on createRouter() or new Hono()
+	if (current.type === 'CallExpression') {
+		const callee = (current as ASTCallExpression).callee as ASTNode;
+		if (callee?.type === 'Identifier' && (callee as ASTNodeIdentifier).name === 'createRouter')
+			return true;
+	}
+	if (current.type === 'NewExpression') {
+		const callee = (current as ASTCallExpression).callee as ASTNode;
+		if (callee?.type === 'Identifier' && (callee as ASTNodeIdentifier).name === 'Hono')
+			return true;
+	}
+
+	return false;
+}
+
+/**
+ * Flatten a chained call expression into individual method calls.
+ *
+ * Given `createRouter().get('/a', h1).post('/b', h2).route('/c', sub)`, returns:
+ * ```
+ * [
+ *   { method: 'get', arguments: ['/a', h1] },
+ *   { method: 'post', arguments: ['/b', h2] },
+ *   { method: 'route', arguments: ['/c', sub] },
+ * ]
+ * ```
+ */
+function flattenChainedCalls(node: ASTNode): Array<{ method: string; arguments: unknown[] }> {
+	const calls: Array<{ method: string; arguments: unknown[] }> = [];
+
+	let current: ASTNode = node;
+	while (current.type === 'CallExpression') {
+		const callee = (current as ASTCallExpression).callee as ASTNode;
+		if (!callee) break;
+
+		if (
+			callee.type === 'MemberExpression' &&
+			((callee as ASTMemberExpression).property as ASTNode)?.type === 'Identifier'
+		) {
+			calls.unshift({
+				method: ((callee as ASTMemberExpression).property as ASTNodeIdentifier).name,
+				arguments: (current as ASTCallExpression).arguments || [],
+			});
+			current = (callee as ASTMemberExpression).object as ASTNode;
+			continue;
+		}
+
+		break; // Reached the root (createRouter() / new Hono())
+	}
+
+	return calls;
+}
+
+export interface ParseRouteOptions {
+	visitedFiles?: Set<string>;
+	mountedSubrouters?: Set<string>;
+	/**
+	 * Explicit mount prefix for this router file, derived from code-based routing
+	 * (e.g., from `createApp({ router })` or `.route()` calls).
+	 * When provided, overrides the filesystem-derived mount path.
+	 */
+	mountPrefix?: string;
+}
+
 export async function parseRoute(
 	rootDir: string,
 	filename: string,
 	projectId: string,
 	deploymentId: string,
-	visitedFiles?: Set<string>,
+	visitedFilesOrOptions?: Set<string> | ParseRouteOptions,
 	mountedSubrouters?: Set<string>
 ): Promise<BuildMetadata['routes']> {
+	// Support both old positional args and new options object
+	let options: ParseRouteOptions;
+	if (visitedFilesOrOptions instanceof Set) {
+		options = { visitedFiles: visitedFilesOrOptions, mountedSubrouters };
+	} else if (visitedFilesOrOptions && typeof visitedFilesOrOptions === 'object') {
+		options = visitedFilesOrOptions;
+	} else {
+		options = { mountedSubrouters };
+	}
 	// Track visited files to prevent infinite recursion
-	const visited = visitedFiles ?? new Set<string>();
+	const visited = options.visitedFiles ?? new Set<string>();
 	const resolvedFilename = resolve(filename);
 	if (visited.has(resolvedFilename)) {
 		return []; // Already parsed this file, avoid infinite loop
@@ -1643,6 +1751,10 @@ export async function parseRoute(
 			message: `could not find default export for ${filename} using ${rootDir}`,
 		});
 	}
+	// Track the chained init expression (e.g., createRouter().get(...).post(...))
+	// so we can extract routes from it later
+	let chainedInitExpr: ASTNode | undefined;
+
 	for (const body of ast.body) {
 		if (body.type === 'VariableDeclaration') {
 			for (const vardecl of body.declarations) {
@@ -1656,6 +1768,14 @@ export async function parseRoute(
 								variableName = identifier.name;
 								break;
 							}
+							// Support chained calls: createRouter().get(...).post(...)
+							// The init is a CallExpression whose callee is a MemberExpression chain
+							// that eventually roots at createRouter() or new Hono()
+							if (isChainedRouterInit(call)) {
+								variableName = identifier.name;
+								chainedInitExpr = call;
+								break;
+							}
 						} else if (vardecl.init?.type === 'NewExpression') {
 							const newExpr = vardecl.init as ASTCallExpression;
 							// Support new Hono() pattern
@@ -1678,16 +1798,18 @@ export async function parseRoute(
 
 	const rel = toForwardSlash(relative(rootDir, filename));
 
-	// Compute the API mount path using the shared helper
-	// This ensures consistency between route type generation (here) and runtime mounting (entry-generator.ts)
-	// Examples:
-	//   src/api/index.ts           -> basePath = '/api'
-	//   src/api/sessions.ts        -> basePath = '/api/sessions'
-	//   src/api/auth/route.ts      -> basePath = '/api/auth'
-	//   src/api/users/profile/route.ts -> basePath = '/api/users/profile'
-	const srcDir = join(rootDir, 'src');
-	const relativeApiPath = extractRelativeApiPath(filename, srcDir);
-	const basePath = computeApiMountPath(relativeApiPath);
+	// Determine the base mount path for routes in this file.
+	// When mountPrefix is provided (explicit routing via createApp({ router })),
+	// use it directly — the mount path comes from the code, not the filesystem.
+	// Otherwise, derive it from the file's position in src/api/ (file-based routing).
+	let basePath: string;
+	if (options.mountPrefix !== undefined) {
+		basePath = options.mountPrefix;
+	} else {
+		const srcDir = join(rootDir, 'src');
+		const relativeApiPath = extractRelativeApiPath(filename, srcDir);
+		basePath = computeApiMountPath(relativeApiPath);
+	}
 
 	const routes: RouteDefinition = [];
 
@@ -1773,40 +1895,33 @@ export async function parseRoute(
 								}
 
 								try {
-									// Parse sub-router's routes
+									// The combined mount point for this sub-router
+									const combinedBase = joinMountAndRoute(basePath, mountPath);
+
+									// Parse sub-router's routes with the code-derived mount prefix.
+									// This ensures the sub-router's routes are prefixed correctly
+									// regardless of where the file lives on disk.
 									const subRoutes = await parseRoute(
 										rootDir,
 										resolvedFile,
 										projectId,
 										deploymentId,
-										visited,
-										mountedSubrouters
+										{
+											visitedFiles: visited,
+											mountedSubrouters: options.mountedSubrouters,
+											mountPrefix: combinedBase,
+										}
 									);
 
 									// Track this file as a mounted sub-router
-									if (mountedSubrouters) {
-										mountedSubrouters.add(resolve(resolvedFile));
+									if (options.mountedSubrouters) {
+										options.mountedSubrouters.add(resolve(resolvedFile));
 									}
 
-									// Compute the sub-router's own basePath so we can strip it
-									const subSrcDir = join(rootDir, 'src');
-									const subRelativeApiPath = extractRelativeApiPath(
-										resolvedFile,
-										subSrcDir
-									);
-									const subBasePath = computeApiMountPath(subRelativeApiPath);
-
-									// The combined mount point for sub-routes
-									const combinedBase = joinMountAndRoute(basePath, mountPath);
-
 									for (const subRoute of subRoutes) {
-										// Strip the sub-router's own basePath from the route path
-										let routeSuffix = subRoute.path;
-										if (routeSuffix.startsWith(subBasePath)) {
-											routeSuffix = routeSuffix.slice(subBasePath.length) || '/';
-										}
-
-										const fullPath = joinMountAndRoute(combinedBase, routeSuffix);
+										// Sub-routes already have the correct full path
+										// (the recursive call used combinedBase as mountPrefix)
+										const fullPath = subRoute.path;
 										const id = generateRouteId(
 											projectId,
 											deploymentId,
@@ -1817,11 +1932,20 @@ export async function parseRoute(
 											subRoute.version
 										);
 
+										// Preserve the sub-route's original filename for schema
+										// import resolution. The registry generator needs to know
+										// which file actually defines/exports the schema variable.
+										const config = { ...subRoute.config };
+										if (subRoute.filename && subRoute.filename !== rel) {
+											config.schemaSourceFile = subRoute.filename;
+										}
+
 										routes.push({
 											...subRoute,
 											id,
 											path: fullPath,
-											filename: rel, // Keep parent file as the filename since routes are mounted here
+											filename: rel,
+											config: Object.keys(config).length > 0 ? config : undefined,
 										});
 									}
 								} catch {
@@ -2309,6 +2433,185 @@ export async function parseRoute(
 				}
 			}
 		}
+		// Process routes from chained initialization expressions
+		// e.g., const router = createRouter().get('/foo', handler).post('/bar', handler)
+		if (chainedInitExpr) {
+			const chainedCalls = flattenChainedCalls(chainedInitExpr);
+			for (const chainedCall of chainedCalls) {
+				const { method: chainMethod, arguments: chainArgs } = chainedCall;
+
+				// Skip non-route methods
+				if (
+					chainMethod === 'use' ||
+					chainMethod === 'onError' ||
+					chainMethod === 'notFound' ||
+					chainMethod === 'basePath' ||
+					chainMethod === 'mount'
+				) {
+					continue;
+				}
+
+				// Handle .route() for sub-router mounting (same as the ExpressionStatement case)
+				if (chainMethod === 'route') {
+					const mountPathArg = chainArgs[0] as ASTNode | undefined;
+					const subRouterArg = chainArgs[1] as ASTNode | undefined;
+
+					if (
+						mountPathArg &&
+						(mountPathArg as ASTLiteral).type === 'Literal' &&
+						subRouterArg &&
+						(subRouterArg as ASTNodeIdentifier).type === 'Identifier'
+					) {
+						const mountPath = String((mountPathArg as ASTLiteral).value);
+						const subRouterName = (subRouterArg as ASTNodeIdentifier).name;
+						const subRouterImportPath = importMap.get(subRouterName);
+
+						if (subRouterImportPath) {
+							const resolvedFile = resolveImportPath(dirname(filename), subRouterImportPath);
+							if (resolvedFile && !visited.has(resolve(resolvedFile))) {
+								try {
+									const combinedBase = joinMountAndRoute(basePath, mountPath);
+									const subRoutes = await parseRoute(
+										rootDir,
+										resolvedFile,
+										projectId,
+										deploymentId,
+										{
+											visitedFiles: visited,
+											mountedSubrouters: options.mountedSubrouters,
+											mountPrefix: combinedBase,
+										}
+									);
+
+									if (options.mountedSubrouters) {
+										options.mountedSubrouters.add(resolve(resolvedFile));
+									}
+
+									for (const subRoute of subRoutes) {
+										const fullPath = subRoute.path;
+										const id = generateRouteId(
+											projectId,
+											deploymentId,
+											subRoute.type,
+											subRoute.method,
+											rel,
+											fullPath,
+											subRoute.version
+										);
+
+										const config = { ...subRoute.config };
+										if (subRoute.filename && subRoute.filename !== rel) {
+											config.schemaSourceFile = subRoute.filename;
+										}
+
+										routes.push({
+											...subRoute,
+											id,
+											path: fullPath,
+											filename: rel,
+											config: Object.keys(config).length > 0 ? config : undefined,
+										});
+									}
+								} catch {
+									// Sub-router parse failure — skip
+								}
+							}
+						}
+					}
+					continue;
+				}
+
+				// Handle HTTP methods: get, post, put, patch, delete
+				const CHAINED_HTTP_METHODS = ['get', 'post', 'put', 'delete', 'patch'] as const;
+				if (
+					CHAINED_HTTP_METHODS.includes(
+						chainMethod.toLowerCase() as (typeof CHAINED_HTTP_METHODS)[number]
+					)
+				) {
+					const pathArg = chainArgs[0] as ASTNode | undefined;
+					if (!pathArg || (pathArg as ASTLiteral).type !== 'Literal') continue;
+
+					const suffix = String((pathArg as ASTLiteral).value);
+					let type = 'api';
+
+					// Check for websocket/sse/stream wrappers in handler args
+					for (const arg of chainArgs.slice(1)) {
+						if ((arg as ASTCallExpression)?.type === 'CallExpression') {
+							const callExpr = arg as ASTCallExpression;
+							if (callExpr.callee?.type === 'Identifier') {
+								const calleeName = (callExpr.callee as ASTNodeIdentifier).name;
+								if (
+									calleeName === 'websocket' ||
+									calleeName === 'sse' ||
+									calleeName === 'stream'
+								) {
+									type = calleeName;
+									break;
+								}
+							}
+						}
+					}
+
+					const thepath = joinMountAndRoute(basePath, suffix);
+					const id = generateRouteId(
+						projectId,
+						deploymentId,
+						type,
+						chainMethod,
+						rel,
+						thepath,
+						version
+					);
+
+					// Check for validators in chained args
+					const validatorInfo = hasValidatorCall(chainArgs as unknown[]);
+					const routeConfig: Record<string, unknown> = {};
+					if (validatorInfo.hasValidator) {
+						routeConfig.hasValidator = true;
+						if (validatorInfo.agentVariable) {
+							routeConfig.agentVariable = validatorInfo.agentVariable;
+							const agentImportPath = importMap.get(validatorInfo.agentVariable);
+							if (agentImportPath) routeConfig.agentImportPath = agentImportPath;
+						}
+						if (validatorInfo.inputSchemaVariable) {
+							routeConfig.inputSchemaVariable = validatorInfo.inputSchemaVariable;
+							const inputImportInfo = importInfoMap.get(validatorInfo.inputSchemaVariable);
+							if (inputImportInfo) {
+								routeConfig.inputSchemaImportPath = inputImportInfo.modulePath;
+								routeConfig.inputSchemaImportedName = inputImportInfo.importedName;
+							}
+						}
+						if (validatorInfo.outputSchemaVariable) {
+							routeConfig.outputSchemaVariable = validatorInfo.outputSchemaVariable;
+							const outputImportInfo = importInfoMap.get(validatorInfo.outputSchemaVariable);
+							if (outputImportInfo) {
+								routeConfig.outputSchemaImportPath = outputImportInfo.modulePath;
+								routeConfig.outputSchemaImportedName = outputImportInfo.importedName;
+							}
+						}
+						if (validatorInfo.stream !== undefined) routeConfig.stream = validatorInfo.stream;
+					}
+
+					// Fall back to exported schemas
+					if (!routeConfig.inputSchemaVariable && exportedInputSchemaName) {
+						routeConfig.inputSchemaVariable = exportedInputSchemaName;
+					}
+					if (!routeConfig.outputSchemaVariable && exportedOutputSchemaName) {
+						routeConfig.outputSchemaVariable = exportedOutputSchemaName;
+					}
+
+					routes.push({
+						id,
+						method: chainMethod as 'get' | 'post' | 'put' | 'delete' | 'patch',
+						type: type as 'api' | 'sms' | 'email' | 'cron',
+						filename: rel,
+						path: thepath,
+						version,
+						config: Object.keys(routeConfig).length > 0 ? routeConfig : undefined,
+					});
+				}
+			}
+		}
 	} catch (error) {
 		if (error instanceof InvalidRouterConfigError || error instanceof SchemaNotExportedError) {
 			throw error;

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

@@ -84,6 +84,7 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 		`  createCompressionMiddleware,`,
 		`  getAppState,`,
 		`  getAppConfig,`,
+		`  getUserRouter,`,
 		`  register,`,
 		`  getSpanProcessors,`,
 		`  createServices,`,
@@ -151,8 +152,25 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 	const apiMount =
 		routeImportsAndMounts.length > 0
 			? `
-// Mount API routes
-${routeImportsAndMounts.join('\n')}
+// Apply middleware and mount API routes
+// If user passed router(s) via createApp({ router }), mount those instead of discovered files
+const __userMounts = getUserRouter();
+if (__userMounts) {
+	for (const mount of __userMounts) {
+		// Apply Agentuity middleware (CORS, OTel, agent context) to each user-provided prefix
+		const prefix = mount.path.endsWith('/') ? mount.path + '*' : mount.path + '/*';
+		app.use(prefix, createCorsMiddleware());
+		app.use(prefix, createOtelMiddleware());
+		app.use(prefix, createAgentMiddleware(''));
+		app.route(mount.path, mount.router);
+	}
+} else {
+	// File-based routing: apply middleware to /api/* and mount discovered route files
+	app.use('/api/*', createCorsMiddleware());
+	app.use('/api/*', createOtelMiddleware());
+	app.use('/api/*', createAgentMiddleware(''));
+${routeImportsAndMounts.map((line) => `\t${line}`).join('\n')}
+}
 `
 			: '';
 
@@ -682,22 +700,11 @@ app.use('*', createBaseMiddleware({
 	meter: otel.meter,
 }));
 
-// Note: Workbench routes use their own CORS middleware (defined in createWorkbenchRouter)
-// which includes signature headers for production authentication
-app.use('/api/*', createCorsMiddleware());
-
-// Critical: otelMiddleware creates session/thread/waitUntilHandler
-// Only apply to routes that need full session tracking:
-// - /api/* routes (agent/API invocations)
-// - /_agentuity/workbench/* routes (workbench API)
-// Explicitly excluded (no session tracking, no Catalyst events):
-// - /_agentuity/webanalytics/* (web analytics - uses lightweight cookie-only middleware)
-// - /_agentuity/health, /_agentuity/ready, /_agentuity/idle (health checks)
+// Workbench routes always get OTel middleware for session tracking
 app.use('/_agentuity/workbench/*', createOtelMiddleware());
-app.use('/api/*', createOtelMiddleware());
 
-// Critical: agentMiddleware sets up agent context
-app.use('/api/*', createAgentMiddleware(''));
+// Note: /api/* middleware (CORS, OTel, agent context) is applied in Step 6
+// after app.ts import, so user-provided routers can specify custom prefixes.
 
 // Step 4: Import user's app.ts (runs createApp, gets state/config)
 await import('../../app.js');

package/src/cmd/build/vite/bundle-files.ts

@@ -0,0 +1,135 @@
+import { join, dirname } from 'node:path';
+import { mkdirSync, cpSync } from 'node:fs';
+import type { Logger } from '../../../types';
+
+/** Paths that are always excluded regardless of .gitignore */
+function isHardExcluded(match: string): boolean {
+	return (
+		match.startsWith('.agentuity/') ||
+		match.startsWith('.agentuity\\') ||
+		match.startsWith('node_modules/') ||
+		match.startsWith('node_modules\\') ||
+		match.startsWith('.git/') ||
+		match.startsWith('.git\\') ||
+		match === '.env' ||
+		match.startsWith('.env.')
+	);
+}
+
+/**
+ * Use `git check-ignore --stdin` to filter out files that are ignored by .gitignore.
+ * Returns the subset of `files` that are NOT gitignored.
+ * Falls back to returning all files if not in a git repo or git is unavailable.
+ */
+async function filterGitIgnored(
+	rootDir: string,
+	files: string[],
+	logger: Logger
+): Promise<string[]> {
+	if (files.length === 0) return files;
+
+	try {
+		// Check if we're in a git repo
+		const gitCheck = Bun.spawnSync(['git', 'rev-parse', '--git-dir'], {
+			cwd: rootDir,
+			stderr: 'pipe',
+		});
+		if (gitCheck.exitCode !== 0) {
+			logger.debug('Not a git repository, skipping .gitignore filtering');
+			return files;
+		}
+
+		// Use git check-ignore to find which files are ignored
+		const proc = Bun.spawn(['git', 'check-ignore', '--stdin'], {
+			cwd: rootDir,
+			stdin: 'pipe',
+			stdout: 'pipe',
+			stderr: 'pipe',
+		});
+
+		// Write all file paths to stdin, one per line
+		proc.stdin.write(files.join('\n'));
+		proc.stdin.end();
+
+		const output = await new Response(proc.stdout).text();
+		await proc.exited;
+
+		// git check-ignore exits 0 if some files are ignored, 1 if none are ignored.
+		// Both are fine. Other exit codes mean an error.
+
+		const ignoredFiles = output
+			.split('\n')
+			.map((line) => line.trim())
+			.filter(Boolean);
+		const ignoredSet = new Set(ignoredFiles);
+
+		if (ignoredSet.size > 0) {
+			logger.debug(`Filtered ${ignoredSet.size} gitignored file(s) from bundle`);
+		}
+
+		return files.filter((f) => !ignoredSet.has(f));
+	} catch {
+		logger.debug('git not available, skipping .gitignore filtering');
+		return files;
+	}
+}
+
+/**
+ * Copy files matching glob patterns into the build output directory.
+ * Files are copied preserving their relative directory structure from the project root.
+ * This runs BEFORE the build steps so that build output can overwrite any conflicts.
+ *
+ * Filtering layers:
+ * 1. Hard exclusions: .agentuity/, node_modules/, .git/, .env* (always skipped)
+ * 2. .gitignore: files ignored by git are skipped (falls back if not a git repo)
+ */
+export async function copyBundleFiles(
+	rootDir: string,
+	outDir: string,
+	patterns: string[],
+	logger: Logger
+): Promise<number> {
+	let totalCopied = 0;
+
+	// Ensure output directory exists
+	mkdirSync(outDir, { recursive: true });
+
+	for (const pattern of patterns) {
+		const glob = new Bun.Glob(pattern);
+		const candidates: string[] = [];
+
+		// Phase 1: Glob match + hard exclusions
+		for await (const match of glob.scan({ cwd: rootDir, onlyFiles: true })) {
+			if (!isHardExcluded(match)) {
+				candidates.push(match);
+			}
+		}
+
+		// Phase 2: Filter out gitignored files
+		const filesToCopy = await filterGitIgnored(rootDir, candidates, logger);
+
+		// Phase 3: Copy files
+		for (const match of filesToCopy) {
+			const src = join(rootDir, match);
+			const dest = join(outDir, match);
+			try {
+				mkdirSync(dirname(dest), { recursive: true });
+				cpSync(src, dest);
+			} catch (err) {
+				throw new Error(
+					`Failed to copy bundle file '${match}' (pattern '${pattern}'): ${(err as Error).message}`
+				);
+			}
+		}
+
+		if (filesToCopy.length === 0) {
+			logger.warn(`Bundle pattern '${pattern}' matched no files`);
+		} else {
+			logger.debug(`Bundle pattern '${pattern}': ${filesToCopy.length} file(s)`);
+		}
+
+		totalCopied += filesToCopy.length;
+	}
+
+	return totalCopied;
+}