@agentuity/cli 1.0.1 → 1.0.3

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

@@ -183,26 +183,26 @@ function buildFileTree(files: SnapshotFileInfo[]): TreeNode {
 		const parts = file.path.split('/');
 		let current = root;
 
-	for (let i = 0; i < parts.length; i++) {
-		const part = parts[i];
-		if (!part) continue;
-		if (!current.children.has(part)) {
-			current.children.set(part, {
-				name: part,
-				isFile: i === parts.length - 1,
-				children: new Map(),
-			});
-		}
-		const child = current.children.get(part);
-		if (!child) continue;
-		current = child;
+		for (let i = 0; i < parts.length; i++) {
+			const part = parts[i];
+			if (!part) continue;
+			if (!current.children.has(part)) {
+				current.children.set(part, {
+					name: part,
+					isFile: i === parts.length - 1,
+					children: new Map(),
+				});
+			}
+			const child = current.children.get(part);
+			if (!child) continue;
+			current = child;
 
-		if (i === parts.length - 1) {
-			current.size = file.size;
-			current.isFile = true;
+			if (i === parts.length - 1) {
+				current.size = file.size;
+				current.isFile = true;
+			}
 		}
 	}
-	}
 
 	return root;
 }

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

@@ -2,16 +2,16 @@ import { z } from 'zod';
 import { readFileSync, statSync } from 'node:fs';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createSandboxClient, getSandboxRegion } from './util';
+import { createSandboxClient } from './util';
 import { getCommand } from '../../../command-prefix';
