@agentuity/cli 0.0.110 → 0.0.111

package/src/cmd/cloud/sandbox/env.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 { sandboxSetEnv } from '@agentuity/server';
+
+export const envSubcommand = createCommand({
+	name: 'env',
+	description: 'Set or delete environment variables on a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox env sbx_abc123 MY_VAR=value'),
+			description: 'Set an environment variable',
+		},
+		{
+			command: getCommand('cloud sandbox env sbx_abc123 VAR1=value1 VAR2=value2'),
+			description: 'Set multiple environment variables',
+		},
+		{
+			command: getCommand('cloud sandbox env sbx_abc123 --delete MY_VAR'),
+			description: 'Delete an environment variable',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			vars: z.array(z.string()).optional().describe('Environment variables (KEY=VALUE format)'),
+		}),
+		options: z.object({
+			delete: z.array(z.string()).optional().describe('Environment variable names to delete'),
+		}),
+		aliases: {
+			delete: ['d'],
+		},
+		response: z.object({
+			success: z.boolean(),
+			env: z.record(z.string(), z.string()),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+
+		const client = createSandboxClient(logger, auth, region);
+
+		const envMap: Record<string, string | null> = {};
+
+		if (args.vars) {
+			for (const varSpec of args.vars) {
+				const eqIndex = varSpec.indexOf('=');
+				if (eqIndex === -1) {
+					logger.fatal(
+						`Invalid environment variable format: ${varSpec}. Use KEY=VALUE format.`
+					);
+				}
+				const key = varSpec.slice(0, eqIndex);
+				const value = varSpec.slice(eqIndex + 1);
+				envMap[key] = value;
+			}
+		}
+
+		if (opts.delete) {
+			for (const key of opts.delete) {
+				envMap[key] = null;
+			}
+		}
+
+		if (Object.keys(envMap).length === 0) {
+			logger.fatal('No environment variables specified. Use KEY=VALUE or --delete KEY');
+		}
+
+		const result = await sandboxSetEnv(client, {
+			sandboxId: args.sandboxId,
+			env: envMap,
+			orgId,
+		});
+
+		if (!options.json) {
+			const setVars = Object.entries(envMap).filter(([_, v]) => v !== null);
+			const deletedVars = Object.entries(envMap).filter(([_, v]) => v === null);
+
+			if (setVars.length > 0) {
+				tui.success(`Set ${setVars.length} environment variable(s)`);
+			}
+			if (deletedVars.length > 0) {
+				tui.success(`Deleted ${deletedVars.length} environment variable(s)`);
+			}
+
+			if (Object.keys(result.env).length > 0) {
+				console.log('\nCurrent environment:');
+				for (const [key, value] of Object.entries(result.env)) {
+					console.log(`  ${key}=${value}`);
+				}
+			}
+		}
+
+		return { success: true, env: result.env };
+	},
+});
+
+export default envSubcommand;

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

