@agentuity/cli 0.1.8 → 0.1.9

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

@@ -28,6 +28,10 @@ export const createSubcommand = createCommand({
 			command: getCommand('cloud sandbox create'),
 			description: 'Create a sandbox with default settings',
 		},
+		{
+			command: getCommand('cloud sandbox create --runtime python:3.14'),
+			description: 'Create a sandbox with Python runtime',
+		},
 		{
 			command: getCommand('cloud sandbox create --memory 1Gi --cpu 1000m'),
 			description: 'Create a sandbox with resource limits',
@@ -43,6 +47,13 @@ export const createSubcommand = createCommand({
 	],
 	schema: {
 		options: z.object({
+			runtime: z
+				.string()
+				.optional()
+				.describe('Runtime name (e.g., "bun:1", "python:3.14")'),
+			runtimeId: z.string().optional().describe('Runtime ID (e.g., "srt_xxx")'),
+			name: z.string().optional().describe('Sandbox name'),
+			description: z.string().optional().describe('Sandbox description'),
 			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")'),
@@ -100,6 +111,10 @@ export const createSubcommand = createCommand({
 
 		const result = await sandboxCreate(client, {
 			options: {
+				runtime: opts.runtime,
+				runtimeId: opts.runtimeId,
+				name: opts.name,
+				description: opts.description,
 				resources:
 					opts.memory || opts.cpu || opts.disk
 						? {

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

@@ -13,9 +13,13 @@ const SandboxResourcesSchema = z.object({
 
 const SandboxGetResponseSchema = z.object({
 	sandboxId: z.string().describe('Sandbox ID'),
+	name: z.string().optional().describe('Sandbox name'),
+	description: z.string().optional().describe('Sandbox description'),
 	status: z.string().describe('Current status'),
 	createdAt: z.string().describe('Creation timestamp'),
 	region: z.string().optional().describe('Region where sandbox is running'),
+	runtimeId: z.string().optional().describe('Runtime ID'),
+	runtimeName: z.string().optional().describe('Runtime name'),
 	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'),
@@ -63,8 +67,17 @@ export const getSubcommand = createCommand({
 							: tui.colorMuted;
 
 			console.log(`${tui.muted('Sandbox:')}         ${tui.bold(result.sandboxId)}`);
+			if (result.name) {
+				console.log(`${tui.muted('Name:')}            ${result.name}`);
+			}
+			if (result.description) {
+				console.log(`${tui.muted('Description:')}     ${result.description}`);
+			}
 			console.log(`${tui.muted('Status:')}          ${statusColor(result.status)}`);
 			console.log(`${tui.muted('Created:')}         ${result.createdAt}`);
+			if (result.runtimeName) {
+				console.log(`${tui.muted('Runtime:')}         ${result.runtimeName}`);
+			}
 			if (result.region) {
 				console.log(`${tui.muted('Region:')}          ${result.region}`);
 			}
@@ -108,9 +121,13 @@ export const getSubcommand = createCommand({
 
 		return {
 			sandboxId: result.sandboxId,
+			name: result.name,
+			description: result.description,
 			status: result.status,
 			createdAt: result.createdAt,
 			region: result.region,
+			runtimeId: result.runtimeId,
+			runtimeName: result.runtimeName,
 			snapshotId: result.snapshotId,
 			snapshotTag: result.snapshotTag,
 			executions: result.executions,

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

@@ -6,6 +6,7 @@ import { listSubcommand } from './list';
 import { getSubcommand } from './get';
 import { deleteSubcommand } from './delete';
 import { snapshotCommand } from './snapshot';
+import { runtimeCommand } from './runtime';
 import { cpSubcommand } from './cp';
 import { command as executionCommand } from './execution';
 import { mkdirSubcommand } from './mkdir';
@@ -44,6 +45,7 @@ export const command = createCommand({
 		getSubcommand,
 		deleteSubcommand,
 		snapshotCommand,
+		runtimeCommand,
 		cpSubcommand,
 		executionCommand,
 		mkdirSubcommand,

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

@@ -8,9 +8,13 @@ import type { SandboxStatus } from '@agentuity/core';
 
 const SandboxInfoSchema = z.object({
 	sandboxId: z.string().describe('Sandbox ID'),
+	name: z.string().optional().describe('Sandbox name'),
+	description: z.string().optional().describe('Sandbox description'),
 	status: z.string().describe('Current status'),
 	createdAt: z.string().describe('Creation timestamp'),
 	region: z.string().optional().describe('Region where sandbox is running'),
+	runtimeId: z.string().optional().describe('Runtime ID'),
+	runtimeName: z.string().optional().describe('Runtime name'),
 	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'),
@@ -88,22 +92,21 @@ export const listSubcommand = createCommand({
 				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,
+						Name: sandbox.name || '-',
+						Runtime: sandbox.runtimeName || '-',
 						Status: sandbox.status,
 						'Created At': sandbox.createdAt,
-						Snapshot: snapshotDisplay,
 						Executions: sandbox.executions,
 					};
 				});
 				tui.table(tableData, [
 					{ name: 'ID', alignment: 'left' },
+					{ name: 'Name', alignment: 'left' },
+					{ name: 'Runtime', alignment: 'left' },
 					{ name: 'Status', alignment: 'left' },
 					{ name: 'Created At', alignment: 'left' },
-					{ name: 'Snapshot', alignment: 'left' },
 					{ name: 'Executions', alignment: 'right' },
 				]);
 
@@ -114,9 +117,13 @@ export const listSubcommand = createCommand({
 		return {
 			sandboxes: result.sandboxes.map((s) => ({
 				sandboxId: s.sandboxId,
+				name: s.name,
+				description: s.description,
 				status: s.status,
 				createdAt: s.createdAt,
 				region: s.region,
+				runtimeId: s.runtimeId,
+				runtimeName: s.runtimeName,
 				snapshotId: s.snapshotId,
 				snapshotTag: s.snapshotTag,
 				executions: s.executions,

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

@@ -37,6 +37,13 @@ export const runSubcommand = createCommand({
 			command: z.array(z.string()).describe('Command and arguments to execute'),
 		}),
 		options: z.object({
+			runtime: z
+				.string()
+				.optional()
+				.describe('Runtime name (e.g., "bun:1", "python:3.14")'),
+			runtimeId: z.string().optional().describe('Runtime ID (e.g., "srt_xxx")'),
+			name: z.string().optional().describe('Sandbox name'),
+			description: z.string().optional().describe('Sandbox description'),
 			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")'),
@@ -102,6 +109,10 @@ export const runSubcommand = createCommand({
 		try {
 			const result = await sandboxRun(client, {
 				options: {
+					runtime: opts.runtime,
+					runtimeId: opts.runtimeId,
+					name: opts.name,
+					description: opts.description,
 					command: {
 						exec: args.command,
 						files: hasFiles ? files : undefined,

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

@@ -0,0 +1,20 @@
+import { createCommand } from '../../../../types';
+import { listSubcommand } from './list';
+import { getCommand } from '../../../../command-prefix';
+
+export const runtimeCommand = createCommand({
+	name: 'runtime',
+	aliases: ['rt'],
+	description: 'Manage sandbox runtimes',
+	tags: ['slow', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud sandbox runtime list'),
+			description: 'List all available runtimes',
+		},
+	],
+	subcommands: [listSubcommand],
+	requires: { auth: true, region: true, org: true },
+});
+
+export default runtimeCommand;

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

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+import { createCommand } from '../../../../types';
+import * as tui from '../../../../tui';
+import { createSandboxClient } from '../util';
+import { getCommand } from '../../../../command-prefix';
+import { runtimeList } from '@agentuity/server';
+
+const RuntimeInfoSchema = z.object({
+	id: z.string().describe('Runtime ID'),
+	name: z.string().describe('Runtime name'),
+	description: z.string().optional().describe('Runtime description'),
+});
+
+const RuntimeListResponseSchema = z.object({
+	runtimes: z.array(RuntimeInfoSchema).describe('List of runtimes'),
+	total: z.number().describe('Total number of runtimes'),
+});
+
+export const listSubcommand = createCommand({
+	name: 'list',
+	aliases: ['ls'],
+	description: 'List available sandbox runtimes',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	idempotent: true,
+	examples: [
+		{
+			command: getCommand('cloud sandbox runtime list'),
+			description: 'List all available runtimes',
+		},
+	],
+	schema: {
+		options: z.object({
+			limit: z.number().optional().describe('Maximum number of results'),
+			offset: z.number().optional().describe('Offset for pagination'),
+		}),
+		response: RuntimeListResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const result = await runtimeList(client, {
+			orgId,
+			limit: opts.limit,
+			offset: opts.offset,
+		});
+
+		if (!options.json) {
+			if (result.runtimes.length === 0) {
+				tui.info('No runtimes available');
+			} else {
+				const tableData = result.runtimes.map((runtime) => {
+					return {
+						ID: runtime.id,
+						Name: runtime.name,
+						Description: runtime.description ?? '-',
+					};
+				});
+				tui.table(tableData, [
+					{ name: 'ID', alignment: 'left' },
+					{ name: 'Name', alignment: 'left' },
+					{ name: 'Description', alignment: 'left' },
+				]);
+
+				tui.info(`Total: ${result.total} ${tui.plural(result.total, 'runtime', 'runtimes')}`);
+			}
+		}
+
+		return result;
+	},
+});
+
+export default listSubcommand;

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

@@ -5,9 +5,15 @@ import { createSandboxClient } from '../util';
 import { getCommand } from '../../../../command-prefix';
 import { snapshotCreate } from '@agentuity/server';
 
+const SNAPSHOT_NAME_REGEX = /^[a-zA-Z0-9_-]+$/;
+const SNAPSHOT_TAG_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+const MAX_SNAPSHOT_TAG_LENGTH = 128;
+
 const SnapshotCreateResponseSchema = z.object({
 	snapshotId: z.string().describe('Snapshot ID'),
-	tag: z.string().optional().nullable().describe('Snapshot tag'),
+	name: z.string().describe('Snapshot display name'),
+	description: z.string().optional().nullable().describe('Snapshot description'),
+	tag: z.string().optional().nullable().describe('Snapshot tag (defaults to "latest")'),
 	sizeBytes: z.number().describe('Snapshot size in bytes'),
 	fileCount: z.number().describe('Number of files in snapshot'),
 	createdAt: z.string().describe('Snapshot creation timestamp'),
@@ -27,37 +33,70 @@ export const createSubcommand = createCommand({
 			command: getCommand('cloud sandbox snapshot create sbx_abc123 --tag latest'),
 			description: 'Create a tagged snapshot',
 		},
+		{
+			command: getCommand('cloud sandbox snapshot create sbx_abc123 --name "My Snapshot" --description "Initial setup"'),
+			description: 'Create a named snapshot with description',
+		},
 	],
 	schema: {
 		args: z.object({
 			sandboxId: z.string().describe('Sandbox ID to snapshot'),
 		}),
 		options: z.object({
-			tag: z.string().optional().describe('Tag for the snapshot'),
+			name: z
+				.string()
+				.optional()
+				.describe('Display name for the snapshot (letters, numbers, underscores, dashes only)'),
+			description: z.string().optional().describe('Description of the snapshot'),
+			tag: z.string().optional().describe('Tag for the snapshot (defaults to "latest")'),
 		}),
 		response: SnapshotCreateResponseSchema,
 	},
 
 	async handler(ctx) {
 		const { args, opts, options, auth, region, logger, orgId } = ctx;
+
+		if (opts.name && !SNAPSHOT_NAME_REGEX.test(opts.name)) {
+			logger.fatal(
+				'Invalid snapshot name: must only contain letters, numbers, underscores, and dashes'
+			);
+		}
+
+		if (opts.tag) {
+			if (opts.tag.length > MAX_SNAPSHOT_TAG_LENGTH) {
+				logger.fatal(`Invalid snapshot tag: must be at most ${MAX_SNAPSHOT_TAG_LENGTH} characters`);
+			}
+			if (!SNAPSHOT_TAG_REGEX.test(opts.tag)) {
+				logger.fatal(
+					'Invalid snapshot tag: must only contain letters, numbers, dashes, underscores, and dots, and cannot start with a period or dash'
+				);
+			}
+		}
+
 		const client = createSandboxClient(logger, auth, region);
 
 		const snapshot = await snapshotCreate(client, {
 			sandboxId: args.sandboxId,
+			name: opts.name,
+			description: opts.description,
 			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}`);
+			tui.info(`Name: ${snapshot.name}`);
+			if (snapshot.description) {
+				tui.info(`Description: ${snapshot.description}`);
 			}
+			tui.info(`Size: ${tui.formatBytes(snapshot.sizeBytes)}, Files: ${snapshot.fileCount}`);
+			tui.info(`Tag: ${snapshot.tag ?? 'latest'}`);
 		}
 
 		return {
 			snapshotId: snapshot.snapshotId,
+			name: snapshot.name,
+			description: snapshot.description ?? undefined,
 			tag: snapshot.tag ?? undefined,
 			sizeBytes: snapshot.sizeBytes,
 			fileCount: snapshot.fileCount,

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

@@ -27,7 +27,7 @@ const SnapshotGetResponseSchema = z.object({
 	parentSnapshotId: z.string().nullable().optional().describe('Parent snapshot ID'),
 	createdAt: z.string().describe('Creation timestamp'),
 	downloadUrl: z.string().optional().describe('Presigned download URL'),
-	files: z.array(SnapshotFileSchema).optional().describe('Files in snapshot'),
+	files: z.array(SnapshotFileSchema).nullable().optional().describe('Files in snapshot'),
 	sandboxes: z
 		.array(SandboxInfoSchema)
 		.optional()

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

@@ -7,6 +7,8 @@ import { snapshotList } from '@agentuity/server';
 
 const SnapshotInfoSchema = z.object({
 	snapshotId: z.string(),
+	name: z.string().nullable().optional(),
+	description: z.string().nullable().optional(),
 	tag: z.string().nullable().optional(),
 	sizeBytes: z.number(),
 	fileCount: z.number(),
@@ -62,6 +64,7 @@ export const listSubcommand = createCommand({
 				const tableData = result.snapshots.map((snap) => {
 					return {
 						ID: snap.snapshotId,
+						Name: snap.name ?? '-',
 						Tag: snap.tag ?? '-',
 						Size: tui.formatBytes(snap.sizeBytes),
 						Files: snap.fileCount,
@@ -70,6 +73,7 @@ export const listSubcommand = createCommand({
 				});
 				tui.table(tableData, [
 					{ name: 'ID', alignment: 'left' },
+					{ name: 'Name', alignment: 'left' },
 					{ name: 'Tag', alignment: 'left' },
 					{ name: 'Size', alignment: 'right' },
 					{ name: 'Files', alignment: 'right' },

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

@@ -5,6 +5,9 @@ import { createSandboxClient } from '../util';
 import { getCommand } from '../../../../command-prefix';
 import { snapshotTag } from '@agentuity/server';
 
+const SNAPSHOT_TAG_REGEX = /^[a-zA-Z0-9_][a-zA-Z0-9._-]*$/;
+const MAX_SNAPSHOT_TAG_LENGTH = 128;
+
 const SnapshotTagResponseSchema = z.object({
 	snapshotId: z.string().describe('Snapshot ID'),
 	tag: z.string().nullable().optional().describe('New tag'),
@@ -44,6 +47,17 @@ export const tagSubcommand = createCommand({
 			throw new Error('Either provide a tag name or use --clear to remove the tag');
 		}
 
+		if (args.tag) {
+			if (args.tag.length > MAX_SNAPSHOT_TAG_LENGTH) {
+				logger.fatal(`Invalid snapshot tag: must be at most ${MAX_SNAPSHOT_TAG_LENGTH} characters`);
+			}
+			if (!SNAPSHOT_TAG_REGEX.test(args.tag)) {
+				logger.fatal(
+					'Invalid snapshot tag: must only contain letters, numbers, dashes, underscores, and dots, and cannot start with a period or dash'
+				);
+			}
+		}
+
 		const tag = opts.clear ? null : (args.tag ?? null);
 
 		const snapshot = await snapshotTag(client, {

package/src/config.ts

@@ -563,6 +563,16 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 	const configData = {
 		$schema: 'https://agentuity.dev/schema/cli/v1/agentuity.json',
 		...sanitizedConfig,
+		deployment: {
+			...sanitizedConfig.deployment,
+			resources: {
+				memory: '500Mi',
+				cpu: '500m',
+				disk: '500Mi',
+				...sanitizedConfig.deployment?.resources,
+			},
+			domains: sanitizedConfig.deployment?.domains ?? [],
+		},
 	};
 	await Bun.write(configPath, JSON.stringify(configData, null, 2) + '\n');