@agentuity/cli 0.0.12 → 0.0.13

package/src/cmd/auth/api.ts

@@ -1,4 +1,4 @@
-import { APIClient } from '@/api';
+import { APIClient, APIError } from '@/api';
 import type { Config } from '@/types';
 
 interface APIResponse<T> {
@@ -23,6 +23,18 @@ export interface LoginResult {
 	expires: Date;
 }
 
+interface SignupCompleteData {
+	userId: string;
+	apiKey: string;
+	expiresAt: number;
+}
+
+export interface SignupResult {
+	apiKey: string;
+	userId: string;
+	expires: Date;
+}
+
 export async function generateLoginOTP(apiUrl: string, config?: Config | null): Promise<string> {
 	const client = new APIClient(apiUrl, undefined, config);
 	const resp = await client.request<APIResponse<OTPStartData>>('GET', '/cli/auth/start');
@@ -64,8 +76,60 @@ export async function pollForLoginCompletion(
 			};
 		}
 
-		await new Promise((resolve) => setTimeout(resolve, 2000));
+		await Bun.sleep(2000);
 	}
 
 	throw new Error('Login timed out');
 }
+
+export function generateSignupOTP(): string {
+	const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+	let result = '';
+	const array = new Uint8Array(5);
+	crypto.getRandomValues(array);
+	for (let i = 0; i < 5; i++) {
+		result += chars[array[i] % chars.length];
+	}
+	return result;
+}
+
+export async function pollForSignupCompletion(
+	apiUrl: string,
+	otp: string,
+	config?: Config | null,
+	timeoutMs = 300000
+): Promise<SignupResult> {
+	const client = new APIClient(apiUrl, undefined, config);
+	const started = Date.now();
+
+	while (Date.now() - started < timeoutMs) {
+		try {
+			const resp = await client.request<APIResponse<SignupCompleteData>>(
+				'GET',
+				`/cli/auth/signup/${otp}`
+			);
+
+			if (!resp.success) {
+				throw new Error(resp.message);
+			}
+
+			if (resp.data) {
+				return {
+					apiKey: resp.data.apiKey,
+					userId: resp.data.userId,
+					expires: new Date(resp.data.expiresAt),
+				};
+			}
+		} catch (error) {
+			if (error instanceof APIError && error.status === 404) {
+				await Bun.sleep(2000);
+				continue;
+			}
+			throw error;
+		}
+
+		await Bun.sleep(2000);
+	}
+
+	throw new Error('Signup timed out');
+}

package/src/cmd/auth/index.ts

@@ -1,9 +1,10 @@
 import { createCommand } from '@/types';
 import { loginCommand } from './login';
 import { logoutCommand } from './logout';
+import { signupCommand } from './signup';
 
 export const command = createCommand({
 	name: 'auth',
 	description: 'Authentication and authorization related commands',
-	subcommands: [loginCommand, logoutCommand],
+	subcommands: [loginCommand, logoutCommand, signupCommand],
 });

package/src/cmd/auth/login.ts

