@agentuity/cli 0.0.72 → 0.0.73

package/src/cmd/build/format-schema.ts

@@ -0,0 +1,66 @@
+/**
+ * Simple formatter for schema code strings.
+ * Adds basic indentation and line breaks for readability.
+ */
+export function formatSchemaCode(code: string): string {
+	if (!code) return code;
+
+	let indentLevel = 0;
+	const indentSize = 2;
+	const lines: string[] = [];
+	let currentLine = '';
+
+	for (let i = 0; i < code.length; i++) {
+		const char = code[i];
+		const nextChar = code[i + 1];
+		const prevChar = i > 0 ? code[i - 1] : '';
+
+		// Skip existing whitespace/newlines
+		if (char === '\n' || char === '\r' || (char === ' ' && prevChar === ' ')) {
+			continue;
+		}
+
+		// Handle opening braces
+		if (char === '{') {
+			currentLine += char;
+			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+			indentLevel++;
+			currentLine = '';
+			continue;
+		}
+
+		// Handle closing braces
+		if (char === '}') {
+			if (currentLine.trim()) {
+				lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+				currentLine = '';
+			}
+			indentLevel--;
+			// Check if next char is closing paren - if so, put on same line
+			if (nextChar === ')') {
+				currentLine = '}';
+			} else {
+				lines.push(' '.repeat(indentLevel * indentSize) + char);
+			}
+			continue;
+		}
+
+		// Handle commas - add line break after
+		if (char === ',') {
+			currentLine += char;
+			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+			currentLine = '';
+			continue;
+		}
+
+		// Accumulate characters
+		currentLine += char;
+	}
+
+	// Add any remaining content
+	if (currentLine.trim()) {
+		lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+	}
+
+	return lines.join('\n');
+}

package/src/cmd/build/index.ts

@@ -77,6 +77,20 @@ export const command = createCommand({
 				logger: ctx.logger,
 			});
 
+			// Copy profile-specific .env file AFTER bundling (bundler clears outDir first)
+			if (opts.dev && ctx.config?.name) {
+				const envSourcePath = join(absoluteProjectDir, `.env.${ctx.config.name}`);
+				const envDestPath = join(outDir, '.env');
+
+				const envFile = Bun.file(envSourcePath);
+				if (await envFile.exists()) {
+					await Bun.write(envDestPath, envFile);
+					ctx.logger.debug(`Copied ${envSourcePath} to ${envDestPath}`);
+				} else {
+					ctx.logger.debug(`No .env.${ctx.config.name} file found, skipping env copy`);
+				}
+			}
+
 			// Run TypeScript type checking after registry generation (skip in dev mode)
 			if (!opts.dev && !opts.skipTypeCheck) {
 				try {

package/src/cmd/build/plugin.ts

@@ -371,10 +371,30 @@ import { readFileSync, existsSync } from 'node:fs';
 		}
 	}
 	const webstatic = serveStatic({ root: import.meta.dir + '/web' });
+	// In dev mode, serve from source; in prod, serve from build output
+	const publicRoot = ${isDevMode} ? ${JSON.stringify(join(srcDir, 'web', 'public'))} : import.meta.dir + '/web/public';
+	const publicstatic = serveStatic({ root: publicRoot, rewriteRequestPath: (path) => path });
 	router.get('/', (c) => c.html(index));
     router.get('/web/chunk/*', webstatic);
     router.get('/web/asset/*', webstatic);
