@agentuity/cli 3.0.0-alpha.7 → 3.0.0-beta.0

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

@@ -1,343 +0,0 @@
-import { z } from 'zod';
-import { Writable } from 'node:stream';
-import { ErrorCode } from '../../../errors';
-import { createCommand } from '../../../types';
-import * as tui from '../../../tui';
-import { createSandboxClient, detectNullStream } from './util';
-import { getCommand } from '../../../command-prefix';
-import { sandboxExecute, executionGet, sandboxResolve } from '@agentuity/server';
-import { streamUrlToWritable } from '../../../utils/stream-url';
-
-const EXECUTION_WAIT_DURATION = '5m';
-
-const SandboxExecResponseSchema = z.object({
-	executionId: z.string().describe('Unique execution identifier'),
-	status: z.string().describe('Execution status'),
-	exitCode: z.number().optional().describe('Exit code (if completed)'),
-	durationMs: z.number().optional().describe('Duration in milliseconds (if completed)'),
-	stdout: z
-		.string()
-		.optional()
-		.describe('Standard output (only when separate streams are available)'),
-	stderr: z
-		.string()
-		.optional()
-		.describe('Standard error output (only when separate streams are available)'),
-	output: z.string().optional().describe('Combined stdout/stderr output'),
-	outputTruncated: z
-		.boolean()
-		.optional()
-		.describe('Whether the captured output was truncated due to size limits'),
-	autoResumed: z
-		.boolean()
-		.optional()
-		.describe('True if the sandbox was automatically resumed from a suspended state'),
-});
-
-export const execSubcommand = createCommand({
-	name: 'exec',
-	aliases: ['execute'],
-	description: 'Execute a command in a running sandbox',
-	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, apiClient: true },
-	examples: [
-		{
-			command: getCommand('cloud sandbox exec abc123 -- echo "hello"'),
-			description: 'Execute a command in a sandbox',
-		},
-		{
-			command: getCommand('cloud sandbox exec abc123 --timeout 5m -- bun run build'),
-			description: 'Execute with timeout',
-		},
-	],
-
-	schema: {
-		args: z.object({
-			sandboxId: z.string().describe('Sandbox ID'),
-			command: z.array(z.string()).describe('Command and arguments to execute'),
-		}),
-		options: z.object({
-			timeout: z.string().optional().describe('Execution timeout (e.g., "5m", "1h")'),
-			timestamps: z
-				.boolean()
-				.default(false)
-				.optional()
-				.describe('Include timestamps in output (default: false)'),
-			quiet: z
-				.boolean()
-				.default(false)
-				.optional()
-				.describe('Suppress output (do not create stdout/stderr streams)'),
-		}),
-		response: SandboxExecResponseSchema,
-	},
-
-	async handler(ctx) {
-		const { args, opts, options, auth, logger, apiClient } = ctx;
-
-		if (opts.timeout) {
-			if (!/^(?:0|(\d+(\.\d+)?(ns|us|[µμ]s|ms|s|m|h))+)$/.test(opts.timeout)) {
-				tui.fatal(
-					`Invalid timeout format '${opts.timeout}': expected duration like '5s', '1m', '1h', '300ms'`,
-					ErrorCode.INVALID_ARGUMENT
-				);
-			}
-		}
-
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId } = sandboxInfo;
-
-		const client = createSandboxClient(logger, auth, region);
-		const started = Date.now();
-
-		// Detect if stdout/stderr are redirected to /dev/null
-		const stdoutIsNull = detectNullStream(1);
-		const stderrIsNull = detectNullStream(2);
-
-		// Build stream configuration
-		const streamConfig: {
-			timestamps?: boolean;
-			stdout?: string;
-			stderr?: string;
-		} = {
-			timestamps: opts.timestamps,
-		};
-
-		// --quiet: suppress all output streams (no server streams, no local capture)
-		if (opts.quiet) {
-			streamConfig.stdout = 'ignore';
-			streamConfig.stderr = 'ignore';
-		} else if (!options.json) {
-			// Auto-detect /dev/null redirection (only when not in JSON mode)
-			// In JSON mode we need output for the response, so keep streams even if redirected
-			if (stdoutIsNull) {
-				streamConfig.stdout = 'ignore';
-			}
-			if (stderrIsNull) {
-				streamConfig.stderr = 'ignore';
-			}
-		}
-
-		const abortController = new AbortController();
-		const handleSignal = () => {
-			abortController.abort();
-		};
-		process.on('SIGINT', handleSignal);
-		process.on('SIGTERM', handleSignal);
-
-		try {
-			logger.debug('[exec] calling sandboxExecute for %s', args.sandboxId);
-			const executeStart = Date.now();
-			const execution = await sandboxExecute(client, {
-				sandboxId: args.sandboxId,
-				options: {
-					command: args.command,
-					timeout: opts.timeout,
-					stream: streamConfig,
-				},
-				orgId,
-			});
-			logger.debug(
-				'[exec] sandboxExecute returned in %dms: executionId=%s, stdoutUrl=%s, stderrUrl=%s',
-				Date.now() - executeStart,
-				execution.executionId,
-				execution.stdoutStreamUrl ?? 'none',
-				execution.stderrStreamUrl ?? 'none'
-			);
-
-			if (execution.autoResumed && !options.json) {
-				tui.warning('Sandbox was automatically resumed from suspended state');
-			}
-
-			const stdoutStreamUrl = execution.stdoutStreamUrl;
-			const stderrStreamUrl = execution.stderrStreamUrl;
-			const streamAbortController = new AbortController();
-			const streamPromises: Promise<void>[] = [];
-			const streamLabels: string[] = [];
-
-			const isCombinedOutput =
-				stdoutStreamUrl && stderrStreamUrl && stdoutStreamUrl === stderrStreamUrl;
-			logger.debug(
-				'[exec] stream mode: combined=%s, stdoutUrl=%s, stderrUrl=%s',
-				isCombinedOutput,
-				stdoutStreamUrl ?? 'none',
-				stderrStreamUrl ?? 'none'
-			);
-
-			const outputChunks: string[] = [];
-			const stdoutChunks: string[] = [];
-			const stderrChunks: string[] = [];
-
-			const stdoutWritable: NodeJS.WritableStream =
-				options.json || stdoutIsNull
-					? createCaptureStream((chunk) => {
-							stdoutChunks.push(chunk);
-							outputChunks.push(chunk);
-						})
-					: process.stdout;
-			const stderrWritable: NodeJS.WritableStream =
-				options.json || stderrIsNull
-					? createCaptureStream((chunk) => {
-							stderrChunks.push(chunk);
-							outputChunks.push(chunk);
-						})
-					: process.stderr;
-
-			if (isCombinedOutput) {
-				logger.debug('[exec] starting combined stream: %s', stdoutStreamUrl);
-				streamLabels.push('combined');
-				streamPromises.push(
-					streamUrlToWritable(stdoutStreamUrl!, stdoutWritable, logger, {
-						signal: streamAbortController.signal,
-						label: 'combined',
-						raw: true,
-						v2: true,
-					}).then(() => {})
-				);
-			} else {
-				if (stdoutStreamUrl) {
-					logger.debug('[exec] starting stdout stream: %s', stdoutStreamUrl);
-					streamLabels.push('stdout');
-					streamPromises.push(
-						streamUrlToWritable(stdoutStreamUrl, stdoutWritable, logger, {
-							signal: streamAbortController.signal,
-							label: 'stdout',
-							raw: true,
-							v2: true,
-						}).then(() => {})
-					);
-				}
-
-				if (stderrStreamUrl) {
-					logger.debug('[exec] starting stderr stream: %s', stderrStreamUrl);
-					streamLabels.push('stderr');
-					streamPromises.push(
-						streamUrlToWritable(stderrStreamUrl, stderrWritable, logger, {
-							signal: streamAbortController.signal,
-							label: 'stderr',
-							raw: true,
-							v2: true,
-						}).then(() => {})
-					);
-				}
-			}
-
-			logger.debug(
-				'[exec] %d stream(s) started [%s], now long-polling executionGet',
-				streamPromises.length,
-				streamLabels.join(', ')
-			);
-
-			let finalExecution: Awaited<ReturnType<typeof executionGet>>;
-			const pollStart = Date.now();
-			try {
-				finalExecution = await executionGet(client, {
-					executionId: execution.executionId,
-					orgId,
-					wait: EXECUTION_WAIT_DURATION,
-				});
-			} catch (err) {
-				streamAbortController.abort();
-				throw err;
-			}
-			logger.debug(
-				'[exec] executionGet returned in %dms: status=%s, exitCode=%s',
-				Date.now() - pollStart,
-				finalExecution.status,
-				finalExecution.exitCode ?? 'undefined'
-			);
-
-			if (streamPromises.length > 0) {
-				logger.debug('[exec] waiting for %d stream(s) to EOF', streamPromises.length);
-				const streamWaitStart = Date.now();
-				let graceTriggered = false;
-				const streamGrace = setTimeout(() => {
-					graceTriggered = true;
-					logger.debug(
-						'[exec] stream grace period (5s) expired after execution complete — aborting streams'
-					);
-					streamAbortController.abort();
-				}, 5_000);
-				try {
-					await Promise.all(streamPromises);
-				} finally {
-					clearTimeout(streamGrace);
-				}
-				logger.debug(
-					'[exec] all streams done in %dms (graceTriggered=%s)',
-					Date.now() - streamWaitStart,
-					graceTriggered
-				);
-			}
-
-			if (!options.json && process.stdout.writable) {
-				await new Promise<void>((resolve) => {
-					if (process.stdout.writableNeedDrain) {
-						process.stdout.once('drain', () => resolve());
-					} else {
-						resolve();
-					}
-				});
-			}
-
-			const duration = Date.now() - started;
-			const output = outputChunks.join('');
-			const stdoutOutput =
-				!isCombinedOutput && stdoutStreamUrl ? stdoutChunks.join('') : undefined;
-			const stderrOutput =
-				!isCombinedOutput && stderrStreamUrl ? stderrChunks.join('') : undefined;
-
-			if (finalExecution.exitCode !== undefined && finalExecution.exitCode !== 0) {
-				if (!options.json) {
-					tui.error(`failed with exit code ${finalExecution.exitCode} in ${duration}ms`);
-				}
-				process.exitCode = finalExecution.exitCode;
-			} else if (finalExecution.exitCode === undefined) {
-				const failStatuses = ['failed', 'error', 'timeout', 'killed'];
-				if (failStatuses.includes(finalExecution.status)) {
-					if (!options.json) {
-						tui.error(
-							`Execution ${tui.bold(finalExecution.executionId)} ${finalExecution.status} in ${duration}ms`
-						);
-					}
-					process.exitCode = 1;
-				} else if (!options.json) {
-					tui.info(
-						`Execution ${tui.bold(finalExecution.executionId)} - Status: ${finalExecution.status}`
-					);
-				}
-			}
-
-			return {
-				executionId: finalExecution.executionId,
-				status: finalExecution.status,
-				exitCode: finalExecution.exitCode,
-				durationMs: finalExecution.durationMs,
-				stdout: options.json ? stdoutOutput : undefined,
-				stderr: options.json ? stderrOutput : undefined,
-				output: options.json ? output : undefined,
-				outputTruncated: finalExecution.outputTruncated ?? undefined,
-				autoResumed: execution.autoResumed ?? undefined,
-			};
-		} finally {
-			process.off('SIGINT', handleSignal);
-			process.off('SIGTERM', handleSignal);
-		}
-	},
-});
-
-function createCaptureStream(onChunk: (chunk: string) => void): NodeJS.WritableStream {
-	return new Writable({
-		write(
-			chunk: Buffer | string,
-			_encoding: string,
-			callback: (error?: Error | null) => void
-		): void {
-			const text = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
-			onChunk(text);
-			callback();
-		},
-	});
-}
-
-export default execSubcommand;

