@agentuity/cli 0.1.26 → 0.1.28

package/src/cmd/build/ast.ts

@@ -11,6 +11,11 @@ import type { LogLevel } from '../../types';
 import { existsSync, mkdirSync } from 'node:fs';
 import JSON5 from 'json5';
 import { formatSchemaCode } from './format-schema';
+import {
+	computeApiMountPath,
+	joinMountAndRoute,
+	extractRelativeApiPath,
+} from './vite/api-mount-path';
 
 const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel);
 
@@ -1492,26 +1497,18 @@ export async function parseRoute(
 
 	const rel = relative(rootDir, filename);
 
-	// For src/api/index.ts, we don't want to add the folder name since it's the root API router
-	const isRootApi = filename.includes('src/api/index.ts');
-
-	// For nested routes, use the full path from src/api/ instead of just the immediate parent
-	// e.g., src/api/v1/users/route.ts -> routeName = "v1/users"
-	//       src/api/auth/route.ts -> routeName = "auth"
-	//       src/api/test.ts -> routeName = "" (file directly in src/api/)
-	let routeName = '';
-	if (!isRootApi) {
-		const apiMatch = filename.match(/src\/api\/(.+?)\/[^/]+\.ts$/);
-		if (apiMatch) {
-			// File in subdirectory: src/api/auth/route.ts -> "auth"
-			routeName = apiMatch[1];
-		}
-		// For files directly in src/api/ (e.g., test.ts), routeName stays empty
-		// This prevents double /api prefix since these files often define full paths
-	}
+	// 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);
 
 	const routes: RouteDefinition = [];
-	const routePrefix = '/api';
 
 	try {
 		for (const body of ast.body) {
@@ -1593,9 +1590,7 @@ export async function parseRoute(
 
 								// Create a route entry for each method
 								for (const httpMethod of methods) {
-									const thepath = `${routePrefix}/${routeName}/${pathSuffix}`
-										.replaceAll(/\/{2,}/g, '/')
-										.replaceAll(/\/$/g, '');
+									const thepath = joinMountAndRoute(basePath, pathSuffix);
 									const id = generateRouteId(
 										projectId,
 										deploymentId,
@@ -1692,9 +1687,7 @@ export async function parseRoute(
 
 								// Create a route entry for each supported method
 								for (const httpMethod of SUPPORTED_HTTP_METHODS) {
-									const thepath = `${routePrefix}/${routeName}/${pathSuffix}`
-										.replaceAll(/\/{2,}/g, '/')
-										.replaceAll(/\/$/g, '');
+									const thepath = joinMountAndRoute(basePath, pathSuffix);
 									const id = generateRouteId(
 										projectId,
 										deploymentId,
@@ -1888,9 +1881,7 @@ export async function parseRoute(
 								});
 							}
 						}
-						const thepath = `${routePrefix}/${routeName}/${suffix}`
-							.replaceAll(/\/{2,}/g, '/')
-							.replaceAll(/\/$/g, '');
+						const thepath = joinMountAndRoute(basePath, suffix);
 						const id = generateRouteId(
 							projectId,
 							deploymentId,

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

@@ -7,6 +7,7 @@ import { join } from 'node:path';
 import type { Logger, WorkbenchConfig, AnalyticsConfig } from '../../types';
 import { discoverRoutes } from './vite/route-discovery';
 import { generateWebAnalyticsFile } from './webanalytics-generator';
+import { computeApiMountPath } from './vite/api-mount-path';
 
 interface GenerateEntryOptions {
 	rootDir: string;
@@ -107,21 +108,14 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 	let routeIndex = 0;
 
 	for (const routeFile of sortedRouteFiles) {
+		// Normalize path separators for cross-platform compatibility (Windows uses backslashes)
+		const normalizedRouteFile = routeFile.replace(/\\/g, '/');
 		// Convert src/api/auth/route.ts -> auth/route
-		const relativePath = routeFile.replace(/^src\/api\//, '').replace(/\.tsx?$/, '');
-
-		// Determine the mount path
-		// src/api/index.ts -> /api
-		// src/api/auth/route.ts -> /api/auth
-		// src/api/users/profile/route.ts -> /api/users/profile
-		let mountPath = '/api';
-		if (relativePath !== 'index') {
-			// Remove 'route' or 'index' from the end
-			const cleanPath = relativePath.replace(/\/(route|index)$/, '');
-			if (cleanPath) {
-				mountPath = `/api/${cleanPath}`;
-			}
-		}
+		const relativePath = normalizedRouteFile.replace(/^src\/api\//, '').replace(/\.tsx?$/, '');
+
+		// Determine the mount path using the shared helper
+		// This ensures consistency with route type generation in ast.ts
+		const mountPath = computeApiMountPath(relativePath);
 
 		const importName = `router_${routeIndex++}`;
 		routeImportsAndMounts.push(

package/src/cmd/build/vite/api-mount-path.ts

@@ -0,0 +1,87 @@
+/**
+ * API Mount Path Utilities
+ *
+ * Shared helpers for computing API route mount paths from file paths.
+ * Used by both entry-generator.ts (runtime mounting) and ast.ts (type generation)
+ * to ensure consistent path calculation.
+ */
+
+/**
+ * Compute the API mount path from a route file's relative path.
+ * This is the path used in app.route(mountPath, router).
+ *
+ * The mount path is based on the DIRECTORY containing the file, not the filename.
+ * Files directly in src/api/ (regardless of their name) mount at /api.
+ * Files in subdirectories mount at /api/{subdirectory}.
+ *
+ * @param relativePath - Path relative to src/api/ without extension
+ *                       e.g., 'index', 'sessions', 'auth/route', 'users/profile/route'
+ * @returns Mount path like '/api', '/api/auth', '/api/users/profile'
+ *
+ * @example
+ * computeApiMountPath('index')              // '/api' (file in src/api/)
+ * computeApiMountPath('sessions')           // '/api' (file in src/api/)
+ * computeApiMountPath('route')              // '/api' (file in src/api/)
+ * computeApiMountPath('auth/route')         // '/api/auth' (file in src/api/auth/)
+ * computeApiMountPath('auth/index')         // '/api/auth' (file in src/api/auth/)
+ * computeApiMountPath('users/profile/route') // '/api/users/profile' (file in src/api/users/profile/)
+ */
+export function computeApiMountPath(relativePath: string): string {
+	// Extract the directory path (everything before the last /)
+	const lastSlashIndex = relativePath.lastIndexOf('/');
+	if (lastSlashIndex === -1) {
+		// File is directly in src/api/ (e.g., 'index', 'sessions', 'route')
+		return '/api';
+	}
+
+	// File is in a subdirectory (e.g., 'auth/route' -> 'auth')
+	const dirPath = relativePath.substring(0, lastSlashIndex);
+	return `/api/${dirPath}`;
+}
+
+/**
+ * Join a mount base path with a route's local path.
+ * Handles normalization of slashes and empty/root paths.
+ *
+ * @param base - The mount base path (e.g., '/api/sessions')
+ * @param route - The local route path (e.g., '/', '/users', ':id')
+ * @returns The combined full path
+ *
+ * @example
+ * joinMountAndRoute('/api/sessions', '/')      // '/api/sessions'
+ * joinMountAndRoute('/api/sessions', '/users') // '/api/sessions/users'
+ * joinMountAndRoute('/api', '/health')         // '/api/health'
+ * joinMountAndRoute('/api/users', ':id')       // '/api/users/:id'
+ */
+export function joinMountAndRoute(base: string, route: string): string {
+	if (!route || route === '/') {
+		return base;
+	}
+	const normalized = route.startsWith('/') ? route : `/${route}`;
+	return `${base}${normalized}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
+}
+
+import { join, relative } from 'node:path';
+
+/**
+ * Extract the relative path from a full file path to src/api/.
+ * Normalizes path separators for cross-platform compatibility.
+ *
+ * @param filename - Full path to the route file
+ * @param srcDir - Path to the src directory
+ * @returns Path relative to src/api/ without extension
+ *
+ * @example
+ * // Given srcDir = '/project/src'
+ * extractRelativeApiPath('/project/src/api/sessions.ts', '/project/src')
+ * // Returns: 'sessions'
+ *
+ * extractRelativeApiPath('/project/src/api/auth/route.ts', '/project/src')
+ * // Returns: 'auth/route'
+ */
+export function extractRelativeApiPath(filename: string, srcDir: string): string {
+	const apiDir = join(srcDir, 'api');
+	return relative(apiDir, filename)
+		.replace(/\\/g, '/') // Normalize Windows paths
+		.replace(/\.tsx?$/, ''); // Remove extension
+}

package/src/cmd/cloud/deploy.ts

@@ -13,6 +13,7 @@ import {
 	getDefaultConfigDir,
 	loadProjectSDKKey,
 	updateProjectConfig,
+	getGlobalCatalystAPIClient,
 } from '../../config';
 import { getProjectGithubStatus } from '../git/api';
 import { runGitLink } from '../git/link';
@@ -341,8 +342,10 @@ export const deploySubcommand = createSubcommand({
 						return null;
 					}
 					logger.debug('Checking %d packages for malware', packages.length);
+					// Use Catalyst client directly for malware check (security routes are on Catalyst)
+					const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 					const result = await projectDeploymentMalwareCheck(
-						apiClient,
+						catalystClient,
 						deployment!.id,
 						packages
 					);

package/src/version-check.ts

@@ -1,4 +1,4 @@
-import type { Config, Logger, CommandDefinition } from './types';
+import type { Config, Logger, CommandDefinition, SubcommandDefinition } from './types';
 import { isRunningFromExecutable, fetchLatestVersion } from './cmd/upgrade';
 import { getVersion, getCompareUrl, getReleaseUrl, toTag } from './version';
 import * as tui from './tui';
@@ -7,6 +7,9 @@ import { $ } from 'bun';
 
 const ONE_HOUR_MS = 60 * 60 * 1000;
 
+// Tags that indicate a command should skip the upgrade prompt
+const SKIP_UPGRADE_TAGS = ['read-only', 'fast'];
+
 /**
  * Check if we should skip the version check based on environment and config
  */
@@ -20,6 +23,7 @@ function shouldSkipCheck(
 		skipVersionCheck?: boolean;
 	},
 	commandDef: CommandDefinition | undefined,
+	subcommandDef: SubcommandDefinition | undefined,
 	args: string[]
 ): boolean {
 	// Skip if running via bun/bunx (not installed executable)
@@ -64,6 +68,21 @@ function shouldSkipCheck(
 		return true;
 	}
 
+	// Skip if subcommand explicitly opts out of upgrade check
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	if (subcommandDef && (subcommandDef as any).skipUpgradeCheck === true) {
+		return true;
+	}
+
+	// Skip if command or subcommand has tags indicating it's read-only or fast
+	// These commands shouldn't be interrupted with upgrade prompts
+	const commandTags = commandDef?.tags ?? [];
+	const subcommandTags = subcommandDef?.tags ?? [];
+	const allTags = [...commandTags, ...subcommandTags];
+	if (allTags.some((tag) => SKIP_UPGRADE_TAGS.includes(tag))) {
+		return true;
+	}
+
 	// Skip for help commands
 	const helpFlags = ['--help', '-h', 'help'];
 	if (args.some((arg) => helpFlags.includes(arg))) {
@@ -187,10 +206,11 @@ export async function checkForUpdates(
 		skipVersionCheck?: boolean;
 	},
 	commandDef: CommandDefinition | undefined,
+	subcommandDef: SubcommandDefinition | undefined,
 	args: string[]
 ): Promise<void> {
 	// Determine if we should skip the check
-	if (shouldSkipCheck(config, options, commandDef, args)) {
+	if (shouldSkipCheck(config, options, commandDef, subcommandDef, args)) {
 		logger.trace('Skipping version check (disabled or not applicable)');
 		return;
 	}