@@ -15,9 +15,16 @@ export const loginCommand: SubcommandDefinition = {
 		const appUrl = getAppBaseURL(config);
 
 		try {
-			console.log('Generating login OTP...');
+			let otp: string | undefined;
+
+			await tui.spinner('Generating login one time code...', async () => {
+				otp = await generateLoginOTP(apiUrl, config);
+			});
+
+			if (!otp) {
+				return;
+			}
 
-			const otp = await generateLoginOTP(apiUrl, config);
 			const authURL = `${appUrl}/auth/cli`;
 
 			const copied = await tui.copyToClipboard(otp);
@@ -39,7 +46,8 @@ export const loginCommand: SubcommandDefinition = {
 			tui.newline();
 
 			if (process.platform === 'darwin') {
-				await tui.waitForAnyKey('Press Enter to open the URL...');
+				await tui.waitForAnyKey('Press any key to open the URL in your browser...');
+				tui.newline();
 				try {
 					Bun.spawn(['open', authURL], {
 						stdio: ['ignore', 'ignore', 'ignore'],

package/src/cmd/auth/signup.ts

@@ -0,0 +1,51 @@
+import type { SubcommandDefinition } from '@/types';
+import { getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from '@/api';
+import { saveAuth } from '@/config';
+import { generateSignupOTP, pollForSignupCompletion } from './api';
+import * as tui from '@/tui';
+
+export const signupCommand: SubcommandDefinition = {
+	name: 'signup',
+	description: 'Create a new Agentuity Cloud Platform account',
+	toplevel: true,
+
+	async handler(ctx) {
+		const { logger, config } = ctx;
+		const apiUrl = getAPIBaseURL(config);
+		const appUrl = getAppBaseURL(config);
+
+		try {
+			const otp = generateSignupOTP();
+
+			const signupURL = `${appUrl}/sign-up?code=${otp}`;
+
+			const bannerBody = `Please open the URL in your browser:\n\n${tui.link(signupURL)}\n\n${tui.muted('Once you have completed the signup process, you will be given a one-time password to complete the signup process.')}`;
+
+			tui.banner('Signup for Agentuity', bannerBody);
+			tui.newline();
+
+			await tui.spinner('Waiting for signup to complete...', async () => {
+				const result = await pollForSignupCompletion(apiUrl, otp, config);
+
+				await saveAuth({
+					apiKey: result.apiKey,
+					userId: result.userId,
+					expires: result.expires,
+				});
+			});
+
+			tui.newline();
+			tui.success('Welcome to Agentuity! You are now logged in');
+		} catch (error) {
+			if (error instanceof UpgradeRequiredError) {
+				const bannerBody = `${error.message}\n\nVisit: ${tui.link('https://agentuity.dev/CLI/installation')}`;
+				tui.banner('CLI Upgrade Required', bannerBody);
+				process.exit(1);
+			} else if (error instanceof Error) {
+				logger.fatal(`Signup failed: ${error.message}`);
+			} else {
+				logger.fatal('Signup failed');
+			}
+		}
+	},
+};

package/src/cmd/dev/index.ts

@@ -1,8 +1,8 @@
 import { createCommand } from '@/types';
 import { z } from 'zod';
-import { resolve } from 'node:path';
+import { resolve, join } from 'node:path';
 import { bundle } from '../bundle/bundler';
-import { existsSync } from 'node:fs';
+import { existsSync, FSWatcher, watch } from 'node:fs';
 import * as tui from '@/tui';
 
 export const command = createCommand({
@@ -13,69 +13,156 @@ export const command = createCommand({
 			dir: z.string().optional().describe('Root directory of the project'),
 		}),
 	},
+	optionalAuth: 'Continue without an account (local only)',
 
 	async handler(ctx) {
-		const { opts } = ctx;
+		const { opts, logger } = ctx;
+
 		const rootDir = resolve(opts.dir || process.cwd());
+		const appTs = join(rootDir, 'app.ts');
+		const srcDir = join(rootDir, 'src');
+		const mustHaves = [join(rootDir, 'package.json'), appTs, srcDir];
+		const missing: string[] = [];
+
+		for (const filename of mustHaves) {
+			if (!existsSync(filename)) {
+				missing.push(filename);
+			}
+		}
+
+		if (missing.length) {
+			tui.error(`${rootDir} does not appear to be a valid Agentuity project`);
+			for (const filename of missing) {
+				tui.bullet(`Missing ${filename}`);
+			}
+			process.exit(1);
+		}
+
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
-		try {
-			await tui.spinner('Building project...', async () => {
-				await bundle({
-					rootDir,
-					dev: true,
-				});
-			});
+		const watches = [appTs, srcDir];
+		const watchers: FSWatcher[] = [];
+		let failures = 0;
+		let running = false;
+		let pid = 0;
+		let failed = false;
+		let devServer: Bun.Subprocess | undefined;
 
-			tui.success('Build complete');
+		function failure(msg: string) {
+			failed = true;
+			failures++;
+			if (failures >= 5) {
+				tui.error(msg);
+				tui.fatal('too many failures, exiting');
+			} else {
+				setImmediate(() => tui.error(msg));
+			}
+		}
 
-			if (!existsSync(appPath)) {
-				tui.error(`App file not found: ${appPath}`);
-				process.exit(1);
+		const kill = () => {
+			running = false;
+			try {
+				// Kill the process group (negative PID kills entire group)
+				process.kill(-pid, 'SIGTERM');
+			} catch {
+				// Fallback: kill the direct process
+				try {
+					if (devServer) {
+						devServer.kill();
+					}
+				} catch {
+					// Ignore if already dead
+				}
+			} finally {
+				devServer = undefined;
 			}
+		};
 
-			tui.info('Starting development server...');
-
-			// Use shell to run in a process group for proper cleanup
-			// The 'exec' ensures the shell is replaced by the actual process
-			const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
-				cwd: rootDir,
-				stdout: 'inherit',
-				stderr: 'inherit',
-				stdin: 'inherit',
-			});
-
-			// Handle signals to ensure entire process tree is killed
-			const cleanup = () => {
-				if (devServer.pid) {
-					try {
-						// Kill the process group (negative PID kills entire group)
-						process.kill(-devServer.pid, 'SIGTERM');
-					} catch {
-						// Fallback: kill the direct process
+		// Handle signals to ensure entire process tree is killed
+		const cleanup = () => {
+			if (pid && running) {
+				kill();
+			}
+			for (const watcher of watchers) {
+				watcher.close();
+			}
+			watchers.length = 0;
+			process.exit(0);
+		};
+
+		process.on('SIGINT', cleanup);
+		process.on('SIGTERM', cleanup);
+
+		async function restart() {
+			try {
+				if (running) {
+					tui.info('Restarting on file change');
+					kill();
+					return;
+				}
+				await Promise.all([
+					tui.runCommand({
+						command: 'tsc',
+						cmd: ['bunx', 'tsc', '--noEmit'],
+						cwd: rootDir,
+						clearOnSuccess: true,
+						truncate: false,
+						maxLinesOutput: 1,
+						maxLinesOnFailure: 15,
+					}),
+					tui.spinner('Building project', async () => {
 						try {
-							devServer.kill();
+							await bundle({
+								rootDir,
+								dev: true,
+							});
 						} catch {
-							// Ignore if already dead
+							failure('Build failed');
 						}
-					}
+					}),
+				]);
+
+				if (failed) {
+					return;
 				}
-				process.exit(0);
-			};
 
-			process.on('SIGINT', cleanup);
-			process.on('SIGTERM', cleanup);
+				if (!existsSync(appPath)) {
+					failure(`App file not found: ${appPath}`);
+					return;
+				}
 
-			const exitCode = await devServer.exited;
-			process.exit(exitCode);
-		} catch (error) {
-			if (error instanceof Error) {
-				tui.error(`Dev server failed: ${error.message}`);
-			} else {
-				tui.error('Dev server failed');
+				// Use shell to run in a process group for proper cleanup
+				// The 'exec' ensures the shell is replaced by the actual process
+				const devServer = Bun.spawn(['sh', '-c', `exec bun run "${appPath}"`], {
+					cwd: rootDir,
+					stdout: 'inherit',
+					stderr: 'inherit',
+					stdin: 'inherit',
+				});
+
+				running = true;
+				failed = false;
+				pid = devServer.pid;
+
+				const exitCode = await devServer.exited;
+				if (exitCode === 0) {
+					process.exit(exitCode);
+				}
+			} catch (error) {
+				if (error instanceof Error) {
+					failure(`Dev server failed: ${error.message}`);
+				} else {
+					failure('Dev server failed');
+				}
+			} finally {
+				running = false;
 			}
-			process.exit(1);
+		}
+		await restart();
+		for (const filename of watches) {
+			logger.trace('watching %s', filename);
+			watchers.push(watch(filename, { recursive: true }, restart));
 		}
 	},
 });

package/src/cmd/example/index.ts

@@ -8,6 +8,7 @@ import { versionSubcommand } from './version';
 import { createUserSubcommand } from './create-user';
 import { runCommandSubcommand } from './run-command';
 import { soundSubcommand } from './sound';
+import { optionalAuthSubcommand } from './optional-auth';
 
 export const command = createCommand({
 	name: 'example',
@@ -23,5 +24,6 @@ export const command = createCommand({
 		createUserSubcommand,
 		runCommandSubcommand,
 		soundSubcommand,
+		optionalAuthSubcommand,
 	],
 });

package/src/cmd/example/optional-auth.ts

@@ -0,0 +1,38 @@
+import type { SubcommandDefinition, CommandContext, AuthData } from '@/types';
+import * as tui from '@/tui';
+
+export const optionalAuthSubcommand: SubcommandDefinition = {
+	name: 'optional-auth',
+	description: 'Test optional authentication flow',
+	optionalAuth: 'Continue with local features only',
+	handler: async (ctx: CommandContext) => {
+		tui.newline();
+
+		// Type guard to check if auth is present
+		const ctxWithAuth = ctx as CommandContext<true>;
+		if ('auth' in ctx && ctxWithAuth.auth) {
+			const auth = ctxWithAuth.auth as AuthData;
+			// User chose to authenticate
+			tui.success('You are authenticated!');
+			tui.info(`User ID: ${auth.userId}`);
+			tui.info(`Session expires: ${auth.expires.toLocaleString()}`);
+			tui.newline();
+			tui.info('You can now access cloud features:');
+			tui.bullet('Deploy to production');
+			tui.bullet('Access remote resources');
+			tui.bullet('View team analytics');
+		} else {
+			// User chose to continue without auth
+			tui.info('Running in local mode (no authentication)');
+			tui.newline();
+			tui.info('Available local features:');
+			tui.bullet('Local development');
+			tui.bullet('Offline testing');
+			tui.bullet('Build and bundle');
+			tui.newline();
+			tui.warning('Some cloud features are unavailable without authentication');
+		}
+
+		tui.newline();
+	},
+};

package/src/config.ts

@@ -1,5 +1,5 @@
 import { YAML } from 'bun';
-import { join, extname } from 'node:path';
+import { join, extname, basename } from 'node:path';
 import { homedir } from 'node:os';
 import { mkdir, readdir, readFile, writeFile, chmod } from 'node:fs/promises';
 import type { Config, Profile, AuthData } from './types';
@@ -104,6 +104,13 @@ export async function loadConfig(customPath?: string): Promise<Config | null> {
 		const content = await file.text();
 		const config = YAML.parse(content);
 
+		// check to see if this is a legacy config file that might not have the required name
+		// and in this case we can just use the filename
+		const _config = config as { name?: string };
+		if (!_config.name) {
+			_config.name = basename(configPath).replace(extname(configPath), '');
+		}
+
 		const result = ConfigSchema.safeParse(config);
 		if (!result.success) {
 			tui.error(`Invalid config in ${configPath}:`);

package/src/index.ts

@@ -1,6 +1,7 @@
 export { createCLI, registerCommands } from './cli';
 export { validateRuntime, isBun } from './runtime';
 export { getVersion, getRevision, getPackageName, getPackage } from './version';
+export { requireAuth, optionalAuth, withAuth, withOptionalAuth } from './auth';
 export {
 	loadConfig,
 	saveConfig,

package/src/tui.ts

@@ -82,6 +82,16 @@ export function error(message: string): void {
 	console.error(`${color}${ICONS.error} ${message}${reset}`);
 }
 
+/**
+ * Print an error message with a red X and then exit
+ */
+export function fatal(message: string): never {
+	const color = getColor('error');
+	const reset = COLORS.reset;
+	console.error(`${color}${ICONS.error} ${message}${reset}`);
+	process.exit(1);
+}
+
 /**
  * Print a warning message with a yellow warning icon
  */
@@ -200,9 +210,13 @@ export function padLeft(str: string, length: number, pad = ' '): string {
  * Creates a bordered box around the content
  *
  * Uses Bun.stringWidth() for accurate width calculation with ANSI codes and unicode
+ * Responsive to terminal width - adapts to narrow terminals
  */
 export function banner(title: string, body: string): void {
-	const maxWidth = 80;
+	// Get terminal width, default to 80 if not available, minimum 40
+	const termWidth = process.stdout.columns || 80;
+	const maxWidth = Math.max(40, Math.min(termWidth - 2, 80)); // Between 40 and 80, with 2 char margin
+
 	const border = {
 		topLeft: '╭',
 		topRight: '╮',
@@ -377,6 +391,33 @@ export async function confirm(message: string, defaultValue = true): Promise<boo
 	});
 }
 
+/**
+ * Display a signup benefits box with cyan border
+ * Shows the value proposition for creating an Agentuity account
+ */
+export function showSignupBenefits(): void {
+	const CYAN = Bun.color('cyan', 'ansi-16m');
+	const TEXT =
+		currentColorScheme === 'dark' ? Bun.color('white', 'ansi') : Bun.color('black', 'ansi');
+	const RESET = '\x1b[0m';
+
+	const lines = [
+		'╔════════════════════════════════════════════╗',
+		`║ ⨺ Signup for Agentuity             ${muted('free')}${CYAN}    ║`,
+		'║                                            ║',
+		`║ ✓ ${TEXT}Cloud deployment, previews and CI/CD${CYAN}     ║`,
+		`║ ✓ ${TEXT}AI Gateway, KV, Vector and more${CYAN}          ║`,
+		`║ ✓ ${TEXT}Observability, Tracing and Logging${CYAN}       ║`,
+		`║ ✓ ${TEXT}Organization and Team support${CYAN}            ║`,
+		`║ ✓ ${TEXT}And much more!${CYAN}                           ║`,
+		'╚════════════════════════════════════════════╝',
+	];
+
+	console.log('');
+	lines.forEach((line) => console.log(CYAN + line + RESET));
+	console.log('');
+}
+
 /**
  * Copy text to clipboard
  * Returns true if successful, false otherwise
@@ -443,9 +484,36 @@ function getDisplayWidth(str: string): number {
 	return Bun.stringWidth(withoutOSC8);
 }
 
+/**
+ * Extract ANSI codes from the beginning of a string
+ */
+function extractLeadingAnsiCodes(str: string): string {
+	// Match ANSI escape sequences at the start of the string
+	// eslint-disable-next-line no-control-regex
+	const match = str.match(/^(\x1b\[[0-9;]*m)+/);
+	return match ? match[0] : '';
+}
+
+/**
+ * Strip ANSI codes from a string
+ */
+function stripAnsiCodes(str: string): string {
+	// Remove all ANSI escape sequences
+	// eslint-disable-next-line no-control-regex
+	return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+/**
+ * Check if a string ends with ANSI reset code
+ */
+function endsWithReset(str: string): boolean {
+	return str.endsWith('\x1b[0m') || str.endsWith(COLORS.reset);
+}
+
 /**
  * Wrap text to a maximum width
  * Handles explicit newlines and word wrapping
+ * Preserves ANSI color codes across wrapped lines
  */
 function wrapText(text: string, maxWidth: number): string[] {
 	const allLines: string[] = [];
@@ -460,6 +528,13 @@ function wrapText(text: string, maxWidth: number): string[] {
 			continue;
 		}
 
+		// Record starting index for this paragraph's lines
+		const paragraphStart = allLines.length;
+
+		// Extract any leading ANSI codes from the paragraph
+		const leadingCodes = extractLeadingAnsiCodes(paragraph);
+		const hasReset = endsWithReset(paragraph);
+
 		// Wrap each paragraph
 		const words = paragraph.split(' ');
 		let currentLine = '';
@@ -477,13 +552,30 @@ function wrapText(text: string, maxWidth: number): string[] {
 				}
 				// If the word itself is longer than maxWidth, just use it as is
 				// (better to have a long line than break in the middle)
-				currentLine = word;
+				// But if we have leading codes and this isn't the first line, apply them
+				if (leadingCodes && currentLine) {
+					// Strip any existing codes from the word to avoid duplication
+					const strippedWord = stripAnsiCodes(word);
+					currentLine = leadingCodes + strippedWord;
+				} else {
+					currentLine = word;
+				}
 			}
 		}
 
 		if (currentLine) {
 			allLines.push(currentLine);
 		}
+
+		// If the original paragraph had ANSI codes and ended with reset,
+		// ensure each wrapped line ends with reset (only for this paragraph's lines)
+		if (leadingCodes && hasReset) {
+			for (let i = paragraphStart; i < allLines.length; i++) {
+				if (!endsWithReset(allLines[i])) {
+					allLines[i] += COLORS.reset;
+				}
+			}
+		}
 	}
 
 	return allLines.length > 0 ? allLines : [''];
@@ -658,6 +750,20 @@ export interface CommandRunnerOptions {
 	 * Defaults to false
 	 */
 	clearOnSuccess?: boolean;
+	/**
+	 * If true or undefined, will truncate each line of output
+	 */
+	truncate?: boolean;
+
+	/**
+	 * If undefined, will show up to 3 last lines of output while running. Customize the number with this property.
+	 */
+	maxLinesOutput?: number;
+
+	/**
+	 * If undefined, will show up to 10 last lines on failure. Customize the number with this property.
+	 */
+	maxLinesOnFailure?: number;
 }
 
 /**
@@ -671,7 +777,16 @@ export interface CommandRunnerOptions {
  * Shows the last 3 lines of output as it streams.
  */
 export async function runCommand(options: CommandRunnerOptions): Promise<number> {
-	const { command, cmd, cwd, env, clearOnSuccess = false } = options;
+	const {
+		command,
+		cmd,
+		cwd,
+		env,
+		clearOnSuccess = false,
+		truncate = true,
+		maxLinesOutput = 3,
+		maxLinesOnFailure = 10,
+	} = options;
 	const isTTY = process.stdout.isTTY;
 
 	// If not a TTY, just run the command normally and log output
@@ -746,7 +861,7 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 	};
 
 	// Initial display
-	renderOutput(3);
+	renderOutput(maxLinesOutput);
 
 	try {
 		// Spawn the command
@@ -810,7 +925,7 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 			);
 		} else {
 			// Determine how many lines to show in final output
-			const finalLinesToShow = exitCode === 0 ? 3 : 10;
+			const finalLinesToShow = exitCode === 0 ? maxLinesOutput : maxLinesOnFailure;
 
 			// Show final status with appropriate color
 			const statusColor = exitCode === 0 ? green : red;
@@ -820,7 +935,7 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 			const finalOutputLines = allOutputLines.slice(-finalLinesToShow);
 			for (const line of finalOutputLines) {
 				let displayLine = line;
-				if (getDisplayWidth(displayLine) > maxLineWidth) {
+				if (truncate && getDisplayWidth(displayLine) > maxLineWidth) {
 					displayLine = displayLine.slice(0, maxLineWidth - 3) + '...';
 				}
 				process.stdout.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);