@agentuity/cli 0.0.55 → 0.0.57

package/src/cmd/build/ast.ts

@@ -3,6 +3,11 @@ import { basename, dirname, relative } from 'node:path';
 import { generate } from 'astring';
 import type { BuildMetadata } from '../../types';
 import { createLogger } from '@agentuity/server';
+import * as ts from 'typescript';
+import type { WorkbenchConfig } from '@agentuity/core';
+import type { LogLevel } from '../../types';
+
+const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL || 'info') as LogLevel);
 
 interface ASTNode {
 	type: string;
@@ -790,123 +795,141 @@ export async function parseRoute(
 	const routes: RouteDefinition = [];
 	const routePrefix = filename.includes('src/agents') ? '/agent' : '/api';
 
-	for (const body of ast.body) {
-		if (body.type === 'ExpressionStatement') {
-			const statement = body as ASTExpressionStatement;
-			const callee = statement.expression.callee;
-			if (callee.object.type === 'Identifier') {
-				const identifier = callee.object as ASTNodeIdentifier;
-				if (identifier.name === variableName) {
-					let method = (callee.property as ASTNodeIdentifier).name;
-					let type = 'api';
-					const action = statement.expression.arguments[0];
-					let suffix = '';
-					let config: Record<string, unknown> | undefined;
-					switch (method) {
-						case 'get':
-						case 'put':
-						case 'post':
-						case 'patch':
-						case 'delete': {
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								suffix = theaction.value;
+	try {
+		for (const body of ast.body) {
+			if (body.type === 'ExpressionStatement') {
+				const statement = body as ASTExpressionStatement;
+
+				// Validate that the expression is a call expression (e.g. function call)
+				if (statement.expression.type !== 'CallExpression') {
+					continue;
+				}
+
+				const callee = statement.expression.callee;
+
+				// Validate that the callee is a member expression (e.g. object.method())
+				// This handles cases like 'console.log()' or 'router.get()'
+				// direct function calls like 'myFunc()' have type 'Identifier' and will be skipped
+				if (callee.type !== 'MemberExpression') {
+					continue;
+				}
+
+				if (callee.object.type === 'Identifier' && statement.expression.arguments?.length > 0) {
+					const identifier = callee.object as ASTNodeIdentifier;
+					if (identifier.name === variableName) {
+						let method = (callee.property as ASTNodeIdentifier).name;
+						let type = 'api';
+						const action = statement.expression.arguments[0];
+						let suffix = '';
+						let config: Record<string, unknown> | undefined;
+						switch (method) {
+							case 'get':
+							case 'put':
+							case 'post':
+							case 'patch':
+							case 'delete': {
+								if (action && (action as ASTLiteral).type === 'Literal') {
+									suffix = (action as ASTLiteral).value;
+								} else {
+									throw new Error(
+										`unsupported HTTP method ${method} in ${filename} at line ${body.start}`
+									);
+								}
 								break;
 							}
-							break;
-						}
-						case 'stream':
-						case 'sse':
-						case 'websocket': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								suffix = theaction.value;
+							case 'stream':
+							case 'sse':
+							case 'websocket': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									suffix = theaction.value;
+									break;
+								}
 								break;
 							}
-							break;
-						}
-						case 'sms': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTObjectExpression;
-							if (theaction.type === 'ObjectExpression') {
-								config = {};
-								theaction.properties.forEach((p) => {
-									if (p.value.type === 'Literal') {
-										const literal = p.value as ASTLiteral;
-										config![p.key.name] = literal.value;
+							case 'sms': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTObjectExpression;
+								if (theaction.type === 'ObjectExpression') {
+									config = {};
+									theaction.properties.forEach((p) => {
+										if (p.value.type === 'Literal') {
+											const literal = p.value as ASTLiteral;
+											config![p.key.name] = literal.value;
+										}
+									});
+									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);
+										break;
 									}
-								});
-								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);
-									break;
 								}
+								break;
 							}
-							break;
-						}
-						case 'email': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								const email = theaction.value;
-								suffix = hash(email);
+							case 'email': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									const email = theaction.value;
+									suffix = hash(email);
+									break;
+								}
 								break;
 							}
-							break;
-						}
-						case 'cron': {
-							type = method;
-							method = 'post';
-							const theaction = action as ASTLiteral;
-							if (theaction.type === 'Literal') {
-								const number = theaction.value;
-								suffix = hash(number);
+							case 'cron': {
+								type = method;
+								method = 'post';
+								const theaction = action as ASTLiteral;
+								if (theaction.type === 'Literal') {
+									const number = theaction.value;
+									suffix = hash(number);
+									break;
+								}
 								break;
 							}
-							break;
+							default: {
+								throw new Error(
+									`unsupported router method ${method} in ${filename} at line ${body.start}`
+								);
+							}
 						}
+						const thepath = `${routePrefix}/${routeName}/${suffix}`
+							.replaceAll(/\/{2,}/g, '/')
+							.replaceAll(/\/$/g, '');
+						const id = generateRouteId(
+							projectId,
+							deploymentId,
+							type,
+							method,
+							rel,
+							thepath,
+							version
+						);
+						routes.push({
+							id,
+							method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
+							type: type as 'api' | 'sms' | 'email' | 'cron',
+							filename: rel,
+							path: thepath,
+							version,
+							config,
+						});
 					}
-					const thepath = `${routePrefix}/${routeName}/${suffix}`
-						.replaceAll(/\/{2,}/g, '/')
-						.replaceAll(/\/$/g, '');
-					const id = generateRouteId(
-						projectId,
-						deploymentId,
-						type,
-						method,
-						rel,
-						thepath,
-						version
-					);
-					routes.push({
-						id,
-						method: method as 'get' | 'post' | 'put' | 'delete' | 'patch',
-						type: type as 'api' | 'sms' | 'email' | 'cron',
-						filename: rel,
-						path: thepath,
-						version,
-						config,
-					});
 				}
 			}
 		}
+	} catch (error) {
+		const err = error instanceof Error ? error : new Error(String(error));
+		throw new Error(`Failed to parse route file ${filename}: ${err.message}`);
 	}
 	return routes;
 }
 