@@ -16,6 +16,7 @@ const SandboxGetResponseSchema = z.object({
 	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'),
+	metadata: z.record(z.string(), z.unknown()).optional().describe('User-defined metadata'),
 });
 
 export const getSubcommand = createCommand({
@@ -84,6 +85,9 @@ export const getSubcommand = createCommand({
 			if (result.dependencies && result.dependencies.length > 0) {
 				console.log(`${tui.muted('Dependencies:')}    ${result.dependencies.join(', ')}`);
 			}
+			if (result.metadata && Object.keys(result.metadata).length > 0) {
+				console.log(`${tui.muted('Metadata:')}        ${JSON.stringify(result.metadata)}`);
+			}
 		}
 
 		return {
@@ -97,6 +101,7 @@ export const getSubcommand = createCommand({
 			stdoutStreamUrl: result.stdoutStreamUrl,
 			stderrStreamUrl: result.stderrStreamUrl,
 			dependencies: result.dependencies,
+			metadata: result.metadata,
 		};
 	},
 });

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

@@ -8,6 +8,13 @@ import { deleteSubcommand } from './delete';
 import { snapshotCommand } from './snapshot';
 import { cpSubcommand } from './cp';
 import { command as executionCommand } from './execution';
+import { mkdirSubcommand } from './mkdir';
+import { rmdirSubcommand } from './rmdir';
+import { rmSubcommand } from './rm';
+import { lsSubcommand } from './ls';
+import { downloadSubcommand } from './download';
+import { uploadSubcommand } from './upload';
+import { envSubcommand } from './env';
 import { getCommand } from '../../../command-prefix';
 
 export const command = createCommand({
@@ -39,6 +46,13 @@ export const command = createCommand({
 		snapshotCommand,
 		cpSubcommand,
 		executionCommand,
+		mkdirSubcommand,
+		rmdirSubcommand,
+		rmSubcommand,
+		lsSubcommand,
+		downloadSubcommand,
+		uploadSubcommand,
+		envSubcommand,
 	],
 	requires: { auth: true, region: true, org: true },
 });

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

@@ -0,0 +1,126 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxListFiles } from '@agentuity/server';
+
+const FileInfoSchema = z.object({
+	path: z.string(),
+	size: z.number(),
+	isDir: z.boolean(),
+	mode: z.string(),
+	modTime: z.string(),
+});
+
+const LsResponseSchema = z.object({
+	files: z.array(FileInfoSchema),
+	total: z.number(),
+});
+
+export const lsSubcommand = createCommand({
+	name: 'files',
+	aliases: ['lsf'],
+	description: 'List files in a sandbox directory',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox files sbx_abc123'),
+			description: 'List files in the sandbox root directory',
+		},
+		{
+			command: getCommand('cloud sandbox files sbx_abc123 /path/to/dir'),
+			description: 'List files in a specific directory',
+		},
+		{
+			command: getCommand('cloud sandbox files sbx_abc123 -l'),
+			description: 'List files with permissions and modification time',
+		},
+		{
+			command: getCommand('cloud sandbox files sbx_abc123 --json'),
+			description: 'List files with JSON output',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			path: z.string().optional().describe('Path to list (defaults to root)'),
+		}),
+		options: z.object({
+			long: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Use long listing format with permissions and timestamps'),
+		}),
+		aliases: {
+			long: ['l'],
+		},
+		response: LsResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		const result = await sandboxListFiles(client, {
+			sandboxId: args.sandboxId,
+			path: args.path || '.',
+			orgId,
+		});
+
+		if (!options.json) {
+			if (result.files.length === 0) {
+				console.log(tui.muted('Directory is empty'));
+			} else {
+				for (const file of result.files) {
+					const typeIndicator = file.isDir ? tui.colorInfo('d') : tui.muted('-');
+					const sizeStr = file.isDir ? tui.muted('-') : formatSize(file.size);
+
+					if (opts.long) {
+						const modTimeStr = formatModTime(file.modTime);
+						console.log(
+							`${typeIndicator}${file.mode.padEnd(5)} ${sizeStr.padStart(10)}  ${modTimeStr}  ${file.path}`
+						);
+					} else {
+						console.log(`${typeIndicator} ${sizeStr.padStart(10)}  ${file.path}`);
+					}
+				}
+				console.log(tui.muted(`\nTotal: ${result.files.length} items`));
+			}
+		}
+
+		return { files: result.files, total: result.files.length };
+	},
+});
+
+function formatSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+function formatModTime(isoString: string): string {
+	try {
+		const date = new Date(isoString);
+		const now = new Date();
+		const isThisYear = date.getFullYear() === now.getFullYear();
+
+		const month = date.toLocaleString('en-US', { month: 'short' });
+		const day = date.getDate().toString().padStart(2, ' ');
+
+		if (isThisYear) {
+			const hours = date.getHours().toString().padStart(2, '0');
+			const minutes = date.getMinutes().toString().padStart(2, '0');
+			return `${month} ${day} ${hours}:${minutes}`;
+		} else {
+			return `${month} ${day}  ${date.getFullYear()}`;
+		}
+	} catch {
+		return isoString.slice(0, 16);
+	}
+}
+
+export default lsSubcommand;

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxMkDir } from '@agentuity/server';
+
+const MkDirResponseSchema = z.object({
+	success: z.boolean(),
+	path: z.string(),
+});
+
+export const mkdirSubcommand = createCommand({
+	name: 'mkdir',
+	description: 'Create a directory in a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox mkdir sbx_abc123 /path/to/dir'),
+			description: 'Create a directory in the sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox mkdir sbx_abc123 /path/to/nested/dir -p'),
+			description: 'Create nested directories recursively',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			path: z.string().describe('Path to the directory to create'),
+		}),
+		options: z.object({
+			parents: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Create parent directories as needed'),
+		}),
+		aliases: {
+			parents: ['p'],
+		},
+		response: MkDirResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		await sandboxMkDir(client, {
+			sandboxId: args.sandboxId,
+			path: args.path,
+			recursive: opts.parents,
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`Created directory: ${args.path}`);
+		}
+
+		return { success: true, path: args.path };
+	},
+});
+
+export default mkdirSubcommand;

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxRmFile } from '@agentuity/server';
+
+const RmFileResponseSchema = z.object({
+	success: z.boolean(),
+	path: z.string(),
+});
+
+export const rmSubcommand = createCommand({
+	name: 'rm',
+	description: 'Remove a file from a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox rm sbx_abc123 /path/to/file.txt'),
+			description: 'Remove a file from the sandbox',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			path: z.string().describe('Path to the file to remove'),
+		}),
+		options: z.object({}),
+		response: RmFileResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		await sandboxRmFile(client, {
+			sandboxId: args.sandboxId,
+			path: args.path,
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`Removed file: ${args.path}`);
+		}
+
+		return { success: true, path: args.path };
+	},
+});
+
+export default rmSubcommand;

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxRmDir } from '@agentuity/server';
+
+const RmDirResponseSchema = z.object({
+	success: z.boolean(),
+	path: z.string(),
+});
+
+export const rmdirSubcommand = createCommand({
+	name: 'rmdir',
+	description: 'Remove a directory from a sandbox',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox rmdir sbx_abc123 /path/to/dir'),
+			description: 'Remove an empty directory from the sandbox',
+		},
+		{
+			command: getCommand('cloud sandbox rmdir sbx_abc123 /path/to/dir -r'),
+			description: 'Remove a directory and all its contents recursively',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			path: z.string().describe('Path to the directory to remove'),
+		}),
+		options: z.object({
+			recursive: z
+				.boolean()
+				.default(false)
+				.optional()
+				.describe('Remove directory and all contents'),
+		}),
+		aliases: {
+			recursive: ['r'],
+		},
+		response: RmDirResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const client = createSandboxClient(logger, auth, region);
+
+		await sandboxRmDir(client, {
+			sandboxId: args.sandboxId,
+			path: args.path,
+			recursive: opts.recursive,
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`Removed directory: ${args.path}`);
+		}
+
+		return { success: true, path: args.path };
+	},
+});
+
+export default rmdirSubcommand;

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

