@agentuity/cli 0.0.101 → 0.0.103

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

@@ -5,10 +5,43 @@
  */
 
 import { join } from 'node:path';
-import type { InlineConfig } from 'vite';
+import { existsSync, renameSync, rmSync } from 'node:fs';
+import type { InlineConfig, Plugin } from 'vite';
 import type { Logger } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
 
+/**
+ * Vite plugin to flatten the output structure for index.html
+ *
+ * When root is set to the project root (for TanStack Router compatibility),
+ * Vite outputs index.html to .agentuity/client/src/web/index.html instead of
+ * .agentuity/client/index.html. This plugin moves it to the expected location.
+ */
+function flattenHtmlOutputPlugin(outDir: string): Plugin {
+	return {
+		name: 'agentuity:flatten-html-output',
+		apply: 'build',
+		closeBundle() {
+			const nestedHtmlPath = join(outDir, 'src', 'web', 'index.html');
+			const targetHtmlPath = join(outDir, 'index.html');
+
+			if (existsSync(nestedHtmlPath)) {
+				renameSync(nestedHtmlPath, targetHtmlPath);
+
+				// Clean up empty src/web directory structure
+				const srcWebDir = join(outDir, 'src', 'web');
+				const srcDir = join(outDir, 'src');
+				try {
+					rmSync(srcWebDir, { recursive: true, force: true });
+					rmSync(srcDir, { recursive: true, force: true });
+				} catch {
+					// Ignore cleanup errors
+				}
+			}
+		},
+	};
+}
+
 export interface ViteBuildOptions {
 	rootDir: string;
 	mode: 'client' | 'server' | 'workbench';
@@ -34,38 +67,40 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 
 	// For server mode, use Bun.build (preserves process.env at runtime)
 	if (mode === 'server') {
-		try {
-			const srcDir = join(rootDir, 'src');
-
-			// Generate documentation files (if they don't exist)
-			const { generateDocumentation } = await import('./docs-generator');
-			await generateDocumentation(srcDir, logger);
-
-			// Generate lifecycle types (if setup() exists)
-			const { generateLifecycleTypes } = await import('./lifecycle-generator');
-			await generateLifecycleTypes(rootDir, srcDir, logger);
-
-			// Then, generate the entry file
-			const { generateEntryFile } = await import('../entry-generator');
-			await generateEntryFile({
-				rootDir,
-				projectId,
-				deploymentId: deploymentId || '',
-				logger,
-				mode: dev ? 'dev' : 'prod',
-			});
-
-			// Finally, 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: %s', error);
-			throw error;
+		const srcDir = join(rootDir, 'src');
+
+		// Generate documentation files (if they don't exist)
+		const { generateDocumentation } = await import('./docs-generator');
+		await generateDocumentation(srcDir, logger);
+
+		// Generate/update prompt files in dev mode only (non-blocking)
+		if (dev) {
+			import('./prompt-generator')
+				.then(({ generatePromptFiles }) => generatePromptFiles(srcDir, logger))
+				.catch((err) => logger.warn('Failed to generate prompt files: %s', err.message));
 		}
+
+		// Generate lifecycle types (if setup() exists)
+		const { generateLifecycleTypes } = await import('./lifecycle-generator');
+		await generateLifecycleTypes(rootDir, srcDir, logger);
+
+		// Then, generate the entry file
+		const { generateEntryFile } = await import('../entry-generator');
+		await generateEntryFile({
+			rootDir,
+			projectId,
+			deploymentId: deploymentId || '',
+			logger,
+			mode: dev ? 'dev' : 'prod',
+		});
+
+		// Finally, build with Bun.build
+		const { installExternalsAndBuild } = await import('./server-bundler');
+		await installExternalsAndBuild({
+			rootDir,
+			dev,
+			logger,
+		});
 		return;
 	}
 
@@ -85,7 +120,8 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const { workbenchEnabled = false, workbenchRoute = '/workbench' } = options;
 
 		// Load custom user plugins from agentuity.config.ts if it exists
-		const plugins = [react(), browserEnvPlugin()];
+		const clientOutDir = join(rootDir, '.agentuity/client');
+		const plugins = [react(), browserEnvPlugin(), flattenHtmlOutputPlugin(clientOutDir)];
 		const { loadAgentuityConfig } = await import('./config-loader');
 		const userConfig = await loadAgentuityConfig(rootDir, logger);
 		const userPlugins = userConfig?.plugins || [];
@@ -104,14 +140,18 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		}
 
 		// Determine CDN base URL for production builds
+		// Use CDN for all non-dev builds with a deploymentId (including local region)
 		const isLocalRegion = options.region === 'local';
+		const cdnDomain = isLocalRegion
+			? 'localstack-static-assets.t3.storage.dev'
+			: 'static.agentuity.com';
 		const cdnBaseUrl =
-			!dev && deploymentId && !isLocalRegion
-				? `https://static.agentuity.com/${deploymentId}/client/`
-				: undefined;
+			!dev && deploymentId ? `https://${cdnDomain}/${deploymentId}/client/` : undefined;
 
 		viteConfig = {
-			root: join(rootDir, 'src', 'web'), // Set web dir as root
+			// Use project root as Vite root so plugins (e.g., TanStack Router) resolve paths
+			// from the repo root, matching where agentuity.config.ts is located
+			root: rootDir,
 			plugins,
 			envPrefix: ['VITE_', 'AGENTUITY_PUBLIC_', 'PUBLIC_'],
 			publicDir: join(rootDir, 'src', 'web', 'public'),
@@ -126,7 +166,7 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 					: 'undefined',
 			},
 			build: {
-				outDir: join(rootDir, '.agentuity/client'),
+				outDir: clientOutDir,
 				rollupOptions: {
 					input: htmlPath,
 				},
@@ -177,20 +217,15 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 	}
 
 	// Build with Vite
-	try {
-		// Force the build to use the correct mode
-		const buildMode = dev ? 'development' : 'production';
+	// Force the build to use the correct mode
+	const buildMode = dev ? 'development' : 'production';
 
-		await viteBuild({
-			...viteConfig,
-			mode: buildMode,
-		});
+	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;
-	}
+	logger.debug(`Vite build complete for mode: ${mode}`);
 }
 
 interface BuildResult {
@@ -255,20 +290,15 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	// 2. 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;
-		}
+		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;
 	} else {
 		logger.debug('Skipping client build - no src/web/index.html found');
 	}
