@agentuity/cli 0.1.42 → 0.1.44

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/cmd/upgrade/index.ts

@@ -185,6 +185,31 @@ export const command = createCommand({
 				};
 			}
 
+			// Verify the version is available on npm before proceeding
+			const isAvailable = await tui.spinner({
+				message: 'Verifying npm availability...',
+				clearOnSuccess: true,
+				callback: async () => {
+					const { waitForNpmAvailability } = await import('./npm-availability');
+					return await waitForNpmAvailability(latestVersion, {
+						maxAttempts: 6,
+						initialDelayMs: 2000,
+					});
+				},
+			});
+
+			if (!isAvailable) {
+				tui.warning('The new version is not yet available on npm.');
+				tui.info('This can happen right after a release. Please try again in a few minutes.');
+				tui.info(`You can also run: ${tui.muted('bun add -g @agentuity/cli@latest')}`);
+				return {
+					upgraded: false,
+					from: currentVersion,
+					to: latestVersion,
+					message: 'Version not yet available on npm',
+				};
+			}
+
 			// Show version info
 			if (!force) {
 				tui.info(`Current version: ${tui.muted(normalizedCurrent)}`);

package/src/cmd/upgrade/npm-availability.ts

@@ -0,0 +1,105 @@
+/**
+ * npm registry availability checking utilities.
+ * Used to verify a version is available on npm before attempting upgrade.
+ */
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const PACKAGE_NAME = '@agentuity/cli';
+
+/** Default timeout for quick checks (implicit version check) */
+const QUICK_CHECK_TIMEOUT_MS = 1000;
+
+/** Default timeout for explicit upgrade command */
+const EXPLICIT_CHECK_TIMEOUT_MS = 5000;
+
+export interface CheckNpmOptions {
+	/** Timeout in milliseconds (default: 5000 for explicit, 1000 for quick) */
+	timeoutMs?: number;
+}
+
+/**
+ * Check if a specific version of @agentuity/cli is available on npm registry.
+ * Uses the npm registry API directly for faster response than `npm view`.
+ *
+ * @param version - Version to check (with or without 'v' prefix)
+ * @param options - Optional configuration
+ * @returns true if version is available, false otherwise
+ */
+export async function isVersionAvailableOnNpm(
+	version: string,
+	options: CheckNpmOptions = {}
+): Promise<boolean> {
+	const { timeoutMs = EXPLICIT_CHECK_TIMEOUT_MS } = options;
+	const normalizedVersion = version.replace(/^v/, '');
+	const url = `${NPM_REGISTRY_URL}/${encodeURIComponent(PACKAGE_NAME)}/${normalizedVersion}`;
+
+	try {
+		const response = await fetch(url, {
+			method: 'HEAD', // Only need to check existence, not full metadata
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: {
+				Accept: 'application/json',
+			},
+		});
+		return response.ok;
+	} catch {
+		// Network error or timeout - assume not available
+		return false;
+	}
+}
+
+/**
+ * Quick check if a version is available on npm with a short timeout.
+ * Used for implicit version checks (auto-upgrade flow) to avoid blocking the user's command.
+ *
+ * @param version - Version to check (with or without 'v' prefix)
+ * @returns true if version is available, false if unavailable or timeout
+ */
+export async function isVersionAvailableOnNpmQuick(version: string): Promise<boolean> {
+	return isVersionAvailableOnNpm(version, { timeoutMs: QUICK_CHECK_TIMEOUT_MS });
+}
+
+export interface WaitForNpmOptions {
+	/** Maximum number of attempts (default: 6) */
+	maxAttempts?: number;
+	/** Initial delay between attempts in ms (default: 2000) */
+	initialDelayMs?: number;
+	/** Maximum delay between attempts in ms (default: 10000) */
+	maxDelayMs?: number;
+	/** Callback called before each retry */
+	onRetry?: (attempt: number, delayMs: number) => void;
+}
+
+/**
+ * Wait for a version to become available on npm with exponential backoff.
+ *
+ * @param version - Version to wait for (with or without 'v' prefix)
+ * @param options - Configuration options
+ * @returns true if version became available, false if timed out
+ */
+export async function waitForNpmAvailability(
+	version: string,
+	options: WaitForNpmOptions = {}
+): Promise<boolean> {
+	const { maxAttempts = 6, initialDelayMs = 2000, maxDelayMs = 10000, onRetry } = options;
+
+	// First check - no delay
+	if (await isVersionAvailableOnNpm(version)) {
+		return true;
+	}
+
+	// Retry with exponential backoff
+	let delay = initialDelayMs;
+	for (let attempt = 1; attempt < maxAttempts; attempt++) {
+		onRetry?.(attempt, delay);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+
+		if (await isVersionAvailableOnNpm(version)) {
+			return true;
+		}
+
+		delay = Math.min(Math.round(delay * 1.5), maxDelayMs);
+	}
+
+	return false;
+}

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,30 +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);
 
-		const firstDir = dirs[0];
-		if (!firstDir) {
-			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, firstDir);
+		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/tui.ts

@@ -1764,9 +1764,18 @@ export async function prompt(message: string): Promise<string> {
 	});
 }
 
