@agentuity/cli 1.0.7 → 1.0.9

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

@@ -0,0 +1,26 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface ClaudeSettings {
+	permissions?: {
+		allow?: string[];
+		deny?: string[];
+	};
+	[key: string]: unknown;
+}
+
+export const CLAUDE_DIR = join(homedir(), '.claude');
+export const CLAUDE_SETTINGS_FILE = join(CLAUDE_DIR, 'settings.local.json');
+export const PLUGIN_INSTALL_DIR = join(homedir(), '.agentuity', 'plugins', 'claude-code');
+
+export const AGENTUITY_ALLOW_PERMISSIONS = [
+	'Bash(agentuity cloud *)',
+	'Bash(agentuity auth whoami *)',
+];
+
+export const AGENTUITY_DENY_PERMISSIONS = [
+	'Bash(agentuity cloud secrets *)',
+	'Bash(agentuity cloud secret *)',
+	'Bash(agentuity cloud apikey *)',
+	'Bash(agentuity auth token *)',
+];

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

@@ -0,0 +1,23 @@
+import { createCommand } from '../../../types';
+import { installSubcommand } from './install';
+import { uninstallSubcommand } from './uninstall';
+import { getCommand } from '../../../command-prefix';
+
+export const command = createCommand({
+	name: 'claude-code',
+	description: 'Agentuity Coder plugin for Claude Code',
+	tags: ['fast'],
+	examples: [
+		{
+			command: getCommand('ai claude-code install'),
+			description: 'Install Agentuity Coder plugin for Claude Code',
+		},
+		{
+			command: getCommand('ai claude-code uninstall'),
+			description: 'Uninstall Agentuity Coder plugin for Claude Code',
+		},
+	],
+	subcommands: [installSubcommand, uninstallSubcommand],
+});
+
+export default command;

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

