@agentuity/cli 0.0.42 → 0.0.44

package/src/env-util.ts

@@ -0,0 +1,290 @@
+/**
+ * Utility functions for handling .env files
+ */
+
+import { join } from 'node:path';
+
+export interface EnvVars {
+	[key: string]: string;
+}
+
+/**
+ * Find the appropriate .env file to use for user environment variables.
+ * Always returns .env.production path (will be created if needed).
+ * .env should only contain AGENTUITY_SDK_KEY.
+ */
+export async function findEnvFile(dir: string): Promise<string> {
+	return join(dir, '.env.production');
+}
+
+/**
+ * Find an existing env file for reading.
+ * Preference: .env.production > .env
+ */
+export async function findExistingEnvFile(dir: string): Promise<string> {
+	const productionEnv = join(dir, '.env.production');
+	const defaultEnv = join(dir, '.env');
+
+	if (await Bun.file(productionEnv).exists()) {
+		return productionEnv;
+	}
+
+	return defaultEnv;
+}
+
+/**
+ * Parse a single line from an .env file
+ * Handles comments, empty lines, and quoted values
+ */
+export function parseEnvLine(line: string): { key: string; value: string } | null {
+	const trimmed = line.trim();
+
+	// Skip empty lines and comments
+	if (!trimmed || trimmed.startsWith('#')) {
+		return null;
+	}
+
+	const equalIndex = trimmed.indexOf('=');
+	if (equalIndex === -1) {
+		return null;
+	}
+
+	const key = trimmed.slice(0, equalIndex).trim();
+	let value = trimmed.slice(equalIndex + 1).trim();
+
+	// Remove surrounding quotes if present
+	if (
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith("'") && value.endsWith("'"))
+	) {
+		value = value.slice(1, -1);
+	}
+
+	return { key, value };
+}
+
+/**
+ * Read and parse an .env file
+ */
+export async function readEnvFile(path: string): Promise<EnvVars> {
+	const file = Bun.file(path);
+
+	if (!(await file.exists())) {
+		return {};
+	}
+
+	const content = await file.text();
+	const lines = content.split('\n');
+	const env: EnvVars = {};
+
+	for (const line of lines) {
+		const parsed = parseEnvLine(line);
+		if (parsed) {
+			env[parsed.key] = parsed.value;
+		}
+	}
+
+	return env;
+}
+
+/**
+ * Write environment variables to an .env file
+ * Optionally skip certain keys (like AGENTUITY_SDK_KEY)
+ */
+export async function writeEnvFile(
+	path: string,
+	vars: EnvVars,
+	options?: {
+		skipKeys?: string[];
+		addComment?: (key: string) => string | null;
+	}
+): Promise<void> {
+	const skipKeys = options?.skipKeys || [];
+	const lines: string[] = [];
+
+	// Sort keys for consistent output
+	const sortedKeys = Object.keys(vars).sort();
+
+	for (const key of sortedKeys) {
+		if (skipKeys.includes(key)) {
+			continue;
+		}
+
+		const value = vars[key];
+
+		// Add comment if provided
+		if (options?.addComment) {
+			const comment = options.addComment(key);
+			if (comment) {
+				lines.push(`# ${comment}`);
+			}
+		}
+
+		// Write key=value
+		lines.push(`${key}=${value}`);
+	}
+
+	const content = lines.join('\n') + '\n';
+	await Bun.write(path, content);
+}
+
+/**
+ * Merge environment variables with special handling
+ * - Later values override earlier values
+ * - Can filter out keys (like AGENTUITY_* keys)
+ */
+export function mergeEnvVars(
+	base: EnvVars,
+	updates: EnvVars,
+	options?: {
+		filterPrefix?: string;
+	}
+): EnvVars {
+	const merged = { ...base };
+	const filterPrefix = options?.filterPrefix;
+
+	for (const [key, value] of Object.entries(updates)) {
+		// Skip keys with filter prefix if specified
+		if (filterPrefix && key.startsWith(filterPrefix)) {
+			continue;
+		}
+
+		merged[key] = value;
+	}
+
+	return merged;
+}
+
+/**
+ * Filter out AGENTUITY_ prefixed keys from env vars
+ * This is used when pushing to the cloud to avoid sending SDK keys
+ */
+export function filterAgentuitySdkKeys(vars: EnvVars): EnvVars {
+	const filtered: EnvVars = {};
+
+	for (const [key, value] of Object.entries(vars)) {
+		if (!key.startsWith('AGENTUITY_')) {
+			filtered[key] = value;
+		}
+	}
+
+	return filtered;
+}
+
+/**
+ * Split env vars into env and secrets based on key names
+ * Convention: Keys ending with _SECRET, _KEY, _TOKEN, _PASSWORD are secrets
+ */
+export function splitEnvAndSecrets(vars: EnvVars): {
+	env: EnvVars;
+	secrets: EnvVars;
+} {
+	const env: EnvVars = {};
+	const secrets: EnvVars = {};
+
+	const secretSuffixes = ['_SECRET', '_KEY', '_TOKEN', '_PASSWORD', '_PRIVATE'];
+
+	for (const [key, value] of Object.entries(vars)) {
+		// Skip AGENTUITY_ prefixed keys
+		if (key.startsWith('AGENTUITY_')) {
+			continue;
+		}
+
+		const isSecret = secretSuffixes.some((suffix) => key.endsWith(suffix));
+
+		if (isSecret) {
+			secrets[key] = value;
+		} else {
+			env[key] = value;
+		}
+	}
+
+	return { env, secrets };
+}
+
+/**
+ * Mask a secret value for display
+ */
+export function maskSecret(value: string): string {
+	if (!value) {
+		return '';
+	}
+
+	if (value.length <= 8) {
+		return '***';
+	}
+
+	// Show first 4 and last 4 characters
+	return `${value.slice(0, 4)}...${value.slice(-4)}`;
+}
+
+/**
+ * Detect if a key or value looks like it should be a secret
+ */
+export function looksLikeSecret(key: string, value: string): boolean {
+	// Check key name for secret-like patterns
+	const secretKeyPatterns = [
+		/_SECRET$/i,
+		/_KEY$/i,
+		/_TOKEN$/i,
+		/_PASSWORD$/i,
+		/_PRIVATE$/i,
+		/_CERT$/i,
+		/_CERTIFICATE$/i,
+		/^SECRET_/i,
+		/^API_?KEY/i,
+		/^JWT/i,
+		/PASSWORD/i,
+		/CREDENTIAL/i,
+		/AUTH.*KEY/i,
+	];
+
+	const keyLooksSecret = secretKeyPatterns.some((pattern) => pattern.test(key));
+	if (keyLooksSecret) {
+		return true;
+	}
+
+	// Check value for secret-like patterns
+	if (!value || value.length < 8) {
+		return false;
+	}
+
+	// JWT pattern (header.payload.signature)
+	if (/^eyJ[A-Za-z0-9_-]+\.eyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/.test(value)) {
+		return true;
+	}
+
+	// Bearer token pattern
+	if (/^Bearer\s+[A-Za-z0-9_-]{20,}$/i.test(value)) {
+		return true;
+	}
+
+	// AWS/Cloud provider key patterns
+	if (/^(AKIA|ASIA)[A-Z0-9]{16}$/.test(value)) {
+		// AWS access key
+		return true;
+	}
+
+	// GitHub token patterns
+	if (/^gh[ps]_[A-Za-z0-9_]{36,}$/.test(value)) {
+		return true;
+	}
+
+	// Generic long alphanumeric strings (likely API keys)
+	// Exclude UUIDs (8-4-4-4-12 format) and simple alphanumeric IDs
+	const isUUID = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(value);
+	if (!isUUID && /^[A-Za-z0-9_-]{32,}$/.test(value) && !/^[0-9]+$/.test(value)) {
+		return true;
+	}
+
+	// PEM-encoded certificates or private keys
+	if (
+		value.includes('BEGIN CERTIFICATE') ||
+		value.includes('BEGIN PRIVATE KEY') ||
+		value.includes('BEGIN RSA PRIVATE KEY')
+	) {
+		return true;
+	}
+
+	return false;
+}

