@agentuity/cli 0.1.33 → 0.1.35

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

@@ -7,8 +7,8 @@ import { getCommand } from '../../../command-prefix';
 import { sandboxExecute, executionGet, writeAndDrain } from '@agentuity/server';
 import type { Logger } from '@agentuity/core';
 
-const POLL_INTERVAL_MS = 500;
-const MAX_POLL_ATTEMPTS = 7200;
+// Server-side long-poll wait duration (max 5 minutes supported by server)
+const EXECUTION_WAIT_DURATION = '5m';
 
 const SandboxExecResponseSchema = z.object({
 	executionId: z.string().describe('Unique execution identifier'),
@@ -115,41 +115,14 @@ export const execSubcommand = createCommand({
 				}
 			}
 
-			let attempts = 0;
-			let finalExecution = execution;
-
-			while (attempts < MAX_POLL_ATTEMPTS) {
-				if (abortController.signal.aborted) {
-					throw new Error('Execution cancelled');
-				}
-
-				await sleep(POLL_INTERVAL_MS);
-				attempts++;
-
-				try {
-					const execInfo = await executionGet(client, {
-						executionId: execution.executionId,
-						orgId,
-					});
-
-					if (
-						execInfo.status === 'completed' ||
-						execInfo.status === 'failed' ||
-						execInfo.status === 'timeout' ||
-						execInfo.status === 'cancelled'
-					) {
-						finalExecution = {
-							executionId: execInfo.executionId,
-							status: execInfo.status,
-							exitCode: execInfo.exitCode,
-							durationMs: execInfo.durationMs,
-						};
-						break;
-					}
-				} catch {
-					continue;
-				}
-			}
+			// Use server-side long-polling to wait for execution completion
+			// This is more efficient than client-side polling and provides immediate
+			// error detection if the sandbox is terminated
+			const finalExecution = await executionGet(client, {
+				executionId: execution.executionId,
+				orgId,
+				wait: EXECUTION_WAIT_DURATION,
+			});
 
 			// Wait for all streams to reach EOF (Pulse blocks until true EOF)
 			await Promise.all(streamPromises);
@@ -248,8 +221,4 @@ function createCaptureStream(onChunk: (chunk: string) => void): NodeJS.WritableS
 	});
 }
 
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 export default execSubcommand;

package/src/cmd/dev/index.ts

@@ -18,7 +18,6 @@ import { typecheck } from '../build/typecheck';
 import { validateGravityRequiresUpgrade } from '../../runtime';
 import { isTTY, hasLoggedInBefore } from '../../auth';
 import { createFileWatcher } from './file-watcher';
-import { regenerateSkillsAsync } from './skills';
 import { prepareDevLock, releaseLockSync } from './dev-lock';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
 import { ErrorCode } from '../../errors';
