@agentuity/cli 0.1.13 → 0.1.15

package/src/cmd/ai/opencode/install.ts

@@ -0,0 +1,120 @@
+import { mkdirSync, writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = join(OPENCODE_CONFIG_DIR, 'opencode.json');
+
+export const installSubcommand = createSubcommand({
+	name: 'install',
+	description: 'Install Agentuity Open Code plugin',
+	tags: ['fast'],
+	requires: { auth: true, apiClient: true, org: true },
+	examples: [
+		{
+			command: getCommand('ai opencode install'),
+			description: 'Install Agentuity Open Code plugin',
+		},
+	],
+	async handler(ctx: CommandContext<{ auth: true; apiClient: true; org: true }>) {
+		const { options, orgId } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Installing Agentuity Open Code plugin'));
+			tui.newline();
+			tui.success(`Using organization: ${orgId}`);
+		}
+
+		const pluginEntry = '@agentuity/opencode';
+
+		// Update Open Code config if needed
+		let openCodeUpdated = false;
+		if (!existsSync(OPENCODE_CONFIG_DIR)) {
+			mkdirSync(OPENCODE_CONFIG_DIR, { recursive: true });
+		}
+
+		let openCodeConfig: { plugin?: string[]; $schema?: string } = {};
+		if (existsSync(OPENCODE_CONFIG_FILE)) {
+			try {
+				const content = readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
+				openCodeConfig = JSON.parse(content);
+			} catch {
+				openCodeConfig = {};
+			}
+		}
+
+		if (!openCodeConfig.plugin) {
+			openCodeConfig.plugin = [];
+		}
+
+		// Check if the exact plugin entry already exists
+		const hasExactEntry = openCodeConfig.plugin.includes(pluginEntry);
+
+		// Check if there's an existing entry that needs updating
+		const existingIndex = openCodeConfig.plugin.findIndex((p) => p === '@agentuity/opencode');
+
+		if (hasExactEntry) {
+			if (!jsonMode) {
+				tui.info('Open Code plugin already configured');
+			}
+		} else if (existingIndex >= 0) {
+			// Update existing entry to new value
+			openCodeConfig.plugin[existingIndex] = pluginEntry;
+			writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+			if (!jsonMode) {
+				tui.success(`Updated Open Code plugin to: ${pluginEntry}`);
+			}
+			openCodeUpdated = true;
+		} else {
+			// Add new entry
+			openCodeConfig.plugin.push(pluginEntry);
+			writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+			if (!jsonMode) {
+				tui.success(`Added ${pluginEntry} to Open Code config`);
+			}
+			openCodeUpdated = true;
+		}
+
+		// Summary (TUI only)
+		if (!jsonMode) {
+			tui.newline();
+			if (openCodeUpdated) {
+				tui.output(tui.bold('Agentuity Open Code plugin installed successfully!'));
+			} else {
+				tui.output(tui.bold('Agentuity Open Code plugin already installed'));
+			}
+
+			tui.newline();
+			tui.info('Next steps:');
+			tui.output(`  ${tui.ICONS.bullet} Start Open Code to use Agentuity Coder agents`);
+			tui.output(
+				`  ${tui.ICONS.bullet} Run ${tui.bold(getCommand('ai opencode run "<task>"'))} to execute tasks`
+			);
+			tui.newline();
+
+			tui.output(tui.muted('Recommended MCP servers for Scout/Expert agents:'));
+			tui.output(tui.muted('Add to your opencode.json:'));
+			tui.newline();
+			tui.output(tui.muted('  "mcp": {'));
+			tui.output(
+				tui.muted(
+					'    "context7": { "type": "remote", "url": "https://mcp.context7.com/mcp" },'
+				)
+			);
+			tui.output(
+				tui.muted('    "grep_app": { "type": "remote", "url": "https://mcp.grep.app" }')
+			);
+			tui.output(tui.muted('  }'));
+			tui.newline();
+		}
+
+		return { success: true, orgId };
+	},
+});
+
+export default installSubcommand;

