@agentuity/cli 1.0.20 → 1.0.22

package/src/cmd/build/vite/static-renderer.ts

@@ -0,0 +1,236 @@
+/**
+ * Static Renderer
+ *
+ * When `render: 'static'` is set in agentuity.config.ts, this module:
+ * 1. Runs a Vite SSR build to create a server-side entry point
+ * 2. Imports the built entry-server.js
+ * 3. Discovers routes to pre-render:
+ *    - If `routeTree` is exported: auto-discovers all non-parameterized routes
+ *    - If `getStaticPaths()` is exported: merges those paths in (for parameterized routes)
+ *    - If neither: throws an error
+ * 4. Calls render(url) for each route
+ * 5. Replaces <!--app-html--> in the client template with rendered HTML
+ * 6. Writes pre-rendered HTML files to .agentuity/client/
+ */
+
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from 'node:fs';
+import type { Logger } from '../../../types';
+import { hasFrameworkPlugin } from './config-loader';
+
+/** Minimal shape of a TanStack Router route tree node. */
+interface RouteTreeNode {
+	path?: string;
+	options?: { path?: string };
+	children?: Record<string, RouteTreeNode>;
+}
+
+/**
+ * Walks a TanStack Router route tree and extracts all non-parameterized paths.
+ * Skips layout routes (no path) and parameterized routes (containing $).
+ */
+function extractRoutePaths(node: RouteTreeNode): string[] {
+	const paths = new Set<string>();
+
+	function walk(route: RouteTreeNode) {
+		const path: string | undefined = route.path ?? route.options?.path;
+		if (path && !path.includes('$')) {
+			// Normalize: strip trailing slashes, ensure leading slash
+			const normalized = path === '/' ? '/' : path.replace(/\/+$/, '');
+			if (normalized) {
+				paths.add(normalized);
+			}
+		}
+
+		// Recurse into children (TanStack Router stores them as an object)
+		const children = route.children;
+		if (children && typeof children === 'object') {
+			for (const child of Object.values(children)) {
+				if (child) walk(child);
+			}
+		}
+	}
+
+	walk(node);
+	return [...paths].sort();
+}
+
+export interface StaticRenderOptions {
+	rootDir: string;
+	logger: Logger;
+	/** User plugins from agentuity.config.ts */
+	userPlugins: import('vite').PluginOption[];
+}
+
+export interface StaticRenderResult {
+	routes: number;
+	duration: number;
+}
+
+export async function runStaticRender(options: StaticRenderOptions): Promise<StaticRenderResult> {
+	const { rootDir, logger, userPlugins } = options;
+	const started = Date.now();
+
+	const clientDir = join(rootDir, '.agentuity/client');
+	const ssrOutDir = join(rootDir, '.agentuity/ssr');
+	const entryServerPath = join(rootDir, 'src/web/entry-server.tsx');
+	const templatePath = join(clientDir, 'index.html');
+
+	// Verify prerequisites
+	if (!existsSync(entryServerPath)) {
+		throw new Error(
+			'Static rendering requires src/web/entry-server.tsx. ' +
+				'This file must export a render(url: string) function and either ' +
+				'a routeTree for auto-discovery or getStaticPaths() for explicit paths.'
+		);
+	}
+
+	if (!existsSync(templatePath)) {
+		throw new Error(
+			'Client build must complete before static rendering. ' +
+				'No index.html found in .agentuity/client/'
+		);
+	}
+
+	// Step 1: Vite SSR build
+	// This resolves import.meta.glob, MDX imports, and other Vite-specific APIs
+	logger.debug('Running Vite SSR build for static rendering...');
+
+	const projectRequire = createRequire(join(rootDir, 'package.json'));
+	let vitePath = 'vite';
+	let reactPluginPath = '@vitejs/plugin-react';
+	try {
+		vitePath = projectRequire.resolve('vite');
+		reactPluginPath = projectRequire.resolve('@vitejs/plugin-react');
+	} catch {
+		// Use CLI's bundled version
+	}
+
+	const { build: viteBuild } = await import(vitePath);
+	const reactModule = await import(reactPluginPath);
+	const react = reactModule.default;
+
+	// Build plugin list: auto-add React if no framework plugin present
+	const plugins = [...(userPlugins || [])];
+	if (plugins.length === 0 || !hasFrameworkPlugin(plugins)) {
+		plugins.unshift(react());
+	}
+
+	await viteBuild({
+		root: rootDir,
+		plugins,
+		build: {
+			ssr: entryServerPath,
+			outDir: ssrOutDir,
+			rollupOptions: {
+				output: {
+					format: 'esm',
+				},
+			},
+		},
+		ssr: {
+			// Bundle all dependencies for SSR — we need import.meta.glob, MDX, etc.
+			// resolved at build time. Node built-ins are still externalized.
+			noExternal: true,
+		},
+		logLevel: 'warn',
+	});
+
+	// Steps 2–4: wrapped in try-finally so SSR artifacts are always cleaned up,
+	// even if an exception is thrown during module import, validation, or rendering.
+	let routeCount = 0;
+	try {
+		// Step 2: Import the built SSR entry
+		const ssrEntryPath = join(ssrOutDir, 'entry-server.js');
+		if (!existsSync(ssrEntryPath)) {
+			throw new Error(`SSR build did not produce entry-server.js at ${ssrEntryPath}`);
+		}
+
+		const ssrModule = await import(ssrEntryPath);
+
+		if (typeof ssrModule.render !== 'function') {
+			throw new Error(
+				'entry-server.tsx must export a render(url: string) function that returns HTML string'
+			);
+		}
+
+		// Step 3: Discover routes
+		// Priority: auto-discover from routeTree + merge getStaticPaths() if present
+		const discovered = new Set<string>();
+
+		// 3a. Auto-discover from exported routeTree (skips parameterized routes)
+		if (ssrModule.routeTree) {
+			const autoRoutes = extractRoutePaths(ssrModule.routeTree);
+			for (const r of autoRoutes) {
+				discovered.add(r);
+			}
+			logger.debug(`Auto-discovered ${autoRoutes.length} routes from route tree`);
+		}
+
+		// 3b. Merge paths from getStaticPaths() if exported (for parameterized routes, etc.)
+		if (typeof ssrModule.getStaticPaths === 'function') {
+			const extraRoutes = await ssrModule.getStaticPaths();
+			if (!Array.isArray(extraRoutes)) {
+				throw new Error(
+					'getStaticPaths() must return an array of URL paths (e.g., ["/", "/about"])'
+				);
+			}
+			for (const r of extraRoutes) {
+				discovered.add(r);
+			}
+			logger.debug(`getStaticPaths() added ${extraRoutes.length} paths`);
+		}
+
+		// Must have at least one source of routes
+		if (discovered.size === 0) {
+			throw new Error(
+				'No routes to pre-render. Export routeTree from entry-server.tsx for auto-discovery, ' +
+					'or export getStaticPaths() returning an array of URL paths.'
+			);
+		}
+
+		const routes: string[] = [...discovered].sort();
+		routeCount = routes.length;
+		logger.debug(`Total: ${routes.length} routes for pre-rendering`);
+
+		// Step 4: Read template and pre-render each route
+		const template = readFileSync(templatePath, 'utf-8');
+		if (!template.includes('<!--app-html-->')) {
+			logger.warn(
+				'index.html is missing the <!--app-html--> placeholder; ' +
+					'pre-rendered content will not be injected into the page.'
+			);
+		}
+
+		for (const route of routes) {
+			try {
+				const html = await ssrModule.render(route);
+				const page = template.replace('<!--app-html-->', html);
+
+				let outPath: string;
+				if (route === '/') {
+					outPath = join(clientDir, 'index.html');
+				} else {
+					const dir = join(clientDir, route.slice(1));
+					mkdirSync(dir, { recursive: true });
+					outPath = join(dir, 'index.html');
+				}
+
+				writeFileSync(outPath, page, 'utf-8');
+			} catch (err) {
+				const message = err instanceof Error ? err.message : String(err);
+				logger.warn(`Failed to render route ${route}: ${message}`);
+				// Continue rendering other routes
+			}
+		}
+	} finally {
+		// Step 5: Clean up SSR build artifacts (always runs, even on error)
+		rmSync(ssrOutDir, { recursive: true, force: true });
+	}
+
+	const duration = Date.now() - started;
+	logger.debug(`Static rendering complete: ${routeCount} routes in ${duration}ms`);
+
+	return { routes: routeCount, duration };
+}

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

