@agentuity/cli 0.0.100 → 0.0.101

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

@@ -33,8 +33,12 @@ export interface RouteInfo {
 	routeType: 'api' | 'sms' | 'email' | 'cron' | 'websocket' | 'sse' | 'stream';
 	agentVariable?: string;
 	agentImportPath?: string;
+	agentName?: string;
+	agentDescription?: string;
 	inputSchemaVariable?: string;
 	outputSchemaVariable?: string;
+	inputSchemaCode?: string;
+	outputSchemaCode?: string;
 	stream?: boolean;
 }
 

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

@@ -24,7 +24,7 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 
 	logger.debug('[server-bundler] Starting server bundle process');
 
-	const entryPath = join(rootDir, '.agentuity/app.generated.ts');
+	const entryPath = join(rootDir, 'src/generated/app.ts');
 	const outDir = join(rootDir, '.agentuity');
 
 	logger.debug(`[server-bundler] Entry: ${entryPath}, OutDir: ${outDir}`);
@@ -246,6 +246,10 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		minify: !dev,
 		sourcemap: (dev ? 'inline' : 'external') as 'inline' | 'external',
 		external,
+		// CRITICAL: Disable environment variable inlining for server builds
+		// Server code must read process.env at RUNTIME, not have values baked in at build time
+		// Without this, NODE_ENV and other env vars get inlined as string literals
+		env: 'disable' as const,
 		define: userDefine, // Include custom define values from agentuity.config.ts
 		plugins: [patchPlugin],
 		naming: {
@@ -257,6 +261,12 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		`Bun.build config: ${JSON.stringify({ ...buildConfig, external: `[${external.length} packages]` }, null, 2)}`
 	);
 
