@agentuity/cli 0.1.23 → 0.1.25

package/src/cmd/cloud/sandbox/snapshot/build.ts

@@ -138,7 +138,8 @@ function parseKeyValueArgs(args: string[] | undefined): Record<string, string> {
 
 function substituteVariables(
 	values: Record<string, string>,
-	variables: Record<string, string>
+	variables: Record<string, string>,
+	flagName: 'env' | 'metadata'
 ): Record<string, string> {
 	const result: Record<string, string> = {};
 	const varPattern = /\$\{([^}]+)\}/g;
@@ -152,7 +153,7 @@ function substituteVariables(
 			const varName = match[1];
 			if (!(varName in variables)) {
 				throw new Error(
-					`Variable "\${${varName}}" in "${key}" is not defined. Use --env ${varName}=value to provide it.`
+					`Variable "\${${varName}}" in "${key}" is not defined. Use --${flagName} ${varName}=value to provide it.`
 				);
 			}
 			substituted = substituted.replace(match[0], variables[varName]);
@@ -163,12 +164,15 @@ function substituteVariables(
 	return result;
 }
 
+// Default patterns that are always excluded from snapshot builds
+const DEFAULT_EXCLUSIONS = ['.git/**', 'node_modules/**', '.agentuity/**', '.env*'];
+
 async function resolveFileGlobs(
 	directory: string,
 	patterns: string[]
 ): Promise<Map<string, FileEntry>> {
 	const files = new Map<string, FileEntry>();
-	const exclusions: string[] = [];
+	const exclusions: string[] = [...DEFAULT_EXCLUSIONS];
 	const inclusions: string[] = [];
 
 	for (const pattern of patterns) {
@@ -200,15 +204,19 @@ async function resolveFileGlobs(
 	}
 
 	for (let pattern of exclusions) {
-		// If the pattern refers to a directory, auto-append /** to exclude all contents
-		const patternPath = join(directory, pattern);
-		try {
-			const stat = statSync(patternPath);
-			if (stat.isDirectory()) {
-				pattern = pattern.endsWith('/') ? `${pattern}**` : `${pattern}/**`;
+		// If pattern already contains glob wildcards, use it as-is
+		// Otherwise, check if it refers to a directory and auto-append /** to exclude all contents
+		const hasGlobChars = /[*?[\]]/.test(pattern);
+		if (!hasGlobChars) {
+			const patternPath = join(directory, pattern);
+			try {
+				const stat = statSync(patternPath);
+				if (stat.isDirectory()) {
+					pattern = pattern.endsWith('/') ? `${pattern}**` : `${pattern}/**`;
+				}
+			} catch {
+				// Path doesn't exist or can't be stat'd, use pattern as-is
 			}
-		} catch {
-			// Path doesn't exist or can't be stat'd, use pattern as-is
 		}
 
 		const glob = new Bun.Glob(pattern);
@@ -379,37 +387,6 @@ export const buildSubcommand = createCommand({
 		const { args, opts, options, auth, region, config, logger, orgId } = ctx;
 
 		const dryRun = options.dryRun === true;
-		const isPublic = opts.public === true;
-
-		if (isPublic && !dryRun) {
-			if (!opts.confirm) {
-				if (!tui.isTTYLike()) {
-					logger.fatal(
-						`Publishing a public snapshot requires confirmation.\n\n` +
-							`Public snapshots make all environment variables and files publicly accessible.\n\n` +
-							`To proceed, add the --confirm flag:\n` +
-							`  ${getCommand('cloud sandbox snapshot build . --public --confirm')}\n\n` +
-							`To preview what will be published, use --dry-run first:\n` +
-							`  ${getCommand('cloud sandbox snapshot build . --public --dry-run')}`
-					);
-				}
-
-				tui.warningBox(
-					'Public Snapshot',
-					`You are publishing a public snapshot.\n\n` +
-						`This will make all environment variables and\n` +
-						`files in the snapshot publicly accessible.\n\n` +
-						`Run with --dry-run to preview the contents.`
-				);
-				console.log('');
-
-				const confirmed = await tui.confirm('Proceed with public snapshot?', false);
-
-				if (!confirmed) {
-					logger.fatal('Aborted');
-				}
-			}
-		}
 
 		const directory = resolve(args.directory);
 		if (!existsSync(directory)) {
@@ -470,6 +447,40 @@ export const buildSubcommand = createCommand({
 
 		const buildConfig = validationResult.data;
 
+		// Determine if snapshot is public: CLI flag takes precedence, otherwise use build file
+		const isPublic =
+			opts.public === true || (opts.public === undefined && buildConfig.public === true);
+
+		if (isPublic && !dryRun) {
+			if (!opts.confirm) {
+				if (!tui.isTTYLike()) {
+					logger.fatal(
+						`Publishing a public snapshot requires confirmation.\n\n` +
+							`Public snapshots make all environment variables and files publicly accessible.\n\n` +
+							`To proceed, add the --confirm flag:\n` +
+							`  ${getCommand('cloud sandbox snapshot build . --public --confirm')}\n\n` +
+							`To preview what will be published, use --dry-run first:\n` +
+							`  ${getCommand('cloud sandbox snapshot build . --public --dry-run')}`
+					);
+				}
+
+				tui.warningBox(
+					'Public Snapshot',
+					`You are publishing a public snapshot.\n\n` +
+						`This will make all environment variables and\n` +
+						`files in the snapshot publicly accessible.\n\n` +
+						`Run with --dry-run to preview the contents.`
+				);
+				console.log('');
+
+				const confirmed = await tui.confirm('Proceed with public snapshot?', false);
+
+				if (!confirmed) {
+					logger.fatal('Aborted');
+				}
+			}
+		}
+
 		if (opts.tag) {
 			if (opts.tag.length > MAX_SNAPSHOT_TAG_LENGTH) {
 				logger.fatal(
@@ -502,10 +513,14 @@ export const buildSubcommand = createCommand({
 
 		try {
 			if (buildConfig.env) {
-				finalEnv = substituteVariables(buildConfig.env, envSubstitutions);
+				finalEnv = substituteVariables(buildConfig.env, envSubstitutions, 'env');
 			}
 			if (buildConfig.metadata) {
-				finalMetadata = substituteVariables(buildConfig.metadata, metadataSubstitutions);
+				finalMetadata = substituteVariables(
+					buildConfig.metadata,
+					metadataSubstitutions,
+					'metadata'
+				);
 			}
 		} catch (err) {
 			logger.fatal(err instanceof Error ? err.message : String(err));
@@ -811,7 +826,11 @@ export const buildSubcommand = createCommand({
 						clearOnError: true,
 						callback: async (updateProgress) => {
 							const uploadFile = Bun.file(uploadPath);
-							const progressStream = createProgressStream(uploadFile, uploadSize, updateProgress);
+							const progressStream = createProgressStream(
+								uploadFile,
+								uploadSize,
+								updateProgress
+							);
 							await snapshotUpload(client, {
 								snapshotId: initResult.snapshotId!,
 								body: progressStream,

package/src/cmd/cloud/sandbox/snapshot/create.ts

@@ -55,7 +55,11 @@ export const createSubcommand = createCommand({
 				.describe('Display name for the snapshot (letters, numbers, underscores, dashes only)'),
 			description: z.string().optional().describe('Description of the snapshot'),
 			tag: z.string().optional().describe('Tag for the snapshot (defaults to "latest")'),
-			public: z.boolean().optional().default(false).describe('Make the snapshot publicly accessible'),
+			public: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('Make the snapshot publicly accessible'),
 		}),
 		response: SnapshotCreateResponseSchema,
 	},

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

@@ -58,11 +58,13 @@ export const uploadSubcommand = createCommand({
 		const content = readFileSync(args.archive);
 		const bytes = content.length;
 
+		const format = opts.format ?? detectFormat(args.archive);
+
 		await sandboxUploadArchive(client, {
 			sandboxId: args.sandboxId,
 			archive: content,
 			path: opts.path || '.',
-			format: opts.format || '',
+			format,
 			orgId,
 		});
 
@@ -81,4 +83,10 @@ function formatSize(bytes: number): string {
 	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
 }
 
+function detectFormat(filename: string): 'zip' | 'tar.gz' {
+	const lower = filename.toLowerCase();
+	if (lower.endsWith('.zip')) return 'zip';
+	return 'tar.gz';
+}
+
 export default uploadSubcommand;

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

@@ -13,7 +13,7 @@ export const uploadSubcommand = createSubcommand({
 	name: 'upload',
 	aliases: ['put'],
 	description: 'Upload a file to storage bucket',
-	tags: ['write', 'requires-auth'],
+	tags: ['write', 'requires-auth', 'uses-stdin'],
 	requires: { auth: true },
 	optional: { org: true },
 	idempotent: false,

package/src/cmd/cloud/vector/stats.ts

@@ -22,7 +22,9 @@ const VectorNamespaceStatsSchema = z.object({
 });
 
 const VectorStatsPaginatedSchema = z.object({
-	namespaces: z.record(z.string(), VectorNamespaceStatsSchema).describe('Map of namespace names to their statistics'),
+	namespaces: z
+		.record(z.string(), VectorNamespaceStatsSchema)
+		.describe('Map of namespace names to their statistics'),
 	total: z.number().describe('Total number of namespaces across all pages'),
 	limit: z.number().describe('Number of namespaces requested per page'),
 	offset: z.number().describe('Number of namespaces skipped'),

package/src/cmd/cloud/vector/upsert.ts

@@ -24,7 +24,7 @@ export const upsertSubcommand = createCommand({
 	name: 'upsert',
 	aliases: ['put', 'add'],
 	description: 'Add or update vectors in the vector storage',
-	tags: ['mutating', 'updates-resource', 'slow', 'requires-auth'],
+	tags: ['mutating', 'updates-resource', 'slow', 'requires-auth', 'uses-stdin'],
 	idempotent: true,
 	requires: { auth: true, region: true },
 	optional: { project: true },

package/src/cmd/profile/create.ts

@@ -24,9 +24,9 @@ export const createCommand = createSubcommand({
 	aliases: ['new'],
 	idempotent: false,
 	examples: [
-		{ command: getCommand('profile create production'), description: 'Create new item' },
+		{ command: getCommand('profile create production'), description: 'Create new profile' },
 		{ command: getCommand('profile create staging --switch'), description: 'Use switch option' },
-		{ command: getCommand('profile create development'), description: 'Create new item' },
+		{ command: getCommand('profile create development'), description: 'Create new profile' },
 	],
 	schema: {
 		args: z

package/src/cmd/project/create.ts

@@ -27,11 +27,14 @@ export const createProjectSubcommand = createSubcommand({
 	idempotent: false,
 	optional: { auth: true, region: true, apiClient: true },
 	examples: [
-		{ command: getCommand('project create'), description: 'Create new item' },
-		{ command: getCommand('project create --name my-ai-agent'), description: 'Create new item' },
+		{ command: getCommand('project create'), description: 'Create new project' },
+		{
+			command: getCommand('project create --name my-ai-agent'),
+			description: 'Create new project',
+		},
 		{
 			command: getCommand('project create --name customer-service-bot --dir ~/projects/agent'),
-			description: 'Create new item',
+			description: 'Create new project',
 		},
 		{
 			command: getCommand('project create --template basic --no-install'),

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');
 

package/src/utils/deps.ts

@@ -0,0 +1,54 @@
+import { $ } from 'bun';
+import type { Logger } from '../types';
+
+export interface PackageRef {
+	name: string;
+	version: string;
+}
+
+export async function extractDependencies(
+	projectDir: string,
+	logger: Logger
+): Promise<PackageRef[]> {
+	try {
+		logger.debug('Extracting dependencies using bun pm ls --all');
+
+		const result = await $`bun pm ls --all`.cwd(projectDir).quiet().nothrow();
+
+		if (result.exitCode !== 0) {
+			logger.warn(
+				'Failed to extract dependencies: bun pm ls exited with code %d',
+				result.exitCode
+			);
+			return [];
+		}
+
+		const output = result.stdout.toString();
+		const packages = parseBunPmLsOutput(output);
+
+		logger.debug('Extracted %d unique packages', packages.length);
+		return packages;
+	} catch (error) {
+		logger.warn('Failed to extract dependencies: %s', error);
+		return [];
+	}
+}
+
+export function parseBunPmLsOutput(output: string): PackageRef[] {
+	const packages = new Map<string, PackageRef>();
+	const lines = output.split('\n');
+
+	for (const line of lines) {
+		const match = line.match(/([^\s]+)@(\d+\.\d+\.\d+[^\s]*)/);
+		if (match) {
+			const name = match[1];
+			const version = match[2];
+			const key = `${name}@${version}`;
+			if (!packages.has(key)) {
+				packages.set(key, { name, version });
+			}
+		}
+	}
+
+	return Array.from(packages.values());
+}