@agentuity/cli 1.0.39 → 1.0.41

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

@@ -1,8 +1,9 @@
 /**
  * Route Discovery - READ-ONLY AST analysis
  *
- * Discovers routes by scanning src/api/**\/*.ts files
- * Extracts route definitions WITHOUT mutating source files
+ * Discovers routes by scanning src/api/**\/*.ts files or by following
+ * explicit router mounts from createApp({ router }).
+ * Extracts route definitions WITHOUT mutating source files.
  */
 
 import { join, relative } from 'node:path';
@@ -10,6 +11,7 @@ import { existsSync } from 'node:fs';
 import type { Logger } from '../../../types';
 import { parseRoute } from '../ast';
 import { toForwardSlash } from '../../../utils/normalize-path';
+import { detectExplicitRouter, type AppRouterDetection } from '../app-router-detector';
 
 export interface RouteMetadata {
 	id: string;
@@ -46,6 +48,12 @@ export interface RouteInfo {
 	outputSchemaCode?: string;
 	stream?: boolean;
 	pathParams?: string[];
+	/**
+	 * When a route is mounted via .route(), its filename is set to the parent file
+	 * (for dedup filtering). schemaSourceFile preserves the actual file where the
+	 * route's schema variables are defined/exported, so registry imports resolve correctly.
+	 */
+	schemaSourceFile?: string;
 }
 
 /**
@@ -66,13 +74,152 @@ export function extractPathParams(path: string): string[] {
 }
 
 /**
- * Discover all routes in src/api directory (READ-ONLY)
+ * Discover all routes — tries explicit router detection first, falls back to file-based.
+ *
+ * When `createApp({ router })` is detected in app.ts, routes are discovered by
+ * following the router imports with code-derived mount paths. Otherwise, falls back
+ * to scanning src/api/**\/*.ts with filesystem-derived paths.
  */
 export async function discoverRoutes(
 	srcDir: string,
 	projectId: string,
 	deploymentId: string,
 	logger: Logger
+): Promise<{
+	routes: RouteMetadata[];
+	routeInfoList: RouteInfo[];
+	/** Whether explicit router was detected (vs file-based fallback) */
+	explicitRouter?: AppRouterDetection;
+}> {
+	const rootDir = join(srcDir, '..');
+
+	// Try explicit router detection first
+	const detection = await detectExplicitRouter(rootDir, logger);
+	if (detection.detected && detection.mounts.length > 0) {
+		logger.debug(
+			'Using explicit router detection (%d mount(s) from createApp)',
+			detection.mounts.length
+		);
+		const result = await discoverExplicitRoutes(
+			rootDir,
+			srcDir,
+			projectId,
+			deploymentId,
+			detection,
+			logger
+		);
+		return { ...result, explicitRouter: detection };
+	}
+
+	// Fall back to file-based discovery
+	return discoverFileBasedRoutes(srcDir, projectId, deploymentId, logger);
+}
+
+/**
+ * Discover routes from explicit router mounts detected in app.ts.
+ * Parses each router file with its code-derived mount prefix.
+ */
+async function discoverExplicitRoutes(
+	rootDir: string,
+	srcDir: string,
+	projectId: string,
+	deploymentId: string,
+	detection: AppRouterDetection,
+	logger: Logger
+): Promise<{ routes: RouteMetadata[]; routeInfoList: RouteInfo[] }> {
+	const routes: RouteMetadata[] = [];
+	const routeInfoList: RouteInfo[] = [];
+	const visited = new Set<string>();
+	const mountedSubrouters = new Set<string>();
+
+	for (const mount of detection.mounts) {
+		try {
+			const parsedRoutes = await parseRoute(rootDir, mount.routerFile, projectId, deploymentId, {
+				visitedFiles: visited,
+				mountedSubrouters,
+				mountPrefix: mount.path,
+			});
+
+			if (parsedRoutes.length > 0) {
+				const relFile = './' + toForwardSlash(relative(srcDir, mount.routerFile));
+				logger.trace(
+					'Discovered %d route(s) from explicit mount at %s (%s)',
+					parsedRoutes.length,
+					mount.path,
+					relFile
+				);
+				routes.push(...parsedRoutes);
+
+				for (const route of parsedRoutes) {
+					const pathParams = extractPathParams(route.path);
+					routeInfoList.push({
+						method: route.method.toUpperCase(),
+						path: route.path,
+						filename: route.filename,
+						hasValidator: route.config?.hasValidator === true,
+						routeType: route.type || 'api',
+						agentVariable: route.config?.agentVariable as string | undefined,
+						agentImportPath: route.config?.agentImportPath as string | undefined,
+						inputSchemaVariable: route.config?.inputSchemaVariable as string | undefined,
+						outputSchemaVariable: route.config?.outputSchemaVariable as string | undefined,
+						inputSchemaImportPath: route.config?.inputSchemaImportPath as string | undefined,
+						inputSchemaImportedName: route.config?.inputSchemaImportedName as
+							| string
+							| undefined,
+						outputSchemaImportPath: route.config?.outputSchemaImportPath as
+							| string
+							| undefined,
+						outputSchemaImportedName: route.config?.outputSchemaImportedName as
+							| string
+							| undefined,
+						stream:
+							route.config?.stream !== undefined && route.config.stream !== null
+								? Boolean(route.config.stream)
+								: route.type === 'stream'
+									? true
+									: undefined,
+						pathParams: pathParams.length > 0 ? pathParams : undefined,
+						schemaSourceFile: route.config?.schemaSourceFile as string | undefined,
+					});
+				}
+			}
+		} catch (error) {
+			logger.warn(
+				'Failed to parse explicit router at %s: %s',
+				mount.routerFile,
+				error instanceof Error ? error.message : String(error)
+			);
+		}
+	}
+
+	logger.debug('Discovered %d route(s) via explicit router detection', routes.length);
+
+	// Check for route conflicts
+	const conflicts = detectRouteConflicts(routeInfoList);
+	if (conflicts.length > 0) {
+		logger.error('Route conflicts detected:');
+		for (const conflict of conflicts) {
+			logger.error('  %s', conflict.message);
+			for (const route of conflict.routes) {
+				logger.error('    - %s %s in %s', route.method, route.path, route.filename);
+			}
+		}
+		throw new Error(
+			`Found ${conflicts.length} route conflict(s). Fix the conflicts and try again.`
+		);
+	}
+
+	return { routes, routeInfoList };
+}
+
+/**
+ * Discover routes by scanning src/api directory (original file-based approach).
+ */
+async function discoverFileBasedRoutes(
+	srcDir: string,
+	projectId: string,
+	deploymentId: string,
+	logger: Logger
 ): Promise<{ routes: RouteMetadata[]; routeInfoList: RouteInfo[] }> {
 	const apiDir = join(srcDir, 'api');
 	const routes: RouteMetadata[] = [];
@@ -154,6 +301,7 @@ export async function discoverRoutes(
 										? true
 										: undefined,
 							pathParams: pathParams.length > 0 ? pathParams : undefined,
+							schemaSourceFile: route.config?.schemaSourceFile as string | undefined,
 						});
 					}
 				}

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

