@agentuity/cli 0.0.64 → 0.0.65

package/src/cmd/build/index.ts

@@ -50,30 +50,30 @@ 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 (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);
+			}
+
+			ctx.logger.trace('setting env to %s', env);
 
 			await bundle({
 				rootDir: absoluteProjectDir,

package/src/cmd/build/plugin.ts

@@ -726,12 +726,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'),
@@ -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/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,
 	},
@@ -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/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);
+
+			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);
+		}
+	},
+});

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

@@ -1,23 +1,14 @@
 import { z } from 'zod';
-import { SQL } from 'bun';
-import { listResources, type ResourceList } from '@agentuity/server';
+import { dbQuery } 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';
-
-interface DatabaseResource {
-	name: string;
-	username?: string | null;
-	password?: string | null;
-	url?: string | null;
-}
 
 const DBSQLResponseSchema = z.object({
 	rows: z.array(z.record(z.string(), z.unknown())).describe('Query results'),
 	rowCount: z.number().describe('Number of rows returned'),
-	executionTime: z.number().optional().describe('Query execution time in ms'),
+	truncated: z.boolean().describe('Whether results were truncated'),
 });
 
 export const sqlSubcommand = createSubcommand({
@@ -55,80 +46,39 @@ export const sqlSubcommand = createSubcommand({
 
 		const catalystClient = getCatalystAPIClient(config, logger, auth);
 
-		const resources: ResourceList = await tui.spinner({
-			message: `Fetching database ${args.name}`,
+		const result = await tui.spinner({
+			message: `Executing query on ${args.name}`,
 			clearOnSuccess: true,
 			callback: async () => {
-				return listResources(catalystClient, orgId, region);
+				return dbQuery(catalystClient, {
+					database: args.name,
+					query: args.query,
+					orgId,
+					region,
+				});
 			},
 		});
 
-		const db: DatabaseResource | undefined = resources.db.find(
-			(d: DatabaseResource) => d.name === args.name
-		);
-
-		if (!db) {
-			tui.fatal(`Database '${args.name}' not found`, ErrorCode.RESOURCE_NOT_FOUND);
-		}
-
-		if (!db.url) {
-			tui.fatal(`Database '${args.name}' has no connection URL`, ErrorCode.RUNTIME_ERROR);
-		}
-
-		let database: SQL | undefined;
-		let rows: Record<string, unknown>[];
-		let executionTime: number | undefined;
-
-		try {
-			// Add sslmode=require if not already present in URL
-			let connectionUrl = db.url;
-			if (!connectionUrl.includes('sslmode=') && !connectionUrl.includes('ssl=')) {
-				const separator = connectionUrl.includes('?') ? '&' : '?';
-				connectionUrl = `${connectionUrl}${separator}sslmode=require`;
-			}
-
-			database = new SQL(connectionUrl);
-
-			const startTime = performance.now();
-			const result = await tui.spinner({
-				message: `Executing query on ${args.name}`,
-				clearOnSuccess: true,
-				callback: async () => {
-					return database!.unsafe(args.query);
-				},
-			});
-			executionTime = performance.now() - startTime;
-
-			rows = result;
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			tui.fatal(`Query execution failed: ${message}`, ErrorCode.RUNTIME_ERROR);
-		} finally {
-			if (database) {
-				await database.close();
-			}
-		}
-
 		if (!options.json) {
-			if (rows.length === 0) {
+			if (result.rowCount === 0) {
 				tui.info('No rows returned');
 			} else {
 				if (process.stdout.isTTY) {
 					tui.newline();
 					tui.success(
-						`Query returned ${rows.length} row${rows.length !== 1 ? 's' : ''} (${executionTime?.toFixed(2)}ms):`
+						`Query returned ${result.rowCount} row${result.rowCount !== 1 ? 's' : ''}${result.truncated ? ' (truncated to 1000 rows)' : ''}:`
 					);
 					tui.newline();
 				}
 
-				tui.table(rows);
+				tui.table(result.rows);
 			}
 		}
 
 		return {
-			rows,
-			rowCount: rows.length,
-			executionTime,
+			rows: result.rows,
+			rowCount: result.rowCount,
+			truncated: result.truncated,
 		};
 	},
 });

package/src/cmd/cloud/deploy.ts

@@ -27,9 +27,9 @@ import {
 } from '../../env-util';
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
-import { DeployOptionsSchema } from '../build/bundler';
 import { getCommand } from '../../command-prefix';
 import { checkCustomDomainForDNS } from './domain';
+import { DeployOptionsSchema } from '../../schemas/deploy';
 
 const DeployResponseSchema = z.object({
 	success: z.boolean().describe('Whether deployment succeeded'),
@@ -162,7 +162,8 @@ export const deploySubcommand = createSubcommand({
 								);
 								return stepSuccess();
 							} catch (ex) {
-								return stepError(ex instanceof Error ? ex.message : String(ex));
+								const _ex = ex as { message?: string };
+								return stepError(_ex.message ?? String(_ex), ex as Error);
 							}
 						},
 					},

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

@@ -103,10 +103,7 @@ export const listSubcommand = createSubcommand({
 
 			return result;
 		} catch (ex) {
-			tui.fatal(
-				`Failed to list deployments: ${ex instanceof Error ? ex.message : String(ex)}`,
-				ErrorCode.API_ERROR
-			);
+			tui.fatal(`Failed to list deployments: ${ex}`, ErrorCode.API_ERROR);
 		}
 	},
 });

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

@@ -78,10 +78,7 @@ export const logsSubcommand = createSubcommand({
 
 			return logs;
 		} catch (ex) {
-			tui.fatal(
-				`Failed to fetch deployment logs: ${ex instanceof Error ? ex.message : String(ex)}`,
-				ErrorCode.API_ERROR
-			);
+			tui.fatal(`Failed to fetch deployment logs: ${ex}`, ErrorCode.API_ERROR);
 		}
 	},
 });

package/src/cmd/cloud/deployment/remove.ts

@@ -69,7 +69,7 @@ export const removeSubcommand = createSubcommand({
 				deploymentId: args.deployment_id,
 			};
 		} catch (ex) {
-			tui.fatal(`Failed to remove deployment: ${ex instanceof Error ? ex.message : String(ex)}`);
+			tui.fatal(`Failed to remove deployment: ${ex}`);
 		}
 	},
 });

package/src/cmd/cloud/deployment/rollback.ts

@@ -86,7 +86,7 @@ export const rollbackSubcommand = createSubcommand({
 				targetDeploymentId,
 			};
 		} catch (ex) {
-			tui.fatal(`Failed to rollback: ${ex instanceof Error ? ex.message : String(ex)}`);
+			tui.fatal(`Failed to rollback: ${ex}`);
 		}
 	},
 });

package/src/cmd/cloud/deployment/show.ts

@@ -155,7 +155,7 @@ export const showSubcommand = createSubcommand({
 				metadata: deployment.metadata ?? undefined,
 			};
 		} catch (ex) {
-			tui.fatal(`Failed to show deployment: ${ex instanceof Error ? ex.message : String(ex)}`);
+			tui.fatal(`Failed to show deployment: ${ex}`);
 		}
 	},
 });