@@ -276,33 +306,23 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	// 3. 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;
-		}
+		const started = Date.now();
+		await runViteBuild({
+			...options,
+			mode: 'workbench',
+			workbenchRoute: workbenchConfig.route,
+			workbenchEnabled: true,
+		});
+		result.workbench.included = true;
+		result.workbench.duration = Date.now() - started;
 	}
 
 	// 4. 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;
-	}
+	const serverStarted = Date.now();
+	await runViteBuild({ ...options, mode: 'server' });
+	result.server.included = true;
+	result.server.duration = Date.now() - serverStarted;
 
 	// 5. Generate metadata (after all builds complete)
 	logger.debug('Generating metadata...');

package/src/cmd/cloud/deploy.ts

@@ -14,6 +14,7 @@ import {
 	stepSuccess,
 	stepSkipped,
 	stepError,
+	pauseStepUI,
 	type Step,
 	type StepContext,
 } from '../../steps';
@@ -41,7 +42,7 @@ import {
 import { zipDir } from '../../utils/zip';
 import { encryptFIPSKEMDEMStream } from '../../crypto/box';
 import { getCommand } from '../../command-prefix';
-import { checkCustomDomainForDNS } from './domain';
+import * as domain from '../../domain';
 import { DeployOptionsSchema } from '../../schemas/deploy';
 import { ErrorCode } from '../../errors';
 
@@ -107,6 +108,35 @@ export const deploySubcommand = createSubcommand({
 		let statusResult: DeploymentStatusResult | undefined;
 		const logs: string[] = [];
 
+		// Check for pre-created deployment from CI/Nova
+		const deploymentEnv = process.env.AGENTUITY_DEPLOYMENT;
+		let useExistingDeployment = false;
+		if (deploymentEnv) {
+			const ExistingDeploymentSchema = z.object({
+				id: z.string(),
+				orgId: z.string(),
+				publicKey: z.string(),
+			});
+			try {
+				const parsed = JSON.parse(deploymentEnv);
+				const result = ExistingDeploymentSchema.safeParse(parsed);
+				if (result.success) {
+					deployment = result.data;
+					useExistingDeployment = true;
+					logger.info(`Using existing deployment: ${result.data.id}`);
+				} else {
+					const errors = result.error.issues
+						.map((i) => `${i.path.join('.')}: ${i.message}`)
+						.join(', ');
+					logger.warn(`Invalid AGENTUITY_DEPLOYMENT schema: ${errors}`);
+				}
+			} catch (err) {
+				logger.warn(
+					`Failed to parse AGENTUITY_DEPLOYMENT: ${err instanceof Error ? err.message : String(err)}`
+				);
+			}
+		}
+
 		const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
 
 		// Ensure SDK key is present before proceeding
@@ -124,24 +154,20 @@ export const deploySubcommand = createSubcommand({
 					!project.deployment?.domains?.length
 						? null
 						: {
-								label: `Validate Custom Domain${project.deployment.domains.length > 1 ? `s: ${project.deployment.domains.join(', ')}` : `: ${project.deployment.domains[0]}`}`,
+								label: `Validate Custom ${tui.plural(project.deployment.domains.length, 'Domain', 'Domains')}`,
 								run: async () => {
 									if (project.deployment?.domains?.length) {
-										const result = await checkCustomDomainForDNS(
-											project.projectId,
-											project.deployment.domains,
-											config
-										);
-										for (const r of result) {
-											if (r.success) {
-												continue;
-											}
-											if (r.message) {
-												return stepError(r.message);
-											}
-											return stepError('unknown dns error'); // shouldn't get here
+										try {
+											await domain.promptForDNS(
+												project.projectId,
+												project.deployment.domains,
+												config!,
+												() => pauseStepUI(true)
+											);
+											return stepSuccess();
+										} catch (ex) {
+											return stepError(String(ex), ex as Error);
 										}
-										return stepSuccess();
 									}
 									return stepSkipped();
 								},
@@ -186,6 +212,9 @@ export const deploySubcommand = createSubcommand({
 					{
 						label: 'Create Deployment',
 						run: async () => {
+							if (useExistingDeployment && deployment) {
+								return stepSkipped('using existing deployment');
+							}
 							try {
 								deployment = await projectDeploymentCreate(
 									apiClient,
@@ -334,6 +363,7 @@ export const deploySubcommand = createSubcommand({
 							}
 
 							progress(80);
+							let bytes = 0;
 							if (build?.assets) {
 								ctx.logger.trace(`Uploading ${build.assets.length} assets`);
 								if (!instructions.assets) {
@@ -343,9 +373,9 @@ export const deploySubcommand = createSubcommand({
 								}
 
 								// Workaround for Bun crash in compiled executables (https://github.com/agentuity/sdk/issues/191)
-								// Use limited concurrency (2 at a time) for executables to avoid parallel fetch crash
+								// Use limited concurrency (1 at a time) for executables to avoid parallel fetch crash
 								const isExecutable = isRunningFromExecutable();
-								const concurrency = isExecutable ? 2 : build.assets.length;
+								const concurrency = isExecutable ? 1 : Math.min(4, build.assets.length);
 
 								if (isExecutable) {
 									ctx.logger.trace(
@@ -367,15 +397,34 @@ export const deploySubcommand = createSubcommand({
 										}
 
 										// Asset filename already includes the subdirectory (e.g., "client/assets/main-abc123.js")
-										const file = Bun.file(join(projectDir, '.agentuity', asset.filename));
+										const filePath = join(projectDir, '.agentuity', asset.filename);
+
+										const headers: Record<string, string> = {
+											'Content-Type': asset.contentType,
+										};
+
+										bytes += asset.size;
+
+										let body: Uint8Array | Blob;
+										if (asset.contentEncoding === 'gzip') {
+											const file = Bun.file(filePath);
+											const ab = await file.arrayBuffer();
+											const gzipped = Bun.gzipSync(new Uint8Array(ab));
+											headers['Content-Encoding'] = 'gzip';
+											body = gzipped;
+											ctx.logger.trace(
+												`Compressing ${asset.filename} (${asset.size} -> ${gzipped.byteLength} bytes)`
+											);
+										} else {
+											body = Bun.file(filePath);
+										}
+
 										promises.push(
 											fetch(assetUrl, {
 												method: 'PUT',
 												duplex: 'half',
-												headers: {
-													'Content-Type': asset.contentType,
-												},
-												body: file,
+												headers,
+												body,
 											})
 										);
 									}
@@ -392,7 +441,14 @@ export const deploySubcommand = createSubcommand({
 							}
 
 							progress(100);
-							return stepSuccess();
+							const output = build?.assets.length
+								? [
+										tui.muted(
+											`✓ Uploaded ${build.assets.length} ${tui.plural(build.assets.length, 'asset', 'assets')} (${tui.formatBytes(bytes)}) to CDN`
+										),
+									]
+								: undefined;
+							return stepSuccess(output);
 						},
 					},
 					{
@@ -406,7 +462,7 @@ export const deploySubcommand = createSubcommand({
 						},
 					},
 				].filter(Boolean) as Step[],
-				options.logLevel
+				useExistingDeployment ? 'debug' : options.logLevel
 			);
 
 			if (!deployment) {
@@ -617,20 +673,36 @@ export const deploySubcommand = createSubcommand({
 
 			// Show deployment URLs
 			if (complete?.publicUrls) {
+				const lines: string[] = [];
 				if (complete.publicUrls.custom?.length) {
 					for (const url of complete.publicUrls.custom) {
-						tui.arrow(tui.bold(tui.padRight('Deployment URL:', 17)) + tui.link(url));
+						lines.push(
+							`${tui.ICONS.arrow} ${tui.bold(tui.padRight('Deployment:', 12)) + tui.link(url)}`
+						);
 					}
 				} else {
-					tui.arrow(
-						tui.bold(tui.padRight('Deployment URL:', 17)) +
+					lines.push(
+						`${tui.ICONS.arrow} ${
+							tui.bold(tui.padRight('Deployment:', 12)) +
 							tui.link(complete.publicUrls.deployment)
+						}`
 					);
-					tui.arrow(
-						tui.bold(tui.padRight('Project URL:', 17)) + tui.link(complete.publicUrls.latest)
+					lines.push(
+						`${tui.ICONS.arrow} ${
+							tui.bold(tui.padRight('Project:', 12)) + tui.link(complete.publicUrls.latest)
+						}`
 					);
-					tui.arrow(tui.bold(tui.padRight('Dashboard URL:', 17)) + tui.link(dashboard));
 				}
+				lines.push(
+					`${tui.ICONS.arrow} ${
+						tui.bold(tui.padRight('Dashboard:', 12)) + tui.link(dashboard)
+					}`
+				);
+				tui.banner(`Deployment: ${tui.colorPrimary(deployment.id)}`, lines.join('\n'), {
+					centerTitle: false,
+					topSpacer: false,
+					bottomSpacer: false,
+				});
 			}
 
 			return {

package/src/cmd/cloud/keyvalue/create-namespace.ts

@@ -37,7 +37,9 @@ export const createNamespaceSubcommand = createCommand({
 		const kv = await createStorageAdapter(ctx);
 
 		await kv.createNamespace(args.name);
-		tui.success(`Namespace ${tui.bold(args.name)} created`);
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} created`);
+		}
 
 		return {
 			success: true,

package/src/cmd/cloud/keyvalue/delete-namespace.ts

@@ -68,7 +68,9 @@ export const deleteNamespaceSubcommand = createCommand({
 		}
 
 		await kv.deleteNamespace(args.name);
-		tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		}
 
 		return {
 			success: true,

package/src/cmd/cloud/keyvalue/delete.ts

@@ -39,7 +39,9 @@ export const deleteSubcommand = createCommand({
 		const storage = await createStorageAdapter(ctx);
 		await storage.delete(args.namespace, args.key);
 		const durationMs = Date.now() - started;
-		tui.success(`deleted in ${durationMs.toFixed(1)}ms`);
+		if (!ctx.options.json) {
+			tui.success(`deleted in ${durationMs.toFixed(1)}ms`);
+		}
 
 		return {
 			success: true,

package/src/cmd/cloud/keyvalue/set.ts

@@ -47,7 +47,7 @@ export const setSubcommand = createCommand({
 	},
 
 	async handler(ctx) {
-		const { args } = ctx;
+		const { args, options } = ctx;
 		const started = Date.now();
 		const storage = await createStorageAdapter(ctx);
 		const contentType = isPossiblyJSON(args.value) ? 'application/json' : 'text/plain';
@@ -57,7 +57,9 @@ export const setSubcommand = createCommand({
 			ttl,
 		});
 		const durationMs = Date.now() - started;
-		tui.success(`saved in ${durationMs.toFixed(1)}ms (${contentType})`);
+		if (!options.json) {
+			tui.success(`saved in ${durationMs.toFixed(1)}ms (${contentType})`);
+		}
 
 		return {
 			success: true,

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

@@ -3,13 +3,6 @@ import { createCommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createStorageAdapter } from './util';
 import { getCommand } from '../../../command-prefix';
-function formatBytes(bytes: number): string {
-	if (bytes === 0) return '0 B';
-	if (bytes < 1024) return `${bytes} B`;
-	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} KB`;
-	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
-}
 
 const GetStreamResponseSchema = z.object({
 	id: z.string().describe('Stream ID'),
@@ -70,7 +63,7 @@ export const getSubcommand = createCommand({
 				const durationMs = Date.now() - started;
 				const stats = await Bun.file(opts.output).stat();
 				tui.success(
-					`downloaded ${formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
+					`downloaded ${tui.formatBytes(stats.size)} to ${opts.output} in ${durationMs.toFixed(1)}ms`
 				);
 
 				// Fetch stream metadata to populate the response
@@ -100,7 +93,7 @@ export const getSubcommand = createCommand({
 
 			console.log(`Name:     ${tui.bold(stream.name ?? 'unknown')}`);
 			console.log(`ID:       ${stream.id}`);
-			console.log(`Size:     ${formatBytes(sizeBytes)}`);
+			console.log(`Size:     ${tui.formatBytes(sizeBytes)}`);
 			console.log(`URL:      ${tui.link(stream.url ?? 'unknown')}`);
 			if (stream.metadata && Object.keys(stream.metadata).length > 0) {
 				console.log(`Metadata:`);

package/src/cmd/cloud/vector/delete-namespace.ts

@@ -0,0 +1,89 @@
+import { z } from 'zod';
+import { createCommand } from '../../../types';
+import { ErrorCode } from '../../../errors';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+export const deleteNamespaceSubcommand = createCommand({
+	name: 'delete-namespace',
+	aliases: ['rm-namespace'],
+	description: 'Delete a vector namespace and all its vectors',
+	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
+	idempotent: true,
+	requires: { auth: true, project: true },
+	examples: [
+		{
+			command: getCommand('vector delete-namespace staging'),
+			description: 'Delete staging namespace (interactive)',
+		},
+		{
+			command: getCommand('vector rm-namespace cache --confirm'),
+			description: 'Delete cache without confirmation',
+		},
+		{
+			command: getCommand('vector delete-namespace old-data --confirm'),
+			description: 'Force delete old-data namespace',
+		},
+	],
+	schema: {
+		args: z.object({
+			name: z.string().min(1).describe('the namespace name to delete'),
+		}),
+		options: z.object({
+			confirm: z
+				.boolean()
+				.optional()
+				.default(false)
+				.describe('if true will not prompt for confirmation'),
+		}),
+		response: z.object({
+			success: z.boolean().describe('Whether the deletion succeeded'),
+			namespace: z.string().describe('Deleted namespace name'),
+			message: z.string().optional().describe('Confirmation message'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { args, opts } = ctx;
+		const storage = await createStorageAdapter(ctx);
+
+		if (!opts.confirm) {
+			if (!process.stdin.isTTY) {
+				tui.fatal(
+					'No TTY and --confirm is not set. Refusing to delete',
+					ErrorCode.VALIDATION_FAILED
+				);
+			}
+			tui.warning(
+				`This will delete namespace ${tui.bold(args.name)} and ALL its vectors permanently.`
+			);
+			const confirm = await new Promise<boolean>((resolve) => {
+				process.stdout.write('Are you sure? (yes/no): ');
+				process.stdin.once('data', (data) => {
+					const answer = data.toString().trim().toLowerCase();
+					resolve(answer === 'yes' || answer === 'y');
+				});
+			});
+
+			if (!confirm) {
+				tui.info('Cancelled');
+				return { success: false, namespace: args.name, message: 'Cancelled' };
+			}
+		}
+
+		await storage.deleteNamespace(args.name);
+
+		if (!ctx.options.json) {
+			tui.success(`Namespace ${tui.bold(args.name)} deleted`);
+		}
+
+		return {
+			success: true,
+			namespace: args.name,
+			message: `Namespace ${args.name} deleted`,
+		};
+	},
+});
+
+export default deleteNamespaceSubcommand;