-	router.get('/public/*', webstatic);
+	// Serve public assets at root (e.g., /favicon.ico) - must be last
+	router.get('/*', async (c, next) => {
+		const path = c.req.path;
+		// Prevent directory traversal attacks
+		if (path.includes('..') || path.includes('%2e%2e')) {
+			return c.notFound();
+		}
+		// Only serve from public folder at root (skip /web/* routes and /)
+		if (path !== '/' && !path.startsWith('/web/')) {
+			try {
+				// serveStatic calls next() internally if file not found
+				return await publicstatic(c, next);
+			} catch (err) {
+				return next();
+			}
+		}
+		return next();
+	});
 })();`);
 				}
 
@@ -415,7 +435,11 @@ import { readFileSync, existsSync } from 'node:fs';
 
 					for (const subdir of subdirs) {
 						const fullPath = join(agentBaseDir, subdir);
-						if (!agentDirs.has(fullPath)) {
+						// Check if this directory or any subdirectory contains agents
+						const hasAgentInTree = Array.from(agentDirs).some((agentDir) =>
+							agentDir.startsWith(fullPath)
+						);
+						if (!hasAgentInTree) {
 							throw new Error(
 								`Directory ${subdir} in src/agent must contain at least one agent (a file with a createAgent export)`
 							);
@@ -447,6 +471,56 @@ import { readFileSync, existsSync } from 'node:fs';
 						if (statSync(apiFile).isFile()) {
 							try {
 								const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
+
+								// Extract schemas from agents for routes that use validators
+								for (const route of routes) {
+									// Check if route has custom schema overrides from validator({ input, output })
+									const hasCustomInput = route.config?.inputSchemaVariable;
+									const hasCustomOutput = route.config?.outputSchemaVariable;
+
+									// If route uses agent.validator(), get schemas from the agent (unless overridden)
+									if (
+										route.config?.agentImportPath &&
+										(!hasCustomInput || !hasCustomOutput)
+									) {
+										const agentImportPath = route.config.agentImportPath as string;
+										// Match by import path: @agent/zod-test -> src/agent/zod-test/agent.ts
+										// Normalize import path by removing leading '@' -> agent/zod-test
+										const importPattern = agentImportPath.replace(/^@/, '');
+										// Escape regex special characters for safe pattern matching
+										const escapedPattern = importPattern.replace(
+											/[.*+?^${}()|[\]\\]/g,
+											'\\$&'
+										);
+										// Match as complete path segment to avoid false positives (e.g., "agent/hello" matching "agent/hello-world")
+										const segmentPattern = new RegExp(`(^|/)${escapedPattern}(/|$)`);
+
+										for (const [, agentMd] of agentMetadata) {
+											const agentFilename = agentMd.get('filename');
+											if (agentFilename && segmentPattern.test(agentFilename)) {
+												// Use agent schemas unless overridden
+												const inputSchemaCode = hasCustomInput
+													? undefined
+													: agentMd.get('inputSchemaCode');
+												const outputSchemaCode = hasCustomOutput
+													? undefined
+													: agentMd.get('outputSchemaCode');
+
+												if (inputSchemaCode || outputSchemaCode) {
+													route.schema = {
+														input: inputSchemaCode,
+														output: outputSchemaCode,
+													};
+												}
+												break;
+											}
+										}
+									}
+
+									// TODO: Extract inline schema code from custom validator({ input: z.string(), output: ... })
+									// For now, custom schema overrides with inline code are not extracted (would require parsing the validator call's object expression)
+								}
+
 								apiRoutesMetadata.push(...routes);
 
 								// Collect route info for RouteRegistry generation
@@ -594,6 +668,16 @@ await (async() => {
 						projectId,
 					};
 
+					// Extract schema codes if available
+					const inputSchemaCode = v.get('inputSchemaCode');
+					const outputSchemaCode = v.get('outputSchemaCode');
+					if (inputSchemaCode || outputSchemaCode) {
+						agentData.schema = {
+							input: inputSchemaCode,
+							output: outputSchemaCode,
+						};
+					}
+
 					const evalsStr = v.get('evals');
 					if (evalsStr) {
 						logger.trace(

package/src/cmd/cloud/deployment/show.ts

@@ -15,6 +15,10 @@ const DeploymentShowResponseSchema = z.object({
 	tags: z.array(z.string()).describe('Deployment tags'),
 	customDomains: z.array(z.string()).optional().describe('Custom domains'),
 	cloudRegion: z.string().optional().describe('Cloud region'),
+	resourceDb: z.string().nullable().optional().describe('the database name'),
+	resourceStorage: z.string().nullable().optional().describe('the storage name'),
+	deploymentLogsURL: z.string().nullable().optional().describe('the url to the deployment logs'),
+	buildLogsURL: z.string().nullable().optional().describe('the url to the build logs'),
 	metadata: z
 		.object({
 			git: z
@@ -87,27 +91,51 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				console.log(tui.bold('ID:       ') + deployment.id);
-				console.log(tui.bold('Project:  ') + projectId);
-				console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
-				console.log(tui.bold('Active:   ') + (deployment.active ? 'Yes' : 'No'));
-				console.log(tui.bold('Created:  ') + new Date(deployment.createdAt).toLocaleString());
+				const maxWidth = 18;
+				console.log(tui.bold('ID:'.padEnd(maxWidth)) + deployment.id);
+				console.log(tui.bold('Project:'.padEnd(maxWidth)) + projectId);
+				console.log(tui.bold('State:'.padEnd(maxWidth)) + (deployment.state || 'unknown'));
+				console.log(tui.bold('Active:'.padEnd(maxWidth)) + (deployment.active ? 'Yes' : 'No'));
+				console.log(
+					tui.bold('Created:'.padEnd(maxWidth)) +
+						new Date(deployment.createdAt).toLocaleString()
+				);
 				if (deployment.updatedAt) {
 					console.log(
-						tui.bold('Updated:  ') + new Date(deployment.updatedAt).toLocaleString()
+						tui.bold('Updated:'.padEnd(maxWidth)) +
+							new Date(deployment.updatedAt).toLocaleString()
 					);
 				}
 				if (deployment.message) {
-					console.log(tui.bold('Message:  ') + deployment.message);
+					console.log(tui.bold('Message:'.padEnd(maxWidth)) + deployment.message);
 				}
 				if (deployment.tags.length > 0) {
-					console.log(tui.bold('Tags:     ') + deployment.tags.join(', '));
+					console.log(tui.bold('Tags:'.padEnd(maxWidth)) + deployment.tags.join(', '));
 				}
 				if (deployment.customDomains && deployment.customDomains.length > 0) {
-					console.log(tui.bold('Domains:  ') + deployment.customDomains.join(', '));
+					console.log(
+						tui.bold('Domains:'.padEnd(maxWidth)) + deployment.customDomains.join(', ')
+					);
 				}
 				if (deployment.cloudRegion) {
-					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
+					console.log(tui.bold('Region:'.padEnd(maxWidth)) + deployment.cloudRegion);
+				}
+				if (deployment.resourceDb) {
+					console.log(tui.bold('Database:'.padEnd(maxWidth)) + deployment.resourceDb);
+				}
+				if (deployment.resourceStorage) {
+					console.log(tui.bold('Storage:'.padEnd(maxWidth)) + deployment.resourceStorage);
+				}
+				if (deployment.deploymentLogsURL) {
+					console.log(
+						tui.bold('Deployment Logs:'.padEnd(maxWidth)) +
+							tui.link(deployment.deploymentLogsURL)
+					);
+				}
+				if (deployment.buildLogsURL) {
+					console.log(
+						tui.bold('Build Logs:'.padEnd(maxWidth)) + tui.link(deployment.buildLogsURL)
+					);
 				}
 
 				// Git metadata
@@ -153,6 +181,10 @@ export const showSubcommand = createSubcommand({
 				customDomains: deployment.customDomains ?? undefined,
 				cloudRegion: deployment.cloudRegion ?? undefined,
 				metadata: deployment.metadata ?? undefined,
+				resourceDb: deployment.resourceDb ?? undefined,
+				resourceStorage: deployment.resourceStorage ?? undefined,
+				deploymentLogsURL: deployment.deploymentLogsURL ?? undefined,
+				buildLogsURL: deployment.buildLogsURL ?? undefined,
 			};
 		} catch (ex) {
 			tui.fatal(`Failed to show deployment: ${ex}`);

package/src/cmd/dev/agents.ts

@@ -63,14 +63,12 @@ export const agentsSubcommand = createSubcommand({
 		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
 
 		const response = options.json
-			? await apiClient.request(
-					'GET',
+			? await apiClient.get(
 					`/cli/agent/${projectId}${queryParams}`,
 					AgentsResponseSchema
 				)
 			: await tui.spinner('Fetching agents', async () => {
-					return apiClient.request(
-						'GET',
+					return apiClient.get(
 						`/cli/agent/${projectId}${queryParams}`,
 						AgentsResponseSchema
 					);

package/src/cmd/dev/sync.ts

@@ -253,11 +253,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			JSON.stringify(payload, null, 2)
 		);
 
-		await this.apiClient.request(
-			'POST',
+		await this.apiClient.post(
 			'/cli/devmode/agent',
-			z.object({ success: z.boolean() }),
-			payload
+			payload,
+			z.object({ success: z.boolean() })
 		);
 	}
 
@@ -280,11 +279,10 @@ class DevmodeSyncService implements IDevmodeSyncService {
 			JSON.stringify(payload, null, 2)
 		);
 
-		await this.apiClient.request(
-			'POST',
+		await this.apiClient.post(
 			'/cli/devmode/eval',
-			z.object({ success: z.boolean() }),
-			payload
+			payload,
+			z.object({ success: z.boolean() })
 		);
 	}
 }

package/src/cmd/project/show.ts

@@ -6,8 +6,10 @@ import { getCommand } from '../../command-prefix';
 
 const ProjectShowResponseSchema = z.object({
 	id: z.string().describe('Project ID'),
+	name: z.string().describe('Project name'),
+	description: z.string().nullable().optional().describe('Project description'),
+	tags: z.array(z.string()).nullable().optional().describe('Project tags'),
 	orgId: z.string().describe('Organization ID'),
-	name: z.string().optional().describe('Project name'),
 	secrets: z.record(z.string(), z.string()).optional().describe('Project secrets (masked)'),
 	env: z.record(z.string(), z.string()).optional().describe('Environment variables'),
 });
@@ -45,16 +47,16 @@ export const showSubcommand = createSubcommand({
 			tui.fatal('Project not found');
 		}
 
-		if (options.json) {
-			console.log(JSON.stringify(project, null, 2));
-		} else {
-			tui.table([project], ['id', 'orgId']);
+		if (!options.json) {
+			tui.table([project], ['id', 'name', 'description', 'tags', 'orgId']);
 		}
 
 		return {
 			id: project.id,
+			name: project.name,
+			description: project.description,
+			tags: project.tags,
 			orgId: project.orgId,
-			name: undefined,
 			secrets: project.secrets,
 			env: project.env,
 		};

package/src/cmd/project/template-flow.ts

@@ -177,7 +177,13 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 	if (initialTemplate) {
 		const found = templates.find((t) => t.id === initialTemplate);
 		if (!found) {
-			logger.fatal(`Template "${initialTemplate}" not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			const availableTemplates = templates
+				.map((t) => `  - ${t.id.padEnd(20)} ${t.description}`)
+				.join('\n');
+			logger.fatal(
+				`Template "${initialTemplate}" not found\n\nAvailable templates:\n${availableTemplates}`,
+				ErrorCode.RESOURCE_NOT_FOUND
+			);
 			return;
 		}
 		selectedTemplate = found;
