@agentuity/cli 0.1.19 → 0.1.21

package/src/cmd/cloud/keyvalue/keys.ts

@@ -13,7 +13,8 @@ export const keysSubcommand = createCommand({
 	aliases: ['ls', 'list'],
 	description: 'List all keys in a keyvalue namespace',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('kv keys production'), description: 'List all keys in production' },

package/src/cmd/cloud/keyvalue/list-namespaces.ts

@@ -10,7 +10,8 @@ export const listNamespacesSubcommand = createCommand({
 	aliases: ['namespaces', 'ns'],
 	description: 'List all keyvalue namespaces',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{ command: getCommand('kv list-namespaces'), description: 'List all namespaces' },
 		{ command: getCommand('kv namespaces'), description: 'List namespaces (using alias)' },

package/src/cmd/cloud/keyvalue/repl.ts

@@ -11,7 +11,7 @@ export const replSubcommand = createCommand({
 	description: 'Start an interactive repl for working with keyvalue database',
 	tags: ['slow', 'requires-auth'],
 	idempotent: false,
-	requires: { auth: true },
+	requires: { auth: true, region: true },
 	optional: { project: true },
 	examples: [{ command: getCommand('kv repl'), description: 'Start interactive KV session' }],
 

package/src/cmd/cloud/keyvalue/search.ts

@@ -20,7 +20,8 @@ export const searchSubcommand = createCommand({
 	name: 'search',
 	description: 'Search for keys matching a keyword in a keyvalue namespace',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{

package/src/cmd/cloud/keyvalue/set.ts

@@ -19,7 +19,8 @@ export const setSubcommand = createCommand({
 	description: 'Set a key and value in the keyvalue storage',
 	tags: ['mutating', 'updates-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{
 			command: getCommand(

package/src/cmd/cloud/keyvalue/stats.ts

@@ -26,7 +26,8 @@ export const statsSubcommand = createCommand({
 	name: 'stats',
 	description: 'Get statistics for keyvalue storage',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('kv stats'), description: 'Show stats for all namespaces' },

package/src/cmd/cloud/keyvalue/util.ts

@@ -1,25 +1,33 @@
 import { KeyValueStorageService, type Logger } from '@agentuity/core';
 import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
-import { getDefaultRegion } from '../../../config';
-import type { AuthData, Config } from '../../../types';
+import type { AuthData, GlobalOptions, ProjectConfig } from '../../../types';
+import * as tui from '../../../tui';
 
-export async function createStorageAdapter(ctx: {
+export function createStorageAdapter(ctx: {
 	logger: Logger;
-	config: Config | null;
 	auth: AuthData;
-	project?: { region: string };
+	region: string;
+	project?: ProjectConfig;
+	options: GlobalOptions;
 }) {
+	const orgId = ctx.project?.orgId ?? ctx.options.orgId;
+	if (!orgId) {
+		tui.fatal(
+			'Organization ID is required. Either run from a project directory or use --org-id flag.'
+		);
+	}
+
 	const adapter = createServerFetchAdapter(
 		{
 			headers: {
 				Authorization: `Bearer ${ctx.auth.apiKey}`,
+				'x-agentuity-orgid': orgId,
 			},
 		},
 		ctx.logger
 	);
 
-	const region = ctx.project?.region || (await getDefaultRegion(ctx.config?.name, ctx.config));
-	const urls = getServiceUrls(region);
+	const urls = getServiceUrls(ctx.region);
 	const baseUrl = urls.catalyst;
 	return new KeyValueStorageService(baseUrl, adapter);
 }

package/src/cmd/cloud/machine/delete.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { machineDelete, machineGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getGlobalCatalystAPIClient } from '../../../config';
+import enquirer from 'enquirer';
+
+const MachineDeleteResponseSchema = z.object({
+	success: z.boolean().describe('Whether the deletion succeeded'),
+	machineId: z.string().describe('The deleted machine ID'),
+});
+
+export const deleteSubcommand = createSubcommand({
+	name: 'delete',
+	description: 'Delete an organization managed machine',
+	tags: ['mutating', 'destructive', 'slow', 'requires-auth'],
+	examples: [
+		{
+			command: `${getCommand('cloud machine delete')} mach_abc123xyz`,
+			description: 'Delete a machine (with confirmation)',
+		},
+		{
+			command: `${getCommand('cloud machine delete')} mach_abc123xyz --confirm`,
+			description: 'Delete a machine without confirmation',
+		},
+	],
+	aliases: ['rm', 'remove'],
+	requires: { auth: true, org: true },
+	idempotent: false,
+	schema: {
+		args: z.object({
+			machine_id: z.string().describe('Machine ID'),
+		}),
+		options: z.object({
+			confirm: z.boolean().optional().default(false).describe('Skip confirmation prompt'),
+		}),
+		response: MachineDeleteResponseSchema,
+	},
+	async handler(ctx) {
+		const { args, opts, options, logger, auth, config, orgId } = ctx;
+
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name, orgId);
+
+		try {
+			const machine = await machineGet(catalystClient, args.machine_id);
+
+			if (!opts.confirm) {
+				if (process.stdin.isTTY) {
+					tui.newline();
+					tui.warn(`You are about to delete machine ${tui.bold(machine.id)}`);
+					if (machine.orgName) {
+						tui.info(`Organization: ${machine.orgName}`);
+					}
+					tui.newline();
+
+					const response = await enquirer.prompt<{ confirm: boolean }>({
+						type: 'confirm',
+						name: 'confirm',
+						message: 'Are you sure you want to delete this machine?',
+						initial: false,
+					});
+
+					if (!response.confirm) {
+						tui.info('Deletion cancelled.');
+						return { success: false, machineId: args.machine_id };
+					}
+				} else {
+					tui.error('Non-interactive sessions require --confirm flag to delete a machine.');
+					return { success: false, machineId: args.machine_id };
+				}
+			}
+
+			await tui.spinner({
+				type: 'simple',
+				message: 'Deleting machine...',
+				callback: () => machineDelete(catalystClient, args.machine_id),
+				clearOnSuccess: true,
+			});
+
+			if (!options.json) {
+				tui.success(`Machine ${args.machine_id} deleted successfully.`);
+			}
+
+			return { success: true, machineId: args.machine_id };
+		} catch (ex) {
+			tui.fatal(`Failed to delete machine: ${ex}`, ErrorCode.API_ERROR);
+		}
+	},
+});

package/src/cmd/cloud/machine/deployments.ts

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { machineDeployments } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getGlobalCatalystAPIClient } from '../../../config';
+
+const MachineDeploymentResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Deployment ID'),
+		identifier: z.string().optional().describe('Deployment identifier'),
+		state: z.string().optional().describe('Deployment state'),
+		projectName: z.string().optional().describe('Project name'),
+		projectId: z.string().optional().describe('Project ID'),
+		paused: z.boolean().describe('Whether the deployment is paused'),
+		domainSuffix: z.string().describe('Domain suffix'),
+		url: z.string().describe('URL to the deployment'),
+	})
+);
+
+export const deploymentsSubcommand = createSubcommand({
+	name: 'deployments',
+	description: 'List deployments running on a specific organization managed machine',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [
+		{
+			command: `${getCommand('cloud machine deployments')} machine_abc123xyz`,
+			description: 'List deployments on a machine',
+		},
+	],
+	aliases: ['deps', 'deployment'],
+	requires: { auth: true, org: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			machine_id: z.string().describe('Machine ID'),
+		}),
+		response: MachineDeploymentResponseSchema,
+	},
+	async handler(ctx) {
+		const { args, options, logger, auth, config, orgId } = ctx;
+
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name, orgId);
+
+		try {
+			const deployments = await machineDeployments(catalystClient, args.machine_id);
+
+			const result = deployments.map((d) => ({
+				id: d.id,
+				identifier: d.identifier,
+				state: d.state,
+				projectName: d.project?.name,
+				projectId: d.project?.id,
+				paused: d.paused,
+				domainSuffix: d.domainSuffix,
+				url:
+					d.customDomains?.length > 0
+						? d.customDomains.map((domain) => `https://${domain}`).join(',')
+						: d.identifier
+							? `https://d${d.identifier}.${d.domainSuffix}`
+							: d.project?.identifier
+								? `https://p${d.project?.identifier}.${d.domainSuffix}`
+								: '',
+			}));
+
+			if (!options.json) {
+				if (deployments.length === 0) {
+					tui.info('No deployments found on this machine.');
+				} else {
+					const tableData = result.map((d) => ({
+						ID: d.id,
+						State: d.state || 'unknown',
+						Project: d.projectName ? `${d.projectName} (${d.projectId})` : '-',
+						Paused: d.paused ? 'Yes' : 'No',
+						URL: d.url,
+					}));
+
+					tui.table(tableData, [
+						{ name: 'ID', alignment: 'left' },
+						{ name: 'State', alignment: 'left' },
+						{ name: 'Project', alignment: 'left' },
+						{ name: 'Paused', alignment: 'center' },
+						{ name: 'URL', alignment: 'left' },
+					]);
+				}
+			}
+
+			return result;
+		} catch (ex) {
+			tui.fatal(`Failed to get machine deployments: ${ex}`, ErrorCode.API_ERROR);
+		}
+	},
+});

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

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { machineGet } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getGlobalCatalystAPIClient } from '../../../config';
+
+const MachineGetResponseSchema = z.object({
+	id: z.string().describe('Machine ID'),
+	status: z.string().describe('Machine status'),
+	provider: z.string().describe('Cloud provider'),
+	region: z.string().describe('Region'),
+	instanceId: z.string().nullable().optional().describe('Cloud instance ID'),
+	privateIPv4: z.string().nullable().optional().describe('Private IPv4 of the machine'),
+	availabilityZone: z.string().nullable().optional().describe('Availability zone of the machine'),
+	deploymentCount: z.number().describe('The number of deployments'),
+	orgId: z.string().nullable().optional().describe('Organization ID'),
+	orgName: z.string().nullable().optional().describe('Organization name'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().nullable().optional().describe('Last update timestamp'),
+	startedAt: z.string().nullable().optional().describe('Start timestamp'),
+	stoppedAt: z.string().nullable().optional().describe('Stop timestamp'),
+	error: z.string().nullable().optional().describe('Error message if any'),
+});
+
+export const getSubcommand = createSubcommand({
+	name: 'get',
+	description: 'Get details about a specific organization managed machine',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	examples: [
+		{
+			command: `${getCommand('cloud machine get')} machine_abc123xyz`,
+			description: 'Get machine details by ID',
+		},
+	],
+	aliases: ['show'],
+	requires: { auth: true, org: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			machine_id: z.string().describe('Machine ID'),
+		}),
+		response: MachineGetResponseSchema,
+	},
+	async handler(ctx) {
+		const { args, options, logger, auth, config, orgId } = ctx;
+
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name, orgId);
+
+		try {
+			const machine = await machineGet(catalystClient, args.machine_id);
+
+			if (!options.json) {
+				const tableData: Record<string, string> = {
+					ID: machine.id,
+					Status: machine.status,
+					Provider: machine.provider,
+					Region: machine.region,
+				};
+
+				if (machine.instanceId) {
+					tableData['Instance ID'] = machine.instanceId;
+				}
+				if (machine.privateIPv4) {
+					tableData['Private IP'] = machine.privateIPv4;
+				}
+				if (machine.availabilityZone) {
+					tableData['Availability Zone'] = machine.availabilityZone;
+				}
+				tableData['Deployments'] = (machine.deploymentCount ?? 0).toString();
+				tableData['Created'] = new Date(machine.createdAt).toLocaleString();
+				if (machine.updatedAt) {
+					tableData['Updated'] = new Date(machine.updatedAt).toLocaleString();
+				}
+				if (machine.startedAt) {
+					tableData['Started'] = new Date(machine.startedAt).toLocaleString();
+				}
+				if (machine.stoppedAt) {
+					tableData['Stopped'] = new Date(machine.stoppedAt).toLocaleString();
+				}
+				if (machine.error) {
+					tableData['Error'] = machine.error;
+				}
+
+				tui.table([tableData], Object.keys(tableData), { layout: 'vertical', padStart: '  ' });
+			}
+
+			return {
+				id: machine.id,
+				status: machine.status,
+				provider: machine.provider,
+				region: machine.region,
+				instanceId: machine.instanceId ?? undefined,
+				orgId: machine.orgId ?? undefined,
+				orgName: machine.orgName ?? undefined,
+				createdAt: machine.createdAt,
+				updatedAt: machine.updatedAt ?? undefined,
+				startedAt: machine.startedAt ?? undefined,
+				stoppedAt: machine.stoppedAt ?? undefined,
+				error: machine.error ?? undefined,
+				deploymentCount: machine.deploymentCount ?? 0,
+				privateIPv4: machine.privateIPv4,
+				availabilityZone: machine.availabilityZone,
+			};
+		} catch (ex) {
+			tui.fatal(`Failed to get machine: ${ex}`, ErrorCode.API_ERROR);
+		}
+	},
+});

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

@@ -0,0 +1,22 @@
+import { createCommand } from '../../../types';
+import { listSubcommand } from './list';
+import { getSubcommand } from './get';
+import { deploymentsSubcommand } from './deployments';
+import { deleteSubcommand } from './delete';
+import { getCommand } from '../../../command-prefix';
+
+export const machineCommand = createCommand({
+	name: 'machine',
+	description: 'Manage organization managed machines',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	aliases: ['machines'],
+	examples: [
+		{ command: getCommand('cloud machine list'), description: 'List all machines' },
+		{ command: getCommand('cloud machine get <id>'), description: 'Get machine details' },
+		{
+			command: getCommand('cloud machine deployments <id>'),
+			description: 'List deployments on a machine',
+		},
+	],
+	subcommands: [listSubcommand, getSubcommand, deploymentsSubcommand, deleteSubcommand],
+});

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

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { machineList } from '@agentuity/server';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+import { getGlobalCatalystAPIClient } from '../../../config';
+
+const MachineListResponseSchema = z.array(
+	z.object({
+		id: z.string().describe('Machine ID'),
+		status: z.string().describe('Machine status'),
+		provider: z.string().describe('Cloud provider'),
+		region: z.string().describe('Region'),
+		orgName: z.string().nullable().optional().describe('Organization name'),
+		createdAt: z.string().describe('Creation timestamp'),
+	})
+);
+
+export const listSubcommand = createSubcommand({
+	name: 'list',
+	description: 'List organization managed machines',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud machine list'),
+			description: 'List all machines',
+		},
+	],
+	aliases: ['ls'],
+	requires: { auth: true, org: true },
+	idempotent: true,
+	schema: {
+		response: MachineListResponseSchema,
+	},
+	async handler(ctx) {
+		const { options, logger, auth, config, orgId } = ctx;
+
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name, orgId);
+
+		try {
+			const machines = await machineList(catalystClient);
+
+			const result = machines.map((m) => ({
+				id: m.id,
+				status: m.status,
+				provider: m.provider,
+				region: m.region,
+				orgName: m.orgName ?? undefined,
+				createdAt: m.createdAt,
+			}));
+
+			if (!options.json) {
+				if (machines.length === 0) {
+					tui.info('No machines found.');
+				} else {
+					const tableData = machines.map((m) => ({
+						ID: m.id,
+						Status: m.status,
+						Provider: m.provider,
+						Region: m.region,
+						Created: new Date(m.createdAt).toLocaleString(),
+					}));
+
+					tui.table(tableData, [
+						{ name: 'ID', alignment: 'left' },
+						{ name: 'Status', alignment: 'left' },
+						{ name: 'Provider', alignment: 'left' },
+						{ name: 'Region', alignment: 'left' },
+						{ name: 'Created', alignment: 'left' },
+					]);
+				}
+			}
+
+			return result;
+		} catch (ex) {
+			tui.fatal(`Failed to list machines: ${ex}`, ErrorCode.API_ERROR);
+		}
+	},
+});

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

@@ -19,7 +19,7 @@ import { getCommand } from '../../../command-prefix';
 export const command = createCommand({
 	name: 'queue',
 	aliases: ['queues'],
-	description: 'Manage message queues',
+	description: 'Manage managed message queues',
 	tags: ['requires-auth'],
 	examples: [
 		{

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

@@ -4,7 +4,7 @@ import { getCommand } from '../../../command-prefix';
 
 export const redisCommand = createCommand({
 	name: 'redis',
-	description: 'Manage Redis resources',
+	description: 'Manage Redis managed resources',
 	tags: ['slow', 'requires-auth'],
 	examples: [
 		{ command: getCommand('cloud redis show'), description: 'Show Redis connection URL' },

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

@@ -12,6 +12,22 @@ const SandboxResourcesSchema = z.object({
 	disk: z.string().optional().describe('Disk limit (e.g., "1Gi", "10Gi")'),
 });
 
+const SandboxRuntimeInfoSchema = z.object({
+	id: z.string().describe('Runtime ID'),
+	name: z.string().describe('Runtime name'),
+	iconUrl: z.string().optional().describe('URL for runtime icon'),
+	brandColor: z.string().optional().describe('Brand color for the runtime'),
+	tags: z.array(z.string()).optional().describe('Runtime tags'),
+});
+
+const SandboxSnapshotInfoSchema = z.object({
+	id: z.string().describe('Snapshot ID'),
+	name: z.string().optional().describe('Snapshot name'),
+	tag: z.string().optional().describe('Snapshot tag'),
+	fullName: z.string().optional().describe('Full name with org slug'),
+	public: z.boolean().describe('Whether snapshot is public'),
+});
+
 const SandboxGetResponseSchema = z.object({
 	sandboxId: z.string().describe('Sandbox ID'),
 	name: z.string().optional().describe('Sandbox name'),
@@ -19,10 +35,8 @@ const SandboxGetResponseSchema = z.object({
 	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'),
+	runtime: SandboxRuntimeInfoSchema.optional().describe('Runtime information'),
+	snapshot: SandboxSnapshotInfoSchema.optional().describe('Snapshot information'),
 	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'),
@@ -73,15 +87,6 @@ export const getSubcommand = createCommand({
 							? tui.colorError
 							: tui.colorMuted;
 
-			const snapshotDisplay =
-				result.snapshotId || result.snapshotTag
-					? result.snapshotTag
-						? result.snapshotId
-							? `${result.snapshotTag} ${tui.muted('(' + result.snapshotId + ')')}`
-							: result.snapshotTag
-						: result.snapshotId
-					: undefined;
-
 			let streamDisplay: string | undefined;
 			if (
 				result.stdoutStreamUrl &&
@@ -106,9 +111,15 @@ export const getSubcommand = createCommand({
 			if (result.description) tableData['Description'] = result.description;
 			tableData['Status'] = statusColor(result.status);
 			tableData['Created'] = result.createdAt;
-			if (result.runtimeName) tableData['Runtime'] = result.runtimeName;
+			if (result.runtime?.name) tableData['Runtime'] = result.runtime.name;
 			if (result.region) tableData['Region'] = result.region;
-			if (snapshotDisplay) tableData['Snapshot'] = snapshotDisplay;
+			if (result.snapshot?.id) {
+				const snapshotDisplay =
+					result.snapshot.public && result.snapshot.fullName
+						? result.snapshot.fullName
+						: result.snapshot.tag || result.snapshot.id;
+				tableData['Snapshot'] = snapshotDisplay;
+			}
 			tableData['Executions'] = result.executions;
 			if (streamDisplay) {
 				tableData['Stream'] = streamDisplay;
@@ -141,10 +152,8 @@ export const getSubcommand = createCommand({
 			status: result.status,
 			createdAt: result.createdAt,
 			region: result.region,
-			runtimeId: result.runtimeId,
-			runtimeName: result.runtimeName,
-			snapshotId: result.snapshotId,
-			snapshotTag: result.snapshotTag,
+			runtime: result.runtime,
+			snapshot: result.snapshot,
 			executions: result.executions,
 			stdoutStreamUrl: result.stdoutStreamUrl,
 			stderrStreamUrl: result.stderrStreamUrl,

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

@@ -21,7 +21,7 @@ import { getCommand } from '../../../command-prefix';
 export const command = createCommand({
 	name: 'sandbox',
 	aliases: ['sb'],
-	description: 'Manage sandboxes for isolated code execution',
+	description: 'Manage sandboxes for managed isolated code execution',
 	tags: ['slow', 'requires-auth'],
 	examples: [
 		{