@agentuity/cli 0.0.87 → 0.0.89

package/src/cmd/build/bundler.ts

@@ -1,6 +1,6 @@
 import { $, semver } from 'bun';
 import { join, relative, resolve, dirname, basename } from 'node:path';
-import { cpSync, existsSync, mkdirSync, rmSync, readdirSync } from 'node:fs';
+import { cpSync, existsSync, mkdirSync, rmSync, readdirSync, readFileSync } from 'node:fs';
 import gitParseUrl from 'git-url-parse';
 import { StructuredError } from '@agentuity/core';
 import * as tui from '../../tui';
@@ -10,11 +10,12 @@ import { getFilesRecursively } from './file';
 import { getVersion } from '../../version';
 import type { Project } from '../../types';
 import { fixDuplicateExportsInDirectory } from './fix-duplicate-exports';
-import type { Logger } from '../../types';
+import type { Logger, BuildContext } from '../../types';
 import { generateWorkbenchMainTsx, generateWorkbenchIndexHtml } from './workbench';
 import { analyzeWorkbench, type WorkbenchAnalysis } from './ast';
 import { type DeployOptions } from '../../schemas/deploy';
 import { checkAndUpgradeDependencies } from '../../utils/dependency-checker';
+import { loadBuildConfig, executeBuildConfig, mergeBuildConfig } from './config-loader';
 
 const minBunVersion = '>=1.3.3';
 
@@ -79,6 +80,77 @@ const InvalidBunVersion = StructuredError('InvalidBunVersion')<{
 	required: string;
 }>();
 
