@agentuity/cli 0.0.77 → 0.0.79

package/src/cmd/build/ast.ts

@@ -1,5 +1,5 @@
 import * as acornLoose from 'acorn-loose';
-import { dirname, relative } from 'node:path';
+import { dirname, relative, join, basename } from 'node:path';
 import { parse as parseCronExpression } from '@datasert/cronjs-parser';
 import { generate } from 'astring';
 import type { BuildMetadata } from '../../types';
@@ -7,7 +7,7 @@ import { createLogger } from '@agentuity/server';
 import * as ts from 'typescript';
 import { StructuredError, type WorkbenchConfig } from '@agentuity/core';
 import type { LogLevel } from '../../types';
-import { join } from 'node:path';
+
 import { existsSync, mkdirSync } from 'node:fs';
 import JSON5 from 'json5';
 import { formatSchemaCode } from './format-schema';
@@ -48,7 +48,7 @@ interface ASTObjectExpression extends ASTNode {
 }
 
 interface ASTLiteral extends ASTNode {
-	value: string;
+	value: string | number | boolean | null;
 	raw?: string;
 }
 
@@ -75,7 +75,7 @@ function parseObjectExpressionToMap(expr: ASTObjectExpression): Map<string, stri
 		switch (prop.value.type) {
 			case 'Literal': {
 				const value = prop.value as unknown as ASTLiteral;
-				result.set(prop.key.name, value.value);
+				result.set(prop.key.name, String(value.value));
 				break;
 			}
 			default: {
@@ -152,7 +152,7 @@ function getEvalId(
 	name: string,
 	version: string
 ): string {
-	return `eval_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
+	return `evalid_${hashSHA1(projectId, deploymentId, filename, name, version)}`;
 }
 
 function generateRouteId(
@@ -172,7 +172,7 @@ function generateStableAgentId(projectId: string, name: string): string {
 }
 
 function generateStableEvalId(projectId: string, agentId: string, name: string): string {
-	return `evalid_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
+	return `eval_${hashSHA1(projectId, agentId, name)}`.substring(0, 64);
 }
 
 /**
@@ -255,7 +255,8 @@ function augmentAgentMetadataNode(
 	}
 	const name = metadata.get('name')!;
 	const descriptionNode = propvalue.properties.find((x) => x.key.name === 'description')?.value;
-	const description = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const descriptionValue = descriptionNode ? (descriptionNode as ASTLiteral).value : '';
+	const description = typeof descriptionValue === 'string' ? descriptionValue : '';
 	const agentId = generateStableAgentId(projectId, name);
 	metadata.set('version', version);
 	metadata.set('filename', rel);
@@ -327,14 +328,118 @@ function createAgentMetadataNode(
 
 const DuplicateNameError = StructuredError('DuplicateNameError')<{ filename: string }>();
 
-export function parseEvalMetadata(
+function injectEvalMetadata(
+	configObj: ASTObjectExpression,
+	evalId: string,
+	stableEvalId: string,
+	version: string,
+	filename: string,
+	agentId?: string
+): void {
+	// Create metadata object with eval IDs and version
+	const properties = [
+		createObjectPropertyNode('id', evalId),
+		createObjectPropertyNode('evalId', stableEvalId),
+		createObjectPropertyNode('version', version),
+		createObjectPropertyNode('filename', filename),
+	];
+
+	// Add agentId if available
+	if (agentId) {
+		properties.push(createObjectPropertyNode('agentId', agentId));
+	}
+
+	const metadataObj: ASTPropertyNode = {
+		type: 'Property',
+		kind: 'init',
+		key: {
+			type: 'Identifier',
+			name: 'metadata',
+		},
+		value: {
+			type: 'ObjectExpression',
+			properties,
+		} as ASTObjectExpression,
+	};
+
+	// Add metadata to the config object
+	configObj.properties.push(metadataObj);
+}
+
+function findAgentVariableAndImport(ast: ASTProgram): { varName: string; importPath: string } | undefined {
+	// First, find what variable is being used in agent.createEval() calls
+	let agentVarName: string | undefined;
+	
+	for (const node of ast.body) {
+		if (node.type === 'ExportNamedDeclaration') {
+			const exportDecl = node as {
+				declaration?: { type: string; declarations?: Array<ASTVariableDeclarator> };
+			};
+			if (exportDecl.declaration?.type === 'VariableDeclaration') {
+				const variableDeclaration = exportDecl.declaration as {
+					declarations: Array<ASTVariableDeclarator>;
+				};
+				
+				for (const vardecl of variableDeclaration.declarations) {
+					if (vardecl.type === 'VariableDeclarator' && vardecl.init?.type === 'CallExpression') {
+						const call = vardecl.init as ASTCallExpression;
+						if (call.callee.type === 'MemberExpression') {
+							const memberExpr = call.callee as ASTMemberExpression;
+							const object = memberExpr.object as ASTNodeIdentifier;
+							const property = memberExpr.property as ASTNodeIdentifier;
+							if (
+								object.type === 'Identifier' &&
+								property.type === 'Identifier' &&
+								property.name === 'createEval'
+							) {
+								agentVarName = object.name;
+								break;
+							}
+						}
+					}
+				}
+				if (agentVarName) break;
+			}
+		}
+	}
+	
+	if (!agentVarName) return undefined;
+	
+	// Now find the import for this variable
+	for (const node of ast.body) {
+		if (node.type === 'ImportDeclaration') {
+			const importDecl = node as unknown as {
+				source: ASTLiteral;
+				specifiers: Array<{
+					type: string;
+					local: ASTNodeIdentifier;
+				}>;
+			};
+			
+			// Find default import specifier that matches our variable
+			for (const spec of importDecl.specifiers) {
+				if (spec.type === 'ImportDefaultSpecifier' && spec.local.name === agentVarName) {
+					const importPath = importDecl.source.value;
+					if (typeof importPath === 'string') {
+						return { varName: agentVarName, importPath };
+					}
+				}
+			}
+		}
+	}
+	
+	return undefined;
+}
+
+export async function parseEvalMetadata(
 	rootDir: string,
 	filename: string,
 	contents: string,
 	projectId: string,
 	deploymentId: string,
-	agentId?: string
-): [
+	agentId?: string,
+	agentMetadata?: Map<string, Map<string, string>>
+): Promise<[
 	string,
 	Array<{
 		filename: string;
@@ -344,7 +449,7 @@ export function parseEvalMetadata(
 		evalId: string;
 		description?: string;
 	}>,
-] {
+]> {
 	const logLevel = (process.env.AGENTUITY_LOG_LEVEL || 'info') as
 		| 'trace'
 		| 'debug'
@@ -369,6 +474,41 @@ export function parseEvalMetadata(
 		description?: string;
 	}> = [];
 
+	// Try to find the corresponding agent to get the agentId
+	let resolvedAgentId = agentId;
+	if (!resolvedAgentId && agentMetadata) {
+		const agentInfo = findAgentVariableAndImport(ast);
+		if (agentInfo) {
+			logger.trace(`[EVAL METADATA] Found agent variable '${agentInfo.varName}' imported from '${agentInfo.importPath}'`);
+			
+			// Resolve the import path to actual file path
+			let resolvedPath = agentInfo.importPath;
+			if (resolvedPath.startsWith('./') || resolvedPath.startsWith('../')) {
+				// Convert relative path to match the format in agentMetadata
+				const baseDir = dirname(filename);
+				resolvedPath = join(baseDir, resolvedPath);
+				// Normalize and ensure .ts extension
+				if (!resolvedPath.endsWith('.ts')) {
+					resolvedPath += '.ts';
+				}
+			}
+			
+			// Find the agent metadata from the passed agentMetadata map
+			for (const [agentFile, metadata] of agentMetadata) {
+				// Check if this agent file matches the resolved import path
+				if (agentFile.includes(basename(resolvedPath)) && metadata.has('agentId')) {
+					resolvedAgentId = metadata.get('agentId');
+					logger.trace(`[EVAL METADATA] Resolved agentId from agent metadata: ${resolvedAgentId} (file: ${agentFile})`);
+					break;
+				}
+			}
+			
+			if (!resolvedAgentId) {
+				logger.warn(`[EVAL METADATA] Could not find agent metadata for import path: ${resolvedPath}`);
+			}
+		}
+	}
+
 	// Find all exported agent.createEval() calls
 	for (const body of ast.body) {
 		let variableDeclaration: { declarations: Array<ASTVariableDeclarator> } | undefined;
@@ -414,7 +554,7 @@ export function parseEvalMetadata(
 									firstArg.type === 'Literal' &&
 									typeof (firstArg as ASTLiteral).value === 'string'
 								) {
-									evalName = (firstArg as ASTLiteral).value;
+									evalName = (firstArg as ASTLiteral).value as string;
 								} else {
 									throw new MetadataError({
 										filename,
@@ -435,7 +575,9 @@ export function parseEvalMetadata(
 											prop.key.name === 'description'
 										) {
 											if (prop.value.type === 'Literal') {
-												evalDescription = (prop.value as ASTLiteral).value;
+												const literalValue = (prop.value as ASTLiteral).value;
+												evalDescription =
+													typeof literalValue === 'string' ? literalValue : undefined;
 											}
 										}
 									}
@@ -448,16 +590,18 @@ export function parseEvalMetadata(
 								);
 								const evalId = getEvalId(projectId, deploymentId, rel, finalName, version);
 
-								// Generate stable evalId
-								const effectiveAgentId = agentId || '';
+								// Generate stable evalId using resolved agentId
+								const effectiveAgentId = resolvedAgentId || '';
 								const stableEvalId = generateStableEvalId(
 									projectId,
 									effectiveAgentId,
 									finalName
 								);
 
-								// Note: We no longer inject metadata into the AST since there's no metadata object
-								// The runtime will generate IDs from the name parameter
+								// Inject eval metadata into the AST (same pattern as agents)
+								if (configObj) {
+									injectEvalMetadata(configObj, evalId, stableEvalId, version, rel, resolvedAgentId);
+								}
 
 								evals.push({
 									filename: rel,
@@ -737,13 +881,14 @@ export async function parseAgentMetadata(
 		const transpiler = new Bun.Transpiler({ loader: 'ts', target: 'bun' });
 		const evalsContents = transpiler.transformSync(evalsSource);
 		const agentId = result[1].get('agentId') || '';
-		const [, evals] = parseEvalMetadata(
+		const [, evals] = await parseEvalMetadata(
 			rootDir,
 			evalsPath,
 			evalsContents,
 			projectId,
 			deploymentId,
-			agentId
+			agentId,
+			new Map() // Empty map since we already have agentId
 		);
 		if (evals.length > 0) {
 			logger.trace(`Adding ${evals.length} eval(s) to agent metadata for ${name}`);
@@ -777,6 +922,7 @@ interface ValidatorInfo {
 	agentVariable?: string;
 	inputSchemaVariable?: string;
 	outputSchemaVariable?: string;
+	stream?: boolean;
 }
 
 function hasValidatorCall(args: unknown[]): ValidatorInfo {
@@ -826,14 +972,16 @@ function hasValidatorCall(args: unknown[]): ValidatorInfo {
 }
 
 /**
- * Extract schema variable names from validator() call arguments
- * Example: validator({ input: myInputSchema, output: myOutputSchema })
+ * Extract schema variable names and stream flag from validator() call arguments
+ * Example: validator({ input: myInputSchema, output: myOutputSchema, stream: true })
  */
 function extractValidatorSchemas(callExpr: ASTCallExpression): {
 	inputSchemaVariable?: string;
 	outputSchemaVariable?: string;
+	stream?: boolean;
 } {
-	const result: { inputSchemaVariable?: string; outputSchemaVariable?: string } = {};
+	const result: { inputSchemaVariable?: string; outputSchemaVariable?: string; stream?: boolean } =
+		{};
 
 	// Check if validator has arguments
 	if (!callExpr.arguments || callExpr.arguments.length === 0) {
@@ -848,7 +996,17 @@ function extractValidatorSchemas(callExpr: ASTCallExpression): {
 
 	const objExpr = firstArg as ASTObjectExpression;
 	for (const prop of objExpr.properties) {
-		const keyName = prop.key.name;
+		// Extract key name defensively - could be Identifier or Literal
+		let keyName: string | undefined;
+		const propKey = prop.key as { type: string; name?: string; value?: unknown };
+		if (propKey.type === 'Identifier') {
+			keyName = propKey.name;
+		} else if (propKey.type === 'Literal') {
+			keyName = String(propKey.value);
+		}
+
+		if (!keyName) continue;
+
 		if ((keyName === 'input' || keyName === 'output') && prop.value.type === 'Identifier') {
 			const valueName = (prop.value as ASTNodeIdentifier).name;
 			if (keyName === 'input') {
@@ -857,6 +1015,46 @@ function extractValidatorSchemas(callExpr: ASTCallExpression): {
 				result.outputSchemaVariable = valueName;
 			}
 		}
+		// Extract stream flag - can be Literal, Identifier, or UnaryExpression (!0 or !1)
+		if (keyName === 'stream') {
+			if (prop.value.type === 'Literal') {
+				const literal = prop.value as ASTLiteral;
+				if (typeof literal.value === 'boolean') {
+					result.stream = literal.value;
+				}
+			} else if (prop.value.type === 'Identifier') {
+				const identifier = prop.value as ASTNodeIdentifier;
+				// Handle stream: true or stream: false as identifiers
+				if (identifier.name === 'true') {
+					result.stream = true;
+				} else if (identifier.name === 'false') {
+					result.stream = false;
+				}
+			} else if (prop.value.type === 'UnaryExpression') {
+				// Handle !0 (true) or !1 (false) - acorn-loose transpiles booleans this way
+				const unary = prop.value as { type: string; operator?: string; argument?: ASTNode };
+				if (unary.argument?.type === 'Literal') {
+					const literal = unary.argument as ASTLiteral;
+					// Numeric literal: !0 = true, !1 = false
+					if (typeof literal.value === 'number') {
+						if (unary.operator === '!') {
+							result.stream = literal.value === 0;
+						}
+					} else if (typeof literal.value === 'boolean') {
+						result.stream = unary.operator === '!' ? !literal.value : literal.value;
+					}
+				}
+				// Handle true/false as identifiers
+				if (unary.argument?.type === 'Identifier') {
+					const identifier = unary.argument as ASTNodeIdentifier;
+					if (identifier.name === 'true') {
+						result.stream = unary.operator === '!' ? false : true;
+					} else if (identifier.name === 'false') {
+						result.stream = unary.operator === '!' ? true : false;
+					}
+				}
+			}
+		}
 	}
 
 	return result;
@@ -883,7 +1081,7 @@ function extractZValidatorSchema(callExpr: ASTCallExpression): {
 	if (targetArg.type === 'Literal') {
 		const targetValue = (targetArg as ASTLiteral).value;
 		// Only extract schemas for JSON body validation
-		if (targetValue !== 'json') {
+		if (typeof targetValue === 'string' && targetValue !== 'json') {
 			return result;
 		}
 	} else {
@@ -1051,7 +1249,7 @@ export async function parseRoute(
 							case 'patch':
 							case 'delete': {
 								if (action && (action as ASTLiteral).type === 'Literal') {
-									suffix = (action as ASTLiteral).value;
+									suffix = String((action as ASTLiteral).value);
 								} else {
 									throw new InvalidRouterConfigError({
 										filename,
@@ -1068,7 +1266,7 @@ export async function parseRoute(
 								method = 'post';
 								const theaction = action as ASTLiteral;
 								if (theaction.type === 'Literal') {
-									suffix = theaction.value;
+									suffix = String(theaction.value);
 									break;
 								}
 								break;
@@ -1088,7 +1286,7 @@ export async function parseRoute(
 									const number = theaction.properties.find((p) => p.key.name === 'number');
 									if (number && number.value.type === 'Literal') {
 										const phoneNumber = number.value as ASTLiteral;
-										suffix = hash(phoneNumber.value);
+										suffix = hash(String(phoneNumber.value));
 										break;
 									}
 								}
@@ -1099,7 +1297,7 @@ export async function parseRoute(
 								method = 'post';
 								const theaction = action as ASTLiteral;
 								if (theaction.type === 'Literal') {
-									const email = theaction.value;
+									const email = String(theaction.value);
 									suffix = hash(email);
 									break;
 								}
@@ -1110,7 +1308,7 @@ export async function parseRoute(
 								method = 'post';
 								const theaction = action as ASTLiteral;
 								if (theaction.type === 'Literal') {
-									const expression = theaction.value;
+									const expression = String(theaction.value);
 									try {
 										parseCronExpression(expression, { hasSeconds: false });
 									} catch (ex) {
@@ -1169,6 +1367,9 @@ export async function parseRoute(
 							if (validatorInfo.outputSchemaVariable) {
 								routeConfig.outputSchemaVariable = validatorInfo.outputSchemaVariable;
 							}
+							if (validatorInfo.stream !== undefined) {
+								routeConfig.stream = validatorInfo.stream;
+							}
 						}
 
 						routes.push({

package/src/cmd/build/bundler.ts

@@ -305,10 +305,12 @@ export async function bundle({
 			format: 'esm',
 			banner: `// Generated file. DO NOT EDIT`,
 			// Disable minify for server bundle (keep code readable for debugging)
-			// Enable splitting to reduce bundle size by extracting common code
-			minify: false,
+			minify: !dev,
 			drop: isProd ? ['debugger'] : undefined,
-			splitting: true,
+			// Disable splitting - causes module initialization issues with externalized packages
+			// The chunk helper functions (__commonJS, __esm, etc.) don't properly handle
+			// CommonJS packages in node_modules that require() other modules
+			splitting: false,
 			conditions: [isProd ? 'production' : 'development', 'bun'],
 			external,
 			naming: {
@@ -322,9 +324,6 @@ export async function bundle({
 		if (!buildResult.success) {
 			handleBuildFailure(buildResult);
 		}
-		// Fix duplicate exports caused by Bun splitting bug
-		// See: https://github.com/oven-sh/bun/issues/5344
-		await fixDuplicateExportsInDirectory(outDir, false);
 	})();
 
 	const buildmetadata = getBuildMetadata();
@@ -486,19 +485,19 @@ export async function bundle({
 				await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
 				// Bundle workbench using generated files
-				// NOTE: Don't set 'root' to tempWorkbenchDir because it breaks module resolution
-				// Bun needs to resolve @agentuity/* packages from the project's node_modules
+				// Use same strategy as web bundle - fully bundle all dependencies to avoid cross-bundle chunk conflicts
 				const workbenchBuildConfig: Bun.BuildConfig = {
 					entrypoints: [workbenchIndexFile],
 					outdir: join(outDir, 'workbench'),
 					sourcemap: dev ? 'inline' : 'linked',
-					plugins: [AgentuityBundler], // i dont think we need this plugin here
 					target: 'browser',
 					format: 'esm',
 					banner: `// Generated file. DO NOT EDIT`,
-					minify: !dev, // Disable minification in dev to avoid module resolution issues
-					splitting: !dev, // Disable code splitting in dev to avoid relative import resolution issues
+					minify: true,
+					drop: isProd ? ['debugger'] : undefined,
+					splitting: true,
 					packages: 'bundle',
+					conditions: ['browser', 'import', 'default'],
 					naming: {
 						entry: '[dir]/[name].[ext]',
 						chunk: 'workbench/chunk/[name]-[hash].[ext]',

package/src/cmd/build/plugin.ts

@@ -236,38 +236,55 @@ const AgentuityBundler: BunPlugin = {
 			let newsource = await Bun.file(args.path).text();
 			if (args.path.startsWith(srcDir)) {
 				const contents = transpiler.transformSync(newsource);
-				const result = await parseAgentMetadata(
-					rootDir,
-					args.path,
-					contents,
-					projectId,
-					deploymentId
-				);
 
-				// Skip files that don't have a createAgent export
-				if (result === undefined) {
-					return {
-						contents: newsource,
-						loader: 'ts',
-					};
-				}
+				// Check if this is an eval file (eval.ts)
+				if (args.path.endsWith('/eval.ts')) {
+					// parseEvalMetadata will find the agent from the import statement
+					const [ns] = await parseEvalMetadata(
+						rootDir,
+						args.path,
+						contents,
+						projectId,
+						deploymentId,
+						undefined, // No agentId - will be resolved from import
+						agentMetadata
+					);
+					newsource = ns;
+				} else {
+					// Handle regular agent files
+					const result = await parseAgentMetadata(
+						rootDir,
+						args.path,
+						contents,
+						projectId,
+						deploymentId
+					);
+
+					// Skip files that don't have a createAgent export
+					if (result === undefined) {
+						return {
+							contents: newsource,
+							loader: 'ts',
+						};
+					}
 
-				const [ns, md] = result;
-				newsource = ns;
-
-				// Only process files that actually export an agent
-				if (md.has('name')) {
-					const newAgentName = md.get('name');
-					for (const [, kv] of agentMetadata) {
-						const found = kv.get('name');
-						if (newAgentName === found) {
-							throw new AgentNameDuplicateError({
-								message: `The agent in ${kv.get('filename')} and the agent in ${md.get('filename')} have the same name (${found}). Agent Names must be unique within a project.`,
-							});
+					const [ns, md] = result;
+					newsource = ns;
+
+					// Only process files that actually export an agent
+					if (md.has('name')) {
+						const newAgentName = md.get('name');
+						for (const [, kv] of agentMetadata) {
+							const found = kv.get('name');
+							if (newAgentName === found) {
+								throw new AgentNameDuplicateError({
+									message: `The agent in ${kv.get('filename')} and the agent in ${md.get('filename')} have the same name (${found}). Agent Names must be unique within a project.`,
+								});
+							}
 						}
-					}
 
-					agentMetadata.set(md.get('name')!, md);
+						agentMetadata.set(md.get('name')!, md);
+					}
 				}
 			}
 			return {
@@ -276,19 +293,6 @@ const AgentuityBundler: BunPlugin = {
 			};
 		});
 
-		build.onLoad({ filter: /\/eval\.ts$/, namespace: 'file' }, async (args) => {
-			let newsource = await Bun.file(args.path).text();
-			if (args.path.startsWith(srcDir)) {
-				const contents = transpiler.transformSync(newsource);
-				const [ns] = parseEvalMetadata(rootDir, args.path, contents, projectId, deploymentId);
-				newsource = ns;
-			}
-			return {
-				contents: newsource,
-				loader: 'ts',
-			};
-		});
-
 		const patches = generatePatches();
 		for (const [, patch] of patches) {
 			let modulePath = join('node_modules', patch.module, '.*');

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

@@ -25,6 +25,8 @@ export interface RouteInfo {
 	inputSchemaVariable?: string;
 	/** Output schema variable name if using validator({ output }) */
 	outputSchemaVariable?: string;
+	/** Whether this route is a streaming route (from validator({ stream: true })) */
+	stream?: boolean;
 }
 
 /**
@@ -38,7 +40,8 @@ export interface RouteInfo {
  */
 export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void {
 	// Filter routes by type (include ALL routes, not just those with validators)
-	const apiRoutes = routes.filter((r) => r.routeType === 'api');
+	// Note: 'stream' routes are HTTP routes that return ReadableStream, so include them with API routes
+	const apiRoutes = routes.filter((r) => r.routeType === 'api' || r.routeType === 'stream');
 	const websocketRoutes = routes.filter((r) => r.routeType === 'websocket');
 	const sseRoutes = routes.filter((r) => r.routeType === 'sse');
 
@@ -142,6 +145,7 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 			return `  '${routeKey}': {
     inputSchema: typeof ${importName} extends { inputSchema?: infer I } ? I : never;
     outputSchema: typeof ${importName} extends { outputSchema?: infer O } ? O : never;
+    stream: typeof ${importName} extends { stream?: infer S } ? S : false;
   };`;
 		}
 
@@ -153,9 +157,11 @@ export function generateRouteRegistry(srcDir: string, routes: RouteInfo[]): void
 			const outputType = route.outputSchemaVariable
 				? `typeof ${route.outputSchemaVariable}`
 				: 'never';
+			const streamValue = route.stream === true ? 'true' : 'false';
 			return `  '${routeKey}': {
     inputSchema: ${inputType};
     outputSchema: ${outputType};
+    stream: ${streamValue};
   };`;
 		}
 

package/src/cmd/cloud/deploy.ts

@@ -27,6 +27,7 @@ import {
 	type DeploymentInstructions,
 	type DeploymentComplete,
 	type DeploymentStatusResult,
+	getAppBaseURL,
 } from '@agentuity/server';
 import {
 	findEnvFile,
@@ -51,6 +52,7 @@ const DeployResponseSchema = z.object({
 			deployment: z.string().describe('Deployment-specific URL'),
 			latest: z.string().describe('Latest/active deployment URL'),
 			custom: z.array(z.string()).optional().describe('Custom domain URLs'),
+			dashboard: z.string().describe('The dashboard URL for the deployment'),
 		})
 		.optional()
 		.describe('Deployment URLs'),
@@ -551,9 +553,12 @@ export const deploySubcommand = createSubcommand({
 				tui.success('Your project was deployed!');
 			}
 
+			const appUrl = getAppBaseURL(config?.name, config?.overrides);
+
+			const dashboard = `${appUrl}/r/${deployment.id}`;
+
 			// Show deployment URLs
 			if (complete?.publicUrls) {
-				tui.arrow(tui.bold(tui.padRight('Deployment ID:', 17)) + tui.link(deployment.id));
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
 						tui.arrow(tui.bold(tui.padRight('Deployment URL:', 17)) + tui.link(url));
@@ -566,6 +571,7 @@ export const deploySubcommand = createSubcommand({
 					tui.arrow(
 						tui.bold(tui.padRight('Project URL:', 17)) + tui.link(complete.publicUrls.latest)
 					);
+					tui.arrow(tui.bold(tui.padRight('Dashboard URL:', 17)) + tui.link(dashboard));
 				}
 			}
 
@@ -579,6 +585,7 @@ export const deploySubcommand = createSubcommand({
 							deployment: complete.publicUrls.deployment,
 							latest: complete.publicUrls.latest,
 							custom: complete.publicUrls.custom,
+							dashboard,
 						}
 					: undefined,
 			};