@agentuity/cli 0.0.105 → 0.0.107

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/cli",
-	"version": "0.0.105",
+	"version": "0.0.107",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -40,8 +40,8 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "0.0.105",
-		"@agentuity/server": "0.0.105",
+		"@agentuity/core": "0.0.107",
+		"@agentuity/server": "0.0.107",
 		"@datasert/cronjs-parser": "^1.4.0",
 		"@terascope/fetch-github-release": "^2.2.1",
 		"@vitejs/plugin-react": "^5.1.2",
@@ -61,7 +61,7 @@
 		"zod": "^4.1.12"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "0.0.105",
+		"@agentuity/test-utils": "0.0.107",
 		"@types/adm-zip": "^0.5.7",
 		"@types/bun": "latest",
 		"@types/tar-fs": "^2.0.4",

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/metadata-generator.ts

@@ -9,7 +9,7 @@ import { writeFileSync, mkdirSync, existsSync, readFileSync, statSync, readdirSy
 import type { BuildMetadata } from '@agentuity/server';
 import type { AgentMetadata } from './agent-discovery';
 import type { RouteMetadata } from './route-discovery';
-import type { Logger } from '../../../types';
+import type { Logger, DeployOptions } from '../../../types';
 import { getVersion } from '../../../version';
 
 interface ViteManifestEntry {
@@ -162,6 +162,7 @@ export interface MetadataGeneratorOptions {
 	routes: RouteMetadata[];
 	dev?: boolean;
 	logger: Logger;
+	deploymentOptions?: DeployOptions;
 }
 
 /**
@@ -472,6 +473,21 @@ export async function generateMetadata(options: MetadataGeneratorOptions): Promi
 		},
 	};
 
+	if (options.deploymentOptions) {
+		const git = { ...(metadata.deployment.git ?? {}), ...options.deploymentOptions };
+		if (options.deploymentOptions.pullRequestNumber) {
+			git.pull_request = {
+				number: options.deploymentOptions.pullRequestNumber,
+				commentId: options.deploymentOptions.pullRequestCommentId,
+				url: options.deploymentOptions.pullRequestURL,
+			};
+			delete git.pullRequestCommentId;
+			delete git.pullRequestNumber;
+			delete git.pullRequestURL;
+		}
+		metadata.deployment.git = git;
+	}
+
 	return metadata;
 }
 

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/build/vite/vite-builder.ts

@@ -7,7 +7,7 @@
 import { join } from 'node:path';
 import { existsSync, renameSync, rmSync } from 'node:fs';
 import type { InlineConfig, Plugin } from 'vite';
-import type { Logger } from '../../../types';
+import type { Logger, DeployOptions } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
 
 /**
@@ -54,6 +54,7 @@ export interface ViteBuildOptions {
 	workbenchRoute?: string;
 	workbenchEnabled?: boolean;
 	logger: Logger;
+	deploymentOptions?: DeployOptions;
 }
 
 /**
@@ -341,6 +342,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		routes,
 		logger,
 		dev,
+		deploymentOptions: options.deploymentOptions,
 	});
 
 	writeMetadataFile(rootDir, metadata, dev, logger);

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

@@ -7,7 +7,7 @@
 import { join } from 'node:path';
 import { stat } from 'node:fs/promises';
 import { StructuredError } from '@agentuity/core';
-import type { Logger } from '../../types';
+import type { Logger, DeployOptions } from '../../types';
 import { runAllBuilds } from './vite/vite-builder';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
 import { checkBunVersion } from '../../utils/bun-version-checker';
@@ -25,6 +25,7 @@ export interface ViteBundleOptions {
 	deploymentId?: string;
 	port?: number;
 	logger: Logger;
+	deploymentOptions?: DeployOptions;
 }
 
 /**
@@ -39,6 +40,7 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 		deploymentId = '',
 		port = 3500,
 		logger,
+		deploymentOptions,
 	} = options;
 
 	const output: string[] = [];
@@ -87,6 +89,7 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 			region,
 			deploymentId,
 			logger,
+			deploymentOptions,
 		});
 
 		if (result.client.included) {

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');