@agentuity/cli 0.0.95 → 0.0.97

package/src/cmd/build/vite/vite-builder.ts

@@ -0,0 +1,288 @@
+/**
+ * Vite Builder
+ *
+ * Utilities for running Vite builds (client, server, workbench)
+ */
+
+import { join } from 'node:path';
+import type { InlineConfig } from 'vite';
+import type { Logger } from '../../../types';
+import { patchPlugin } from './patch-plugin';
+import { browserEnvPlugin } from './browser-env-plugin';
+
+export interface ViteBuildOptions {
+	rootDir: string;
+	mode: 'client' | 'server' | 'workbench';
+	dev?: boolean;
+	port?: number;
+	projectId?: string;
+	orgId?: string;
+	region?: string;
+	deploymentId?: string;
+	workbenchRoute?: string;
+	workbenchEnabled?: boolean;
+	logger: Logger;
+}
+
+/**
+ * Run a Vite build for the specified mode
+ * Generates vite config in .agentuity/.vite/ and uses it
+ */
+export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
+	const { rootDir, mode, dev = false, projectId = '', deploymentId = '', logger } = options;
+
+	logger.debug(`Running Vite build for mode: ${mode}`);
+
+	// For server mode, use Bun.build (preserves process.env at runtime)
+	if (mode === 'server') {
+		try {
+			// First, generate the entry file
+			const { generateEntryFile } = await import('../entry-generator');
+			await generateEntryFile({
+				rootDir,
+				projectId,
+				deploymentId: deploymentId || '',
+				logger,
+				mode: dev ? 'dev' : 'prod',
+			});
+
+			// Then, build with Bun.build
+			const { installExternalsAndBuild } = await import('./server-bundler');
+			await installExternalsAndBuild({
+				rootDir,
+				dev,
+				logger,
+			});
+		} catch (error) {
+			logger.error('server-bundler import or execution failed:', error);
+			throw error;
+		}
+		return;
+	}
+
+	// Dynamically import vite and react plugin
+	const { build: viteBuild } = await import('vite');
+	const reactModule = await import('@vitejs/plugin-react');
+	const react = reactModule.default;
+
+	// For client/workbench, use inline config (no agentuity plugin needed)
+	let viteConfig: InlineConfig;
+
+	if (mode === 'client') {
+		// Vite needs index.html as entry point for web apps
+		const htmlPath = join(rootDir, 'src', 'web', 'index.html');
+
+		// Use workbench config passed from runAllBuilds
+		const { workbenchEnabled = false, workbenchRoute = '/workbench' } = options;
+
+		// Load custom user plugins from agentuity.config.ts if it exists
+		const plugins = [react(), browserEnvPlugin(), patchPlugin({ logger, dev })];
+		const { loadAgentuityConfig } = await import('./config-loader');
+		const userConfig = await loadAgentuityConfig(rootDir, logger);
+		const userPlugins = userConfig?.plugins || [];
+		plugins.push(...userPlugins);
+		if (userPlugins.length > 0) {
+			logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
+		}
+
+		// Determine CDN base URL for production builds
+		const isLocalRegion = options.region === 'local';
+		const cdnBaseUrl =
+			!dev && deploymentId && !isLocalRegion
+				? `https://static.agentuity.com/${deploymentId}/`
+				: undefined;
+
+		viteConfig = {
+			root: join(rootDir, 'src', 'web'), // Set web dir as root
+			plugins,
+			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
+			publicDir: join(rootDir, 'src', 'web', 'public'),
+			base: cdnBaseUrl, // CDN URL for production assets
+			define: {
+				// Set workbench path if enabled (use import.meta.env for client code)
+				'import.meta.env.AGENTUITY_PUBLIC_WORKBENCH_PATH': workbenchEnabled
+					? JSON.stringify(workbenchRoute)
+					: 'undefined',
+			},
+			build: {
+				outDir: join(rootDir, '.agentuity/client'),
+				rollupOptions: {
+					input: htmlPath,
+				},
+				manifest: true,
+				emptyOutDir: true,
+				// Disable copying public files - Vite already includes them in assets with hashing
+				copyPublicDir: false,
+			},
+			logLevel: 'warn',
+		};
+	} else if (mode === 'workbench') {
+		const { workbenchRoute = '/workbench' } = options;
+		// Ensure route ends with / for Vite base
+		const base = workbenchRoute.endsWith('/') ? workbenchRoute : `${workbenchRoute}/`;
+
+		viteConfig = {
+			root: join(rootDir, '.agentuity/workbench-src'), // Use generated workbench source
+			base, // All workbench assets are under the configured route
+			plugins: [react(), patchPlugin({ logger, dev })],
+			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
+			build: {
+				outDir: join(rootDir, '.agentuity/workbench'),
+				rollupOptions: {
+					input: join(rootDir, '.agentuity/workbench-src/index.html'),
+				},
+				manifest: true,
+				emptyOutDir: true,
+			},
+			logLevel: 'warn',
+		};
+	} else {
+		throw new Error(`Unknown build mode: ${mode}`);
+	}
+
+	// Build with Vite
+	try {
+		// Force the build to use the correct mode
+		const buildMode = dev ? 'development' : 'production';
+
+		await viteBuild({
+			...viteConfig,
+			mode: buildMode,
+		});
+
+		logger.debug(`Vite build complete for mode: ${mode}`);
+	} catch (error) {
+		logger.error(`Vite build failed for mode ${mode}:`, error);
+		throw error;
+	}
+}
+
+interface BuildResult {
+	workbench: { included: boolean; duration: number };
+	client: { included: boolean; duration: number };
+	server: { included: boolean; duration: number };
+}
+
+/**
+ * Run all builds in sequence: client -> workbench (if enabled) -> server
+ */
+export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Promise<BuildResult> {
+	const { rootDir, projectId = '', dev = false, logger } = options;
+
+	const result: BuildResult = {
+		workbench: { included: false, duration: 0 },
+		client: { included: false, duration: 0 },
+		server: { included: false, duration: 0 },
+	};
+
+	// Load config to check if workbench is enabled (dev mode only)
+	const { loadAgentuityConfig, getWorkbenchConfig } = await import('./config-loader');
+	const config = await loadAgentuityConfig(rootDir, logger);
+	const workbenchConfig = getWorkbenchConfig(config, dev);
+
+	// Generate workbench files BEFORE any builds if enabled (dev mode only)
+	if (workbenchConfig.enabled) {
+		logger.debug('Workbench enabled (dev mode), generating files before build...');
+		const { generateWorkbenchFiles } = await import('./workbench-generator');
+		await generateWorkbenchFiles(rootDir, projectId, workbenchConfig, logger);
+	}
+
+	// Check if web frontend exists
+	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
+
+	// 1. Build client (only if web frontend exists)
+	if (hasWebFrontend) {
+		logger.debug('Building client assets...');
+		try {
+			const started = Date.now();
+			await runViteBuild({
+				...options,
+				mode: 'client',
+				workbenchEnabled: workbenchConfig.enabled,
+				workbenchRoute: workbenchConfig.route,
+			});
+			result.client.included = true;
+			result.client.duration = Date.now() - started;
+		} catch (error) {
+			logger.error('Client build failed:', error);
+			throw error;
+		}
+	} else {
+		logger.debug('Skipping client build - no src/web/index.html found');
+	}
+
+	// 2. Build workbench (if enabled in config)
+	if (workbenchConfig.enabled) {
+		logger.debug('Building workbench assets...');
+		try {
+			const started = Date.now();
+			await runViteBuild({
+				...options,
+				mode: 'workbench',
+				workbenchRoute: workbenchConfig.route,
+				workbenchEnabled: true,
+			});
+			result.workbench.included = true;
+			result.workbench.duration = Date.now() - started;
+		} catch (error) {
+			logger.error('Workbench build failed:', error);
+			throw error;
+		}
+	}
+
+	// 3. Build server
+	logger.debug('Building server...');
+	try {
+		const started = Date.now();
+		await runViteBuild({ ...options, mode: 'server' });
+		result.server.included = true;
+		result.server.duration = Date.now() - started;
+	} catch (error) {
+		logger.error('Server build failed:', error);
+		throw error;
+	}
+
+	// 4. Generate registry and metadata (after all builds complete)
+	logger.debug('Generating agent registry and metadata...');
+	const { generateMetadata, writeMetadataFile } = await import('./metadata-generator');
+	const { generateAgentRegistry, generateRouteRegistry } = await import('./registry-generator');
+	const { discoverAgents } = await import('./agent-discovery');
+	const { discoverRoutes } = await import('./route-discovery');
+
+	const srcDir = join(rootDir, 'src');
+	const agentMetadata = await discoverAgents(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+	const { routes, routeInfoList } = await discoverRoutes(
+		srcDir,
+		projectId,
+		options.deploymentId || '',
+		logger
+	);
+
+	// Generate agent and route registries for type augmentation
+	generateAgentRegistry(srcDir, agentMetadata);
+	generateRouteRegistry(srcDir, routeInfoList);
+	logger.debug('Agent and route registries generated');
+
+	// Generate metadata
+	const metadata = await generateMetadata({
+		rootDir,
+		projectId,
+		orgId: options.orgId,
+		deploymentId: options.deploymentId,
+		agents: agentMetadata,
+		routes,
+		logger,
+		dev,
+	});
+
+	writeMetadataFile(rootDir, metadata, dev, logger);
+	logger.debug('Registry and metadata generation complete');
+
+	logger.debug('All builds complete');
+	return result;
+}

package/src/cmd/build/vite/workbench-generator.ts

@@ -0,0 +1,152 @@
+/**
+ * Workbench file generator for Vite builds
+ */
+
+import { join } from 'node:path';
+import { mkdirSync, existsSync, cpSync } from 'node:fs';
+import {
+	encodeWorkbenchConfig,
+	type WorkbenchConfig as CoreWorkbenchConfig,
+} from '@agentuity/core';
+import type { Logger, WorkbenchConfig } from '../../../types';
+
+/**
+ * Find the @agentuity/workbench package path
+ */
+async function findWorkbenchPackage(rootDir: string, logger: Logger): Promise<string | null> {
+	// Try app-level node_modules first
+	const appLevel = join(rootDir, 'node_modules', '@agentuity', 'workbench');
+	if (existsSync(appLevel)) {
+		return appLevel;
+	}
+
+	// Try workspace root (walk up looking for workspace)
+	let current = rootDir;
+	while (true) {
+		const pkgPath = join(current, 'package.json');
+		if (existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(await Bun.file(pkgPath).text());
+				if (pkg.workspaces) {
+					// Found workspace root
+					const workspaceWorkbench = join(current, 'node_modules', '@agentuity', 'workbench');
+					if (existsSync(workspaceWorkbench)) {
+						return workspaceWorkbench;
+					}
+					// Try workspace packages directory
+					const packagesWorkbench = join(current, 'packages', 'workbench');
+					if (existsSync(packagesWorkbench)) {
+						return packagesWorkbench;
+					}
+				}
+			} catch {
+				// Ignore parse errors
+			}
+		}
+		const parent = join(current, '..');
+		if (parent === current) break;
+		current = parent;
+	}
+
+	logger.warn('Could not find @agentuity/workbench package');
+	return null;
+}
+
+/**
+ * Generate workbench main.tsx file
+ */
+function generateMainTsx(config: CoreWorkbenchConfig): string {
+	const encodedConfig = encodeWorkbenchConfig(config);
+	return `// Generated workbench entry point
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { App } from '@agentuity/workbench';
+import './styles.css'; // Import CSS for Vite HMR
+
+// Root element
+const rootElement = document.getElementById('root');
+if (!rootElement) {
+	throw new Error('Root element not found');
+}
+
+// Render the app
+const root = createRoot(rootElement);
+root.render(<App configBase64="${encodedConfig}" />);
+`;
+}
+
+/**
+ * Generate workbench index.html file
+ */
+function generateIndexHtml(): string {
+	return `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>Agentuity Workbench</title>
+</head>
+<body>
+	<div id="root"></div>
+	<script type="module" src="./main.tsx"></script>
+</body>
+</html>`;
+}
+
+/**
+ * Generate workbench files in .agentuity/workbench-src/
+ * This keeps them separate from user's source code
+ */
+export async function generateWorkbenchFiles(
+	rootDir: string,
+	projectId: string,
+	config: WorkbenchConfig,
+	logger: Logger
+): Promise<void> {
+	const workbenchDir = join(rootDir, '.agentuity', 'workbench-src');
+
+	// Create directory if it doesn't exist
+	if (!existsSync(workbenchDir)) {
+		mkdirSync(workbenchDir, { recursive: true });
+		logger.debug('Created workbench directory: %s', workbenchDir);
+	}
+
+	// Create core workbench config
+	const coreConfig: CoreWorkbenchConfig = {
+		route: config.route ?? '/workbench',
+		headers: config.headers ?? {},
+	};
+
+	// Generate main.tsx
+	const mainTsxPath = join(workbenchDir, 'main.tsx');
+	await Bun.write(mainTsxPath, generateMainTsx(coreConfig));
+	logger.debug('Generated workbench main.tsx');
+
+	// Generate index.html
+	const indexHtmlPath = join(workbenchDir, 'index.html');
+	await Bun.write(indexHtmlPath, generateIndexHtml());
+	logger.debug('Generated workbench index.html');
+
+	// Copy standalone CSS from @agentuity/workbench package
+	const workbenchPackage = await findWorkbenchPackage(rootDir, logger);
+	if (workbenchPackage) {
+		const distCss = join(workbenchPackage, 'dist', 'standalone.css');
+		const srcCss = join(workbenchPackage, 'src', 'standalone.css');
+		const destCss = join(workbenchDir, 'styles.css');
+
+		if (existsSync(distCss)) {
+			cpSync(distCss, destCss);
+			logger.debug('Copied workbench standalone.css from dist');
+		} else if (existsSync(srcCss)) {
+			cpSync(srcCss, destCss);
+			logger.warn('Using source standalone.css (ensure @agentuity/workbench is built)');
+		} else {
+			logger.error('Workbench styles not found in package: %s', workbenchPackage);
+			throw new Error('Workbench styles not found. Ensure @agentuity/workbench is installed.');
+		}
+	} else {
+		throw new Error('Could not find @agentuity/workbench package. Ensure it is installed.');
+	}
+
+	logger.trace('Workbench files generated successfully');
+}

