@agentuity/cli 1.0.1 → 1.0.3

package/src/cmd/ai/detect.ts

@@ -0,0 +1,54 @@
+import { createSubcommand } from '../../types';
+import { getExecutingAgent, getAgentDisplayName, KNOWN_AGENTS } from '../../agent-detection';
+import { getCommand } from '../../command-prefix';
+import * as tui from '../../tui';
+
+export const detectSubcommand = createSubcommand({
+	name: 'detect',
+	description: 'Detect if the CLI is being run from a known AI coding agent',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
+	examples: [
+		{ command: getCommand('ai detect'), description: 'Detect the executing agent' },
+		{ command: getCommand('ai detect --json'), description: 'Output detection result as JSON' },
+	],
+	handler(ctx) {
+		const agentId = getExecutingAgent();
+		const agentName = agentId ? getAgentDisplayName(agentId) : null;
+
+		if (ctx.options.json) {
+			tui.json({
+				id: agentId ?? null,
+				name: agentName,
+			});
+			// Exit with code 1 when no agent detected (consistent with non-JSON mode)
+			if (!agentId) {
+				process.exit(1);
+			}
+			return;
+		}
+
+		if (agentId) {
+			tui.success(`Detected agent: ${agentName} (${agentId})`);
+		} else {
+			tui.newline();
+			tui.info('No AI coding agent detected.');
+			tui.newline();
+			console.log(`  This CLI can detect when it's being run by an AI coding agent.`);
+			console.log(`  Currently supported agents:\n`);
+			for (const [, id] of KNOWN_AGENTS) {
+				console.log(`    - ${getAgentDisplayName(id)} (${id})`);
+			}
+			tui.newline();
+			console.log(
+				`  You can also set the ${tui.colorPrimary('AGENTUITY_AGENT_MODE')} environment variable`
+			);
+			console.log(`  to manually specify the agent.\n`);
+
+			// Exit with code 1 when no agent detected (non-JSON mode)
+			process.exit(1);
+		}
+	},
+});
+
+export default detectSubcommand;

package/src/cmd/ai/index.ts

@@ -3,6 +3,8 @@ import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
 import opencodeCommand from './opencode';