@@ -0,0 +1,181 @@
+import { mkdirSync, writeFileSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { createSubcommand, type CommandContext } from '../../../types';
+import * as tui from '../../../tui';
+import { getCommand } from '../../../command-prefix';
+import {
+	type ClaudeSettings,
+	CLAUDE_DIR,
+	CLAUDE_SETTINGS_FILE,
+	PLUGIN_INSTALL_DIR,
+	AGENTUITY_ALLOW_PERMISSIONS,
+	AGENTUITY_DENY_PERMISSIONS,
+} from './constants';
+
+async function readClaudeSettings(): Promise<ClaudeSettings> {
+	try {
+		if (await Bun.file(CLAUDE_SETTINGS_FILE).exists()) {
+			const content = readFileSync(CLAUDE_SETTINGS_FILE, 'utf-8');
+			return JSON.parse(content);
+		}
+	} catch {
+		// invalid or missing
+	}
+	return {};
+}
+
+function writeClaudeSettings(settings: ClaudeSettings): void {
+	mkdirSync(CLAUDE_DIR, { recursive: true });
+	writeFileSync(CLAUDE_SETTINGS_FILE, JSON.stringify(settings, null, 2) + '\n');
+}
+
+function configurePermissions(settings: ClaudeSettings): number {
+	if (!settings.permissions) {
+		settings.permissions = {};
+	}
+	if (!settings.permissions.allow) {
+		settings.permissions.allow = [];
+	}
+	if (!settings.permissions.deny) {
+		settings.permissions.deny = [];
+	}
+
+	let added = 0;
+
+	for (const perm of AGENTUITY_ALLOW_PERMISSIONS) {
+		if (!settings.permissions.allow.includes(perm)) {
+			settings.permissions.allow.push(perm);
+			added++;
+		}
+	}
+
+	for (const perm of AGENTUITY_DENY_PERMISSIONS) {
+		if (!settings.permissions.deny.includes(perm)) {
+			settings.permissions.deny.push(perm);
+			added++;
+		}
+	}
+
+	return added;
+}
+
+async function installPackage(logger: { debug: (msg: string) => void }): Promise<string | null> {
+	mkdirSync(PLUGIN_INSTALL_DIR, { recursive: true });
+
+	const packageJsonPath = join(PLUGIN_INSTALL_DIR, 'package.json');
+	if (!(await Bun.file(packageJsonPath).exists())) {
+		writeFileSync(
+			packageJsonPath,
+			JSON.stringify({ name: 'agentuity-claude-code-plugin', private: true }, null, 2)
+		);
+	}
+
+	logger.debug(`Installing @agentuity/claude-code to ${PLUGIN_INSTALL_DIR}`);
+
+	const proc = Bun.spawn(['bun', 'add', '@agentuity/claude-code@latest'], {
+		cwd: PLUGIN_INSTALL_DIR,
+		stdio: ['ignore', 'pipe', 'pipe'],
+	});
+
+	await proc.exited;
+
+	const pluginPath = join(PLUGIN_INSTALL_DIR, 'node_modules', '@agentuity', 'claude-code');
+	if (await Bun.file(join(pluginPath, '.claude-plugin', 'plugin.json')).exists()) {
+		return pluginPath;
+	}
+
+	return null;
+}
+
+export const installSubcommand = createSubcommand({
+	name: 'install',
+	description: 'Install Agentuity Coder plugin for Claude Code',
+	tags: ['fast'],
+	requires: { auth: true, apiClient: true, org: true },
+	examples: [
+		{
+			command: getCommand('ai claude-code install'),
+			description: 'Install Agentuity Coder plugin for Claude Code',
+		},
+	],
+	async handler(ctx: CommandContext<{ auth: true; apiClient: true; org: true }>) {
+		const { options, orgId, logger } = ctx;
+		const jsonMode = !!options?.json;
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Installing Agentuity Coder plugin for Claude Code'));
+			tui.newline();
+			tui.success(`Using organization: ${orgId}`);
+		}
+
+		if (!jsonMode) {
+			tui.info('Installing @agentuity/claude-code package...');
+		}
+
+		const pluginPath = await installPackage(logger);
+
+		if (!pluginPath) {
+			if (jsonMode) {
+				return { success: false, orgId, error: 'Failed to install package' };
+			}
+			logger.fatal(
+				'Failed to install @agentuity/claude-code package. Make sure bun is installed and try again'
+			);
+		}
+
+		if (!jsonMode) {
+			tui.success(`Plugin installed to: ${pluginPath}`);
+		}
+
+		const settings = await readClaudeSettings();
+
+		const permissionsAdded = configurePermissions(settings);
+		if (permissionsAdded > 0) {
+			if (!jsonMode) {
+				tui.success(
+					`Configured ${permissionsAdded} permission rules for Agentuity Cloud commands`
+				);
+			}
+		} else {
+			if (!jsonMode) {
+				tui.info('Permissions already configured');
+			}
+		}
+
+		writeClaudeSettings(settings);
+
+		if (!jsonMode) {
+			tui.newline();
+			tui.output(tui.bold('Agentuity Coder plugin installed successfully!'));
+			tui.newline();
+
+			tui.info('To use the plugin, start Claude Code with:');
+			tui.output(`  ${tui.ICONS.bullet} ${tui.bold(`claude --plugin-dir ${pluginPath}`)}`);
+			tui.newline();
+
+			tui.info('Or install permanently via the Claude Code marketplace:');
+			tui.output(`  ${tui.ICONS.bullet} ${tui.bold('/plugin marketplace add agentuity/sdk')}`);
+			tui.output(
+				`  ${tui.ICONS.bullet} ${tui.bold('/plugin install agentuity-coder@agentuity')}`
+			);
+			tui.newline();
+
+			tui.info('Available commands in Claude Code:');
+			tui.output(
+				`  ${tui.ICONS.bullet} ${tui.muted('/agentuity-coder')} - Run a task with the agent team`
+			);
+			tui.output(
+				`  ${tui.ICONS.bullet} ${tui.muted('/agentuity-cadence')} - Start autonomous long-running task`
+			);
+			tui.output(
+				`  ${tui.ICONS.bullet} ${tui.muted('/agentuity-memory-save')} - Save session context to memory`
+			);
+			tui.newline();
+		}
+
+		return { success: true, orgId, pluginPath };
+	},
+});
+
+export default installSubcommand;

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/vite/db-rewrite.ts

