@agentuity/cli 0.0.105 → 0.0.106

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

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxGet } from '@agentuity/server';
+
+const SandboxGetResponseSchema = z.object({
+	sandboxId: z.string().describe('Sandbox ID'),
+	status: z.string().describe('Current status'),
+	createdAt: z.string().describe('Creation timestamp'),
+	region: z.string().optional().describe('Region where sandbox is running'),
+	snapshotId: z.string().optional().describe('Snapshot ID sandbox was created from'),
+	snapshotTag: z.string().optional().describe('Snapshot tag sandbox was created from'),
+	executions: z.number().describe('Number of executions'),
+	stdoutStreamUrl: z.string().optional().describe('URL to stdout output stream'),
+	stderrStreamUrl: z.string().optional().describe('URL to stderr output stream'),
+	dependencies: z.array(z.string()).optional().describe('Apt packages installed'),
+});
+
+export const getSubcommand = createCommand({
+	name: 'get',
+	aliases: ['info', 'show'],
+	description: 'Get information about a sandbox',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud sandbox get abc123'),
+			description: 'Get sandbox information',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID'),
+		}),
+		response: SandboxGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const result = await sandboxGet(client, { sandboxId: args.sandboxId, orgId });
+
+		if (!options.json) {
+			const statusColor =
+				result.status === 'running'
+					? tui.colorSuccess
+					: result.status === 'idle'
+						? tui.colorWarning
+						: result.status === 'failed'
+							? tui.colorError
+							: tui.colorMuted;
+
+			console.log(`${tui.muted('Sandbox:')}         ${tui.bold(result.sandboxId)}`);
+			console.log(`${tui.muted('Status:')}          ${statusColor(result.status)}`);
+			console.log(`${tui.muted('Created:')}         ${result.createdAt}`);
+			if (result.region) {
+				console.log(`${tui.muted('Region:')}          ${result.region}`);
+			}
+			if (result.snapshotId || result.snapshotTag) {
+				const snapshotDisplay = result.snapshotTag
+					? `${result.snapshotTag} ${tui.muted('(' + result.snapshotId + ')')}`
+					: result.snapshotId;
+				console.log(`${tui.muted('Snapshot:')}        ${snapshotDisplay}`);
+			}
+			console.log(`${tui.muted('Executions:')}      ${result.executions}`);
+			if (
+				result.stdoutStreamUrl &&
+				result.stderrStreamUrl &&
+				result.stdoutStreamUrl === result.stderrStreamUrl
+			) {
+				console.log(`${tui.muted('Stream:')}          ${tui.link(result.stdoutStreamUrl)}`);
+			} else {
+				if (result.stdoutStreamUrl) {
+					console.log(`${tui.muted('Stream (stdout):')} ${tui.link(result.stdoutStreamUrl)}`);
+				}
+				if (result.stderrStreamUrl) {
+					console.log(`${tui.muted('Stream (stderr):')} ${tui.link(result.stderrStreamUrl)}`);
+				}
+			}
+			if (result.dependencies && result.dependencies.length > 0) {
+				console.log(`${tui.muted('Dependencies:')}    ${result.dependencies.join(', ')}`);
+			}
+		}
+
+		return {
+			sandboxId: result.sandboxId,
+			status: result.status,
+			createdAt: result.createdAt,
+			region: result.region,
+			snapshotId: result.snapshotId,
+			snapshotTag: result.snapshotTag,
+			executions: result.executions,
+			stdoutStreamUrl: result.stdoutStreamUrl,
+			stderrStreamUrl: result.stderrStreamUrl,
+			dependencies: result.dependencies,
+		};
+	},
+});
+
+export default getSubcommand;

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

@@ -0,0 +1,46 @@
+import { createCommand } from '../../../types';
+import { runSubcommand } from './run';
+import { createSubcommand } from './create';
+import { execSubcommand } from './exec';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deleteSubcommand } from './delete';
+import { snapshotCommand } from './snapshot';
+import { cpSubcommand } from './cp';
+import { command as executionCommand } from './execution';
+import { getCommand } from '../../../command-prefix';
+
+export const command = createCommand({
+	name: 'sandbox',
+	aliases: ['sb'],
+	description: 'Manage sandboxes for isolated code execution',
+	tags: ['slow', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud sandbox run -- echo "hello"'),
+			description: 'Run a one-shot command in a sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox create'),
+			description: 'Create an interactive sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox list'),
+			description: 'List all sandboxes',
+		},
+	],
+	subcommands: [
+		runSubcommand,
+		createSubcommand,
+		execSubcommand,
+		listSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		snapshotCommand,
+		cpSubcommand,
+		executionCommand,
+	],
+	requires: { auth: true, region: true, org: true },
+});
+
+export default command;

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