package/src/cmd/ai/opencode/run.ts

@@ -0,0 +1,103 @@
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import { z } from 'zod';
+
+const RunArgsSchema = z.object({
+	task: z.string().describe('The task description to execute'),
+});
+
+const RunOptionsSchema = z.object({
+	sandbox: z.boolean().optional().describe('Run in a cloud sandbox environment'),
+	json: z.boolean().optional().describe('Output raw JSON events'),
+});
+
+export const runSubcommand = createSubcommand({
+	name: 'run',
+	description: 'Run a task with the Agentuity Coder agent team (non-interactive)',
+	tags: ['slow'],
+	requires: { auth: true },
+	schema: {
+		args: RunArgsSchema,
+		options: RunOptionsSchema,
+	},
+	examples: [
+		{
+			command: getCommand('ai opencode run "implement dark mode toggle"'),
+			description: 'Run a coding task',
+		},
+		{
+			command: getCommand('ai opencode run --sandbox "run the test suite"'),
+			description: 'Run in a cloud sandbox',
+		},
+		{
+			command: getCommand('ai opencode run --json "fix the bug"'),
+			description: 'Output raw JSON events',
+		},
+	],
+	async handler(
+		ctx: CommandContext<{ auth: true }, undefined, typeof RunArgsSchema, typeof RunOptionsSchema>
+	) {
+		const { logger, args, opts } = ctx;
+		const { task } = args;
+		const sandbox = opts?.sandbox;
+		const json = opts?.json;
+
+		if (!json) {
+			tui.newline();
+			tui.output(tui.bold('Agentuity Coder'));
+			tui.newline();
+			tui.output(`${tui.ICONS.arrow} Running task: ${task}`);
+			if (sandbox) {
+				tui.info('Sandbox mode enabled');
+			}
+			tui.newline();
+		}
+
+		const openCodeArgs = ['run', '--agent', 'Agentuity Coder Lead'];
+
+		if (json) {
+			openCodeArgs.push('--format', 'json');
+		}
+
+		// Build the task prompt with any mode prefixes
+		let taskPrompt = task;
+		if (sandbox) {
+			taskPrompt = `[SANDBOX MODE: Execute all code in an Agentuity cloud sandbox, not locally] ${taskPrompt}`;
+		}
+		if (json) {
+			taskPrompt = `[JSON OUTPUT: Your final response MUST be a valid JSON object with this structure: {"status": "success" | "failed" | "partial", "summary": "Brief description of what was done", "filesChanged": ["path/to/file.ts"], "errors": ["error message if any"], "payload": <any task-specific return data or null>}. Output ONLY the JSON, no other text.] ${taskPrompt}`;
+		}
+
+		openCodeArgs.push(taskPrompt);
+
+		logger.debug(`Spawning: opencode ${openCodeArgs.join(' ')}`);
+
+		const proc = Bun.spawn(['opencode', ...openCodeArgs], {
+			stdio: ['inherit', 'inherit', 'inherit'],
+			env: {
+				...process.env,
+				AGENTUITY_CODER_MODE: 'non-interactive',
+			},
+		});
+
+		const exitCode = await proc.exited;
+
+		// In JSON mode, let opencode's output speak for itself - exit code indicates success
+		if (json) {
+			process.exit(exitCode);
+		}
+
+		if (exitCode === 0) {
+			tui.newline();
+			tui.success('Task completed');
+		} else {
+			tui.newline();
+			tui.error(`Task failed with exit code ${exitCode}`);
+		}
+
+		return { success: exitCode === 0, task, exitCode, sandbox: !!sandbox };
+	},
+});
+
+export default runSubcommand;