@@ -0,0 +1,189 @@
+/**
+ * DB import rewriting helpers for the Bun.build plugin.
+ *
+ * These functions rewrite `import { SQL } from 'bun'` → `@agentuity/postgres`
+ * and `import { Pool } from 'pg'` → `@agentuity/postgres` so that
+ * the Agentuity resilient postgres driver is bundled into the server output.
+ */
+
+/**
+ * Map a file path to the appropriate Bun loader based on extension.
+ */
+export const getLoaderForPath = (filePath: string): string => {
+	if (filePath.endsWith('.tsx')) return 'tsx';
+	if (filePath.endsWith('.jsx')) return 'jsx';
+	if (filePath.endsWith('.ts')) return 'ts';
+	if (filePath.endsWith('.mts') || filePath.endsWith('.cts')) return 'ts';
+	if (filePath.endsWith('.js')) return 'js';
+	if (filePath.endsWith('.mjs')) return 'js';
+	if (filePath.endsWith('.cjs')) return 'js';
+	return 'js';
+};
+
+/**
+ * Split named import/export specifiers, moving the `targetName` specifier
+ * to the `move` list while leaving everything else in `stay`.
+ *
+ * Type-only specifiers (prefixed with `type `) always stay.
+ * Aliases (`SQL as Foo`) are matched on the import name, not the alias.
+ */
+export const rewriteNamedSpecifiers = (
+	specifiers: string,
+	targetName: string
+): {
+	stay: string[];
+	move: string[];
+	moved: boolean;
+} => {
+	const stay: string[] = [];
+	const move: string[] = [];
+	for (const raw of specifiers.split(',')) {
+		const spec = raw.trim();
+		if (!spec) continue;
+		const isType = spec.startsWith('type ');
+		const specText = isType ? spec.slice(5).trim() : spec;
+		const [importName] = specText.split(/\s+as\s+/);
+		if (!isType && importName === targetName) {
+			move.push(specText);
+		} else {
+			stay.push(spec);
+		}
+	}
+
+	return { stay, move, moved: move.length > 0 };
+};
+
+/**
+ * Rewrite `import { SQL } from 'bun'` → `import { SQL } from '@agentuity/postgres'`.
+ *
+ * - Type-only imports (`import type { SQL }`) are left untouched.
+ * - Inline type specifiers (`import { type SQL }`) are left untouched.
+ * - Mixed imports are split: non-SQL specifiers stay with `'bun'`.
+ * - Works with both single and double quotes, with or without semicolons.
+ * - Preserves leading indentation.
+ */
+export const rewriteBunImports = (contents: string): { contents: string; changed: boolean } => {
+	const bunNamedRegex =
+		/(^|\n)([\t ]*)(import|export)\s+(type\s+)?\{([^}]+)\}\s+from\s+(['"])bun\6\s*;?/g;
+	let changed = false;
+	const updated = contents.replace(
+		bunNamedRegex,
+		(match, prefix, indent, keyword, typeKeyword, specifiers) => {
+			if (typeKeyword) {
+				return match;
+			}
+			const { stay, move, moved } = rewriteNamedSpecifiers(specifiers, 'SQL');
+			if (!moved) {
+				return match;
+			}
+			changed = true;
+			const statements: string[] = [];
+			if (stay.length > 0) {
+				statements.push(`${indent}${keyword} { ${stay.join(', ')} } from 'bun';`);
+			}
+			if (move.length > 0) {
+				statements.push(
+					`${indent}${keyword} { ${move.join(', ')} } from '@agentuity/postgres';`
+				);
+			}
+			return `${prefix}${statements.join('\n')}`;
+		}
+	);
+
+	return { contents: updated, changed };
+};
+
+/**
+ * Rewrite `import { Pool } from 'pg'` → `import { Pool } from '@agentuity/postgres'`.
+ *
+ * - Type-only imports (`import type { Pool }`) are left untouched.
+ * - Namespace imports (`import * as pg`) are left untouched.
+ * - Default imports (`import pg from 'pg'`) are left untouched.
+ * - Mixed default+named imports are split correctly.
+ * - Works with both `import` and `export` statements.
+ */
+export const rewritePgImports = (contents: string): { contents: string; changed: boolean } => {
+	const importRegex = /(^|\n)([\t ]*)(import)\s+(type\s+)?([^;]+?)\s+from\s+(['"])pg\6\s*;?/g;
+	const exportRegex = /(^|\n)([\t ]*)(export)\s+(?!type\b)\{([^}]+)\}\s+from\s+(['"])pg\5\s*;?/g;
+	let changed = false;
+
+	const updatedImports = contents.replace(
+		importRegex,
+		(match, prefix, indent, keyword, typeKeyword, clause) => {
+			if (typeKeyword) {
+				return match; // import type { ... } from 'pg' — skip entirely
+			}
+			const trimmed = clause.trim();
+			if (trimmed.startsWith('*')) {
+				return match;
+			}
+
+			let defaultImport: string | undefined;
+			let namedSpecifiers: string | undefined;
+			if (trimmed.startsWith('{')) {
+				namedSpecifiers = trimmed.slice(1, trimmed.lastIndexOf('}'));
+			} else if (trimmed.includes('{')) {
+				const [defaultPart, rest] = trimmed.split('{', 2);
+				defaultImport = defaultPart.replace(/,\s*$/, '').trim();
+				namedSpecifiers = rest.slice(0, rest.lastIndexOf('}'));
+			} else {
+				defaultImport = trimmed;
+			}
+
+			const movedNamed = namedSpecifiers
+				? rewriteNamedSpecifiers(namedSpecifiers, 'Pool')
+				: { stay: [], move: [], moved: false };
+			const moveDefault = false; // Default import is the entire pg module, not Pool — keep it with 'pg'
+			const shouldMove = moveDefault || movedNamed.moved;
+
+			if (!shouldMove) {
+				return match;
+			}
+
+			changed = true;
+			const statements: string[] = [];
+			const pgNamed = movedNamed.stay;
+			const postgresNamed = movedNamed.move;
+			const pgDefault = moveDefault ? undefined : defaultImport;
+			const postgresDefault = moveDefault ? defaultImport : undefined;
+
+			if (pgDefault || pgNamed.length > 0) {
+				const parts: string[] = [];
+				if (pgDefault) parts.push(pgDefault);
+				if (pgNamed.length > 0) parts.push(`{ ${pgNamed.join(', ')} }`);
+				statements.push(`${indent}${keyword} ${parts.join(', ')} from 'pg';`);
+			}
+			if (postgresDefault || postgresNamed.length > 0) {
+				const parts: string[] = [];
+				if (postgresDefault) parts.push(postgresDefault);
+				if (postgresNamed.length > 0) parts.push(`{ ${postgresNamed.join(', ')} }`);
+				statements.push(`${indent}${keyword} ${parts.join(', ')} from '@agentuity/postgres';`);
+			}
+
+			return `${prefix}${statements.join('\n')}`;
+		}
+	);
+
+	const updatedExports = updatedImports.replace(
+		exportRegex,
+		(match, prefix, indent, keyword, specifiers) => {
+			const { stay, move, moved } = rewriteNamedSpecifiers(specifiers, 'Pool');
+			if (!moved) {
+				return match;
+			}
+			changed = true;
+			const statements: string[] = [];
+			if (stay.length > 0) {
+				statements.push(`${indent}${keyword} { ${stay.join(', ')} } from 'pg';`);
+			}
+			if (move.length > 0) {
+				statements.push(
+					`${indent}${keyword} { ${move.join(', ')} } from '@agentuity/postgres';`
+				);
+			}
+			return `${prefix}${statements.join('\n')}`;
+		}
+	);
+
+	return { contents: updatedExports, changed };
+};

package/src/cmd/build/vite/registry-generator.ts

@@ -658,6 +658,13 @@ export async function generateRouteRegistry(
 	});
 
 	if (apiRoutes.length === 0 && websocketRoutes.length === 0 && sseRoutes.length === 0) {
+		// Clean up stale routes.ts from previous builds (issue #924)
+		// When all API routes are removed, the old file would reference deleted modules
+		const generatedDir = join(srcDir, 'generated');
+		const registryPath = join(generatedDir, 'routes.ts');
+		if (existsSync(registryPath)) {
+			unlinkSync(registryPath);
+		}
 		return;
 	}