@agentuity/cli 0.1.20 → 0.1.22

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/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: [
 		{

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

@@ -10,7 +10,7 @@ import { getCommand } from '../../../command-prefix';
 export const storageCommand = createCommand({
 	name: 'storage',
 	aliases: ['s3'],
-	description: 'Manage storage resources',
+	description: 'Manage S3 compatible managed storage resources',
 	tags: ['slow', 'requires-auth', 'requires-deployment'],
 	examples: [
 		{ command: getCommand('cloud storage list'), description: 'List all storage resources' },

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

@@ -7,7 +7,7 @@ import { getCommand } from '../../../command-prefix';
 export const streamCommand = createCommand({
 	name: 'stream',
 	aliases: ['streams'],
-	description: 'Manage streams',
+	description: 'Manage durable streams',
 	tags: ['slow', 'requires-auth'],
 	examples: [
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },

package/src/cmd/cloud/vector/delete-namespace.ts

@@ -11,7 +11,8 @@ export const deleteNamespaceSubcommand = createCommand({
 	description: 'Delete a vector namespace and all its vectors',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{
 			command: getCommand('vector delete-namespace staging'),

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

@@ -18,7 +18,8 @@ export const deleteSubcommand = createCommand({
 	aliases: ['del', 'rm'],
 	description: 'Delete one or more vectors by key',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{

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

@@ -16,7 +16,8 @@ export const getSubcommand = createCommand({
 	name: 'get',
 	description: 'Get a specific vector entry by key',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{

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

@@ -34,7 +34,7 @@ export const vectorCommand = createCommand({
 		listNamespacesSubcommand,
 		deleteNamespaceSubcommand,
 	],
-	requires: { auth: true, project: true },
+	requires: { auth: true },
 });
 
 export default vectorCommand;

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

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

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

@@ -22,7 +22,8 @@ export const searchSubcommand = createCommand({
 	aliases: ['list', 'ls'],
 	description: 'Search for vectors using semantic similarity',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{

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

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

package/src/cmd/cloud/vector/upsert.ts

@@ -26,7 +26,8 @@ export const upsertSubcommand = createCommand({
 	description: 'Add or update vectors in the vector storage',
 	tags: ['mutating', 'updates-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{
 			command: getCommand('vector upsert products doc1 --document "Comfortable office chair"'),

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

@@ -1,30 +1,37 @@
-import { Logger, VectorStorageService } from '@agentuity/core';
+import { type Logger, VectorStorageService } from '@agentuity/core';
 import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
-import { loadProjectSDKKey } from '../../../config';
-import type { Config } from '../../../types';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 import * as tui from '../../../tui';
 
-export async function createStorageAdapter(ctx: {
+export function createStorageAdapter(ctx: {
 	logger: Logger;
-	projectDir: string;
+	auth: AuthData;
+	region: string;
+	project?: ProjectConfig;
 	config: Config | null;
-	project: { region: string };
+	options: GlobalOptions;
 }) {
-	const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
-	if (!sdkKey) {
-		tui.fatal(`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`);
+	const orgId =
+		ctx.project?.orgId ??
+		ctx.options.orgId ??
+		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.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 ${sdkKey}`,
+				Authorization: `Bearer ${ctx.auth.apiKey}`,
+				'x-agentuity-orgid': orgId,
 			},
 		},
 		ctx.logger
 	);
 
-	const urls = getServiceUrls(ctx.project.region);
+	const urls = getServiceUrls(ctx.region);
 	const baseUrl = urls.catalyst;
 	return new VectorStorageService(baseUrl, adapter);
 }

package/src/cmd/setup/index.ts

@@ -37,9 +37,14 @@ export const command = createCommand({
 						message: 'Validating your identity',
 						clearOnSuccess: true,
 						callback: async () => {
-							const newargs = process.argv.map((x) => (x === 'setup' ? 'login' : x));
+							// For compiled binaries, process.argv contains virtual paths (/$bunfs/root/...)
+							// Use process.execPath which has the actual binary path
+							const isCompiledBinary = process.argv[1]?.startsWith('/$bunfs/');
+							const cmd = isCompiledBinary
+								? [process.execPath, ...process.argv.slice(2).map((x) => (x === 'setup' ? 'login' : x))]
+								: process.argv.map((x) => (x === 'setup' ? 'login' : x));
 							const r = Bun.spawn({
-								cmd: newargs.concat('--json'),
+								cmd: cmd.concat('--json'),
 								stdout: 'pipe',
 								stderr: 'inherit',
 							});

package/src/config.ts

@@ -733,10 +733,19 @@ export async function loadProjectSDKKey(
 	logger.trace(`[SDK_KEY] AGENTUITY_SDK_KEY not found in any file`);
 }
 
-export function getCatalystAPIClient(logger: Logger, auth: AuthData, region: string) {
+export function getCatalystAPIClient(
+	logger: Logger,
+	auth: AuthData,
+	region: string,
+	orgId?: string
+) {
 	const serviceUrls = getServiceUrls(region);
 	const catalystUrl = serviceUrls.catalyst;
-	return new ServerAPIClient(catalystUrl, logger, auth.apiKey);
+	const headers: Record<string, string> = {};
+	if (orgId) {
+		headers['x-agentuity-orgid'] = orgId;
+	}
+	return new ServerAPIClient(catalystUrl, logger, auth.apiKey, { headers });
 }
 
 interface RegionsCacheData {
@@ -795,14 +804,20 @@ export async function getDefaultRegion(
 /**
  * Get a Catalyst API client for global database operations.
  * Uses the default region since the admin DB is global.
+ *
+ * @param logger - Logger instance
+ * @param auth - Authentication data
+ * @param profileName - Profile name (default: 'production')
+ * @param orgId - Optional organization ID for CLI key authentication
  */
 export async function getGlobalCatalystAPIClient(
 	logger: Logger,
 	auth: AuthData,
-	profileName = 'production'
+	profileName = 'production',
+	orgId?: string
 ) {
 	const region = await getDefaultRegion(profileName);
-	return getCatalystAPIClient(logger, auth, region);
+	return getCatalystAPIClient(logger, auth, region, orgId);
 }
 
 export function getIONHost(config: Config | null, region: string) {

package/src/env-util.ts

@@ -17,7 +17,7 @@ export const PUBLIC_VAR_PREFIXES = ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'] as
  * Specific AGENTUITY_ keys that are allowed to be set by users.
  * Note: There is also a whitelist in the API that must be kept in sync.
  */
-export const AGENTUITY_ALLOWED_KEYS = ['AGENTUITY_AUTH_SECRET'] as const;
+export const AGENTUITY_ALLOWED_KEYS = ['AGENTUITY_AUTH_SECRET', 'AGENTUITY_CLOUD_BASE_URL'] as const;
 
 /**
  * Check if a key is a public variable (exposed to frontend)