@agentuity/cli 0.1.9 → 0.1.10

package/src/cmd/ai/prompt/llm.ts

@@ -191,7 +191,7 @@ ${getCommand('project create')}
 ${getCommand('auth signup')}
 ${getCommand('auth login')}
 ${getCommand('project create')}
-${getCommand('secret set API_KEY <value>')}
+${getCommand('env set API_KEY <value> --secret')}
 \`\`\`
 
 ### 2. Deploy Application
@@ -211,12 +211,12 @@ ${getCommand('cloud deploy')}
 ${getCommand('--json cloud deployment show')}
 \`\`\`
 
-### 3. Manage Secrets
+### 3. Manage Environment Variables & Secrets
 
 \`\`\`bash
-${getCommand('--json secret list')}
-${getCommand('secret set DATABASE_URL <value>')}
-${getCommand('secret get DATABASE_URL')}
+${getCommand('--json env list')}
+${getCommand('env set DATABASE_URL <value> --secret')}
+${getCommand('env get DATABASE_URL')}
 \`\`\`
 
 ### 4. List Resources

package/src/cmd/auth/logout.ts

@@ -14,8 +14,11 @@ export const logoutCommand = createSubcommand({
 		{ command: getCommand('logout'), description: 'Logout from account' },
 	],
 
-	async handler() {
+	async handler(ctx) {
+		const { options } = ctx;
 		await clearAuth();
-		tui.success('You have been logged out');
+		if (!options.json) {
+			tui.success('You have been logged out');
+		}
 	},
 });

package/src/cmd/build/ast.ts

@@ -941,6 +941,102 @@ const InvalidRouterConfigError = StructuredError('InvalidRouterConfigError')<{
 	line?: number;
 }>();
 
+const SchemaNotExportedError = StructuredError('SchemaNotExportedError')<{
+	filename: string;
+	schemaName: string;
+	kind: 'input' | 'output';
+	method?: string;
+	path?: string;
+}>();
+
+/**
+ * Build a set of exported identifiers from the top-level program.
+ * Handles both `export const X = ...` and `export { X }` patterns.
+ */
+function buildExportedIdentifierSet(program: ASTProgram): Set<string> {
+	const exported = new Set<string>();
+
+	for (const node of program.body) {
+		if (node.type === 'ExportNamedDeclaration') {
+			const exp = node as unknown as {
+				declaration?: ASTNode;
+				specifiers?: Array<{ local?: ASTNodeIdentifier; exported?: ASTNodeIdentifier }>;
+			};
+
+			// Handle `export const X = ...` or `export function X() { ... }` or `export class X { ... }`
+			if (exp.declaration) {
+				if (exp.declaration.type === 'VariableDeclaration') {
+					const decl = exp.declaration as unknown as { declarations: ASTVariableDeclarator[] };
+					for (const d of decl.declarations) {
+						if (d.id.type === 'Identifier') {
+							const id = d.id as ASTNodeIdentifier;
+							exported.add(id.name);
+						}
+					}
+				} else if (exp.declaration.type === 'FunctionDeclaration') {
+					const funcDecl = exp.declaration as unknown as { id?: ASTNodeIdentifier };
+					if (funcDecl.id?.name) {
+						exported.add(funcDecl.id.name);
+					}
+				} else if (exp.declaration.type === 'ClassDeclaration') {
+					const classDecl = exp.declaration as unknown as { id?: ASTNodeIdentifier };
+					if (classDecl.id?.name) {
+						exported.add(classDecl.id.name);
+					}
+				}
+			}
+
+			// Handle `export { X }` or `export { X as Y }`
+			if (exp.specifiers && Array.isArray(exp.specifiers)) {
+				for (const spec of exp.specifiers) {
+					// For `export { X }`, local.name is the variable name in this file
+					if (spec.local?.name) {
+						exported.add(spec.local.name);
+					}
+				}
+			}
+		}
+	}
+
+	return exported;
+}
+
+/**
+ * Validate that schema variables used in validators are either imported or exported.
+ * Throws SchemaNotExportedError if a locally-defined schema is not exported.
+ */
+function validateSchemaExports(
+	schemaVariable: string | undefined,
+	kind: 'input' | 'output',
+	importedNames: Set<string>,
+	exportedNames: Set<string>,
+	filename: string,
+	method?: string,
+	path?: string
+): void {
+	if (!schemaVariable) return;
+
+	// If the schema is imported from another file, it's already exported from its source
+	if (importedNames.has(schemaVariable)) return;
+
+	// If the schema is defined locally, it must be exported
+	if (!exportedNames.has(schemaVariable)) {
+		const routeDesc = method && path ? ` for route "${method.toUpperCase()} ${path}"` : '';
+		throw new SchemaNotExportedError({
+			filename,
+			schemaName: schemaVariable,
+			kind,
+			method,
+			path,
+			message:
+				`Schema "${schemaVariable}" used as the ${kind} validator${routeDesc} in ${filename} is not exported.\n\n` +
+				`Agentuity generates a route registry that imports schema types by name, so the schema must be exported.\n\n` +
+				`To fix this, add "export" to the schema declaration:\n\n` +
+				`  export const ${schemaVariable} = s.object({ ... });\n`,
+		});
+	}
+}
+
 /**
  * Check if an AST node contains a validator() call
  */
@@ -1292,6 +1388,12 @@ export async function parseRoute(
 		}
 	}
 
+	// Build set of imported names for schema export validation
+	const importedNames = new Set(importMap.keys());
+
+	// Build set of exported identifiers for schema export validation
+	const exportedNames = buildExportedIdentifierSet(ast as ASTProgram);
+
 	// Scan for exported schemas (for WebSocket/SSE routes)
 	let exportedInputSchemaName: string | undefined;
 	let exportedOutputSchemaName: string | undefined;
@@ -1496,6 +1598,25 @@ export async function parseRoute(
 												routeConfig.agentImportPath = agentImportPath;
 											}
 										}
+										// Validate that schema variables are exported (if defined locally)
+										validateSchemaExports(
+											validatorInfo.inputSchemaVariable,
+											'input',
+											importedNames,
+											exportedNames,
+											rel,
+											httpMethod,
+											thepath
+										);
+										validateSchemaExports(
+											validatorInfo.outputSchemaVariable,
+											'output',
+											importedNames,
+											exportedNames,
+											rel,
+											httpMethod,
+											thepath
+										);
 										if (validatorInfo.inputSchemaVariable) {
 											routeConfig.inputSchemaVariable =
 												validatorInfo.inputSchemaVariable;
@@ -1557,6 +1678,25 @@ export async function parseRoute(
 												routeConfig.agentImportPath = agentImportPath;
 											}
 										}
+										// Validate that schema variables are exported (if defined locally)
+										validateSchemaExports(
+											validatorInfo.inputSchemaVariable,
+											'input',
+											importedNames,
+											exportedNames,
+											rel,
+											httpMethod,
+											thepath
+										);
+										validateSchemaExports(
+											validatorInfo.outputSchemaVariable,
+											'output',
+											importedNames,
+											exportedNames,
+											rel,
+											httpMethod,
+											thepath
+										);
 										if (validatorInfo.inputSchemaVariable) {
 											routeConfig.inputSchemaVariable =
 												validatorInfo.inputSchemaVariable;
@@ -1718,6 +1858,25 @@ export async function parseRoute(
 									routeConfig.agentImportPath = agentImportPath;
 								}
 							}
+							// Validate that schema variables are exported (if defined locally)
+							validateSchemaExports(
+								validatorInfo.inputSchemaVariable,
+								'input',
+								importedNames,
+								exportedNames,
+								rel,
+								method,
+								thepath
+							);
+							validateSchemaExports(
+								validatorInfo.outputSchemaVariable,
+								'output',
+								importedNames,
+								exportedNames,
+								rel,
+								method,
+								thepath
+							);
 							if (validatorInfo.inputSchemaVariable) {
 								routeConfig.inputSchemaVariable = validatorInfo.inputSchemaVariable;
 							}
@@ -1754,7 +1913,7 @@ export async function parseRoute(
 			}
 		}
 	} catch (error) {
-		if (error instanceof InvalidRouterConfigError) {
+		if (error instanceof InvalidRouterConfigError || error instanceof SchemaNotExportedError) {
 			throw error;
 		}
 		throw new InvalidRouterConfigError({

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -94,11 +94,11 @@ export async function generateAssetServerConfig(
 			},
 
 			// HMR configuration - client must connect to Vite asset server directly
+			// Do NOT set port/clientPort - let Vite use the actual server port it binds to
+			// (important when strictPort: false and Vite falls back to an alternate port)
 			hmr: {
 				protocol: 'ws',
 				host: '127.0.0.1',
-				port, // HMR WebSocket on same port as HTTP
-				clientPort: port, // Tell client to connect to this port (not origin 3500)
 			},
 
 			// Don't open browser - Bun server will be the entry point
@@ -151,7 +151,11 @@ export async function generateAssetServerConfig(
 		// Custom logger to integrate with our logger
 		customLogger: {
 			info(msg: string) {
-				if (!msg.includes('[vite]')) {
+				// Show port-related messages at info level (important for debugging port conflicts)
+				// Keep other Vite info messages (like HMR updates) at debug to avoid noise
+				if (msg.includes('Port') || msg.includes('port')) {
+					logger.info(`[Vite Asset] ${msg}`);
+				} else {
 					logger.debug(`[Vite Asset] ${msg}`);
 				}
 			},

package/src/cmd/build/vite/vite-asset-server.ts

@@ -111,9 +111,12 @@ export async function startViteAssetServer(
 		actualPort = getPortFromHttpServer() ?? preferredPort;
 	}
 
-	logger.debug(`✅ Vite asset server started on port ${actualPort}`);
-	if (actualPort !== preferredPort) {
-		logger.debug(`Port ${preferredPort} was taken, using ${actualPort} instead`);
+	if (actualPort === preferredPort) {
+		logger.info(`Vite asset server running on port ${actualPort}`);
+	} else {
+		logger.warn(
+			`Vite asset server running on port ${actualPort} (preferred port ${preferredPort} was in use)`
+		);
 	}
 	logger.debug(`Asset server will handle: HMR, React transformation, source maps`);
 	logger.debug(`HMR WebSocket configured to connect to ws://127.0.0.1:${actualPort}`);

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

