@agentuity/cli 0.0.56 → 0.0.58

package/src/cmd/cloud/deploy.ts

@@ -1,3 +1,4 @@
+import { z } from 'zod';
 import { join, resolve } from 'node:path';
 import { createPublicKey } from 'node:crypto';
 import { createReadStream, createWriteStream } from 'node:fs';
@@ -26,9 +27,9 @@ import {
 } from '../../env-util';
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
-import { checkCustomDomainForDNS } from './domain';
+import { DeployOptionsSchema } from '../build/bundler';
 import { getCommand } from '../../command-prefix';
-import { z } from 'zod';
+import { checkCustomDomainForDNS } from './domain';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
@@ -58,17 +59,19 @@ export const deploySubcommand = createSubcommand({
 	examples: [
 		`${getCommand('cloud deploy')}                    # Deploy current project`,
 		`${getCommand('cloud deploy')} --log-level=debug  # Deploy with verbose output`,
+		`${getCommand('cloud deploy')} --tag a --tag b    # Deploy with specific tags`,
 	],
 	toplevel: true,
 	idempotent: false,
 	requires: { auth: true, project: true, apiClient: true },
 	prerequisites: ['auth login'],
 	schema: {
+		options: DeployOptionsSchema,
 		response: DeployResponseSchema,
 	},
 
 	async handler(ctx) {
-		const { project, apiClient, projectDir, config, options } = ctx;
+		const { project, apiClient, projectDir, config, options, opts } = ctx;
 
 		let deployment: Deployment | undefined;
 		let build: BuildMetadata | undefined;
@@ -171,6 +174,11 @@ export const deploySubcommand = createSubcommand({
 									orgId: deployment.orgId,
 									projectId: project.projectId,
 									project,
+									commitUrl: opts?.commitUrl,
+									logsUrl: opts?.logsUrl,
+									provider: opts?.provider,
+									trigger: opts?.trigger,
+									tag: opts?.tag,
 								});
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(

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

@@ -15,7 +15,39 @@ 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'),
-	metadata: z.any().optional().describe('Deployment metadata'),
+	metadata: z
+		.object({
+			git: z
+				.object({
+					repo: z.string().optional(),
+					commit: z.string().optional(),
+					message: z.string().optional(),
+					branch: z.string().optional(),
+					url: z.string().optional(),
+					trigger: z.string().optional(),
+					provider: z.string().optional(),
+					event: z.string().optional(),
+					buildUrl: z.string().optional(),
+					pull_request: z
+						.object({
+							number: z.number(),
+							url: z.string().optional(),
+							commentId: z.string().optional(),
+						})
+						.optional(),
+				})
+				.optional(),
+			build: z
+				.object({
+					agentuity: z.string().optional(),
+					bun: z.string().optional(),
+					platform: z.string().optional(),
+					arch: z.string().optional(),
+				})
+				.optional(),
+		})
+		.optional()
+		.describe('Deployment metadata'),
 });
 
 export const showSubcommand = createSubcommand({
@@ -49,8 +81,6 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				tui.banner(`Deployment ${deployment.id}`, `State: ${deployment.state || 'unknown'}`);
-
 				console.log(tui.bold('ID:       ') + deployment.id);
 				console.log(tui.bold('Project:  ') + projectId);
 				console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
@@ -74,22 +104,35 @@ export const showSubcommand = createSubcommand({
 					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
 				}
 
-				// Metadata
-				const origin = deployment.metadata?.origin;
-				if (origin?.commit) {
+				// Git metadata
+				const git = deployment.metadata?.git;
+				if (git) {
 					tui.newline();
-					tui.info('Origin Information');
-					if (origin.trigger) console.log(`  Trigger:  ${origin.trigger}`);
-					if (origin.provider) console.log(`  Provider: ${origin.provider}`);
-					if (origin.event) console.log(`  Event:    ${origin.event}`);
-					if (origin.branch) console.log(`  Branch:   ${origin.branch}`);
-
-					if (origin.commit) {
-						console.log(`  Commit:   ${origin.commit.hash}`);
-						if (origin.commit.message) console.log(`  Message:  ${origin.commit.message}`);
-						if (origin.commit.author?.name)
-							console.log(`  Author:   ${origin.commit.author.name}`);
+					tui.info('Git Information');
+					if (git.repo) console.log(`  Repo:     ${git.repo}`);
+					if (git.branch) console.log(`  Branch:   ${git.branch}`);
+					if (git.commit) console.log(`  Commit:   ${git.commit}`);
+					if (git.message) console.log(`  Message:  ${git.message}`);
+					if (git.url) console.log(`  URL:      ${git.url}`);
+					if (git.trigger) console.log(`  Trigger:  ${git.trigger}`);
+					if (git.provider) console.log(`  Provider: ${git.provider}`);
+					if (git.event) console.log(`  Event:    ${git.event}`);
+					if (git.pull_request) {
+						console.log(`  PR:       #${git.pull_request.number}`);
+						if (git.pull_request.url) console.log(`  PR URL:   ${git.pull_request.url}`);
 					}
+					if (git.buildUrl) console.log(`  Build:    ${git.buildUrl}`);
+				}
+
+				// Build metadata
+				const build = deployment.metadata?.build;
+				if (build) {
+					tui.newline();
+					tui.info('Build Information');
+					if (build.agentuity) console.log(`  Agentuity: ${build.agentuity}`);
+					if (build.bun) console.log(`  Bun:       ${build.bun}`);
+					if (build.platform) console.log(`  Platform:  ${build.platform}`);
+					if (build.arch) console.log(`  Arch:      ${build.arch}`);
 				}
 			}
 

package/src/cmd/cloud/session/get.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { sessionGet, type SpanNode } from '@agentuity/server';
+import { sessionGet, type SpanNode, type EvalRun, type AgentInfo } from '@agentuity/server';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 import { getCatalystAPIClient } from '../../../config';
@@ -95,7 +95,7 @@ function printTimeline(node: SpanNode, prefix: string, isLast = true): void {
 
 	const childPrefix = prefix + (isLast ? '    ' : '│   ');
 	const children = node.children ?? [];
-	children.forEach((child, index) => {
+	children.forEach((child: SpanNode, index: number) => {
 		printTimeline(child, childPrefix, index === children.length - 1);
 	});
 }
@@ -142,7 +142,7 @@ export const getSubcommand = createSubcommand({
 				route_id: session.route_id,
 				thread_id: session.thread_id,
 				agents: enriched.agents,
-				eval_runs: enriched.evalRuns.map((run) => ({
+				eval_runs: enriched.evalRuns.map((run: EvalRun) => ({
 					id: run.id,
 					eval_id: run.eval_id,
 					created_at: run.created_at,
@@ -189,7 +189,7 @@ export const getSubcommand = createSubcommand({
 			}
 			if (enriched.agents.length > 0) {
 				const agentDisplay = enriched.agents
-					.map((agent) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
+					.map((agent: AgentInfo) => `${agent.name} ${tui.muted(`(${agent.identifier})`)}`)
 					.join(', ');
 				console.log(tui.bold('Agents:      ') + agentDisplay);
 			}
@@ -206,7 +206,7 @@ export const getSubcommand = createSubcommand({
 			if (enriched.evalRuns.length > 0) {
 				console.log('');
 				console.log(tui.bold('Eval Runs:'));
-				const evalTableData = enriched.evalRuns.map((run) => ({
+				const evalTableData = enriched.evalRuns.map((run: EvalRun) => ({
 					ID: run.id,
 					'Eval ID': run.eval_id,
 					Success: run.success ? tui.colorSuccess('✓') : tui.colorError('✗'),

package/src/cmd/dev/index.ts

@@ -238,48 +238,52 @@ export const command = createCommand({
 		let gravityClient: Bun.Subprocess | undefined;
 		let initialStartupComplete = false;
 
-		if (gravityBin && devmode && project) {
-			const sdkKey = await loadProjectSDKKey(rootDir);
-			if (!sdkKey) {
-				tui.warning(`Couldn't find the AGENTUITY_SDK_KEY in ${rootDir} .env file`);
-			} else {
-				const gravityBinExists = await Bun.file(gravityBin).exists();
-				if (!gravityBinExists) {
-					logger.error(
-						`Gravity binary not found at ${gravityBin}, skipping gravity client startup`
-					);
-				} else {
-					try {
-						gravityClient = Bun.spawn(
-							[
-								gravityBin,
-								'--endpoint-id',
-								devmode.id,
-								'--port',
-								env.PORT,
-								'--url',
-								config?.overrides?.gravity_url ?? 'grpc://devmode.agentuity.com',
-								'--log-level',
-								process.env.AGENTUITY_GRAVITY_LOG_LEVEL ?? 'error',
-							],
-							{
-								cwd: rootDir,
-								stdout: 'inherit',
-								stderr: 'inherit',
-								stdin: 'ignore',
-								env: { ...env, AGENTUITY_SDK_KEY: sdkKey },
-							}
-						);
-						gravityClient.exited.then(() => {
-							logger.debug('gravity client exited');
-						});
-					} catch (err) {
-						logger.error(
-							'Failed to spawn gravity client: %s',
-							err instanceof Error ? err.message : String(err)
-						);
+		const sdkKey = await loadProjectSDKKey(rootDir);
+		if (!sdkKey) {
+			tui.warning(`Couldn't find the AGENTUITY_SDK_KEY in ${rootDir} .env file`);
+		}
+		const gravityBinExists = gravityBin ? await Bun.file(gravityBin).exists() : undefined;
+		if (!gravityBinExists) {
+			logger.error(`Gravity binary not found at ${gravityBin}, skipping gravity client startup`);
+		}
+
+		async function restartGravityClient() {
+			if (gravityClient) {
+				gravityClient.kill('SIGINT');
+				gravityClient.kill();
+			}
+			if (!devmode) {
+				return;
+			}
+			try {
+				gravityClient = Bun.spawn(
+					[
+						gravityBin!,
+						'--endpoint-id',
+						devmode.id,
+						'--port',
+						env.PORT!,
+						'--url',
+						config?.overrides?.gravity_url ?? 'grpc://devmode.agentuity.com',
+						'--log-level',
+						process.env.AGENTUITY_GRAVITY_LOG_LEVEL ?? 'error',
+					],
+					{
+						cwd: rootDir,
+						stdout: 'inherit',
+						stderr: 'inherit',
+						stdin: 'ignore',
+						env: { ...env, AGENTUITY_SDK_KEY: sdkKey },
 					}
-				}
+				);
+				gravityClient.exited.then(() => {
+					logger.debug('gravity client exited');
+				});
+			} catch (err) {
+				logger.error(
+					'Failed to spawn gravity client: %s',
+					err instanceof Error ? err.message : String(err)
+				);
 			}
 		}
 
@@ -307,14 +311,42 @@ export const command = createCommand({
 			}
 		}
 
+		let lastErrorLineCount = 0;
+		let showedRestartMessage = false;
+
+		function clearRestartMessage() {
+			if (showedRestartMessage) {
+				process.stdout.write('\x1b[1A\x1b[2K');
+				showedRestartMessage = false;
+			}
+		}
+
 		function failure(msg: string) {
 			failed = true;
 			failures++;
+			// Exit immediately on initial startup failure
+			if (!initialStartupComplete) {
+				tui.fatal(msg);
+			}
+			// During hot reload, show error but don't exit unless too many failures
 			if (failures >= 5) {
 				tui.error(msg);
 				tui.fatal('too many failures, exiting');
 			} else {
-				setImmediate(() => tui.error(msg));
+				// Ensure we're on a new line before printing error
+				tui.error(msg);
+				// Track lines: 1 for "✗ Building..." + 1 for error message
+				lastErrorLineCount = 2;
+			}
+		}
+
+		function clearLastError() {
+			if (lastErrorLineCount > 0) {
+				// Move cursor up and clear each line
+				for (let i = 0; i < lastErrorLineCount; i++) {
+					process.stdout.write('\x1b[1A\x1b[2K');
+				}
+				lastErrorLineCount = 0;
 			}
 		}
 
@@ -406,6 +438,7 @@ export const command = createCommand({
 					logger.trace('Server is running, killing before restart');
 					checkRestartThrottle();
 					tui.info('Restarting on file change');
+					showedRestartMessage = true;
 					await kill();
 					logger.trace('Server killed, continuing with restart');
 					// Continue with restart after kill completes
@@ -413,11 +446,16 @@ export const command = createCommand({
 					logger.trace('Initial server start');
 				}
 				logger.trace('Starting typecheck and build...');
-				await tui.spinner({
-					message: 'Building project',
-					clearOnSuccess: true,
-					callback: async () => {
-						try {
+
+				// Clear any previous error before starting new build
+				clearLastError();
+				clearRestartMessage();
+
+				try {
+					await tui.spinner({
+						message: 'Building...',
+						clearOnSuccess: true,
+						callback: async () => {
 							logger.trace('Bundle starting...');
 							building = true;
 							await bundle({
@@ -431,7 +469,7 @@ export const command = createCommand({
 							buildCompletedAt = Date.now();
 							logger.trace('Bundle completed successfully');
 							logger.trace('tsc starting...');
-							await tui.runCommand({
+							const tscExitCode = await tui.runCommand({
 								command: 'tsc',
 								cmd: ['bunx', 'tsc', '--noEmit'],
 								cwd: rootDir,
@@ -440,15 +478,32 @@ export const command = createCommand({
 								maxLinesOutput: 2,
 								maxLinesOnFailure: 15,
 							});
+							if (tscExitCode !== 0) {
+								logger.trace('tsc failed with exit code %d', tscExitCode);
+								failure('Type check failed');
+								return;
+							}
 							logger.trace('tsc completed successfully');
-						} catch (error) {
-							building = false;
-							logger.trace('Bundle failed: %s', error);
-							failure('Build failed');
-							return;
+							await restartGravityClient();
+						},
+					});
+				} catch (error) {
+					building = false;
+					const e = error as Error;
+					if (e.constructor.name === 'AggregateError') {
+						const ex = e as AggregateError;
+						for (const err of ex.errors) {
+							if (err) {
+								failure(err);
+								return;
+							}
 						}
-					},
-				});
+						return;
+					}
+					const errorMsg = error instanceof Error ? error.message : String(error);
+					failure(errorMsg);
+					return;
+				}
 
 				logger.trace('Typecheck and build completed');
 
@@ -457,6 +512,9 @@ export const command = createCommand({
 					return;
 				}
 
+				// Reset failure counter on successful build
+				failures = 0;
+
 				logger.trace('Checking if app file exists: %s', appPath);
 				if (!existsSync(appPath)) {
 					logger.trace('App file not found: %s', appPath);
@@ -548,9 +606,6 @@ export const command = createCommand({
 
 				if (showInitialReadyMessage) {
 					showInitialReadyMessage = false;
-					// Clear any lingering spinner/command output - clear everything below cursor
-					process.stderr.write('\x1B[J'); // Clear from cursor to end of screen
-					process.stdout.write('\x1B[J'); // Clear from cursor to end of screen
 					logger.info('DevMode ready 🚀');
 					logger.trace('Initial ready message logged');
 					// Mark initial startup complete immediately to prevent watcher restarts

package/src/cmd/index.ts

@@ -38,6 +38,8 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									prerequisites: (subcommand as any).prerequisites,
 									// eslint-disable-next-line @typescript-eslint/no-explicit-any
 									tags: (subcommand as any).tags,
+									// eslint-disable-next-line @typescript-eslint/no-explicit-any
+									examples: (subcommand as any).examples,
 								};
 								commands.push(alias as CommandDefinition);
 							}

package/src/schema-generator.ts

@@ -13,7 +13,7 @@ export interface SchemaArgument {
 
 export interface SchemaOption {
 	name: string;
-	type: 'string' | 'number' | 'boolean';
+	type: 'string' | 'number' | 'boolean' | 'array';
 	required: boolean;
 	default?: unknown;
 	description?: string;

package/src/schema-parser.ts

@@ -13,9 +13,10 @@ export interface ParsedArgs {
 export interface ParsedOption {
 	name: string;
 	description?: string;
-	type: 'string' | 'number' | 'boolean';
+	type: 'string' | 'number' | 'boolean' | 'array';
 	hasDefault?: boolean;
 	defaultValue?: unknown;
+	enumValues?: string[];
 }
 
 interface ZodTypeDef {
@@ -167,11 +168,21 @@ export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
 			? (defaultInfo.defaultValue as () => unknown)()
 			: defaultInfo.defaultValue;
 
-		let type: 'string' | 'number' | 'boolean' = 'string';
+		let type: 'string' | 'number' | 'boolean' | 'array' = 'string';
+		let enumValues: string[] | undefined;
 		if (typeId === 'ZodNumber' || typeId === 'number') {
 			type = 'number';
 		} else if (typeId === 'ZodBoolean' || typeId === 'boolean') {
 			type = 'boolean';
+		} else if (typeId === 'ZodArray' || typeId === 'array') {
+			type = 'array';
+		} else if (typeId === 'ZodEnum' || typeId === 'enum') {
+			// Extract enum values from Zod 4's def.entries
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const def = (unwrapped as any)?._def;
+			if (def?.entries && typeof def.entries === 'object') {
+				enumValues = Object.values(def.entries as Record<string, string>);
+			}
 		}
 
 		options.push({
@@ -180,6 +191,7 @@ export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
 			description,
 			hasDefault: defaultInfo.hasDefault,
 			defaultValue,
+			enumValues,
 		});
 	}
 
@@ -203,8 +215,11 @@ export function buildValidationInput(
 	if (schemas.options) {
 		const parsed = parseOptionsSchema(schemas.options);
 		for (const opt of parsed) {
-			// Always include the option value (even if undefined) so zod can apply defaults
-			result.options[opt.name] = rawOptions[opt.name];
+			// Only include the option if it has a value - omitting undefined allows Zod to apply defaults
+			const value = rawOptions[opt.name];
+			if (value !== undefined) {
+				result.options[opt.name] = value;
+			}
 		}
 	}
 

package/src/steps.ts

@@ -7,6 +7,7 @@
 
 import type { ColorScheme } from './terminal';
 import type { LogLevel } from './types';
+import { ValidationError } from '@agentuity/server';
 
 /**
  * Get the appropriate exit function (Bun.exit or process.exit)
@@ -108,14 +109,18 @@ function getColor(colorKey: keyof typeof COLORS): string {
 export type StepOutcome =
 	| { status: 'success' }
 	| { status: 'skipped'; reason?: string }
-	| { status: 'error'; message: string };
+	| { status: 'error'; message: string; cause?: Error };
 
 /**
  * Helper functions for creating step outcomes
  */
 export const stepSuccess = (): StepOutcome => ({ status: 'success' });
 export const stepSkipped = (reason?: string): StepOutcome => ({ status: 'skipped', reason });
-export const stepError = (message: string): StepOutcome => ({ status: 'error', message });
+export const stepError = (message: string, cause?: Error): StepOutcome => ({
+	status: 'error',
+	message,
+	cause,
+});
 
 /**
  * Progress callback function
@@ -260,6 +265,7 @@ async function runStepsTUI(state: StepState[]): Promise<void> {
 				step.outcome = {
 					status: 'error',
 					message: err instanceof Error ? err.message : String(err),
+					cause: err instanceof Error ? err : undefined,
 				};
 			}
 
@@ -276,7 +282,15 @@ async function runStepsTUI(state: StepState[]): Promise<void> {
 			// If error, show error message and exit
 			if (step.outcome?.status === 'error') {
 				const errorColor = getColor('red');
-				console.error(`\n${errorColor}Error: ${step.outcome.message}${COLORS.reset}\n`);
+				console.error(`\n${errorColor}Error: ${step.outcome.message}${COLORS.reset}`);
+				if (step.outcome.cause instanceof ValidationError) {
+					console.error(`${errorColor}Validation details:${COLORS.reset}`);
+					for (const issue of step.outcome.cause.issues) {
+						const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+						console.error(`  ${path}: ${issue.message}`);
+					}
+				}
+				console.error('');
 				process.stdout.write('\x1B[?25h'); // Show cursor
 				process.exit(1);
 			}
@@ -312,6 +326,7 @@ async function runStepsPlain(state: StepState[]): Promise<void> {
 			step.outcome = {
 				status: 'error',
 				message: err instanceof Error ? err.message : String(err),
+				cause: err instanceof Error ? err : undefined,
 			};
 		}
 
@@ -326,7 +341,15 @@ async function runStepsPlain(state: StepState[]): Promise<void> {
 		} else if (step.outcome?.status === 'error') {
 			console.log(`${redColor}${ICONS.error}${COLORS.reset} ${step.label}`);
 			const errorColor = getColor('red');
-			console.error(`\n${errorColor}Error: ${step.outcome.message}${COLORS.reset}\n`);
+			console.error(`\n${errorColor}Error: ${step.outcome.message}${COLORS.reset}`);
+			if (step.outcome.cause instanceof ValidationError) {
+				console.error(`${errorColor}Validation details:${COLORS.reset}`);
+				for (const issue of step.outcome.cause.issues) {
+					const path = issue.path.length > 0 ? issue.path.join('.') : '(root)';
+					console.error(`  ${path}: ${issue.message}`);
+				}
+			}
+			console.error('');
 			process.exit(1);
 		}
 	}

package/src/tui.ts

@@ -859,8 +859,8 @@ export async function spinner<T>(
 	let frameIndex = 0;
 	let currentProgress: number | undefined;
 
-	// Hide cursor
-	process.stderr.write('\x1B[?25l');
+	// Save cursor position and hide cursor
+	process.stderr.write('\x1B[s\x1B[?25l');
 
 	// Start animation
 	const interval = setInterval(() => {
@@ -893,9 +893,12 @@ export async function spinner<T>(
 					? await options.callback()
 					: await options.callback;
 
-		// Clear interval and line
+		// Stop animation first
 		clearInterval(interval);
-		process.stderr.write('\r\x1B[K');
+
+		// Restore cursor position, clear to end of screen, show cursor
+		// This removes spinner and any partial output that happened during animation
+		process.stderr.write('\x1B[u\x1B[J\x1B[?25h');
 
 		// If clearOnSuccess is false, show success message
 		if (!options.clearOnSuccess) {
@@ -904,22 +907,18 @@ export async function spinner<T>(
 			console.error(`${successColor}${ICONS.success} ${message}${reset}`);
 		}
 
-		// Show cursor
-		process.stderr.write('\x1B[?25h');
-
 		return result;
 	} catch (err) {
-		// Clear interval and line
+		// Stop animation first
 		clearInterval(interval);
-		process.stderr.write('\r\x1B[K');
+
+		// Restore cursor position, clear to end of screen, show cursor
+		process.stderr.write('\x1B[u\x1B[J\x1B[?25h');
 
 		// Show error
 		const errorColor = getColor('error');
 		console.error(`${errorColor}${ICONS.error} ${message}${reset}`);
 
-		// Show cursor
-		process.stderr.write('\x1B[?25h');
-
 		throw err;
 	}
 }