@agentuity/cli 0.0.86 → 0.0.88

package/src/config.ts

@@ -407,81 +407,6 @@ function getPlaceholderValue(schema: z.ZodTypeAny): string {
 	}
 }
 
-function extractDefaultValue(schema: z.ZodTypeAny): unknown {
-	let unwrapped = schema;
-
-	// Unwrap optional layers
-	while (unwrapped instanceof z.ZodOptional) {
-		unwrapped = (unwrapped._def as unknown as { innerType: z.ZodTypeAny }).innerType;
-	}
-
-	// Check if it's a ZodDefault (has defaultValue in def or _def)
-	const checkDef = (obj: unknown): unknown => {
-		if (typeof obj !== 'object' || obj === null) return undefined;
-		const anyObj = obj as Record<string, unknown>;
-
-		// Check `def` property first (used in some Zod versions)
-		if ('def' in anyObj && typeof anyObj.def === 'object' && anyObj.def !== null) {
-			const def = anyObj.def as Record<string, unknown>;
-			if (def.type === 'default' && 'defaultValue' in def) {
-				const val = def.defaultValue;
-				return typeof val === 'function' ? (val as () => unknown)() : val;
-			}
-		}
-
-		// Check `_def` property (standard Zod property)
-		if ('_def' in anyObj && typeof anyObj._def === 'object' && anyObj._def !== null) {
-			const def = anyObj._def as Record<string, unknown>;
-			if (def.type === 'default' && 'defaultValue' in def) {
-				const val = def.defaultValue;
-				return typeof val === 'function' ? (val as () => unknown)() : val;
-			}
-		}
-
-		return undefined;
-	};
-
-	return checkDef(unwrapped);
-}
-
-function getValueWithDefaults(schema: z.ZodTypeAny, providedValue: unknown): unknown {
-	// If value is explicitly provided, use it
-	if (providedValue !== undefined) {
-		return providedValue;
-	}
-
-	// Try to extract default value
-	const defaultValue = extractDefaultValue(schema);
-	if (defaultValue !== undefined) {
-		return defaultValue;
-	}
-
-	// For optional fields without defaults, check if it's an object
-	let unwrapped = schema;
-	if (schema instanceof z.ZodOptional) {
-		unwrapped = (schema._def as unknown as { innerType: z.ZodTypeAny }).innerType;
-	}
-
-	// If it's an object schema, recursively populate defaults
-	if (unwrapped instanceof z.ZodObject) {
-		const shape = unwrapped.shape;
-		const result: Record<string, unknown> = {};
-		let hasAnyDefaults = false;
-
-		for (const [key, fieldSchema] of Object.entries(shape)) {
-			const fieldValue = getValueWithDefaults(fieldSchema as z.ZodTypeAny, undefined);
-			if (fieldValue !== undefined) {
-				result[key] = fieldValue;
-				hasAnyDefaults = true;
-			}
-		}
-
-		return hasAnyDefaults ? result : undefined;
-	}
-
-	return undefined;
-}
-
 export function generateYAMLTemplate(name: string): string {
 	const lines: string[] = [];
 
@@ -552,39 +477,6 @@ class ProjectConfigNotFoundExpection extends Error {
 
 type ProjectConfig = z.infer<typeof ProjectSchema>;
 
-function generateJSON5WithComments(
-	jsonSchema: string,
-	schema: z.ZodObject<z.ZodRawShape>,
-	data: Record<string, unknown>
-): string {
-	const lines: string[] = ['{'];
-	const shape = schema.shape;
-	const keys = Object.keys(shape);
-
-	lines.push(`  "$schema": "${jsonSchema}",`);
-
-	for (let i = 0; i < keys.length; i++) {
-		const key = keys[i];
-		const fieldSchema = shape[key] as z.ZodTypeAny;
-		const description = getSchemaDescription(fieldSchema);
-		const providedValue = data[key];
-
-		if (description) {
-			lines.push(`  // ${description}`);
-		}
-
-		// Get value with defaults applied
-		const valueWithDefaults = getValueWithDefaults(fieldSchema, providedValue);
-		const safeValue = valueWithDefaults === undefined ? null : valueWithDefaults;
-		const jsonValue = JSON.stringify(safeValue, null, 2).replace(/\n/g, '\n  ');
-		const comma = i < keys.length - 1 ? ',' : '';
-		lines.push(`  ${JSON.stringify(key)}: ${jsonValue}${comma}`);
-	}
-
-	lines.push('}');
-	return lines.join('\n');
-}
-
 export async function loadProjectConfig(
 	dir: string,
 	config?: Config | null
@@ -636,12 +528,11 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 
 	// generate the project config
 	const configPath = join(dir, 'agentuity.json');
-	const json5Content = generateJSON5WithComments(
-		'https://agentuity.dev/schema/cli/v1/agentuity.json',
-		ProjectSchema,
-		sanitizedConfig
-	);
-	await Bun.write(configPath, json5Content + '\n');
+	const configData = {
+		$schema: 'https://agentuity.dev/schema/cli/v1/agentuity.json',
+		...sanitizedConfig,
+	};
+	await Bun.write(configPath, JSON.stringify(configData, null, 2) + '\n');
 
 	// generate the .env file with initial secret
 	const envPath = join(dir, '.env');
@@ -656,9 +547,6 @@ export async function createProjectConfig(dir: string, config: InitialProjectCon
 	mkdirSync(vscodeDir);
 
 	const settings = {
-		'files.associations': {
-			'agentuity.json': 'jsonc',
-		},
 		'search.exclude': {
 			'**/.git/**': true,
 			'**/node_modules/**': true,
@@ -743,12 +631,15 @@ export function getCatalystAPIClient(logger: Logger, auth: AuthData, region: str
 	return new ServerAPIClient(catalystUrl, logger, auth.apiKey);
 }
 
-export function getIONHost(config: Config | null) {
-	if (config?.name === 'local') {
+export function getIONHost(config: Config | null, region: string) {
+	if (config?.overrides?.ion_url) {
+		const url = new URL(config.overrides.ion_url);
+		return url.hostname;
+	}
+	if (config?.name === 'local' || region === 'local') {
 		return 'ion.agentuity.io';
 	}
-	const url = new URL(config?.overrides?.ion_url ?? 'https://ion.agentuity.cloud');
-	return url.hostname;
+	return `ion-${region}.agentuity.cloud`;
 }
 
 export function getStreamURL(region: string, config: Config | null) {

package/src/git-helper.ts

@@ -1,17 +1,17 @@
 /**
  * Git helper utilities for detecting and using git safely.
- * 
+ *
  * On macOS, git may be a stub that triggers Xcode Command Line Tools installation popup.
  * This helper detects the real git binary and provides safe wrappers.
  */
 
 /**
  * Check if git is available and is the real git binary (not the macOS stub).
- * 
+ *
  * On macOS without Xcode CLT installed, /usr/bin/git exists but it's a stub that
  * triggers a popup asking to install developer tools. We detect this by checking
  * if Xcode Command Line Tools are installed using `xcode-select -p`.
- * 
+ *
  * @returns true if git is available and functional, false otherwise
  */
 export async function isGitAvailable(): Promise<boolean> {
@@ -28,7 +28,7 @@ export async function isGitAvailable(): Promise<boolean> {
 				stdout: 'pipe',
 				stderr: 'pipe',
 			});
-			
+
 			// If xcode-select -p fails, CLT are not installed, git is just a stub
 			if (result.exitCode !== 0) {
 				return false;

package/src/index.ts

@@ -104,6 +104,10 @@ export type {
 	Profile,
 	AuthData,
 	CommandSchemas,
+	BuildPhase,
+	BuildContext,
+	BuildConfig,
+	BuildConfigFunction,
 } from './types';
 export { createSubcommand, createCommand } from './types';
 export type { ColorScheme } from './terminal';

package/src/tui.ts

@@ -15,6 +15,25 @@ import { type APIClient as APIClientType } from './api';
 import { getExitCode } from './errors';
 import { maskSecret } from './env-util';
 
+// Install global exit handler to always restore terminal cursor
+// This ensures cursor is restored even when process.exit() is called directly
+let exitHandlerInstalled = false;
+function ensureCursorRestoration(): void {
+	if (exitHandlerInstalled) return;
+	exitHandlerInstalled = true;
+
+	const restoreCursor = () => {
+		// Restore cursor visibility
+		process.stderr.write('\x1B[?25h');
+	};
+
+	// Handle process exit
+	process.on('exit', restoreCursor);
+}
+
+// Install handler immediately when module loads
+ensureCursorRestoration();
+
 // Re-export maskSecret for convenience
 export { maskSecret };
 
@@ -327,6 +346,14 @@ export function newline(): void {
 	process.stderr.write('\n');
 }
 
+/**
+ * Print plain text output without any prefix or icon
+ * Use for primary command output that shouldn't have semantic formatting
+ */
+export function output(message: string): void {
+	console.log(message);
+}
+
 /**
  * Get the display width of a string, handling ANSI codes and OSC 8 hyperlinks
  *

package/src/types.ts

@@ -63,6 +63,79 @@ export type Config = zod.infer<typeof ConfigSchema>;
 
 export type LogLevel = 'debug' | 'trace' | 'info' | 'warn' | 'error';
 
+/**
+ * Build phases for the bundler
+ */
+export type BuildPhase = 'api' | 'web' | 'workbench';
+
+/**
+ * Context provided to the build config function
+ */
+export interface BuildContext {
+	/**
+	 * The root directory of the project
+	 */
+	rootDir: string;
+	/**
+	 * Whether this is a development build
+	 */
+	dev: boolean;
+	/**
+	 * The output directory for the build
+	 */
+	outDir: string;
+	/**
+	 * The source directory
+	 */
+	srcDir: string;
+	/**
+	 * Organization ID (if available)
+	 */
+	orgId?: string;
+	/**
+	 * Project ID (if available)
+	 */
+	projectId?: string;
+	/**
+	 * Deployment region
+	 */
+	region: string;
+	/**
+	 * Logger instance
+	 */
+	logger: Logger;
+}
+
+/**
+ * User-provided build configuration for a specific phase
+ */
+export interface BuildConfig {
+	/**
+	 * Additional Bun plugins to apply during bundling
+	 * These are added AFTER the Agentuity plugin
+	 */
+	plugins?: Array<import('bun').BunPlugin>;
+	/**
+	 * Additional external modules to exclude from bundling
+	 * These are merged with Agentuity's default externals
+	 */
+	external?: string[];
+	/**
+	 * Additional define constants for code replacement
+	 * These are merged with Agentuity's default defines
+	 * Note: Cannot override process.env.AGENTUITY_* or process.env.NODE_ENV
+	 */
+	define?: Record<string, string>;
+}
+
+/**
+ * Configuration function that users export from agentuity.config.ts
+ */
+export type BuildConfigFunction = (
+	phase: BuildPhase,
+	context: BuildContext
+) => BuildConfig | Promise<BuildConfig>;
+
 export interface Profile {
 	name: string;
 	filename: string;
@@ -89,6 +162,7 @@ export interface GlobalOptions {
 	explain?: boolean;
 	dryRun?: boolean;
 	validate?: boolean;
+	skipVersionCheck?: boolean;
 }
 
 export interface PaginationInfo {
@@ -282,6 +356,8 @@ export function createCommand<
 	banner?: true;
 	aliases?: string[];
 	hidden?: boolean;
+	executable?: boolean;
+	skipUpgradeCheck?: boolean;
 	requires?: R;
 	optional?: O;
 	examples?: CommandExample[];
@@ -318,6 +394,8 @@ type CommandDefBase =
 			description: string;
 			aliases?: string[];
 			banner?: boolean;
+			executable?: boolean;
+			skipUpgradeCheck?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];
@@ -332,6 +410,8 @@ type CommandDefBase =
 			description: string;
 			aliases?: string[];
 			banner?: boolean;
+			executable?: boolean;
+			skipUpgradeCheck?: boolean;
 			examples?: CommandExample[];
 			idempotent?: boolean;
 			prerequisites?: string[];

package/src/utils/dependency-checker.ts

@@ -0,0 +1,207 @@
+import { $ } from 'bun';
+import { join } from 'node:path';
+import { readFileSync, writeFileSync } from 'node:fs';
+import { getVersion } from '../version';
+import type { Logger } from '../types';
+
+interface PackageJson {
+	dependencies?: Record<string, string>;
+	devDependencies?: Record<string, string>;
+}
+
+export interface UpgradeResult {
+	upgraded: string[];
+	skipped: string[];
+	failed: string[];
+}
+
+/**
+ * Checks if a version specifier should be upgraded
+ * @param specifier - The version specifier from package.json (e.g., "latest", "^1.0.0", "1.2.3")
+ * @returns true if the package should be upgraded
+ */
+export function shouldUpgradeVersion(specifier: string): boolean {
+	// Always upgrade "latest" and "*"
+	if (specifier === 'latest' || specifier === '*') {
+		return true;
+	}
+
+	// Skip pinned versions (exact semver like "1.2.3")
+	if (/^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?$/.test(specifier)) {
+		return false;
+	}
+
+	// Upgrade ranges (^1.0.0, ~1.0.0, >=1.0.0, etc.)
+	// Check if the specifier is a range pattern
+	if (/^[~^>=<]/.test(specifier)) {
+		return true;
+	}
+
+	// Default to not upgrading if we can't determine
+	return false;
+}
+
+/**
+ * Check and upgrade @agentuity/* dependencies to match CLI version
+ * @param projectDir - Root directory of the user's project
+ * @param logger - Logger instance
+ * @returns Result of the upgrade operation
+ */
+export async function checkAndUpgradeDependencies(
+	projectDir: string,
+	logger: Logger
+): Promise<UpgradeResult> {
+	const result: UpgradeResult = {
+		upgraded: [],
+		skipped: [],
+		failed: [],
+	};
+
+	// Skip in CI/non-interactive environments
+	if (!process.stdin.isTTY) {
+		logger.debug('Skipping dependency check in non-interactive environment');
+		return result;
+	}
+
+	const packageJsonPath = join(projectDir, 'package.json');
+	const cliVersion = getVersion();
+
+	logger.debug('CLI version: %s', cliVersion);
+
+	// Read package.json
+	let packageJson: PackageJson;
+	try {
+		packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+	} catch (error) {
+		logger.debug('Failed to read package.json: %s', error);
+		return result;
+	}
+
+	// Collect all @agentuity/* packages and their original specifiers
+	const allDeps = {
+		...packageJson.dependencies,
+		...packageJson.devDependencies,
+	};
+
+	const agentuitPackages = Object.entries(allDeps)
+		.filter(([name]) => name.startsWith('@agentuity/'))
+		.map(([name, specifier]) => ({ name, specifier }));
+
+	if (agentuitPackages.length === 0) {
+		logger.debug('No @agentuity/* packages found in package.json');
+		return result;
+	}
+
+	// Check which packages need upgrading
+	const packagesToUpgrade = agentuitPackages.filter(({ specifier }) =>
+		shouldUpgradeVersion(specifier)
+	);
+
+	if (packagesToUpgrade.length === 0) {
+		logger.debug('All @agentuity/* packages are pinned, skipping upgrade');
+		for (const pkg of agentuitPackages) {
+			result.skipped.push(pkg.name);
+		}
+		return result;
+	}
+
+	// Check if CLI version is different from installed packages
+	let needsUpgrade = false;
+	for (const { name } of packagesToUpgrade) {
+		try {
+			const installedPackageJson = JSON.parse(
+				readFileSync(join(projectDir, 'node_modules', name, 'package.json'), 'utf-8')
+			);
+			const installedVersion: string = installedPackageJson.version;
+			if (installedVersion !== cliVersion) {
+				logger.debug(
+					'%s: installed=%s, cli=%s (needs upgrade)',
+					name,
+					installedVersion,
+					cliVersion
+				);
+				needsUpgrade = true;
+			} else {
+				logger.debug('%s: already at correct version %s', name, installedVersion);
+			}
+		} catch {
+			// Package not installed or can't read version - needs upgrade
+			logger.debug('%s: not installed or unreadable, needs upgrade', name);
+			needsUpgrade = true;
+		}
+	}
+
+	if (!needsUpgrade) {
+		logger.debug('All @agentuity/* packages are already at CLI version');
+		for (const pkg of packagesToUpgrade) {
+			result.skipped.push(pkg.name);
+		}
+		return result;
+	}
+
+	// Upgrade packages
+	logger.debug('Upgrading %d @agentuity/* package(s) to %s', packagesToUpgrade.length, cliVersion);
+
+	for (const { name } of packagesToUpgrade) {
+		try {
+			logger.debug('Installing %s@%s', name, cliVersion);
+			const installResult = await $`bun add ${name}@${cliVersion}`
+				.cwd(projectDir)
+				.quiet()
+				.nothrow();
+
+			if (installResult.exitCode !== 0) {
+				logger.error(
+					'Failed to install %s@%s: %s',
+					name,
+					cliVersion,
+					installResult.stderr.toString()
+				);
+				result.failed.push(name);
+			} else {
+				logger.debug('Successfully installed %s@%s', name, cliVersion);
+				result.upgraded.push(name);
+			}
+		} catch (_error) {
+			logger.error('Error installing %s: %s', name, _error);
+			result.failed.push(name);
+		}
+	}
+
+	// Restore original version specifiers in package.json
+	// (bun add replaces them with specific versions)
+	if (result.upgraded.length > 0) {
+		try {
+			const updatedPackageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+			let modified = false;
+
+			for (const { name, specifier } of packagesToUpgrade) {
+				// Only restore if we successfully upgraded
+				if (!result.upgraded.includes(name)) {
+					continue;
+				}
+
+				// Check both dependencies and devDependencies
+				if (updatedPackageJson.dependencies?.[name]) {
+					updatedPackageJson.dependencies[name] = specifier;
+					modified = true;
+					logger.debug('Restored %s to "%s" in dependencies', name, specifier);
+				}
+				if (updatedPackageJson.devDependencies?.[name]) {
+					updatedPackageJson.devDependencies[name] = specifier;
+					modified = true;
+					logger.debug('Restored %s to "%s" in devDependencies', name, specifier);
+				}
+			}
+
+			if (modified) {
+				writeFileSync(packageJsonPath, JSON.stringify(updatedPackageJson, null, 2) + '\n');
+				logger.debug('Restored original version specifiers in package.json');
+			}
+		} catch (_error) {
+			logger.warn('Failed to restore version specifiers in package.json: %s', _error);
+		}
+	}
+
+	return result;
+}