@@ -10,6 +10,7 @@ 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';
@@ -89,6 +90,9 @@ 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/dev/index.ts

@@ -20,6 +20,11 @@ import { isTTY, hasLoggedInBefore } from '../../auth';
 import { createFileWatcher } from './file-watcher';
 import { prepareDevLock, releaseLockSync } from './dev-lock';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
+import {
+	promptRouteMigration,
+	performMigration,
+	checkMigrationEligibility,
+} from '../../utils/route-migration';
 import { ErrorCode } from '../../errors';
 
 const DEFAULT_PORT = 3500;
@@ -232,6 +237,12 @@ export const command = createCommand({
 				.boolean()
 				.optional()
 				.describe('Skip TypeScript type checking on startup and restarts'),
+			migrateRoutes: z
+				.boolean()
+				.optional()
+				.describe(
+					'Migrate file-based routes to explicit routing (src/api/index.ts root router)'
+				),
 			resume: z.string().optional().describe('Resume a paused Hub session by ID'),
 		}),
 	},
@@ -414,6 +425,29 @@ export const command = createCommand({
 			);
 		}
 
+		// Check if project can migrate to explicit routing
+		if (opts.migrateRoutes) {
+			const eligibility = checkMigrationEligibility(rootDir);
+			if (eligibility.available) {
+				const result = performMigration(rootDir, eligibility.routeFiles);
+				if (result.success) {
+					tui.success(result.message);
+					if (result.filesCreated.length > 0) {
+						tui.info(`Created: ${result.filesCreated.map((f) => tui.muted(f)).join(', ')}`);
+					}
+					tui.newline();
+				} else {
+					tui.warning(result.message);
+					tui.newline();
+				}
+			} else {
+				tui.info('No migration needed — already using explicit routing.');
+				tui.newline();
+			}
+		} else {
+			await promptRouteMigration(rootDir, logger, { interactive });
+		}
+
 		try {
 			// Setup devmode and gravity (if using public URL)
 			const useMockService = process.env.DEVMODE_SYNC_SERVICE_MOCK === 'true';

package/src/cmd/project/import.ts

@@ -46,6 +46,10 @@ export const importSubcommand = createSubcommand({
 			),
 			description: 'Import with resource provisioning and push to new repo',
 		},
+		{
+			command: getCommand('project import --name my-agent --confirm'),
+			description: 'Import project non-interactively, skipping prompts',
+		},
 	],
 	requires: { auth: true, apiClient: true },
 	optional: { region: true, org: true },
