@agentuity/cli 0.0.35 → 0.0.41

package/src/cmd/dev/index.ts

@@ -38,6 +38,22 @@ export const command = createCommand({
 			process.exit(1);
 		}
 
+		const devmodebody = tui.muted('Local: ') + tui.link('http://127.0.0.1:3000');
+
+		tui.banner('⨺ Agentuity DevMode', devmodebody, {
+			padding: 2,
+			topSpacer: false,
+			bottomSpacer: false,
+			centerTitle: false,
+		});
+
+		const env = { ...process.env };
+		env.AGENTUITY_SDK_DEV_MODE = 'true';
+		env.AGENTUITY_ENV = 'development';
+		env.NODE_ENV = 'development';
+		env.PORT = '3000';
+		env.AGENTUITY_PORT = env.PORT;
+
 		const agentuityDir = resolve(rootDir, '.agentuity');
 		const appPath = resolve(agentuityDir, 'app.js');
 
@@ -208,6 +224,7 @@ export const command = createCommand({
 					stdout: 'inherit',
 					stderr: 'inherit',
 					stdin: 'inherit',
+					env,
 				});
 
 				running = true;

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

@@ -10,7 +10,7 @@ export const optionalAuthSubcommand: SubcommandDefinition = {
 
 		// Type guard to check if auth is present
 		const ctxWithAuth = ctx as CommandContext<true>;
-		if ('auth' in ctx && ctxWithAuth.auth) {
+		if (ctxWithAuth.auth) {
 			const auth = ctxWithAuth.auth as AuthData;
 			// User chose to authenticate
 			tui.success('You are authenticated!');

package/src/cmd/index.ts

@@ -28,6 +28,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 									aliases: subcommand.aliases,
 									hidden: true,
 									requiresAuth: subcommand.requiresAuth,
+									optionalAuth: subcommand.optionalAuth,
 									schema: subcommand.schema,
 									handler: subcommand.handler,
 								};

package/src/cmd/profile/README.md

@@ -77,4 +77,4 @@ The `name` field is extracted using the regex: `/\bname:\s+["']?([\w-_]+)["']?/`
 - Profile files must have `.yaml` extension
 - Profile names must match: `^[\w-_]{3,}$` (3+ chars, alphanumeric, dashes, underscores)
 - The config loader (`loadConfig()`) automatically uses the active profile
-- If no profile is selected or the file doesn't exist, falls back to `config.yaml`
+- If no profile is selected or the file doesn't exist, falls back to `production.yaml`

package/src/cmd/project/create.ts

@@ -7,7 +7,7 @@ export const createProjectSubcommand = createSubcommand({
 	description: 'Create a new project',
 	aliases: ['new'],
 	toplevel: true,
-	requiresAuth: false,
+	optionalAuth: true,
 	schema: {
 		options: z.object({
 			name: z.string().optional().describe('Project name'),
@@ -31,12 +31,18 @@ export const createProjectSubcommand = createSubcommand({
 				.optional()
 				.default(true)
 				.describe('Run bun run build after installing (use --no-build to skip)'),
-			confirm: z.boolean().optional().describe('Skip confirmation prompts'),
+			confirm: z.boolean().optional().describe('Show confirmation prompts'),
+			register: z
+				.boolean()
+				.default(true)
+				.optional()
+				.describe('Register the project, if authenticated (use --no-register to skip)'),
 		}),
 	},
 
 	async handler(ctx) {
-		const { logger, opts } = ctx;
+		const { logger, opts, auth, config } = ctx;
+
 		await runCreateFlow({
 			projectName: opts.name,
 			dir: opts.dir,
@@ -47,6 +53,8 @@ export const createProjectSubcommand = createSubcommand({
 			noBuild: opts.build === false,
 			skipPrompts: opts.confirm === true,
 			logger,
+			auth: opts.register === true ? auth : undefined,
+			config: config!,
 		});
 	},
 });

package/src/cmd/project/download.ts

@@ -225,6 +225,23 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 			clearOnSuccess: true,
 		});
 
+		// Configure git user in CI environments (where git config may not be set)
+		if (process.env.CI) {
+			await tui.runCommand({
+				command: 'git config user.email',
+				cwd: dest,
+				cmd: ['git', 'config', 'user.email', 'agentuity@example.com'],
+				clearOnSuccess: true,
+			});
+
+			await tui.runCommand({
+				command: 'git config user.name',
+				cwd: dest,
+				cmd: ['git', 'config', 'user.name', 'Agentuity'],
+				clearOnSuccess: true,
+			});
+		}
+
 		// Add all files
 		await tui.runCommand({
 			command: 'git add .',

package/src/cmd/project/template-flow.ts

@@ -3,12 +3,21 @@ import { existsSync, readdirSync, rmSync, statSync } from 'node:fs';
 import { cwd } from 'node:process';
 import { homedir } from 'node:os';
 import enquirer from 'enquirer';
+import {
+	createProject,
+	projectExists,
+	listOrganizations,
+	type OrganizationList,
+} from '@agentuity/server';
 import type { Logger } from '../../logger';
 import * as tui from '../../tui';
 import { playSound } from '../../sound';
 import { fetchTemplates, type TemplateInfo } from './templates';
 import { downloadTemplate, setupProject } from './download';
 import { showBanner } from '../../banner';
+import type { AuthData, Config } from '../../types';
+import { getAPIBaseURL, APIClient } from '../../api';
+import { createProjectConfig } from '../../config';
 
 interface CreateFlowOptions {
 	projectName?: string;
@@ -20,6 +29,8 @@ interface CreateFlowOptions {
 	noBuild: boolean;
 	skipPrompts: boolean;
 	logger: Logger;
+	auth?: AuthData;
+	config?: Config;
 }
 
 export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
@@ -31,6 +42,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		templateBranch,
 		skipPrompts,
 		logger,
+		auth,
+		config,
 	} = options;
 
 	showBanner();
@@ -52,16 +65,39 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 
 	// Step 2: Get project name
 	let projectName = initialProjectName;
+
+	let orgs: OrganizationList | undefined;
+	let client: APIClient | undefined;
+	let orgId: string | undefined;
+
+	if (auth) {
+		const apiUrl = getAPIBaseURL(config);
+		client = new APIClient(apiUrl, config);
+		await tui.spinner('Fetching organizations', async () => {
+			const resp = await listOrganizations(client!);
+			if (resp.data) {
+				orgs = resp.data;
+			}
+		});
+		orgId = await tui.selectOrganization(orgs!, config?.preferences?.orgId);
+	}
+
 	if (!projectName && !skipPrompts) {
 		const response = await enquirer.prompt<{ name: string }>({
 			type: 'input',
 			name: 'name',
 			message: 'What is the name of your project?',
 			initial: 'My First Agent',
-			validate: (value: string) => {
+			validate: async (value: string) => {
 				if (!value || value.trim().length === 0) {
 					return 'Project name is required';
 				}
+				if (client) {
+					const exists = await projectExists(client, { name: value, organization_id: orgId! });
+					if (exists) {
+						return `Project with name '${value}' already exists in this organization`;
+					}
+				}
 				return true;
 			},
 		});
@@ -163,6 +199,24 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<void> {
 		logger,
 	});
 
+	if (auth && client && orgId) {
+		await tui.spinner('Registering your project', async () => {
+			const res = await createProject(client, {
+				name: projectName,
+				organization_id: orgId,
+				provider: 'bunjs',
+			});
+			if (res.success && res.data) {
+				return createProjectConfig(dest, {
+					projectId: res.data.id,
+					orgId,
+					apiKey: res.data.api_key,
+				});
+			}
+			tui.fatal(res.message!);
+		});
+	}
+
 	// Step 8: Show completion message
 	tui.success('✨ Project created successfully!\n');
 	tui.info('Next steps:');

package/src/config.ts

@@ -3,7 +3,7 @@ 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';
-import { ConfigSchema } from './types';
+import { ConfigSchema, ProjectSchema } from './types';
 import * as tui from './tui';
 import { z } from 'zod';
 
@@ -12,7 +12,7 @@ export function getDefaultConfigDir(): string {
 }
 
 export function getDefaultConfigPath(): string {
-	return join(getDefaultConfigDir(), 'config.yaml');
+	return join(getDefaultConfigDir(), 'production.yaml');
 }
 
 export function getProfilePath(): string {
@@ -90,8 +90,15 @@ export async function fetchProfiles(): Promise<Profile[]> {
 	return profiles;
 }
 
+function expandTilde(path: string): string {
+	if (path.startsWith('~/')) {
+		return join(homedir(), path.slice(2));
+	}
+	return path;
+}
+
 export async function loadConfig(customPath?: string): Promise<Config | null> {
-	const configPath = customPath || (await getProfile());
+	const configPath = customPath ? expandTilde(customPath) : await getProfile();
 
 	try {
 		const file = Bun.file(configPath);
@@ -248,7 +255,7 @@ function getPlaceholderValue(schema: z.ZodTypeAny): string {
 	}
 }
 
-function generateYAMLTemplate(name: string): string {
+export function generateYAMLTemplate(name: string): string {
 	const lines: string[] = [];
 
 	// Add name (required)
@@ -308,4 +315,46 @@ function generateYAMLTemplate(name: string): string {
 	return lines.join('\n');
 }
 
-export { generateYAMLTemplate };
+class ProjectConfigNotFoundExpection extends Error {
+	public name: string;
+	constructor() {
+		super('project not found');
+		this.name = 'ProjectConfigNotFoundExpection';
+	}
+}
+
+type ProjectConfig = z.infer<typeof ProjectSchema>;
+
+export async function loadProjectConfig(dir: string): Promise<ProjectConfig> {
+	const configPath = join(dir, 'agentuity.json');
+	const file = Bun.file(configPath);
+	if (!(await file.exists())) {
+		throw new ProjectConfigNotFoundExpection();
+	}
+	const text = await file.text();
+	const config = JSON.parse(text);
+	const result = ProjectSchema.safeParse(config);
+	if (!result.success) {
+		tui.error(`Invalid project config at ${configPath}:`);
+		for (const issue of result.error.issues) {
+			const path = issue.path.length > 0 ? issue.path.join('.') : 'root';
+			tui.bullet(`${path}: ${issue.message}`);
+		}
+		process.exit(1);
+	}
+	return result.data;
+}
+
+type InitialProjectConfig = ProjectConfig & {
+	apiKey: string;
+};
+
+export async function createProjectConfig(dir: string, config: InitialProjectConfig) {
+	const configPath = join(dir, 'agentuity.json');
+	const configFile = Bun.file(configPath);
+	await configFile.write(JSON.stringify(config, null, 2));
+
+	const envPath = join(dir, '.env');
+	const envFile = Bun.file(envPath);
+	await envFile.write(`AGENTUITY_SDK_KEY=${config.apiKey}`);
+}

package/src/index.ts

@@ -1,7 +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 { requireAuth, optionalAuth } from './auth';
 export {
 	loadConfig,
 	saveConfig,
@@ -16,7 +16,7 @@ export {
 	clearAuth,
 	getAuth,
 } from './config';
-export { APIClient, getAPIBaseURL, getAppBaseURL, UpgradeRequiredError } from './api';
+export { APIClient, getAPIBaseURL, getAppBaseURL } from './api';
 export { Logger, logger } from './logger';
 export { showBanner } from './banner';
 export { discoverCommands } from './cmd';

package/src/sound.ts

@@ -33,7 +33,13 @@ export function playSound(): void {
 			return;
 	}
 
-	Bun.spawn(command, {
-		stdio: ['ignore', 'ignore', 'ignore'],
-	}).unref();
+	if (process.stdout.isTTY && Bun.which(command[0])) {
+		try {
+			Bun.spawn(command, {
+				stdio: ['ignore', 'ignore', 'ignore'],
+			}).unref();
+		} catch {
+			/* ignore */
+		}
+	}
 }

package/src/tui.ts

@@ -4,7 +4,8 @@
  * Provides semantic helpers for console output with automatic icons and colors.
  * Uses Bun's built-in color support and ANSI escape codes.
  */
-
+import enquirer from 'enquirer';
+import type { OrganizationList } from '@agentuity/server';
 import type { ColorScheme } from './terminal';
 
 // Icons
@@ -205,6 +206,15 @@ export function padLeft(str: string, length: number, pad = ' '): string {
 	return pad.repeat(length - str.length) + str;
 }
 
+interface BannerOptions {
+	padding?: number;
+	minWidth?: number;
+	topSpacer?: boolean;
+	middleSpacer?: boolean;
+	bottomSpacer?: boolean;
+	centerTitle?: boolean;
+}
+
 /**
  * Display a formatted banner with title and body content
  * Creates a bordered box around the content
@@ -212,10 +222,12 @@ export function padLeft(str: string, length: number, pad = ' '): string {
  * 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 {
+export function banner(title: string, body: string, options?: BannerOptions): void {
 	// 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 minWidth = options?.minWidth ?? 40;
+	const maxWidth = Math.max(minWidth, Math.min(termWidth - 2, 80)); // Between 40 and 80, with 2 char margin
+	const padding = options?.padding ?? 4;
 
 	const border = {
 		topLeft: '╭',
@@ -227,14 +239,14 @@ export function banner(title: string, body: string): void {
 	};
 
 	// Split body into lines and wrap if needed
-	const bodyLines = wrapText(body, maxWidth - 4); // -4 for padding and borders
+	const bodyLines = wrapText(body, maxWidth - padding); // -4 for padding and borders
 
 	// Calculate width based on content
 	const titleWidth = getDisplayWidth(title);
 	const maxBodyWidth = Math.max(...bodyLines.map((line) => getDisplayWidth(line)));
-	const contentWidth = Math.max(titleWidth, maxBodyWidth);
-	const boxWidth = Math.min(contentWidth + 4, maxWidth); // +4 for padding
-	const innerWidth = boxWidth - 4;
+	const contentWidth = Math.max(minWidth, Math.max(titleWidth, maxBodyWidth) + padding);
+	const boxWidth = Math.min(contentWidth, maxWidth); // +N for padding
+	const innerWidth = boxWidth - padding;
 
 	// Colors
 	const borderColor = getColor('muted');
@@ -249,41 +261,58 @@ export function banner(title: string, body: string): void {
 		`${borderColor}${border.topLeft}${border.horizontal.repeat(boxWidth - 2)}${border.topRight}${reset}`
 	);
 
-	// Empty line
-	lines.push(
-		`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
-	);
+	if (options?.topSpacer === true || options?.topSpacer === undefined) {
+		// Empty line
+		lines.push(
+			`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
+		);
+	}
 
 	// Title (centered and bold)
 	const titleDisplayWidth = getDisplayWidth(title);
-	const titlePadding = Math.max(0, Math.floor((innerWidth - titleDisplayWidth) / 2));
-	const titleRightPadding = Math.max(0, innerWidth - titlePadding - titleDisplayWidth);
-	const titleLine =
-		' '.repeat(titlePadding) +
-		`${titleColor}${bold(title)}${reset}` +
-		' '.repeat(titleRightPadding);
-	lines.push(
-		`${borderColor}${border.vertical} ${reset}${titleLine}${borderColor} ${border.vertical}${reset}`
-	);
+	if (options?.centerTitle === true || options?.centerTitle === undefined) {
+		const titlePadding = Math.max(0, Math.floor((innerWidth - titleDisplayWidth) / 2));
+		const titleRightPadding = Math.max(
+			0,
+			Math.max(0, innerWidth - titlePadding - titleDisplayWidth) - padding
+		);
+		const titleLine =
+			' '.repeat(titlePadding) +
+			`${titleColor}${bold(title)}${reset}` +
+			' '.repeat(titleRightPadding);
+		lines.push(
+			`${borderColor}${border.vertical} ${reset}${titleLine}${borderColor} ${border.vertical}${reset}`
+		);
+	} else {
+		const titleRightPadding = Math.max(0, Math.max(0, innerWidth - titleDisplayWidth) - padding);
+		const titleLine = `${titleColor}${bold(title)}${reset}` + ' '.repeat(titleRightPadding);
+		lines.push(
+			`${borderColor}${border.vertical} ${reset}${titleLine}${borderColor} ${border.vertical}${reset}`
+		);
+	}
 
-	// Empty line
-	lines.push(
-		`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
-	);
+	if (options?.middleSpacer === true || options?.middleSpacer === undefined) {
+		// Empty line
+		lines.push(
+			`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
+		);
+	}
 
 	// Body lines
 	for (const line of bodyLines) {
 		const lineWidth = getDisplayWidth(line);
-		const padding = Math.max(0, innerWidth - lineWidth);
+		const linePadding = Math.max(0, Math.max(0, innerWidth - lineWidth) - padding);
 		lines.push(
-			`${borderColor}${border.vertical} ${reset}${line}${' '.repeat(padding)}${borderColor} ${border.vertical}${reset}`
+			`${borderColor}${border.vertical} ${reset}${line}${' '.repeat(linePadding)}${borderColor} ${border.vertical}${reset}`
 		);
 	}
 
-	// Empty line
-	lines.push(
-		`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
-	);
+	if (options?.bottomSpacer === true || options?.bottomSpacer === undefined) {
+		// Empty line
+		lines.push(
+			`${borderColor}${border.vertical}${' '.repeat(boxWidth - 2)}${border.vertical}${reset}`
+		);
+	}
 
 	// Bottom border
 	lines.push(
@@ -418,6 +447,30 @@ export function showSignupBenefits(): void {
 	console.log('');
 }
 
+/**
+ * Display a message when unauthenticated to let the user know certain capabilities are disabled
+ */
+export function showLoggedOutMessage(): void {
+	const CYAN = Bun.color('yellow', 'ansi-16m');
+	const TEXT =
+		currentColorScheme === 'dark' ? Bun.color('white', 'ansi') : Bun.color('black', 'ansi');
+	const RESET = '\x1b[0m';
+
+	const lines = [
+		'╔══════════════════════════════════════════════╗',
+		`║ ⨺ Unauthenticated (local mode)               ║`,
+		'║                                              ║',
+		`║ ${TEXT}Certain capabilities such as the AI services${CYAN} ║`,
+		`║ ${TEXT}and devmode remote are unavailable when${CYAN}      ║`,
+		`║ ${TEXT}unauthenticated.${CYAN}                             ║`,
+		'╚══════════════════════════════════════════════╝',
+	];
+
+	console.log('');
+	lines.forEach((line) => console.log(CYAN + line + RESET));
+	console.log('');
+}
+
 /**
  * Copy text to clipboard
  * Returns true if successful, false otherwise
@@ -649,6 +702,28 @@ export async function spinner<T>(
 	}
 
 	const message = options.message;
+	const reset = COLORS.reset;
+
+	// If no TTY, just execute the callback without animation
+	if (!process.stdout.isTTY) {
+		try {
+			const result =
+				options.type === 'progress'
+					? await options.callback(() => {})
+					: typeof options.callback === 'function'
+						? await options.callback()
+						: await options.callback;
+
+			const successColor = getColor('success');
+			console.log(`${successColor}${ICONS.success} ${message}${reset}`);
+			return result;
+		} catch (err) {
+			const errorColor = getColor('error');
+			console.error(`${errorColor}${ICONS.error} ${message}${reset}`);
+			throw err;
+		}
+	}
+
 	const frames = ['◐', '◓', '◑', '◒'];
 	const spinnerColors = [
 		{ light: '\x1b[36m', dark: '\x1b[96m' }, // cyan
@@ -657,7 +732,6 @@ export async function spinner<T>(
 		{ light: '\x1b[36m', dark: '\x1b[96m' }, // cyan
 	];
 	const bold = '\x1b[1m';
-	const reset = COLORS.reset;
 	const cyanColor = { light: '\x1b[36m', dark: '\x1b[96m' }[currentColorScheme];
 
 	let frameIndex = 0;
@@ -905,41 +979,52 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 		// Wait for process to exit
 		const exitCode = await proc.exited;
 
-		// Move cursor up to redraw final state
+		// If clearOnSuccess is true and command succeeded, clear everything
+		if (clearOnSuccess && exitCode === 0) {
+			if (linesRendered > 0) {
+				// Move up to the command line
+				process.stdout.write(`\x1b[${linesRendered}A`);
+				// Clear each line (entire line) and move cursor back up
+				for (let i = 0; i < linesRendered; i++) {
+					process.stdout.write('\x1b[2K'); // Clear entire line
+					if (i < linesRendered - 1) {
+						process.stdout.write('\x1b[B'); // Move down one line
+					}
+				}
+				// Move cursor back up to original position
+				process.stdout.write(`\x1b[${linesRendered}A\r`);
+			}
+			return exitCode;
+		}
+
+		// Clear all rendered lines completely
 		if (linesRendered > 0) {
+			// Move up to the command line (first line of our output)
 			process.stdout.write(`\x1b[${linesRendered}A`);
+			// Move to beginning of line and clear from cursor to end of screen
+			process.stdout.write('\r\x1b[J');
 		}
 
-		// Clear all lines if clearOnSuccess is true and command succeeded
-		if (clearOnSuccess && exitCode === 0) {
-			// Clear all rendered lines
-			for (let i = 0; i < linesRendered; i++) {
-				process.stdout.write('\r\x1b[K\n');
-			}
-			// Move cursor back up
-			process.stdout.write(`\x1b[${linesRendered}A`);
+		// Determine icon based on exit code
+		const icon = exitCode === 0 ? ICONS.success : ICONS.error;
+		const statusColor = exitCode === 0 ? green : red;
 
-			// Show compact success: ✓ command
-			process.stdout.write(
-				`\r\x1b[K${green}${ICONS.success}${reset} ${cmdColor}${displayCmd}${reset}\n`
-			);
-		} else {
-			// Determine how many lines to show in final output
-			const finalLinesToShow = exitCode === 0 ? maxLinesOutput : maxLinesOnFailure;
-
-			// Show final status with appropriate color
-			const statusColor = exitCode === 0 ? green : red;
-			process.stdout.write(`\r\x1b[K${statusColor}$${reset} ${cmdColor}${displayCmd}${reset}\n`);
-
-			// 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) + '...';
-				}
-				process.stdout.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);
+		// Show final status: icon + command
+		process.stdout.write(
+			`\r\x1b[K${statusColor}${icon}${reset} ${cmdColor}${displayCmd}${reset}\n`
+		);
+
+		// Determine how many lines to show in final output
+		const finalLinesToShow = exitCode === 0 ? maxLinesOutput : maxLinesOnFailure;
+
+		// 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) + '...';
 			}
+			process.stdout.write(`\r\x1b[K${mutedColor}${displayLine}${reset}\n`);
 		}
 
 		return exitCode;
@@ -971,3 +1056,21 @@ export async function runCommand(options: CommandRunnerOptions): Promise<number>
 		process.stdout.write('\x1B[?25h');
 	}
 }
+
+export async function selectOrganization(
+	orgs: OrganizationList,
+	initial?: string
+): Promise<string> {
+	if (orgs.length === 1) {
+		return orgs[0].id;
+	}
+	const response = await enquirer.prompt<{ action: string }>({
+		type: 'select',
+		name: 'action',
+		message: 'Select an organization',
+		initial,
+		choices: orgs.map((o) => ({ message: o.name, name: o.id })),
+	});
+
+	return response.action;
+}