@agentuity/cli 1.0.9 → 1.0.11

package/src/cmd/project/hostname/set.ts

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { projectHostnameSet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { isJSONMode } from '../../../output';
+import { ErrorCode } from '../../../errors';
+
+// Client-side reserved names list (mirrors server-side list)
+const RESERVED_NAMES = new Set([
+	'app',
+	'api',
+	'catalyst',
+	'pulse',
+	'streams',
+	'registry',
+	'ion',
+	'status',
+	'admin',
+	'www',
+	'mail',
+	'dns',
+	'console',
+	'dashboard',
+	'docs',
+	'help',
+	'support',
+	'billing',
+	'test',
+	'staging',
+	'dev',
+	'prod',
+	'ns0',
+	'ns1',
+	'ns2',
+]);
+
+const HostnameSetResponseSchema = z.object({
+	hostname: z.string().describe('The vanity hostname that was set'),
+	url: z.string().describe('The full URL'),
+});
+
+export const setSubcommand = createSubcommand({
+	name: 'set',
+	description: 'Set a custom vanity hostname for the project on agentuity.run',
+	tags: ['mutating', 'fast', 'requires-auth', 'requires-project'],
+	requires: { auth: true, apiClient: true, project: true },
+	examples: [
+		{
+			command: getCommand('project hostname set my-cool-api'),
+			description: 'Set a custom hostname',
+		},
+	],
+	schema: {
+		args: z.object({
+			hostname: z.string().describe('the vanity hostname (e.g., my-cool-api)'),
+		}),
+		response: HostnameSetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, apiClient, project, options, logger } = ctx;
+		const jsonMode = isJSONMode(options);
+
+		const hostname = args.hostname.toLowerCase().trim();
+
+		// Client-side validation: DNS label regex
+		const hostnameRegex = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+		if (!hostnameRegex.test(hostname)) {
+			logger.fatal(
+				'Invalid hostname: must contain only lowercase letters, numbers, and hyphens, and must start and end with a letter or number',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Max 63 chars (DNS label limit)
+		if (hostname.length > 63) {
+			logger.fatal(
+				'Invalid hostname: must be 63 characters or fewer',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Must not match reserved hash patterns
+		const reservedHashPattern = /^[dp][a-f0-9]{16}$/;
+		if (reservedHashPattern.test(hostname)) {
+			logger.fatal(
+				'Invalid hostname: this pattern is reserved for internal use',
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		// Must not be a reserved name
+		if (RESERVED_NAMES.has(hostname)) {
+			logger.fatal(
+				`Invalid hostname: "${hostname}" is a reserved name`,
+				ErrorCode.VALIDATION_FAILED
+			);
+		}
+
+		const result = jsonMode
+			? await projectHostnameSet(apiClient, {
+					projectId: project.projectId,
+					hostname,
+				})
+			: await tui.spinner('Setting hostname', () => {
+					return projectHostnameSet(apiClient, {
+						projectId: project.projectId,
+						hostname,
+					});
+				});
+
+		if (!jsonMode) {
+			tui.success(`Hostname set: ${tui.bold(result.url)}`);
+			tui.info('Hostname will be active after next deployment');
+		}
+
+		return {
+			hostname: result.hostname,
+			url: result.url,
+		};
+	},
+});

package/src/cmd/project/index.ts

@@ -6,6 +6,8 @@ import { deleteSubcommand } from './delete';
 import { showSubcommand } from './show';
 import { authCommand } from './auth';
 import { addCommand } from './add';
+import { hostnameCommand } from './hostname';
+import { domainCommand } from './domain';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -22,6 +24,14 @@ export const command = createCommand({
 			command: getCommand('project add storage'),
 			description: 'Link an existing storage bucket',
 		},
+		{
+			command: getCommand('project hostname get'),
+			description: 'Show current vanity hostname',
+		},
+		{
+			command: getCommand('project domain check'),
+			description: 'Check DNS for custom domains',
+		},
 	],
 	subcommands: [
 		createProjectSubcommand,
@@ -31,5 +41,7 @@ export const command = createCommand({
 		showSubcommand,
 		authCommand,
 		addCommand,
+		hostnameCommand,
+		domainCommand,
 	],
 });

package/src/index.ts

@@ -102,7 +102,7 @@ export {
 	type CommandHandler,
 	type TableColumn,
 } from './repl';
-export { runSteps, stepSuccess, stepSkipped, stepError } from './steps';
+export { runSteps, stepSuccess, stepSkipped, stepError, StepInterruptError } from './steps';
 export { playSound } from './sound';
 export {
 	downloadWithProgress,

package/src/steps.ts

@@ -11,6 +11,19 @@ import { ValidationInputError, ValidationOutputError, type IssuesType } from '@a
 import { clearLastLines, isTTYLike } from './tui';
 import { appendLog, isLogCollectionEnabled } from './log-collector';
 
+/**
+ * Error thrown when step execution is interrupted by a signal (e.g., Ctrl+C).
+ * Callers can catch this to perform cleanup before exiting.
+ */
+export class StepInterruptError extends Error {
+	public readonly exitCode: number;
+	constructor(exitCode = 130) {
+		super('Step execution interrupted');
+		this.name = 'StepInterruptError';
+		this.exitCode = exitCode;
+	}
+}
+
 // Spinner frames
 const FRAMES = ['◐', '◓', '◑', '◒'];
 
@@ -77,6 +90,7 @@ export const stepError = (message: string, cause?: Error, output?: string[]): St
  */
 export interface StepContext {
 	progress: (n: number) => void;
+	signal: AbortSignal;
 }
 
 /**
@@ -300,14 +314,6 @@ export function pauseStepUI(clear = false): () => void {
 	};
 }
 
-/**
- * Get exit function (Bun.exit or process.exit)
- */
-function getExitFn(): (code: number) => never {
-	const bunExit = (globalThis as { Bun?: { exit?: (code: number) => never } }).Bun?.exit;
-	return typeof bunExit === 'function' ? bunExit : process.exit.bind(process);
-}
-
 /**
  * Install interrupt handlers (SIGINT/SIGTERM + raw mode)
  */
@@ -367,19 +373,24 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 	let currentStepIndex = -1;
 	let currentFrameIndex = 0;
 
+	// Create abort controller for cooperative cancellation
+	const abortController = new AbortController();
+
 	// Hide cursor
 	process.stdout.write('\x1B[?25l');
 
 	// Set up interrupt handler
-	const exit = getExitFn();
+	let restoreInterrupts: (() => void) | null = null;
 	const onInterrupt = () => {
 		if (interrupted) return;
 		interrupted = true;
+		abortController.abort();
 		if (activeInterval) clearInterval(activeInterval);
+		restoreInterrupts?.();
+		restoreInterrupts = null;
 		process.stdout.write('\x1B[?25h\n'); // Show cursor
-		exit(130);
 	};
-	const restoreInterrupts = installInterruptHandlers(onInterrupt);
+	restoreInterrupts = installInterruptHandlers(onInterrupt);
 
 	// Force re-render function
 	const forceRerender = (skipMove = false) => {
@@ -476,7 +487,10 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 
 			// Run the step
 			try {
-				const outcome = await step.run({ progress: progressCallback });
+				const outcome = await step.run({
+					progress: progressCallback,
+					signal: abortController.signal,
+				});
 
 				// Update state from outcome
 				if (outcome.status === 'success') {
@@ -493,6 +507,11 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 					stepState.output = outcome.output;
 				}
 			} catch (err) {
+				// If the step was aborted due to cancellation, treat as interrupt
+				if (err instanceof Error && err.name === 'AbortError') {
+					interrupted = true;
+					throw new StepInterruptError();
+				}
 				stepState.status = 'error';
 				stepState.errorMessage = err instanceof Error ? err.message : String(err);
 				stepState.errorCause = err instanceof Error ? err : undefined;
@@ -522,6 +541,14 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 
 			// Handle errors
 			if (stepState.status === 'error') {
+				// If the error is due to abort/cancellation, treat as interrupt
+				if (
+					stepState.errorCause instanceof Error &&
+					stepState.errorCause.name === 'AbortError'
+				) {
+					interrupted = true;
+					throw new StepInterruptError();
+				}
 				const errorColor = getColor('red');
 				const errorMsg = stepState.errorMessage || 'An unknown error occurred';
 				console.error(`\n${errorColor}Error: ${errorMsg}${COLORS.reset}`);
@@ -537,13 +564,19 @@ async function runStepsTUI(steps: Step[]): Promise<void> {
 			}
 		}
 
+		// If interrupted during step execution, throw so callers' finally blocks run
+		if (interrupted) {
+			throw new StepInterruptError();
+		}
+
 		// Show cursor
 		process.stdout.write('\x1B[?25h');
 	} catch (err) {
 		process.stdout.write('\x1B[?25h');
 		throw err;
 	} finally {
-		restoreInterrupts();
+		restoreInterrupts?.();
+		restoreInterrupts = null;
 		getTotalLinesFn = null; // Clear pause capability
 		forceRerenderFn = null;
 	}
@@ -558,76 +591,108 @@ async function runStepsPlain(steps: Step[]): Promise<void> {
 	const yellowColor = getColor('yellow');
 	const redColor = getColor('red');
 
-	for (const step of steps) {
-		let outcome: StepOutcome;
-
-		try {
-			outcome = await step.run({ progress: () => {} });
-		} catch (err) {
-			outcome = {
-				status: 'error',
-				message: err instanceof Error ? err.message : String(err),
-				cause: err instanceof Error ? err : undefined,
-			};
-		}
+	const abortController = new AbortController();
+	let interrupted = false;
+	const onInterrupt = () => {
+		if (interrupted) return;
+		interrupted = true;
+		abortController.abort();
+	};
+	process.on('SIGINT', onInterrupt);
+	process.on('SIGTERM', onInterrupt);
 
-		// Build step state for clean log emission
-		const stepState: StepState = {
-			label: step.label,
-			status: outcome.status,
-			output: outcome.output,
-			skipReason: outcome.status === 'skipped' ? outcome.reason : undefined,
-			errorMessage: outcome.status === 'error' ? outcome.message : undefined,
-			errorCause: outcome.status === 'error' ? outcome.cause : undefined,
-		};
+	try {
+		for (const step of steps) {
+			if (abortController.signal.aborted) break;
 
-		// Emit clean log for this step
-		emitCleanStepLog(stepState);
+			let outcome: StepOutcome;
 
-		// Print final state
-		if (outcome.status === 'success') {
-			console.log(`${greenColor}${ICONS.success}${COLORS.reset} ${step.label}`);
-			if (outcome.output && outcome.output.length > 0) {
-				console.log(`${grayColor}╭─ Output${COLORS.reset}`);
-				for (const line of outcome.output) {
-					console.log(`${grayColor}│${COLORS.reset} ${line}`);
+			try {
+				outcome = await step.run({ progress: () => {}, signal: abortController.signal });
+			} catch (err) {
+				// If the step was aborted due to cancellation, treat as interrupt
+				if (err instanceof Error && err.name === 'AbortError') {
+					interrupted = true;
+					throw new StepInterruptError();
 				}
-				console.log(`${grayColor}╰─${COLORS.reset}`);
-				console.log('');
+				outcome = {
+					status: 'error',
+					message: err instanceof Error ? err.message : String(err),
+					cause: err instanceof Error ? err : undefined,
+				};
 			}
-		} else if (outcome.status === 'skipped') {
-			const reason = outcome.reason ? ` ${grayColor}(${outcome.reason})${COLORS.reset}` : '';
-			console.log(`${yellowColor}${ICONS.skipped}${COLORS.reset} ${step.label}${reason}`);
-			if (outcome.output && outcome.output.length > 0) {
-				console.log(`${grayColor}╭─ Output${COLORS.reset}`);
-				for (const line of outcome.output) {
-					console.log(`${grayColor}│${COLORS.reset} ${line}`);
+
+			// Build step state for clean log emission
+			const stepState: StepState = {
+				label: step.label,
+				status: outcome.status,
+				output: outcome.output,
+				skipReason: outcome.status === 'skipped' ? outcome.reason : undefined,
+				errorMessage: outcome.status === 'error' ? outcome.message : undefined,
+				errorCause: outcome.status === 'error' ? outcome.cause : undefined,
+			};
+
+			// Emit clean log for this step
+			emitCleanStepLog(stepState);
+
+			// Print final state
+			if (outcome.status === 'success') {
+				console.log(`${greenColor}${ICONS.success}${COLORS.reset} ${step.label}`);
+				if (outcome.output && outcome.output.length > 0) {
+					console.log(`${grayColor}╭─ Output${COLORS.reset}`);
+					for (const line of outcome.output) {
+						console.log(`${grayColor}│${COLORS.reset} ${line}`);
+					}
+					console.log(`${grayColor}╰─${COLORS.reset}`);
+					console.log('');
 				}
-				console.log(`${grayColor}╰─${COLORS.reset}`);
-				console.log('');
-			}
-		} else {
-			console.log(`${redColor}${ICONS.error}${COLORS.reset} ${step.label}`);
-			if (outcome.output && outcome.output.length > 0) {
-				console.log(`${grayColor}╭─ Output${COLORS.reset}`);
-				for (const line of outcome.output) {
-					console.log(`${grayColor}│${COLORS.reset} ${line}`);
+			} else if (outcome.status === 'skipped') {
+				const reason = outcome.reason ? ` ${grayColor}(${outcome.reason})${COLORS.reset}` : '';
+				console.log(`${yellowColor}${ICONS.skipped}${COLORS.reset} ${step.label}${reason}`);
+				if (outcome.output && outcome.output.length > 0) {
+					console.log(`${grayColor}╭─ Output${COLORS.reset}`);
+					for (const line of outcome.output) {
+						console.log(`${grayColor}│${COLORS.reset} ${line}`);
+					}
+					console.log(`${grayColor}╰─${COLORS.reset}`);
+					console.log('');
 				}
-				console.log(`${grayColor}╰─${COLORS.reset}`);
-				console.log('');
-			}
-			const errorColor = getColor('red');
-			const errorMsg = outcome.message || 'An unknown error occurred';
-			console.error(`\n${errorColor}Error: ${errorMsg}${COLORS.reset}`);
-			if (
-				outcome.cause instanceof ValidationInputError ||
-				outcome.cause instanceof ValidationOutputError
-			) {
-				printValidationIssues(outcome.cause.issues);
+			} else {
+				// If the error is due to abort/cancellation, treat as interrupt
+				if (outcome.cause instanceof Error && outcome.cause.name === 'AbortError') {
+					interrupted = true;
+					throw new StepInterruptError();
+				}
+				console.log(`${redColor}${ICONS.error}${COLORS.reset} ${step.label}`);
+				if (outcome.output && outcome.output.length > 0) {
+					console.log(`${grayColor}╭─ Output${COLORS.reset}`);
+					for (const line of outcome.output) {
+						console.log(`${grayColor}│${COLORS.reset} ${line}`);
+					}
+					console.log(`${grayColor}╰─${COLORS.reset}`);
+					console.log('');
+				}
+				const errorColor = getColor('red');
+				const errorMsg = outcome.message || 'An unknown error occurred';
+				console.error(`\n${errorColor}Error: ${errorMsg}${COLORS.reset}`);
+				if (
+					outcome.cause instanceof ValidationInputError ||
+					outcome.cause instanceof ValidationOutputError
+				) {
+					printValidationIssues(outcome.cause.issues);
+				}
+				console.error('');
+				process.exit(1);
 			}
-			console.error('');
-			process.exit(1);
 		}
+
+		// If interrupted during step execution, throw so callers' finally blocks run
+		if (interrupted) {
+			throw new StepInterruptError();
+		}
+	} finally {
+		process.off('SIGINT', onInterrupt);
+		process.off('SIGTERM', onInterrupt);
 	}
 }
 

package/src/tui.ts

@@ -737,7 +737,7 @@ export function banner(title: string, body: string, options?: BannerOptions): vo
 /**
  * Wait for any key press before continuing
  * Displays a prompt message and waits for user input
- * Exits with code 1 if CTRL+C is pressed
+ * Raises SIGINT if CTRL+C is pressed
  */
 export async function waitForAnyKey(message = 'Press Enter to continue...'): Promise<void> {
 	process.stdout.write(muted(message));
@@ -765,7 +765,8 @@ export async function waitForAnyKey(message = 'Press Enter to continue...'): Pro
 			// Check for CTRL+C (character code 3)
 			if (data.length === 1 && data[0] === 3) {
 				console.log('\n');
-				process.exit(1);
+				process.kill(process.pid, 'SIGINT');
+				return;
 			}
 
 			console.log('');
@@ -777,7 +778,7 @@ export async function waitForAnyKey(message = 'Press Enter to continue...'): Pro
 /**
  * Prompts user with a yes/no question
  * Returns true for yes, false for no
- * Exits with code 1 if CTRL+C is pressed
+ * Raises SIGINT if CTRL+C is pressed
  */
 export async function confirm(message: string, defaultValue = true): Promise<boolean> {
 	const suffix = defaultValue ? '[Y/n]' : '[y/N]';
@@ -805,7 +806,8 @@ export async function confirm(message: string, defaultValue = true): Promise<boo
 			// Check for CTRL+C (character code 3)
 			if (data.length === 1 && data[0] === 3) {
 				console.log('\n');
-				process.exit(1);
+				process.kill(process.pid, 'SIGINT');
+				return;
 			}
 
 			const input = data.toString().trim().toLowerCase();

package/src/types.ts

@@ -228,8 +228,10 @@ export interface AgentuityConfig {
 	analytics?: boolean | AnalyticsConfig;
 
 	/**
-	 * Vite plugins to add to the client build
-	 * These are added AFTER Agentuity's built-in plugins
+	 * Vite plugins for the client build (src/web/).
+	 * Should include your framework plugin (e.g., @vitejs/plugin-react).
+	 * If no framework plugin is detected, React is added automatically
+	 * for backwards compatibility.
 	 */
 	plugins?: import('vite').PluginOption[];
 	/**