@@ -71,6 +75,7 @@ export const importSubcommand = createSubcommand({
 				.optional()
 				.describe('Target GitHub repo (owner/repo) to push imported code to'),
 			name: z.string().optional().describe('Project name (for non-interactive mode)'),
+			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
 			env: z
 				.array(z.string())
 				.optional()
@@ -100,6 +105,7 @@ export const importSubcommand = createSubcommand({
 				env: opts.env,
 				org: orgId,
 				region,
+				confirm: opts.confirm,
 				apiClient,
 				auth,
 				config,
@@ -123,8 +129,12 @@ export const importSubcommand = createSubcommand({
 			apiClient,
 			config,
 			logger,
-			interactive: validateOnly ? false : isTTY(),
+			interactive: validateOnly ? false : opts.confirm ? false : isTTY(),
 			validateOnly,
+			confirm: opts.confirm === true,
+			orgId,
+			region,
+			name: opts.name,
 		});
 
 		if (result.status === 'error') {

package/src/cmd/project/reconcile.ts

@@ -40,6 +40,14 @@ export interface ReconcileOptions {
 	interactive?: boolean;
 	/** If true, skip prompts and just validate */
 	validateOnly?: boolean;
+	/** If true, auto-confirm all prompts (--confirm flag) */
+	confirm?: boolean;
+	/** Pre-selected organization ID (skips org selection prompt) */
+	orgId?: string;
+	/** Pre-selected region (skips region selection prompt) */
+	region?: string;
+	/** Project name from --name flag */
+	name?: string;
 }
 
 /**
@@ -315,7 +323,7 @@ async function importExistingProject(
 ): Promise<ReconcileResult> {
 	const { dir, apiClient, config, logger } = opts;
 
-	if (!options?.skipPrompt) {
+	if (!options?.skipPrompt && opts.interactive !== false) {
 		tui.warning(
 			"You don't have access to this project. It may have been deleted or transferred to another organization."
 		);
@@ -333,29 +341,67 @@ async function importExistingProject(
 		tui.newline();
 	}
 
-	// Select org
-	const orgId = await selectOrg(orgs, config, existingConfig.orgId);
+	// Select org - use --org-id if provided, otherwise auto-select or prompt
+	let orgId: string;
+	if (opts.orgId) {
+		orgId = opts.orgId;
+	} else if (opts.confirm) {
+		orgId = await tui.selectOrganization(orgs, config.preferences?.orgId, true);
+	} else {
+		orgId = await selectOrg(orgs, config, existingConfig.orgId);
+	}
 
-	// Fetch regions and select
-	const regions = await tui.spinner({
-		message: 'Fetching regions',
-		clearOnSuccess: true,
-		callback: () => fetchRegionsWithCache(config.name, apiClient, logger),
-	});
-	const region = await selectRegion(regions, existingConfig.region);
+	// Select region (use pre-selected if available, otherwise fetch and prompt/auto-select)
+	let region: string;
+	if (opts.region) {
+		region = opts.region;
+	} else {
+		const regions = await tui.spinner({
+			message: 'Fetching regions',
+			clearOnSuccess: true,
+			callback: () => fetchRegionsWithCache(config.name, apiClient, logger),
+		});
+
+		if (opts.confirm) {
+			// Auto-select: use existing config region if valid, otherwise first available
+			const defaultRegion = existingConfig.region;
+			if (defaultRegion && regions.some((r) => r.region === defaultRegion)) {
+				region = defaultRegion;
+			} else {
+				const firstRegion = regions[0];
+				if (!firstRegion) {
+					return { status: 'error', message: 'No cloud regions available.' };
+				}
+				region = firstRegion.region;
+			}
+		} else {
+			region = await selectRegion(regions, existingConfig.region);
+		}
+	}
 
 	// Get project name
 	const defaultName = await getDefaultProjectName(dir);
-	const projectName = await textPrompt({
-		message: 'Project name:',
-		initial: defaultName,
-		validate: (value: string) => {
-			if (!value || value.trim().length === 0) {
-				return 'Project name is required';
-			}
-			return true;
-		},
-	});
+	let projectName: string;
+	if (opts.name) {
+		const trimmed = opts.name.trim();
+		if (trimmed.length === 0) {
+			return { status: 'error', message: 'Project name is required.' };
+		}
+		projectName = trimmed;
+	} else if (opts.confirm) {
+		projectName = defaultName;
+	} else {
+		projectName = await textPrompt({
+			message: 'Project name:',
+			initial: defaultName,
+			validate: (value: string) => {
+				if (!value || value.trim().length === 0) {
+					return 'Project name is required';
+				}
+				return true;
+			},
+		});
+	}
 
 	// Create the project
 	const newProject = await tui.spinner({
@@ -407,51 +453,87 @@ async function importExistingProject(
 async function createNewProject(opts: ReconcileOptions): Promise<ReconcileResult> {
 	const { dir, apiClient, config, logger } = opts;
 
-	tui.warning('This project is not registered with Agentuity Cloud.');
-	tui.newline();
+	if (opts.interactive !== false) {
+		tui.warning('This project is not registered with Agentuity Cloud.');
+		tui.newline();
+
+		const shouldCreate = await tui.confirm('Would you like to register it now?', true);
 
-	const shouldCreate = await tui.confirm('Would you like to register it now?', true);
+		if (!shouldCreate) {
+			return { status: 'skipped', message: 'Project registration cancelled.' };
+		}
 
-	if (!shouldCreate) {
-		return { status: 'skipped', message: 'Project registration cancelled.' };
+		tui.newline();
 	}
 
-	tui.newline();
-
-	// Fetch user's orgs
-	const orgs = await tui.spinner({
-		message: 'Fetching organizations',
-		clearOnSuccess: true,
-		callback: () => listOrganizations(apiClient),
-	});
+	// Select org - use --org-id if provided, otherwise fetch and select/auto-select
+	let orgId: string;
+	if (opts.orgId) {
+		orgId = opts.orgId;
+	} else {
+		// Fetch user's orgs
+		const orgs = await tui.spinner({
+			message: 'Fetching organizations',
+			clearOnSuccess: true,
+			callback: () => listOrganizations(apiClient),
+		});
+
+		if (orgs.length === 0) {
+			return { status: 'error', message: 'No organizations found for your account.' };
+		}
 
-	if (orgs.length === 0) {
-		return { status: 'error', message: 'No organizations found for your account.' };
+		if (opts.confirm) {
+			orgId = await tui.selectOrganization(orgs, config.preferences?.orgId, true);
+		} else {
+			orgId = await selectOrg(orgs, config);
+		}
 	}
 
-	// Select org
-	const orgId = await selectOrg(orgs, config);
-
-	// Fetch regions and select
-	const regions = await tui.spinner({
-		message: 'Fetching regions',
-		clearOnSuccess: true,
-		callback: () => fetchRegionsWithCache(config.name, apiClient, logger),
-	});
-	const region = await selectRegion(regions);
+	// Select region (use pre-selected if available, otherwise fetch and prompt/auto-select)
+	let region: string;
+	if (opts.region) {
+		region = opts.region;
+	} else {
+		const regions = await tui.spinner({
+			message: 'Fetching regions',
+			clearOnSuccess: true,
+			callback: () => fetchRegionsWithCache(config.name, apiClient, logger),
+		});
+
+		if (opts.confirm) {
+			const firstRegion = regions[0];
+			if (!firstRegion) {
+				return { status: 'error', message: 'No cloud regions available.' };
+			}
+			region = firstRegion.region;
+		} else {
+			region = await selectRegion(regions);
+		}
+	}
 
 	// Get project name from package.json or prompt
 	const defaultName = await getDefaultProjectName(dir);
-	const projectName = await textPrompt({
-		message: 'Project name:',
-		initial: defaultName,
-		validate: (value: string) => {
-			if (!value || value.trim().length === 0) {
-				return 'Project name is required';
-			}
-			return true;
-		},
-	});
+	let projectName: string;
+	if (opts.name) {
+		const trimmed = opts.name.trim();
+		if (trimmed.length === 0) {
+			return { status: 'error', message: 'Project name is required.' };
+		}
+		projectName = trimmed;
+	} else if (opts.confirm) {
+		projectName = defaultName;
+	} else {
+		projectName = await textPrompt({
+			message: 'Project name:',
+			initial: defaultName,
+			validate: (value: string) => {
+				if (!value || value.trim().length === 0) {
+					return 'Project name is required';
+				}
+				return true;
+			},
+		});
+	}
 
 	// Create the project
 	const newProject = await tui.spinner({
@@ -627,7 +709,7 @@ export async function runProjectImport(opts: ReconcileOptions): Promise<Reconcil
 			}
 
 			// Has agentuity.json but no access - offer to import
-			if (!interactive) {
+			if (!interactive && !opts.confirm) {
 				return {
 					status: 'error',
 					message:
@@ -635,10 +717,12 @@ export async function runProjectImport(opts: ReconcileOptions): Promise<Reconcil
 				};
 			}
 
-			return await importExistingProject(opts, projectConfig, userOrgs);
+			return await importExistingProject(opts, projectConfig, userOrgs, {
+				skipPrompt: opts.confirm,
+			});
 		} catch {
 			// Project doesn't exist - offer to import
-			if (!interactive) {
+			if (!interactive && !opts.confirm) {
 				return {
 					status: 'error',
 					message: 'Project not found. Run interactively to import it to your organization.',
@@ -646,14 +730,16 @@ export async function runProjectImport(opts: ReconcileOptions): Promise<Reconcil
 			}
 
 			const userOrgs = await listOrganizations(apiClient);
-			return await importExistingProject(opts, projectConfig, userOrgs);
+			return await importExistingProject(opts, projectConfig, userOrgs, {
+				skipPrompt: opts.confirm,
+			});
 		}
 	}
 
 	// No agentuity.json - validate structure and create new project
 	const isValid = await isValidProjectStructure(dir);
 
-	if (!isValid) {
+	if (!isValid && !opts.confirm) {
 		return {
 			status: 'error',
 			message:
@@ -670,7 +756,7 @@ export async function runProjectImport(opts: ReconcileOptions): Promise<Reconcil
 		};
 	}
 
-	if (!interactive) {
+	if (!interactive && !opts.confirm) {
 		return {
 			status: 'error',
 			message: 'Project import requires interactive mode.',

package/src/cmd/project/remote-import.ts

@@ -62,6 +62,8 @@ export interface RemoteImportOptions {
 	env?: string[];
 	org?: string;
 	region?: string;
+	/** If true, skip confirmation prompts (--confirm flag) */
+	confirm?: boolean;
 	apiClient: APIClient;
 	auth: AuthData;
 	config: Config;
@@ -744,7 +746,7 @@ export async function runRemoteImport(options: RemoteImportOptions): Promise<voi
 				optRegion,
 				org
 			);
-		} else if (isTTY()) {
+		} else if (isTTY() && !options.confirm) {
 			// Interactive mode: prompt for org/region/name
 			projectInfo = await createProjectInteractive(apiClient, config, logger, parsed.repo);
 		} else {
@@ -893,7 +895,7 @@ export async function runRemoteImport(options: RemoteImportOptions): Promise<voi
 		}
 
 		const resourceEnvVars: Record<string, string> = {};
-		const interactive = isTTY();
+		const interactive = isTTY() && !options.confirm;
 		const templateResources = template?.requirements?.resources ?? [];
 		const templateEnvVars = template?.requirements?.env ?? [];
 

package/src/config.ts

@@ -141,6 +141,8 @@ function expandTilde(path: string): string {
 }
 
 let cachedConfig: Config | null | undefined;
+// Track the resolved config path so saveConfig writes back to the same file
+let cachedConfigPath: string | undefined;
 
 export async function loadConfig(
 	customPath?: string,
@@ -217,6 +219,7 @@ export async function loadConfig(
 		// This ensures --config flag is respected across all commands
 		if (!skipCache) {
 			cachedConfig = result.data;
+			cachedConfigPath = configPath;
 		}
 		return result.data;
 	} catch (error) {
@@ -227,6 +230,7 @@ export async function loadConfig(
 		// Note: For long-running processes, consider time-based cache expiry for transient failures.
 		if (!skipCache) {
 			cachedConfig = null;
+			cachedConfigPath = configPath;
 		}
 		return null;
 	}
@@ -275,7 +279,10 @@ function formatYAML(obj: unknown, indent = 0): string {
 }
 
 export async function saveConfig(config: Config, customPath?: string): Promise<void> {
-	const configPath = customPath || (await getProfile());
+	// Use the path the config was originally loaded from (cachedConfigPath) so that
+	// saves go back to the correct profile even when --profile was used to load it.
+	// Falls back to getProfile() if no config has been loaded yet.
+	const configPath = customPath || cachedConfigPath || (await getProfile());
 	await ensureConfigDir();
 
 	const content = formatYAML(config);

package/src/schema-parser.ts

@@ -443,8 +443,14 @@ export function buildValidationInput(
 			const camelCaseName = opt.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 			let value = rawOptions[opt.name] ?? rawOptions[camelCaseName];
 
-			// Handle --yes alias for --confirm: if confirm is not set but yes is, use yes value
-			if (opt.name === 'confirm' && value === undefined && rawOptions.yes === true) {
+			// Handle --yes and --force aliases for --confirm: if confirm is not set but yes/force is, use that value
+			// Only treat --force as a --confirm alias if the schema does NOT declare a separate 'force' option
+			if (
+				opt.name === 'confirm' &&
+				value === undefined &&
+				(rawOptions.yes === true ||
+					(rawOptions.force === true && !parsed.some((o) => o.name === 'force')))
+			) {
 				value = true;
 			}