-import { sandboxUploadArchive } from '@agentuity/server';
+import { sandboxUploadArchive, sandboxResolve } 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, org: true },
+	requires: { auth: true, apiClient: true },
 	examples: [
 		{
 			command: getCommand('cloud sandbox upload sbx_abc123 ./archive.tar.gz'),
@@ -45,9 +45,12 @@ export const uploadSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, opts, options, auth, logger, orgId, config } = ctx;
+		const { args, opts, options, auth, logger, apiClient } = ctx;
+
+		// Resolve sandbox to get region and orgId using CLI API
+		const sandboxInfo = await sandboxResolve(apiClient, args.sandboxId);
+		const { region, orgId } = sandboxInfo;
 
-		const region = await getSandboxRegion(logger, auth, config?.name, args.sandboxId, orgId);
 		const client = createSandboxClient(logger, auth, region);
 
 		const stat = statSync(args.archive);

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

@@ -1,16 +1,15 @@
-import { existsSync, readFileSync } from 'node:fs';
+import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import type { Logger, FileToWrite } from '@agentuity/core';
-import { APIClient, getServiceUrls, sandboxGet } from '@agentuity/server';
+import { APIClient, sandboxGet, getServiceUrls } from '@agentuity/server';
 import type { AuthData } from '../../../types';
 import { getGlobalCatalystAPIClient } from '../../../config';
-import { getResourceRegion, setResourceRegion, deleteResourceRegion } from '../../../cache';
+import { getResourceInfo, setResourceInfo, deleteResourceRegion } from '../../../cache';
 import * as tui from '../../../tui';
 import { ErrorCode } from '../../../errors';
 
 export function createSandboxClient(logger: Logger, auth: AuthData, region: string): APIClient {
-	const urls = getServiceUrls(region);
-	return new APIClient(urls.catalyst, logger, auth.apiKey);
+	return new APIClient(getServiceUrls(region).catalyst, logger, auth.apiKey);
 }
 
 /**
@@ -22,13 +21,13 @@ export async function getSandboxRegion(
 	auth: AuthData,
 	profileName = 'production',
 	sandboxId: string,
-	orgId: string
+	orgId?: string
 ): Promise<string> {
 	// Check cache first
-	const cachedRegion = await getResourceRegion('sandbox', profileName, sandboxId);
-	if (cachedRegion) {
-		logger.trace(`[sandbox] Found cached region for ${sandboxId}: ${cachedRegion}`);
-		return cachedRegion;
+	const cachedInfo = await getResourceInfo('sandbox', profileName, sandboxId);
+	if (cachedInfo?.region) {
+		logger.trace(`[sandbox] Found cached region for ${sandboxId}: ${cachedInfo.region}`);
+		return cachedInfo.region;
 	}
 
 	// Fallback to API lookup using global client
@@ -41,7 +40,7 @@ export async function getSandboxRegion(
 	}
 
 	// Cache the result
-	await setResourceRegion('sandbox', profileName, sandboxId, sandbox.region);
+	await setResourceInfo('sandbox', profileName, sandboxId, sandbox.region, orgId);
 	logger.trace(`[sandbox] Cached region for ${sandboxId}: ${sandbox.region}`);
 
 	return sandbox.region;
@@ -55,7 +54,7 @@ export async function cacheSandboxRegion(
 	sandboxId: string,
 	region: string
 ): Promise<void> {
-	await setResourceRegion('sandbox', profileName, sandboxId, region);
+	await setResourceInfo('sandbox', profileName, sandboxId, region);
 }
 
 /**
@@ -77,7 +76,7 @@ export async function clearSandboxRegionCache(
  *
  * @returns Array of FileToWrite objects
  */
-export function parseFileArgs(fileArgs: string[] | undefined): FileToWrite[] {
+export async function parseFileArgs(fileArgs: string[] | undefined): Promise<FileToWrite[]> {
 	if (!fileArgs || fileArgs.length === 0) {
 		return [];
 	}
@@ -106,7 +105,9 @@ export function parseFileArgs(fileArgs: string[] | undefined): FileToWrite[] {
 		}
 
 		const resolvedPath = resolve(localPath);
-		if (!existsSync(resolvedPath)) {
+		// Use Bun.file().exists() instead of Node's existsSync per coding guidelines
+		const fileExists = await Bun.file(resolvedPath).exists();
+		if (!fileExists) {
 			throw new Error(`File not found: ${localPath} (resolved to ${resolvedPath})`);
 		}
 

package/src/cmd/cloud/ssh.ts

@@ -71,16 +71,14 @@ export const sshSubcommand = createSubcommand({
 		const profileName = config?.name;
 		const targetIdentifier = identifier ?? projectId!;
 
-		// For sandbox identifiers, use saved org preference (no prompting)
-		const orgId = targetIdentifier.startsWith('sbx_') ? config?.preferences?.orgId : undefined;
-
+		// Region lookup handles org resolution automatically via CLI API
 		const region = await getIdentifierRegion(
 			logger,
 			auth,
 			apiClient,
 			profileName,
 			targetIdentifier,
-			orgId,
+			undefined, // orgId resolved automatically for sandboxes
 			config
 		);
 

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

@@ -67,24 +67,24 @@ export const createSubcommand = defineSubcommand({
 			},
 		});
 
-	const resource = created[0];
-	if (resource) {
-		// Write environment variables to .env if running inside a project
-		if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
-			await addResourceEnvVars(ctx.projectDir, resource.env);
-			if (!options.json) {
-				tui.info('Environment variables written to .env');
+		const resource = created[0];
+		if (resource) {
+			// Write environment variables to .env if running inside a project
+			if (ctx.projectDir && resource.env && Object.keys(resource.env).length > 0) {
+				await addResourceEnvVars(ctx.projectDir, resource.env);
+				if (!options.json) {
+					tui.info('Environment variables written to .env');
+				}
 			}
-		}
 
-		if (!options.json) {
-			tui.success(`Created storage: ${tui.bold(resource.name)}`);
-		}
-		return {
-			success: true,
-			name: resource.name,
-		};
-	} else {
+			if (!options.json) {
+				tui.success(`Created storage: ${tui.bold(resource.name)}`);
+			}
+			return {
+				success: true,
+				name: resource.name,
+			};
+		} else {
 			tui.fatal('Failed to create storage');
 		}
 	},

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

@@ -242,27 +242,27 @@ export const deleteSubcommand = createSubcommand({
 			},
 		});
 
-	const resource = deleted[0];
-	if (resource) {
-		// Clear cache entry for deleted bucket
-		await deleteResourceRegion('bucket', profileName, resource.name);
-
-		// Remove env vars from .env if running inside a project
-		if (ctx.projectDir && resource.env_keys.length > 0) {
-			await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
-			if (!options.json) {
-				tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
+		const resource = deleted[0];
+		if (resource) {
+			// Clear cache entry for deleted bucket
+			await deleteResourceRegion('bucket', profileName, resource.name);
+
+			// Remove env vars from .env if running inside a project
+			if (ctx.projectDir && resource.env_keys.length > 0) {
+				await removeResourceEnvVars(ctx.projectDir, resource.env_keys);
+				if (!options.json) {
+					tui.info(`Removed ${resource.env_keys.join(', ')} from .env`);
+				}
 			}
-		}
 
-		if (!options.json) {
-			tui.success(`Deleted storage bucket: ${tui.bold(resource.name)}`);
-		}
-		return {
-			success: true,
-			name: resource.name,
-		};
-	} else {
+			if (!options.json) {
+				tui.success(`Deleted storage bucket: ${tui.bold(resource.name)}`);
+			}
+			return {
+				success: true,
+				name: resource.name,
+			};
+		} else {
 			tui.error('Failed to delete storage bucket');
 			return { success: false, name: bucketName };
 		}

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

@@ -5,7 +5,7 @@ import * as tui from '../../../tui';
 import { getGlobalCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
-import { getResourceInfo, setResourceInfo } from '../../../cache';
+import { setResourceInfo } from '../../../cache';
 
 const StorageGetResponseSchema = z.object({
 	bucket_name: z.string().describe('Storage bucket name'),
@@ -26,7 +26,6 @@ export const getSubcommand = createSubcommand({
 	description: 'Show details about a specific storage bucket',
 	tags: ['read-only', 'fast', 'requires-auth'],
 	requires: { auth: true },
-	optional: { org: true },
 	idempotent: true,
 	examples: [
 		{
@@ -64,35 +63,25 @@ export const getSubcommand = createSubcommand({
 		const profileName = config?.name ?? 'production';
 		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
 
-		// Check cache first for orgId
-		const cachedInfo = await getResourceInfo('bucket', profileName, args.name);
-		const orgId = ctx.orgId ?? cachedInfo?.orgId;
-
-		if (!orgId) {
-			tui.fatal(
-				`Organization not found for bucket '${args.name}'. Run 'agentuity cloud storage list' first or specify --org-id.`,
-				ErrorCode.INVALID_ARGUMENT
-			);
-		}
-
+		// Search across all orgs the user has access to
 		const resources = await tui.spinner({
 			message: `Fetching storage bucket ${args.name}`,
 			clearOnSuccess: true,
 			callback: async () => {
-				return listOrgResources(catalystClient, { type: 's3', orgId });
+				return listOrgResources(catalystClient, { type: 's3' });
 			},
 		});
 
 		const bucket = resources.s3.find((s3) => s3.bucket_name === args.name);
 
 		// Cache the bucket info for future lookups
-		if (bucket?.cloud_region) {
+		if (bucket?.cloud_region && bucket.org_id) {
 			await setResourceInfo(
 				'bucket',
 				profileName,
 				bucket.bucket_name,
 				bucket.cloud_region,
-				orgId
+				bucket.org_id
 			);
 		}
 

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

@@ -44,7 +44,7 @@ export const listSubcommand = createSubcommand({
 	aliases: ['ls'],
 	description: 'List storage resources or files in a bucket',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, org: true },
+	requires: { auth: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('cloud storage list'), description: 'List items' },
@@ -85,23 +85,29 @@ export const listSubcommand = createSubcommand({
 			: '/services/storage',
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, auth, config } = ctx;
+		const { logger, args, opts, options, auth, config } = ctx;
 
 		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
 		const profileName = config?.name ?? 'production';
 		const resources = await tui.spinner({
-			message: `Fetching storage for ${orgId}`,
+			message: 'Fetching storage',
 			clearOnSuccess: true,
 			callback: async () => {
-				return listOrgResources(catalystClient, { type: 's3', orgId });
+				return listOrgResources(catalystClient, { type: 's3' });
 			},
 		});
 
 		// Cache each bucket with its region and orgId for future lookups
 		for (const s3 of resources.s3) {
-			if (s3.cloud_region) {
-				await setResourceInfo('bucket', profileName, s3.bucket_name, s3.cloud_region, orgId);
+			if (s3.cloud_region && s3.org_id) {
+				await setResourceInfo(
+					'bucket',
+					profileName,
+					s3.bucket_name,
+					s3.cloud_region,
+					s3.org_id
+				);
 			}
 		}
 

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

@@ -4,6 +4,7 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
+import { getDefaultRegion } from '../../../config';
 
 const StreamCreateResponseSchema = z.object({
 	id: z.string().describe('Stream ID'),
@@ -19,8 +20,8 @@ export const createSubcommand = createCommand({
 	aliases: ['new'],
 	description: 'Create a new stream and upload content',
 	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'uses-stdin'],
-	requires: { auth: true, region: true },
-	optional: { project: true },
+	requires: { auth: true },
+	optional: { project: true, region: true, org: true },
 	idempotent: false,
 	examples: [
 		{
@@ -77,9 +78,12 @@ export const createSubcommand = createCommand({
 	webUrl: '/services/stream',
 
 	async handler(ctx) {
-		const { args, opts, options } = ctx;
+		const { args, opts, options, config } = ctx;
 		const started = Date.now();
-		const storage = await createStorageAdapter(ctx);
+
+		// Resolve region from config if not provided
+		const region = ctx.region ?? (await getDefaultRegion(config?.name, config));
+		const storage = await createStorageAdapter({ ...ctx, region });
 
 		// Parse metadata if provided
 		let metadata: Record<string, string> | undefined;

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

@@ -1,7 +1,8 @@
 import { z } from 'zod';
+import { streamGet } from '@agentuity/server';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
+import { createStorageAdapterForOrg } from './util';
 import { getCommand } from '../../../command-prefix';
 const DeleteStreamResponseSchema = z.object({
 	id: z.string().describe('Stream ID'),
@@ -13,7 +14,7 @@ export const deleteSubcommand = createCommand({
 	description: 'Delete a stream by ID (soft delete)',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true, region: true },
+	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	examples: [
 		{ command: getCommand('stream delete stream-id-123'), description: 'Delete a stream' },
@@ -34,9 +35,32 @@ export const deleteSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args, options } = ctx;
+		const { args, options, logger, auth, apiClient } = ctx;
 		const started = Date.now();
-		const storage = await createStorageAdapter(ctx);
+
+		if (!apiClient) {
+			tui.fatal('API client is required for stream delete');
+		}
+
+		// Look up the stream to get its org and region
+		const streamInfo = await streamGet(apiClient, args.id);
+
+		// Extract region from the stream URL (e.g., https://streams-use.agentuity.cloud/...)
+		let region = 'usc'; // default
+		const urlMatch = streamInfo.url.match(/https:\/\/streams-([^.]+)\.agentuity\.cloud/);
+		if (urlMatch?.[1]) {
+			region = urlMatch[1];
+		} else if (streamInfo.url.includes('streams.agentuity.io')) {
+			region = 'local';
+		}
+
+		// Use the stream's orgId for auth
+		const storage = createStorageAdapterForOrg({
+			logger,
+			auth,
+			region,
+			orgId: streamInfo.orgId,
+		});
 
 		await storage.delete(args.id);
 

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

@@ -1,9 +1,19 @@
 import { z } from 'zod';
+import { streamGet } from '@agentuity/server';
+import { StructuredError } from '@agentuity/core';
 import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
-import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
 
+const StreamGetError = StructuredError('StreamGetError')<{
+	streamId?: string;
+}>();
+const StreamDownloadError = StructuredError('StreamDownloadError')<{
+	statusCode?: number;
+	statusText?: string;
+}>();
+const StreamReaderError = StructuredError('StreamReaderError');
+
 const GetStreamResponseSchema = z.object({
 	id: z.string().describe('Stream ID'),
 	namespace: z.string().describe('Stream namespace'),
@@ -16,19 +26,21 @@ export const getSubcommand = createCommand({
 	name: 'get',
 	description: 'Get detailed information about a specific stream',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, region: true },
+	requires: { auth: true, apiClient: true },
 	optional: { project: true },
 	idempotent: true,
 	examples: [
-		{ command: getCommand('stream get stream-id-123'), description: 'Get stream details' },
-		{ command: getCommand('stream get stream-id-123 --json'), description: 'Get stream as JSON' },
 		{
-			command: getCommand('stream get stream-id-123 --output stream.dat'),
-			description: 'Download stream to file',
+			command: getCommand('stream get stream_abc123'),
+			description: 'Get stream details',
+		},
+		{
+			command: getCommand('stream get stream_abc123 --json'),
+			description: 'Get stream as JSON',
 		},
 		{
-			command: getCommand('stream get stream-id-123 -o stream.dat'),
-			description: 'Download stream (short flag)',
+			command: getCommand('stream get stream_abc123 --output stream.dat'),
+			description: 'Download stream to file',
 		},
 	],
 	schema: {
@@ -43,75 +55,101 @@ export const getSubcommand = createCommand({
 	webUrl: (ctx) => `/services/stream/${encodeURIComponent(ctx.args.id)}`,
 
 	async handler(ctx) {
-		const { args, opts, options } = ctx;
+		const { args, opts, options, apiClient } = ctx;
 		const started = Date.now();
-		const storage = await createStorageAdapter(ctx);
 
-		// If --output is specified, download the stream content
-		if (opts.output) {
-			const readable = await storage.download(args.id);
-			const file = Bun.file(opts.output);
-			const writer = file.writer();
+		try {
+			// Get stream metadata using the new API
+			const stream = await streamGet(apiClient, args.id);
+			const durationMs = Date.now() - started;
+
+			// If --output is specified, download the stream content
+			if (opts.output) {
+				const downloadStarted = Date.now();
 
-			const reader = readable.getReader();
-			try {
-				while (true) {
-					const { done, value } = await reader.read();
-					if (done) break;
-					writer.write(value);
+				// Fetch the stream content from the URL
+				const response = await fetch(stream.url);
+				if (!response.ok) {
+					throw new StreamDownloadError({
+						message: `Failed to download stream: ${response.status} ${response.statusText}`,
+						statusCode: response.status,
+						statusText: response.statusText,
+					});
 				}
-				await writer.end();
-				const durationMs = Date.now() - started;
-				const stats = await Bun.file(opts.output).stat();
-				tui.success(
-					`downloaded ${tui.formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
-				);
 
-				// Fetch stream metadata to populate the response
-				const stream = await storage.get(args.id);
-				return {
-					id: args.id,
-					namespace: stream.namespace ?? '',
-					metadata: stream.metadata ?? {},
-					url: stream.url ?? '',
-					sizeBytes: stats.size,
-				};
-			} finally {
-				reader.releaseLock();
-			}
-		}
+				const file = Bun.file(opts.output);
+				const writer = file.writer();
 
-		// Otherwise, get metadata
-		const stream = await storage.get(args.id);
-		const durationMs = Date.now() - started;
+				const reader = response.body?.getReader();
+				if (!reader) {
+					throw new StreamReaderError({ message: 'Failed to get stream reader' });
+				}
+
+				try {
+					while (true) {
+						const { done, value } = await reader.read();
+						if (done) break;
+						writer.write(value);
+					}
+					await writer.end();
+					const downloadDurationMs = Date.now() - downloadStarted;
+					const stats = await Bun.file(opts.output).stat();
+					tui.success(
+						`downloaded ${tui.formatBytes(stats.size)} to ${opts.output} in ${downloadDurationMs.toFixed(1)}ms`
+					);
 
-		if (!options.json) {
-			if (!stream) {
-				tui.fatal(`Failed to retrieve stream metadata for ${args.id}`);
+					return {
+						id: stream.id,
+						namespace: stream.namespace ?? '',
+						metadata: stream.metadata ?? {},
+						url: stream.url ?? '',
+						sizeBytes: stats.size,
+					};
+				} finally {
+					reader.releaseLock();
+				}
 			}
 
-			const sizeBytes = stream.sizeBytes ?? 0;
+			// Display metadata
+			if (!options.json) {
+				const sizeBytes = stream.sizeBytes ?? 0;
 
-			console.log(`Namespace: ${tui.bold(stream.namespace ?? 'unknown')}`);
-			console.log(`ID:        ${stream.id}`);
-			console.log(`Size:      ${tui.formatBytes(sizeBytes)}`);
-			console.log(`URL:       ${tui.link(stream.url ?? 'unknown')}`);
-			if (stream.metadata && Object.keys(stream.metadata).length > 0) {
-				console.log(`Metadata:`);
-				for (const [key, value] of Object.entries(stream.metadata)) {
-					console.log(`  ${key}: ${value}`);
+				console.log(`Namespace: ${tui.bold(stream.namespace ?? 'unknown')}`);
+				console.log(`ID:        ${stream.id}`);
+				console.log(`Size:      ${tui.formatBytes(sizeBytes)}`);
+				console.log(`URL:       ${tui.link(stream.url ?? 'unknown')}`);
+				if (stream.metadata && Object.keys(stream.metadata).length > 0) {
+					console.log(`Metadata:`);
+					for (const [key, value] of Object.entries(stream.metadata)) {
+						console.log(`  ${key}: ${value}`);
+					}
+				}
+				if (stream.completed !== undefined) {
+					console.log(`Completed: ${stream.completed ? 'yes' : 'no'}`);
 				}
+				if (stream.expiresAt) {
+					console.log(`Expires:   ${stream.expiresAt}`);
+				}
+				tui.success(`retrieved in ${durationMs.toFixed(1)}ms`);
 			}
-			tui.success(`retrieved in ${durationMs.toFixed(1)}ms`);
-		}
 
-		return {
-			id: stream.id,
-			namespace: stream.namespace,
-			metadata: stream.metadata,
-			url: stream.url,
-			sizeBytes: stream.sizeBytes,
-		};
+			return {
+				id: stream.id,
+				namespace: stream.namespace,
+				metadata: stream.metadata,
+				url: stream.url,
+				sizeBytes: stream.sizeBytes,
+			};
+		} catch (ex) {
+			if (
+				ex instanceof StreamGetError ||
+				ex instanceof StreamDownloadError ||
+				ex instanceof StreamReaderError
+			) {
+				throw ex;
+			}
+			throw new StreamGetError({ message: `Failed to get stream: ${ex}`, streamId: args.id });
+		}
 	},
 });