@@ -0,0 +1,129 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { sandboxList } from '@agentuity/server';
+import { createSandboxClient } from './util';
+import type { SandboxStatus } from '@agentuity/core';
+
+const SandboxInfoSchema = z.object({
+	sandboxId: z.string().describe('Sandbox ID'),
+	status: z.string().describe('Current status'),
+	createdAt: z.string().describe('Creation timestamp'),
+	region: z.string().optional().describe('Region where sandbox is running'),
+	snapshotId: z.string().optional().describe('Snapshot ID sandbox was created from'),
+	snapshotTag: z.string().optional().describe('Snapshot tag sandbox was created from'),
+	executions: z.number().describe('Number of executions'),
+});
+
+const SandboxListResponseSchema = z.object({
+	sandboxes: z.array(SandboxInfoSchema).describe('List of sandboxes'),
+	total: z.number().describe('Total count'),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List sandboxes with optional filtering',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	optional: { project: true },
+	idempotent: true,
+	pagination: {
+		supported: true,
+		defaultLimit: 50,
+		maxLimit: 100,
+		parameters: {
+			limit: 'limit',
+			offset: 'offset',
+		},
+	},
+	examples: [
+		{
+			command: getCommand('cloud sandbox list'),
+			description: 'List all sandboxes',
+		},
+		{
+			command: getCommand('cloud sandbox list --status running'),
+			description: 'List running sandboxes',
+		},
+		{
+			command: getCommand('cloud sandbox list --project-id proj_123'),
+			description: 'List sandboxes for a specific project',
+		},
+		{
+			command: getCommand('cloud sandbox list --limit 10 --offset 20'),
+			description: 'List with pagination',
+		},
+	],
+	schema: {
+		options: z.object({
+			status: z
+				.enum(['creating', 'idle', 'running', 'terminated', 'failed'])
+				.optional()
+				.describe('Filter by status'),
+			projectId: z.string().optional().describe('Filter by project ID'),
+			limit: z.number().optional().describe('Maximum number of results (default: 50, max: 100)'),
+			offset: z.number().optional().describe('Pagination offset'),
+		}),
+		response: SandboxListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options, auth, project, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const projectId = opts.projectId || project?.projectId;
+
+		const result = await sandboxList(client, {
+			orgId,
+			projectId,
+			status: opts.status as SandboxStatus | undefined,
+			limit: opts.limit,
+			offset: opts.offset,
+		});
+
+		if (!options.json) {
+			if (result.sandboxes.length === 0) {
+				tui.info('No sandboxes found');
+			} else {
+				const tableData = result.sandboxes.map((sandbox) => {
+					const snapshotDisplay = sandbox.snapshotTag
+						? `${sandbox.snapshotTag} (${sandbox.snapshotId})`
+						: sandbox.snapshotId || '-';
+					return {
+						ID: sandbox.sandboxId,
+						Status: sandbox.status,
+						'Created At': sandbox.createdAt,
+						Snapshot: snapshotDisplay,
+						Executions: sandbox.executions,
+					};
+				});
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Status', alignment: 'left' },
+					{ name: 'Created At', alignment: 'left' },
+					{ name: 'Snapshot', alignment: 'left' },
+					{ name: 'Executions', alignment: 'right' },
+				]);
+
+				tui.info(`Total: ${result.total} ${tui.plural(result.total, 'sandbox', 'sandboxes')}`);
+			}
+		}
+
+		return {
+			sandboxes: result.sandboxes.map((s) => ({
+				sandboxId: s.sandboxId,
+				status: s.status,
+				createdAt: s.createdAt,
+				region: s.region,
+				snapshotId: s.snapshotId,
+				snapshotTag: s.snapshotTag,
+				executions: s.executions,
+			})),
+			total: result.total,
+		};
+	},
+});
+
+export default listSubcommand;

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

