@agentuity/cli 0.0.64 → 0.0.66

package/src/cmd/build/bundler.ts

@@ -1,5 +1,4 @@
 import { $ } from 'bun';
-import { z } from 'zod';
 import { join, relative, resolve, dirname, basename } from 'node:path';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
@@ -12,34 +11,11 @@ import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
 import { analyzeWorkbench } from './ast';
-import { encodeWorkbenchConfig, StructuredError } from '@agentuity/core';
-
-export const DeployOptionsSchema = z.object({
-	tag: z
-		.array(z.string())
-		.default(['latest'])
-		.optional()
-		.describe('One or more tags to add to the deployment'),
-	logsUrl: z.url().optional().describe('The url to the CI build logs'),
-	trigger: z
-		.enum(['cli', 'workflow', 'webhook'])
-		.default('cli')
-		.optional()
-		.describe('The trigger that caused the build'),
-	commitUrl: z.url().optional().describe('The url to the CI commit'),
-	message: z.string().optional().describe('The message to associate with this deployment'),
-	provider: z.string().optional().describe('The CI provider name (attempts to autodetect)'),
-	event: z
-		.enum(['pull_request', 'push', 'manual', 'workflow'])
-		.default('manual')
-		.optional()
-		.describe('The event that triggered the deployment'),
-	pullRequestNumber: z.number().optional().describe('the pull request number'),
-	pullRequestCommentId: z.string().optional().describe('the pull request comment id'),
-	pullRequestURL: z.url().optional().describe('the pull request url'),
-});
-
-type DeployOptions = z.infer<typeof DeployOptionsSchema>;
+import { StructuredError } from '@agentuity/core';
+import { DeployOptionsSchema, type DeployOptions } from '../../schemas/deploy';
+
+// Re-export for backward compatibility
+export { DeployOptionsSchema };
 
 export interface BundleOptions extends DeployOptions {
 	rootDir: string;
@@ -138,6 +114,15 @@ export async function bundle({
 	mkdirSync(join(outDir, 'chunk'), { recursive: true });
 	mkdirSync(join(outDir, 'asset'), { recursive: true });
 
+	// Pre-create all nested source directories in output
+	// This is needed because Bun.build with naming.entry preserves structure
+	// but doesn't create nested directories automatically
+	for (const entrypoint of appEntrypoints) {
+		const relPath = relative(rootDir, dirname(entrypoint));
+		const outputSubdir = join(outDir, relPath);
+		mkdirSync(outputSubdir, { recursive: true });
+	}
+
 	const pkgFile = Bun.file(join(rootDir, 'package.json'));
 	const pkgContents = JSON.parse(await pkgFile.text());
 	const isProd = !dev;
@@ -270,10 +255,15 @@ export async function bundle({
 			);
 
 			if (webEntrypoints.length) {
+				const webOutDir = join(outDir, 'web');
+				mkdirSync(webOutDir, { recursive: true });
+				mkdirSync(join(webOutDir, 'chunk'), { recursive: true });
+				mkdirSync(join(webOutDir, 'asset'), { recursive: true });
+
 				const config: Bun.BuildConfig = {
 					entrypoints: webEntrypoints,
 					root: webDir,
-					outdir: join(outDir, 'web'),
+					outdir: webOutDir,
 					define,
 					sourcemap: dev ? 'inline' : 'linked',
 					env: 'AGENTUITY_PUBLIC_*',
@@ -330,15 +320,9 @@ export async function bundle({
 		const analysis = analyzeWorkbench(appContent);
 
 		if (analysis.hasWorkbench) {
-			// Encode workbench config for environment variable
-			const config = analysis.config || { route: '/workbench', headers: {} };
-			// Add port to config (defaults to 3500 if not provided)
-			const configWithPort = { ...config, port: port || 3500 };
-			const encodedConfig = encodeWorkbenchConfig(configWithPort);
-			const workbenchDefine = {
-				...define,
-				AGENTUITY_WORKBENCH_CONFIG_INLINE: JSON.stringify(encodedConfig),
-			};
+			// 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
@@ -356,14 +340,13 @@ export async function bundle({
 				const workbenchBuildConfig: Bun.BuildConfig = {
 					entrypoints: [workbenchIndexFile],
 					outdir: join(outDir, 'workbench'),
-					define: workbenchDefine,
 					sourcemap: dev ? 'inline' : 'linked',
-					plugins: [AgentuityBundler],
+					plugins: [AgentuityBundler], // i dont think we need this plugin here
 					target: 'browser',
 					format: 'esm',
 					banner: `// Generated file. DO NOT EDIT`,
-					minify: true,
-					splitting: true,
+					minify: !dev, // Disable minification in dev to avoid module resolution issues
+					splitting: !dev, // Disable code splitting in dev to avoid relative import resolution issues
 					packages: 'bundle',
 					naming: {
 						entry: '[dir]/[name].[ext]',
@@ -390,7 +373,7 @@ export async function bundle({
 					}
 					// Clean up temp directory even on failure
 					rmSync(tempWorkbenchDir, { recursive: true, force: true });
-					process.exit(1);
+					logger.fatal('Workbench bundling failed');
 				}
 			} catch (error) {
 				logger.error('Failed to bundle workbench:', error);

package/src/cmd/build/index.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { resolve, join } from 'node:path';
+import { getServiceUrls } from '@agentuity/server';
 import { createCommand } from '../../types';
 import { bundle } from './bundler';
 import * as tui from '../../tui';
@@ -40,7 +41,7 @@ export const command = createCommand({
 	},
 
 	async handler(ctx) {
-		const { opts, projectDir, project, config } = ctx;
+		const { opts, projectDir, project } = ctx;
 
 		const absoluteProjectDir = resolve(projectDir);
 		const outDir = opts.outdir ? resolve(opts.outdir) : join(absoluteProjectDir, '.agentuity');
@@ -50,31 +51,21 @@ export const command = createCommand({
 
 			const env: Map<string, string> = new Map();
 
-			if (opts.dev) {
-				if (config?.overrides?.transport_url) {
-					env.set('AGENTUITY_TRANSPORT_URL', config.overrides.transport_url);
-				}
-				if (config?.overrides?.catalyst_url) {
-					env.set('AGENTUITY_CATALYST_URL', config.overrides.catalyst_url);
-				}
-				if (config?.overrides?.vector_url) {
-					env.set('AGENTUITY_VECTOR_URL', config.overrides.vector_url);
-				}
-				if (config?.overrides?.object_url) {
-					env.set('AGENTUITY_OBJECTSTORE_URL', config.overrides.object_url);
-				}
-				if (config?.overrides?.kv_url) {
-					env.set('AGENTUITY_KEYVALUE_URL', config.overrides.kv_url);
-				}
-				if (config?.overrides?.stream_url) {
-					env.set('AGENTUITY_STREAM_URL', config.overrides.stream_url);
-				}
-				if (project) {
-					env.set('AGENTUITY_CLOUD_ORG_ID', project.orgId);
-					env.set('AGENTUITY_CLOUD_PROJECT_ID', project.projectId);
-				}
+			if (project) {
+				const serviceUrls = getServiceUrls(project.region);
+				env.set('AGENTUITY_TRANSPORT_URL', serviceUrls.catalyst);
+				env.set('AGENTUITY_CATALYST_URL', serviceUrls.catalyst);
+				env.set('AGENTUITY_VECTOR_URL', serviceUrls.vector);
+				env.set('AGENTUITY_OBJECTSTORE_URL', serviceUrls.objectstore);
+				env.set('AGENTUITY_KEYVALUE_URL', serviceUrls.keyvalue);
+				env.set('AGENTUITY_STREAM_URL', serviceUrls.stream);
+				env.set('AGENTUITY_CLOUD_ORG_ID', project.orgId);
+				env.set('AGENTUITY_CLOUD_PROJECT_ID', project.projectId);
+				env.set('AGENTUITY_REGION', project.region);
 			}
 
+			ctx.logger.trace('setting env to %s', env);
+
 			await bundle({
 				rootDir: absoluteProjectDir,
 				dev: opts.dev || false,

package/src/cmd/build/plugin.ts

@@ -636,15 +636,17 @@ const AgentuityBundler: BunPlugin = {
 				const workbenchConfig = await setupWorkbench(srcDir);
 
 				if (existsSync(indexFile)) {
-					inserts.push(`await (async () => {
-    const { serveStatic } = require('hono/bun');
-    const { getRouter, registerDevModeRoutes } = await import('@agentuity/runtime');
+					inserts.push(`import { serveStatic } from 'hono/bun';
+import { getRouter, registerDevModeRoutes } from '@agentuity/runtime';
+import { readFileSync, existsSync } from 'node:fs';
+
+(() => {
     const router = getRouter()!;
 	
 	// Setup workbench routes if workbench was bundled
 	const workbenchIndexPath = import.meta.dir + '/workbench/index.html';
-	if (await Bun.file(workbenchIndexPath).exists()) {
-		let workbenchIndex = await Bun.file(workbenchIndexPath).text();
+	if (existsSync(workbenchIndexPath)) {
+		let workbenchIndex = readFileSync(workbenchIndexPath, 'utf-8');
 		
 		// Always serve assets at /workbench/* regardless of HTML route
 		const workbenchStatic = serveStatic({ root: import.meta.dir + '/workbench' });
@@ -662,7 +664,7 @@ const AgentuityBundler: BunPlugin = {
 		router.get(route, (c) => c.html(workbenchIndex));
 	}
 	
-	let index = await Bun.file(import.meta.dir + '/web/index.html').text();
+	let index = readFileSync(import.meta.dir + '/web/index.html', 'utf-8');
 	if (${isDevMode}) {
 		const end = index.lastIndexOf('</html>');
 		const html = registerDevModeRoutes(router);
@@ -726,12 +728,13 @@ const AgentuityBundler: BunPlugin = {
 				// Generate lifecycle types if setup() is present in app.ts
 				await setupLifecycleTypes(rootDir, outDir, srcDir, logger);
 
-				// Only create the workbench metadata route if workbench is actually configured
+				// Only create the workbench routes if workbench is actually configured
 				if (workbenchConfig) {
 					inserts.push(`await (async() => {
-    const { createWorkbenchMetadataRoute, getRouter } = await import('@agentuity/runtime');
-    const router = getRouter()!;
-	router.get('/_agentuity/workbench/metadata.json', createWorkbenchMetadataRoute());
+	const { createWorkbenchRouter, getRouter } = await import('@agentuity/runtime');
+	const router = getRouter()!;
+	const workbenchRouter = createWorkbenchRouter();
+	router.route('/', workbenchRouter);
 })();`);
 				}
 

package/src/cmd/build/workbench-templates.ts

@@ -1,13 +1,11 @@
-import type { WorkbenchConfig } from '@agentuity/core';
+import { encodeWorkbenchConfig, type WorkbenchConfig } from '@agentuity/core';
 
 export function generateWorkbenchMainTsx(config: WorkbenchConfig): string {
-	const configString = JSON.stringify(config);
-
+	const encodedConfig = encodeWorkbenchConfig(config);
 	return `// Generated workbench entry point
 import React from 'react';
 import { createRoot } from 'react-dom/client';
-import { AgentuityProvider } from '@agentuity/react';
-import { createWorkbench, Workbench } from '@agentuity/workbench';
+import { App } from '@agentuity/workbench';
 import '@agentuity/workbench/styles';
 
 // Root element
@@ -16,23 +14,10 @@ if (!rootElement) {
 	throw new Error('Root element not found');
 }
 
-// Create workbench instance with config from bundler
-const workbenchConfig = ${configString};
-const workbench = createWorkbench(workbenchConfig);
-
-function App() {
-	return (
-		<AgentuityProvider baseUrl={window.location.origin}>
-			<div className="min-h-screen bg-background text-foreground">
-				<Workbench workbench={workbench} />
-			</div>
-		</AgentuityProvider>
-	);
-}
-
-// Render the app
+// Render the app (App has its own provider and config)
 const root = createRoot(rootElement);
-root.render(<App />);
+console.log('encodedConfig', '${encodedConfig}');
+root.render(<App configBase64="${encodedConfig}" />);
 `;
 }
 

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

@@ -82,22 +82,14 @@ export const createSubcommand = createSubcommandHelper({
 			}
 		}
 
-		let result: Awaited<ReturnType<typeof apikeyCreate>>;
-		try {
-			result = await tui.spinner('Creating API key', () => {
-				return apikeyCreate(apiClient, {
-					name: opts.name,
-					expiresAt: expiresAt,
-					projectId: projectId,
-					orgId: orgId,
-				});
+		const result = await tui.spinner('Creating API key', () => {
+			return apikeyCreate(apiClient, {
+				name: opts.name,
+				expiresAt: expiresAt,
+				projectId: projectId,
+				orgId: orgId,
 			});
-		} catch (error) {
-			if (error instanceof Error) {
-				tui.fatal(error.message);
-			}
-			throw error;
-		}
+		});
 
 		if (!options.json) {
 			tui.newline();

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

@@ -22,7 +22,7 @@ export const createSubcommand = defineSubcommand({
 	],
 	schema: {
 		options: z.object({
-			name: z.string().optional().describe('Custom database name (optional)'),
+			name: z.string().optional().describe('Custom database name'),
 		}),
 		response: z.object({
 			success: z.boolean().describe('Whether creation succeeded'),
@@ -49,7 +49,7 @@ export const createSubcommand = defineSubcommand({
 			};
 		}
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth);
+		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
 
 		try {
 			const created = await tui.spinner({
@@ -75,8 +75,9 @@ export const createSubcommand = defineSubcommand({
 		} catch (ex) {
 			if (ex instanceof APIError) {
 				if (ex.status === 409) {
+					const dbName = opts.name || 'auto-generated';
 					tui.fatal(
-						`database with the name "${opts.name}" already exists. Use another name or don't specify --name for a unique name to be generated automatically.`,
+						`database with the name "${dbName}" already exists. Use another name or don't specify --name for a unique name to be generated automatically.`,
 						ErrorCode.INVALID_ARGUMENT
 					);
 				}

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

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

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

@@ -1,15 +1,21 @@
 import { z } from 'zod';
-import { listResources } from '@agentuity/server';
+import { listResources, dbTables, generateCreateTableSQL } from '@agentuity/server';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { ErrorCode } from '../../../errors';
 
-const DBGetResponseSchema = z.object({
-	name: z.string().describe('Database name'),
-	url: z.string().optional().describe('Database connection URL'),
-});
+const DBGetResponseSchema = z
+	.object({
+		name: z.string().describe('Database name'),
+		url: z.string().optional().describe('Database connection URL'),
+	})
+	.or(
+		z.object({
+			tables: z.union([z.array(z.string()), z.array(z.any())]).describe('Table information'),
+		})
+	);
 
 export const getSubcommand = createSubcommand({
 	name: 'get',
@@ -28,6 +34,18 @@ export const getSubcommand = createSubcommand({
 			command: `${getCommand('cloud db get')} my-database --show-credentials`,
 			description: 'Get database with credentials',
 		},
+		{
+			command: `${getCommand('cloud db get')} my-database --show-tables`,
+			description: 'Get table schemas from the database',
+		},
+		{
+			command: `${getCommand('cloud db get')} my-database --show-tables --sql`,
+			description: 'Get table schemas as SQL CREATE statements',
+		},
+		{
+			command: `${getCommand('cloud db get')} my-database --show-tables --json`,
+			description: 'Get table schemas as JSON',
+		},
 	],
 	schema: {
 		args: z.object({
@@ -40,6 +58,8 @@ export const getSubcommand = createSubcommand({
 				.describe(
 					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
 				),
+			showTables: z.boolean().optional().describe('Fetch table schemas from the database'),
+			sql: z.boolean().optional().describe('Output table schemas as SQL CREATE statements'),
 		}),
 		response: DBGetResponseSchema,
 	},
@@ -47,7 +67,7 @@ export const getSubcommand = createSubcommand({
 	async handler(ctx) {
 		const { logger, args, opts, options, orgId, region, config, auth } = ctx;
 
-		const catalystClient = getCatalystAPIClient(config, logger, auth);
+		const catalystClient = getCatalystAPIClient(config, logger, auth, region);
 
 		const resources = await tui.spinner({
 			message: `Fetching database ${args.name}`,
@@ -63,6 +83,66 @@ export const getSubcommand = createSubcommand({
 			tui.fatal(`Database '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
 		}
 
+		// If --tables flag is provided, fetch table schemas
+		if (opts.showTables) {
+			const tables = await tui.spinner({
+				message: `Fetching table schemas for ${args.name}`,
+				clearOnSuccess: true,
+				callback: async () => {
+					return dbTables(catalystClient, {
+						database: args.name,
+						orgId,
+						region,
+					});
+				},
+			});
+
+			if (!tables || tables.length === 0) {
+				if (!options.json) {
+					tui.info(`No tables found in database '${args.name}'`);
+				}
+				return {
+					name: args.name,
+					url: db.url ?? undefined,
+				};
+			}
+
+			// --sql option: output CREATE TABLE statements
+			if (opts.sql) {
+				if (options.json) {
+					return { tables: tables.map(generateCreateTableSQL) };
+				}
+
+				for (const table of tables) {
+					console.log(generateCreateTableSQL(table));
+					console.log('');
+				}
+				return { tables: tables.map((t) => t.table_name) };
+			}
+
+			// --json option: return raw table schemas
+			if (options.json) {
+				return { tables };
+			}
+
+			// Default: display as tables using tui.table
+			for (const table of tables) {
+				console.log(tui.bold(`\nTable: ${table.table_name}`));
+
+				const tableData = table.columns.map((col) => ({
+					Column: col.name,
+					Type: col.data_type,
+					Nullable: col.is_nullable ? 'YES' : 'NO',
+					Default: col.default_value || '',
+					'Primary Key': col.is_primary_key ? 'YES' : '',
+				}));
+
+				tui.table(tableData);
+			}
+
+			return { tables: tables.map((t) => t.table_name) };
+		}
+
 		// Mask credentials in terminal output by default, unless --show-credentials is passed
 		const shouldShowCredentials = opts.showCredentials === true;
 		const shouldMask = !options.json && !shouldShowCredentials;

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

@@ -3,6 +3,7 @@ import { createSubcommand } from './create';
 import { listSubcommand } from './list';
 import { deleteSubcommand } from './delete';
 import { getSubcommand } from './get';
+import { logsSubcommand } from './logs';
 import { sqlSubcommand } from './sql';
 import { getCommand } from '../../../command-prefix';
 
@@ -15,5 +16,12 @@ export const dbCommand = createCommand({
 		{ command: getCommand('cloud db list'), description: 'List all databases' },
 		{ command: getCommand('cloud db sql "SELECT * FROM users"'), description: 'Run SQL query' },
 	],
-	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand, sqlSubcommand],
+	subcommands: [
+		createSubcommand,
+		listSubcommand,
+		getSubcommand,
+		deleteSubcommand,
+		logsSubcommand,
+		sqlSubcommand,
+	],
 });

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

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

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

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { dbLogs, DbQueryLogSchema } from '@agentuity/server';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+import { ErrorCode } from '../../../errors';
+
+const DbLogsResponseSchema = z.array(DbQueryLogSchema);
+
+export const logsSubcommand = createSubcommand({
+	name: 'logs',
+	aliases: ['log'],
+	description: 'Get query logs for a specific database',
+	tags: ['read-only', 'slow', 'requires-auth'],
+	examples: [
+		{
+			command: getCommand('cloud db logs my-database'),
+			description: 'View query logs for database',
+		},
+		{
+			command: getCommand('cloud db logs my-database --limit=50'),
+			description: 'Limit to 50 log entries',
+		},
+		{
+			command: getCommand('cloud db logs my-database --has-error'),
+			description: 'Show only queries with errors',
+		},
+		{
+			command: getCommand('cloud db logs my-database --username=user123'),
+			description: 'Filter by username',
+		},
+		{
+			command: getCommand('cloud db logs my-database --command=SELECT'),
+			description: 'Filter by SQL command type',
+		},
+		{
+			command: getCommand('cloud db logs my-database --session-id=sess_abc123'),
+			description: 'Filter by session ID',
+		},
+		{
+			command: getCommand('cloud db logs my-database --show-session-id'),
+			description: 'Show session ID column',
+		},
+		{
+			command: getCommand('cloud db logs my-database --show-username'),
+			description: 'Show username column',
+		},
+		{
+			command: getCommand('cloud db logs my-database --pretty'),
+			description: 'Show full formatted SQL on separate lines',
+		},
+	],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	schema: {
+		args: z.object({
+			database: z.string().describe('Database name'),
+		}),
+		options: z.object({
+			startDate: z.string().optional().describe('Start date for filtering logs'),
+			endDate: z.string().optional().describe('End date for filtering logs'),
+			username: z.string().optional().describe('Filter by username'),
+			command: z.string().optional().describe('Filter by SQL command type'),
+			hasError: z.boolean().optional().describe('Show only queries with errors'),
+			sessionId: z.string().optional().describe('Filter by session ID (trace ID)'),
+			showSessionId: z.boolean().default(false).describe('Show session ID column in output'),
+			showUsername: z.boolean().default(false).describe('Show username column in output'),
+			pretty: z.boolean().default(false).describe('Show full formatted SQL on separate line'),
+			limit: z.coerce
+				.number()
+				.int()
+				.min(1)
+				.default(100)
+				.describe('Maximum number of logs to return'),
+			timestamps: z.boolean().default(true).describe('Show timestamps in output'),
+		}),
+		response: DbLogsResponseSchema,
+	},
+	async handler(ctx) {
+		const { args, options, orgId, region, config, 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 logs = await dbLogs(catalystClient, {
+				database: args.database,
+				orgId,
+				region,
+				startDate: ctx.opts.startDate,
+				endDate: ctx.opts.endDate,
+				username: ctx.opts.username,
+				command: ctx.opts.command,
+				hasError: ctx.opts.hasError,
+				sessionId: ctx.opts.sessionId,
+				limit: ctx.opts.limit,
+			});
+
+			if (!options.json) {
+				if (logs.length === 0) {
+					tui.info('No logs found for this database.');
+				} else {
+					for (const log of logs) {
+						// Format timestamp with explicit locale for consistency
+						const timestamp = showTimestamps
+							? `${tui.muted(new Date(log.timestamp).toLocaleString('en-US', { year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' }).padEnd(22))} `
+							: '';
+
+						// Format command with cyan color (using info color) and consistent width
+						const commandText = log.command.padEnd(8);
+						const command = tui.colorInfo(commandText);
+
+						// Format duration with consistent width
+						const duration = `${log.duration.toFixed(2)}ms`.padStart(9);
+
+						// Format username if requested
+						const username = showUsername
+							? `${tui.muted(`[${log.username}]`.padEnd(14))} `
+							: '';
+
+						// Format session ID if requested (already has sess_ prefix from API)
+						const sessionId = showSessionId
+							? `${tui.muted((log.sessionId || '').padEnd(38))} `
+							: '';
+
+						if (prettySQL) {
+							// Pretty mode: show metadata on first line, full SQL on next line
+							console.log(
+								`${timestamp}${command} ${tui.muted(duration)} ${username}${sessionId}`
+							);
+							// Show full formatted SQL indented on next line with clear color
+							console.log(`  ${log.sql}`);
+						} else {
+							// Normal mode: truncate SQL and show inline
+							const sqlClean = log.sql
+								.replace(/[\n\r\t]+/g, ' ')
+								.replace(/\s+/g, ' ')
+								.trim();
+							const sql =
+								sqlClean.length > 100 ? `${sqlClean.substring(0, 97)}...` : sqlClean;
+							console.log(
+								`${timestamp}${command} ${tui.muted(duration)} ${username}${sessionId}${sql}`
+							);
+						}
+
+						// Show error on separate line underneath if present
+						if (log.error) {
+							console.log(tui.colorError(`  ↳ ERROR: ${log.error}`));
+						}
+					}
+				}
+			}
+
+			return logs;
+		} catch (ex) {
+			tui.fatal(`Failed to get database logs: ${ex}`, ErrorCode.API_ERROR);
+		}
+	},
+});