@agentuity/cli 0.0.70 → 0.0.72

package/src/cmd/cloud/storage/list.ts

@@ -74,9 +74,9 @@ export const listSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage for ${orgId} in ${region}`,

package/src/cmd/cloud/storage/upload.ts

@@ -49,9 +49,9 @@ export const uploadSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		// Fetch bucket credentials
 		const resources = await tui.spinner({

package/src/cmd/cloud/thread/delete.ts

@@ -24,8 +24,8 @@ export const deleteSubcommand = createSubcommand({
 		}),
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			await threadDelete(catalystClient, { id: args.thread_id });

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

@@ -37,8 +37,8 @@ export const getSubcommand = createSubcommand({
 		response: ThreadGetResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			const thread = await threadGet(catalystClient, { id: args.thread_id });

package/src/cmd/cloud/thread/list.ts

@@ -62,8 +62,8 @@ export const listSubcommand = createSubcommand({
 		response: ThreadListResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, project, opts, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, project, opts, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const projectId = opts.projectId || project?.projectId;
 		const orgId = opts.orgId;

package/src/cmd/dev/index.ts

@@ -499,6 +499,7 @@ export const command = createCommand({
 								deploymentId,
 								port: opts.port,
 								region: project?.region ?? 'local',
+								logger,
 							});
 							building = false;
 							buildCompletedAt = Date.now();

package/src/config.ts

@@ -727,12 +727,7 @@ export async function loadProjectSDKKey(
 	logger.trace(`[SDK_KEY] AGENTUITY_SDK_KEY not found in any file`);
 }
 
-export function getCatalystAPIClient(
-	config: Config | null,
-	logger: Logger,
-	auth: AuthData,
-	region: string
-) {
+export function getCatalystAPIClient(logger: Logger, auth: AuthData, region: string) {
 	const serviceUrls = getServiceUrls(region);
 	const catalystUrl = serviceUrls.catalyst;
 	return new ServerAPIClient(catalystUrl, logger, auth.apiKey);
@@ -745,3 +740,11 @@ export function getIONHost(config: Config | null) {
 	const url = new URL(config?.overrides?.ion_url ?? 'https://ion.agentuity.cloud');
 	return url.hostname;
 }
+
+export function getStreamURL(region: string, config: Config | null) {
+	if (config?.name === 'local') {
+		return 'https://streams.agentuity.io';
+	}
+	const serviceUrls = getServiceUrls(region);
+	return serviceUrls.stream;
+}

package/src/env-util.ts

@@ -70,7 +70,6 @@ export async function readEnvFile(path: string): Promise<EnvVars> {
 	const file = Bun.file(path);
 
 	if (!(await file.exists())) {
-		console.log(`[ENV] File does not exist: ${path}`);
 		return {};
 	}
 
@@ -85,8 +84,6 @@ export async function readEnvFile(path: string): Promise<EnvVars> {
 		}
 	}
 
-	console.log(`[ENV] Read ${Object.keys(env).length} variables from: ${path}`);
-	console.log(`[ENV] Variables: ${Object.keys(env).join(', ')}`);
 	return env;
 }
 

package/src/output.ts

@@ -39,7 +39,13 @@ export function isQuietMode(options: GlobalOptions): boolean {
  * Check if progress indicators should be disabled
  */
 export function shouldDisableProgress(options: GlobalOptions): boolean {
-	return options.noProgress === true || options.json === true || options.quiet === true;
+	return (
+		options.noProgress === true ||
+		options.json === true ||
+		options.quiet === true ||
+		options.logLevel === 'debug' ||
+		options.logLevel === 'trace'
+	);
 }
 
 /**

package/src/tui.ts

@@ -341,6 +341,85 @@ function getDisplayWidth(str: string): number {
 	return Bun.stringWidth(withoutOSC8);
 }
 
+/**
+ * Strip all ANSI escape sequences from a string
+ */
+function stripAnsi(str: string): string {
+	// eslint-disable-next-line no-control-regex
+	return str.replace(/\u001b\[[0-9;]*m/g, '').replace(/\u001b\]8;;[^\u0007]*\u0007/g, '');
+}
+
+/**
+ * Truncate a string to a maximum display width, handling ANSI codes and Unicode correctly
+ * Preserves ANSI escape sequences and doesn't break multi-byte characters or grapheme clusters
+ */
+function truncateToWidth(str: string, maxWidth: number, ellipsis = '...'): string {
+	const totalWidth = getDisplayWidth(str);
+	if (totalWidth <= maxWidth) {
+		return str;
+	}
+
+	// Strip ANSI to get visible text
+	const visible = stripAnsi(str);
+
+	// Use Intl.Segmenter for grapheme-aware iteration
+	const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+	const segments = Array.from(segmenter.segment(visible));
+
+	// Find the cutoff point by accumulating display width
+	let currentWidth = 0;
+	let cutIndex = 0;
+	const targetWidth = maxWidth - ellipsis.length;
+
+	for (let i = 0; i < segments.length; i++) {
+		const segment = segments[i].segment;
+		const segmentWidth = Bun.stringWidth(segment);
+
+		if (currentWidth + segmentWidth > targetWidth) {
+			break;
+		}
+
+		currentWidth += segmentWidth;
+		cutIndex = segments[i].index + segment.length;
+	}
+
+	// Now reconstruct with ANSI codes preserved
+	// Walk through original string and copy characters + ANSI codes until we hit cutIndex in visible content
+	let result = '';
+	let visibleIndex = 0;
+	let i = 0;
+
+	while (i < str.length && visibleIndex < cutIndex) {
+		// Check for ANSI escape sequence
+		if (str[i] === '\u001b') {
+			// Copy entire ANSI sequence
+			// eslint-disable-next-line no-control-regex
+			const match = str.slice(i).match(/^\u001b\[[0-9;]*m/);
+			if (match) {
+				result += match[0];
+				i += match[0].length;
+				continue;
+			}
+
+			// Check for OSC 8 hyperlink
+			// eslint-disable-next-line no-control-regex
+			const oscMatch = str.slice(i).match(/^\u001b\]8;;[^\u0007]*\u0007/);
+			if (oscMatch) {
+				result += oscMatch[0];
+				i += oscMatch[0].length;
+				continue;
+			}
+		}
+
+		// Copy visible character
+		result += str[i];
+		visibleIndex++;
+		i++;
+	}
+
+	return result + ellipsis;
+}
+
 /**
  * Pad a string to a specific length on the right
  */
@@ -796,6 +875,11 @@ function wrapText(text: string, maxWidth: number): string[] {
  */
 export type SpinnerProgressCallback = (progress: number) => void;
 
+/**
+ * Log callback for spinner
+ */
+export type SpinnerLogCallback = (message: string) => void;
+
 /**
  * Spinner options (simple without progress)
  */
@@ -824,10 +908,32 @@ export interface ProgressSpinnerOptions<T> {
 	clearOnSuccess?: boolean;
 }
 
+/**
+ * Spinner options (with logger streaming)
+ */
+export interface LoggerSpinnerOptions<T> {
+	type: 'logger';
+	message: string;
+	callback: (log: SpinnerLogCallback) => Promise<T>;
+	/**
+	 * If true, clear the spinner output on success (no icon, no message)
+	 * Defaults to false
+	 */
+	clearOnSuccess?: boolean;
+	/**
+	 * Maximum number of log lines to show while running
+	 * If < 0, shows all lines. Defaults to 3.
+	 */
+	maxLines?: number;
+}
+
 /**
  * Spinner options (discriminated union)
  */
-export type SpinnerOptions<T> = SimpleSpinnerOptions<T> | ProgressSpinnerOptions<T>;
+export type SpinnerOptions<T> =
+	| SimpleSpinnerOptions<T>
+	| ProgressSpinnerOptions<T>
+	| LoggerSpinnerOptions<T>;
 
 /**
  * Run a callback with an animated spinner (simple overload)
@@ -882,9 +988,14 @@ export async function spinner<T>(
 			const result =
 				options.type === 'progress'
 					? await options.callback(() => {})
-					: typeof options.callback === 'function'
-						? await options.callback()
-						: await options.callback;
+					: options.type === 'logger'
+						? await options.callback((logMessage: string) => {
+								// In non-TTY mode, just write logs directly to stdout
+								process.stdout.write(logMessage + '\n');
+							})
+						: typeof options.callback === 'function'
+							? await options.callback()
+							: await options.callback;
 
 			// If clearOnSuccess is true, don't show success message
 			// Also skip success message in JSON mode
@@ -914,12 +1025,22 @@ export async function spinner<T>(
 
 	let frameIndex = 0;
 	let currentProgress: number | undefined;
+	const logLines: string[] = [];
+	const maxLines = options.type === 'logger' ? (options.maxLines ?? 3) : 0;
+	const mutedColor = getColor('muted');
+	let linesRendered = 0;
 
-	// Save cursor position and hide cursor
-	process.stderr.write('\x1B[s\x1B[?25l');
+	// Get terminal width for truncation
+	const termWidth = process.stderr.columns || 80;
+	const maxLineWidth = Math.min(80, termWidth);
+
+	// Function to render spinner with optional log lines
+	const renderSpinner = () => {
+		// Move cursor up to start of our output area if we've rendered before
+		if (linesRendered > 0) {
+			process.stderr.write(`\x1b[${linesRendered}A`);
+		}
 
-	// Start animation
-	const interval = setInterval(() => {
 		const colorDef = spinnerColors[frameIndex % spinnerColors.length];
 		const color = colorDef[currentColorScheme];
 		const frame = `${color}${bold}${frames[frameIndex % frames.length]}${reset}`;
@@ -930,31 +1051,64 @@ export async function spinner<T>(
 				? ` ${cyanColor}${Math.floor(currentProgress)}%${reset}`
 				: '';
 
-		// Clear line and render
-		process.stderr.write('\r\x1B[K' + `${frame} ${message}${progressIndicator}`);
+		// Render spinner line
+		process.stderr.write(`\r\x1b[K${frame} ${message}${progressIndicator}\n`);
+
+		// Render log lines if in logger mode
+		if (options.type === 'logger') {
+			const displayLines = maxLines < 0 ? logLines : logLines.slice(-maxLines);
+			for (const line of displayLines) {
+				const displayLine =
+					getDisplayWidth(line) > maxLineWidth ? truncateToWidth(line, maxLineWidth) : line;
+				process.stderr.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);
+			}
+			linesRendered = 1 + displayLines.length;
+		} else {
+			linesRendered = 1;
+		}
+
 		frameIndex++;
-	}, 120);
+	};
+
+	// Save cursor position and hide cursor
+	process.stderr.write('\x1B[s\x1B[?25l');
+
+	// Initial render
+	renderSpinner();
+
+	// Start animation
+	const interval = setInterval(renderSpinner, 120);
 
 	// Progress callback
 	const progressCallback: SpinnerProgressCallback = (progress: number) => {
 		currentProgress = Math.min(100, Math.max(0, progress));
 	};
 
+	// Log callback
+	const logCallback: SpinnerLogCallback = (logMessage: string) => {
+		logLines.push(logMessage);
+	};
+
 	try {
 		// Execute callback
 		const result =
 			options.type === 'progress'
 				? await options.callback(progressCallback)
-				: typeof options.callback === 'function'
-					? await options.callback()
-					: await options.callback;
+				: options.type === 'logger'
+					? await options.callback(logCallback)
+					: typeof options.callback === 'function'
+						? await options.callback()
+						: await options.callback;
 
 		// Stop animation first
 		clearInterval(interval);
 
-		// 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');
+		// Move cursor to start of output, clear all lines
+		if (linesRendered > 0) {
+			process.stderr.write(`\x1b[${linesRendered}A`);
+		}
+		process.stderr.write('\x1b[J'); // Clear from cursor to end of screen
+		process.stderr.write('\x1B[?25h'); // Show cursor
 
 		// If clearOnSuccess is false, show success message
 		if (!options.clearOnSuccess) {
@@ -968,17 +1122,27 @@ export async function spinner<T>(
 		// Stop animation first
 		clearInterval(interval);
 
-		// Restore cursor position, clear to end of screen, show cursor
-		process.stderr.write('\x1B[u\x1B[J\x1B[?25h');
+		// Move cursor to start of output, clear all lines
+		if (linesRendered > 0) {
+			process.stderr.write(`\x1b[${linesRendered}A`);
+		}
+		process.stderr.write('\x1b[J'); // Clear from cursor to end of screen
+		process.stderr.write('\x1B[?25h'); // Show cursor
 
 		// Show error
 		const errorColor = getColor('error');
-		console.error(`${errorColor}${ICONS.error} ${message}${reset}`);
+		const errorMessage = err instanceof Error ? err.message : String(err);
+		console.error(`${errorColor}${ICONS.error} ${message}: ${errorMessage}${reset}`);
 
 		throw err;
 	}
 }
 
+/**
+ * Alias for spinner function (for better semantics when using progress/logger types)
+ */
+export const progress = spinner;
+
 /**
  * Options for running a command with streaming output
  */
@@ -1072,11 +1236,8 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 	const maxLineWidth = Math.min(80, termWidth);
 
 	// Truncate command if needed
-	let displayCmd = command;
-	if (getDisplayWidth(displayCmd) > maxCmdWidth) {
-		// Simple truncation for now - could be smarter about this
-		displayCmd = displayCmd.slice(0, maxCmdWidth - 3) + '...';
-	}
+	const displayCmd =
+		getDisplayWidth(command) > maxCmdWidth ? truncateToWidth(command, maxCmdWidth) : command;
 
 	// Store all output lines, display subset based on context
 	const allOutputLines: string[] = [];
@@ -1100,11 +1261,8 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 
 		// Render output lines
 		for (const line of displayLines) {
-			// Truncate line if needed
-			let displayLine = line;
-			if (getDisplayWidth(displayLine) > maxLineWidth) {
-				displayLine = displayLine.slice(0, maxLineWidth - 3) + '...';
-			}
+			const displayLine =
+				getDisplayWidth(line) > maxLineWidth ? truncateToWidth(line, maxLineWidth) : line;
 			process.stdout.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);
 		}
 
@@ -1198,10 +1356,10 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 		// Show final output lines
 		const finalOutputLines = allOutputLines.slice(-finalLinesToShow);
 		for (const line of finalOutputLines) {
-			let displayLine = line;
-			if (truncate && getDisplayWidth(displayLine) > maxLineWidth) {
-				displayLine = displayLine.slice(0, maxLineWidth - 3) + '...';
-			}
+			const displayLine =
+				truncate && getDisplayWidth(line) > maxLineWidth
+					? truncateToWidth(line, maxLineWidth)
+					: line;
 			process.stdout.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);
 		}