@@ -0,0 +1,170 @@
+import { z } from 'zod';
+import { Writable } from 'node:stream';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient, parseFileArgs } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxRun } from '@agentuity/server';
+
+const SandboxRunResponseSchema = z.object({
+	sandboxId: z.string().describe('Sandbox ID'),
+	exitCode: z.number().describe('Exit code from the process'),
+	durationMs: z.number().describe('Duration in milliseconds'),
+	output: z.string().optional().describe('Combined stdout/stderr output'),
+});
+
+export const runSubcommand = createCommand({
+	name: 'run',
+	description: 'Run a one-shot command in a sandbox (creates, executes, destroys)',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox run -- echo "hello world"'),
+			description: 'Run a simple command',
+		},
+		{
+			command: getCommand('cloud sandbox run --memory 1Gi --cpu 1000m -- bun run index.ts'),
+			description: 'Run with resource limits',
+		},
+		{
+			command: getCommand('cloud sandbox run --network -- curl https://api.example.com'),
+			description: 'Run with network access enabled',
+		},
+	],
+	schema: {
+		args: z.object({
+			command: z.array(z.string()).describe('Command and arguments to execute'),
+		}),
+		options: z.object({
+			memory: z.string().optional().describe('Memory limit (e.g., "500Mi", "1Gi")'),
+			cpu: z.string().optional().describe('CPU limit in millicores (e.g., "500m", "1000m")'),
+			disk: z.string().optional().describe('Disk limit (e.g., "500Mi", "1Gi")'),
+			network: z.boolean().default(false).optional().describe('Enable outbound network access'),
+			timeout: z.string().optional().describe('Execution timeout (e.g., "5m", "1h")'),
+			env: z.array(z.string()).optional().describe('Environment variables (KEY=VALUE)'),
+			file: z
+				.array(z.string())
+				.optional()
+				.describe('Files to create in sandbox (sandbox-path:local-path)'),
+			timestamps: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Include timestamps in output (default: true)'),
+			snapshot: z.string().optional().describe('Snapshot ID or tag to restore from'),
+			dependency: z
+				.array(z.string())
+				.optional()
+				.describe('Apt packages to install (can be specified multiple times)'),
+		}),
+		response: SandboxRunResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+		const started = Date.now();
+
+		const envMap: Record<string, string> = {};
+		if (opts.env) {
+			for (const e of opts.env) {
+				const [key, ...valueParts] = e.split('=');
+				if (key) {
+					envMap[key] = valueParts.join('=');
+				}
+			}
+		}
+
+		const files = parseFileArgs(opts.file);
+		const hasFiles = files.length > 0;
+
+		const abortController = new AbortController();
+		const handleSignal = () => {
+			abortController.abort();
+		};
+		process.on('SIGINT', handleSignal);
+		process.on('SIGTERM', handleSignal);
+
+		const outputChunks: string[] = [];
+
+		// Determine if we have stdin data (not a TTY means piped input)
+		const hasStdin = !process.stdin.isTTY;
+
+		// For JSON output, we need to capture output instead of streaming to process
+		const stdout = options.json
+			? createCaptureStream((chunk) => outputChunks.push(chunk))
+			: process.stdout;
+		const stderr = options.json
+			? createCaptureStream((chunk) => outputChunks.push(chunk))
+			: process.stderr;
+
+		try {
+			const result = await sandboxRun(client, {
+				options: {
+					command: {
+						exec: args.command,
+						files: hasFiles ? files : undefined,
+					},
+					resources:
+						opts.memory || opts.cpu || opts.disk
+							? {
+									memory: opts.memory,
+									cpu: opts.cpu,
+									disk: opts.disk,
+								}
+							: undefined,
+					network: opts.network ? { enabled: true } : undefined,
+					timeout: opts.timeout ? { execution: opts.timeout } : undefined,
+					env: Object.keys(envMap).length > 0 ? envMap : undefined,
+					stream: opts.timestamps !== undefined ? { timestamps: opts.timestamps } : undefined,
+					snapshot: opts.snapshot,
+					dependencies: opts.dependency,
+				},
+				orgId,
+				region,
+				apiKey: auth.apiKey,
+				signal: abortController.signal,
+				stdin: hasStdin ? process.stdin : undefined,
+				stdout,
+				stderr,
+				logger,
+			});
+
+			const duration = Date.now() - started;
+			const output = outputChunks.join('');
+
+			if (!options.json) {
+				if (result.exitCode !== 0) {
+					tui.error(`failed with exit code ${result.exitCode} in ${duration}ms`);
+				}
+			}
+
+			return {
+				sandboxId: result.sandboxId,
+				exitCode: result.exitCode,
+				durationMs: result.durationMs,
+				output: options.json ? output : undefined,
+			};
+		} finally {
+			process.off('SIGINT', handleSignal);
+			process.off('SIGTERM', handleSignal);
+		}
+	},
+});
+
+function createCaptureStream(onChunk: (chunk: string) => void): Writable {
+	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 runSubcommand;

package/src/cmd/cloud/sandbox/snapshot/create.ts

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { snapshotCreate } from '@agentuity/server';
+
+const SnapshotCreateResponseSchema = z.object({
+	snapshotId: z.string().describe('Snapshot ID'),
+	sandboxId: z.string().describe('Source sandbox ID'),
+	tag: z.string().optional().nullable().describe('Snapshot tag'),
+	sizeBytes: z.number().describe('Snapshot size in bytes'),
+	fileCount: z.number().describe('Number of files in snapshot'),
+	createdAt: z.string().describe('Snapshot creation timestamp'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	description: 'Create a snapshot from a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot create sbx_abc123'),
+			description: 'Create a snapshot from a sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox snapshot create sbx_abc123 --tag latest'),
+			description: 'Create a tagged snapshot',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('Sandbox ID to snapshot'),
+		}),
+		options: z.object({
+			tag: z.string().optional().describe('Tag for the snapshot'),
+		}),
+		response: SnapshotCreateResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const snapshot = await snapshotCreate(client, {
+			sandboxId: args.sandboxId,
+			tag: opts.tag,
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`created snapshot ${tui.bold(snapshot.snapshotId)}`);
+			tui.info(`Size: ${tui.formatBytes(snapshot.sizeBytes)}, Files: ${snapshot.fileCount}`);
+			if (snapshot.tag) {
+				tui.info(`Tag: ${snapshot.tag}`);
+			}
+		}
+
+		return {
+			snapshotId: snapshot.snapshotId,
+			sandboxId: snapshot.sandboxId,
+			tag: snapshot.tag ?? undefined,
+			sizeBytes: snapshot.sizeBytes,
+			fileCount: snapshot.fileCount,
+			createdAt: snapshot.createdAt,
+		};
+	},
+});
+
+export default createSubcommand;

