@agentuity/cli 0.0.72 → 0.0.74

package/src/cmd/build/plugin.ts

@@ -16,6 +16,7 @@ import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
 import { toCamelCase, toPascalCase } from '../../utils/string';
 import { generateRouteRegistry, type RouteInfo } from './route-registry';
+import { discoverRouteFiles } from './route-discovery';
 
 /**
  * Setup lifecycle types by analyzing app.ts for setup() function
@@ -371,10 +372,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 +436,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)`
 							);
@@ -437,46 +462,116 @@ import { readFileSync, existsSync } from 'node:fs';
 				const apiRoutesMetadata: BuildMetadata['routes'] = [];
 				const routeInfoList: RouteInfo[] = [];
 				const apiDir = join(srcDir, 'api');
+				// Track subdirectory routes for auto-mounting
+				const subRouteInserts: string[] = [];
 				if (existsSync(apiDir)) {
-					const { readdirSync, statSync } = await import('node:fs');
-					const apiFiles = readdirSync(apiDir)
-						.filter((name) => name.endsWith('.ts') && !name.endsWith('.generated.ts'))
-						.map((name) => join(apiDir, name));
+					// Use recursive route discovery to find all route files in subdirectories
+					const discoveredRoutes = discoverRouteFiles(apiDir);
+
+					// Collect all API files: index.ts and discovered subdirectory routes
+					const apiFiles: string[] = [];
+
+					// Check for root index.ts
+					const indexFile = join(apiDir, 'index.ts');
+					if (existsSync(indexFile)) {
+						apiFiles.push(indexFile);
+					}
+
+					// Add all discovered route files
+					for (const route of discoveredRoutes) {
+						apiFiles.push(route.filepath);
+
+						// Generate auto-mount code for this subdirectory route
+						subRouteInserts.push(`await (async() => {
+						const { getRouter } = await import('@agentuity/runtime');
+						const router = getRouter()!;
+						const ${route.variableName} = (await import('${route.importPath}')).default;
+						router.route('${route.mountPath}', ${route.variableName});
+						})();`);
+					}
 
 					for (const apiFile of apiFiles) {
-						if (statSync(apiFile).isFile()) {
-							try {
-								const routes = await parseRoute(rootDir, apiFile, projectId, deploymentId);
-								apiRoutesMetadata.push(...routes);
-
-								// Collect route info for RouteRegistry generation
-								for (const route of routes) {
-									routeInfoList.push({
-										method: route.method.toUpperCase(),
-										path: route.path,
-										filename: route.filename,
-										hasValidator: route.config?.hasValidator === true,
-										routeType: route.type || 'api',
-										agentVariable: route.config?.agentVariable as string | undefined,
-										agentImportPath: route.config?.agentImportPath as string | undefined,
-										inputSchemaVariable: route.config?.inputSchemaVariable as
-											| string
-											| undefined,
-										outputSchemaVariable: route.config?.outputSchemaVariable as
-											| string
-											| undefined,
-									});
-								}
-							} catch (error) {
-								// Skip files that don't have createRouter (they might be utilities)
+						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 (
-									error instanceof Error &&
-									error.message.includes('could not find an proper createRouter')
+									route.config?.agentImportPath &&
+									(!hasCustomInput || !hasCustomOutput)
 								) {
-									logger.trace(`Skipping ${apiFile}: no createRouter found`);
-								} else {
-									throw error;
+									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
+							for (const route of routes) {
+								routeInfoList.push({
+									method: route.method.toUpperCase(),
+									path: route.path,
+									filename: route.filename,
+									hasValidator: route.config?.hasValidator === true,
+									routeType: route.type || 'api',
+									agentVariable: route.config?.agentVariable as string | undefined,
+									agentImportPath: route.config?.agentImportPath as string | undefined,
+									inputSchemaVariable: route.config?.inputSchemaVariable as
+										| string
+										| undefined,
+									outputSchemaVariable: route.config?.outputSchemaVariable as
+										| string
+										| undefined,
+								});
+							}
+						} catch (error) {
+							// Skip files that don't have createRouter (they might be utilities)
+							if (
+								error instanceof Error &&
+								error.message.includes('could not find an proper createRouter')
+							) {
+								logger.trace(`Skipping ${apiFile}: no createRouter found`);
+							} else {
+								throw error;
 							}
 						}
 					}
@@ -499,6 +594,11 @@ import { readFileSync, existsSync } from 'node:fs';
 })();`);
 				}
 
+				// Auto-mount subdirectory routes (src/api/foo/route.ts -> /api/foo)
+				for (const subRouteInsert of subRouteInserts) {
+					inserts.push(subRouteInsert);
+				}
+
 				// Only create the workbench routes if workbench is actually configured
 				if (workbenchConfig) {
 					inserts.push(`await (async() => {
@@ -594,6 +694,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/build/route-discovery.ts

@@ -0,0 +1,197 @@
+import { existsSync, readdirSync, lstatSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { toCamelCase } from '../../utils/string';
+
+/**
+ * Information about a discovered route file
+ */
+export interface DiscoveredRouteFile {
+	/** Full path to the route file */
+	filepath: string;
+	/** Relative path from apiDir (e.g., 'auth/route.ts', 'v1/users/route.ts') */
+	relativePath: string;
+	/** Mount path for the route (e.g., '/api/auth', '/api/v1/users') */
+	mountPath: string;
+	/** Safe variable name for importing (e.g., 'authRoute', 'v1UsersRoute') */
+	variableName: string;
+	/** Import path relative to build output (e.g., './src/api/auth/route') */
+	importPath: string;
+}
+
+/**
+ * Recursively discover all TypeScript route files in an API directory
+ * Supports nested structures like:
+ * - src/api/index.ts (root API router)
+ * - src/api/auth/route.ts -> mounted at /api/auth
+ * - src/api/v1/users/route.ts -> mounted at /api/v1/users
+ * - src/api/admin/users/login.ts -> mounted at /api/admin/users (any .ts file works)
+ *
+ * @param apiDir - Absolute path to the src/api directory
+ * @param currentDir - Current directory being scanned (used for recursion)
+ * @param results - Accumulated results (used for recursion)
+ * @returns Array of discovered route files with mount information
+ */
+export function discoverRouteFiles(
+	apiDir: string,
+	currentDir: string = apiDir,
+	results: DiscoveredRouteFile[] = []
+): DiscoveredRouteFile[] {
+	if (!existsSync(currentDir)) {
+		return results;
+	}
+
+	const entries = readdirSync(currentDir);
+
+	for (const entry of entries) {
+		const entryPath = join(currentDir, entry);
+		const stat = lstatSync(entryPath);
+
+		// Skip symlinks to prevent infinite recursion
+		if (stat.isSymbolicLink()) {
+			continue;
+		}
+
+		if (stat.isFile() && entry.endsWith('.ts') && !entry.endsWith('.generated.ts')) {
+			// Found a TypeScript file
+			const relativePath = relative(apiDir, entryPath);
+			const isRootIndex = relativePath === 'index.ts';
+
+			// Skip root index.ts - it's handled separately
+			if (isRootIndex) {
+				continue;
+			}
+
+			// For subdirectory files, determine mount path
+			// src/api/auth/route.ts -> /api/auth
+			// src/api/v1/users/route.ts -> /api/v1/users
+			// src/api/admin/login.ts -> /api/admin
+			const pathParts = relativePath.split('/');
+			pathParts.pop(); // Remove filename
+
+			// Skip files directly in src/api/ to avoid mount path conflicts with root index.ts
+			if (pathParts.length === 0) {
+				continue;
+			}
+
+			const mountPath = `/api/${pathParts.join('/')}`;
+
+			// Generate safe variable name
+			// auth/route.ts -> authRoute
+			// v1/users/route.ts -> v1UsersRoute
+			// admin/login.ts -> adminLoginRoute
+			const variableParts = pathParts.map((p, idx) => {
+				const camel = toCamelCase(p);
+				// Capitalize first letter of all parts except the first
+				return idx === 0 ? camel : camel.charAt(0).toUpperCase() + camel.slice(1);
+			});
+			const baseName = entry.replace('.ts', '');
+			if (baseName !== 'route' && baseName !== 'index') {
+				const camelBase = toCamelCase(baseName);
+				// Always capitalize the base name since it's not the first part
+				variableParts.push(camelBase.charAt(0).toUpperCase() + camelBase.slice(1));
+			}
+			const variableName = variableParts.join('') + 'Route';
+
+			// Generate import path relative to build output
+			// src/api/auth/route.ts -> ./src/api/auth/route
+			const importPath = './src/api/' + relativePath.replace('.ts', '');
+
+			results.push({
+				filepath: entryPath,
+				relativePath,
+				mountPath,
+				variableName,
+				importPath,
+			});
+		} else if (stat.isDirectory()) {
+			// Recursively scan subdirectories
+			discoverRouteFiles(apiDir, entryPath, results);
+		}
+	}
+
+	return results;
+}
+
+/**
+ * Detect potential route path conflicts
+ *
+ * @param routes - Array of route metadata with method and path
+ * @returns Array of conflict descriptions
+ */
+export interface RouteConflict {
+	type: 'duplicate' | 'ambiguous-param' | 'wildcard-overlap';
+	routes: Array<{ method: string; path: string; filename: string }>;
+	message: string;
+}
+
+export function detectRouteConflicts(
+	routes: Array<{ method: string; path: string; filename: string }>
+): RouteConflict[] {
+	const conflicts: RouteConflict[] = [];
+
+	// Group routes by method+path
+	const methodPathMap = new Map<string, Array<{ path: string; filename: string }>>();
+
+	for (const route of routes) {
+		const key = `${route.method.toUpperCase()} ${route.path}`;
+		if (!methodPathMap.has(key)) {
+			methodPathMap.set(key, []);
+		}
+		methodPathMap.get(key)!.push({ path: route.path, filename: route.filename });
+	}
+
+	// Check for exact duplicates
+	for (const [methodPath, routeList] of methodPathMap.entries()) {
+		if (routeList.length > 1) {
+			const [method] = methodPath.split(' ', 2);
+			conflicts.push({
+				type: 'duplicate',
+				routes: routeList.map((r) => ({ method, path: r.path, filename: r.filename })),
+				message: `Duplicate route: ${methodPath} defined in ${routeList.length} files`,
+			});
+		}
+	}
+
+	// Check for ambiguous parameter routes (same method, different param names)
+	// e.g., GET /users/:id and GET /users/:userId
+	const methodGroups = new Map<string, Array<{ path: string; filename: string }>>();
+	for (const route of routes) {
+		const method = route.method.toUpperCase();
+		if (!methodGroups.has(method)) {
+			methodGroups.set(method, []);
+		}
+		methodGroups.get(method)!.push({ path: route.path, filename: route.filename });
+	}
+
+	for (const [method, routeList] of methodGroups.entries()) {
+		// Normalize params to check for conflicts
+		const normalized = routeList.map((r) => ({
+			...r,
+			normalizedPath: r.path.replace(/:[^/]+/g, ':param'),
+		}));
+
+		const pathMap = new Map<string, Array<{ path: string; filename: string }>>();
+		for (const route of normalized) {
+			if (!pathMap.has(route.normalizedPath)) {
+				pathMap.set(route.normalizedPath, []);
+			}
+			pathMap.get(route.normalizedPath)!.push({ path: route.path, filename: route.filename });
+		}
+
+		for (const [normalizedPath, paths] of pathMap.entries()) {
+			if (paths.length > 1 && normalizedPath.includes(':param')) {
+				// Check if the actual param names differ
+				const uniquePaths = new Set(paths.map((p) => p.path));
+				if (uniquePaths.size > 1) {
+					conflicts.push({
+						type: 'ambiguous-param',
+						routes: paths.map(({ path, filename }) => ({ method, path, filename })),
+						message: `Ambiguous param routes: ${method} ${Array.from(uniquePaths).join(', ')}`,
+					});
+				}
+			}
+		}
+	}
+
+	return conflicts;
+}

