@agentuity/cli 1.0.8 → 1.0.10

package/src/cmd/ai/claude-code/uninstall.ts

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, rmSync } from 'node:fs';
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import {
+	type ClaudeSettings,
+	CLAUDE_SETTINGS_FILE,
+	PLUGIN_INSTALL_DIR,
+	AGENTUITY_ALLOW_PERMISSIONS,
+	AGENTUITY_DENY_PERMISSIONS,
+} from './constants';
+
+export const uninstallSubcommand = createSubcommand({
+	name: 'uninstall',
+	description: 'Uninstall Agentuity Coder plugin for Claude Code',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai claude-code uninstall'),
+			description: 'Uninstall Agentuity Coder plugin for Claude Code',
+		},
+	],
+	async handler(ctx: CommandContext) {
+		const { options } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Uninstalling Agentuity Coder plugin for Claude Code'));
+			tui.newline();
+		}
+
+		let removedPlugin = false;
+		let removedPermissions = false;
+
+		if (await Bun.file(`${PLUGIN_INSTALL_DIR}/package.json`).exists()) {
+			try {
+				rmSync(PLUGIN_INSTALL_DIR, { recursive: true, force: true });
+				removedPlugin = true;
+				if (!jsonMode) {
+					tui.success('Removed plugin installation directory');
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warning(`Failed to remove plugin directory: ${error}`);
+				}
+			}
+		} else {
+			if (!jsonMode) {
+				tui.info('Plugin installation directory not found - nothing to remove');
+			}
+		}
+
+		if (await Bun.file(CLAUDE_SETTINGS_FILE).exists()) {
+			try {
+				const content = readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8');
+				const settings: ClaudeSettings = JSON.parse(content);
+
+				if (settings.permissions) {
+					const allPerms = [...AGENTUITY_ALLOW_PERMISSIONS, ...AGENTUITY_DENY_PERMISSIONS];
+
+					if (settings.permissions.allow) {
+						const originalAllowLen = settings.permissions.allow.length;
+						settings.permissions.allow = settings.permissions.allow.filter(
+							(p) => !allPerms.includes(p)
+						);
+						if (settings.permissions.allow.length < originalAllowLen) {
+							removedPermissions = true;
+						}
+					}
+
+					if (settings.permissions.deny) {
+						const originalDenyLen = settings.permissions.deny.length;
+						settings.permissions.deny = settings.permissions.deny.filter(
+							(p) => !allPerms.includes(p)
+						);
+						if (settings.permissions.deny.length < originalDenyLen) {
+							removedPermissions = true;
+						}
+					}
+
+					if (removedPermissions) {
+						writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2) + '\n');
+						if (!jsonMode) {
+							tui.success('Removed Agentuity permissions from Claude Code settings');
+						}
+					} else {
+						if (!jsonMode) {
+							tui.info('No Agentuity permissions found in Claude Code settings');
+						}
+					}
+				}
+			} catch (error) {
+				if (!jsonMode) {
+					tui.warning(`Failed to update Claude Code settings: ${error}`);
+				}
+			}
+		} else {
+			if (!jsonMode) {
+				tui.info('Claude Code settings file not found');
+			}
+		}
+
+		if (!jsonMode) {
+			tui.newline();
+
+			if (removedPlugin || removedPermissions) {
+				tui.output(tui.bold('Agentuity Coder plugin uninstalled successfully'));
+			} else {
+				tui.output(tui.bold('Agentuity Coder plugin was not installed'));
+			}
+
+			tui.newline();
+			tui.info(`To reinstall, run: ${tui.bold(getCommand('ai claude-code install'))}`);
+			tui.newline();
+		}
+
+		return { success: true, removedPlugin, removedPermissions };
+	},
+});
+
+export default uninstallSubcommand;

package/src/cmd/ai/index.ts

@@ -3,6 +3,7 @@ import capabilitiesCommand from './capabilities';
 import promptCommand from './prompt';
 import schemaCommand from './schema';
 import opencodeCommand from './opencode';
+import claudeCodeCommand from './claude-code';
 import introSubcommand from './intro';
 import detectSubcommand from './detect';
 import { getCommand } from '../../command-prefix';