@@ -81,6 +80,7 @@ async function killLingeringGravityProcesses(logger: {
 /**
  * Stop the existing Bun server if one is running.
  * Waits for the port to become available before returning (with timeout).
+ * Handles both in-process server and subprocess (when debugger is enabled).
  */
 async function stopBunServer(
 	port: number,
@@ -88,6 +88,48 @@ async function stopBunServer(
 ): Promise<void> {
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	const globalAny = globalThis as any;
+
+	// Check for subprocess first (used when debugger flags are enabled)
+	const bunSubprocess = globalAny.__AGENTUITY_BUN_SUBPROCESS__ as ProcessLike | undefined;
+	if (bunSubprocess) {
+		logger.debug('Stopping Bun subprocess...');
+		try {
+			bunSubprocess.kill('SIGTERM');
+			// After SIGTERM, wait and check multiple times before giving up
+			let attempts = 0;
+			while (bunSubprocess.exitCode === null && attempts < 3) {
+				await new Promise((resolve) => setTimeout(resolve, 100));
+				attempts++;
+			}
+			if (bunSubprocess.exitCode === null) {
+				bunSubprocess.kill('SIGKILL');
+			}
+			logger.debug('Bun subprocess killed');
+		} catch (err) {
+			logger.debug('Error killing Bun subprocess: %s', err);
+		}
+		globalAny.__AGENTUITY_BUN_SUBPROCESS__ = undefined;
+
+		// Wait for port to become available
+		const MAX_WAIT_ITERATIONS = 10;
+		for (let i = 0; i < MAX_WAIT_ITERATIONS; i++) {
+			try {
+				await fetch(`http://127.0.0.1:${port}/`, {
+					method: 'HEAD',
+					signal: AbortSignal.timeout(150),
+				});
+				// Still responding, wait a bit more
+				await new Promise((r) => setTimeout(r, 50));
+			} catch {
+				// Connection refused or timeout => server is down
+				logger.debug('Bun subprocess stopped');
+				break;
+			}
+		}
+		return;
+	}
+
+	// Handle in-process server
 	const server = globalAny.__AGENTUITY_SERVER__ as BunServer | undefined;
 	if (!server) {
 		logger.debug('No Bun server to stop');
@@ -171,6 +213,15 @@ export const command = createCommand({
 				.max(MAX_PORT)
 				.default(getDefaultPort())
 				.describe('The TCP port to start the dev server (also reads from PORT env)'),
+			inspect: z.boolean().optional().describe('Enable bun debugger on available port'),
+			inspectWait: z
+				.boolean()
+				.optional()
+				.describe('Enable bun debugger and wait for connection before executing'),
+			inspectBrk: z
+				.boolean()
+				.optional()
+				.describe('Enable bun debugger with breakpoint at first line'),
 		}),
 	},
 	optional: { project: true },
@@ -489,12 +540,6 @@ export const command = createCommand({
 				centerTitle: false,
 			});
 
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			const cliVersion = ((global as any).__CLI_SCHEMA__?.version as string) ?? '';
-			if (cliVersion) {
-				regenerateSkillsAsync(rootDir, cliVersion, logger).catch(() => {});
-			}
-
 			// Start Vite asset server ONCE before restart loop
 			// Vite handles frontend HMR independently and stays running across backend restarts
 			let viteServer: ServerLike | null = null;
@@ -961,7 +1006,7 @@ export const command = createCommand({
 					}
 				} catch (error) {
 					tui.error(`Failed to build dev bundle: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Resume watcher to detect changes for retry
 					fileWatcher.resume();
@@ -986,7 +1031,7 @@ export const command = createCommand({
 						if (sdkKey) {
 							process.env.AGENTUITY_SDK_KEY = sdkKey;
 						} else if (project) {
-							tui.warn(
+							tui.warning(
 								'AGENTUITY_SDK_KEY not found in .env file. Numerous features will be unavailable.'
 							);
 							tui.bullet(
@@ -1035,6 +1080,9 @@ export const command = createCommand({
 						deploymentId,
 						logger,
 						vitePort, // Pass port of already-running Vite server
+						inspect: opts.inspect,
+						inspectWait: opts.inspectWait,
+						inspectBrk: opts.inspectBrk,
 					});
 
 					// Wait for app.ts to finish loading (Vite is ready but app may still be initializing)
@@ -1047,7 +1095,7 @@ export const command = createCommand({
 					}
 				} catch (error) {
 					tui.error(`Failed to start dev server: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Wait for next restart trigger or shutdown
 					await new Promise<void>((resolve) => {
@@ -1274,7 +1322,7 @@ export const command = createCommand({
 					await Bun.sleep(500);
 				} catch (error) {
 					tui.error(`Error during server operation: ${error}`);
-					tui.warn('Waiting for file changes to retry...');
+					tui.warning('Waiting for file changes to retry...');
 
 					// Cleanup on error (Vite stays running)
 					await cleanupForRestart();

package/src/cmd/index.ts

@@ -15,6 +15,7 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 		import('./project').then((m) => m.command),
 		import('./repl').then((m) => m.command),
 		import('./setup').then((m) => m.command),
+		import('./support').then((m) => m.command),
 		import('./upgrade').then((m) => m.command),
 		import('./version').then((m) => m.command),
 	]);

package/src/cmd/support/index.ts

@@ -0,0 +1,11 @@
+import { createCommand } from '../../types';
+import logs from './logs';
+import report from './report';
+import system from './system';
+
+export const command = createCommand({
+	name: 'support',
+	description: 'Create support tickets and report issues',
+	skipInternalLogging: true,
+	subcommands: [logs, report, system],
+});

package/src/cmd/support/logs/index.ts

@@ -0,0 +1,9 @@
+import { createCommand } from '../../../types';
+import show from './show';
+import path from './path';
+
+export default createCommand({
+	name: 'logs',
+	description: 'View and manage CLI execution logs',
+	subcommands: [show, path],
+});

package/src/cmd/support/logs/path.ts

@@ -0,0 +1,56 @@
+import { createSubcommand } from '../../../types';
+import { z } from 'zod';
+import { getLatestLogSession, getLogsDirPath } from '../../../internal-logger';
+import * as tui from '../../../tui';
+
+const argsSchema = z.object({});
+
+const optionsSchema = z.object({
+	logs: z.boolean().optional().default(false).describe('Show path to logs directory instead of session'),
+});
+
+export default createSubcommand({
+	name: 'path',
+	description: 'Show the path to the most recent log session',
+	schema: {
+		args: argsSchema,
+		options: optionsSchema,
+	},
+	handler: async (ctx) => {
+		const { opts } = ctx;
+		const isJsonMode = ctx.options.json;
+
+		if (opts.logs) {
+			// Show the logs directory path
+			const logsDir = getLogsDirPath();
+			if (isJsonMode) {
+				console.log(JSON.stringify({ logsDir }));
+			} else {
+				console.log(logsDir);
+			}
+			return;
+		}
+
+		const sessionDir = getLatestLogSession();
+		if (!sessionDir) {
+			if (isJsonMode) {
+				console.log(
+					JSON.stringify({
+						error: 'No logs found',
+						logsDir: getLogsDirPath(),
+					})
+				);
+			} else {
+				tui.warning('No CLI logs found');
+				tui.info(`Logs directory: ${tui.muted(getLogsDirPath())}`);
+			}
+			return;
+		}
+
+		if (isJsonMode) {
+			console.log(JSON.stringify({ sessionDir }));
+		} else {
+			console.log(sessionDir);
+		}
+	},
+});

package/src/cmd/support/logs/show.ts

@@ -0,0 +1,144 @@
+import { createSubcommand } from '../../../types';
+import { z } from 'zod';
+import { readFileSync, existsSync } from 'node:fs';
+import { getLatestLogSession, getLogsDirPath } from '../../../internal-logger';
+import * as tui from '../../../tui';
+import { join } from 'node:path';
+
+const argsSchema = z.object({});
+
+const optionsSchema = z.object({
+	session: z.boolean().optional().default(false).describe('Show session metadata only'),
+	tail: z.number().optional().describe('Show last N log entries'),
+});
+
+export default createSubcommand({
+	name: 'show',
+	description: 'Show the most recent CLI command logs',
+	schema: {
+		args: argsSchema,
+		options: optionsSchema,
+	},
+	handler: async (ctx) => {
+		const { opts } = ctx;
+		const isJsonMode = ctx.options.json;
+
+		const sessionDir = getLatestLogSession();
+		if (!sessionDir) {
+			if (isJsonMode) {
+				console.log(
+					JSON.stringify({
+						error: 'No logs found',
+						logsDir: getLogsDirPath(),
+					})
+				);
+				return;
+			}
+			tui.warning('No CLI logs found');
+			tui.info(`Logs are stored in: ${tui.muted(getLogsDirPath())}`);
+			return;
+		}
+
+		const sessionFile = join(sessionDir, 'session.json');
+		const logsFile = join(sessionDir, 'logs.jsonl');
+
+		if (!existsSync(sessionFile)) {
+			if (isJsonMode) {
+				console.log(JSON.stringify({ error: 'Session metadata not found' }));
+				return;
+			}
+			tui.error('Session metadata not found');
+			return;
+		}
+
+		// Read session metadata
+		const sessionData = JSON.parse(readFileSync(sessionFile, 'utf-8'));
+
+		if (opts.session) {
+			// Show session metadata only
+			if (isJsonMode) {
+				console.log(JSON.stringify(sessionData, null, 2));
+			} else {
+				tui.info(tui.bold('CLI Command Session'));
+				tui.newline();
+				tui.output(`Session ID:  ${tui.colorPrimary(sessionData.sessionId)}`);
+				tui.output(`Command:     ${tui.colorInfo(sessionData.command)}`);
+				tui.output(`Args:        ${sessionData.args.join(' ')}`);
+				tui.output(`Timestamp:   ${sessionData.timestamp}`);
+				tui.output(`CLI Version: ${sessionData.cli.version}`);
+				tui.output(`Platform:    ${sessionData.system.platform}/${sessionData.system.arch}`);
+				tui.output(`CWD:         ${sessionData.cwd}`);
+				tui.newline();
+				tui.output(tui.muted(`Session directory: ${sessionDir}`));
+			}
+			return;
+		}
+
+		// Read log entries
+		if (!existsSync(logsFile)) {
+			if (isJsonMode) {
+				console.log(JSON.stringify({ session: sessionData, logs: [] }));
+				return;
+			}
+			tui.warning('No log entries found for this session');
+			return;
+		}
+
+		const logLines = readFileSync(logsFile, 'utf-8')
+			.split('\n')
+			.filter((line) => line.trim());
+		const logEntries = logLines.map((line) => JSON.parse(line));
+
+		// Apply tail filter if specified
+		const displayEntries = opts.tail ? logEntries.slice(-opts.tail) : logEntries;
+
+		if (isJsonMode) {
+			console.log(
+				JSON.stringify(
+					{
+						session: sessionData,
+						logs: displayEntries,
+					},
+					null,
+					2
+				)
+			);
+		} else {
+			// Human-readable output
+			tui.info(tui.bold('CLI Command Session'));
+			tui.newline();
+			tui.output(`Session ID:  ${tui.colorPrimary(sessionData.sessionId)}`);
+			tui.output(`Command:     ${tui.colorInfo(sessionData.command)}`);
+			tui.output(`Timestamp:   ${sessionData.timestamp}`);
+			tui.output(`Total Logs:  ${logEntries.length}`);
+			if (opts.tail) {
+				tui.output(`Showing:     Last ${opts.tail} entries`);
+			}
+			tui.newline();
+
+			// Display log entries
+			for (const entry of displayEntries) {
+				const levelColor =
+					entry.level === 'error'
+						? tui.colorError
+						: entry.level === 'warn'
+							? tui.warn
+							: entry.level === 'info'
+								? tui.colorInfo
+								: tui.muted;
+
+				const timestamp = new Date(entry.timestamp).toLocaleTimeString();
+				const level = entry.level.toUpperCase().padEnd(5);
+
+				tui.output(`${tui.muted(timestamp)} ${levelColor(level)} ${entry.message}`);
+
+				if (entry.context && Object.keys(entry.context).length > 0) {
+					tui.output(tui.muted(`  Context: ${JSON.stringify(entry.context)}`));
+				}
+			}
+
+			tui.newline();
+			tui.output(tui.muted(`Session directory: ${sessionDir}`));
+		}
+	},
+});