+/**
+ * Finds the workspace root by walking up the directory tree looking for a package.json with workspaces
+ */
+function findWorkspaceRoot(startDir: string): string | null {
+	let currentDir = startDir;
+	while (true) {
+		const pkgPath = join(currentDir, 'package.json');
+		if (existsSync(pkgPath)) {
+			try {
+				const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+				if (pkg.workspaces) {
+					return currentDir;
+				}
+			} catch {
+				// Ignore parse errors, continue searching
+			}
+		}
+		const parent = resolve(currentDir, '..');
+		if (parent === currentDir) break; // reached filesystem root
+		currentDir = parent;
+	}
+	return null;
+}
+
+/**
+ * Finds a package by searching multiple locations:
+ * 1. App-level node_modules
+ * 2. Workspace root node_modules
+ * 3. Workspace packages directory (for workspace packages)
+ *
+ * @param rootDir - Root directory of the project
+ * @param packageName - Package name (e.g., '@agentuity/workbench')
+ * @param logger - Optional logger for debug messages
+ * @returns Path to the package directory, or null if not found
+ */
+function findPackagePath(rootDir: string, packageName: string, logger?: Logger): string | null {
+	const [scope, name] = packageName.startsWith('@')
+		? packageName.slice(1).split('/')
+		: [null, packageName];
+
+	// 1. Try app-level node_modules
+	const appLevelPath = scope
+		? join(rootDir, 'node_modules', `@${scope}`, name)
+		: join(rootDir, 'node_modules', name);
+	if (existsSync(appLevelPath)) {
+		logger?.debug(`Found ${packageName} at app level: ${appLevelPath}`);
+		return appLevelPath;
+	}
+
+	// 2. Try workspace root node_modules
+	const workspaceRoot = findWorkspaceRoot(rootDir);
+	if (workspaceRoot) {
+		const rootLevelPath = scope
+			? join(workspaceRoot, 'node_modules', `@${scope}`, name)
+			: join(workspaceRoot, 'node_modules', name);
+		if (existsSync(rootLevelPath)) {
+			logger?.debug(`Found ${packageName} at workspace root: ${rootLevelPath}`);
+			return rootLevelPath;
+		}
+
+		// 3. Try workspace packages directory
+		const workspacePackagePath = join(workspaceRoot, 'packages', name);
+		if (existsSync(workspacePackagePath)) {
+			logger?.debug(`Found ${packageName} in workspace packages: ${workspacePackagePath}`);
+			return workspacePackagePath;
+		}
+	}
+
+	return null;
+}
+
 const handleBuildFailure = (buildResult: BuildResult) => {
 	// Collect all build errors with full details
 	const errorMessages = buildResult.logs
@@ -302,8 +374,23 @@ export async function bundle({
 	const tsconfigPath = join(rootDir, 'tsconfig.json');
 	const hasTsconfig = existsSync(tsconfigPath);
 
+	// Load user build config (if it exists)
+	const buildConfigFunction = await loadBuildConfig(rootDir);
+
+	// Helper to create build context for config function
+	const createBuildContext = (): BuildContext => ({
+		rootDir,
+		dev,
+		outDir,
+		srcDir,
+		orgId,
+		projectId,
+		region,
+		logger,
+	});
+
 	await (async () => {
-		const config: Bun.BuildConfig = {
+		const baseConfig: Bun.BuildConfig = {
 			entrypoints: appEntrypoints,
 			root: rootDir,
 			outdir: outDir,
@@ -330,7 +417,19 @@ export async function bundle({
 			},
 			tsconfig: hasTsconfig ? tsconfigPath : undefined,
 		};
-		const buildResult = await Bun.build(config);
+
+		// Apply user config for 'api' phase
+		let finalConfig = baseConfig;
+		if (buildConfigFunction) {
+			const userConfig = await executeBuildConfig(
+				buildConfigFunction,
+				'api',
+				createBuildContext()
+			);
+			finalConfig = mergeBuildConfig(baseConfig, userConfig);
+		}
+
+		const buildResult = await Bun.build(finalConfig);
 		if (!buildResult.success) {
 			handleBuildFailure(buildResult);
 		}
@@ -438,7 +537,7 @@ export async function bundle({
 				mkdirSync(join(webOutDir, 'asset'), { recursive: true });
 				const isLocalRegion = region === 'local' || region === 'l';
 
-				const config: Bun.BuildConfig = {
+				const baseConfig: Bun.BuildConfig = {
 					entrypoints: webEntrypoints,
 					root: webDir,
 					outdir: webOutDir,
@@ -467,7 +566,19 @@ export async function bundle({
 					},
 					tsconfig: hasTsconfig ? tsconfigPath : undefined,
 				};
-				const result = await Bun.build(config);
+
+				// Apply user config for 'web' phase
+				let finalConfig = baseConfig;
+				if (buildConfigFunction) {
+					const userConfig = await executeBuildConfig(
+						buildConfigFunction,
+						'web',
+						createBuildContext()
+					);
+					finalConfig = mergeBuildConfig(baseConfig, userConfig);
+				}
+
+				const result = await Bun.build(finalConfig);
 				if (result.success) {
 					// Fix duplicate exports caused by Bun splitting bug
 					// See: https://github.com/oven-sh/bun/issues/5344
@@ -507,12 +618,51 @@ export async function bundle({
 
 			// Generate files using templates
 			await Bun.write(join(tempWorkbenchDir, 'main.tsx'), generateWorkbenchMainTsx(config));
+
+			// Copy the pre-built standalone.css from workbench package instead of generating it
+			// This ensures we use the built version with Tailwind already processed
+			const workbenchPackagePath = findPackagePath(rootDir, '@agentuity/workbench', logger);
+			const workbenchStylesOut = join(tempWorkbenchDir, 'styles.css');
+
+			if (workbenchPackagePath) {
+				const workbenchStylesPath = join(workbenchPackagePath, 'dist', 'standalone.css');
+				const workbenchStylesSourcePath = join(workbenchPackagePath, 'src', 'standalone.css');
+
+				if (existsSync(workbenchStylesPath)) {
+					cpSync(workbenchStylesPath, workbenchStylesOut);
+					logger.debug('Copied workbench dist/standalone.css to temp workbench dir');
+				} else if (existsSync(workbenchStylesSourcePath)) {
+					// Fallback: copy source CSS file (contains Tailwind directives that need processing)
+					cpSync(workbenchStylesSourcePath, workbenchStylesOut);
+					logger.warn(
+						'Workbench dist/standalone.css not found, using source CSS. Ensure @agentuity/workbench is built.'
+					);
+				} else {
+					throw new BuildFailedError({
+						message: `Workbench styles not found in ${workbenchPackagePath}. Expected either:
+  - ${workbenchStylesPath}
+  - ${workbenchStylesSourcePath}
+  
+Make sure @agentuity/workbench is built.`,
+					});
+				}
+			} else {
+				throw new BuildFailedError({
+					message: `Workbench package not found. Searched in:
+  - App-level node_modules
+  - Workspace root node_modules
+  - Workspace packages directory
+  
+Make sure @agentuity/workbench is installed or available in the workspace.`,
+				});
+			}
+
 			const workbenchIndexFile = join(tempWorkbenchDir, 'index.html');
 			await Bun.write(workbenchIndexFile, generateWorkbenchIndexHtml());
 
 			// Bundle workbench using generated files
 			// Disable splitting to avoid CommonJS/ESM module resolution conflicts
-			const workbenchBuildConfig: Bun.BuildConfig = {
+			const workbenchBaseConfig: Bun.BuildConfig = {
 				entrypoints: [workbenchIndexFile],
 				outdir: join(outDir, 'workbench'),
 				sourcemap: dev ? 'inline' : 'linked',
@@ -531,7 +681,18 @@ export async function bundle({
 				},
 			};
 
-			const workbenchResult = await Bun.build(workbenchBuildConfig);
+			// Apply user config for 'workbench' phase
+			let finalWorkbenchConfig = workbenchBaseConfig;
+			if (buildConfigFunction) {
+				const userConfig = await executeBuildConfig(
+					buildConfigFunction,
+					'workbench',
+					createBuildContext()
+				);
+				finalWorkbenchConfig = mergeBuildConfig(workbenchBaseConfig, userConfig);
+			}
+
+			const workbenchResult = await Bun.build(finalWorkbenchConfig);
 			if (workbenchResult.success) {
 				logger.debug('Workbench bundled successfully');
 				// Clean up temp directory

package/src/cmd/build/config-loader.ts

@@ -0,0 +1,200 @@
+import { join } from 'node:path';
+import { StructuredError } from '@agentuity/core';
+import type { BuildConfigFunction, BuildPhase, BuildContext, BuildConfig } from '../../types';
+
+const BuildConfigLoadError = StructuredError('BuildConfigLoadError');
+const BuildConfigValidationError = StructuredError('BuildConfigValidationError');
+
+/**
+ * Reserved define keys that cannot be overridden by user config
+ */
+const RESERVED_DEFINE_PREFIXES = ['process.env.AGENTUITY_', 'process.env.NODE_ENV'];
+
+/**
+ * Load and validate agentuity.config.ts from the project root
+ */
+export async function loadBuildConfig(rootDir: string): Promise<BuildConfigFunction | null> {
+	const configPath = join(rootDir, 'agentuity.config.ts');
+
+	// Check if config file exists
+	const configFile = Bun.file(configPath);
+	if (!(await configFile.exists())) {
+		return null; // No config file is OK - it's optional
+	}
+
+	try {
+		// Import the config file (Bun handles TypeScript natively)
+		// Dynamically import using absolute path; Bun resolves TS modules without a file:// URL
+		const configModule = await import(configPath);
+
+		// Get the default export
+		const configFunction = configModule.default;
+
+		// Validate it's a function
+		if (typeof configFunction !== 'function') {
+			throw new BuildConfigValidationError({
+				message: `agentuity.config.ts must export a default function, got ${typeof configFunction}`,
+			});
+		}
+
+		return configFunction as BuildConfigFunction;
+	} catch (error) {
+		// If it's already our error, re-throw
+		if (error instanceof BuildConfigValidationError || error instanceof BuildConfigLoadError) {
+			throw error;
+		}
+
+		// Wrap other errors
+		throw new BuildConfigLoadError({
+			message: `Failed to load agentuity.config.ts: ${error instanceof Error ? error.message : String(error)}`,
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+/**
+ * Execute the build config function for a specific phase and validate the result
+ */
+export async function executeBuildConfig(
+	configFunction: BuildConfigFunction,
+	phase: BuildPhase,
+	context: BuildContext
+): Promise<BuildConfig> {
+	try {
+		// Execute the config function (may be async)
+		const config = await configFunction(phase, context);
+
+		// Validate the result is an object
+		if (!config || typeof config !== 'object') {
+			throw new BuildConfigValidationError({
+				message: `Build config for phase "${phase}" must return an object, got ${typeof config}`,
+			});
+		}
+
+		// Validate plugins array if provided
+		if (config.plugins !== undefined) {
+			if (!Array.isArray(config.plugins)) {
+				throw new BuildConfigValidationError({
+					message: `Build config plugins for phase "${phase}" must be an array, got ${typeof config.plugins}`,
+				});
+			}
+			// Validate each plugin has a name property (basic BunPlugin check)
+			for (const plugin of config.plugins) {
+				if (!plugin || typeof plugin !== 'object' || !('name' in plugin)) {
+					throw new BuildConfigValidationError({
+						message: `Invalid plugin in phase "${phase}": plugins must be BunPlugin objects with a name property`,
+					});
+				}
+			}
+		}
+
+		// Validate external array if provided
+		if (config.external !== undefined) {
+			if (!Array.isArray(config.external)) {
+				throw new BuildConfigValidationError({
+					message: `Build config external for phase "${phase}" must be an array, got ${typeof config.external}`,
+				});
+			}
+			// Validate each external is a string
+			for (const ext of config.external) {
+				if (typeof ext !== 'string') {
+					throw new BuildConfigValidationError({
+						message: `Invalid external in phase "${phase}": all externals must be strings, got ${typeof ext}`,
+					});
+				}
+			}
+		}
+
+		// Validate and filter define object if provided
+		if (config.define !== undefined) {
+			if (typeof config.define !== 'object' || config.define === null) {
+				throw new BuildConfigValidationError({
+					message: `Build config define for phase "${phase}" must be an object, got ${typeof config.define}`,
+				});
+			}
+
+			// Check for reserved keys and filter them out
+			const filteredDefine: Record<string, string> = {};
+			const blockedKeys: string[] = [];
+
+			for (const [key, value] of Object.entries(config.define)) {
+				// Check if this key starts with any reserved prefix
+				const isReserved = RESERVED_DEFINE_PREFIXES.some((prefix) => key.startsWith(prefix));
+
+				if (isReserved) {
+					blockedKeys.push(key);
+					continue; // Skip reserved keys
+				}
+
+				// Validate value is a string
+				if (typeof value !== 'string') {
+					throw new BuildConfigValidationError({
+						message: `Build config define values for phase "${phase}" must be strings, got ${typeof value} for key "${key}"`,
+					});
+				}
+
+				filteredDefine[key] = value;
+			}
+
+			// Warn if we blocked any keys
+			if (blockedKeys.length > 0) {
+				context.logger.warn(
+					`Build config for phase "${phase}" attempted to override reserved define keys (ignored): ${blockedKeys.join(', ')}`
+				);
+			}
+
+			// Replace with filtered version
+			config.define = filteredDefine;
+		}
+
+		return config;
+	} catch (error) {
+		// If it's already our error, re-throw
+		if (error instanceof BuildConfigValidationError) {
+			throw error;
+		}
+
+		// Wrap other errors
+		throw new BuildConfigLoadError({
+			message: `Failed to execute build config for phase "${phase}": ${error instanceof Error ? error.message : String(error)}`,
+			cause: error instanceof Error ? error : undefined,
+		});
+	}
+}
+
+/**
+ * Merge user build config with base Bun.BuildConfig
+ * User config is applied AFTER base config with safeguards
+ * Returns a complete Bun.BuildConfig with user overrides applied
+ */
+export function mergeBuildConfig(
+	baseConfig: import('bun').BuildConfig,
+	userConfig: BuildConfig
+): import('bun').BuildConfig {
+	const merged = { ...baseConfig };
+
+	// Merge plugins (user plugins come AFTER Agentuity plugin)
+	if (userConfig.plugins && userConfig.plugins.length > 0) {
+		merged.plugins = [...(baseConfig.plugins ?? []), ...userConfig.plugins];
+	}
+
+	// Merge external (combine arrays, dedupe)
+	if (userConfig.external && userConfig.external.length > 0) {
+		const existingExternal = Array.isArray(baseConfig.external)
+			? baseConfig.external
+			: baseConfig.external
+				? [baseConfig.external]
+				: [];
+		merged.external = [...new Set([...existingExternal, ...userConfig.external])];
+	}
+
+	// Merge define (user defines come last, but reserved keys already filtered)
+	if (userConfig.define && Object.keys(userConfig.define).length > 0) {
+		merged.define = {
+			...baseConfig.define,
+			...userConfig.define,
+		};
+	}
+
+	return merged;
+}

package/src/cmd/build/plugin.ts

@@ -336,8 +336,11 @@ const AgentuityBundler: BunPlugin = {
 				// Setup workbench configuration - evaluate fresh each time during builds
 				const workbenchConfig = await setupWorkbench(srcDir);
 
+				// Store web routes for later (must be registered AFTER API routes)
+				let webRoutesInsert: string | null = null;
+
 				if (existsSync(indexFile)) {
-					inserts.push(`import { serveStatic } from 'hono/bun';
+					webRoutesInsert = `import { serveStatic } from 'hono/bun';
 import { getRouter, registerDevModeRoutes } from '@agentuity/runtime';
 import { readFileSync, existsSync } from 'node:fs';
 
@@ -387,14 +390,22 @@ import { readFileSync, existsSync } from 'node:fs';
 	// Serve public assets at root (e.g., /favicon.ico) - must be last
 	router.get('/*', async (c, next) => {
 		const path = c.req.path;
+		// Skip API routes - let them 404 naturally
+		if (path === '/api' || path.startsWith('/api/')) {
+			return c.notFound();
+		}
 		// Prevent directory traversal attacks
 		if (path.includes('..') || path.includes('%2e%2e')) {
 			return c.notFound();
 		}
+		// Don't catch workbench routes (already handled above)
+		if (path.startsWith('/workbench')) {
+			return c.notFound();
+		}
 		// serve default for any path not explicitly matched
 		return c.html(index);
 	});
-})();`);
+})();`;
 				}
 
 				// Build agentInfo from all discovered agents and track directories
@@ -626,6 +637,11 @@ import { readFileSync, existsSync } from 'node:fs';
 })();`);
 				}
 
+				// Add web routes AFTER API routes (catch-all must be last)
+				if (webRoutesInsert) {
+					inserts.push(webRoutesInsert);
+				}
+
 				const file = Bun.file(args.path);
 				let contents = await file.text();
 				// Use AST-based parsing to reliably find createApp statement end

package/src/cmd/build/workbench.ts

@@ -8,7 +8,6 @@ export function generateWorkbenchMainTsx(config: WorkbenchConfig): string {
 import React from 'react';
 import { createRoot } from 'react-dom/client';
 import { App } from '@agentuity/workbench';
-import '@agentuity/workbench/styles';
 
 // Root element
 const rootElement = document.getElementById('root');
@@ -23,6 +22,14 @@ root.render(<App configBase64="${encodedConfig}" />);
 `;
 }
 
+export function generateWorkbenchStylesCss(): string {
+	// This file will be replaced with the actual dist/styles.css content during build
+	// We use @import here as a placeholder, but the bundler should resolve it to the built file
+	return `/* Generated workbench styles - will be replaced with dist/styles.css */
+@import '@agentuity/workbench/styles-standalone';
+`;
+}
+
 export function generateWorkbenchIndexHtml(): string {
 	return `<!DOCTYPE html>
 <html lang="en">
@@ -30,6 +37,7 @@ export function generateWorkbenchIndexHtml(): string {
 	<meta charset="UTF-8">
 	<meta name="viewport" content="width=device-width, initial-scale=1.0">
 	<title>Agentuity Workbench</title>
+	<link rel="stylesheet" href="./styles.css">
 </head>
 <body>
 	<div id="root"></div>

package/src/cmd/cloud/index.ts

@@ -1,6 +1,7 @@
 import { createCommand } from '../../types';
 import { deploySubcommand } from './deploy';
 import { dbCommand } from './db';
+import { redisCommand } from './redis';
 import { storageCommand } from './storage';
 import { sessionCommand } from './session';
 import { threadCommand } from './thread';
@@ -34,6 +35,7 @@ export const command = createCommand({
 		secretCommand,
 		deploySubcommand,
 		dbCommand,
+		redisCommand,
 		storageCommand,
 		sessionCommand,
 		threadCommand,

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

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+
+const RedisGetResponseSchema = z.object({
+	url: z.string().optional().describe('Redis connection URL'),
+});
+
+export const showSubcommand = createSubcommand({
+	name: 'show',
+	aliases: ['info'],
+	description: 'Show Redis connection URL',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		{ command: getCommand('cloud redis show'), description: 'Show Redis connection URL' },
+		{
+			command: getCommand('cloud redis show --show-credentials'),
+			description: 'Show Redis URL with credentials visible',
+		},
+		{
+			command: getCommand('--json cloud redis show'),
+			description: 'Show Redis URL as JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe(
+					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
+				),
+		}),
+		response: RedisGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, opts, options, orgId, region, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
+
+		const resources = await tui.spinner({
+			message: `Fetching Redis for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		if (!resources.redis) {
+			tui.info('No Redis provisioned for this organization');
+			return { url: undefined };
+		}
+
+		const shouldShowCredentials = opts.showCredentials === true;
+		const shouldMask = !options.json && !shouldShowCredentials;
+
+		if (!options.json) {
+			const displayUrl = shouldMask ? tui.maskSecret(resources.redis.url) : resources.redis.url;
+			tui.output(tui.bold('Redis URL: ') + displayUrl);
+		}
+
+		return {
+			url: resources.redis.url,
+		};
+	},
+});

package/src/cmd/cloud/redis/index.ts

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../types';
+import { showSubcommand } from './get';
+import { getCommand } from '../../../command-prefix';
+
+export const redisCommand = createCommand({
+	name: 'redis',
+	description: 'Manage Redis resources',
+	tags: ['slow', 'requires-auth'],
+	examples: [
+		{ command: getCommand('cloud redis show'), description: 'Show Redis connection URL' },
+	],
+	subcommands: [showSubcommand],
+});

package/src/cmd/upgrade/index.ts

@@ -300,7 +300,7 @@ export const command = createCommand({
 			if (!force) {
 				tui.info(`Current version: ${tui.muted(currentVersion)}`);
 				tui.info(`Latest version:  ${tui.bold(latestVersion)}`);
-				tui.info('');
+				tui.newline();
 
 				const shouldUpgrade = await tui.confirm('Do you want to upgrade?', true);
 

package/src/index.ts

@@ -104,6 +104,10 @@ export type {
 	Profile,
 	AuthData,
 	CommandSchemas,
+	BuildPhase,
+	BuildContext,
+	BuildConfig,
+	BuildConfigFunction,
 } from './types';
 export { createSubcommand, createCommand } from './types';
 export type { ColorScheme } from './terminal';

package/src/tui.ts

@@ -346,6 +346,14 @@ export function newline(): void {
 	process.stderr.write('\n');
 }
 
+/**
+ * Print plain text output without any prefix or icon
+ * Use for primary command output that shouldn't have semantic formatting
+ */
+export function output(message: string): void {
+	console.log(message);
+}
+
 /**
  * Get the display width of a string, handling ANSI codes and OSC 8 hyperlinks
  *