package/src/cmd/cloud/sandbox/snapshot/delete.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { snapshotDelete } from '@agentuity/server';
+
+const SnapshotDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the operation succeeded'),
+	snapshotId: z.string().describe('Deleted snapshot ID'),
+	message: z.string().optional().describe('Status message'),
+});
+
+export const deleteSubcommand = createCommand({
+	name: 'delete',
+	aliases: ['del', 'rm', 'remove'],
+	description: 'Delete a snapshot',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud sandbox snapshot delete snp_abc123'),
+			description: 'Delete a snapshot',
+		},
+		{
+			command: getCommand('cloud sandbox snapshot rm snp_abc123 --confirm'),
+			description: 'Delete without confirmation prompt',
+		},
+	],
+	schema: {
+		args: z.object({
+			snapshotId: z.string().describe('Snapshot ID to delete'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: SnapshotDeleteResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, opts, auth, region, logger, orgId } = ctx;
+
+		if (!opts.confirm) {
+			const confirmed = await tui.confirm(`Delete snapshot "${args.snapshotId}"?`, false);
+			if (!confirmed) {
+				logger.info('Cancelled');
+				return {
+					success: false,
+					snapshotId: args.snapshotId,
+					message: 'Cancelled',
+				};
+			}
+		}
+
+		const client = createSandboxClient(logger, auth, region);
+
+		await snapshotDelete(client, {
+			snapshotId: args.snapshotId,
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`deleted snapshot ${tui.bold(args.snapshotId)}`);
+		}
+
+		return {
+			success: true,
+			snapshotId: args.snapshotId,
+		};
+	},
+});
+
+export default deleteSubcommand;