@agentuity/cli 0.1.41 → 0.1.43

package/src/cmd/project/reconcile.ts

@@ -217,8 +217,9 @@ async function selectRegion(regions: RegionList, defaultRegion?: string): Promis
 		throw new Error('No cloud regions available');
 	}
 
-	if (regions.length === 1) {
-		return regions[0].region;
+	const firstRegion = regions[0];
+	if (regions.length === 1 && firstRegion) {
+		return firstRegion.region;
 	}
 
 	// Build options from API regions
@@ -228,18 +229,21 @@ async function selectRegion(regions: RegionList, defaultRegion?: string): Promis
 	}));
 
 	// Move default to top if found
-	const defaultValue = defaultRegion ?? regions[0].region;
+	const defaultValue = defaultRegion ?? firstRegion?.region ?? '';
 	const defaultIndex = options.findIndex((r) => r.value === defaultValue);
 	if (defaultIndex > 0) {
 		const [defaultItem] = options.splice(defaultIndex, 1);
-		options.unshift(defaultItem);
+		if (defaultItem) {
+			options.unshift(defaultItem);
+		}
 	}
 
 	const prompt = createPrompt();
+	const firstOption = options[0];
 	return prompt.select({
 		message: 'Select a region:',
 		options,
-		initial: options[0].value,
+		initial: firstOption?.value ?? '',
 	});
 }
 

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

@@ -220,7 +220,12 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		}
 		selectedTemplate = found;
 	} else if (!isInteractive || templates.length === 1) {
-		selectedTemplate = templates[0];
+		const firstTemplate = templates[0];
+		if (!firstTemplate) {
+			logger.fatal('No templates available', ErrorCode.RESOURCE_NOT_FOUND);
+			return undefined as never;
+		}
+		selectedTemplate = firstTemplate;
 	} else {
 		let maxLength = 15;
 		templates.forEach((t) => {
@@ -572,14 +577,19 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 					return createResources(catalystClient!, orgId!, region!, [{ type: 'db' }]);
 				},
 			});
-			authDatabaseName = created[0].name;
+			const createdDb = created[0];
+			if (!createdDb) {
+				logger.fatal('Failed to create database for auth', ErrorCode.RESOURCE_NOT_FOUND);
+				return undefined as never;
+			}
+			authDatabaseName = createdDb.name;
 
 			// Get env vars from created resource
-			if (created[0]?.env) {
-				authDatabaseUrl = created[0].env.DATABASE_URL;
+			if (createdDb.env) {
+				authDatabaseUrl = createdDb.env.DATABASE_URL;
 				// Also add to resourceEnvVars if not already set
 				if (!resourceEnvVars.DATABASE_URL) {
-					Object.assign(resourceEnvVars, created[0].env);
+					Object.assign(resourceEnvVars, createdDb.env);
 				}
 			}
 		}

package/src/cmd/support/report.ts

@@ -1,13 +1,34 @@
 import { createSubcommand } from '../../types';
 import { z } from 'zod';
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join, basename } from 'node:path';
 import { tmpdir } from 'node:os';
-import { getLatestLogSession } from '../../internal-logger';
+import { getLogSessionsInCurrentWindow } from '../../internal-logger';
 import * as tui from '../../tui';
 import { randomBytes } from 'node:crypto';
 import AdmZip from 'adm-zip';
 import { APIResponseSchema } from '@agentuity/server';
+import { StructuredError } from '@agentuity/core';
+
+// Structured errors for this module
+const NoSessionDirectoriesError = StructuredError(
+	'NoSessionDirectoriesError',
+	'No session directories provided'
+);
+
+const ReportUploadError = StructuredError('ReportUploadError')<{
+	statusText: string;
+	status?: number;
+}>();
+
+const UploadUrlCreationError = StructuredError('UploadUrlCreationError');
+
+const BrowserOpenError = StructuredError(
+	'BrowserOpenError',
+	'Failed to open browser. Please open the URL manually.'
+)<{
+	exitCode?: number | null;
+}>();
 
 const argsSchema = z.object({});
 
