@agentuity/cli 0.1.22 → 0.1.24

package/src/cmd/project/delete.ts

@@ -1,10 +1,19 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
-import { projectDelete, projectList } from '@agentuity/server';
+import { projectDelete, projectList, projectGet } from '@agentuity/server';
 import enquirer from 'enquirer';
 import { getCommand } from '../../command-prefix';
 
+interface ProjectDisplayInfo {
+	id: string;
+	name: string;
+}
+
+function formatProjectDisplay(project: ProjectDisplayInfo): string {
+	return `${project.name} (${project.id})`;
+}
+
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
 	description: 'Delete a project',
@@ -46,11 +55,37 @@ export const deleteSubcommand = createSubcommand({
 	async handler(ctx) {
 		const { args, opts, apiClient } = ctx;
 
-		let projectIds: string[] = [];
+		let projectsToDelete: ProjectDisplayInfo[] = [];
 
 		if (args.id) {
-			// Command line argument provided
-			projectIds = [args.id];
+			// Command line argument provided - validate and fetch project details
+			const projectInfo = await tui.spinner({
+				message: 'Fetching project details',
+				clearOnSuccess: true,
+				callback: async () => {
+					try {
+						const project = await projectGet(apiClient, {
+							id: args.id!,
+							mask: true,
+							keys: false,
+						});
+
+						return {
+							id: project.id,
+							name: project.name,
+						};
+					} catch {
+						return null;
+					}
+				},
+			});
+
+			if (!projectInfo) {
+				tui.error(`Project not found: ${args.id}`);
+				return { success: false, projectIds: [], count: 0 };
+			}
+
+			projectsToDelete = [projectInfo];
 		} else {
 			// Check TTY before attempting to prompt
 			if (!process.stdin.isTTY) {
@@ -87,10 +122,16 @@ export const deleteSubcommand = createSubcommand({
 				choices,
 			});
 
-			projectIds = response.projects;
+			// Map selected IDs to full project info
+			projectsToDelete = response.projects
+				.map((id) => {
+					const project = projects.find((p) => p.id === id);
+					return project ? { id: project.id, name: project.name } : null;
+				})
+				.filter((p): p is ProjectDisplayInfo => p !== null);
 		}
 
-		if (projectIds.length === 0) {
+		if (projectsToDelete.length === 0) {
 			tui.info('No projects selected for deletion');
 			return { success: false, projectIds: [], count: 0 };
 		}
@@ -103,13 +144,16 @@ export const deleteSubcommand = createSubcommand({
 
 		// Confirm deletion
 		if (!skipConfirm) {
-			const projectNames = projectIds.join(', ');
-			tui.warning(`You are about to delete: ${tui.bold(projectNames)}`);
+			const projectDisplay =
+				projectsToDelete.length === 1
+					? formatProjectDisplay(projectsToDelete[0])
+					: projectsToDelete.map((p) => `\n  • ${formatProjectDisplay(p)}`).join('');
+			tui.warning(`You are about to delete: ${tui.bold(projectDisplay)}`);
 
 			const confirm = await enquirer.prompt<{ confirm: boolean }>({
 				type: 'confirm',
 				name: 'confirm',
-				message: `Are you sure you want to delete ${projectIds.length > 1 ? 'these projects' : 'this project'}?`,
+				message: `Are you sure you want to delete ${projectsToDelete.length > 1 ? 'these projects' : 'this project'}?`,
 				initial: false,
 			});
 
@@ -119,8 +163,9 @@ export const deleteSubcommand = createSubcommand({
 			}
 		}
 
+		const projectIds = projectsToDelete.map((p) => p.id);
 		const deleted = await tui.spinner({
-			message: `Deleting ${projectIds.length} project(s)`,
+			message: `Deleting ${projectsToDelete.length} project(s)`,
 			clearOnSuccess: true,
 			callback: async () => {
 				return projectDelete(apiClient, ...projectIds);

package/src/cmd/setup/index.ts

@@ -41,7 +41,10 @@ export const command = createCommand({
 							// Use process.execPath which has the actual binary path
 							const isCompiledBinary = process.argv[1]?.startsWith('/$bunfs/');
 							const cmd = isCompiledBinary
-								? [process.execPath, ...process.argv.slice(2).map((x) => (x === 'setup' ? 'login' : x))]
+								? [
+										process.execPath,
+										...process.argv.slice(2).map((x) => (x === 'setup' ? 'login' : x)),
+									]
 								: process.argv.map((x) => (x === 'setup' ? 'login' : x));
 							const r = Bun.spawn({
 								cmd: cmd.concat('--json'),

package/src/env-util.ts

@@ -17,7 +17,10 @@ export const PUBLIC_VAR_PREFIXES = ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'] as
  * Specific AGENTUITY_ keys that are allowed to be set by users.
  * Note: There is also a whitelist in the API that must be kept in sync.
  */
-export const AGENTUITY_ALLOWED_KEYS = ['AGENTUITY_AUTH_SECRET', 'AGENTUITY_CLOUD_BASE_URL'] as const;
+export const AGENTUITY_ALLOWED_KEYS = [
+	'AGENTUITY_AUTH_SECRET',
+	'AGENTUITY_CLOUD_BASE_URL',
+] as const;
 
 /**
  * Check if a key is a public variable (exposed to frontend)

package/src/schema-parser.ts

@@ -254,10 +254,119 @@ export function parseOptionsSchema(schema: ZodType): ParsedOption[] {
 	return options;
 }
 
+// Cache for stdin confirmation detection
+let stdinConfirmationChecked = false;
+let stdinConfirmation: boolean | null = null;
+
+/**
+ * Check if stdin contains a piped "yes" confirmation.
+ * This allows commands to be run with `echo "yes" | agentuity <command>` pattern.
+ * Only works when stdin is not a TTY (piped input) and command doesn't use stdin.
+ */
+async function checkStdinConfirmation(): Promise<boolean> {
+	if (stdinConfirmationChecked) {
+		return stdinConfirmation === true;
+	}
+	stdinConfirmationChecked = true;
+
+	// Only check if stdin is not a TTY (meaning input is piped)
+	if (process.stdin.isTTY) {
+		stdinConfirmation = null;
+		return false;
+	}
+
+	try {
+		// Read stdin with a short timeout to avoid blocking
+		const reader = process.stdin;
+		let timeoutId: ReturnType<typeof setTimeout> | null = null;
+		let resolved = false;
+		const MAX_BYTES = 4096;
+
+		// Define handlers outside so we can remove them in all paths
+		let data = '';
+		const onData = (chunk: Buffer) => {
+			data += chunk.toString();
+			if (data.length >= MAX_BYTES) {
+				data = data.slice(0, MAX_BYTES);
+			}
+		};
+
+		let onEnd: (() => void) | null = null;
+		let onError: ((err: Error) => void) | null = null;
+
+		const cleanup = () => {
+			reader.removeListener('data', onData);
+			if (onEnd) {
+				reader.removeListener('end', onEnd);
+			}
+			if (onError) {
+				reader.removeListener('error', onError);
+			}
+			reader.pause();
+		};
+
+		const readPromise = new Promise<string>((resolve) => {
+			onEnd = () => {
+				if (resolved) return;
+				resolved = true;
+				if (timeoutId !== null) {
+					clearTimeout(timeoutId);
+					timeoutId = null;
+				}
+				cleanup();
+				resolve(data.trim().toLowerCase());
+			};
+			onError = (_err: Error) => {
+				if (resolved) return;
+				resolved = true;
+				stdinConfirmation = null;
+				if (timeoutId !== null) {
+					clearTimeout(timeoutId);
+					timeoutId = null;
+				}
+				cleanup();
+				resolve('');
+			};
+			reader.on('data', onData);
+			reader.on('end', onEnd);
+			reader.on('error', onError);
+		});
+
+		// Use a short timeout to avoid blocking
+		const timeoutPromise = new Promise<string>((resolve) => {
+			timeoutId = setTimeout(() => {
+				if (resolved) return;
+				resolved = true;
+				// Clean up listeners and pause stdin when timeout wins
+				cleanup();
+				resolve('');
+			}, 100);
+		});
+
+		const input = await Promise.race([readPromise, timeoutPromise]);
+		// Take first token/line to handle inputs like "yes\nanything"
+		const firstToken = input.split(/\s+/)[0] ?? '';
+		stdinConfirmation = firstToken === 'yes' || firstToken === 'y';
+		return stdinConfirmation;
+	} catch {
+		stdinConfirmation = null;
+		return false;
+	}
+}
+
+/**
+ * Reset stdin confirmation cache (for testing)
+ */
+export function resetStdinConfirmationCache(): void {
+	stdinConfirmationChecked = false;
+	stdinConfirmation = null;
+}
+
 export function buildValidationInput(
 	schemas: CommandSchemas,
 	rawArgs: unknown[],
-	rawOptions: Record<string, unknown>
+	rawOptions: Record<string, unknown>,
+	_options?: { usesStdin?: boolean }
 ): { args: Record<string, unknown>; options: Record<string, unknown> } {
 	const result = { args: {} as Record<string, unknown>, options: {} as Record<string, unknown> };
 
@@ -274,7 +383,13 @@ export function buildValidationInput(
 			// Only include the option if it has a value - omitting undefined allows Zod to apply defaults
 			// Commander.js converts kebab-case to camelCase, so we need to check both
 			const camelCaseName = opt.name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
-			const value = rawOptions[opt.name] ?? rawOptions[camelCaseName];
+			let value = rawOptions[opt.name] ?? rawOptions[camelCaseName];
+
+			// Handle --yes alias for --confirm: if confirm is not set but yes is, use yes value
+			if (opt.name === 'confirm' && value === undefined && rawOptions.yes === true) {
+				value = true;
+			}
+
 			if (value !== undefined) {
 				result.options[opt.name] = value;
 			}
@@ -283,3 +398,36 @@ export function buildValidationInput(
 
 	return result;
 }
+
+/**
+ * Async version of buildValidationInput that also checks stdin for "yes" confirmation.
+ * Use this when the command has a confirm option and doesn't use stdin for other purposes.
+ */
+export async function buildValidationInputAsync(
+	schemas: CommandSchemas,
+	rawArgs: unknown[],
+	rawOptions: Record<string, unknown>,
+	options?: { usesStdin?: boolean }
+): Promise<{ args: Record<string, unknown>; options: Record<string, unknown> }> {
+	const result = buildValidationInput(schemas, rawArgs, rawOptions, options);
+
+	// Check for stdin confirmation if:
+	// 1. Command has a confirm option in schema
+	// 2. Command doesn't use stdin for other purposes
+	// 3. confirm is not already set via flags
+	if (schemas.options && !options?.usesStdin) {
+		// Use getShape() instead of parseOptionsSchema() to avoid re-evaluating function defaults
+		const shape = getShape(schemas.options);
+		const hasConfirmOption = Object.prototype.hasOwnProperty.call(shape, 'confirm');
+		const confirmValue = result.options.confirm;
+
+		if (hasConfirmOption && confirmValue === undefined) {
+			const stdinConfirmed = await checkStdinConfirmation();
+			if (stdinConfirmed) {
+				result.options.confirm = true;
+			}
+		}
+	}
+
+	return result;
+}

package/src/tui.ts

@@ -1172,6 +1172,11 @@ export async function spinner<T>(
 		options = messageOrOptions;
 	}
 
+	// assume true by default
+	if (options.clearOnSuccess === undefined) {
+		options.clearOnSuccess = true;
+	}
+
 	const message = options.message;
 	const reset = getColor('reset');