@agentuity/cli 0.0.105 → 0.0.106

package/src/cli.ts

@@ -141,10 +141,17 @@ async function executeOrValidate(
 /**
  * Format a user-friendly message for a validation issue
  */
-function formatValidationIssueMessage(field: string, message: string): string {
+function formatValidationIssueMessage(
+	field: string,
+	message: string,
+	isArg: boolean = false
+): string {
 	// Detect "expected X, received undefined" pattern (missing required value)
 	if (message.includes('received undefined')) {
 		if (field && field !== 'unknown') {
+			if (isArg) {
+				return `Missing required argument: <${field}>`;
+			}
 			return `Missing required option: --${field}`;
 		}
 		return 'Missing required value';
@@ -155,6 +162,9 @@ function formatValidationIssueMessage(field: string, message: string): string {
 	if (typeMatch) {
 		const [, expected, received] = typeMatch;
 		if (field && field !== 'unknown') {
+			if (isArg) {
+				return `Invalid value for <${field}>: expected ${expected}, got ${received}`;
+			}
 			return `Invalid value for --${field}: expected ${expected}, got ${received}`;
 		}
 		return `Invalid value: expected ${expected}, got ${received}`;
@@ -162,25 +172,69 @@ function formatValidationIssueMessage(field: string, message: string): string {
 
 	// Default: include the field name if we have it
 	if (field && field !== 'unknown') {
+		if (isArg) {
+			return `<${field}>: ${message}`;
+		}
 		return `--${field}: ${message}`;
 	}
 	return message;
 }
 
+/**
+ * Custom error class to wrap ZodErrors with context about whether they are for args or options
+ */
+class SchemaValidationError extends Error {
+	constructor(
+		public readonly originalError: unknown,
+		public readonly isArg: boolean
+	) {
+		super('Schema validation error');
+	}
+}
+
+/**
+ * Parse args schema and wrap any ZodError with context
+ */
+function parseArgs<T>(schema: { parse: (input: unknown) => T }, input: unknown): T {
+	try {
+		return schema.parse(input);
+	} catch (error) {
+		if (error && typeof error === 'object' && 'issues' in error) {
+			throw new SchemaValidationError(error, true);
+		}
+		throw error;
+	}
+}
+
+/**
+ * Parse options schema (no wrapping needed, isArg defaults to false)
+ */
+function parseOptions<T>(schema: { parse: (input: unknown) => T }, input: unknown): T {
+	return schema.parse(input);
+}
+
 function handleValidationError(
 	error: unknown,
 	commandName: string,
 	baseCtx: { options: GlobalOptions; logger: Logger }
 ): never {
-	if (error && typeof error === 'object' && 'issues' in error) {
-		const issues = (error as { issues: Array<{ path: string[]; message: string }> }).issues;
+	// Unwrap SchemaValidationError to get context about whether it's an arg or option
+	let actualError = error;
+	let isArg = false;
+	if (error instanceof SchemaValidationError) {
+		actualError = error.originalError;
+		isArg = error.isArg;
+	}
+
+	if (actualError && typeof actualError === 'object' && 'issues' in actualError) {
+		const issues = (actualError as { issues: Array<{ path: string[]; message: string }> }).issues;
 
 		const formattedIssues = issues.map((issue) => {
 			const field = issue.path?.length ? issue.path.join('.') : 'unknown';
 			return {
 				field,
 				message: issue.message,
-				formatted: formatValidationIssueMessage(field, issue.message),
+				formatted: formatValidationIssueMessage(field, issue.message, isArg),
 			};
 		});
 
@@ -227,6 +281,22 @@ type Normalized = {
 	optionalRegion: boolean;
 };
 
+/**
+ * Get the full command path for a command (e.g., "cloud sandbox snapshot delete")
+ * Uses Commander's _getCommandAndAncestors to traverse the command hierarchy.
+ */
+function getFullCommandPath(cmd: Command): string {
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	const ancestors = (cmd as any)._getCommandAndAncestors() as Command[];
+	// ancestors is [current, parent, grandparent, ...root] - reverse and skip root program name
+	const names = ancestors.map((c) => c.name()).reverse();
+	// Skip the first entry if it's the root program (usually empty or 'agentuity')
+	if (names.length > 1 && (names[0] === '' || names[0] === 'agentuity')) {
+		return names.slice(1).join(' ');
+	}
+	return names.join(' ');
+}
+
 function normalizeReqs(def: CommandDefinition | SubcommandDefinition): Normalized {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const d: any = def as any;
@@ -802,6 +872,7 @@ async function registerSubcommand(
 
 	if (subcommand.schema?.options) {
 		const parsed = parseOptionsSchema(subcommand.schema.options);
+		const aliases = subcommand.schema.aliases ?? {};
 		for (const opt of parsed) {
 			const flag = opt.name
 				.replace(/([a-z0-9])([A-Z])/g, '$1-$2')
@@ -814,8 +885,15 @@ async function registerSubcommand(
 			}
 
 			const desc = opt.description || '';
-			// Add short flag alias for verbose
-			const flagSpec = flag === 'verbose' ? `-v, --${flag}` : `--${flag}`;
+			// Build flag spec with aliases (check both camelCase and kebab-case names)
+			const optAliases = aliases[opt.name] ?? aliases[flag] ?? [];
+			let flagSpec = `--${flag}`;
+			if (flag === 'verbose') {
+				flagSpec = `-v, --${flag}`;
+			} else if (optAliases.length > 0) {
+				const shortFlags = optAliases.map((a) => `-${a}`).join(', ');
+				flagSpec = `${shortFlags}, --${flag}`;
+			}
 			if (opt.type === 'boolean') {
 				if (opt.hasDefault) {
 					const defaultValue =
@@ -1019,10 +1097,10 @@ async function registerSubcommand(
 						ctx.projectDir = projectDir;
 					}
 					if (subcommand.schema.args) {
-						ctx.args = subcommand.schema.args.parse(input.args);
+						ctx.args = parseArgs(subcommand.schema.args, input.args);
 					}
 					if (subcommand.schema.options) {
-						ctx.opts = subcommand.schema.options.parse(input.options);
+						ctx.opts = parseOptions(subcommand.schema.options, input.options);
 					}
 					if (normalized.requiresAPIClient) {
 						// Recreate apiClient with auth credentials
@@ -1059,14 +1137,14 @@ async function registerSubcommand(
 					}
 					await executeOrValidate(
 						ctx as CommandContext,
-						`${parent.name()} ${subcommand.name}`,
+						getFullCommandPath(cmd),
 						subcommand.handler,
 						!!subcommand.schema?.response,
 						subcommand.webUrl
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+						handleValidationError(error, getFullCommandPath(cmd), baseCtx);
 					}
 					handleProjectConfigError(
 						error,
@@ -1139,7 +1217,7 @@ async function registerSubcommand(
 							exitWithError(
 								createError(
 									ErrorCode.INTERNAL_ERROR,
-									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+									`Command '${getFullCommandPath(cmd)}' declares a response schema but returned no data. This is a bug in the command implementation.`
 								),
 								baseCtx.logger,
 								baseCtx.options.errorFormat
@@ -1192,10 +1270,10 @@ async function registerSubcommand(
 						ctx.projectDir = projectDir;
 					}
 					if (subcommand.schema.args) {
-						ctx.args = subcommand.schema.args.parse(input.args);
+						ctx.args = parseArgs(subcommand.schema.args, input.args);
 					}
 					if (subcommand.schema.options) {
-						ctx.opts = subcommand.schema.options.parse(input.options);
+						ctx.opts = parseOptions(subcommand.schema.options, input.options);
 					}
 					if (normalized.requiresAPIClient) {
 						// Recreate apiClient with auth credentials
@@ -1238,14 +1316,14 @@ async function registerSubcommand(
 					}
 					await executeOrValidate(
 						ctx as CommandContext,
-						`${parent.name()} ${subcommand.name}`,
+						getFullCommandPath(cmd),
 						subcommand.handler,
 						!!subcommand.schema?.response,
 						subcommand.webUrl
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+						handleValidationError(error, getFullCommandPath(cmd), baseCtx);
 					}
 					handleProjectConfigError(
 						error,
@@ -1314,7 +1392,7 @@ async function registerSubcommand(
 							exitWithError(
 								createError(
 									ErrorCode.INTERNAL_ERROR,
-									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+									`Command '${getFullCommandPath(cmd)}' declares a response schema but returned no data. This is a bug in the command implementation.`
 								),
 								baseCtx.logger,
 								baseCtx.options.errorFormat
@@ -1343,10 +1421,10 @@ async function registerSubcommand(
 						ctx.projectDir = projectDir;
 					}
 					if (subcommand.schema.args) {
-						ctx.args = subcommand.schema.args.parse(input.args);
+						ctx.args = parseArgs(subcommand.schema.args, input.args);
 					}
 					if (subcommand.schema.options) {
-						ctx.opts = subcommand.schema.options.parse(input.options);
+						ctx.opts = parseOptions(subcommand.schema.options, input.options);
 					}
 					if (normalized.requiresAPIClient && !ctx.apiClient) {
 						ctx.apiClient = createAPIClient(baseCtx, ctx.config as Config | null);
@@ -1363,14 +1441,14 @@ async function registerSubcommand(
 					}
 					await executeOrValidate(
 						ctx as CommandContext,
-						`${parent.name()} ${subcommand.name}`,
+						getFullCommandPath(cmd),
 						subcommand.handler,
 						!!subcommand.schema?.response,
 						subcommand.webUrl
 					);
 				} catch (error) {
 					if (error && typeof error === 'object' && 'issues' in error) {
-						handleValidationError(error, `${parent.name()} ${subcommand.name}`, baseCtx);
+						handleValidationError(error, getFullCommandPath(cmd), baseCtx);
 					}
 					handleProjectConfigError(
 						error,
@@ -1426,7 +1504,7 @@ async function registerSubcommand(
 							exitWithError(
 								createError(
 									ErrorCode.INTERNAL_ERROR,
-									`Command '${parent.name()} ${subcommand.name}' declares a response schema but returned no data. This is a bug in the command implementation.`
+									`Command '${getFullCommandPath(cmd)}' declares a response schema but returned no data. This is a bug in the command implementation.`
 								),
 								baseCtx.logger,
 								baseCtx.options.errorFormat

package/src/cmd/build/ast.ts

@@ -1300,12 +1300,168 @@ export async function parseRoute(
 						const action = statement.expression.arguments[0];
 						let suffix = '';
 						let config: Record<string, unknown> | undefined;
+						// Supported HTTP methods that can be represented in BuildMetadata
+						const SUPPORTED_HTTP_METHODS = ['get', 'post', 'put', 'delete', 'patch'] as const;
+						type SupportedHttpMethod = (typeof SUPPORTED_HTTP_METHODS)[number];
+
+						const isSupportedHttpMethod = (m: string): m is SupportedHttpMethod =>
+							SUPPORTED_HTTP_METHODS.includes(m.toLowerCase() as SupportedHttpMethod);
+
 						switch (method) {
 							case 'use':
-							case 'on':
-							case 'all':
 							case 'route': {
-								// Skip Hono middleware/routing methods - they don't represent API routes
+								// Skip Hono middleware and sub-router mounting - they don't represent API routes
+								continue;
+							}
+							case 'on': {
+								// router.on(method | method[], path, handler)
+								// First arg is method(s), second arg is path
+								const methodArg = statement.expression.arguments[0];
+								const pathArg = statement.expression.arguments[1];
+
+								// Extract methods from first argument
+								const methods: SupportedHttpMethod[] = [];
+
+								if (methodArg && (methodArg as ASTLiteral).type === 'Literal') {
+									// Single method: router.on('GET', '/path', handler)
+									const raw = String((methodArg as ASTLiteral).value || '').toLowerCase();
+									if (isSupportedHttpMethod(raw)) {
+										methods.push(raw as SupportedHttpMethod);
+									}
+								} else if (methodArg && (methodArg as ASTNode).type === 'ArrayExpression') {
+									// Array of methods: router.on(['GET', 'POST'], '/path', handler)
+									const arr = methodArg as { elements: ASTNode[] };
+									for (const el of arr.elements) {
+										if (!el || (el as ASTLiteral).type !== 'Literal') continue;
+										const raw = String((el as ASTLiteral).value || '').toLowerCase();
+										if (isSupportedHttpMethod(raw)) {
+											methods.push(raw as SupportedHttpMethod);
+										}
+									}
+								}
+
+								// Skip if no supported methods or path is not a literal
+								if (
+									methods.length === 0 ||
+									!pathArg ||
+									(pathArg as ASTLiteral).type !== 'Literal'
+								) {
+									continue;
+								}
+
+								const pathSuffix = String((pathArg as ASTLiteral).value);
+
+								// Create a route entry for each method
+								for (const httpMethod of methods) {
+									const thepath = `${routePrefix}/${routeName}/${pathSuffix}`
+										.replaceAll(/\/{2,}/g, '/')
+										.replaceAll(/\/$/g, '');
+									const id = generateRouteId(
+										projectId,
+										deploymentId,
+										'api',
+										httpMethod,
+										rel,
+										thepath,
+										version
+									);
+
+									// Check if this route uses validator middleware
+									const validatorInfo = hasValidatorCall(statement.expression.arguments);
+									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;
+										}
+										if (validatorInfo.outputSchemaVariable) {
+											routeConfig.outputSchemaVariable =
+												validatorInfo.outputSchemaVariable;
+										}
+										if (validatorInfo.stream !== undefined) {
+											routeConfig.stream = validatorInfo.stream;
+										}
+									}
+
+									routes.push({
+										id,
+										method: httpMethod,
+										type: 'api',
+										filename: rel,
+										path: thepath,
+										version,
+										config: Object.keys(routeConfig).length > 0 ? routeConfig : undefined,
+									});
+								}
+								continue;
+							}
+							case 'all': {
+								// router.all(path, handler) - matches all HTTP methods
+								// First arg is path (same as get/post/etc.)
+								if (!action || (action as ASTLiteral).type !== 'Literal') {
+									continue;
+								}
+
+								const pathSuffix = String((action as ASTLiteral).value);
+
+								// 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 id = generateRouteId(
+										projectId,
+										deploymentId,
+										'api',
+										httpMethod,
+										rel,
+										thepath,
+										version
+									);
+
+									// Check if this route uses validator middleware
+									const validatorInfo = hasValidatorCall(statement.expression.arguments);
+									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;
+										}
+										if (validatorInfo.outputSchemaVariable) {
+											routeConfig.outputSchemaVariable =
+												validatorInfo.outputSchemaVariable;
+										}
+										if (validatorInfo.stream !== undefined) {
+											routeConfig.stream = validatorInfo.stream;
+										}
+									}
+
+									routes.push({
+										id,
+										method: httpMethod,
+										type: 'api',
+										filename: rel,
+										path: thepath,
+										version,
+										config: Object.keys(routeConfig).length > 0 ? routeConfig : undefined,
+									});
+								}
 								continue;
 							}
 							case 'get':
@@ -1456,7 +1612,10 @@ export async function parseRoute(
 						}
 
 						// For WebSocket/SSE/stream routes that don't use validator(), fall back to exported schemas
-						if (!routeConfig.hasValidator && (type === 'websocket' || type === 'sse' || type === 'stream')) {
+						if (
+							!routeConfig.hasValidator &&
+							(type === 'websocket' || type === 'sse' || type === 'stream')
+						) {
 							if (!routeConfig.inputSchemaVariable && exportedInputSchemaName) {
 								routeConfig.inputSchemaVariable = exportedInputSchemaName;
 							}

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

@@ -57,6 +57,7 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 		`  getAppState,`,
 		`  getAppConfig,`,
 		`  register,`,
+		`  getSpanProcessors,`,
 		`  createServices,`,
 		`  runAgentSetups,`,
 		`  getThreadProvider,`,
@@ -84,7 +85,7 @@ export async function generateEntryFile(options: GenerateEntryOptions): Promise<
 	].filter(Boolean);
 
 	imports.push(`import { type LogLevel } from '@agentuity/core';`);
-	imports.push(`import { bootstrapRuntimeEnv } from '@agentuity/runtime';`);
+	imports.push(`import { bootstrapRuntimeEnv, patchBunS3ForStorageDev } from '@agentuity/runtime';`);
 
 	// Generate route mounting code for all discovered routes
 	const routeImportsAndMounts: string[] = [];
@@ -428,9 +429,14 @@ if (isDevelopment()) {
 	await bootstrapRuntimeEnv({ projectDir: import.meta.dir + '/../..' });
 }
 
+// Step 0.5: Patch Bun's S3 client for Agentuity storage endpoints
+// Agentuity storage uses virtual-hosted-style URLs (*.storage.dev)
+// This patches s3.file() to automatically set virtualHostedStyle: true
+patchBunS3ForStorageDev();
+
 // Step 1: Initialize telemetry and services
 const serverUrl = \`http://127.0.0.1:\${process.env.PORT || '3500'}\`;
-const otel = register({ processors: [], logLevel: (process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel });
+const otel = register({ processors: getSpanProcessors(), logLevel: (process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel });
 
 // Step 2: Create router and set as global
 const app = createRouter();

package/src/cmd/build/vite/registry-generator.ts

@@ -289,12 +289,11 @@ function generateRPCRegistryType(
 			.replace(/_+/g, '_');
 		const pascalName = toPascalCase(safeName);
 
-		// Only reference type names if route has schemas, otherwise use 'never'
+		// Only reference type names if route has actual schemas extracted, otherwise use 'never'
+		// Note: hasValidator may be true (e.g., zValidator('query', ...)) but no schemas extracted
+		// because only 'json' validators extract input schemas
 		const hasSchemas =
-			route.hasValidator ||
-			route.inputSchemaVariable ||
-			route.outputSchemaVariable ||
-			route.agentVariable;
+			route.inputSchemaVariable || route.outputSchemaVariable || route.agentVariable;
 
 		current[terminalMethod] = {
 			input: hasSchemas ? `${pascalName}Input` : 'never',
@@ -725,12 +724,10 @@ export function generateRouteRegistry(
 			.replace(/_+/g, '_');
 		const pascalName = toPascalCase(safeName);
 
-		if (
-			!route.hasValidator &&
-			!route.inputSchemaVariable &&
-			!route.outputSchemaVariable &&
-			!route.agentVariable
-		) {
+		// Use 'never' types if no schemas were actually extracted
+		// Note: hasValidator may be true (e.g., zValidator('query', ...)) but no schemas extracted
+		// because only 'json' validators extract input schemas
+		if (!route.inputSchemaVariable && !route.outputSchemaVariable && !route.agentVariable) {
 			const streamValue = route.stream === true ? 'true' : 'false';
 			return `\t'${routeKey}': {
 \t\tinputSchema: never;

package/src/cmd/cloud/db/create.ts

@@ -6,6 +6,7 @@ import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
+import { addResourceEnvVars } from '../../../env-util';
 
 export const createSubcommand = defineSubcommand({
 	name: 'create',
@@ -62,12 +63,22 @@ export const createSubcommand = defineSubcommand({
 				},
 			});
 			if (created.length > 0) {
+				const resource = created[0];
+
+				// Write environment variables to .env if running inside a project
+				if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
+					await addResourceEnvVars(ctx.projectDir, resource.env);
+					if (!options.json) {
+						tui.info('Environment variables written to .env');
+					}
+				}
+
 				if (!options.json) {
-					tui.success(`Created database: ${tui.bold(created[0].name)}`);
+					tui.success(`Created database: ${tui.bold(resource.name)}`);
 				}
 				return {
 					success: true,
-					name: created[0].name,
+					name: resource.name,
 				};
 			} else {
 				tui.fatal('Failed to create database');

package/src/cmd/cloud/db/delete.ts

@@ -7,6 +7,7 @@ import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
+import { removeResourceEnvVars } from '../../../env-util';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
@@ -109,10 +110,22 @@ export const deleteSubcommand = createSubcommand({
 			});
 
 			if (deleted.length > 0) {
-				tui.success(`Deleted database: ${tui.bold(deleted[0])}`);
+				const resource = deleted[0];
+
+				// Remove env vars from .env if running inside a project
+				if (ctx.projectDir && resource.env_keys.length > 0) {
+					await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
+					if (!options.json) {
+						tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
+					}
+				}
+
+				if (!options.json) {
+					tui.success(`Deleted database: ${tui.bold(resource.name)}`);
+				}
 				return {
 					success: true,
-					name: deleted[0],
+					name: resource.name,
 				};
 			} else {
 				tui.error('Failed to delete database');

package/src/cmd/cloud/deploy.ts

@@ -34,7 +34,7 @@ import {
 	getAppBaseURL,
 } from '@agentuity/server';
 import {
-	findEnvFile,
+	findExistingEnvFile,
 	readEnvFile,
 	filterAgentuitySdkKeys,
 	splitEnvAndSecrets,
@@ -176,8 +176,8 @@ export const deploySubcommand = createSubcommand({
 						label: 'Sync Env & Secrets',
 						run: async () => {
 							try {
-								// Read local env file (.env.production or .env)
-								const envFilePath = await findEnvFile(projectDir);
+								// Read env file
+								const envFilePath = await findExistingEnvFile(projectDir);
 								const localEnv = await readEnvFile(envFilePath);
 
 								// Filter out AGENTUITY_ keys

package/src/cmd/cloud/env/delete.ts

@@ -45,7 +45,7 @@ export const deleteSubcommand = createSubcommand({
 			});
 		});
 
-		// Update local .env file (prefer .env.production, fallback to .env)
+		// Update local .env file (prefer .env)
 		const envFilePath = await findExistingEnvFile(projectDir);
 		const currentEnv = await readEnvFile(envFilePath);
 		delete currentEnv[args.key];

package/src/cmd/cloud/env/import.ts

@@ -3,7 +3,7 @@ import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { projectEnvUpdate } from '@agentuity/server';
 import {
-	findEnvFile,
+	findExistingEnvFile,
 	readEnvFile,
 	writeEnvFile,
 	filterAgentuitySdkKeys,
@@ -23,7 +23,7 @@ const EnvImportResponseSchema = z.object({
 
 export const importSubcommand = createSubcommand({
 	name: 'import',
-	description: 'Import environment variables from a file to cloud and local .env.production',
+	description: 'Import environment variables from a file to cloud and local .env',
 	tags: [
 		'mutating',
 		'creates-resource',
@@ -131,8 +131,8 @@ export const importSubcommand = createSubcommand({
 			});
 		});
 
-		// Merge with local .env.production file
-		const localEnvPath = await findEnvFile(projectDir);
+		// Merge environment
+		const localEnvPath = await findExistingEnvFile(projectDir);
 		const localEnv = await readEnvFile(localEnvPath);
 		const mergedEnv = mergeEnvVars(localEnv, filteredEnv);