package/src/index.ts

@@ -17,7 +17,11 @@ export {
 	getAuth,
 } from './config';
 export { APIClient, getAPIBaseURL, getAppBaseURL } from './api';
-export { Logger, logger } from './logger';
+export {
+	ConsoleLogger,
+	createLogger,
+	type ColorScheme as LoggerColorScheme,
+} from '@agentuity/server';
 export { showBanner } from './banner';
 export { discoverCommands } from './cmd';
 export { detectColorScheme } from './terminal';

package/src/schema-parser.ts

@@ -203,9 +203,8 @@ export function buildValidationInput(
 	if (schemas.options) {
 		const parsed = parseOptionsSchema(schemas.options);
 		for (const opt of parsed) {
-			if (rawOptions[opt.name] !== undefined) {
-				result.options[opt.name] = rawOptions[opt.name];
-			}
+			// Always include the option value (even if undefined) so zod can apply defaults
+			result.options[opt.name] = rawOptions[opt.name];
 		}
 	}
 

package/src/steps.ts

@@ -6,6 +6,59 @@
  */
 
 import type { ColorScheme } from './terminal';
+import type { LogLevel } from './types';
+
+/**
+ * Get the appropriate 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 + TTY raw mode for Ctrl+C)
+ */
+function installInterruptHandlers(onInterrupt: () => void): () => void {
+	const cleanupFns: Array<() => void> = [];
+
+	const sigHandler = () => onInterrupt();
+	process.on('SIGINT', sigHandler);
+	process.on('SIGTERM', sigHandler);
+	cleanupFns.push(() => {
+		process.off('SIGINT', sigHandler);
+		process.off('SIGTERM', sigHandler);
+	});
+
+	// TTY raw mode fallback for Bun/Windows/inconsistent SIGINT delivery
+	const stdin = process.stdin as unknown as NodeJS.ReadStream;
+	if (stdin && stdin.isTTY) {
+		const onData = (buf: Buffer) => {
+			// Ctrl+C is ASCII ETX (0x03)
+			if (buf.length === 1 && buf[0] === 0x03) onInterrupt();
+		};
+		try {
+			stdin.setRawMode?.(true);
+		} catch {
+			// ignore if not supported
+		}
+		stdin.resume?.();
+		stdin.on('data', onData);
+		cleanupFns.push(() => {
+			stdin.off?.('data', onData);
+			stdin.pause?.();
+			try {
+				stdin.setRawMode?.(false);
+			} catch {
+				// ignore if setRawMode fails
+			}
+		});
+	}
+
+	return () => {
+		for (const fn of cleanupFns.splice(0)) fn();
+	};
+}
 
 // Spinner frames
 const FRAMES = ['◐', '◓', '◑', '◒'];
@@ -35,7 +88,7 @@ const COLORS = {
 // Spinner color sequence
 const SPINNER_COLORS = ['cyan', 'blue', 'magenta', 'cyan'] as const;
 
-let currentColorScheme: ColorScheme = 'dark';
+let currentColorScheme: ColorScheme = process.env.CI ? 'light' : 'dark';
 
 export function setStepsColorScheme(scheme: ColorScheme): void {
 	currentColorScheme = scheme;
@@ -117,8 +170,10 @@ type StepState =
  * Each step runs its callback while showing a spinner animation.
  * Steps can complete with success, skipped, or error status.
  * Exits with code 1 if any step errors.
+ *
+ * When there's no TTY or log level is debug/trace, uses plain output instead of TUI.
  */
-export async function runSteps(steps: Step[]): Promise<void> {
+export async function runSteps(steps: Step[], logLevel?: LogLevel): Promise<void> {
 	const state: StepState[] = steps.map((s) => {
 		const stepType = s.type === 'progress' ? 'progress' : 'simple';
 		return stepType === 'progress'
@@ -130,26 +185,59 @@ export async function runSteps(steps: Step[]): Promise<void> {
 			: { type: 'simple' as const, label: s.label, run: s.run as () => Promise<StepOutcome> };
 	});
 
+	// Detect if we should use TUI (animated) or plain mode
+	const useTUI =
+		process.stdout.isTTY && (!logLevel || ['info', 'warn', 'error'].includes(logLevel));
+
+	if (useTUI) {
+		await runStepsTUI(state);
+	} else {
+		await runStepsPlain(state);
+	}
+}
+
+/**
+ * Run steps with animated TUI (original behavior)
+ */
+async function runStepsTUI(state: StepState[]): Promise<void> {
 	// Hide cursor
 	process.stdout.write('\x1B[?25l');
 
+	// Track active interval and interrupted state
+	let activeInterval: ReturnType<typeof setInterval> | null = null;
+	let interrupted = false;
+
+	// Set up Ctrl+C handler for graceful exit
+	const exit = getExitFn();
+	const onInterrupt = () => {
+		if (interrupted) return;
+		interrupted = true;
+		if (activeInterval) clearInterval(activeInterval);
+		process.stdout.write('\x1B[?25h\n'); // Show cursor
+		exit(130);
+	};
+	const restoreInterrupts = installInterruptHandlers(onInterrupt);
+
 	try {
 		// Initial render
 		process.stdout.write(renderSteps(state, -1) + '\n');
 
 		for (let stepIndex = 0; stepIndex < state.length; stepIndex++) {
+			if (interrupted) break;
+
 			const step = state[stepIndex];
 			let frameIndex = 0;
+			let currentFrame = '';
 
 			// Start spinner animation
-			const interval = setInterval(() => {
+			activeInterval = setInterval(() => {
 				const colorKey = SPINNER_COLORS[frameIndex % SPINNER_COLORS.length];
 				const color = getColor(colorKey);
-				const frame = `${color}${COLORS.bold}${FRAMES[frameIndex % FRAMES.length]}${COLORS.reset}`;
+				currentFrame = `${color}${COLORS.bold}${FRAMES[frameIndex % FRAMES.length]}${COLORS.reset}`;
 
 				// Move cursor up to the top of checklist
 				process.stdout.write(`\x1B[${state.length}A`);
-				process.stdout.write(renderSteps(state, stepIndex, frame) + '\n');
+				process.stdout.write(renderSteps(state, stepIndex, currentFrame) + '\n');
 
 				frameIndex++;
 			}, 120);
@@ -158,9 +246,9 @@ export async function runSteps(steps: Step[]): Promise<void> {
 			const progressCallback: ProgressCallback = (progress: number) => {
 				step.progress = Math.min(100, Math.max(0, progress));
 
-				// Move cursor up
+				// Move cursor up and render with current spinner frame
 				process.stdout.write(`\x1B[${state.length}A`);
-				process.stdout.write(renderSteps(state, stepIndex) + '\n');
+				process.stdout.write(renderSteps(state, stepIndex, currentFrame) + '\n');
 			};
 
 			try {
@@ -175,12 +263,15 @@ export async function runSteps(steps: Step[]): Promise<void> {
 				};
 			}
 
-			clearInterval(interval);
+			if (activeInterval) {
+				clearInterval(activeInterval);
+				activeInterval = null;
+			}
 
 			// Clear progress and final render with outcome
 			step.progress = undefined;
 			process.stdout.write(`\x1B[${state.length}A`);
-			process.stdout.write(renderSteps(state, stepIndex) + '\n');
+			process.stdout.write(renderSteps(state, -1) + '\n');
 
 			// If error, show error message and exit
 			if (step.outcome?.status === 'error') {
@@ -192,11 +283,52 @@ export async function runSteps(steps: Step[]): Promise<void> {
 		}
 
 		// Show cursor again
-		process.stdout.write('\x1B[?25h\n');
+		process.stdout.write('\x1B[?25h');
 	} catch (err) {
 		// Ensure cursor is shown even if something goes wrong
 		process.stdout.write('\x1B[?25h');
 		throw err;
+	} finally {
+		// Remove signal/TTY handlers
+		restoreInterrupts();
+	}
+}
+
+/**
+ * Run steps in plain mode (no TUI animations)
+ */
+async function runStepsPlain(state: StepState[]): Promise<void> {
+	const grayColor = getColor('gray');
+	const greenColor = getColor('green');
+	const yellowColor = getColor('yellow');
+	const redColor = getColor('red');
+
+	for (const step of state) {
+		// Run the step (no progress callback for plain mode)
+		try {
+			const outcome = step.type === 'progress' ? await step.run(() => {}) : await step.run();
+			step.outcome = outcome;
+		} catch (err) {
+			step.outcome = {
+				status: 'error',
+				message: err instanceof Error ? err.message : String(err),
+			};
+		}
+
+		// Print final state only
+		if (step.outcome?.status === 'success') {
+			console.log(`${greenColor}${ICONS.success}${COLORS.reset} ${step.label}`);
+		} else if (step.outcome?.status === 'skipped') {
+			const reason = step.outcome.reason
+				? ` ${grayColor}(${step.outcome.reason})${COLORS.reset}`
+				: '';
+			console.log(`${yellowColor}${ICONS.skipped}${COLORS.reset} ${step.label}${reason}`);
+		} 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`);
+			process.exit(1);
+		}
 	}
 }
 
@@ -222,6 +354,7 @@ function renderSteps(steps: StepState[], activeIndex: number, spinner?: string):
 	const lines: string[] = [];
 
 	steps.forEach((s, i) => {
+		// Don't show progress indicator for steps with outcomes (success/skipped/error)
 		if (s.outcome?.status === 'success') {
 			lines.push(
 				`${greenColor}${ICONS.success}${COLORS.reset} ${grayColor}${COLORS.strikethrough}${s.label}${COLORS.reset}`
@@ -234,6 +367,7 @@ function renderSteps(steps: StepState[], activeIndex: number, spinner?: string):
 		} else if (s.outcome?.status === 'error') {
 			lines.push(`${redColor}${ICONS.error}${COLORS.reset} ${s.label}`);
 		} else if (i === activeIndex && spinner) {
+			// Only show progress for active step with spinner
 			const progressIndicator = s.progress !== undefined ? renderProgress(s.progress) : '';
 			lines.push(`${spinner} ${s.label}${progressIndicator}`);
 		} else {

package/src/terminal.ts

@@ -1,5 +1,7 @@
 export type ColorScheme = 'light' | 'dark';
 
+const defaultMode = process.env.CI ? 'light' : 'dark';
+
 export async function detectColorScheme(): Promise<ColorScheme> {
 	const debug = process.env.DEBUG_COLORS === 'true';
 
@@ -14,28 +16,27 @@ export async function detectColorScheme(): Promise<ColorScheme> {
 	}
 
 	// Check if we have stdout TTY at minimum
-	if (!process.stdout.isTTY) {
-		if (debug) console.log('[DEBUG] stdout not a TTY, defaulting to dark');
-		return 'dark'; // Default to dark mode
-	}
-
-	// Try to query terminal background color using OSC 11 (most reliable)
-	if (debug) console.log('[DEBUG] Querying terminal background with OSC 11...');
-	try {
-		const bgColor = await queryTerminalBackground();
-		if (bgColor) {
-			const luminance = calculateLuminance(bgColor);
-			const scheme = luminance > 0.5 ? 'light' : 'dark';
-			if (debug)
-				console.log(
-					`[DEBUG] OSC 11 response: rgb(${bgColor.r},${bgColor.g},${bgColor.b}), luminance: ${luminance.toFixed(2)}, scheme: ${scheme}`
-				);
-			return scheme;
-		} else {
-			if (debug) console.log('[DEBUG] OSC 11 query timed out or no response');
+	if (process.stdout.isTTY) {
+		if (debug) console.log('[DEBUG] stdout is a TTY, defaulting to dark');
+
+		// Try to query terminal background color using OSC 11 (most reliable)
+		if (debug) console.log('[DEBUG] Querying terminal background with OSC 11...');
+		try {
+			const bgColor = await queryTerminalBackground();
+			if (bgColor) {
+				const luminance = calculateLuminance(bgColor);
+				const scheme = luminance > 0.5 ? 'light' : 'dark';
+				if (debug)
+					console.log(
+						`[DEBUG] OSC 11 response: rgb(${bgColor.r},${bgColor.g},${bgColor.b}), luminance: ${luminance.toFixed(2)}, scheme: ${scheme}`
+					);
+				return scheme;
+			} else {
+				if (debug) console.log('[DEBUG] OSC 11 query timed out or no response');
+			}
+		} catch (error) {
+			if (debug) console.log('[DEBUG] OSC 11 query failed:', error);
 		}
-	} catch (error) {
-		if (debug) console.log('[DEBUG] OSC 11 query failed:', error);
 	}
 
 	// Fall back to COLORFGBG environment variable (less reliable)
@@ -56,8 +57,8 @@ export async function detectColorScheme(): Promise<ColorScheme> {
 		return scheme;
 	}
 
-	if (debug) console.log('[DEBUG] Defaulting to dark mode');
-	return 'dark'; // Default to dark mode
+	if (debug) console.log('[DEBUG] Defaulting to %s', defaultMode);
+	return defaultMode;
 }
 
 interface RGBColor {