@@ -7,7 +7,6 @@ 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'),
@@ -59,7 +58,6 @@ export const createSubcommand = createCommand({
 
 		return {
 			snapshotId: snapshot.snapshotId,
-			sandboxId: snapshot.sandboxId,
 			tag: snapshot.tag ?? undefined,
 			sizeBytes: snapshot.sizeBytes,
 			fileCount: snapshot.fileCount,

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

@@ -21,7 +21,6 @@ const SandboxInfoSchema = z.object({
 
 const SnapshotGetResponseSchema = z.object({
 	snapshotId: z.string().describe('Snapshot ID'),
-	sandboxId: z.string().describe('Source sandbox ID'),
 	tag: z.string().nullable().optional().describe('Snapshot tag'),
 	sizeBytes: z.number().describe('Snapshot size in bytes'),
 	fileCount: z.number().describe('Number of files'),
@@ -74,7 +73,6 @@ export const getSubcommand = createCommand({
 
 		if (!options.json) {
 			tui.info(`Snapshot: ${tui.bold(snapshot.snapshotId)}`);
-			console.log(`  ${tui.muted('Sandbox:')} ${snapshot.sandboxId}`);
 			if (snapshot.tag) {
 				console.log(`  ${tui.muted('Tag:')}     ${snapshot.tag}`);
 			}

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

@@ -7,7 +7,6 @@ import { snapshotList } from '@agentuity/server';
 
 const SnapshotInfoSchema = z.object({
 	snapshotId: z.string(),
-	sandboxId: z.string(),
 	tag: z.string().nullable().optional(),
 	sizeBytes: z.number(),
 	fileCount: z.number(),
@@ -64,7 +63,6 @@ export const listSubcommand = createCommand({
 					return {
 						ID: snap.snapshotId,
 						Tag: snap.tag ?? '-',
-						Sandbox: snap.sandboxId,
 						Size: tui.formatBytes(snap.sizeBytes),
 						Files: snap.fileCount,
 						'Created At': snap.createdAt,
@@ -73,7 +71,6 @@ export const listSubcommand = createCommand({
 				tui.table(tableData, [
 					{ name: 'ID', alignment: 'left' },
 					{ name: 'Tag', alignment: 'left' },
-					{ name: 'Sandbox', alignment: 'left' },
 					{ name: 'Size', alignment: 'right' },
 					{ name: 'Files', alignment: 'right' },
 					{ name: 'Created At', alignment: 'left' },

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

@@ -0,0 +1,83 @@
+import { z } from 'zod';
+import { readFileSync, statSync } from 'node:fs';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createSandboxClient } from './util';
+import { getCommand } from '../../../command-prefix';
+import { sandboxUploadArchive } from '@agentuity/server';
+
+export const uploadSubcommand = createCommand({
+	name: 'upload',
+	aliases: ['ul'],
+	description: 'Upload a compressed archive to a sandbox and extract it',
+	tags: ['slow', 'requires-auth'],
+	requires: { auth: true, region: true, org: true },
+	examples: [
+		{
+			command: getCommand('cloud sandbox upload sbx_abc123 ./archive.tar.gz'),
+			description: 'Upload and extract a tar.gz archive to sandbox root',
+		},
+		{
+			command: getCommand('cloud sandbox upload sbx_abc123 ./archive.zip --path /subdir'),
+			description: 'Upload and extract a zip archive to a specific directory',
+		},
+		{
+			command: getCommand('cloud sandbox upload sbx_abc123 ./archive.bin --format tar.gz'),
+			description: 'Upload with explicit format specification',
+		},
+	],
+	schema: {
+		args: z.object({
+			sandboxId: z.string().describe('The sandbox ID'),
+			archive: z.string().describe('Path to the archive file to upload'),
+		}),
+		options: z.object({
+			path: z.string().optional().describe('Destination path in sandbox (defaults to root)'),
+			format: z
+				.enum(['zip', 'tar.gz'])
+				.optional()
+				.describe('Archive format (auto-detected if not specified)'),
+		}),
+		response: z.object({
+			success: z.boolean(),
+			bytes: z.number(),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts, options, auth, region, logger, orgId } = ctx;
+
+		const client = createSandboxClient(logger, auth, region);
+
+		const stat = statSync(args.archive);
+		if (!stat.isFile()) {
+			logger.fatal(`${args.archive} is not a file`);
+		}
+
+		const content = readFileSync(args.archive);
+		const bytes = content.length;
+
+		await sandboxUploadArchive(client, {
+			sandboxId: args.sandboxId,
+			archive: content,
+			path: opts.path || '.',
+			format: opts.format || '',
+			orgId,
+		});
+
+		if (!options.json) {
+			tui.success(`Uploaded and extracted ${formatSize(bytes)} to sandbox`);
+		}
+
+		return { success: true, bytes };
+	},
+});
+
+function formatSize(bytes: number): string {
+	if (bytes < 1024) return `${bytes} bytes`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}
+
+export default uploadSubcommand;