package/src/cmd/ai/opencode/uninstall.ts

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+
+const OPENCODE_CONFIG_DIR = join(homedir(), '.config', 'opencode');
+const OPENCODE_CONFIG_FILE = join(OPENCODE_CONFIG_DIR, 'opencode.json');
+
+export const uninstallSubcommand = createSubcommand({
+	name: 'uninstall',
+	description: 'Uninstall Agentuity Open Code plugin',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai opencode uninstall'),
+			description: 'Uninstall Agentuity Open Code plugin',
+		},
+	],
+	async handler(ctx) {
+		const { options } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Uninstalling Agentuity Open Code plugin'));
+			tui.newline();
+		}
+
+		let removedFromOpenCode = false;
+
+		// Remove from OpenCode config
+		if (!existsSync(OPENCODE_CONFIG_FILE)) {
+			if (!jsonMode) {
+				tui.info('Open Code config not found - nothing to uninstall');
+			}
+		} else {
+			try {
+				const content = readFileSync(OPENCODE_CONFIG_FILE, 'utf-8');
+				const openCodeConfig: { plugin?: string[]; $schema?: string } = JSON.parse(content);
+
+				if (!openCodeConfig.plugin || openCodeConfig.plugin.length === 0) {
+					if (!jsonMode) {
+						tui.info('No plugins configured in Open Code');
+					}
+				} else {
+					const originalLength = openCodeConfig.plugin.length;
+					openCodeConfig.plugin = openCodeConfig.plugin.filter(
+						(p) => p !== '@agentuity/opencode'
+					);
+
+					if (openCodeConfig.plugin.length < originalLength) {
+						writeFileSync(OPENCODE_CONFIG_FILE, JSON.stringify(openCodeConfig, null, 2));
+						if (!jsonMode) {
+							tui.success('Removed Agentuity Open Code plugin');
+						}
+						removedFromOpenCode = true;
+					} else {
+						if (!jsonMode) {
+							tui.info('Agentuity Open Code plugin not found');
+						}
+					}
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warn(`Failed to parse Open Code config: ${error}`);
+				}
+			}
+		}
+
+		if (!jsonMode) {
+			tui.newline();
+
+			if (removedFromOpenCode) {
+				tui.output(tui.bold('Agentuity Open Code plugin uninstalled successfully'));
+			} else {
+				tui.output(tui.bold('Agentuity Open Code plugin was not installed'));
+			}
+
+			tui.newline();
+			tui.info(`To reinstall, run: ${tui.bold(getCommand('ai opencode install'))}`);
+			tui.newline();
+		}
+
+		return { success: true, removedFromOpenCode };
+	},
+});
+
+export default uninstallSubcommand;

package/src/cmd/auth/index.ts

@@ -5,6 +5,7 @@ import { logoutCommand } from './logout';
 import { signupCommand } from './signup';
 import { whoamiCommand } from './whoami';
 import { sshSubcommand } from './ssh';