package/src/cmd/build/route-registry.ts

@@ -37,13 +37,13 @@ export interface RouteInfo {
  * @param routes - Array of route information
  */
 export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void {
-	// Filter routes by type and validator presence
-	const apiRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'api');
-	const websocketRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'websocket');
-	const sseRoutes = routes.filter((r) => r.hasValidator && r.routeType === 'sse');
+	// Filter routes by type (include ALL routes, not just those with validators)
+	const apiRoutes = routes.filter((r) => r.routeType === 'api');
+	const websocketRoutes = routes.filter((r) => r.routeType === 'websocket');
+	const sseRoutes = routes.filter((r) => r.routeType === 'sse');
 
 	if (apiRoutes.length === 0 && websocketRoutes.length === 0 && sseRoutes.length === 0) {
-		// No typed routes, skip generation
+		// No routes, skip generation
 		return;
 	}
 
@@ -52,11 +52,15 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 	const agentImports = new Map<string, string>(); // Maps agent variable to unique import name
 	const schemaImports = new Set<string>(); // Track which schema variables we've seen
 
-	// Combine all typed routes for import collection
-	const allTypedRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
+	// Combine all routes for import collection
+	const allRoutes = [...apiRoutes, ...websocketRoutes, ...sseRoutes];
 
-	// First pass: collect all unique agents and schema variables
-	allTypedRoutes.forEach((route) => {
+	// First pass: collect all unique agents and schema variables (only for routes with validators)
+	allRoutes.forEach((route) => {
+		// Skip routes without validators - they won't need imports
+		if (!route.hasValidator) {
+			return;
+		}
 		// If this route uses an agent, import it directly
 		if (route.agentVariable && route.agentImportPath && !agentImports.has(route.agentVariable)) {
 			// Resolve the import path (could be @agent/hello, ../shared, etc.)
@@ -90,7 +94,11 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 
 	// Import schema variables from route files
 	const routeFileImports = new Map<string, Set<string>>(); // Maps route file to schema variables
-	allTypedRoutes.forEach((route) => {
+	allRoutes.forEach((route) => {
+		// Only import schemas for routes with validators
+		if (!route.hasValidator) {
+			return;
+		}
 		if (route.inputSchemaVariable || route.outputSchemaVariable) {
 			const filename = route.filename.replace(/\\/g, '/');
 			const importPath = `../${filename.replace(/\.ts$/, '')}`;
@@ -120,6 +128,14 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 	const generateRouteEntry = (route: RouteInfo): string => {
 		const routeKey = route.path; // Use path only for websocket/sse, or METHOD path for API
 
+		// If route doesn't have a validator, use never for schemas
+		if (!route.hasValidator) {
+			return `  '${routeKey}': {
+    inputSchema: never;
+    outputSchema: never;
+  };`;
+		}
+
 		// If we have an agent variable, we can infer types from it
 		if (route.agentVariable) {
 			const importName = agentImports.get(route.agentVariable)!;

package/src/cmd/cloud/deploy.ts

@@ -6,7 +6,14 @@ import { tmpdir } from 'node:os';
 import { createSubcommand } from '../../types';
 import * as tui from '../../tui';
 import { saveProjectDir, getDefaultConfigDir } from '../../config';
-import { runSteps, stepSuccess, stepSkipped, stepError, Step, ProgressCallback } from '../../steps';
+import {
+	runSteps,
+	stepSuccess,
+	stepSkipped,
+	stepError,
+	type Step,
+	type StepContext,
+} from '../../steps';
 import { bundle } from '../build/bundler';
 import { loadBuildMetadata, getStreamURL } from '../../config';
 import {
@@ -179,8 +186,9 @@ export const deploySubcommand = createSubcommand({
 							if (!deployment) {
 								return stepError('deployment was null');
 							}
+							let capturedOutput: string[] = [];
 							try {
-								await bundle({
+								const bundleResult = await bundle({
 									rootDir: resolve(projectDir),
 									dev: false,
 									deploymentId: deployment.id,
@@ -195,23 +203,28 @@ export const deploySubcommand = createSubcommand({
 									region: project.region,
 									logger: ctx.logger,
 								});
+								capturedOutput = bundleResult.output;
 								build = await loadBuildMetadata(join(projectDir, '.agentuity'));
 								instructions = await projectDeploymentUpdate(
 									apiClient,
 									deployment.id,
 									build
 								);
-								return stepSuccess();
+								return stepSuccess(capturedOutput.length > 0 ? capturedOutput : undefined);
 							} catch (ex) {
 								const _ex = ex as Error;
-								return stepError(_ex.message ?? 'Error building your project');
+								return stepError(
+									_ex.message ?? 'Error building your project',
+									_ex,
+									capturedOutput.length > 0 ? capturedOutput : undefined
+								);
 							}
 						},
 					},
 					{
-						type: 'progress',
 						label: 'Encrypt and Upload Deployment',
-						run: async (progress: ProgressCallback) => {
+						run: async (stepCtx: StepContext) => {
+							const progress = stepCtx.progress;
 							if (!deployment) {
 								return stepError('deployment was null');
 							}

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

@@ -15,6 +15,10 @@ const DeploymentShowResponseSchema = z.object({
 	tags: z.array(z.string()).describe('Deployment tags'),
 	customDomains: z.array(z.string()).optional().describe('Custom domains'),
 	cloudRegion: z.string().optional().describe('Cloud region'),
+	resourceDb: z.string().nullable().optional().describe('the database name'),
+	resourceStorage: z.string().nullable().optional().describe('the storage name'),
+	deploymentLogsURL: z.string().nullable().optional().describe('the url to the deployment logs'),
+	buildLogsURL: z.string().nullable().optional().describe('the url to the build logs'),
 	metadata: z
 		.object({
 			git: z
@@ -87,27 +91,51 @@ export const showSubcommand = createSubcommand({
 
 			// Skip TUI output in JSON mode
 			if (!options.json) {
-				console.log(tui.bold('ID:       ') + deployment.id);
-				console.log(tui.bold('Project:  ') + projectId);
-				console.log(tui.bold('State:    ') + (deployment.state || 'unknown'));
-				console.log(tui.bold('Active:   ') + (deployment.active ? 'Yes' : 'No'));
-				console.log(tui.bold('Created:  ') + new Date(deployment.createdAt).toLocaleString());
+				const maxWidth = 18;
+				console.log(tui.bold('ID:'.padEnd(maxWidth)) + deployment.id);
+				console.log(tui.bold('Project:'.padEnd(maxWidth)) + projectId);
+				console.log(tui.bold('State:'.padEnd(maxWidth)) + (deployment.state || 'unknown'));
+				console.log(tui.bold('Active:'.padEnd(maxWidth)) + (deployment.active ? 'Yes' : 'No'));
+				console.log(
+					tui.bold('Created:'.padEnd(maxWidth)) +
+						new Date(deployment.createdAt).toLocaleString()
+				);
 				if (deployment.updatedAt) {
 					console.log(
-						tui.bold('Updated:  ') + new Date(deployment.updatedAt).toLocaleString()
+						tui.bold('Updated:'.padEnd(maxWidth)) +
+							new Date(deployment.updatedAt).toLocaleString()
 					);
 				}
 				if (deployment.message) {
-					console.log(tui.bold('Message:  ') + deployment.message);
+					console.log(tui.bold('Message:'.padEnd(maxWidth)) + deployment.message);
 				}
 				if (deployment.tags.length > 0) {
-					console.log(tui.bold('Tags:     ') + deployment.tags.join(', '));
+					console.log(tui.bold('Tags:'.padEnd(maxWidth)) + deployment.tags.join(', '));
 				}
 				if (deployment.customDomains && deployment.customDomains.length > 0) {
-					console.log(tui.bold('Domains:  ') + deployment.customDomains.join(', '));
+					console.log(
+						tui.bold('Domains:'.padEnd(maxWidth)) + deployment.customDomains.join(', ')
+					);
 				}
 				if (deployment.cloudRegion) {
-					console.log(tui.bold('Region:   ') + deployment.cloudRegion);
+					console.log(tui.bold('Region:'.padEnd(maxWidth)) + deployment.cloudRegion);
+				}
+				if (deployment.resourceDb) {
+					console.log(tui.bold('Database:'.padEnd(maxWidth)) + deployment.resourceDb);
+				}
+				if (deployment.resourceStorage) {
+					console.log(tui.bold('Storage:'.padEnd(maxWidth)) + deployment.resourceStorage);
+				}
+				if (deployment.deploymentLogsURL) {
+					console.log(
+						tui.bold('Deployment Logs:'.padEnd(maxWidth)) +
+							tui.link(deployment.deploymentLogsURL)
+					);
+				}
+				if (deployment.buildLogsURL) {
+					console.log(
+						tui.bold('Build Logs:'.padEnd(maxWidth)) + tui.link(deployment.buildLogsURL)
+					);
 				}
 
 				// Git metadata
@@ -153,6 +181,10 @@ export const showSubcommand = createSubcommand({
 				customDomains: deployment.customDomains ?? undefined,
 				cloudRegion: deployment.cloudRegion ?? undefined,
 				metadata: deployment.metadata ?? undefined,
+				resourceDb: deployment.resourceDb ?? undefined,
+				resourceStorage: deployment.resourceStorage ?? undefined,
+				deploymentLogsURL: deployment.deploymentLogsURL ?? undefined,
+				buildLogsURL: deployment.buildLogsURL ?? undefined,
 			};
 		} catch (ex) {
 			tui.fatal(`Failed to show deployment: ${ex}`);

package/src/cmd/dev/agents.ts

@@ -63,17 +63,9 @@ export const agentsSubcommand = createSubcommand({
 		const queryParams = deploymentId ? `?deploymentId=${deploymentId}` : '';
 
 		const response = options.json
-			? await apiClient.request(
-					'GET',
-					`/cli/agent/${projectId}${queryParams}`,
-					AgentsResponseSchema
-				)
+			? await apiClient.get(`/cli/agent/${projectId}${queryParams}`, AgentsResponseSchema)
 			: await tui.spinner('Fetching agents', async () => {
-					return apiClient.request(
-						'GET',
-						`/cli/agent/${projectId}${queryParams}`,
-						AgentsResponseSchema
-					);
+					return apiClient.get(`/cli/agent/${projectId}${queryParams}`, AgentsResponseSchema);
 				});
 
 		if (!response.success) {