@@ -302,6 +302,7 @@ interface BuildResult {
 	workbench: { included: boolean; duration: number };
 	client: { included: boolean; duration: number };
 	server: { included: boolean; duration: number };
+	static: { included: boolean; duration: number; routes: number };
 }
 
 /**
@@ -318,6 +319,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		workbench: { included: false, duration: 0 },
 		client: { included: false, duration: 0 },
 		server: { included: false, duration: 0 },
+		static: { included: false, duration: 0, routes: 0 },
 	};
 
 	// Load config to check if workbench is enabled (dev mode only)
@@ -382,6 +384,22 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 		logger.debug('Skipping client build - no src/web/index.html found');
 	}
 
+	// 2b. Static rendering (if configured)
+	if (config?.render === 'static' && hasWebFrontend) {
+		logger.debug('Running static rendering (pre-rendering all routes)...');
+		const endStaticDiagnostic = collector?.startDiagnostic('static-render');
+		const { runStaticRender } = await import('./static-renderer');
+		const staticResult = await runStaticRender({
+			rootDir,
+			logger,
+			userPlugins: config?.plugins || [],
+		});
+		result.static.included = true;
+		result.static.duration = staticResult.duration;
+		result.static.routes = staticResult.routes;
+		endStaticDiagnostic?.();
+	}
+
 	// 3. Build workbench (if enabled in config)
 	if (workbenchConfig.enabled) {
 		logger.debug('Building workbench assets...');

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

@@ -113,6 +113,13 @@ export async function viteBundle(options: ViteBundleOptions): Promise<{ output:
 		if (result.workbench.included) {
 			output.push(tui.muted(`✓ Workbench built in ${result.workbench.duration}ms`));
 		}
+		if (result.static.included) {
+			output.push(
+				tui.muted(
+					`✓ ${result.static.routes} routes pre-rendered in ${result.static.duration}ms`
+				)
+			);
+		}
 		if (result.server.included) {
 			output.push(tui.muted(`✓ Server built in ${result.server.duration}ms`));
 		}

package/src/cmd/cloud/deploy.ts

@@ -553,6 +553,7 @@ export const deploySubcommand = createSubcommand({
 											await domain.promptForDNS(
 												project.projectId,
 												project.deployment.domains,
+												project.region,
 												config!,
 												() => pauseStepUI(true)
 											);

package/src/cmd/project/add/domain.ts

@@ -95,7 +95,7 @@ export const domainSubcommand = createSubcommand({
 				message: `Checking DNS for ${domain}`,
 				clearOnSuccess: true,
 				callback: async () => {
-					return checkCustomDomainForDNS(project.projectId, [domain], config);
+					return checkCustomDomainForDNS(project.projectId, [domain], project.region, config);
 				},
 			});
 
@@ -117,11 +117,17 @@ export const domainSubcommand = createSubcommand({
 				}
 
 				tui.newline();
-				tui.warning('DNS record not yet configured. Please add the following CNAME record:');
+				tui.warning(
+					'DNS record not yet configured. Please add one of the following DNS records:'
+				);
 				tui.newline();
 				tui.output(`  ${tui.colorInfo('Domain:')}  ${tui.colorPrimary(result.domain)}`);
-				tui.output(`  ${tui.colorInfo('Type:')}    ${tui.colorPrimary(result.recordType)}`);
-				tui.output(`  ${tui.colorInfo('Target:')}  ${tui.colorPrimary(result.target)}`);
+				tui.output(`  ${tui.colorInfo('CNAME:')}   ${tui.colorPrimary(result.target)}`);
+				if (result.aRecordTarget) {
+					tui.output(
+						`  ${tui.colorInfo('A:')}       ${tui.colorPrimary(result.aRecordTarget)}`
+					);
+				}
 				tui.newline();
 
 				if (isMisconfigured(result)) {

package/src/cmd/project/domain/check.ts

@@ -39,6 +39,7 @@ export const checkSubcommand = createSubcommand({
 					domain: z.string(),
 					recordType: z.string(),
 					target: z.string(),
+					aRecordTarget: z.string().optional(),
 					status: z.string(),
 					success: z.boolean(),
 				})
@@ -69,11 +70,17 @@ export const checkSubcommand = createSubcommand({
 		}
 
 		const results = jsonMode
-			? await checkCustomDomainForDNS(project.projectId, domainsToCheck, config)
+			? await checkCustomDomainForDNS(project.projectId, domainsToCheck, project.region, config)
 			: await tui.spinner({
 					message: `Checking DNS for ${domainsToCheck.length} ${tui.plural(domainsToCheck.length, 'domain', 'domains')}`,
 					clearOnSuccess: true,
-					callback: () => checkCustomDomainForDNS(project.projectId, domainsToCheck, config),
+					callback: () =>
+						checkCustomDomainForDNS(
+							project.projectId,
+							domainsToCheck,
+							project.region,
+							config
+						),
 				});
 
 		const domainResults = results.map((r) => {
@@ -106,6 +113,7 @@ export const checkSubcommand = createSubcommand({
 				domain: r.domain,
 				recordType: r.recordType,
 				target: r.target,
+				aRecordTarget: r.aRecordTarget,
 				status,
 				statusRaw,
 				success,
@@ -116,8 +124,10 @@ export const checkSubcommand = createSubcommand({
 			tui.newline();
 			for (const r of domainResults) {
 				console.log(`  ${tui.colorInfo('Domain:')}  ${tui.colorPrimary(r.domain)}`);
-				console.log(`  ${tui.colorInfo('Type:')}    ${tui.colorPrimary(r.recordType)}`);
-				console.log(`  ${tui.colorInfo('Target:')}  ${tui.colorPrimary(r.target)}`);
+				console.log(`  ${tui.colorInfo('CNAME:')}   ${tui.colorPrimary(r.target)}`);
+				if (r.aRecordTarget) {
+					console.log(`  ${tui.colorInfo('A:')}       ${tui.colorPrimary(r.aRecordTarget)}`);
+				}
 				console.log(`  ${tui.colorInfo('Status:')}  ${r.status}`);
 				console.log();
 			}
@@ -128,7 +138,7 @@ export const checkSubcommand = createSubcommand({
 			} else {
 				const failCount = domainResults.filter((r) => !r.success).length;
 				tui.warning(
-					`${failCount} ${tui.plural(failCount, 'domain has', 'domains have')} DNS issues — add a CNAME record pointing to the target shown above`
+					`${failCount} ${tui.plural(failCount, 'domain has', 'domains have')} DNS issues — add a CNAME or A record pointing to one of the targets shown above`
 				);
 			}
 		}
@@ -138,6 +148,7 @@ export const checkSubcommand = createSubcommand({
 				domain: r.domain,
 				recordType: r.recordType,
 				target: r.target,
+				aRecordTarget: r.aRecordTarget,
 				status: r.statusRaw,
 				success: r.success,
 			})),

package/src/cmd/project/reconcile.ts

@@ -310,25 +310,28 @@ async function textPrompt(options: {
 async function importExistingProject(
 	opts: ReconcileOptions,
 	existingConfig: Project,
-	orgs: OrganizationList
+	orgs: OrganizationList,
+	options?: { skipPrompt?: boolean }
 ): Promise<ReconcileResult> {
 	const { dir, apiClient, config, logger } = opts;
 
-	tui.warning(
-		"You don't have access to this project. It may have been deleted or transferred to another organization."
-	);
-	tui.newline();
+	if (!options?.skipPrompt) {
+		tui.warning(
+			"You don't have access to this project. It may have been deleted or transferred to another organization."
+		);
+		tui.newline();
 
-	const shouldImport = await tui.confirm(
-		'Would you like to import this project to your organization?',
-		true
-	);
+		const shouldImport = await tui.confirm(
+			'Would you like to import this project to your organization?',
+			true
+		);
 
-	if (!shouldImport) {
-		return { status: 'skipped', message: 'Project import cancelled.' };
-	}
+		if (!shouldImport) {
+			return { status: 'skipped', message: 'Project import cancelled.' };
+		}
 
-	tui.newline();
+		tui.newline();
+	}
 
 	// Select org
 	const orgId = await selectOrg(orgs, config, existingConfig.orgId);
@@ -605,6 +608,21 @@ export async function runProjectImport(opts: ReconcileOptions): Promise<Reconcil
 
 			if (hasAccess) {
 				tui.info('This project is already registered and you have access to it.');
+
+				if (interactive) {
+					tui.newline();
+					const shouldReimport = await tui.confirm(
+						'Would you like to import it to a different organization?',
+						false
+					);
+					if (shouldReimport) {
+						tui.newline();
+						return await importExistingProject(opts, projectConfig, userOrgs, {
+							skipPrompt: true,
+						});
+					}
+				}
+
 				return { status: 'valid', project: projectConfig };
 			}
 

package/src/cmd/project/template-flow.ts

@@ -768,7 +768,8 @@ export async function runCreateFlow(options: CreateFlowOptions): Promise<CreateF
 		const ok = await tui.confirm('Would you like to configure DNS now?', true);
 		if (ok) {
 			tui.newline();
-			await promptForDNS(projectId, _domains, config);
+			const cloudRegion = region ?? process.env.AGENTUITY_REGION ?? 'usc';
+			await promptForDNS(projectId, _domains, cloudRegion, config);
 		}
 	}