+import introSubcommand from './intro';
+import detectSubcommand from './detect';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -11,6 +13,14 @@ export const command = createCommand({
 	skipUpgradeCheck: true,
 	tags: ['fast'],
 	examples: [
+		{
+			command: getCommand('ai detect'),
+			description: 'Detect if running from an AI coding agent',
+		},
+		{
+			command: getCommand('ai intro'),
+			description: 'Introduce the Agentuity CLI to your AI agent',
+		},
 		{
 			command: getCommand('ai opencode install'),
 			description: 'Install Agentuity Open Code plugin',
@@ -24,5 +34,12 @@ export const command = createCommand({
 			description: 'Output CLI schema for AI consumption',
 		},
 	],
-	subcommands: [opencodeCommand, capabilitiesCommand, promptCommand, schemaCommand],
+	subcommands: [
+		detectSubcommand,
+		introSubcommand,
+		opencodeCommand,
+		capabilitiesCommand,
+		promptCommand,
+		schemaCommand,
+	],
 });

package/src/cmd/ai/intro.ts

@@ -0,0 +1,154 @@
+import { createSubcommand } from '../../types';
+import type { CommandContext } from '../../types';
+import { getCommand } from '../../command-prefix';
+import { getExecutingAgent, getAgentDisplayName, KNOWN_AGENTS } from '../../agent-detection';
+import { getVersion } from '../../version';
+import * as tui from '../../tui';
+
+/**
+ * Generate the introduction prompt for AI agents
+ */
+export function generateIntroPrompt(agent: string | undefined): string {
+	const agentGreeting = agent ? `Hello ${getAgentDisplayName(agent)}! ` : 'Hello! ';
+
+	const detectedAgents = KNOWN_AGENTS.map(([, name]) => getAgentDisplayName(name)).join(', ');
+
+	return `${agentGreeting}Welcome to the Agentuity CLI (v${getVersion()}).
+
+## What is Agentuity?
+
+Agentuity is a cloud platform for building, deploying, and running AI agents with production-grade infrastructure. It provides:
+
+- **Serverless Agent Runtime**: Deploy agents that scale automatically with zero cold starts
+- **Built-in Services**: Key-value storage, vector databases, object storage, and PostgreSQL - all accessible via simple APIs
+- **Agent-to-Agent Communication**: Agents can discover and communicate with each other seamlessly
+- **Observability**: Full tracing, logging, and monitoring out of the box
+- **Developer Experience**: Local development server, hot reload, and TypeScript-first SDK
+
+## How to Use This CLI
+
+The Agentuity CLI is designed to be agent-friendly. Here are the key commands:
+
+### Discovery & Introspection
+\`\`\`bash
+${getCommand('--help=json')}              # Get complete CLI schema as JSON
+${getCommand('ai capabilities show')}     # List all capabilities and workflows
+${getCommand('ai schema show')}           # Detailed command metadata
+\`\`\`
+
+### Project Management
+\`\`\`bash
+${getCommand('project create')}           # Create a new Agentuity project
+${getCommand('project list')}             # List all projects
+${getCommand('dev')}                      # Start local development server
+\`\`\`
+
+### Deployment
+\`\`\`bash
+${getCommand('cloud deploy')}             # Deploy to production
+${getCommand('cloud deployment list')}    # List deployments
+${getCommand('cloud deployment logs')}    # View deployment logs
+\`\`\`
+
+### Cloud Services
+\`\`\`bash
+${getCommand('cloud kv')}                 # Key-value storage operations
+${getCommand('cloud vector')}             # Vector database operations
+${getCommand('cloud storage')}            # Object storage operations
+${getCommand('env set KEY value')}        # Set environment variables
+${getCommand('env set KEY value --secret')} # Set secrets (encrypted)
+\`\`\`
+
+## Best Practices for AI Agents
+
+1. **Always use \`--json\` for machine-readable output**
+   \`\`\`bash
+   ${getCommand('--json project list')}
+   \`\`\`
+
+2. **Use \`--explain\` before destructive operations**
+   \`\`\`bash
+   ${getCommand('--explain cloud deployment delete <id>')}
+   \`\`\`
+
+3. **Use \`--dry-run\` to test commands safely**
+   \`\`\`bash
+   ${getCommand('--dry-run cloud deploy')}
+   \`\`\`
+
+4. **Check requirements before running commands**
+   - Many commands require authentication (\`${getCommand('auth login')}\`)
+   - Project commands require an \`agentuity.json\` file in the current directory
+
+## Error Handling
+
+Errors are returned as structured JSON when using \`--json\`:
+\`\`\`json
+{
+  "error": {
+    "code": "AUTH_REQUIRED",
+    "message": "Authentication required",
+    "suggestions": ["Run '${getCommand('auth login')}' to authenticate"]
+  }
+}
+\`\`\`
+
+## Getting Started Workflow
+
+1. \`${getCommand('auth login')}\` - Authenticate with Agentuity
+2. \`${getCommand('project create')}\` - Create a new project (or work in existing one)
+3. \`${getCommand('dev')}\` - Start local development
+4. \`${getCommand('cloud deploy')}\` - Deploy to production
+
+## Agent Detection
+
+This CLI can detect when it's being run by an AI coding agent. Currently supported agents: ${detectedAgents}.
+
+${agent ? `You were detected as: **${getAgentDisplayName(agent)}**` : 'No agent was detected for this session.'}
+
+## More Information
+
+- Documentation: https://agentuity.dev/docs
+- API Reference: https://agentuity.dev/api
+- Examples: https://github.com/agentuity/examples
+
+For detailed command help, use \`${getCommand('<command> --help')}\` or \`${getCommand('--help=json')}\` for the full schema.
+`;
+}
+
+export const introSubcommand = createSubcommand({
+	name: 'intro',
+	description: 'Introduction to Agentuity CLI for AI coding agents',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
+	examples: [{ command: getCommand('ai intro'), description: 'Show introduction for AI agents' }],
+	handler(_ctx: CommandContext) {
+		const agent = getExecutingAgent();
+
+		if (!agent) {
+			// Human is running this command directly
+			tui.newline();
+			tui.info(tui.bold('This command is designed for AI coding agents'));
+			tui.newline();
+			console.log(
+				`  This command outputs an introduction to the Agentuity CLI that helps AI\n` +
+					`  coding agents understand how to use the platform effectively.\n`
+			);
+			console.log(`  ${tui.bold('To use this command:')}\n`);
+			console.log(
+				`  Ask your AI coding agent to run ${tui.colorPrimary(`"${getCommand('ai intro')}"`)} to introduce\n` +
+					`  itself to the Agentuity platform and learn how to help you build and deploy agents.\n`
+			);
+			console.log(
+				`  ${tui.muted('Supported agents:')} ${KNOWN_AGENTS.map(([, name]) => getAgentDisplayName(name)).join(', ')}\n`
+			);
+			return;
+		}
+
+		// Agent is running this command - output the full prompt
+		const prompt = generateIntroPrompt(agent);
+		console.log(prompt);
+	},
+});
+
+export default introSubcommand;

package/src/cmd/ai/opencode/run.ts

@@ -82,6 +82,11 @@ export const runSubcommand = createSubcommand({
 			env: {
 				...process.env,
 				AGENTUITY_CODER_MODE: 'non-interactive',
+				AGENTUITY_AGENT_MODE: 'opencode',
+				// Pass through profile if set
+				...(process.env.AGENTUITY_PROFILE
+					? { AGENTUITY_PROFILE: process.env.AGENTUITY_PROFILE }
+					: {}),
 			},
 		});
 

package/src/cmd/build/ast.ts

@@ -1246,6 +1246,60 @@ function extractZValidatorSchema(callExpr: ASTCallExpression): {
 	return result;
 }
 
+/**
+ * Extract output schema from SSE options object.
+ * Example: sse({ output: MySchema }, handler)
+ *
+ * @param callExpr - The SSE CallExpression AST node
+ * @returns Object with outputSchemaVariable if found
+ */
+function extractSSEOutputSchema(callExpr: ASTCallExpression): {
+	outputSchemaVariable?: string;
+} {
+	const result: { outputSchemaVariable?: string } = {};
+
+	// sse() can be called as:
+	// 1. sse(handler) - no schema
+	// 2. sse({ output: schema }, handler) - with schema
+	if (!callExpr.arguments || callExpr.arguments.length === 0) {
+		return result;
+	}
+
+	// Check if first argument is an options object with 'output' property
+	const firstArg = callExpr.arguments[0] as ASTNode;
+	if (firstArg.type !== 'ObjectExpression') {
+		// First argument is handler function, no options
+		return result;
+	}
+
+	const objExpr = firstArg as ASTObjectExpression;
+	for (const prop of objExpr.properties) {
+		// Skip SpreadElement entries (e.g., { ...obj }) which don't have key/value
+		if ((prop as ASTNode).type !== 'Property') {
+			continue;
+		}
+
+		// Extract key name - could be Identifier or Literal
+		let keyName: string | undefined;
+		const propKey = prop.key as { type: string; name?: string; value?: unknown };
+		if (propKey.type === 'Identifier') {
+			keyName = propKey.name;
+		} else if (propKey.type === 'Literal') {
+			keyName = String(propKey.value);
+		}
+
+		if (!keyName) continue;
+
+		// Look for the 'output' property
+		if (keyName === 'output' && prop.value.type === 'Identifier') {
+			result.outputSchemaVariable = (prop.value as ASTNodeIdentifier).name;
+			break;
+		}
+	}
+
+	return result;
+}
+
 /**
  * Extract schema from Hono validator('json', callback) pattern
  * Example: validator('json', (value, c) => { const result = mySchema['~standard'].validate(value); ... })
@@ -1543,6 +1597,8 @@ export async function parseRoute(
 						const action = statement.expression.arguments[0];
 						let suffix = '';
 						let config: Record<string, unknown> | undefined;
+						// Capture SSE call expression for output schema extraction
+						let sseCallExpr: ASTCallExpression | 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];
@@ -1804,6 +1860,10 @@ export async function parseRoute(
 												calleeName === 'stream'
 											) {
 												type = calleeName;
+												// Capture SSE call expression for output schema extraction
+												if (calleeName === 'sse') {
+													sseCallExpr = callExpr;
+												}
 												break;
 											}
 											if (calleeName === 'cron') {
@@ -1959,6 +2019,43 @@ export async function parseRoute(
 							}
 						}
 
+						// Extract output schema from SSE options: sse({ output: schema }, handler)
+						// For SSE routes, the sse({ output }) pattern takes precedence over any
+						// validator-provided schema. Imported schemas need not be exported, but
+						// locally-defined schemas must be exported and are validated below.
+						if (sseCallExpr) {
+							const sseSchemaInfo = extractSSEOutputSchema(sseCallExpr);
+							if (sseSchemaInfo.outputSchemaVariable) {
+								// Track where the schema is imported from (if imported)
+								const outputImportInfo = importInfoMap.get(
+									sseSchemaInfo.outputSchemaVariable
+								);
+								// Validate that locally-defined schemas are exported
+								// (skip validation if schema is imported from another module)
+								if (!outputImportInfo) {
+									validateSchemaExports(
+										sseSchemaInfo.outputSchemaVariable,
+										'output',
+										importedNames,
+										exportedNames,
+										rel,
+										method,
+										thepath
+									);
+								}
+								// Override any validator-provided schema with SSE-specific schema
+								routeConfig.outputSchemaVariable = sseSchemaInfo.outputSchemaVariable;
+								if (outputImportInfo) {
+									routeConfig.outputSchemaImportPath = outputImportInfo.modulePath;
+									routeConfig.outputSchemaImportedName = outputImportInfo.importedName;
+								} else {
+									// Clear any validator-provided import info since we're using local schema
+									delete routeConfig.outputSchemaImportPath;
+									delete routeConfig.outputSchemaImportedName;
+								}
+							}
+						}
+
 						// Fall back to exported schemas when validator doesn't provide them
 						// This works for all route types (API, WebSocket, SSE, stream)
 						// For API routes, this enables `export const outputSchema` pattern

package/src/cmd/build/vite/bun-dev-server.ts

@@ -6,6 +6,7 @@
  */
 
 import type { Logger } from '../../../types';
+import { getAgentEnv } from '../../../agent-detection';
 
 export interface BunDevServerOptions {
 	rootDir: string;
@@ -80,6 +81,7 @@ export async function startBunDevServer(options: BunDevServerOptions): Promise<B
 			stderr: 'inherit',
 			env: {
 				...process.env,
+				...getAgentEnv(),
 				PORT: String(port),
 			},
 		});

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

@@ -22,15 +22,28 @@ This directory contains auto-generated TypeScript files created by the Agentuity
 - \`app.ts\` - Application entry point
 - \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
 - \`webanalytics.ts\` - Web analytics injection and route registration
+- \`env.d.ts\` - TypeScript types for environment variables from \`.env\` files
 - \`state.ts\` - App state type (only generated when \`setup()\` returns state in \`app.ts\`)
 - \`router.ts\` - Runtime wrapper with type augmentation (only generated when \`setup()\` returns state in \`app.ts\`)
 
+## Environment Variable Types
+
+The \`env.d.ts\` file provides TypeScript intellisense for your environment variables:
+
+- **ProcessEnv**: All variables from your \`.env\` files are typed as \`string\`
+- **ImportMetaEnv**: Only \`VITE_*\`, \`AGENTUITY_PUBLIC_*\`, and \`PUBLIC_*\` prefixed variables (for client-side use)
+
+Files are merged based on build mode:
+- **Development**: \`.env.{profile}\` → \`.env.development\` → \`.env\` (later files override)
+- **Production**: \`.env.{profile}\` → \`.env\` → \`.env.production\` (later files override)
+
 ## For Developers
 
 Do not modify these files. Instead:
 - Add/modify agents in \`src/agent/\`
 - Add/modify routes in \`src/api/\`
 - Configure app in \`app.ts\`
+- Add environment variables to \`.env\` files
 
 These files ARE version controlled to enable better tooling and type checking.
 `;
@@ -45,7 +58,7 @@ const AGENTS_MD_CONTENT = `# AI Agent Instructions
 2. ❌ NEVER include \`src/generated/\` files in context when analyzing code
 3. ❌ NEVER suggest changes to generated files
 4. ✅ Ignore this directory when searching for user code
-5. ✅ Direct users to modify source files in \`src/agent/\`, \`src/api/\`, or \`app.ts\`
+5. ✅ Direct users to modify source files in \`src/agent/\`, \`src/api/\`, \`app.ts\`, or \`.env\` files
 
 ## What Gets Generated
 
@@ -54,6 +67,7 @@ const AGENTS_MD_CONTENT = `# AI Agent Instructions
 - \`app.ts\` - Entry point assembled from project configuration
 - \`analytics-config.ts\` - Web analytics configuration from \`agentuity.json\`
 - \`webanalytics.ts\` - Web analytics injection and route registration
+- \`env.d.ts\` - TypeScript types for environment variables from \`.env\` files
 - \`state.ts\` - App state type (only generated when \`setup()\` returns state in \`app.ts\`)
 - \`router.ts\` - Runtime wrapper with type augmentation (only generated when \`setup()\` returns state)
 

package/src/cmd/build/vite/env-types-generator.ts

@@ -0,0 +1,145 @@
+/**
+ * Environment Types Generator
+ *
+ * Generates src/generated/env.d.ts by analyzing local .env files
+ */
+
+import { join } from 'node:path';
+import { existsSync, mkdirSync } from 'node:fs';
+import { getEnvFilePaths, readEnvFile, isPublicVarKey } from '../../../env-util';
+import type { Logger } from '../../../types';
+
+/**
+ * Generate TypeScript declarations for environment variables
+ */
+function generateEnvTypesContent(keys: string[]): string {
+	const sortedKeys = [...keys].sort();
+	const publicKeys = sortedKeys.filter(isPublicVarKey);
+
+	// Build ProcessEnv interface entries
+	const processEnvEntries =
+		sortedKeys.length > 0
+			? sortedKeys.map((key) => `\t\treadonly ${key}: string;`).join('\n')
+			: '\t\t\t// No environment variables found';
+
+	// Build ImportMetaEnv interface entries (only public keys: VITE_*, AGENTUITY_PUBLIC_*, PUBLIC_*)
+	const importMetaEnvEntries =
+		publicKeys.length > 0
+			? publicKeys.map((key) => `\treadonly ${key}: string;`).join('\n')
+			: '\t// No VITE_*, AGENTUITY_PUBLIC_*, or PUBLIC_* prefixed variables found';
+
+	return `// @generated
+// AUTO-GENERATED from local .env files
+// This file is auto-generated by the build tool - do not edit manually
+
+declare global {
+	namespace NodeJS {
+		interface ProcessEnv {
+${processEnvEntries}
+		}
+	}
+}
+
+// Vite-compatible environment types
+// Only includes variables with VITE_, AGENTUITY_PUBLIC_, or PUBLIC_ prefix
+interface ImportMetaEnv {
+${importMetaEnvEntries}
+}
+
+interface ImportMeta {
+	readonly env: ImportMetaEnv;
+}
+
+export {};
+
+// FOUND AN ERROR IN THIS FILE?
+// Please file an issue at https://github.com/agentuity/sdk/issues
+// or if you know the fix please submit a PR!
+`;
+}
+
+export interface GenerateEnvTypesOptions {
+	/** Root directory of the project */
+	rootDir: string;
+	/** Source directory (typically rootDir/src) */
+	srcDir: string;
+	/** Logger instance */
+	logger: Logger;
+	/** Whether building for production (affects .env file precedence) */
+	isProduction: boolean;
+	/** Optional config profile name (e.g., 'staging', 'test') for .env.{profile} files */
+	profile?: string;
+}
+
+/**
+ * Generate environment type definitions from local .env files
+ *
+ * @param options - Generation options
+ * @returns true if types were generated, false if no env files found
+ */
+export async function generateEnvTypes(options: GenerateEnvTypesOptions): Promise<boolean> {
+	const { rootDir, srcDir, logger, isProduction, profile } = options;
+
+	logger.debug('[env-types] Starting env types generation...');
+	logger.debug(`[env-types] rootDir: ${rootDir}`);
+	logger.debug(`[env-types] srcDir: ${srcDir}`);
+	logger.debug(`[env-types] isProduction: ${isProduction}`);
+	logger.debug(`[env-types] profile: ${profile ?? '(none)'}`);
+
+	// Get env file paths based on build mode and profile
+	// Dev: ['.env.{profile}', '.env.development', '.env'] - later files override earlier
+	// Prod: ['.env.{profile}', '.env', '.env.production'] - later files override earlier
+	const envFilePaths = getEnvFilePaths(rootDir, { isProduction, configName: profile });
+	logger.debug(`[env-types] Env file paths to check: ${envFilePaths.join(', ')}`);
+
+	// Read and merge env files (later files override earlier)
+	const mergedEnv: Record<string, string> = {};
+	let foundAnyFile = false;
+
+	for (const filePath of envFilePaths) {
+		const envVars = await readEnvFile(filePath);
+		const keyCount = Object.keys(envVars).length;
+
+		if (keyCount > 0) {
+			foundAnyFile = true;
+			logger.debug(`[env-types] Read ${keyCount} vars from ${filePath}`);
+
+			// Merge - later values override earlier
+			for (const [key, value] of Object.entries(envVars)) {
+				mergedEnv[key] = value;
+			}
+		} else {
+			logger.debug(`[env-types] No vars found in ${filePath} (file may not exist)`);
+		}
+	}
+
+	if (!foundAnyFile) {
+		logger.debug('[env-types] No .env files found, skipping env types generation');
+		return false;
+	}
+
+	// Extract just the keys (we don't include values in types)
+	const keys = Object.keys(mergedEnv);
+	logger.debug(`[env-types] Total unique keys: ${keys.length}`);
+
+	// Determine output path
+	const outDir = join(srcDir, 'generated');
+	const outputPath = join(outDir, 'env.d.ts');
+
+	// Ensure output directory exists
+	if (!existsSync(outDir)) {
+		mkdirSync(outDir, { recursive: true });
+		logger.debug(`[env-types] Created output directory: ${outDir}`);
+	}
+
+	// Generate and write types
+	const typesContent = generateEnvTypesContent(keys);
+	await Bun.write(outputPath, typesContent);
+
+	const publicKeyCount = keys.filter(isPublicVarKey).length;
+	logger.debug(
+		`[env-types] Generated env types with ${keys.length} keys (${publicKeyCount} public) at ${outputPath}`
+	);
+
+	return true;
+}

package/src/cmd/build/vite/index.ts

@@ -6,6 +6,7 @@ import { discoverAgents, type AgentMetadata } from './agent-discovery';
 import { discoverRoutes, type RouteMetadata, type RouteInfo } from './route-discovery';
 import { generateAgentRegistry, generateRouteRegistry } from './registry-generator';
 import { generateLifecycleTypes } from './lifecycle-generator';
+import { generateEnvTypes } from './env-types-generator';
 import { generateMetadata, writeMetadataFile, generateRouteMapping } from './metadata-generator';
 import { generateEntryFile } from '../entry-generator';
 import { loadAgentuityConfig, getWorkbenchConfig } from './config-loader';
@@ -22,6 +23,8 @@ export interface AgentuityPluginOptions {
 	deploymentId?: string;
 	logLevel?: LogLevel;
 	deploymentOptions?: DeployOptions;
+	/** Optional config profile name (e.g., 'staging', 'test') for .env.{profile} files */
+	profile?: string;
 }
 
 /**
@@ -45,6 +48,7 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 		deploymentId = '',
 		logLevel = 'info',
 		deploymentOptions,
+		profile,
 	} = options;
 	const logger = createLogger(logLevel);
 	const srcDir = join(rootDir, 'src');
@@ -97,6 +101,17 @@ export function agentuityPlugin(options: AgentuityPluginOptions): Plugin {
 			const lifecycleResult = await generateLifecycleTypes(rootDir, srcDir, logger);
 			logger.debug(`[vite-plugin] generateLifecycleTypes returned: ${lifecycleResult}`);
 
+			// Generate environment types from local .env files
+			logger.debug('[vite-plugin] About to call generateEnvTypes');
+			const envTypesResult = await generateEnvTypes({
+				rootDir,
+				srcDir,
+				logger,
+				isProduction: !dev,
+				profile,
+			});
+			logger.debug(`[vite-plugin] generateEnvTypes returned: ${envTypesResult}`);
+
 			// Generate entry file (pass workbench and analytics config)
 			await generateEntryFile({
 				rootDir,

package/src/cmd/build/vite/public-asset-path-plugin.ts

@@ -162,7 +162,10 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 				const patterns = createIncorrectPatterns();
 				for (const { regex, replacement } of patterns) {
 					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+					transformed = transformed.replace(
+						replaceRegex,
+						replacement.replace('{base}', targetBase)
+					);
 				}
 			}
 
@@ -171,7 +174,10 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 				const publicPatterns = createPublicPatterns();
 				for (const { regex, replacement } of publicPatterns) {
 					const replaceRegex = new RegExp(regex.source, regex.flags);
-					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+					transformed = transformed.replace(
+						replaceRegex,
+						replacement.replace('{base}', targetBase)
+					);
 				}
 			}