-/**
- * Configuration extracted from createWorkbench call
- */
-export interface WorkbenchConfig {
-	route: string;
-	headers?: Record<string, string>;
-}
-
 /**
  * Result of workbench analysis
  */
@@ -923,15 +946,14 @@ export interface WorkbenchAnalysis {
  * @param functionName - The function name to check for (e.g., 'createWorkbench')
  * @returns true if the function is both imported and called
  */
-export async function checkFunctionUsage(content: string, functionName: string): Promise<boolean> {
+export function checkFunctionUsage(content: string, functionName: string): boolean {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('temp.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasImport = false;
 		let hasUsage = false;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for import declarations with the function
 			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
 				if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -957,7 +979,7 @@ export async function checkFunctionUsage(content: string, functionName: string):
 		return hasImport && hasUsage;
 	} catch (error) {
 		// Fallback to string check if AST parsing fails
-		console.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
+		logger.warn(`AST parsing failed for ${functionName}, falling back to string check:`, error);
 		return content.includes(functionName);
 	}
 }
@@ -965,17 +987,13 @@ export async function checkFunctionUsage(content: string, functionName: string):
 /**
  * Check if app.ts contains conflicting routes for a given endpoint
  */
-export async function checkRouteConflicts(
-	content: string,
-	workbenchEndpoint: string
-): Promise<boolean> {
+export function checkRouteConflicts(content: string, workbenchEndpoint: string): boolean {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasConflict = false;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for router.get calls
 			if (
 				ts.isCallExpression(node) &&
@@ -1007,16 +1025,15 @@ export async function checkRouteConflicts(
  * @param content - The TypeScript source code
  * @returns workbench analysis including usage and config
  */
-export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalysis> {
+export function analyzeWorkbench(content: string): WorkbenchAnalysis {
 	try {
-		const ts = await import('typescript');
 		const sourceFile = ts.createSourceFile('app.ts', content, ts.ScriptTarget.Latest, true);
 
 		let hasImport = false;
 		let hasUsage = false;
 		let config: WorkbenchConfig | null = null;
 
-		function visitNode(node: import('typescript').Node): void {
+		function visitNode(node: ts.Node): void {
 			// Check for import declarations with createWorkbench
 			if (ts.isImportDeclaration(node) && node.importClause?.namedBindings) {
 				if (ts.isNamedImports(node.importClause.namedBindings)) {
@@ -1036,7 +1053,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 					// Extract configuration from the first argument (if any)
 					if (node.arguments.length > 0) {
 						const configArg = node.arguments[0];
-						config = parseConfigObject(configArg, ts);
+						config = parseConfigObject(configArg);
 					} else {
 						// Default config if no arguments provided
 						config = { route: '/workbench' };
@@ -1061,7 +1078,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 		};
 	} catch (error) {
 		// Fallback to simple check if AST parsing fails
-		console.warn('Workbench AST parsing failed, falling back to string check:', error);
+		logger.warn('Workbench AST parsing failed, falling back to string check:', error);
 		const hasWorkbench = content.includes('createWorkbench');
 		return {
 			hasWorkbench,
@@ -1073,10 +1090,7 @@ export async function analyzeWorkbench(content: string): Promise<WorkbenchAnalys
 /**
  * Parse a TypeScript object literal to extract configuration
  */
-function parseConfigObject(
-	node: import('typescript').Node,
-	ts: typeof import('typescript')
-): WorkbenchConfig | null {
+function parseConfigObject(node: ts.Node): WorkbenchConfig | null {
 	if (!ts.isObjectLiteralExpression(node)) {
 		return { route: '/workbench' }; // Default config
 	}

package/src/cmd/build/bundler.ts

@@ -1,6 +1,6 @@
 import { $ } from 'bun';
+import { z } from 'zod';
 import { join, relative, resolve, dirname } from 'node:path';
-import { createRequire } from 'node:module';
 import { cpSync, existsSync, mkdirSync, rmSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import AgentuityBundler, { getBuildMetadata } from './plugin';
@@ -10,8 +10,37 @@ import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
 import { createLogger } from '@agentuity/server';
 import type { LogLevel } from '../../types';
+import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench-templates';
+import { analyzeWorkbench } from './ast';
+import { encodeWorkbenchConfig } from '@agentuity/core';
 
-export interface BundleOptions {
+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'),
+	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>;
+
+export interface BundleOptions extends DeployOptions {
 	rootDir: string;
 	dev?: boolean;
 	env?: Map<string, string>;
@@ -30,6 +59,15 @@ export async function bundle({
 	rootDir,
 	project,
 	port,
+	tag,
+	logsUrl,
+	commitUrl,
+	provider,
+	trigger,
+	event,
+	pullRequestNumber,
+	pullRequestCommentId,
+	pullRequestURL,
 }: BundleOptions) {
 	const appFile = join(rootDir, 'app.ts');
 	if (!existsSync(appFile)) {
@@ -254,14 +292,12 @@ export async function bundle({
 	}
 
 	// Bundle workbench app if detected via setupWorkbench
-	const { analyzeWorkbench } = await import('./ast');
 	if (existsSync(appFile)) {
 		const appContent = await Bun.file(appFile).text();
-		const analysis = await analyzeWorkbench(appContent);
+		const analysis = analyzeWorkbench(appContent);
 
 		if (analysis.hasWorkbench) {
 			// Encode workbench config for environment variable
-			const { encodeWorkbenchConfig } = await import('@agentuity/core');
 			const config = analysis.config || { route: '/workbench', headers: {} };
 			// Add port to config (defaults to 3500 if not provided)
 			const configWithPort = { ...config, port: port || 3500 };
@@ -272,41 +308,55 @@ export async function bundle({
 			};
 			const logger = createLogger((process.env.AGENTUITY_LOG_LEVEL as LogLevel) || 'info');
 			try {
-				const projectRequire = createRequire(resolve(rootDir, 'package.json'));
-				const workbenchPkgPath = projectRequire.resolve('@agentuity/workbench/package.json');
-				const workbenchAppDir = join(dirname(workbenchPkgPath), 'src', 'app');
+				// Generate workbench files on the fly instead of using files from package
+				const tempWorkbenchDir = join(outDir, 'temp-workbench');
+				mkdirSync(tempWorkbenchDir, { recursive: true });
 
-				if (existsSync(workbenchAppDir)) {
-					const workbenchIndexFile = join(workbenchAppDir, 'index.html');
-					if (existsSync(workbenchIndexFile)) {
-						// Bundle workbench using same config as main web app
-						const workbenchBuildConfig: Bun.BuildConfig = {
-							entrypoints: [workbenchIndexFile],
-							root: workbenchAppDir,
-							outdir: join(outDir, 'workbench'),
-							define: workbenchDefine,
-							sourcemap: dev ? 'inline' : 'linked',
-							plugins: [AgentuityBundler],
-							target: 'browser',
-							format: 'esm',
-							banner: `// Generated file. DO NOT EDIT`,
-							minify: true,
-							splitting: true,
-							packages: 'bundle',
-							naming: {
-								entry: '[dir]/[name].[ext]',
-								chunk: 'workbench/chunk/[name]-[hash].[ext]',
-								asset: 'workbench/asset/[name]-[hash].[ext]',
-							},
-						};
+				// Generate files using templates
+				await Bun.write(join(tempWorkbenchDir, 'main.tsx'), generateWorkbenchMainTsx(config));
+				const workbenchIndexFile = join(tempWorkbenchDir, 'index.html');
+				await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
-						const workbenchResult = await Bun.build(workbenchBuildConfig);
-						if (workbenchResult.success) {
-							logger.debug('Workbench bundled successfully');
-						} else {
-							logger.error('Workbench bundling failed:', workbenchResult.logs.join('\n'));
-						}
+				// Bundle workbench using generated files
+				const workbenchBuildConfig: Bun.BuildConfig = {
+					entrypoints: [workbenchIndexFile],
+					root: tempWorkbenchDir,
+					outdir: join(outDir, 'workbench'),
+					define: workbenchDefine,
+					sourcemap: dev ? 'inline' : 'linked',
+					plugins: [AgentuityBundler],
+					target: 'browser',
+					format: 'esm',
+					banner: `// Generated file. DO NOT EDIT`,
+					minify: true,
+					splitting: true,
+					packages: 'bundle',
+					naming: {
+						entry: '[dir]/[name].[ext]',
+						chunk: 'workbench/chunk/[name]-[hash].[ext]',
+						asset: 'workbench/asset/[name]-[hash].[ext]',
+					},
+				};
+
+				const workbenchResult = await Bun.build(workbenchBuildConfig);
+				if (workbenchResult.success) {
+					logger.debug('Workbench bundled successfully');
+					// Clean up temp directory
+					rmSync(tempWorkbenchDir, { recursive: true, force: true });
+				} else {
+					logger.error('Workbench bundling failed. Logs:', workbenchResult.logs);
+					if (workbenchResult.logs.length === 0) {
+						logger.error('No build logs available. Checking generated files...');
+						logger.error('Temp dir exists:', await Bun.file(tempWorkbenchDir).exists());
+						logger.error('Index file exists:', await Bun.file(workbenchIndexFile).exists());
+						logger.error(
+							'Main.tsx exists:',
+							await Bun.file(join(tempWorkbenchDir, 'main.tsx')).exists()
+						);
 					}
+					// Clean up temp directory even on failure
+					rmSync(tempWorkbenchDir, { recursive: true, force: true });
+					process.exit(1);
 				}
 			} catch (error) {
 				logger.error('Failed to bundle workbench:', error);
@@ -339,7 +389,14 @@ export async function bundle({
 			repo: process.env.GITHUB_REPOSITORY
 				? gitParseUrl(process.env.GITHUB_REPOSITORY).toString('https')
 				: '',
+			provider: 'git',
 		};
+		if (process.env.GITHUB_REPOSITORY) {
+			buildmetadata.deployment.git.provider = 'github';
+		}
+		if (process.env.CI && !trigger) {
+			buildmetadata.deployment.git.trigger = 'ci';
+		}
 		// pull out the git information if we have it
 		try {
 			let gitDir = join(rootDir, '.git');
@@ -358,13 +415,16 @@ export async function bundle({
 						.map((s) => s.trim())
 						.filter(Boolean);
 				}
-				const branch = $`git branch --show-current`.nothrow().quiet();
-				if (branch) {
-					const _branch = await branch.text();
-					if (_branch) {
-						buildmetadata.deployment.git.branch = _branch.trim();
+				let branch = process.env.GITHUB_HEAD_REF;
+				if (!branch) {
+					const branchText = $`git branch --show-current`.nothrow().quiet();
+					if (branchText) {
+						branch = await branchText.text();
 					}
 				}
+				if (branch) {
+					buildmetadata.deployment.git.branch = branch.trim();
+				}
 				const commit = $`git rev-parse HEAD`.nothrow().quiet();
 				if (commit) {
 					const sha = await commit.text();
@@ -393,6 +453,61 @@ export async function bundle({
 		}
 	}
 
+	// if in gitlab CI, set defaults before user overrides
+	if (process.env.GITLAB_CI && buildmetadata?.deployment) {
+		buildmetadata.deployment.git ??= {};
+		buildmetadata.deployment.git.provider ??= 'gitlab';
+		buildmetadata.deployment.git.branch ??= process.env.CI_COMMIT_REF_NAME;
+		buildmetadata.deployment.git.commit ??= process.env.CI_COMMIT_SHA;
+		buildmetadata.deployment.git.buildUrl ??=
+			process.env.CI_JOB_URL ?? process.env.CI_PIPELINE_URL;
+	}
+
+	// configure any overrides or any that aren't detected automatically
+	if (buildmetadata?.deployment) {
+		buildmetadata.deployment.git ??= {};
+
+		// build tags: start with existing discovered tags, add defaults, then merge explicit tags
+		const tags = new Set(buildmetadata.deployment.git.tags ?? []);
+		tags.add('latest');
+		if (buildmetadata.deployment.git.branch) {
+			tags.add(buildmetadata.deployment.git.branch);
+		}
+		if (buildmetadata.deployment.git.commit) {
+			tags.add(buildmetadata.deployment.git.commit.substring(0, 7));
+		}
+		if (tag?.length && !(tag.length === 1 && tag[0] === 'latest')) {
+			for (const t of tag) {
+				tags.add(t);
+			}
+			tags.delete('latest'); // if you specify explicit tags we remove latest
+		}
+		buildmetadata.deployment.git.tags = Array.from(tags);
+
+		if (provider) {
+			buildmetadata.deployment.git.provider = provider;
+		}
+		if (logsUrl) {
+			buildmetadata.deployment.git.buildUrl = logsUrl;
+		}
+		if (commitUrl) {
+			buildmetadata.deployment.git.url = commitUrl;
+		}
+		if (trigger) {
+			buildmetadata.deployment.git.trigger = trigger;
+		}
+		if (event) {
+			buildmetadata.deployment.git.event = event;
+		}
+		if (pullRequestNumber) {
+			buildmetadata.deployment.git.pull_request = {
+				number: pullRequestNumber,
+				url: pullRequestURL,
+				commentId: pullRequestCommentId,
+			};
+		}
+	}
+
 	await Bun.write(
 		`${outDir}/package.json`,
 		JSON.stringify({ name: pkgContents.name, version: pkgContents.version }, null, 2)