package/src/cmd/build/vite-bundler.ts

@@ -0,0 +1,110 @@
+/**
+ * Vite-based bundler
+ *
+ * Replaces the Bun bundler with Vite for client and server builds
+ */
+
+import { join } from 'node:path';
+import { stat } from 'node:fs/promises';
+import { StructuredError } from '@agentuity/core';
+import type { Logger } from '../../types';
+import { runAllBuilds } from './vite/vite-builder';
+import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
+import { checkBunVersion } from '../../utils/bun-version-checker';
+import * as tui from '../../tui';
+
+const AppFileNotFoundError = StructuredError('AppFileNotFoundError');
+const BuildFailedError = StructuredError('BuildFailedError');
+
+export interface ViteBundleOptions {
+	rootDir: string;
+	dev?: boolean;
+	projectId?: string;
+	orgId?: string;
+	region?: string;
+	deploymentId?: string;
+	port?: number;
+	logger: Logger;
+}
+
+/**
+ * Bundle the project using Vite
+ */
+export async function viteBundle(options: ViteBundleOptions): Promise<{ output: string[] }> {
+	const {
+		rootDir,
+		projectId = '',
+		orgId = '',
+		region = 'local',
+		deploymentId = '',
+		port = 3500,
+		logger,
+	} = options;
+
+	const output: string[] = [];
+
+	// Check Bun version meets minimum requirements
+	const versionOutput = await checkBunVersion();
+	output.push(...versionOutput);
+
+	// Verify app.ts exists
+	const appFile = join(rootDir, 'app.ts');
+	if (!(await Bun.file(appFile).exists())) {
+		throw new AppFileNotFoundError({
+			message: `App file not found at expected location: ${appFile}`,
+		});
+	}
+
+	// Verify src directory exists
+	const srcDir = join(rootDir, 'src');
+	const srcDirExists = await stat(srcDir)
+		.then((s) => s.isDirectory())
+		.catch(() => false);
+	if (!srcDirExists) {
+		throw new BuildFailedError({
+			message: `Source directory not found: ${srcDir}`,
+		});
+	}
+
+	// Check and upgrade @agentuity/* dependencies if needed
+	const upgradeResult = await checkAndUpgradeDependencies(rootDir, logger);
+	if (upgradeResult.failed.length > 0 && process.stdin.isTTY) {
+		throw new BuildFailedError({
+			message: `Failed to upgrade dependencies: ${upgradeResult.failed.join(', ')}`,
+		});
+	}
+
+	try {
+		// Run all Vite builds (client -> workbench -> server)
+		logger.debug('Starting Vite builds...');
+
+		const result = await runAllBuilds({
+			rootDir,
+			dev: options.dev || false, // Pass through dev flag for development builds
+			port,
+			projectId,
+			orgId,
+			region,
+			deploymentId,
+			logger,
+		});
+
+		if (result.client.included) {
+			output.push(tui.muted(`✓ Client Built in ${result.client.duration}ms`));
+		}
+		if (result.workbench.included) {
+			output.push(tui.muted(`✓ Workbench Built in ${result.workbench.duration}ms`));
+		}
+		if (result.server.included) {
+			output.push(tui.muted(`✓ Server Built in ${result.server.duration}ms`));
+		}
+
+		logger.debug('Vite builds complete');
+
+		return { output };
+	} catch (error) {
+		throw new BuildFailedError({
+			message: `Build failed: ${error instanceof Error ? error.message : String(error)}`,
+		});
+	}
+}

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