+	// WORKAROUND: Temporarily delete NODE_ENV to prevent Bun.build from inlining it
+	// See: https://github.com/oven-sh/bun/issues/20183
+	// Even with env: 'disable', Bun.build still inlines NODE_ENV at build time
+	const originalNodeEnv = process.env.NODE_ENV;
+	delete process.env.NODE_ENV;
+
 	// Verify entry point exists before building
 	if (!(await Bun.file(entryPath).exists())) {
 		throw new Error(`Entry point not found: ${entryPath}`);
@@ -268,6 +278,10 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 	try {
 		result = await Bun.build(buildConfig);
 	} catch (error: unknown) {
+		// Restore NODE_ENV after build attempt
+		if (originalNodeEnv !== undefined) {
+			process.env.NODE_ENV = originalNodeEnv;
+		}
 		logger.error('Bun.build threw an exception');
 
 		// Handle AggregateError with build/resolve messages
@@ -286,6 +300,11 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		throw error;
 	}
 
+	// Restore NODE_ENV after successful build
+	if (originalNodeEnv !== undefined) {
+		process.env.NODE_ENV = originalNodeEnv;
+	}
+
 	if (!result.success) {
 		logger.error('Bun.build failed for server');
 		logger.error(

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

@@ -25,7 +25,7 @@ export interface ViteBuildOptions {
 
 /**
  * Run a Vite build for the specified mode
- * Generates vite config in .agentuity/.vite/ and uses it
+ * Uses inline Vite config (customizable via agentuity.config.ts)
  */
 export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	const { rootDir, mode, dev = false, projectId = '', deploymentId = '', logger } = options;
@@ -35,7 +35,17 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	// For server mode, use Bun.build (preserves process.env at runtime)
 	if (mode === 'server') {
 		try {
-			// First, generate the entry file
+			const srcDir = join(rootDir, 'src');
+
+			// Generate documentation files (if they don't exist)
+			const { generateDocumentation } = await import('./docs-generator');
+			await generateDocumentation(srcDir, logger);
+
+			// Generate lifecycle types (if setup() exists)
+			const { generateLifecycleTypes } = await import('./lifecycle-generator');
+			await generateLifecycleTypes(rootDir, srcDir, logger);
+
+			// Then, generate the entry file
 			const { generateEntryFile } = await import('../entry-generator');
 			await generateEntryFile({
 				rootDir,
@@ -45,7 +55,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 				mode: dev ? 'dev' : 'prod',
 			});
 
-			// Then, build with Bun.build
+			// Finally, build with Bun.build
 			const { installExternalsAndBuild } = await import('./server-bundler');
 			await installExternalsAndBuild({
 				rootDir,
@@ -213,10 +223,36 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
 	}
 
+	// 1. Discover agents and routes BEFORE builds
+	logger.debug('Discovering agents and routes...');
+	const { generateAgentRegistry, generateRouteRegistry } = await import('./registry-generator');
+	const { discoverAgents } = await import('./agent-discovery');
+	const { discoverRoutes } = await import('./route-discovery');
+
+	const srcDir = join(rootDir, 'src');
+	const agentMetadata = await discoverAgents(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+	const { routes, routeInfoList } = await discoverRoutes(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+
+	// Generate agent and route registries for type augmentation BEFORE builds
+	// (TypeScript needs these files to exist during type checking)
+	generateAgentRegistry(srcDir, agentMetadata);
+	generateRouteRegistry(srcDir, routeInfoList);
+	logger.debug('Agent and route registries generated');
+
 	// Check if web frontend exists
 	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
 
-	// 1. Build client (only if web frontend exists)
+	// 2. Build client (only if web frontend exists)
 	if (hasWebFrontend) {
 		logger.debug('Building client assets...');
 		try {
@@ -237,7 +273,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Skipping client build - no src/web/index.html found');
 	}
 
-	// 2. Build workbench (if enabled in config)
+	// 3. Build workbench (if enabled in config)
 	if (workbenchConfig.enabled) {
 		logger.debug('Building workbench assets...');
 		try {
@@ -256,7 +292,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		}
 	}
 
-	// 3. Build server
+	// 4. Build server
 	logger.debug('Building server...');
 	try {
 		const started = Date.now();
@@ -268,31 +304,9 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		throw error;
 	}
 
-	// 4. Generate registry and metadata (after all builds complete)
-	logger.debug('Generating agent registry and metadata...');
+	// 5. Generate metadata (after all builds complete)
+	logger.debug('Generating metadata...');
 	const { generateMetadata, writeMetadataFile } = await import('./metadata-generator');
-	const { generateAgentRegistry, generateRouteRegistry } = await import('./registry-generator');
-	const { discoverAgents } = await import('./agent-discovery');
-	const { discoverRoutes } = await import('./route-discovery');
-
-	const srcDir = join(rootDir, 'src');
-	const agentMetadata = await discoverAgents(
-		srcDir,
-		projectId,
-		options.deploymentId || '',
-		logger
-	);
-	const { routes, routeInfoList } = await discoverRoutes(
-		srcDir,
-		projectId,
-		options.deploymentId || '',
-		logger
-	);
-
-	// Generate agent and route registries for type augmentation
-	generateAgentRegistry(srcDir, agentMetadata);
-	generateRouteRegistry(srcDir, routeInfoList);
-	logger.debug('Agent and route registries generated');
 
 	// Generate metadata
 	const metadata = await generateMetadata({

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

@@ -75,8 +75,8 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 	}
 
 	try {
-		// Run all Vite builds (client -> workbench -> server)
-		logger.debug('Starting Vite builds...');
+		// Run all builds (client -> workbench -> server)
+		logger.debug('Starting builds...');
 
 		const result = await runAllBuilds({
 			rootDir,
@@ -90,16 +90,16 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 		});
 
 		if (result.client.included) {
-			output.push(tui.muted(`✓ Client Built in ${result.client.duration}ms`));
+			output.push(tui.muted(`✓ Client built in ${result.client.duration}ms`));
 		}
 		if (result.workbench.included) {
-			output.push(tui.muted(`✓ Workbench Built in ${result.workbench.duration}ms`));
+			output.push(tui.muted(`✓ Workbench built in ${result.workbench.duration}ms`));
 		}
 		if (result.server.included) {
-			output.push(tui.muted(`✓ Server Built in ${result.server.duration}ms`));
+			output.push(tui.muted(`✓ Server built in ${result.server.duration}ms`));
 		}
 
-		logger.debug('Vite builds complete');
+		logger.debug('All builds complete');
 
 		return { output };
 	} catch (error) {

package/src/cmd/cloud/deploy.ts

@@ -6,8 +6,9 @@ import { tmpdir } from 'node:os';
 import { StructuredError } from '@agentuity/core';
 import { isRunningFromExecutable } from '../upgrade';
 import { createSubcommand } from '../../types';
+import { getUserAgent } from '../../api';
 import * as tui from '../../tui';
-import { saveProjectDir, getDefaultConfigDir } from '../../config';
+import { saveProjectDir, getDefaultConfigDir, loadProjectSDKKey } from '../../config';
 import {
 	runSteps,
 	stepSuccess,
@@ -106,6 +107,15 @@ export const deploySubcommand = createSubcommand({
 		let statusResult: DeploymentStatusResult | undefined;
 		const logs: string[] = [];
 
+		const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
+
+		// Ensure SDK key is present before proceeding
+		if (!sdkKey) {
+			ctx.logger.fatal(
+				'SDK key not found. Run "agentuity auth login" to authenticate or set AGENTUITY_SDK_KEY environment variable.'
+			);
+		}
+
 		try {
 			await saveProjectDir(projectDir);
 
@@ -241,10 +251,6 @@ export const deploySubcommand = createSubcommand({
 							const deploymentZip = join(tmpdir(), `${deployment.id}.zip`);
 							await zipDir(join(projectDir, '.agentuity'), deploymentZip, {
 								filter: (_filename: string, relative: string) => {
-									// Exclude Vite-specific build artifacts
-									if (relative.endsWith('.generated.ts')) {
-										return false;
-									}
 									if (relative.startsWith('.vite/')) {
 										return false;
 									}
@@ -444,6 +450,10 @@ export const deploySubcommand = createSubcommand({
 										logger.debug('fetching stream: %s/%s', streamsUrl, streamId);
 										const resp = await fetch(`${streamsUrl}/${streamId}`, {
 											signal: logStreamController.signal,
+											headers: {
+												Authorization: `Bearer ${sdkKey}`,
+												'User-Agent': getUserAgent(),
+											},
 										});
 										if (!resp.ok || !resp.body) {
 											ctx.logger.trace(

package/src/cmd/dev/file-watcher.ts

@@ -142,10 +142,16 @@ export function createFileWatcher(options: FileWatcherOptions): FileWatcherManag
 					const contents = readdirSync(absPath);
 					if (contents.length === 0) {
 						// Check if this is an agent or API directory
-						if (normalizedPath.startsWith('src/agent/') || normalizedPath.includes('/src/agent/')) {
+						if (
+							normalizedPath.startsWith('src/agent/') ||
+							normalizedPath.includes('/src/agent/')
+						) {
 							logger.debug('Agent directory created: %s', changedFile);
 							createAgentTemplates(absPath);
-						} else if (normalizedPath.startsWith('src/api/') || normalizedPath.includes('/src/api/')) {
+						} else if (
+							normalizedPath.startsWith('src/api/') ||
+							normalizedPath.includes('/src/api/')
+						) {
 							logger.debug('API directory created: %s', changedFile);
 							createAPITemplates(absPath);
 						}

package/src/cmd/dev/index.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { resolve, join } from 'node:path';
 import { existsSync } from 'node:fs';
-import { internalExit } from '@agentuity/runtime';
+import { getServiceUrls } from '@agentuity/server';
 import { createCommand } from '../../types';
 import { startBunDevServer } from '../build/vite/bun-dev-server';
 import { startViteAssetServer } from '../build/vite/vite-asset-server';
@@ -99,6 +99,13 @@ export const command = createCommand({
 
 		const interactive = !shouldDisableInteractive(opts.interactive);
 
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let originalExit = (globalThis as any).AGENTUITY_PROCESS_EXIT;
+
+		if (!originalExit) {
+			originalExit = process.exit.bind(process);
+		}
+
 		for (const filename of mustHaves) {
 			if (!existsSync(filename)) {
 				missing.push(filename);
@@ -110,17 +117,22 @@ export const command = createCommand({
 			for (const filename of missing) {
 				tui.bullet(`Missing ${filename}`);
 			}
-			internalExit(1);
+			originalExit(1);
 		}
 
 		// Setup devmode and gravity (if using public URL)
 		const useMockService = process.env.DEVMODE_SYNC_SERVICE_MOCK === 'true';
 		const apiClient = auth ? new APIClient(getAPIBaseURL(config), logger, config) : null;
-		createDevmodeSyncService({
-			logger,
-			apiClient,
-			mock: useMockService,
-		});
+		const syncService = apiClient
+			? createDevmodeSyncService({
+					logger,
+					apiClient,
+					mock: useMockService,
+				})
+			: null;
+
+		// Track previous metadata for sync diffing
+		let previousMetadata: Awaited<ReturnType<typeof import('../build/vite/metadata-generator').generateMetadata>> | undefined;
 
 		let devmode: DevmodeResponse | undefined;
 		let gravityBin: string | undefined;
@@ -224,8 +236,8 @@ export const command = createCommand({
 
 		// Start Vite asset server ONCE before restart loop
 		// Vite handles frontend HMR independently and stays running across backend restarts
-		let vitePort: number;
 		let viteServer: ServerLike | null = null;
+		let vitePort: number;
 
 		try {
 			logger.debug('Starting Vite asset server...');
@@ -241,13 +253,15 @@ export const command = createCommand({
 			);
 		} catch (error) {
 			tui.error(`Failed to start Vite asset server: ${error}`);
-			internalExit(1);
+			originalExit(1);
+			return;
 		}
 
 		// Restart loop - allows BACKEND server to restart on file changes
 		// Vite stays running and handles frontend changes via HMR
 		let shouldRestart = false;
 		let gravityProcess: ProcessLike | null = null;
+		let stdinListenerRegistered = false; // Track if stdin listener is already registered
 
 		const restartServer = () => {
 			shouldRestart = true;
@@ -293,11 +307,22 @@ export const command = createCommand({
 				}
 			}
 
-			internalExit(0);
+			originalExit(0);
 		};
 
-		process.on('SIGINT', cleanup);
-		process.on('SIGTERM', cleanup);
+		// SIGINT/SIGTERM: coordinate shutdown between bundle and dev resources
+		let devShutdownHandled = false;
+		process.on('SIGINT', async () => {
+			if (devShutdownHandled) return;
+			devShutdownHandled = true;
+			// The bundle handles its own shutdown, we clean up dev resources
+			await cleanup();
+		});
+		process.on('SIGTERM', async () => {
+			if (devShutdownHandled) return;
+			devShutdownHandled = true;
+			await cleanup();
+		});
 
 		// Ensure Vite and gravity are always killed on exit (even if cleanup is bypassed)
 		process.on('exit', () => {
@@ -329,23 +354,76 @@ export const command = createCommand({
 			fileWatcher.pause();
 
 			try {
-				// Generate entry file for Vite before starting dev server
+				// Generate entry file and bundle for dev server (with LLM patches)
 				await tui.spinner({
-					message: 'Generating entry file',
+					message: 'Building dev bundle',
 					callback: async () => {
-						const { generateEntryFile } = await import('../build/entry-generator');
-						await generateEntryFile({
-							rootDir,
-							projectId: project?.projectId ?? '',
-							deploymentId,
-							logger,
-							mode: 'dev',
-						});
+					const { generateEntryFile } = await import('../build/entry-generator');
+					await generateEntryFile({
+						rootDir,
+						projectId: project?.projectId ?? '',
+						deploymentId,
+						logger,
+						mode: 'dev',
+					});
+
+					// Bundle the app with LLM patches (dev mode = no minification)
+					const { installExternalsAndBuild } = await import('../build/vite/server-bundler');
+					await installExternalsAndBuild({
+						rootDir,
+						dev: true, // DevMode: no minification, inline sourcemaps
+						logger,
+					});
+
+					// Generate metadata file (needed for eval ID lookup at runtime)
+					const { discoverAgents } = await import('../build/vite/agent-discovery');
+					const { discoverRoutes } = await import('../build/vite/route-discovery');
+					const { generateMetadata, writeMetadataFile } = await import(
+						'../build/vite/metadata-generator'
+					);
+
+					const srcDir = join(rootDir, 'src');
+					const agents = await discoverAgents(
+						srcDir,
+						project?.projectId ?? '',
+						deploymentId,
+						logger
+					);
+					const { routes } = await discoverRoutes(
+						srcDir,
+						project?.projectId ?? '',
+						deploymentId,
+						logger
+					);
+
+					const metadata = await generateMetadata({
+						rootDir,
+						projectId: project?.projectId ?? '',
+						orgId: project?.orgId ?? '',
+						deploymentId,
+						agents,
+						routes,
+						dev: true,
+						logger,
+					});
+
+					writeMetadataFile(rootDir, metadata, true, logger);
+
+					// Sync metadata with backend (creates agents and evals in the database)
+					if (syncService && project?.projectId) {
+						await syncService.sync(
+							metadata,
+							previousMetadata,
+							project.projectId,
+							deploymentId
+						);
+						previousMetadata = metadata;
+					}
 					},
 					clearOnSuccess: true,
 				});
 			} catch (error) {
-				tui.error(`Failed to generate entry file: ${error}`);
+				tui.error(`Failed to build dev bundle: ${error}`);
 				tui.warn('Waiting for file changes to retry...');
 
 				// Resume watcher to detect changes for retry
@@ -364,6 +442,34 @@ export const command = createCommand({
 			}
 
 			try {
+				// Set environment variables for LLM provider patches BEFORE starting server
+				// These must be set so the bundled patches can route LLM calls through AI Gateway
+				const serviceUrls = getServiceUrls(project?.region);
+
+				process.env.AGENTUITY_SDK_DEV_MODE = 'true';
+				process.env.AGENTUITY_ENV = 'development';
+				process.env.NODE_ENV = 'development';
+				if (project?.region) {
+					process.env.AGENTUITY_REGION = project.region;
+				}
+				process.env.PORT = String(opts.port);
+				process.env.AGENTUITY_PORT = process.env.PORT;
+
+				if (project) {
+					process.env.AGENTUITY_TRANSPORT_URL = serviceUrls.catalyst;
+					process.env.AGENTUITY_CATALYST_URL = serviceUrls.catalyst;
+					process.env.AGENTUITY_VECTOR_URL = serviceUrls.vector;
+					process.env.AGENTUITY_KEYVALUE_URL = serviceUrls.keyvalue;
+					process.env.AGENTUITY_STREAM_URL = serviceUrls.stream;
+					process.env.AGENTUITY_CLOUD_ORG_ID = project.orgId;
+					process.env.AGENTUITY_CLOUD_PROJECT_ID = project.projectId;
+				}
+
+				// Set Vite port for asset proxying in bundled app
+				process.env.VITE_PORT = String(vitePort);
+
+				logger.debug('Set VITE_PORT=%s for asset proxying', process.env.VITE_PORT);
+
 				// Start Bun dev server (Vite already running, just start backend)
 				await startBunDevServer({
 					rootDir,
@@ -375,8 +481,6 @@ export const command = createCommand({
 					vitePort, // Pass port of already-running Vite server
 				});
 
-				// Note: Bun server runs in-process, no separate app process needed
-
 				// Wait for app.ts to finish loading (Vite is ready but app may still be initializing)
 				// Give it 2 seconds to ensure app initialization completes
 				await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -454,8 +558,14 @@ export const command = createCommand({
 				// TODO: Integrate sync service with Vite's buildStart/buildEnd hooks
 				// The sync service will be called when metadata changes are detected
 
-				// Handle keyboard shortcuts
-				if (interactive && process.stdin.isTTY && process.stdout.isTTY) {
+				// Handle keyboard shortcuts - only register listener once
+				if (
+					interactive &&
+					process.stdin.isTTY &&
+					process.stdout.isTTY &&
+					!stdinListenerRegistered
+				) {
+					stdinListenerRegistered = true;
 					process.stdin.setRawMode(true);
 					process.stdin.resume();
 					process.stdin.setEncoding('utf8');
@@ -470,9 +580,10 @@ export const command = createCommand({
 					process.stdin.on('data', (data) => {
 						const key = data.toString();
 
-						// Handle Ctrl+C
+						// Handle Ctrl+C - send SIGINT to trigger graceful shutdown
 						if (key === '\u0003') {
-							internalExit(0);
+							process.kill(process.pid, 'SIGINT');
+							return;
 						}
 
 						switch (key) {
@@ -489,7 +600,7 @@ export const command = createCommand({
 								});
 								break;
 							case 'q':
-								internalExit(0);
+								originalExit(0);
 								break;
 							default:
 								process.stdout.write(data);

package/src/cmd/dev/sync.ts

@@ -171,9 +171,21 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		for (const agent of currentMetadata.agents || []) {
 			if (agent.evals) {
 				currentEvalCount += agent.evals.length;
+				this.logger.info(
+					'[CLI EVAL SYNC] Agent "%s" has %d eval(s)',
+					agent.name,
+					agent.evals.length
+				);
+				for (const evalItem of agent.evals) {
+					this.logger.info(
+						'[CLI EVAL SYNC]   - %s (evalId: %s)',
+						evalItem.name,
+						evalItem.evalId
+					);
+				}
 			}
 		}
-		this.logger.debug('Processing %d current eval(s)', currentEvalCount);
+		this.logger.info('[CLI EVAL SYNC] Total current eval(s): %d', currentEvalCount);
 
 		// Get agents and evals to sync using shared diff logic
 		const { create: agentsToCreate, delete: agentsToDelete } = getAgentsToSync(
@@ -261,7 +273,14 @@ class DevmodeSyncService implements IDevmodeSyncService {
 		evalsToDelete: string[],
 		deploymentId: string
 	): Promise<void> {
+		this.logger.info(
+			'[CLI EVAL SYNC] syncEvals called: %d to create, %d to delete',
+			evals.length,
+			evalsToDelete.length
+		);
+
 		if (evals.length === 0 && evalsToDelete.length === 0) {
+			this.logger.info('[CLI EVAL SYNC] No evals to sync, skipping');
 			return;
 		}
 
@@ -270,12 +289,28 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			create: evals,
 			delete: evalsToDelete,
 		};
-		this.logger.trace(
-			'[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval: %s',
-			JSON.stringify(payload, null, 2)
-		);
 
-		await this.apiClient.post('/cli/devmode/eval', payload, z.object({ success: z.boolean() }));
+		this.logger.info('[CLI EVAL SYNC] Sending payload to POST /cli/devmode/eval:');
+		for (const evalItem of evals) {
+			this.logger.info(
+				'[CLI EVAL SYNC]   - %s (id: %s, evalId: %s)',
+				evalItem.name,
+				evalItem.id,
+				evalItem.evalId
+			);
+		}
+
+		try {
+			await this.apiClient.post(
+				'/cli/devmode/eval',
+				payload,
+				z.object({ success: z.boolean() })
+			);
+			this.logger.info('[CLI EVAL SYNC] Sync successful');
+		} catch (error) {
+			this.logger.error('[CLI EVAL SYNC] Sync failed: %s', error);
+			throw error;
+		}
 	}
 }
 

package/src/config.ts

@@ -364,6 +364,15 @@ export async function getAuth(): Promise<AuthData | null> {
 		};
 	}
 
+	// Priority 1a: Allow automated login from environment variables (this is set in deployment)
+	if (process.env.AGENTUITY_API_KEY) {
+		return {
+			apiKey: process.env.AGENTUITY_API_KEY,
+			userId: '',
+			expires: new Date(Date.now() + 30 * 60_000),
+		};
+	}
+
 	// Priority 2: On macOS, try to read from Keychain
 	if (isMacOS()) {
 		try {

package/src/index.ts

@@ -75,11 +75,6 @@ export { showBanner } from './banner';
 export { discoverCommands } from './cmd';
 export { detectColorScheme } from './terminal';
 export { getCommandPrefix, getCommand } from './command-prefix';
-export {
-	bootstrapRuntimeEnv,
-	type RuntimeBootstrapOptions,
-	type RuntimeBootstrapResult,
-} from './runtime-bootstrap';
 export * as tui from './tui';
 export {
 	createRepl,

package/src/runtime-bootstrap.md

@@ -43,7 +43,7 @@ Call `bootstrapRuntimeEnv()` at the top of your `app.ts` **before** `createApp()
 
 ```ts
 import { createApp } from '@agentuity/runtime';
-import { bootstrapRuntimeEnv } from '@agentuity/cli';
+import { bootstrapRuntimeEnv } from '@agentuity/runtime';
 
 // Bootstrap runtime environment based on active profile
 await bootstrapRuntimeEnv();