@agentuity/cli 0.1.9 → 0.1.11

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

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { cacheSandboxRegion } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxGet } from '@agentuity/server';
+import { getGlobalCatalystAPIClient } from '../../../config';
 
 const SandboxResourcesSchema = z.object({
 	memory: z.string().optional().describe('Memory limit (e.g., "512Mi", "1Gi")'),
@@ -35,7 +36,7 @@ export const getSubcommand = createCommand({
 	aliases: ['info', 'show'],
 	description: 'Get information about a sandbox',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	idempotent: true,
 	examples: [
 		{
@@ -51,11 +52,16 @@ export const getSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, auth, region, logger, orgId } = ctx;
-		const client = createSandboxClient(logger, auth, region);
+		const { args, options, auth, logger, orgId, config } = ctx;
+		const client = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
 		const result = await sandboxGet(client, { sandboxId: args.sandboxId, orgId });
 
+		// Cache the region for future lookups
+		if (result.region) {
+			await cacheSandboxRegion(config?.name, args.sandboxId, result.region);
+		}
+
 		if (!options.json) {
 			const statusColor =
 				result.status === 'running'

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

@@ -56,7 +56,7 @@ export const command = createCommand({
 		uploadSubcommand,
 		envSubcommand,
 	],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 });
 
 export default command;

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

@@ -3,7 +3,7 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCommand } from '../../../command-prefix';
 import { sandboxList } from '@agentuity/server';
-import { createSandboxClient } from './util';
+import { getGlobalCatalystAPIClient } from '../../../config';
 import type { SandboxStatus } from '@agentuity/core';
 
 const SandboxInfoSchema = z.object({
@@ -30,7 +30,7 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List sandboxes with optional filtering',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	optional: { project: true },
 	idempotent: true,
 	pagination: {
@@ -74,8 +74,8 @@ export const listSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { opts, options, auth, project, region, logger, orgId } = ctx;
-		const client = createSandboxClient(logger, auth, region);
+		const { opts, options, auth, project, logger, orgId, config } = ctx;
+		const client = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
 		const projectId = opts.projectId || project?.projectId;
 

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { getSandboxRegion, createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxListFiles } from '@agentuity/server';
 
@@ -23,7 +23,7 @@ export const lsSubcommand = createCommand({
 	aliases: ['lsf'],
 	description: 'List files in a sandbox directory',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox files sbx_abc123'),
@@ -61,7 +61,8 @@ export const lsSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const { args, opts, options, auth, config, logger, orgId } = ctx;
+		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		const result = await sandboxListFiles(client, {

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { createSandboxClient, getSandboxRegion } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxMkDir } from '@agentuity/server';
 
@@ -14,7 +14,7 @@ export const mkdirSubcommand = createCommand({
 	name: 'mkdir',
 	description: 'Create a directory in a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox mkdir sbx_abc123 /path/to/dir'),
@@ -44,7 +44,8 @@ export const mkdirSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const { args, opts, options, auth, logger, orgId, config } = ctx;
+		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxMkDir(client, {

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { getSandboxRegion, createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxRmFile } from '@agentuity/server';
 
@@ -14,7 +14,7 @@ export const rmSubcommand = createCommand({
 	name: 'rm',
 	description: 'Remove a file from a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox rm sbx_abc123 /path/to/file.txt'),
@@ -31,7 +31,8 @@ export const rmSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options, auth, region, logger, orgId } = ctx;
+		const { args, options, auth, logger, orgId, config } = ctx;
+		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxRmFile(client, {

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient } from './util';
+import { createSandboxClient, getSandboxRegion } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxRmDir } from '@agentuity/server';
 
@@ -14,7 +14,7 @@ export const rmdirSubcommand = createCommand({
 	name: 'rmdir',
 	description: 'Remove a directory from a sandbox',
 	tags: ['slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox rmdir sbx_abc123 /path/to/dir'),
@@ -44,7 +44,8 @@ export const rmdirSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const { args, opts, options, auth, logger, orgId, config } = ctx;
+		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		await sandboxRmDir(client, {

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

@@ -2,9 +2,11 @@ import { z } from 'zod';
 import { Writable } from 'node:stream';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, parseFileArgs } from './util';
+import { createSandboxClient, parseFileArgs, cacheSandboxRegion } from './util';
 import { getCommand } from '../../../command-prefix';
 import { sandboxRun } from '@agentuity/server';
+import { validateAptDependencies } from '../../../utils/apt-validator';
+import { ErrorCode } from '../../../errors';
 
 const SandboxRunResponseSchema = z.object({
 	sandboxId: z.string().describe('Sandbox ID'),
@@ -37,10 +39,7 @@ 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")'),
+			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'),
@@ -69,10 +68,53 @@ export const runSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, region, logger, orgId } = ctx;
+		const { args, opts, options, auth, region, config, logger, orgId } = ctx;
 		const client = createSandboxClient(logger, auth, region);
 		const started = Date.now();
 
+		// Validate apt dependencies before running sandbox
+		if (opts.dependency && opts.dependency.length > 0) {
+			const aptValidation = await tui.spinner({
+				message: 'Validating apt dependencies...',
+				type: 'simple',
+				callback: async () => {
+					return await validateAptDependencies(opts.dependency!, region, config, logger);
+				},
+			});
+
+			if (aptValidation.invalid.length > 0) {
+				if (options.json) {
+					return {
+						sandboxId: '',
+						exitCode: 1,
+						durationMs: 0,
+						errors: aptValidation.invalid.map((pkg) => ({
+							type: 'invalid-apt-dependency',
+							package: pkg.package,
+							error: pkg.error,
+							searchUrl: pkg.searchUrl,
+							availableVersions: pkg.availableVersions,
+						})),
+					} as never;
+				}
+
+				tui.error('Invalid apt dependencies:');
+				tui.newline();
+				for (const pkg of aptValidation.invalid) {
+					tui.bullet(`${tui.bold(pkg.package)}: ${pkg.error}`);
+					if (pkg.availableVersions && pkg.availableVersions.length > 0) {
+						tui.muted(`    Available versions: ${pkg.availableVersions.join(', ')}`);
+					}
+					tui.muted(`    Search: ${tui.link(pkg.searchUrl)}`);
+				}
+				tui.newline();
+				tui.fatal(
+					'Fix the apt dependencies and try again. Search for valid packages at: https://packages.debian.org/stable/',
+					ErrorCode.CONFIG_INVALID
+				);
+			}
+		}
+
 		const envMap: Record<string, string> = {};
 		if (opts.env) {
 			for (const e of opts.env) {
@@ -142,6 +184,9 @@ export const runSubcommand = createCommand({
 				logger,
 			});
 
+			// Cache the region for future lookups (sandbox is destroyed after run but cache helps with lookups during execution)
+			await cacheSandboxRegion(config?.name, result.sandboxId, region);
+
 			const duration = Date.now() - started;
 			const output = outputChunks.join('');
 

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

@@ -14,7 +14,7 @@ export const runtimeCommand = createCommand({
 		},
 	],
 	subcommands: [listSubcommand],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 });
 
 export default runtimeCommand;

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

@@ -1,9 +1,9 @@
 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';
+import { getGlobalCatalystAPIClient } from '../../../../config';
 
 const RuntimeInfoSchema = z.object({
 	id: z.string().describe('Runtime ID'),
@@ -21,7 +21,7 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List available sandbox runtimes',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, region: true, org: true },
+	requires: { auth: true, org: true },
 	idempotent: true,
 	examples: [
 		{
@@ -38,8 +38,8 @@ export const listSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { opts, options, auth, region, logger, orgId } = ctx;
-		const client = createSandboxClient(logger, auth, region);
+		const { opts, options, auth, logger, orgId, config } = ctx;
+		const client = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
 		const result = await runtimeList(client, {
 			orgId,