package/src/cmd/cloud/sandbox/execution/get.ts

@@ -1,120 +0,0 @@
-import { executionGet } from '@agentuity/server';
-import { z } from 'zod';
-import { getCommand } from '../../../../command-prefix';
-import { getGlobalCatalystAPIClient } from '../../../../config';
-import * as tui from '../../../../tui';
-import { createCommand } from '../../../../types';
-
-const ExecutionGetResponseSchema = z.object({
-	executionId: z.string().describe('Execution ID'),
-	sandboxId: z.string().describe('Sandbox ID'),
-	status: z.string().describe('Current status'),
-	command: z.array(z.string()).optional().describe('Command that was executed'),
-	exitCode: z.number().optional().describe('Exit code'),
-	durationMs: z.number().optional().describe('Duration in milliseconds'),
-	startedAt: z.string().optional().describe('Start timestamp'),
-	completedAt: z.string().optional().describe('Completion timestamp'),
-	error: z.string().optional().describe('Error message if failed'),
-	stdoutStreamUrl: z.string().optional().describe('URL to stream stdout'),
-	stderrStreamUrl: z.string().optional().describe('URL to stream stderr'),
-	outputTruncated: z
-		.boolean()
-		.optional()
-		.describe('Whether the captured output was truncated due to size limits'),
-});
-
-export const getSubcommand = createCommand({
-	name: 'get',
-	aliases: ['info', 'show'],
-	description: 'Get information about a specific execution',
-	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, org: true },
-	idempotent: true,
-	examples: [
-		{
-			command: getCommand('cloud sandbox execution get exec_abc123'),
-			description: 'Get execution information',
-		},
-	],
-	schema: {
-		args: z.object({
-			executionId: z.string().describe('Execution ID'),
-		}),
-		response: ExecutionGetResponseSchema,
-	},
-
-	async handler(ctx) {
-		const { args, options, auth, logger, orgId, config } = ctx;
-		const client = await getGlobalCatalystAPIClient(
-			logger,
-			auth,
-			config?.name,
-			undefined,
-			config
-		);
-
-		const result = await executionGet(client, { executionId: args.executionId, orgId });
-
-		if (!options.json) {
-			const statusColor =
-				result.status === 'completed'
-					? tui.colorSuccess
-					: result.status === 'running'
-						? tui.colorWarning
-						: result.status === 'failed' || result.status === 'timeout'
-							? tui.colorError
-							: tui.colorMuted;
-
-			const tableData: Record<string, string | number> = {
-				Execution: tui.bold(result.executionId),
-				Sandbox: result.sandboxId,
-				Status: statusColor(result.status),
-			};
-
-			if (result.exitCode !== undefined) {
-				const exitCodeColor = result.exitCode === 0 ? tui.colorSuccess : tui.colorError;
-				tableData['Exit Code'] = exitCodeColor(String(result.exitCode));
-			}
-			if (result.durationMs !== undefined) {
-				tableData['Duration'] = `${result.durationMs}ms`;
-			}
-			if (result.startedAt) {
-				tableData['Started'] = result.startedAt;
-			}
-			if (result.completedAt) {
-				tableData['Completed'] = result.completedAt;
-			}
-			if (result.error) {
-				tableData['Error'] = tui.colorError(result.error);
-			}
-			if (result.stdoutStreamUrl) {
-				tableData['Stdout'] = result.stdoutStreamUrl;
-			}
-			if (result.stderrStreamUrl) {
-				tableData['Stderr'] = result.stderrStreamUrl;
-			}
-			if (result.command && result.command.length > 0) {
-				tableData['Command'] = result.command.join(' ');
-			}
-
-			tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
-		}
-
-		return {
-			executionId: result.executionId,
-			sandboxId: result.sandboxId,
-			status: result.status,
-			command: result.command,
-			exitCode: result.exitCode,
-			durationMs: result.durationMs,
-			startedAt: result.startedAt,
-			completedAt: result.completedAt,
-			error: result.error,
-			stdoutStreamUrl: result.stdoutStreamUrl,
-			stderrStreamUrl: result.stderrStreamUrl,
-			outputTruncated: result.outputTruncated,
-		};
-	},
-});
-
-export default getSubcommand;

