@agentuity/cli 0.0.70 → 0.0.72

package/src/cmd/build/bundler.ts

@@ -1,21 +1,42 @@
-import { $ } from 'bun';
+import { $, semver } from 'bun';
 import { join, relative, resolve, dirname, basename } from 'node:path';
-import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
+import { StructuredError } from '@agentuity/core';
+import * as tui from '../../tui';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
 import { getFilesRecursively } from './file';
 import { getVersion } from '../../version';
 import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
-import { createLogger } from '@agentuity/server';
-import type { LogLevel } from '../../types';
+import type { Logger } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
 import { analyzeWorkbench } from './ast';
-import { StructuredError } from '@agentuity/core';
-import { DeployOptionsSchema, type DeployOptions } from '../../schemas/deploy';
+import { type DeployOptions } from '../../schemas/deploy';
+
+const minBunVersion = '>=1.3.3';
 
-// Re-export for backward compatibility
-export { DeployOptionsSchema };
+async function checkBunVersion() {
+	if (semver.satisfies(Bun.version, minBunVersion)) {
+		return;
+	}
+	const message = `The current Bun installed is using version ${Bun.version}. This project requires Bun version ${minBunVersion} to build.`;
+	tui.warning(message);
+	if (process.stdin.isTTY) {
+		const ok = await tui.confirm('You would you to upgrade now?');
+		if (ok) {
+			await $`bun upgrade`.quiet();
+			const version = (await $`bun -v`.quiet().text()).trim();
+			tui.success(`Bun upgraded to ${version}`);
+			return;
+		}
+	}
+	throw new InvalidBunVersion({
+		current: Bun.version,
+		required: minBunVersion,
+		message: `Please see https://bun.sh/ for information on how to download the latest version.`,
+	});
+}
 
 export interface BundleOptions extends DeployOptions {
 	rootDir: string;
@@ -28,6 +49,7 @@ export interface BundleOptions extends DeployOptions {
 	port?: number;
 	outDir?: string;
 	region: string;
+	logger: Logger;
 }
 
 type BuildResult = Awaited<ReturnType<typeof Bun.build>>;
@@ -36,6 +58,10 @@ type BuildLogs = BuildResult['logs'];
 const AppFileNotFoundError = StructuredError('AppFileNotFoundError');
 const AgentsDirNotFoundError = StructuredError('AgentsDirNotFoundError');
 const BuildFailedError = StructuredError('BuildFailedError')<{ logs?: BuildLogs }>();
+const InvalidBunVersion = StructuredError('InvalidBunVersion')<{
+	current: string;
+	required: string;
+}>();
 
 const handleBuildFailure = (buildResult: BuildResult) => {
 	// Collect all build errors with full details
@@ -75,6 +101,7 @@ export async function bundle({
 	message,
 	env,
 	region,
+	logger,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
@@ -82,6 +109,9 @@ export async function bundle({
 			message: `App file not found at expected location: ${appFile}`,
 		});
 	}
+
+	await checkBunVersion();
+
 	const outDir = customOutDir ?? join(rootDir, '.agentuity');
 	const srcDir = join(rootDir, 'src');
 
@@ -150,6 +180,98 @@ export async function bundle({
 		}
 	}
 
+	// Common externals for native modules (same as legacy CLI)
+	const commonExternals = ['bun', 'fsevents', 'chromium-bidi', 'sharp'];
+
+	// Allow projects to specify custom externals via package.json "externals" field
+	const customExternals: string[] = [];
+	if (pkgContents.externals && Array.isArray(pkgContents.externals)) {
+		customExternals.push(...pkgContents.externals.filter((e: unknown) => typeof e === 'string'));
+	}
+
+	const externalPatterns = [...commonExternals, ...customExternals];
+
+	// For production builds: install externals FIRST, then discover full dependency tree
+	// This prevents bundling dependencies that will be in node_modules anyway
+	let external = externalPatterns;
+	if (!dev) {
+		logger.debug('Installing externalized packages to discover full dependency tree...');
+
+		// Step 1: Collect packages matching external patterns
+		const externalInstalls: string[] = [];
+		for (const pattern of externalPatterns) {
+			if (pattern.endsWith('/*')) {
+				const prefix = pattern.slice(0, -2);
+				const nmDir = join(rootDir, 'node_modules', prefix);
+				if (existsSync(nmDir)) {
+					const entries = readdirSync(nmDir);
+					for (const entry of entries) {
+						const pkgName = `${prefix}/${entry}`;
+						if (existsSync(join(rootDir, 'node_modules', pkgName))) {
+							externalInstalls.push(pkgName);
+						}
+					}
+				}
+			} else {
+				if (existsSync(join(rootDir, 'node_modules', pattern))) {
+					externalInstalls.push(pattern);
+				}
+			}
+		}
+
+		// Step 2: Write minimal package.json and install externals
+		if (externalInstalls.length > 0) {
+			await Bun.write(
+				`${outDir}/package.json`,
+				JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+			);
+
+			logger.debug(
+				'Installing %d packages: %s',
+				externalInstalls.length,
+				externalInstalls.join(', ')
+			);
+			await $`bun install --no-save --ignore-scripts --target=bun-linux-x64 ${externalInstalls}`
+				.cwd(outDir)
+				.quiet();
+
+			// Step 3: Scan what actually got installed (includes transitive dependencies)
+			const installedNmDir = join(outDir, 'node_modules');
+			if (existsSync(installedNmDir)) {
+				const allInstalled: string[] = [];
+
+				// Recursively find all installed packages
+				const scanDir = (dir: string, prefix = '') => {
+					const entries = readdirSync(dir, { withFileTypes: true });
+					for (const entry of entries) {
+						if (entry.isDirectory()) {
+							const pkgName = prefix ? `${prefix}/${entry.name}` : entry.name;
+
+							// Check if this is a package (has package.json)
+							if (existsSync(join(dir, entry.name, 'package.json'))) {
+								allInstalled.push(pkgName);
+							}
+
+							// Recurse into scoped packages (@org/package)
+							if (entry.name.startsWith('@')) {
+								scanDir(join(dir, entry.name), entry.name);
+							}
+						}
+					}
+				};
+
+				scanDir(installedNmDir);
+				logger.debug(
+					'Discovered %d total packages (including dependencies)',
+					allInstalled.length
+				);
+
+				// Step 4: Use ALL installed packages as externals for bundling
+				external = allInstalled;
+			}
+		}
+	}
+
 	await (async () => {
 		const config: Bun.BuildConfig = {
 			entrypoints: appEntrypoints,
@@ -168,6 +290,7 @@ export async function bundle({
 			drop: isProd ? ['debugger'] : undefined,
 			splitting: true,
 			conditions: [isProd ? 'production' : 'development', 'bun'],
+			external,
 			naming: {
 				entry: '[dir]/[name].[ext]',
 				chunk: 'chunk/[name]-[hash].[ext]',
@@ -328,7 +451,6 @@ export async function bundle({
 			// Create workbench config with proper defaults
 			const defaultConfig = { route: '/workbench', headers: {}, port: port || 3500 };
 			const config = { ...defaultConfig, ...analysis.config };
-			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			try {
 				// Generate workbench files on the fly instead of using files from package
 				const tempWorkbenchDir = join(outDir, 'temp-workbench');
@@ -569,10 +691,13 @@ export async function bundle({
 		}
 	}
 
-	await Bun.write(
-		`${outDir}/package.json`,
-		JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
-	);
+	// Write minimal package.json for dev mode (production already wrote it above)
+	if (dev) {
+		await Bun.write(
+			`${outDir}/package.json`,
+			JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)
+		);
+	}
 
 	await Bun.write(
 		`${outDir}/agentuity.metadata.json`,

package/src/cmd/build/index.ts

@@ -74,6 +74,7 @@ export const command = createCommand({
 				projectId: project?.projectId,
 				env,
 				region: project?.region ?? 'local',
+				logger: ctx.logger,
 			});
 
 			// Run TypeScript type checking after registry generation (skip in dev mode)

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

@@ -31,7 +31,7 @@ export const createSubcommand = defineSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, opts, orgId, region, config, auth, options } = ctx;
+		const { logger, opts, orgId, region, auth, options } = ctx;
 
 		// Handle dry-run mode
 		if (isDryRunMode(options)) {
@@ -49,7 +49,7 @@ export const createSubcommand = defineSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			const created = await tui.spinner({

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

@@ -35,9 +35,9 @@ export const deleteSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, config, orgId, region, auth, options } = ctx;
+		const { logger, args, opts, orgId, region, auth, options } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		let dbName = args.name;
 

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

@@ -65,9 +65,9 @@ export const getSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching database ${args.name}`,

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

@@ -46,9 +46,9 @@ export const listSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching databases for ${orgId} in ${region}`,

package/src/cmd/cloud/db/logs.ts

@@ -78,14 +78,14 @@ export const logsSubcommand = createSubcommand({
 		response: DbLogsResponseSchema,
 	},
 	async handler(ctx) {
-		const { args, options, orgId, region, config, logger, auth } = ctx;
+		const { args, options, orgId, region, logger, auth } = ctx;
 		const showTimestamps = ctx.opts.timestamps ?? true;
 		const showSessionId = ctx.opts.showSessionId ?? false;
 		const showUsername = ctx.opts.showUsername ?? false;
 		const prettySQL = ctx.opts.pretty ?? false;
 
 		try {
-			const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+			const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 			const logs = await dbLogs(catalystClient, {
 				database: args.database,

package/src/cmd/cloud/db/sql.ts

@@ -42,9 +42,9 @@ export const sqlSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, options, orgId, region, config, auth } = ctx;
+		const { logger, args, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const result = await tui.spinner({
 			message: `Executing query on ${args.name}`,

package/src/cmd/cloud/deploy.ts

@@ -1,23 +1,25 @@
 import { z } from 'zod';
 import { join, resolve } from 'node:path';
 import { createPublicKey } from 'node:crypto';
-import { createReadStream, createWriteStream } from 'node:fs';
+import { createReadStream, createWriteStream, existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
-import { saveProjectDir } from '../../config';
+import { saveProjectDir, getDefaultConfigDir } from '../../config';
 import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
 import { bundle } from '../build/bundler';
-import { loadBuildMetadata } from '../../config';
+import { loadBuildMetadata, getStreamURL } from '../../config';
 import {
 	projectEnvUpdate,
 	projectDeploymentCreate,
 	projectDeploymentUpdate,
 	projectDeploymentComplete,
+	projectDeploymentStatus,
 	type Deployment,
 	type BuildMetadata,
 	type DeploymentInstructions,
 	type DeploymentComplete,
+	type DeploymentStatusResult,
 } from '@agentuity/server';
 import {
 	findEnvFile,
@@ -30,11 +32,13 @@ import { encryptFIPSKEMDEMStream } from '../../crypto/box';
 import { getCommand } from '../../command-prefix';
 import { checkCustomDomainForDNS } from './domain';
 import { DeployOptionsSchema } from '../../schemas/deploy';
+import { ErrorCode } from '../../errors';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
 	deploymentId: z.string().describe('Deployment ID'),
 	projectId: z.string().describe('Project ID'),
+	logs: z.array(z.string()).optional().describe('The deployment startup logs'),
 	urls: z
 		.object({
 			deployment: z.string().describe('Deployment-specific URL'),
@@ -77,12 +81,14 @@ export const deploySubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { project, apiClient, projectDir, config, options, opts } = ctx;
+		const { project, apiClient, projectDir, config, options, opts, logger } = ctx;
 
 		let deployment: Deployment | undefined;
 		let build: BuildMetadata | undefined;
 		let instructions: DeploymentInstructions | undefined;
 		let complete: DeploymentComplete | undefined;
+		let statusResult: DeploymentStatusResult | undefined;
+		const logs: string[] = [];
 
 		try {
 			await saveProjectDir(projectDir);
@@ -187,6 +193,7 @@ export const deploySubcommand = createSubcommand({
 									trigger: opts?.trigger,
 									tag: opts?.tag,
 									region: project.region,
+									logger: ctx.logger,
 								});
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(
@@ -236,7 +243,6 @@ export const deploySubcommand = createSubcommand({
 									if (relative.startsWith('.env')) return false;
 									if (relative.startsWith('.git/')) return false;
 									if (relative.startsWith('.ssh/')) return false;
-									if (relative.startsWith('node_modules/')) return false;
 									if (relative === '.DS_Store') return false;
 									return true;
 								},
@@ -366,9 +372,174 @@ export const deploySubcommand = createSubcommand({
 				].filter(Boolean) as Step[],
 				options.logLevel
 			);
-			tui.success('Your project was deployed!');
 
-			if (complete?.publicUrls && deployment) {
+			if (!deployment) {
+				return {
+					success: false,
+					deploymentId: '',
+					projectId: project.projectId,
+				};
+			}
+
+			const streamId = complete?.streamId;
+
+			// Poll for deployment status with optional log streaming
+			const pollInterval = 500;
+			const maxAttempts = 600;
+			let attempts = 0;
+
+			if (streamId) {
+				// Use progress logger to stream logs while polling
+				const streamsUrl = getStreamURL(project.region, config);
+
+				await tui
+					.progress({
+						message: 'Deploying project...',
+						type: 'logger',
+						maxLines: 2,
+						clearOnSuccess: true,
+						callback: async (log) => {
+							// Start log streaming
+							const logStreamController = new AbortController();
+							const logStreamPromise = (async () => {
+								try {
+									logger.debug('fetching stream: %s/%s', streamsUrl, streamId);
+									const resp = await fetch(`${streamsUrl}/${streamId}`, {
+										signal: logStreamController.signal,
+									});
+									if (!resp.ok || !resp.body) {
+										ctx.logger.trace(
+											`Failed to connect to warmup log stream: ${resp.status}`
+										);
+										return;
+									}
+									const reader = resp.body.getReader();
+									const decoder = new TextDecoder();
+									let buffer = '';
+									while (true) {
+										const { done, value } = await reader.read();
+										if (done) break;
+										buffer += decoder.decode(value, { stream: true });
+										const lines = buffer.split('\n');
+										buffer = lines.pop() || ''; // Keep incomplete line in buffer
+										for (const line of lines) {
+											// Strip ISO 8601 timestamp prefix if present
+											const message = line.replace(
+												/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z\s?/,
+												''
+											);
+											if (message) {
+												logs.push(message);
+												log(message);
+											}
+										}
+									}
+								} catch (err) {
+									if (err instanceof Error && err.name === 'AbortError') {
+										return;
+									}
+									ctx.logger.trace(`Warmup log stream error: ${err}`);
+								}
+							})();
+
+							// Poll for deployment status
+							while (attempts < maxAttempts) {
+								attempts++;
+								try {
+									statusResult = await projectDeploymentStatus(
+										apiClient,
+										deployment?.id ?? ''
+									);
+
+									logger.trace('status result: %s', statusResult);
+
+									if (statusResult.state === 'completed') {
+										logStreamController.abort();
+										break;
+									}
+
+									if (statusResult.state === 'failed') {
+										throw new Error('Deployment failed');
+									}
+
+									await Bun.sleep(pollInterval);
+								} catch (err) {
+									logStreamController.abort();
+									throw err;
+								}
+							}
+
+							// Wait for log stream to finish
+							await logStreamPromise;
+
+							if (attempts >= maxAttempts) {
+								throw new Error('Deployment timed out');
+							}
+						},
+					})
+					.then(() => {
+						tui.success('Your project was deployed!');
+					})
+					.catch((ex) => {
+						const exwithmessage = ex as { message: string };
+						const msg =
+							exwithmessage.message === 'Deployment failed' ? '' : exwithmessage.toString();
+						tui.error(`Your deployment failed to start${msg ? `: ${msg}` : ''}`);
+						if (logs.length) {
+							const logsDir = join(getDefaultConfigDir(), 'logs');
+							if (!existsSync(logsDir)) {
+								mkdirSync(logsDir, { recursive: true });
+							}
+							const errorFile = join(logsDir, `${deployment?.id ?? Date.now()}.txt`);
+							writeFileSync(errorFile, logs.join('\n'));
+							const count = Math.min(logs.length, 10);
+							const last = logs.length - count;
+							tui.newline();
+							tui.warning(`The last ${count} lines of the log:`);
+							let offset = last + 1; // we want to show the offset from inside the log starting at 1
+							const max = String(logs.length).length;
+							for (const _log of logs.slice(last)) {
+								console.log(tui.muted(`${offset.toFixed().padEnd(max)} | ${_log}`));
+								offset++;
+							}
+							tui.newline();
+							tui.fatal(`The logs were written to ${errorFile}`, ErrorCode.BUILD_FAILED);
+						}
+						tui.fatal('Deployment failed', ErrorCode.BUILD_FAILED);
+					});
+			} else {
+				// No stream ID - poll without log streaming
+				await tui.spinner({
+					message: 'Deploying project...',
+					type: 'simple',
+					clearOnSuccess: true,
+					callback: async () => {
+						while (attempts < maxAttempts) {
+							attempts++;
+							statusResult = await projectDeploymentStatus(apiClient, deployment?.id ?? '');
+
+							if (statusResult.state === 'completed') {
+								break;
+							}
+
+							if (statusResult.state === 'failed') {
+								throw new Error('Deployment failed');
+							}
+
+							await Bun.sleep(pollInterval);
+						}
+
+						if (attempts >= maxAttempts) {
+							throw new Error('Deployment timed out');
+						}
+					},
+				});
+
+				tui.success('Your project was deployed!');
+			}
+
+			// Show deployment URLs
+			if (complete?.publicUrls) {
 				tui.arrow(tui.bold(tui.padRight('Deployment ID:', 17)) + tui.link(deployment.id));
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
@@ -385,25 +556,18 @@ export const deploySubcommand = createSubcommand({
 				}
 			}
 
-			// Return deployment result (if available)
-			if (deployment && complete?.publicUrls) {
-				return {
-					success: true,
-					deploymentId: deployment.id,
-					projectId: project.projectId,
-					urls: {
-						deployment: complete.publicUrls.deployment,
-						latest: complete.publicUrls.latest,
-						custom: complete.publicUrls.custom,
-					},
-				};
-			}
-
-			// Fallback response
 			return {
-				success: false,
-				deploymentId: '',
+				success: true,
+				deploymentId: deployment.id,
 				projectId: project.projectId,
+				logs,
+				urls: complete?.publicUrls
+					? {
+							deployment: complete.publicUrls.deployment,
+							latest: complete.publicUrls.latest,
+							custom: complete.publicUrls.custom,
+						}
+					: undefined,
 			};
 		} catch (ex) {
 			tui.fatal(`unexpected error trying to deploy project. ${ex}`);

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

@@ -125,8 +125,8 @@ export const getSubcommand = createSubcommand({
 		response: SessionGetResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, args, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, args, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		try {
 			const enriched = await sessionGet(catalystClient, { id: args.session_id });

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

@@ -89,8 +89,8 @@ export const listSubcommand = createSubcommand({
 		response: SessionListResponseSchema,
 	},
 	async handler(ctx) {
-		const { config, logger, auth, project, opts, options, region } = ctx;
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const { logger, auth, project, opts, options, region } = ctx;
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const projectId = opts.projectId || project?.projectId;
 

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

@@ -35,7 +35,7 @@ export const createSubcommand = defineSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, orgId, region, config, auth, options } = ctx;
+		const { logger, orgId, region, auth, options } = ctx;
 
 		// Handle dry-run mode
 		if (isDryRunMode(options)) {
@@ -51,7 +51,7 @@ export const createSubcommand = defineSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const created = await tui.spinner({
 			message: `Creating storage in ${region}`,

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

@@ -49,9 +49,9 @@ export const deleteSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, config, orgId, region, auth, options } = ctx;
+		const { logger, args, opts, orgId, region, auth, options } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage for ${orgId} in ${region}`,

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

@@ -51,9 +51,9 @@ export const downloadSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		// Fetch bucket credentials
 		const resources = await tui.spinner({

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

@@ -51,9 +51,9 @@ export const getSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
+		const { logger, args, opts, options, orgId, region, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching storage bucket ${args.name}`,