@@ -33,22 +54,34 @@ const ReportUploadDataSchema = z.object({
 const ReportUploadResponseSchema = APIResponseSchema(ReportUploadDataSchema);
 
 /**
- * Create a zip file containing session and logs
+ * Create a zip file containing session and logs from multiple session directories
  */
-async function createReportZip(sessionDir: string): Promise<string> {
-	const sessionFile = join(sessionDir, 'session.json');
-	const logsFile = join(sessionDir, 'logs.jsonl');
-
-	if (!existsSync(sessionFile) || !existsSync(logsFile)) {
-		throw new Error('Session files not found');
+async function createReportZip(sessionDirs: string[]): Promise<string> {
+	if (sessionDirs.length === 0) {
+		throw NoSessionDirectoriesError();
 	}
 
 	// Create zip in temp directory
 	const tempZip = join(tmpdir(), `agentuity-report-${randomBytes(8).toString('hex')}.zip`);
 
 	const zip = new AdmZip();
-	zip.addLocalFile(sessionFile);
-	zip.addLocalFile(logsFile);
+
+	for (const sessionDir of sessionDirs) {
+		const sessionFile = join(sessionDir, 'session.json');
+		const logsFile = join(sessionDir, 'logs.jsonl');
+
+		// Extract session ID from directory name cross-platform
+		const sessionId = basename(sessionDir) || 'unknown';
+
+		// Add files with session ID prefix to avoid conflicts
+		if (await Bun.file(sessionFile).exists()) {
+			zip.addLocalFile(sessionFile, sessionId);
+		}
+		if (await Bun.file(logsFile).exists()) {
+			zip.addLocalFile(logsFile, sessionId);
+		}
+	}
+
 	zip.writeZip(tempZip);
 
 	return tempZip;
@@ -76,7 +109,11 @@ async function uploadReport(
 	if (!response.ok) {
 		const errorText = await response.text();
 		logger.error('Upload failed', { status: response.status, error: errorText });
-		throw new Error(`Upload failed: ${response.statusText}`);
+		throw new ReportUploadError({
+			message: `Upload failed: ${response.statusText}`,
+			statusText: response.statusText,
+			status: response.status,
+		});
 	}
 }
 
@@ -161,11 +198,11 @@ async function openBrowser(url: string, logger: import('../../types').Logger): P
 		await proc.exited;
 
 		if (proc.exitCode !== 0) {
-			throw new Error(`Browser process exited with code ${proc.exitCode}`);
+			throw new BrowserOpenError({ exitCode: proc.exitCode });
 		}
 	} catch (error) {
 		logger.error('Failed to open browser', { error });
-		throw new Error('Failed to open browser. Please open the URL manually.');
+		throw new BrowserOpenError({ exitCode: null, cause: error });
 	}
 }
 
@@ -184,9 +221,9 @@ export default createSubcommand({
 		const { opts, logger, apiClient } = ctx;
 		const isJsonMode = ctx.options.json;
 
-		// Get the latest log session
-		const sessionDir = getLatestLogSession();
-		if (!sessionDir) {
+		// Get all log sessions in the current time window (current + previous bucket)
+		const sessionDirs = getLogSessionsInCurrentWindow();
+		if (sessionDirs.length === 0) {
 			if (isJsonMode) {
 				console.log(JSON.stringify({ success: false, error: 'No CLI logs found' }));
 			} else {
@@ -196,10 +233,27 @@ export default createSubcommand({
 			return;
 		}
 
-		// Read session data to get CLI version
-		const sessionFile = join(sessionDir, 'session.json');
-		const sessionData = JSON.parse(readFileSync(sessionFile, 'utf-8'));
-		const cliVersion = sessionData.cli?.version || 'unknown';
+		// Use the first (most recent) session for metadata
+		const primarySessionDir = sessionDirs[0]!;
+		const sessionFile = join(primarySessionDir, 'session.json');
+
+		// Safely read session data with fallback for corrupt/missing session.json
+		let sessionData: SessionData = {};
+		let cliVersion = 'unknown';
+		try {
+			if (await Bun.file(sessionFile).exists()) {
+				sessionData = JSON.parse(readFileSync(sessionFile, 'utf-8'));
+				cliVersion = sessionData.cli?.version || 'unknown';
+			}
+		} catch {
+			// Fall back to defaults if session.json is corrupt or unreadable
+			logger.trace('Failed to read session.json, using defaults');
+		}
+
+		// Log how many sessions we're including
+		if (!isJsonMode && sessionDirs.length > 1) {
+			tui.info(`Found ${sessionDirs.length} session(s) in the current time window`);
+		}
 
 		// Get issue description from:
 		// 1. --description flag
@@ -281,11 +335,11 @@ export default createSubcommand({
 			// Debug: log the response
 			logger.debug('Upload response received', { uploadResponse });
 
-			if (!uploadResponse.success) {
-				const errorMsg = uploadResponse.message || 'Failed to create upload URL';
-				logger.error('Upload URL creation failed', { uploadResponse, errorMsg });
-				throw new Error(errorMsg);
-			}
+		if (!uploadResponse.success) {
+			const errorMsg = uploadResponse.message || 'Failed to create upload URL';
+			logger.error('Upload URL creation failed', { uploadResponse, errorMsg });
+			throw new UploadUrlCreationError({ message: errorMsg });
+		}
 
 			const { presigned_url, url: reportUrl, report_id: reportId } = uploadResponse.data;
 
@@ -294,7 +348,7 @@ export default createSubcommand({
 				tui.info('Creating report archive...');
 			}
 
-			const zipPath = await createReportZip(sessionDir);
+			const zipPath = await createReportZip(sessionDirs);
 
 			// Step 3: Upload to S3
 			if (!isJsonMode) {

package/src/config.ts

@@ -789,8 +789,9 @@ export async function getDefaultRegion(
 		const file = Bun.file(cachePath);
 		if (await file.exists()) {
 			const data: RegionsCacheData = await file.json();
-			if (data.regions && data.regions.length > 0) {
-				return data.regions[0].region;
+			const firstRegion = data.regions?.[0];
+			if (firstRegion) {
+				return firstRegion.region;
 			}
 		}
 	} catch {

package/src/domain.ts

@@ -79,8 +79,9 @@ async function fetchDNSRecord(name: string, type: string): Promise<string | null
 	});
 	if (res.ok) {
 		const result = (await res.json()) as CFRecord;
-		if (result?.Answer?.length) {
-			return result.Answer[0].data.replace(/\.$/, ''); // DNS records end with . so we remove that
+		const firstAnswer = result?.Answer?.[0];
+		if (firstAnswer) {
+			return firstAnswer.data.replace(/\.$/, ''); // DNS records end with . so we remove that
 		}
 	}
 	return null;
@@ -104,7 +105,7 @@ export async function checkCustomDomainForDNS(
 	config?: Config | null
 ): Promise<DNSResult[]> {
 	const suffix = config?.overrides?.api_url?.includes('agentuity.io') ? LOCAL_DNS : PRODUCTION_DNS;
-	const id = Bun.hash.xxHash64(projectId).toString(16);
+	const id = Bun.hash.xxHash64(projectId).toString(16).padStart(16, '0');
 	const proxy = `p${id}.${suffix}`;
 
 	return Promise.all(

package/src/internal-logger.ts

@@ -45,6 +45,9 @@ const SENSITIVE_ENV_PATTERNS = [
 
 interface SessionMetadata {
 	sessionId: string;
+	bucket: number;
+	pid: number;
+	ppid: number;
 	command: string;
 	args: string[];
 	timestamp: string;
@@ -107,9 +110,30 @@ function getLogsDir(): string {
 }
 
 /**
- * Clean up old log directories, keeping only the most recent one
+ * Calculate the current 5-minute bucket number
+ * Each bucket represents a 5-minute window (300000ms)
  */
-function cleanupOldLogs(currentSessionId: string): void {
+function getCurrentBucket(): number {
+	return Math.floor(Date.now() / 300000);
+}
+
+/**
+ * Parse bucket number from directory name
+ * Directory format: {bucket}-{uuid}
+ * Returns null for legacy directories (uuid-only format)
+ */
+function parseBucketFromDirName(dirName: string): number | null {
+	const match = dirName.match(/^(\d+)-/);
+	if (match && match[1]) {
+		return parseInt(match[1], 10);
+	}
+	return null;
+}
+
+/**
+ * Clean up old log directories, keeping only directories in the current bucket
+ */
+function cleanupOldLogs(currentBucket: number): void {
 	// Skip cleanup when inheriting a parent's session ID to avoid
 	// deleting the parent's session directory (race condition).
 	// This applies to forked deploy processes and any subprocess
@@ -125,19 +149,24 @@ function cleanupOldLogs(currentSessionId: string): void {
 
 	try {
 		const entries = readdirSync(logsDir, { withFileTypes: true });
-		const dirs = entries
-			.filter((e) => e.isDirectory())
-			.map((e) => e.name)
-			.filter((name) => name !== currentSessionId);
+		const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
 
-		// Remove all directories except the current one
+		// Remove directories with bucket < currentBucket (old buckets)
+		// Also remove legacy directories (no bucket prefix) for backward compatibility
 		for (const dir of dirs) {
-			const dirPath = join(logsDir, dir);
-			try {
-				rmSync(dirPath, { recursive: true, force: true });
-			} catch (err) {
-				// Ignore errors during cleanup
-				console.debug(`Failed to remove old log directory ${dir}: ${err}`);
+			const bucket = parseBucketFromDirName(dir);
+
+			// Delete if:
+			// 1. Legacy directory (no bucket prefix) - clean up old format
+			// 2. Bucket is older than current bucket
+			if (bucket === null || bucket < currentBucket) {
+				const dirPath = join(logsDir, dir);
+				try {
+					rmSync(dirPath, { recursive: true, force: true });
+				} catch (err) {
+					// Ignore errors during cleanup
+					console.debug(`Failed to remove old log directory ${dir}: ${err}`);
+				}
 			}
 		}
 	} catch (err) {
@@ -154,6 +183,7 @@ export class InternalLogger implements Logger {
 	private sessionDir: string;
 	private sessionFile: string;
 	private logsFile: string;
+	private bucket: number;
 	private initialized = false;
 	private disabled = false;
 
@@ -161,16 +191,23 @@ export class InternalLogger implements Logger {
 		private cliVersion: string,
 		private cliName: string
 	) {
+		// Calculate current 5-minute bucket
+		this.bucket = getCurrentBucket();
+
 		// When a parent session ID is set in the environment, use it to ensure
 		// all CLI invocations (parent and any subprocesses) write to the same log file.
 		// This prevents race conditions where child processes delete parent's logs.
 		const parentSessionId = process.env.AGENTUITY_INTERNAL_SESSION_ID;
 		if (parentSessionId) {
 			this.sessionId = parentSessionId;
+			// Parent session ID already includes bucket prefix, use as-is for directory name
+			this.sessionDir = join(getLogsDir(), parentSessionId);
 		} else {
-			this.sessionId = randomUUID();
+			// Generate new session ID with bucket prefix: {bucket}-{uuid}
+			const uuid = randomUUID();
+			this.sessionId = `${this.bucket}-${uuid}`;
+			this.sessionDir = join(getLogsDir(), this.sessionId);
 		}
-		this.sessionDir = join(getLogsDir(), this.sessionId);
 		this.sessionFile = join(this.sessionDir, 'session.json');
 		this.logsFile = join(this.sessionDir, 'logs.jsonl');
 	}
@@ -189,9 +226,9 @@ export class InternalLogger implements Logger {
 			// Create logs directory (may already exist if we're a child process)
 			mkdirSync(this.sessionDir, { recursive: true, mode: 0o700 });
 
-			// Clean up old logs (keep only this session)
+			// Clean up old logs (directories with bucket < current bucket)
 			// This is skipped for child processes to avoid deleting parent's session
-			cleanupOldLogs(this.sessionId);
+			cleanupOldLogs(this.bucket);
 
 			// When inheriting a parent's session ID, skip session.json creation
 			// (parent already created it) but enable logging
@@ -232,6 +269,9 @@ export class InternalLogger implements Logger {
 			// Gather session metadata
 			const sessionMetadata: SessionMetadata = {
 				sessionId: this.sessionId,
+				bucket: this.bucket,
+				pid: process.pid,
+				ppid: process.ppid,
 				command,
 				args,
 				timestamp: new Date().toISOString(),
@@ -422,29 +462,54 @@ export function createInternalLogger(cliVersion: string, cliName: string): Inter
 }
 
 /**
- * Get the latest log session directory (if any)
+ * Get all log session directories in the current time window
+ * Returns directories from current bucket AND previous bucket (to handle boundary cases)
  */
-export function getLatestLogSession(): string | null {
+export function getLogSessionsInCurrentWindow(): string[] {
 	const logsDir = getLogsDir();
 	if (!existsSync(logsDir)) {
-		return null;
+		return [];
 	}
 
 	try {
+		const currentBucket = getCurrentBucket();
+		const previousBucket = currentBucket - 1;
+
 		const entries = readdirSync(logsDir, { withFileTypes: true });
 		const dirs = entries.filter((e) => e.isDirectory()).map((e) => e.name);
 
-		if (dirs.length === 0) {
-			return null;
-		}
+		// Filter to directories in current or previous bucket
+		const validDirs = dirs.filter((dir) => {
+			const bucket = parseBucketFromDirName(dir);
+			// Include current bucket, previous bucket, and legacy directories (for backward compat)
+			return bucket === currentBucket || bucket === previousBucket || bucket === null;
+		});
+
+		// Sort by bucket (descending) then by name to get most recent first
+		validDirs.sort((a, b) => {
+			const bucketA = parseBucketFromDirName(a) ?? 0;
+			const bucketB = parseBucketFromDirName(b) ?? 0;
+			if (bucketA !== bucketB) {
+				return bucketB - bucketA; // Higher bucket first
+			}
+			return b.localeCompare(a); // Then by name descending
+		});
 
-		// Return the first directory (should be the only one due to cleanup)
-		return join(logsDir, dirs[0]);
+		return validDirs.map((dir) => join(logsDir, dir));
 	} catch {
-		return null;
+		return [];
 	}
 }
 
+/**
+ * Get the latest log session directory (if any)
+ * For backward compatibility, returns the first session in the current window
+ */
+export function getLatestLogSession(): string | null {
+	const sessions = getLogSessionsInCurrentWindow();
+	return sessions[0] ?? null;
+}
+
 /**
  * Get the logs directory path (exported for external use)
  */

package/src/repl.ts

@@ -184,6 +184,7 @@ function parseCommandLine(line: string): ParsedCommand {
 	// Parse remaining tokens into args and options
 	for (let i = 1; i < tokens.length; i++) {
 		const token = tokens[i];
+		if (token === undefined) continue;
 
 		if (token.startsWith('--')) {
 			// Long option: --name=value or --flag
@@ -194,8 +195,9 @@ function parseCommandLine(line: string): ParsedCommand {
 				options[name.slice(0, eqIndex)] = name.slice(eqIndex + 1);
 			} else {
 				// Check if next token is a value
-				if (i + 1 < tokens.length && !tokens[i + 1].startsWith('-')) {
-					options[name] = tokens[i + 1];
+				const nextToken = tokens[i + 1];
+				if (i + 1 < tokens.length && nextToken !== undefined && !nextToken.startsWith('-')) {
+					options[name] = nextToken;
 					i++;
 				} else {
 					options[name] = true;
@@ -206,8 +208,9 @@ function parseCommandLine(line: string): ParsedCommand {
 			const name = token.slice(1);
 
 			// Check if next token is a value
-			if (i + 1 < tokens.length && !tokens[i + 1].startsWith('-')) {
-				options[name] = tokens[i + 1];
+			const nextToken = tokens[i + 1];
+			if (i + 1 < tokens.length && nextToken !== undefined && !nextToken.startsWith('-')) {
+				options[name] = nextToken;
 				i++;
 			} else {
 				options[name] = true;
@@ -603,7 +606,7 @@ function getAutocompleteMatches(
 	if (!buffer.trim()) return [];
 
 	const tokens = buffer.trim().split(/\s+/);
-	const firstToken = tokens[0].toLowerCase();
+	const firstToken = tokens[0]?.toLowerCase() ?? '';
 
 	// If we're typing the first word (no trailing space), suggest commands
 	if (tokens.length === 1 && buffer === buffer.trimEnd()) {
@@ -623,7 +626,7 @@ function getAutocompleteMatches(
 	if (tokens.length === 2 && buffer === buffer.trimEnd() && commandMap) {
 		const cmd = commandMap.get(firstToken);
 		if (cmd?.subcommands) {
-			const subToken = tokens[1].toLowerCase();
+			const subToken = tokens[1]?.toLowerCase() ?? '';
 			return cmd.subcommands
 				.filter((sub) => sub.name.startsWith(subToken) && sub.name !== subToken)
 				.map((sub) => sub.name);
@@ -647,8 +650,10 @@ function getAutocompleteSuggestion(
 	if (matches.length === 0) return '';
 
 	const selectedMatch = matches[cycleIndex % matches.length];
+	if (selectedMatch === undefined) return '';
+
 	const tokens = buffer.trim().split(/\s+/);
-	const firstToken = tokens[0].toLowerCase();
+	const firstToken = tokens[0]?.toLowerCase() ?? '';
 
 	// Typing first word (command name)
 	if (tokens.length === 1 && buffer === buffer.trimEnd()) {
@@ -675,7 +680,7 @@ function getAutocompleteSuggestion(
 	// Typing subcommand name
 	if (tokens.length === 2 && buffer === buffer.trimEnd()) {
 		const cmd = commandMap.get(firstToken);
-		const subToken = tokens[1];
+		const subToken = tokens[1] ?? '';
 		const subcommand = cmd?.subcommands?.find((sub) => sub.name === selectedMatch);
 
 		let suggestion = selectedMatch.slice(subToken.length);
@@ -791,7 +796,7 @@ class ActivityIndicator {
 	}
 
 	private draw() {
-		const frame = this.frames[this.currentFrame];
+		const frame = this.frames[this.currentFrame] ?? this.frames[0] ?? '⠋';
 		// Clear line, draw spinner, stay on same line
 		process.stdout.write('\r\x1b[K'); // Clear line from cursor
 		process.stdout.write(`${tui.muted(frame)} ${tui.muted(this.message)}...`);
@@ -855,6 +860,7 @@ async function showCommandPicker(
 		// Draw commands
 		for (let i = 0; i < commands.length; i++) {
 			const cmd = commands[i];
+			if (cmd === undefined) continue;
 			const isSelected = i === selectedIndex;
 			const prefix = isSelected ? '▶ ' : '  ';
 			const style = isSelected ? '\x1b[7m' : ''; // Reverse video for selected
@@ -913,7 +919,11 @@ async function showCommandPicker(
 				const selected = commands[selectedIndex];
 				cleanup();
 				clearPicker();
-				resolve(selected.name + (selected.argHint ? ' ' : ''));
+				if (selected) {
+					resolve(selected.name + (selected.argHint ? ' ' : ''));
+				} else {
+					resolve(null);
+				}
 				return;
 			}
 
@@ -957,6 +967,7 @@ function applySyntaxHighlighting(buffer: string, commands: string[]): string {
 
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
+		if (token === undefined) continue;
 
 		// Skip whitespace
 		if (/^\s+$/.test(token)) {
@@ -1018,7 +1029,8 @@ async function readLine(
 
 		const searchHistory = (query: string, startFrom: number): number => {
 			for (let i = startFrom - 1; i >= 0; i--) {
-				if (history[i].toLowerCase().includes(query.toLowerCase())) {
+				const historyEntry = history[i];
+				if (historyEntry !== undefined && historyEntry.toLowerCase().includes(query.toLowerCase())) {
 					return i;
 				}
 			}
@@ -1057,7 +1069,8 @@ async function readLine(
 				}
 				const linePrompt = currentLineIndex === 0 ? prompt : '... ';
 				process.stdout.write('\r');
-				process.stdout.write(linePrompt + lines[currentLineIndex].slice(0, cursorPos));
+				const currentLine = lines[currentLineIndex] ?? '';
+				process.stdout.write(linePrompt + currentLine.slice(0, cursorPos));
 			} else {
 				// Single-line mode (original behavior)
 				process.stdout.write('\r\x1b[K');
@@ -1282,7 +1295,7 @@ async function readLine(
 				lines.push('');
 				currentLineIndex++;
 				cursorPos = 0;
-				buffer = lines[currentLineIndex];
+				buffer = lines[currentLineIndex] ?? '';
 				process.stdout.write('\n');
 				process.stdout.write('... ');
 				return;
@@ -1293,7 +1306,7 @@ async function readLine(
 				if (searchMode) {
 					// Accept search result
 					if (searchResultIndex >= 0) {
-						buffer = history[searchResultIndex];
+						buffer = history[searchResultIndex] ?? '';
 					}
 					searchMode = false;
 					process.stdout.write('\n');

package/src/schema-parser.ts

@@ -373,7 +373,10 @@ export function buildValidationInput(
 	if (schemas.args) {
 		const parsed = parseArgsSchema(schemas.args);
 		for (let i = 0; i < parsed.names.length; i++) {
-			result.args[parsed.names[i]] = rawArgs[i];
+			const name = parsed.names[i];
+			if (name !== undefined) {
+				result.args[name] = rawArgs[i];
+			}
 		}
 	}
 

package/src/sound.ts

@@ -17,7 +17,8 @@ export function playSound(): void {
 			return;
 	}
 
-	if (process.stdout.isTTY && Bun.which(command[0])) {
+	const executable = command[0];
+	if (process.stdout.isTTY && executable && Bun.which(executable)) {
 		try {
 			Bun.spawn(command, {
 				stdio: ['ignore', 'ignore', 'ignore'],