@@ -1,13 +1,14 @@
 import { z } from 'zod';
-import { listResources, deleteResources, APIError } from '@agentuity/server';
+import { listOrgResources, listOrganizations, deleteResources, APIError } from '@agentuity/server';
 import enquirer from 'enquirer';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getCatalystAPIClient } from '../../../config';
+import { getGlobalCatalystAPIClient, getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
 import { removeResourceEnvVars } from '../../../env-util';
+import { getResourceInfo, setResourceInfo, deleteResourceRegion } from '../../../cache';
 
 export const deleteSubcommand = createSubcommand({
 	name: 'delete',
@@ -15,7 +16,8 @@ export const deleteSubcommand = createSubcommand({
 	description: 'Delete a database resource',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth', 'requires-deployment'],
 	idempotent: false,
-	requires: { auth: true, org: true, region: true },
+	requires: { auth: true },
+	optional: { org: true },
 	examples: [
 		{ command: getCommand('cloud db delete my-database'), description: 'Delete item' },
 		{ command: getCommand('cloud db rm my-database'), description: 'Delete item' },
@@ -36,21 +38,79 @@ export const deleteSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, opts, orgId, region, auth, options } = ctx;
+		const { logger, args, opts, auth, options, config } = ctx;
 
-		const catalystClient = getCatalystAPIClient(logger, auth, region);
+		const profileName = config?.name ?? 'production';
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
 
 		let dbName = args.name;
 
-		if (!dbName) {
-			const resources = await tui.spinner({
-				message: `Fetching databases for ${orgId} in ${region}`,
+		// If db name provided, try cache first for orgId
+		let orgId = ctx.orgId;
+		if (dbName && !orgId) {
+			const cachedInfo = await getResourceInfo('db', profileName, dbName);
+			orgId = cachedInfo?.orgId;
+		}
+
+		// For interactive selection (no db name), we need orgId
+		if (!dbName && !orgId) {
+			tui.fatal(
+				'Organization required for interactive database selection. Specify --org-id or provide database name.',
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
+
+		// If we have a db name but no orgId, search across all user's orgs
+		let resources: Awaited<ReturnType<typeof listOrgResources>> | undefined;
+		if (dbName && !orgId) {
+			const orgs = await tui.spinner({
+				message: 'Searching for database across organizations...',
+				clearOnSuccess: true,
+				callback: async () => listOrganizations(catalystClient),
+			});
+
+			for (const org of orgs) {
+				const orgResources = await listOrgResources(catalystClient, {
+					type: 'db',
+					orgId: org.id,
+				});
+				// Cache all fetched databases
+				for (const db of orgResources.db) {
+					await setResourceInfo('db', profileName, db.name, db.cloud_region, org.id);
+				}
+				const found = orgResources.db.find((db) => db.name === dbName);
+				if (found) {
+					orgId = org.id;
+					resources = orgResources;
+					break;
+				}
+			}
+
+			if (!orgId) {
+				tui.fatal(
+					`Database '${dbName}' not found in any of your organizations.`,
+					ErrorCode.RESOURCE_NOT_FOUND
+				);
+			}
+		}
+
+		// Fetch databases if we haven't already (when orgId was known upfront)
+		if (!resources) {
+			resources = await tui.spinner({
+				message: `Fetching databases for ${orgId}`,
 				clearOnSuccess: true,
 				callback: async () => {
-					return listResources(catalystClient, orgId, region!);
+					return listOrgResources(catalystClient, { type: 'db', orgId: orgId! });
 				},
 			});
 
+			// Cache all fetched databases
+			for (const db of resources.db) {
+				await setResourceInfo('db', profileName, db.name, db.cloud_region, orgId!);
+			}
+		}
+
+		if (!dbName) {
 			if (resources.db.length === 0) {
 				tui.info('No databases found to delete');
 				return { success: false, name: '' };
@@ -69,9 +129,16 @@ export const deleteSubcommand = createSubcommand({
 			dbName = response.db;
 		}
 
+		// Find the database to get its region
+		const database = resources.db.find((db) => db.name === dbName);
+		if (!database) {
+			tui.fatal(`Database '${dbName}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+		}
+		const region = database.cloud_region;
+
 		// Handle dry-run mode
 		if (isDryRunMode(options)) {
-			outputDryRun(`Would delete database: ${dbName}`, options);
+			outputDryRun(`Would delete database: ${dbName} (region: ${region})`, options);
 			if (!options.json) {
 				tui.newline();
 				tui.info('[DRY RUN] Database deletion skipped');
@@ -99,11 +166,13 @@ export const deleteSubcommand = createSubcommand({
 		}
 
 		try {
+			// Use regional client for the delete operation
+			const regionalClient = getCatalystAPIClient(logger, auth, region);
 			const deleted = await tui.spinner({
 				message: `Deleting database ${dbName}`,
 				clearOnSuccess: true,
 				callback: async () => {
-					return deleteResources(catalystClient, orgId, region!, [
+					return deleteResources(regionalClient, orgId!, region, [
 						{ type: 'db', name: dbName },
 					]);
 				},
@@ -112,6 +181,9 @@ export const deleteSubcommand = createSubcommand({
 			if (deleted.length > 0) {
 				const resource = deleted[0];
 
+				// Clear cache entry for deleted database
+				await deleteResourceRegion('db', 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);

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
-import { listResources, dbTables, generateCreateTableSQL } from '@agentuity/server';
+import { listOrgResources, dbTables, generateCreateTableSQL } from '@agentuity/server';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getCatalystAPIClient } from '../../../config';
+import { getGlobalCatalystAPIClient, getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
+import { getResourceInfo, setResourceInfo } from '../../../cache';
 
 const DBGetResponseSchema = z
 	.object({
@@ -22,7 +23,8 @@ export const getSubcommand = createSubcommand({
 	aliases: ['show'],
 	description: 'Show details about a specific database',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, org: true, region: true },
+	requires: { auth: true },
+	optional: { org: true },
 	idempotent: true,
 	examples: [
 		{ command: `${getCommand('cloud db get')} my-database`, description: 'Get database details' },
@@ -66,31 +68,51 @@ export const getSubcommand = createSubcommand({
 	webUrl: (ctx) => `/services/database/${encodeURIComponent(ctx.args.name)}`,
 
 	async handler(ctx) {
-		const { logger, args, opts, options, orgId, region, auth } = ctx;
+		const { logger, args, opts, options, auth, config } = ctx;
 
-		const catalystClient = getCatalystAPIClient(logger, auth, region);
+		const profileName = config?.name ?? 'production';
+		const globalClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
+
+		// Check cache first for orgId
+		const cachedInfo = await getResourceInfo('db', profileName, args.name);
+		const orgId = ctx.orgId ?? cachedInfo?.orgId;
+
+		if (!orgId) {
+			tui.fatal(
+				`Organization not found for database '${args.name}'. Run 'agentuity cloud db list' first or specify --org-id.`,
+				ErrorCode.INVALID_ARGUMENT
+			);
+		}
 
 		const resources = await tui.spinner({
 			message: `Fetching database ${args.name}`,
 			clearOnSuccess: true,
 			callback: async () => {
-				return listResources(catalystClient, orgId, region);
+				return listOrgResources(globalClient, { type: 'db', orgId });
 			},
 		});
 
 		const db = resources.db.find((d) => d.name === args.name);
 
+		// Cache the database info for future lookups
+		if (db?.cloud_region) {
+			await setResourceInfo('db', profileName, db.name, db.cloud_region, orgId);
+		}
+
 		if (!db) {
 			tui.fatal(`Database '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
 		}
 
 		// If --tables flag is provided, fetch table schemas
+		// Need regional Catalyst for database operations
 		if (opts.showTables) {
+			const region = db.cloud_region;
+			const regionalClient = getCatalystAPIClient(logger, auth, region);
 			const tables = await tui.spinner({
 				message: `Fetching table schemas for ${args.name}`,
 				clearOnSuccess: true,
 				callback: async () => {
-					return dbTables(catalystClient, {
+					return dbTables(regionalClient, {
 						database: args.name,
 						orgId,
 						region,

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

@@ -1,9 +1,10 @@
 import { z } from 'zod';
-import { listResources } from '@agentuity/server';
+import { listOrgResources } from '@agentuity/server';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { getCatalystAPIClient } from '../../../config';
+import { getGlobalCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
+import { setResourceInfo } from '../../../cache';
 
 const DBListResponseSchema = z.object({
 	databases: z
@@ -11,6 +12,7 @@ const DBListResponseSchema = z.object({
 			z.object({
 				name: z.string().describe('Database name'),
 				url: z.string().optional().describe('Database connection URL'),
+				cloud_region: z.string().optional().describe('Cloud region where database is hosted'),
 			})
 		)
 		.describe('List of database resources'),
@@ -21,7 +23,7 @@ export const listSubcommand = createSubcommand({
 	aliases: ['ls'],
 	description: 'List database resources',
 	tags: ['read-only', 'fast', 'requires-auth'],
-	requires: { auth: true, org: true, region: true },
+	requires: { auth: true, org: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('cloud db list'), description: 'List items' },
@@ -47,18 +49,24 @@ export const listSubcommand = createSubcommand({
 	webUrl: '/services/database',
 
 	async handler(ctx) {
-		const { logger, opts, options, orgId, region, auth } = ctx;
+		const { logger, opts, options, orgId, auth, config } = ctx;
 
-		const catalystClient = getCatalystAPIClient(logger, auth, region);
+		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
+		const profileName = config?.name ?? 'production';
 		const resources = await tui.spinner({
-			message: `Fetching databases for ${orgId} in ${region}`,
+			message: `Fetching databases for ${orgId}`,
 			clearOnSuccess: true,
 			callback: async () => {
-				return listResources(catalystClient, orgId, region);
+				return listOrgResources(catalystClient, { type: 'db', orgId });
 			},
 		});
 
+		// Cache each database with its region and orgId for future lookups
+		for (const db of resources.db) {
+			await setResourceInfo('db', profileName, db.name, db.cloud_region, orgId);
+		}
+
 		// Mask credentials in terminal output by default, unless --show-credentials is passed
 		const shouldShowCredentials = opts.showCredentials === true;
 		const shouldMask = !options.json && !shouldShowCredentials;
@@ -90,6 +98,7 @@ export const listSubcommand = createSubcommand({
 			databases: resources.db.map((db) => ({
 				name: db.name,
 				url: db.url ?? undefined,
+				cloud_region: db.cloud_region,
 			})),
 		};
 	},

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

@@ -1,10 +1,11 @@
 import { z } from 'zod';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
-import { dbLogs, DbQueryLogSchema } from '@agentuity/server';
-import { getCatalystAPIClient } from '../../../config';
+import { dbLogs, DbQueryLogSchema, listOrgResources } from '@agentuity/server';
+import { getGlobalCatalystAPIClient, getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
+import { getResourceInfo, setResourceInfo } from '../../../cache';
 
 const DbLogsResponseSchema = z.array(DbQueryLogSchema);
 
@@ -51,7 +52,8 @@ export const logsSubcommand = createSubcommand({
 			description: 'Show full formatted SQL on separate lines',
 		},
 	],
-	requires: { auth: true, org: true, region: true },
+	requires: { auth: true },
+	optional: { org: true },
 	idempotent: true,
 	schema: {
 		args: z.object({
@@ -78,13 +80,40 @@ export const logsSubcommand = createSubcommand({
 		response: DbLogsResponseSchema,
 	},
 	async handler(ctx) {
-		const { args, options, orgId, region, logger, auth } = ctx;
+		const { args, options, logger, auth, config } = 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;
 
+		const profileName = config?.name ?? 'production';
+
 		try {
+			const globalClient = await getGlobalCatalystAPIClient(logger, auth, profileName);
+
+			// Check cache first for orgId
+			const cachedInfo = await getResourceInfo('db', profileName, args.database);
+			const orgId = ctx.orgId ?? cachedInfo?.orgId;
+
+			if (!orgId) {
+				tui.fatal(
+					`Organization not found for database '${args.database}'. Run 'agentuity cloud db list' first or specify --org-id.`,
+					ErrorCode.INVALID_ARGUMENT
+				);
+			}
+
+			// Look up the database to get its region
+			const resources = await listOrgResources(globalClient, { type: 'db', orgId });
+			const database = resources.db.find((db) => db.name === args.database);
+			if (!database) {
+				tui.fatal(`Database '${args.database}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
+			}
+			const region = database.cloud_region;
+
+			// Cache the database info for future lookups
+			await setResourceInfo('db', profileName, database.name, region, orgId);
+
+			// Use regional client for logs (ClickHouse queries are region-specific)
 			const catalystClient = getCatalystAPIClient(logger, auth, region);
 
 			const logs = await dbLogs(catalystClient, {