@agentuity/cli 0.0.41 → 0.0.43

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

@@ -7,6 +7,58 @@
 
 import type { ColorScheme } from './terminal';
 
+/**
+ * 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 +87,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;
@@ -133,16 +185,33 @@ export async function runSteps(steps: Step[]): 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;
 
 			// 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}`;
@@ -175,7 +244,10 @@ 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;
@@ -192,11 +264,14 @@ 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();
 	}
 }