+import { orgSubcommand } from './org';
 import { getCommand } from '../../command-prefix';
 
 export const command = createCommand({
@@ -14,6 +15,7 @@ export const command = createCommand({
 	examples: [
 		{ command: getCommand('auth login'), description: 'Login to your account' },
 		{ command: getCommand('auth whoami'), description: 'Show current user info' },
+		{ command: getCommand('auth org select'), description: 'Set default organization' },
 	],
 	subcommands: [
 		apikeyCommand,
@@ -22,5 +24,6 @@ export const command = createCommand({
 		signupCommand,
 		whoamiCommand,
 		sshSubcommand,
+		orgSubcommand,
 	],
 });

package/src/cmd/auth/org/index.ts

@@ -0,0 +1,142 @@
+import { z } from 'zod';
+import { createSubcommand, createCommand } from '../../../types';
+import { getCommand } from '../../../command-prefix';
+import { saveOrgId, clearOrgId } from '../../../config';
+import * as tui from '../../../tui';
+import { listOrganizations } from '@agentuity/server';
+
+const selectCommand = createSubcommand({
+	name: 'select',
+	description: 'Set the default organization for all commands',
+	tags: ['fast', 'requires-auth'],
+	requires: { auth: true, apiClient: true },
+	examples: [
+		{ command: getCommand('auth org select'), description: 'Select default organization' },
+		{
+			command: getCommand('auth org select org_abc123'),
+			description: 'Set specific organization as default',
+		},
+	],
+	schema: {
+		args: z.object({
+			org_id: z.string().optional().describe('Organization ID to set as default'),
+		}),
+		response: z.object({
+			orgId: z.string().describe('The selected organization ID'),
+			name: z.string().describe('The organization name'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { apiClient, args, options } = ctx;
+		const argOrgId = args.org_id;
+
+		const orgs = await tui.spinner({
+			message: 'Fetching organizations',
+			clearOnSuccess: true,
+			callback: () => listOrganizations(apiClient),
+		});
+
+		if (orgs.length === 0) {
+			tui.fatal('No organizations found for your account');
+		}
+
+		let selectedOrgId = argOrgId;
+
+		if (selectedOrgId) {
+			const org = orgs.find((o) => o.id === selectedOrgId);
+			if (!org) {
+				tui.fatal(
+					`Organization '${selectedOrgId}' not found. Use '${getCommand('auth org select')}' to see available organizations.`
+				);
+			}
+		} else {
+			if (!process.stdin.isTTY) {
+				tui.fatal(
+					'Organization ID required in non-interactive mode. Usage: ' +
+						getCommand('auth org select <org_id>')
+				);
+			}
+			selectedOrgId = await tui.selectOrganization(orgs);
+		}
+
+		await saveOrgId(selectedOrgId);
+
+		const selectedOrg = orgs.find((o) => o.id === selectedOrgId)!;
+
+		if (!options.json) {
+			tui.success(`Default organization set to ${tui.bold(selectedOrg.name)}`);
+		}
+
+		return { orgId: selectedOrgId, name: selectedOrg.name };
+	},
+});
+
+const unselectCommand = createSubcommand({
+	name: 'unselect',
+	description: 'Clear the default organization preference',
+	tags: ['fast'],
+	examples: [
+		{ command: getCommand('auth org unselect'), description: 'Clear default organization' },
+	],
+	schema: {
+		response: z.object({
+			cleared: z.boolean().describe('Whether the preference was cleared'),
+		}),
+	},
+
+	async handler(ctx) {
+		const { options, config } = ctx;
+
+		const hadOrg = !!config?.preferences?.orgId;
+		await clearOrgId();
+
+		if (!options.json) {
+			if (hadOrg) {
+				tui.success('Default organization cleared');
+			} else {
+				tui.info('No default organization was set');
+			}
+		}
+
+		return { cleared: hadOrg };
+	},
+});
+
+const currentCommand = createSubcommand({
+	name: 'current',
+	description: 'Show the current default organization',
+	tags: ['read-only', 'fast'],
+	idempotent: true,
+	examples: [
+		{ command: getCommand('auth org current'), description: 'Show default organization' },
+		{ command: getCommand('auth org current --json'), description: 'Show output in JSON format' },
+	],
+	schema: {
+		response: z.string().nullable().describe('The current organization ID or null if not set'),
+	},
+
+	async handler(ctx) {
+		const { options, config } = ctx;
+		const orgId = config?.preferences?.orgId || null;
+
+		if (!options.json) {
+			if (orgId) {
+				console.log(orgId);
+			}
+		}
+
+		return orgId;
+	},
+});
+
+export const orgSubcommand = createCommand({
+	name: 'org',
+	description: 'Manage default organization preference',
+	tags: ['fast'],
+	examples: [
+		{ command: getCommand('auth org select'), description: 'Set default organization' },
+		{ command: getCommand('auth org current'), description: 'Show current default' },
+	],
+	subcommands: [selectCommand, unselectCommand, currentCommand],
+});

package/src/cmd/build/vite/beacon-plugin.ts

@@ -0,0 +1,164 @@
+/**
+ * Vite plugin to emit the analytics beacon as a hashed CDN asset
+ *
+ * This plugin:
+ * 1. Reads the pre-built beacon from @agentuity/frontend
+ * 2. Emits it as a Rollup asset with content-based hashing
+ * 3. Injects a <script data-agentuity-beacon> tag into the HTML
+ */
+
+import type { Plugin, ResolvedConfig } from 'vite';
+import { join } from 'node:path';
+import { createRequire } from 'node:module';
+
+export interface BeaconPluginOptions {
+	/** Whether analytics is enabled */
+	enabled: boolean;
+}
+
+/**
+ * Read the pre-built beacon script from @agentuity/frontend package
+ * @param projectRoot - The root directory of the project (for resolving node_modules)
+ */
+async function readBeaconScript(projectRoot: string): Promise<string> {
+	let frontendPath: string | null = null;
+
+	// Strategy 1: Use Bun.resolve (works with workspaces and symlinks)
+	try {
+		frontendPath = await Bun.resolve('@agentuity/frontend', projectRoot);
+	} catch {
+		// Not found from project root
+	}
+
+	// Strategy 2: Try from this file's directory (for installed CLI case)
+	if (!frontendPath) {
+		try {
+			const thisDir = new URL('.', import.meta.url).pathname;
+			frontendPath = await Bun.resolve('@agentuity/frontend', thisDir);
+		} catch {
+			// Not found from CLI directory
+		}
+	}
+
+	// Strategy 3: Fallback to createRequire for Node.js compatibility
+	if (!frontendPath) {
+		try {
+			const projectRequire = createRequire(join(projectRoot, 'package.json'));
+			frontendPath = projectRequire.resolve('@agentuity/frontend');
+		} catch {
+			// Not found via createRequire
+		}
+	}
+
+	if (!frontendPath) {
+		throw new Error(
+			'Could not resolve @agentuity/frontend. Ensure the package is installed and built.'
+		);
+	}
+
+	// The beacon.js file is in the dist folder of @agentuity/frontend
+	// frontendPath points to dist/index.js, so we go up one level
+	const packageDir = join(frontendPath, '..');
+	const beaconPath = join(packageDir, 'beacon.js');
+
+	const beaconFile = Bun.file(beaconPath);
+	if (!(await beaconFile.exists())) {
+		throw new Error(
+			`Beacon script not found at ${beaconPath}. Run "bun run build" in @agentuity/frontend first.`
+		);
+	}
+
+	return beaconFile.text();
+}
+
+/**
+ * Vite plugin that emits the analytics beacon as a hashed asset
+ * and injects a script tag into the HTML
+ */
+export function beaconPlugin(options: BeaconPluginOptions): Plugin {
+	const { enabled } = options;
+
+	let resolvedConfig: ResolvedConfig | null = null;
+	let beaconReferenceId: string | null = null;
+
+	return {
+		name: 'agentuity:beacon',
+		apply: 'build',
+
+		configResolved(config) {
+			resolvedConfig = config;
+		},
+
+		async buildStart() {
+			if (!enabled) return;
+
+			try {
+				// Get project root from Vite config
+				const projectRoot = resolvedConfig?.root || process.cwd();
+				const beaconCode = await readBeaconScript(projectRoot);
+
+				// Emit the beacon as an asset - Rollup will hash it
+				beaconReferenceId = this.emitFile({
+					type: 'asset',
+					name: 'agentuity-beacon.js',
+					source: beaconCode,
+				});
+			} catch (error) {
+				this.error(
+					`Failed to read beacon script: ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		},
+
+		// Use transformIndexHtml hook to modify the HTML
+		// This is called during the HTML transformation phase and works with Vite's HTML pipeline
+		transformIndexHtml: {
+			order: 'post',
+			handler(html, ctx) {
+				if (!enabled || !beaconReferenceId) return html;
+
+				// Get the final hashed filename using the bundle from the context
+				// We need to use ctx.bundle to access the emitted file
+				const bundle = ctx.bundle;
+				if (!bundle) return html;
+
+				// Find our beacon asset in the bundle
+				let beaconFileName: string | null = null;
+				for (const fileName of Object.keys(bundle)) {
+					if (fileName.includes('agentuity-beacon') && fileName.endsWith('.js')) {
+						beaconFileName = fileName;
+						break;
+					}
+				}
+
+				if (!beaconFileName) return html;
+
+				// Build the beacon URL using Vite's configured base (respects CDN URL)
+				// resolvedConfig.base is e.g., "https://cdn.agentuity.com/{deploymentId}/client/" or "/"
+				const base = resolvedConfig?.base || '/';
+				// Normalize: ensure base ends with / and beaconFileName doesn't start with /
+				const normalizedBase = base.endsWith('/') ? base : `${base}/`;
+				const normalizedFileName = beaconFileName.startsWith('/')
+					? beaconFileName.slice(1)
+					: beaconFileName;
+				const beaconUrl = `${normalizedBase}${normalizedFileName}`;
+
+				// Inject a marker script tag
+				// The script must be sync (no async/defer) to patch history API before router loads
+				// Use data-agentuity-beacon attribute as a marker for config/session injection
+				const beaconScript = `<script data-agentuity-beacon src="${beaconUrl}"></script>`;
+
+				// Inject before </head>
+				if (html.includes('</head>')) {
+					return html.replace('</head>', `${beaconScript}</head>`);
+				}
+				// Fallback: inject at start of body
+				if (html.includes('<body')) {
+					return html.replace(/<body([^>]*)>/, `<body$1>${beaconScript}`);
+				}
+
+				return beaconScript + html;
+			},
+		},
+	};
+}

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

@@ -10,6 +10,7 @@ import { createRequire } from 'node:module';
 import type { InlineConfig, Plugin } from 'vite';
 import type { Logger, DeployOptions } from '../../../types';
 import { browserEnvPlugin } from './browser-env-plugin';
+import { beaconPlugin } from './beacon-plugin';
 import type { BuildReportCollector } from '../../../build-report';
 
 /**
@@ -55,6 +56,8 @@ export interface ViteBuildOptions {
 	deploymentId?: string;
 	workbenchRoute?: string;
 	workbenchEnabled?: boolean;
+	/** Whether analytics is enabled (for beacon injection in client build) */
+	analyticsEnabled?: boolean;
 	logger: Logger;
 	deploymentOptions?: DeployOptions;
 	/** Optional collector for structured error reporting */
@@ -139,11 +142,21 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 		const htmlPath = join(rootDir, 'src', 'web', 'index.html');
 
 		// Use workbench config passed from runAllBuilds
-		const { workbenchEnabled = false, workbenchRoute = '/workbench' } = options;
+		const {
+			workbenchEnabled = false,
+			workbenchRoute = '/workbench',
+			analyticsEnabled = false,
+		} = options;
 
 		// Load custom user plugins from agentuity.config.ts if it exists
 		const clientOutDir = join(rootDir, '.agentuity/client');
-		const plugins = [react(), browserEnvPlugin(), flattenHtmlOutputPlugin(clientOutDir)];
+		const plugins = [
+			react(),
+			browserEnvPlugin(),
+			flattenHtmlOutputPlugin(clientOutDir),
+			// Emit analytics beacon as hashed CDN asset (prod builds only)
+			beaconPlugin({ enabled: analyticsEnabled && !dev }),
+		];
 		const { loadAgentuityConfig } = await import('./config-loader');
 		const userConfig = await loadAgentuityConfig(rootDir, logger);
 		const userPlugins = userConfig?.plugins || [];
@@ -312,6 +325,9 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 	// Check if web frontend exists
 	const hasWebFrontend = await Bun.file(join(rootDir, 'src', 'web', 'index.html')).exists();
 
+	// Check if analytics is enabled
+	const analyticsEnabled = config?.analytics !== false;
+
 	// 2. Build client (only if web frontend exists)
 	if (hasWebFrontend) {
 		logger.debug('Building client assets...');
@@ -322,6 +338,7 @@ export async function runAllBuilds(options: Omit<ViteBuildOptions, 'mode'>): Pro
 			mode: 'client',
 			workbenchEnabled: workbenchConfig.enabled,
 			workbenchRoute: workbenchConfig.route,
+			analyticsEnabled,
 		});
 		result.client.included = true;
 		result.client.duration = Date.now() - started;