@agentuity/cli 0.0.71 → 0.0.73

package/src/cmd/auth/login.ts

@@ -1,7 +1,7 @@
 import { createSubcommand } from '../../types';
 import { getAppBaseURL } from '../../api';
 import { saveAuth } from '../../config';
-import { generateLoginOTP, pollForLoginCompletion } from './api';
+import { generateLoginCode, pollForLoginCompletion } from './api';
 import * as tui from '../../tui';
 import { getCommand } from '../../command-prefix';
 import { ErrorCode } from '../../errors';
@@ -23,41 +23,60 @@ export const loginCommand = createSubcommand({
 		const appUrl = getAppBaseURL(config);
 
 		try {
-			const otp = await tui.spinner({
-				message: 'Generating login one time code...',
+			const code = await tui.spinner({
+				message: 'Generating login code...',
 				clearOnSuccess: true,
 				callback: () => {
-					return generateLoginOTP(apiClient);
+					return generateLoginCode(apiClient);
 				},
 			});
 
-			if (!otp) {
+			if (!code) {
 				return;
 			}
 
-			const authURL = `${appUrl}/auth/cli`;
+			const authURL = `${appUrl}/auth/cli?code=${code}`;
 
-			const copied = await tui.copyToClipboard(otp);
+			const copied = await tui.copyToClipboard(authURL);
 
+			tui.newline();
+			console.log(`Your login code: ${tui.bold(code)}`);
 			tui.newline();
 			if (copied) {
-				console.log(`Code copied to clipboard: ${tui.bold(otp)}`);
+				console.log('Login URL copied to clipboard! Open it in your browser:');
 			} else {
-				console.log('Copy the following code:');
-				tui.newline();
-				console.log(`  ${tui.bold(otp)}`);
+				console.log('Open this URL in your browser to approve the login:');
 			}
 			tui.newline();
-			console.log('Then open the URL in your browser and paste the code:');
-			tui.newline();
 			console.log(`  ${tui.link(authURL)}`);
 			tui.newline();
-			console.log(tui.muted('This code will expire in 60 seconds'));
+			console.log(tui.muted('Press Enter to open in your browser, or Ctrl+C to cancel'));
 			tui.newline();
 
-			console.log('Waiting for login to complete...');
-
-			const result = await pollForLoginCompletion(apiClient, otp);
+			const result = await tui.spinner({
+				type: 'countdown',
+				message: 'Waiting for approval',
+				timeoutMs: 300000, // 5 minutes
+				clearOnSuccess: true,
+				onEnterPress: () => {
+					// Open URL in default browser
+					const platform = process.platform;
+					if (platform === 'win32') {
+						// Windows: use cmd.exe to invoke start (it's a shell builtin, not an executable)
+						// Empty string is required as the window title argument
+						Bun.spawn(['cmd', '/c', 'start', '', authURL], {
+							stdout: 'ignore',
+							stderr: 'ignore',
+						});
+					} else {
+						const command = platform === 'darwin' ? 'open' : 'xdg-open';
+						Bun.spawn([command, authURL], { stdout: 'ignore', stderr: 'ignore' });
+					}
+				},
+				callback: async () => {
+					return await pollForLoginCompletion(apiClient, code);
+				},
+			});
 
 			await saveAuth({
 				apiKey: result.apiKey,

package/src/cmd/auth/ssh/api.ts

@@ -58,11 +58,10 @@ const AddSSHKeyUnexpectedError = StructuredError(
 );
 
 export async function addSSHKey(apiClient: APIClient, publicKey: string): Promise<AddSSHKeyResult> {
-	const resp = await apiClient.request(
-		'POST',
+	const resp = await apiClient.post(
 		'/cli/auth/ssh-keys',
-		APIResponseSchema(AddSSHKeyResponseSchema),
-		{ publicKey }
+		{ publicKey },
+		APIResponseSchema(AddSSHKeyResponseSchema)
 	);
 
 	if (!resp.success) {
@@ -79,8 +78,7 @@ export async function addSSHKey(apiClient: APIClient, publicKey: string): Promis
 const ListSSHKeysError = StructuredError('ListSSHKeysError');
 
 export async function listSSHKeys(apiClient: APIClient): Promise<SSHKey[]> {
-	const resp = await apiClient.request(
-		'GET',
+	const resp = await apiClient.get(
 		'/cli/auth/ssh-keys',
 		APIResponseSchema(z.array(SSHKeySchema))
 	);
@@ -95,6 +93,7 @@ export async function listSSHKeys(apiClient: APIClient): Promise<SSHKey[]> {
 const RemoveSSHKeysError = StructuredError('RemoveSSHKeysError');
 
 export async function removeSSHKey(apiClient: APIClient, fingerprint: string): Promise<boolean> {
+	// NOTE: Using .request() here because DELETE with body is required by the API
 	const resp = await apiClient.request(
 		'DELETE',
 		'/cli/auth/ssh-keys',

package/src/cmd/build/ast.ts

@@ -10,6 +10,7 @@ import type { LogLevel } from '../../types';
 import { join } from 'node:path';
 import { existsSync, mkdirSync } from 'node:fs';
 import JSON5 from 'json5';
+import { formatSchemaCode } from './format-schema';
 
 const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel);
 
@@ -213,11 +214,11 @@ function extractSchemaCode(callargexp: ASTObjectExpression): {
 	for (const prop of schemaObj.properties) {
 		if (prop.key.type === 'Identifier') {
 			if (prop.key.name === 'input' && prop.value) {
-				// Generate source code from AST node
-				inputSchemaCode = generate(prop.value);
+				// Generate source code from AST node and format it
+				inputSchemaCode = formatSchemaCode(generate(prop.value));
 			} else if (prop.key.name === 'output' && prop.value) {
-				// Generate source code from AST node
-				outputSchemaCode = generate(prop.value);
+				// Generate source code from AST node and format it
+				outputSchemaCode = formatSchemaCode(generate(prop.value));
 			}
 		}
 	}
@@ -524,7 +525,7 @@ export async function parseAgentMetadata(
 	});
 	let exportName: string | undefined;
 	const rel = relative(rootDir, filename);
-	const name = basename(dirname(filename));
+	let name: string | undefined; // Will be set from createAgent identifier
 	const version = hash(contents);
 	const id = getAgentId(projectId, deploymentId, rel, version);
 
@@ -560,6 +561,9 @@ export async function parseAgentMetadata(
 						);
 					}
 
+					// Extract agent identifier from createAgent first argument
+					name = nameArg.value;
+
 					const callargexp = configArg;
 
 					// Extract schema code before processing metadata
@@ -588,7 +592,7 @@ export async function parseAgentMetadata(
 							break;
 						}
 					}
-					if (!result) {
+					if (!result && name) {
 						result = createAgentMetadataNode(
 							id,
 							name,
@@ -656,6 +660,9 @@ export async function parseAgentMetadata(
 										);
 									}
 
+									// Extract agent identifier from createAgent first argument
+									name = nameArg.value;
+
 									const callargexp = configArg;
 
 									// Extract schema code before processing metadata
@@ -684,7 +691,7 @@ export async function parseAgentMetadata(
 											break;
 										}
 									}
-									if (!result) {
+									if (!result && name) {
 										result = createAgentMetadataNode(
 											id,
 											name,
@@ -782,6 +789,8 @@ function hasValidatorCall(args: unknown[]): ValidatorInfo {
 		// Check if this is a CallExpression with callee named 'validator'
 		if (node.type === 'CallExpression') {
 			const callExpr = node as ASTCallExpression;
+
+			// Check for standalone validator({ input, output })
 			if (callExpr.callee.type === 'Identifier') {
 				const identifier = callExpr.callee as ASTNodeIdentifier;
 				if (identifier.name === 'validator') {
@@ -789,7 +798,13 @@ function hasValidatorCall(args: unknown[]): ValidatorInfo {
 					const schemas = extractValidatorSchemas(callExpr);
 					return { hasValidator: true, ...schemas };
 				}
+				// Check for zValidator('json', schema)
+				if (identifier.name === 'zValidator') {
+					const schemas = extractZValidatorSchema(callExpr);
+					return { hasValidator: true, ...schemas };
+				}
 			}
+
 			// Check for agent.validator()
 			if (callExpr.callee.type === 'MemberExpression') {
 				const member = callExpr.callee as ASTMemberExpression;
@@ -799,7 +814,9 @@ function hasValidatorCall(args: unknown[]): ValidatorInfo {
 						member.object.type === 'Identifier'
 							? (member.object as ASTNodeIdentifier).name
 							: undefined;
-					return { hasValidator: true, agentVariable };
+					// Also check for schema overrides: agent.validator({ input, output })
+					const schemas = extractValidatorSchemas(callExpr);
+					return { hasValidator: true, agentVariable, ...schemas };
 				}
 			}
 		}
@@ -845,6 +862,48 @@ function extractValidatorSchemas(callExpr: ASTCallExpression): {
 	return result;
 }
 
+/**
+ * Extract schema from zValidator() call arguments
+ * Example: zValidator('json', mySchema) or zValidator('json', z.object({...}))
+ * Returns the schema as inputSchemaVariable since zValidator is for request body validation
+ * Only extracts schemas for 'json' target, not 'query', 'param', 'header', or 'cookie'
+ */
+function extractZValidatorSchema(callExpr: ASTCallExpression): {
+	inputSchemaVariable?: string;
+} {
+	const result: { inputSchemaVariable?: string } = {};
+
+	// zValidator requires at least 2 arguments: zValidator(target, schema)
+	if (!callExpr.arguments || callExpr.arguments.length < 2) {
+		return result;
+	}
+
+	// First argument should be 'json' literal
+	const targetArg = callExpr.arguments[0] as ASTNode;
+	if (targetArg.type === 'Literal') {
+		const targetValue = (targetArg as ASTLiteral).value;
+		// Only extract schemas for JSON body validation
+		if (targetValue !== 'json') {
+			return result;
+		}
+	} else {
+		// If first arg is not a literal, we can't determine the target, skip
+		return result;
+	}
+
+	// Second argument is the schema
+	const schemaArg = callExpr.arguments[1] as ASTNode;
+
+	// If it's an identifier (variable reference), extract the name
+	if (schemaArg.type === 'Identifier') {
+		result.inputSchemaVariable = (schemaArg as ASTNodeIdentifier).name;
+	}
+	// If it's inline schema (CallExpression like z.object({...})), we detect but don't extract yet
+	// TODO: Extract inline schema code
+
+	return result;
+}
+
 export async function parseRoute(
 	rootDir: string,
 	filename: string,

package/src/cmd/build/bundler.ts

@@ -1,7 +1,9 @@
-import { $ } from 'bun';
+import { $, semver } from 'bun';
 import { join, relative, resolve, dirname, basename } from 'node:path';
 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';
@@ -10,11 +12,31 @@ import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
 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';
 
-// Re-export for backward compatibility
-export { DeployOptionsSchema };
+const minBunVersion = '>=1.3.3';
+
+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;
@@ -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
@@ -83,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');
 
@@ -154,16 +183,13 @@ export async function bundle({
 	// Common externals for native modules (same as legacy CLI)
 	const commonExternals = ['bun', 'fsevents', 'chromium-bidi', 'sharp'];
 
-	// OpenTelemetry packages need to be externalized due to CommonJS/ESM hybrid issues
-	const otelExternals = ['@opentelemetry/*', '@traceloop/*'];
-
 	// 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, ...otelExternals, ...customExternals];
+	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
@@ -286,6 +312,8 @@ export async function bundle({
 		id: projectId ?? '',
 		name: pkgContents.name,
 		version: pkgContents.version,
+		description: pkgContents.description,
+		keywords: pkgContents.keywords,
 		orgId: orgId ?? '',
 	};
 	buildmetadata.deployment = {

package/src/cmd/build/format-schema.ts

@@ -0,0 +1,66 @@
+/**
+ * Simple formatter for schema code strings.
+ * Adds basic indentation and line breaks for readability.
+ */
+export function formatSchemaCode(code: string): string {
+	if (!code) return code;
+
+	let indentLevel = 0;
+	const indentSize = 2;
+	const lines: string[] = [];
+	let currentLine = '';
+
+	for (let i = 0; i < code.length; i++) {
+		const char = code[i];
+		const nextChar = code[i + 1];
+		const prevChar = i > 0 ? code[i - 1] : '';
+
+		// Skip existing whitespace/newlines
+		if (char === '\n' || char === '\r' || (char === ' ' && prevChar === ' ')) {
+			continue;
+		}
+
+		// Handle opening braces
+		if (char === '{') {
+			currentLine += char;
+			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+			indentLevel++;
+			currentLine = '';
+			continue;
+		}
+
+		// Handle closing braces
+		if (char === '}') {
+			if (currentLine.trim()) {
+				lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+				currentLine = '';
+			}
+			indentLevel--;
+			// Check if next char is closing paren - if so, put on same line
+			if (nextChar === ')') {
+				currentLine = '}';
+			} else {
+				lines.push(' '.repeat(indentLevel * indentSize) + char);
+			}
+			continue;
+		}
+
+		// Handle commas - add line break after
+		if (char === ',') {
+			currentLine += char;
+			lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+			currentLine = '';
+			continue;
+		}
+
+		// Accumulate characters
+		currentLine += char;
+	}
+
+	// Add any remaining content
+	if (currentLine.trim()) {
+		lines.push(' '.repeat(indentLevel * indentSize) + currentLine.trim());
+	}
+
+	return lines.join('\n');
+}

package/src/cmd/build/index.ts

@@ -77,6 +77,20 @@ export const command = createCommand({
 				logger: ctx.logger,
 			});
 
+			// Copy profile-specific .env file AFTER bundling (bundler clears outDir first)
+			if (opts.dev && ctx.config?.name) {
+				const envSourcePath = join(absoluteProjectDir, `.env.${ctx.config.name}`);
+				const envDestPath = join(outDir, '.env');
+
+				const envFile = Bun.file(envSourcePath);
+				if (await envFile.exists()) {
+					await Bun.write(envDestPath, envFile);
+					ctx.logger.debug(`Copied ${envSourcePath} to ${envDestPath}`);
+				} else {
+					ctx.logger.debug(`No .env.${ctx.config.name} file found, skipping env copy`);
+				}
+			}
+
 			// Run TypeScript type checking after registry generation (skip in dev mode)
 			if (!opts.dev && !opts.skipTypeCheck) {
 				try {

package/src/cmd/build/plugin.ts

@@ -371,10 +371,30 @@ import { readFileSync, existsSync } from 'node:fs';
 		}
 	}
 	const webstatic = serveStatic({ root: import.meta.dir + '/web' });
+	// In dev mode, serve from source; in prod, serve from build output
+	const publicRoot = ${isDevMode} ? ${JSON.stringify(join(srcDir, 'web', 'public'))} : import.meta.dir + '/web/public';
+	const publicstatic = serveStatic({ root: publicRoot, rewriteRequestPath: (path) => path });
 	router.get('/', (c) => c.html(index));
     router.get('/web/chunk/*', webstatic);
     router.get('/web/asset/*', webstatic);
-	router.get('/public/*', webstatic);
+	// Serve public assets at root (e.g., /favicon.ico) - must be last
+	router.get('/*', async (c, next) => {
+		const path = c.req.path;
+		// Prevent directory traversal attacks
+		if (path.includes('..') || path.includes('%2e%2e')) {
+			return c.notFound();
+		}
+		// Only serve from public folder at root (skip /web/* routes and /)
+		if (path !== '/' && !path.startsWith('/web/')) {
+			try {
+				// serveStatic calls next() internally if file not found
+				return await publicstatic(c, next);
+			} catch (err) {
+				return next();
+			}
+		}
+		return next();
+	});
 })();`);
 				}
 
@@ -415,7 +435,11 @@ import { readFileSync, existsSync } from 'node:fs';
 
 					for (const subdir of subdirs) {
 						const fullPath = join(agentBaseDir, subdir);
-						if (!agentDirs.has(fullPath)) {
+						// Check if this directory or any subdirectory contains agents
+						const hasAgentInTree = Array.from(agentDirs).some((agentDir) =>
+							agentDir.startsWith(fullPath)
+						);
+						if (!hasAgentInTree) {
 							throw new Error(
 								`Directory ${subdir} in src/agent must contain at least one agent (a file with a createAgent export)`
 							);
@@ -447,6 +471,56 @@ import { readFileSync, existsSync } from 'node:fs';
 						if (statSync(apiFile).isFile()) {
 							try {
 								const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
+
+								// Extract schemas from agents for routes that use validators
+								for (const route of routes) {
+									// Check if route has custom schema overrides from validator({ input, output })
+									const hasCustomInput = route.config?.inputSchemaVariable;
+									const hasCustomOutput = route.config?.outputSchemaVariable;
+
+									// If route uses agent.validator(), get schemas from the agent (unless overridden)
+									if (
+										route.config?.agentImportPath &&
+										(!hasCustomInput || !hasCustomOutput)
+									) {
+										const agentImportPath = route.config.agentImportPath as string;
+										// Match by import path: @agent/zod-test -> src/agent/zod-test/agent.ts
+										// Normalize import path by removing leading '@' -> agent/zod-test
+										const importPattern = agentImportPath.replace(/^@/, '');
+										// Escape regex special characters for safe pattern matching
+										const escapedPattern = importPattern.replace(
+											/[.*+?^${}()|[\]\\]/g,
+											'\\$&'
+										);
+										// Match as complete path segment to avoid false positives (e.g., "agent/hello" matching "agent/hello-world")
+										const segmentPattern = new RegExp(`(^|/)${escapedPattern}(/|$)`);
+
+										for (const [, agentMd] of agentMetadata) {
+											const agentFilename = agentMd.get('filename');
+											if (agentFilename && segmentPattern.test(agentFilename)) {
+												// Use agent schemas unless overridden
+												const inputSchemaCode = hasCustomInput
+													? undefined
+													: agentMd.get('inputSchemaCode');
+												const outputSchemaCode = hasCustomOutput
+													? undefined
+													: agentMd.get('outputSchemaCode');
+
+												if (inputSchemaCode || outputSchemaCode) {
+													route.schema = {
+														input: inputSchemaCode,
+														output: outputSchemaCode,
+													};
+												}
+												break;
+											}
+										}
+									}
+
+									// TODO: Extract inline schema code from custom validator({ input: z.string(), output: ... })
+									// For now, custom schema overrides with inline code are not extracted (would require parsing the validator call's object expression)
+								}
+
 								apiRoutesMetadata.push(...routes);
 
 								// Collect route info for RouteRegistry generation
@@ -594,6 +668,16 @@ await (async() => {
 						projectId,
 					};
 
+					// Extract schema codes if available
+					const inputSchemaCode = v.get('inputSchemaCode');
+					const outputSchemaCode = v.get('outputSchemaCode');
+					if (inputSchemaCode || outputSchemaCode) {
+						agentData.schema = {
+							input: inputSchemaCode,
+							output: outputSchemaCode,
+						};
+					}
+
 					const evalsStr = v.get('evals');
 					if (evalsStr) {
 						logger.trace(

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}`,