+/**
+ * Select an organization from a list.
+ *
+ * @param orgs - List of organizations to choose from
+ * @param initial - Preferred org ID to pre-select (from saved preferences)
+ * @param autoSelect - If true, auto-select preferred org without prompting (for --confirm or non-interactive)
+ * @returns The selected organization ID
+ */
 export async function selectOrganization(
 	orgs: OrganizationList,
-	initial?: string
+	initial?: string,
+	autoSelect?: boolean
 ): Promise<string> {
 	if (orgs.length === 0) {
 		fatal(
@@ -1775,6 +1784,7 @@ export async function selectOrganization(
 		);
 	}
 
+	// 1. Environment variable always takes precedence
 	if (process.env.AGENTUITY_CLOUD_ORG_ID) {
 		const org = orgs.find((o) => o.id === process.env.AGENTUITY_CLOUD_ORG_ID);
 		if (org) {
@@ -1782,41 +1792,59 @@ export async function selectOrganization(
 		}
 	}
 
-	// Auto-select if only one org (regardless of TTY mode)
+	// 2. Auto-select if only one org (regardless of TTY mode or autoSelect)
 	if (orgs.length === 1 && orgs[0]) {
 		return orgs[0].id;
 	}
 
-	// Use saved preference if available (regardless of TTY mode)
-	// This allows consistent behavior without prompting on every command
-	if (initial) {
-		const initialOrg = orgs.find((o) => o.id === initial);
-		if (initialOrg) {
-			return initialOrg.id;
+	// 3. Auto-select mode (--confirm flag or explicit autoSelect)
+	// Use preferred org if set, otherwise fall back to first org
+	if (autoSelect) {
+		if (initial) {
+			const initialOrg = orgs.find((o) => o.id === initial);
+			if (initialOrg) {
+				return initialOrg.id;
+			}
+		}
+		// Fall back to first org with warning
+		const firstOrg = orgs[0];
+		if (firstOrg) {
+			warning(
+				`Multiple organizations found. Auto-selecting first org: ${firstOrg.name}. ` +
+					`Set AGENTUITY_CLOUD_ORG_ID, use --org-id, or run 'agentuity auth org select' to set a default.`
+			);
+			return firstOrg.id;
 		}
 	}
 
-	// Check for non-interactive environment (check both stdin and stdout)
+	// 4. Check for non-interactive environment (check both stdin and stdout)
 	const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
 	if (isNonInteractive) {
-		// In non-interactive mode with multiple orgs, auto-select first org
-		// This allows scripts and CI/CD to work without explicit org selection
+		// In non-interactive mode, use preferred org if set
+		if (initial) {
+			const initialOrg = orgs.find((o) => o.id === initial);
+			if (initialOrg) {
+				return initialOrg.id;
+			}
+		}
+		// Fall back to first org with warning
 		const firstOrg = orgs[0];
 		if (firstOrg) {
 			warning(
 				`Multiple organizations found. Auto-selecting first org: ${firstOrg.name}. ` +
-					`Set AGENTUITY_CLOUD_ORG_ID or use --org-id to specify a different org.`
+					`Set AGENTUITY_CLOUD_ORG_ID, use --org-id, or run 'agentuity auth org select' to set a default.`
 			);
 			return firstOrg.id;
 		}
 	}
 
-	// Interactive mode with no saved preference - prompt user
+	// 5. Interactive mode - show selector with preferred org pre-selected
+	const initialIndex = initial ? orgs.findIndex((o) => o.id === initial) : 0;
 	const response = await enquirer.prompt<{ action: string }>({
 		type: 'select',
 		name: 'action',
 		message: 'Select an organization',
-		initial: 0,
+		initial: initialIndex >= 0 ? initialIndex : 0,
 		choices: orgs.map((o) => ({ message: o.name, name: o.id })),
 	});
 

package/src/version-check.ts

@@ -233,18 +233,34 @@ export async function checkForUpdates(
 		const currentVersion = getVersion();
 		const latestVersion = await fetchLatestVersion();
 
-		// Update the timestamp since we successfully checked
-		await updateCheckTimestamp(config, logger);
-
 		// Compare versions
 		const normalizedCurrent = currentVersion.replace(/^v/, '');
 		const normalizedLatest = latestVersion.replace(/^v/, '');
 
 		if (normalizedCurrent === normalizedLatest) {
+			// Update timestamp - we confirmed we're on latest version
+			await updateCheckTimestamp(config, logger);
 			logger.trace('Already on latest version: %s', currentVersion);
 			return;
 		}
 
+		// Quick npm availability check before prompting (short timeout, no retries)
+		// This avoids blocking the user's command if npm is slow or version not yet available
+		const { isVersionAvailableOnNpmQuick } = await import('./cmd/upgrade/npm-availability');
+		const isAvailable = await isVersionAvailableOnNpmQuick(latestVersion);
+
+		if (!isAvailable) {
+			// Don't update timestamp - we want to check again soon since npm may propagate
+			logger.debug(
+				'Version %s not yet available on npm, skipping upgrade prompt',
+				latestVersion
+			);
+			return;
+		}
+
+		// Update timestamp - npm availability confirmed, we can proceed with prompt
+		await updateCheckTimestamp(config, logger);
+
 		// New version available - prompt user
 		const shouldUpgrade = await promptUpgrade(currentVersion, latestVersion);