package/src/cmd/cloud/sandbox/execution/index.ts

@@ -1,25 +0,0 @@
-import { createCommand } from '../../../../types';
-import { getSubcommand } from './get';
-import { listSubcommand } from './list';
-import { getCommand } from '../../../../command-prefix';
-
-export const command = createCommand({
-	name: 'execution',
-	aliases: ['executions'],
-	description: 'Manage sandbox executions',
-	tags: ['read-only', 'requires-auth'],
-	examples: [
-		{
-			command: getCommand('cloud sandbox execution list sbx_abc123'),
-			description: 'List executions for a sandbox',
-		},
-		{
-			command: getCommand('cloud sandbox execution get exec_abc123'),
-			description: 'Get details of a specific execution',
-		},
-	],
-	subcommands: [getSubcommand, listSubcommand],
-	requires: { auth: true, org: true },
-});
-
-export default command;

package/src/cmd/cloud/sandbox/execution/list.ts

@@ -1,120 +0,0 @@
-import { executionList, sandboxResolve } from '@agentuity/server';
-import { z } from 'zod';
-import { getCommand } from '../../../../command-prefix';
-import * as tui from '../../../../tui';
-import { createCommand } from '../../../../types';
-import { createSandboxClient } from '../util';
-
-const ExecutionInfoSchema = z.object({
-	executionId: z.string().describe('Execution ID'),
-	sandboxId: z.string().describe('Sandbox ID'),
-	status: z.string().describe('Current status'),
-	exitCode: z.number().optional().describe('Exit code'),
-	durationMs: z.number().optional().describe('Duration in milliseconds'),
-	startedAt: z.string().optional().describe('Start timestamp'),
-	completedAt: z.string().optional().describe('Completion timestamp'),
-	error: z.string().optional().describe('Error message if failed'),
-});
-
-const ExecutionListResponseSchema = z.object({
-	executions: z.array(ExecutionInfoSchema).describe('List of executions'),
-});
-
-export const listSubcommand = createCommand({
-	name: 'list',
-	aliases: ['ls'],
-	description: 'List executions for a sandbox',
-	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, apiClient: true },
-	idempotent: true,
-	examples: [
-		{
-			command: getCommand('cloud sandbox execution list sbx_abc123'),
-			description: 'List executions for a sandbox',
-		},
-		{
-			command: getCommand('cloud sandbox execution list sbx_abc123 --limit 10'),
-			description: 'List with a limit',
-		},
-	],
-	schema: {
-		args: z.object({
-			sandboxId: z.string().describe('Sandbox ID'),
-		}),
-		options: z.object({
-			limit: z.number().optional().describe('Maximum number of results (default: 50, max: 100)'),
-			orgId: z
-				.string()
-				.optional()
-				.describe('Override organization ID (default: resolved from sandbox)'),
-		}),
-		response: ExecutionListResponseSchema,
-	},
-
-	async handler(ctx) {
-		const { args, opts, options, auth, logger, apiClient } = ctx;
-
-		// Resolve sandbox to get region and orgId (like exec.ts does)
-		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
-		const { region, orgId: resolvedOrgId } = sandboxInfo;
-		const effectiveOrgId = opts?.orgId || resolvedOrgId;
-		const client = createSandboxClient(logger, auth, region);
-
-		const result = await executionList(client, {
-			sandboxId: args.sandboxId,
-			orgId: effectiveOrgId,
-			limit: opts.limit,
-		});
-
-		if (!options.json) {
-			if (result.executions.length === 0) {
-				tui.info('No executions found');
-			} else {
-				const tableData = result.executions.map((exec) => {
-					const statusColor =
-						exec.status === 'completed'
-							? tui.colorSuccess
-							: exec.status === 'running'
-								? tui.colorWarning
-								: exec.status === 'failed' || exec.status === 'timeout'
-									? tui.colorError
-									: tui.colorMuted;
-
-					return {
-						ID: exec.executionId,
-						Status: statusColor(exec.status),
-						'Exit Code': exec.exitCode !== undefined ? String(exec.exitCode) : '-',
-						Duration: exec.durationMs !== undefined ? `${exec.durationMs}ms` : '-',
-						Started: exec.startedAt || '-',
-					};
-				});
-				tui.table(tableData, [
-					{ name: 'ID', alignment: 'left' },
-					{ name: 'Status', alignment: 'left' },
-					{ name: 'Exit Code', alignment: 'right' },
-					{ name: 'Duration', alignment: 'right' },
-					{ name: 'Started', alignment: 'left' },
-				]);
-
-				tui.info(
-					`Total: ${result.executions.length} ${tui.plural(result.executions.length, 'execution', 'executions')}`
-				);
-			}
-		}
-
-		return {
-			executions: result.executions.map((e) => ({
-				executionId: e.executionId,
-				sandboxId: e.sandboxId,
-				status: e.status,
-				exitCode: e.exitCode,
-				durationMs: e.durationMs,
-				startedAt: e.startedAt,
-				completedAt: e.completedAt,
-				error: e.error,
-			})),
-		};
-	},
-});
-
-export default listSubcommand;