@@ -25,6 +26,10 @@ export const command = createCommand({
 			command: getCommand('ai opencode install'),
 			description: 'Install Agentuity Open Code plugin',
 		},
+		{
+			command: getCommand('ai claude-code install'),
+			description: 'Install Agentuity Coder plugin for Claude Code',
+		},
 		{
 			command: getCommand('ai capabilities show'),
 			description: 'Show CLI capabilities for AI agents',
@@ -38,6 +43,7 @@ export const command = createCommand({
 		detectSubcommand,
 		introSubcommand,
 		opencodeCommand,
+		claudeCodeCommand,
 		capabilitiesCommand,
 		promptCommand,
 		schemaCommand,

package/src/cmd/build/entry-generator.ts

@@ -252,18 +252,11 @@ if (isDevelopment() && process.env.VITE_PORT) {
 				const url = new URL(c.req.url);
 				const queryString = url.search; // Includes the '?' prefix
 
-				// Get the requested WebSocket subprotocol (Vite uses 'vite-hmr')
-				const requestedProtocol = c.req.header('sec-websocket-protocol');
-
 				const success = server.upgrade(c.req.raw, {
 					data: { type: 'vite-hmr', queryString },
-					// Echo back the requested subprotocol so the browser accepts the connection
-					headers: requestedProtocol ? {
-						'Sec-WebSocket-Protocol': requestedProtocol,
-					} : undefined,
 				});
 				if (success) {
-					otel.logger.debug('[HMR Proxy] WebSocket upgrade successful (protocol: %s)', requestedProtocol || 'none');
+					otel.logger.debug('[HMR Proxy] WebSocket upgrade successful');
 					return new Response(null);
 				}
 				otel.logger.error('[HMR Proxy] WebSocket upgrade returned false');

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

@@ -71,3 +71,40 @@ export function getWorkbenchConfig(
 		headers: workbench.headers ?? {},
 	};
 }
+
+/**
+ * Known Vite framework plugin name prefixes.
+ * Each framework's Vite plugin registers one or more plugins whose names
+ * start with these prefixes. We match against these to detect whether the
+ * user has already configured a framework plugin in their agentuity.config.ts.
+ */
+const FRAMEWORK_PLUGIN_PREFIXES = [
+	'vite:react', // @vitejs/plugin-react  (vite:react-babel, vite:react-refresh, …)
+	'vite:preact', // @preact/preset-vite
+	'vite-plugin-svelte', // @sveltejs/vite-plugin-svelte
+	'vite:vue', // @vitejs/plugin-vue      (vite:vue, vite:vue-jsx)
+	'vite-plugin-solid', // vite-plugin-solid
+	'solid', // vite-plugin-solid also uses plain "solid"
+];
+
+/**
+ * Check if the user's plugins include any known UI-framework Vite plugin
+ * (React, Svelte, Vue, Solid, Preact, …).
+ *
+ * Detection is name-based: Vite plugins expose a `name` property and every
+ * major framework plugin uses a predictable prefix. This avoids dynamically
+ * importing every possible framework just to compare names.
+ */
+export function hasFrameworkPlugin(userPlugins: import('vite').PluginOption[]): boolean {
+	const flat = (userPlugins as unknown[]).flat(Infinity).filter(Boolean);
+	return flat.some(
+		(p: unknown) =>
+			p &&
+			typeof p === 'object' &&
+			'name' in p &&
+			typeof (p as { name: unknown }).name === 'string' &&
+			FRAMEWORK_PLUGIN_PREFIXES.some((prefix) =>
+				((p as { name: string }).name).startsWith(prefix)
+			)
+	);
+}

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

@@ -316,10 +316,28 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 		},
 	};
 
+	// Detect files belonging to @agentuity/postgres or @agentuity/drizzle.
+	// Matches both published paths (node_modules/@agentuity/postgres/) and
+	// symlinked/monorepo paths (packages/postgres/dist/, packages/postgres/src/).
+	const isAgentuityPostgres = (filePath: string) =>
+		filePath.includes('/@agentuity/postgres/') ||
+		filePath.includes('\\@agentuity\\postgres\\') ||
+		filePath.includes('/packages/postgres/');
+
+	const isAgentuityDrizzle = (filePath: string) =>
+		filePath.includes('/@agentuity/drizzle/') ||
+		filePath.includes('\\@agentuity\\drizzle\\') ||
+		filePath.includes('/packages/drizzle/');
+
 	const dbRewritePlugin: BunPlugin = {
 		name: 'agentuity:db-rewrite',
 		setup(build) {
 			build.onResolve({ filter: /^drizzle-orm\/bun-sql$/ }, (args) => {
+				// Don't redirect if the importer is @agentuity/drizzle itself — that would create a cycle.
+				// Matches both published packages in node_modules and symlinked monorepo paths.
+				if (args.importer && isAgentuityDrizzle(args.importer)) {
+					return; // Let default resolution handle it
+				}
 				// Resolve to @agentuity/drizzle — the bundler will find it in node_modules
 				// and bundle it into .agentuity/app.js (NOT kept external).
 				const resolved = import.meta.resolveSync('@agentuity/drizzle', args.importer);
@@ -333,7 +351,16 @@ export async function installExternalsAndBuild(options: ServerBundleOptions): Pr
 					namespace: 'file',
 				},
 				async (args) => {
-					if (args.path.includes('/node_modules/')) {
+					// Skip node_modules and the rewrite-target packages themselves.
+					// The symlink check is needed because symlinked packages (e.g. via
+					// workspace links) resolve to paths outside node_modules/ (like
+					// ../../sdk/packages/postgres/dist/) and would otherwise be rewritten,
+					// creating circular imports (postgres importing from itself).
+					if (
+						args.path.includes('/node_modules/') ||
+						isAgentuityPostgres(args.path) ||
+						isAgentuityDrizzle(args.path)
+					) {
 						return;
 					}
 					const contents = await Bun.file(args.path).text();

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -128,24 +128,33 @@ export async function generateAssetServerConfig(
 			'process.env.NODE_ENV': JSON.stringify('development'),
 		},
 
-		// Plugins: User plugins first (e.g., Tailwind), then React and browser env
+		// Plugins: User plugins first (includes framework plugin like React/Svelte/Vue), then browser env
 		// Try project's node_modules first, fall back to CLI's bundled version
 		plugins: await (async () => {
-			const projectRequire = createRequire(join(rootDir, 'package.json'));
-			let reactPluginPath = '@vitejs/plugin-react';
-			try {
-				reactPluginPath = projectRequire.resolve('@vitejs/plugin-react');
-			} catch {
-				// Project doesn't have @vitejs/plugin-react, use CLI's bundled version
-			}
-			const reactPlugin = (await import(reactPluginPath)).default();
 			const { browserEnvPlugin } = await import('./browser-env-plugin');
 			const { publicAssetPathPlugin } = await import('./public-asset-path-plugin');
+			const { hasFrameworkPlugin } = await import('./config-loader');
+
+			// Auto-add React plugin if no framework plugin is present (backwards compatibility)
+			const resolvedUserPlugins = [...userPlugins];
+			if (resolvedUserPlugins.length === 0 || !hasFrameworkPlugin(resolvedUserPlugins)) {
+				logger.debug(
+					'No framework plugin found in agentuity.config.ts plugins, adding React automatically for dev server'
+				);
+				const projectRequire = createRequire(join(rootDir, 'package.json'));
+				let reactPluginPath = '@vitejs/plugin-react';
+				try {
+					reactPluginPath = projectRequire.resolve('@vitejs/plugin-react');
+				} catch {
+					// Project doesn't have @vitejs/plugin-react, use CLI's bundled version
+				}
+				const reactModule = await import(reactPluginPath);
+				resolvedUserPlugins.unshift(reactModule.default());
+			}
+
 			return [
-				// User-defined plugins from agentuity.config.ts (e.g., Tailwind CSS)
-				...userPlugins,
-				// React plugin for JSX/TSX transformation and Fast Refresh
-				reactPlugin,
+				// User-defined plugins from agentuity.config.ts (framework plugin + extras)
+				...resolvedUserPlugins,
 				// Browser env plugin to map process.env to import.meta.env
 				browserEnvPlugin(),
 				// Warn about incorrect public asset paths in dev mode

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

@@ -180,8 +180,24 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 
 		// Load custom user plugins from agentuity.config.ts if it exists
 		const clientOutDir = join(rootDir, '.agentuity/client');
+		const { loadAgentuityConfig, hasFrameworkPlugin } = await import('./config-loader');
+		const userConfig = await loadAgentuityConfig(rootDir, logger);
+		const userPlugins = userConfig?.plugins || [];
+
+		// Auto-add React plugin if no framework plugin is present (backwards compatibility)
+		if (userPlugins.length === 0 || !hasFrameworkPlugin(userPlugins)) {
+			logger.debug(
+				'No framework plugin found in agentuity.config.ts plugins, adding React automatically'
+			);
+			userPlugins.unshift(react());
+		}
+
+		if (userPlugins.length > 0) {
+			logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
+		}
+
 		const plugins = [
-			react(),
+			...userPlugins,
 			browserEnvPlugin(),
 			// Fix incorrect public asset paths and rewrite to CDN URLs
 			publicAssetPathPlugin({ cdnBaseUrl }),
@@ -189,13 +205,6 @@ export async function runViteBuild(options: ViteBuildOptions): Promise<void> {
 			// 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 || [];
-		plugins.push(...userPlugins);
-		if (userPlugins.length > 0) {
-			logger.debug('Loaded %d custom plugin(s) from agentuity.config.ts', userPlugins.length);
-		}
 
 		// Merge custom define values from user config
 		const userDefine = userConfig?.define || {};

package/src/cmd/dev/download.ts

@@ -1,118 +1,116 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, createReadStream, mkdirSync, rmSync } from 'node:fs';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir, platform } from 'node:os';
 import { join, dirname } from 'node:path';
 import * as tar from 'tar';
-import { downloadRelease } from '@terascope/fetch-github-release';
+import { StructuredError } from '@agentuity/core';
 import { spinner } from '../../tui';
 
-const user = 'agentuity';
-const repo = 'gravity';
-
-function filterRelease(release: { prerelease: boolean }) {
-	// Filter out prereleases.
-	return release.prerelease === false;
-}
-
-function filterAsset(asset: { name: string }): boolean {
-	// Filter out the release matching our os and architecture
-	let arch: string = process.arch;
-	if (arch === 'x64') {
-		arch = 'x86_64';
-	}
-	return asset.name.includes(arch) && asset.name.includes(platform());
-}
-
 interface GravityClient {
 	filename: string;
 	version: string;
 }
 
+const GravityVersionError = StructuredError('GravityVersionError')<{
+	status: number;
+	statusText: string;
+}>();
+const GravityDownloadError = StructuredError('GravityDownloadError')<{
+	status: number;
+	statusText: string;
+}>();
+const GravityExtractionError = StructuredError('GravityExtractionError')<{
+	path: string;
+}>();
+
+function getBaseURL(): string {
+	return process.env.AGENTUITY_SH_URL || 'https://agentuity.sh';
+}
+
 /**
  *
  * @returns full path to the downloaded file
  */
 export async function download(gravityDir: string): Promise<GravityClient> {
-	const outputdir = join(tmpdir(), randomUUID());
+	const baseURL = getBaseURL();
 
-	const res = (await spinner({
+	// Step 1: Get the latest version from agentuity.sh
+	const tag = (await spinner({
 		message: 'Checking Agentuity Gravity',
 		callback: async () => {
-			return downloadRelease(
-				user,
-				repo,
-				outputdir,
-				filterRelease,
-				filterAsset,
-				false,
-				true,
-				true,
-				''
-			);
+			const resp = await fetch(`${baseURL}/release/gravity/version`, {
+				signal: AbortSignal.timeout(10_000),
+			});
+			if (!resp.ok) {
+				throw new GravityVersionError({
+					status: resp.status,
+					statusText: resp.statusText,
+				});
+			}
+			const text = (await resp.text()).trim();
+			return text.startsWith('v') ? text : `v${text}`;
 		},
 		clearOnSuccess: true,
-	})) as { release: string; assetFileNames: string[] };
+	})) as string;
 
-	const versionTok = res.release.split('@');
-	const version = versionTok[1] ?? 'unknown';
+	const version = tag.startsWith('v') ? tag.slice(1) : tag;
 	const releaseFilename = join(gravityDir, version, 'gravity');
-	const mustDownload = !existsSync(releaseFilename);
 
-	if (!mustDownload) {
+	// Step 2: Check if already downloaded
+	if (await Bun.file(releaseFilename).exists()) {
 		return { filename: releaseFilename, version };
 	}
 
-	const downloadedFile = await spinner({
-		message: `Downloading Gravity ${version}`,
-		callback: async () => {
-			const res = (await downloadRelease(
-				user,
-				repo,
-				outputdir,
-				filterRelease,
-				filterAsset,
-				false,
-				true,
-				false,
-				''
-			)) as string[];
-			const file = res[0];
-			if (!file) {
-				throw new Error('No file downloaded from release');
-			}
-			return file;
-		},
-		clearOnSuccess: true,
-	});
+	// Step 3: Download the binary from agentuity.sh
+	const os = platform();
+	let arch: string = process.arch;
+	if (arch === 'x64') {
+		arch = 'x86_64';
+	}
 
-	if (downloadedFile.endsWith('.tar.gz')) {
+	const tmpFile = join(tmpdir(), `${randomUUID()}.tar.gz`);
+
+	try {
 		await spinner({
-			message: 'Extracting release',
+			message: `Downloading Gravity ${version}`,
 			callback: async () => {
-				return new Promise<void>((resolve, reject) => {
-					const input = createReadStream(downloadedFile);
-					const downloadDir = dirname(releaseFilename);
-					if (!existsSync(downloadDir)) {
-						mkdirSync(downloadDir, { recursive: true });
-					}
-					input.on('finish', resolve);
-					input.on('end', resolve);
-					input.on('error', reject);
-					input.pipe(tar.x({ C: downloadDir, chmod: true }));
+				const resp = await fetch(`${baseURL}/release/gravity/${tag}/${os}/${arch}`, {
+					signal: AbortSignal.timeout(60_000),
 				});
+				if (!resp.ok) {
+					throw new GravityDownloadError({
+						status: resp.status,
+						statusText: resp.statusText,
+					});
+				}
+				const buffer = await resp.arrayBuffer();
+				writeFileSync(tmpFile, Buffer.from(buffer));
 			},
 			clearOnSuccess: true,
 		});
-	} else {
-		// TODO:
-	}
 
-	if (existsSync(outputdir)) {
-		rmSync(outputdir, { recursive: true });
+		// Step 4: Extract the tarball
+		await spinner({
+			message: 'Extracting release',
+			callback: async () => {
+				const downloadDir = dirname(releaseFilename);
+				if (!(await Bun.file(downloadDir).exists())) {
+					mkdirSync(downloadDir, { recursive: true });
+				}
+				await tar.x({ file: tmpFile, cwd: downloadDir, chmod: true });
+			},
+			clearOnSuccess: true,
+		});
+	} finally {
+		// Clean up temp file regardless of success or failure
+		if (await Bun.file(tmpFile).exists()) {
+			rmSync(tmpFile);
+		}
 	}
 
-	if (!existsSync(releaseFilename)) {
-		throw new Error(`Failed to extract gravity binary to ${releaseFilename}`);
+	// Step 5: Verify the binary was extracted
+	if (!(await Bun.file(releaseFilename).exists())) {
+		throw new GravityExtractionError({ path: releaseFilename });
 	}
 
 	return { filename: releaseFilename, version };

package/src/cmd/upgrade/index.ts

@@ -71,19 +71,35 @@ export async function fetchLatestVersion(): Promise<string> {
 }
 
 /**
- * Upgrade the CLI using bun global install
+ * Upgrade the CLI using bun global install.
+ * Retries on transient resolution errors caused by npm CDN propagation delays.
  */
-async function performBunUpgrade(version: string): Promise<void> {
+async function performBunUpgrade(
+	version: string,
+	onRetry?: (attempt: number, delayMs: number) => void
+): Promise<void> {
 	// Remove 'v' prefix for npm version
 	const npmVersion = version.replace(/^v/, '');
 
-	// Use bun to install the specific version globally
-	// Run from tmpdir to avoid interference from any local package.json/node_modules
-	const result = await $`bun add -g @agentuity/cli@${npmVersion}`.cwd(tmpdir()).quiet().nothrow();
-
-	if (result.exitCode !== 0) {
-		const stderr = result.stderr.toString();
-		throw new Error(`Failed to install @agentuity/cli@${npmVersion}: ${stderr}`);
+	const { installWithRetry } = await import('./npm-availability');
+
+	try {
+		await installWithRetry(
+			async () => {
+				// Use bun to install the specific version globally
+				// Run from tmpdir to avoid interference from any local package.json/node_modules
+				const result = await $`bun add -g @agentuity/cli@${npmVersion}`
+					.cwd(tmpdir())
+					.quiet()
+					.nothrow();
+				return { exitCode: result.exitCode, stderr: result.stderr };
+			},
+			{ onRetry }
+		);
+	} catch (error) {
+		throw new Error(
+			`Failed to install @agentuity/cli@${npmVersion}: ${error instanceof Error ? error.message : String(error)}`
+		);
 	}
 }
 
@@ -194,8 +210,9 @@ export const command = createCommand({
 				callback: async () => {
 					const { waitForNpmAvailability } = await import('./npm-availability');
 					return await waitForNpmAvailability(latestVersion, {
-						maxAttempts: 6,
-						initialDelayMs: 2000,
+						maxAttempts: 10,
+						initialDelayMs: 5000,
+						maxDelayMs: 15000,
 					});
 				},
 			});
@@ -244,8 +261,14 @@ export const command = createCommand({
 
 			// Perform the upgrade using bun
 			await tui.spinner({
+				type: 'logger',
 				message: `Installing @agentuity/cli@${normalizedLatest}...`,
-				callback: async () => await performBunUpgrade(latestVersion),
+				callback: async (log) =>
+					await performBunUpgrade(latestVersion, (attempt, delayMs) => {
+						log(
+							`Package not yet available on CDN, retrying in ${Math.round(delayMs / 1000)}s (attempt ${attempt})...`
+						);
+					}),
 			});
 
 			// Verify the upgrade