@agentuity/cli 0.1.42 → 0.1.43

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/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)
  */