@@ -232,7 +238,7 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 	const resourceConfig: ResourcesTypes = Resources.parse({});
 
-	if (auth && apiClient && catalystClient && orgId && region) {
+	if (auth && apiClient && catalystClient && orgId && region && !skipPrompts) {
 		// Fetch resources for selected org and region using Catalyst API
 		const resources = await tui.spinner({
 			message: 'Fetching resources',
@@ -316,12 +322,25 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 		const cloudRegion = region ?? process.env.AGENTUITY_REGION ?? 'usc';
 
+		const pkgJsonPath = resolve(dest, 'package.json');
+		let pkgJson: { description?: string; keywords?: string[] } = {};
+		if (existsSync(pkgJsonPath)) {
+			pkgJson = await Bun.file(pkgJsonPath).json();
+		}
+
+		const keywords = Array.isArray(pkgJson.keywords) ? pkgJson.keywords : [];
+		const tags = keywords.filter(
+			(tag) => tag.toLowerCase() !== 'agentuity' && !tag.toLowerCase().startsWith('agentuity')
+		);
+
 		await tui.spinner({
 			message: 'Registering your project',
 			clearOnSuccess: true,
 			callback: async () => {
 				const project = await projectCreate(apiClient, {
 					name: projectName,
+					description: pkgJson.description,
+					tags: tags.length > 0 ? tags : undefined,
 					orgId,
 					cloudRegion,
 				});

package/src/config.ts

@@ -51,6 +51,16 @@ export async function saveProfile(path: string): Promise<void> {
 }
 
 export async function getProfile(): Promise<string> {
+	// Check environment variable first
+	if (process.env.AGENTUITY_PROFILE) {
+		const profileName = process.env.AGENTUITY_PROFILE;
+		const envProfilePath = join(getDefaultConfigDir(), `${profileName}.yaml`);
+		const envFile = Bun.file(envProfilePath);
+		if (await envFile.exists()) {
+			return envProfilePath;
+		}
+	}
+
 	const profilePath = getProfilePath();
 	const defaultConfigPath = getDefaultConfigPath();
 

package/src/tui.ts

@@ -927,13 +927,34 @@ export interface LoggerSpinnerOptions<T> {
 	maxLines?: number;
 }
 
+/**
+ * Spinner options (with countdown timer)
+ */
+export interface CountdownSpinnerOptions<T> {
+	type: 'countdown';
+	message: string;
+	timeoutMs: number;
+	callback: () => Promise<T>;
+	/**
+	 * If true, clear the spinner output on success (no icon, no message)
+	 * Defaults to false
+	 */
+	clearOnSuccess?: boolean;
+	/**
+	 * Optional callback to handle Enter key press
+	 * Can be used to open a URL in the browser
+	 */
+	onEnterPress?: () => void;
+}
+
 /**
  * Spinner options (discriminated union)
  */
 export type SpinnerOptions<T> =
 	| SimpleSpinnerOptions<T>
 	| ProgressSpinnerOptions<T>
-	| LoggerSpinnerOptions<T>;
+	| LoggerSpinnerOptions<T>
+	| CountdownSpinnerOptions<T>;
 
 /**
  * Run a callback with an animated spinner (simple overload)
@@ -993,9 +1014,11 @@ export async function spinner<T>(
 								// In non-TTY mode, just write logs directly to stdout
 								process.stdout.write(logMessage + '\n');
 							})
-						: typeof options.callback === 'function'
+						: options.type === 'countdown'
 							? await options.callback()
-							: await options.callback;
+							: typeof options.callback === 'function'
+								? await options.callback()
+								: await options.callback;
 
 			// If clearOnSuccess is true, don't show success message
 			// Also skip success message in JSON mode
@@ -1025,6 +1048,7 @@ export async function spinner<T>(
 
 	let frameIndex = 0;
 	let currentProgress: number | undefined;
+	let remainingTime: number | undefined;
 	const logLines: string[] = [];
 	const maxLines = options.type === 'logger' ? (options.maxLines ?? 3) : 0;
 	const mutedColor = getColor('muted');
@@ -1045,14 +1069,19 @@ export async function spinner<T>(
 		const color = colorDef[currentColorScheme];
 		const frame = `${color}${bold}${frames[frameIndex % frames.length]}${reset}`;
 
-		// Add progress indicator if available
-		const progressIndicator =
-			currentProgress !== undefined
-				? ` ${cyanColor}${Math.floor(currentProgress)}%${reset}`
-				: '';
+		// Add progress indicator or countdown timer if available
+		let indicator = '';
+		if (currentProgress !== undefined) {
+			indicator = ` ${cyanColor}${Math.floor(currentProgress)}%${reset}`;
+		} else if (remainingTime !== undefined) {
+			const minutes = Math.floor(remainingTime / 60);
+			const seconds = Math.floor(remainingTime % 60);
+			const timeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+			indicator = ` ${mutedColor}(${timeStr} remaining)${reset}`;
+		}
 
 		// Render spinner line
-		process.stderr.write(`\r\x1b[K${frame} ${message}${progressIndicator}\n`);
+		process.stderr.write(`\r\x1b[K${frame} ${message}${indicator}\n`);
 
 		// Render log lines if in logger mode
 		if (options.type === 'logger') {
@@ -1089,16 +1118,88 @@ export async function spinner<T>(
 		logLines.push(logMessage);
 	};
 
+	// Countdown interval tracking
+	let countdownInterval: NodeJS.Timeout | undefined;
+	let keypressListener: ((chunk: Buffer) => void) | undefined;
+
+	// Helper to clean up all resources
+	const cleanup = () => {
+		if (countdownInterval) {
+			clearInterval(countdownInterval);
+		}
+		if (keypressListener) {
+			process.stdin.off('data', keypressListener);
+			if (process.stdin.isTTY) {
+				process.stdin.setRawMode(false);
+				process.stdin.pause();
+			}
+		}
+		process.off('SIGINT', cleanupAndExit);
+	};
+
+	// Set up SIGINT handler for clean exit
+	const cleanupAndExit = () => {
+		cleanup();
+
+		// Stop animation
+		clearInterval(interval);
+
+		// Move cursor to start of output, clear all lines
+		if (linesRendered > 0) {
+			process.stderr.write(`\x1b[${linesRendered}A`);
+		}
+		process.stderr.write('\x1b[J'); // Clear from cursor to end of screen
+		process.stderr.write('\x1B[?25h'); // Show cursor
+
+		process.exit(130); // Standard exit code for SIGINT
+	};
+
+	process.on('SIGINT', cleanupAndExit);
+
 	try {
+		// For countdown, set up timer tracking and optional keyboard listener
+		if (options.type === 'countdown') {
+			const startTime = Date.now();
+			remainingTime = options.timeoutMs / 1000;
+			countdownInterval = setInterval(() => {
+				const elapsed = Date.now() - startTime;
+				remainingTime = Math.max(0, (options.timeoutMs - elapsed) / 1000);
+			}, 100);
+
+			// Set up Enter key listener if callback provided
+			if (options.onEnterPress && process.stdin.isTTY) {
+				process.stdin.setRawMode(true);
+				process.stdin.resume();
+
+				keypressListener = (chunk: Buffer) => {
+					const key = chunk.toString();
+					// Check for Enter key (both \r and \n)
+					if (key === '\r' || key === '\n') {
+						options.onEnterPress!();
+					}
+					// Check for Ctrl+C - let it propagate as SIGINT
+					if (key === '\x03') {
+						process.kill(process.pid, 'SIGINT');
+					}
+				};
+
+				process.stdin.on('data', keypressListener);
+			}
+		}
+
 		// Execute callback
 		const result =
-			options.type === 'progress'
-				? await options.callback(progressCallback)
-				: options.type === 'logger'
-					? await options.callback(logCallback)
-					: typeof options.callback === 'function'
-						? await options.callback()
-						: await options.callback;
+			options.type === 'countdown'
+				? await options.callback()
+				: options.type === 'progress'
+					? await options.callback(progressCallback)
+					: options.type === 'logger'
+						? await options.callback(logCallback)
+						: typeof options.callback === 'function'
+							? await options.callback()
+							: await options.callback;
+
+		cleanup();
 
 		// Stop animation first
 		clearInterval(interval);
@@ -1119,6 +1220,8 @@ export async function spinner<T>(
 
 		return result;
 	} catch (err) {
+		cleanup();
+
 		// Stop animation first
 		clearInterval(interval);