@@ -23,6 +23,8 @@ export const getSubcommand = createSubcommand({
 		}),
 		response: AgentSchema,
 	},
+	webUrl: (ctx) =>
+		`/projects/${encodeURIComponent(ctx.project.projectId)}/agents/${encodeURIComponent(ctx.args.agent_id)}`,
 	async handler(ctx) {
 		const { args, apiClient, project, options } = ctx;
 		const agentId = args.agent_id;

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

@@ -24,6 +24,7 @@ export const listSubcommand = createSubcommand({
 		}),
 		response: z.array(AgentSchema),
 	},
+	webUrl: (ctx) => `/projects/${encodeURIComponent(ctx.project.projectId)}/agents`,
 	async handler(ctx) {
 		const { opts, apiClient, project, options } = ctx;
 		const projectId = project.projectId;

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

@@ -63,6 +63,7 @@ export const getSubcommand = createSubcommand({
 		}),
 		response: DBGetResponseSchema,
 	},
+	webUrl: (ctx) => `/services/database/${encodeURIComponent(ctx.args.name)}`,
 
 	async handler(ctx) {
 		const { logger, args, opts, options, orgId, region, auth } = ctx;

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

@@ -44,6 +44,7 @@ export const listSubcommand = createSubcommand({
 		}),
 		response: DBListResponseSchema,
 	},
+	webUrl: '/services/database',
 
 	async handler(ctx) {
 		const { logger, opts, options, orgId, region, auth } = ctx;