@agentuity/cli 0.0.86 → 0.0.87

package/src/cmd/cloud/ssh.ts

@@ -35,13 +35,13 @@ export const sshSubcommand = createSubcommand({
 		},
 	],
 	toplevel: true,
-	requires: { auth: true, apiClient: true },
+	requires: { auth: true, apiClient: true, region: true },
 	optional: { project: true },
 	prerequisites: ['cloud deploy'],
 	schema: { args, options },
 
 	async handler(ctx) {
-		const { apiClient, project, projectDir, args, config, opts } = ctx;
+		const { apiClient, project, projectDir, args, config, opts, region } = ctx;
 
 		let projectId = project?.projectId;
 		let identifier = args?.identifier;
@@ -56,7 +56,7 @@ export const sshSubcommand = createSubcommand({
 			projectId = await tui.showProjectList(apiClient, true);
 		}
 
-		const hostname = getIONHost(config);
+		const hostname = getIONHost(config, region);
 
 		const cmd = ['ssh', `${identifier ?? projectId}@${hostname}`, command].filter(
 			Boolean

package/src/cmd/dev/index.ts

@@ -938,6 +938,17 @@ export const command = createCommand({
 						return;
 					}
 
+					// Ignore .git folder
+					if (changedFile && (changedFile === '.git' || changedFile.startsWith('.git/'))) {
+						logger.trace(
+							'File change ignored (.git folder): %s (event: %s, file: %s)',
+							watchDir,
+							eventType,
+							changedFile
+						);
+						return;
+					}
+
 					// Ignore changes in .agentuity directory (build output)
 					// Check both relative path and normalized absolute path
 					const isInAgentuityDir =

package/src/cmd/index.ts

@@ -1,4 +1,5 @@
 import type { CommandDefinition } from '../types';
+import { isRunningFromExecutable } from './upgrade';
 
 // Use dynamic imports for bundler compatibility while maintaining lazy loading
 export async function discoverCommands(): Promise<CommandDefinition[]> {
@@ -12,12 +13,19 @@ export async function discoverCommands(): Promise<CommandDefinition[]> {
 		import('./profile').then((m) => m.command),
 		import('./project').then((m) => m.command),
 		import('./repl').then((m) => m.command),
+		import('./upgrade').then((m) => m.command),
 		import('./version').then((m) => m.command),
 	]);
 
 	const commands: CommandDefinition[] = [];
+	const isExecutable = isRunningFromExecutable();
 
 	for (const cmd of commandModules) {
+		// Skip commands that require running from an executable when not in one
+		if (cmd.executable && !isExecutable) {
+			continue;
+		}
+
 		commands.push(cmd);
 
 		// Auto-create hidden top-level aliases for subcommands with toplevel: true

package/src/cmd/profile/create.ts

@@ -73,6 +73,7 @@ export const createCommand = createSubcommand({
 			if (name === 'local') {
 				// if we're creating a local profile, go ahead and fill it out for the dev to make it easier to get started
 				const localConfig = (await loadConfig(filename)) as Config;
+				localConfig.name = name;
 				localConfig.overrides = {
 					api_url: 'https://api.agentuity.io',
 					app_url: 'https://app.agentuity.io',

package/src/cmd/project/download.ts

@@ -231,7 +231,7 @@ export async function setupProject(options: SetupOptions): Promise<void> {
 	// Check for real git (not macOS stub that triggers Xcode CLT popup)
 	const { isGitAvailable, getDefaultBranch } = await import('../../git-helper');
 	const gitAvailable = await isGitAvailable();
-	
+
 	if (gitAvailable) {
 		// Get default branch from git config, fallback to 'main'
 		const defaultBranch = (await getDefaultBranch()) || 'main';

package/src/cmd/upgrade/index.ts

@@ -0,0 +1,365 @@
+import { createCommand } from '../../types';
+import { getVersion } from '../../version';
+import { getCommand } from '../../command-prefix';
+import { z } from 'zod';
+import { ErrorCode, createError, exitWithError } from '../../errors';
+import * as tui from '../../tui';
+import { downloadWithProgress } from '../../download';
+import { $ } from 'bun';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+const UpgradeOptionsSchema = z.object({
+	force: z.boolean().optional().describe('Force upgrade even if version is the same'),
+});
+
+const UpgradeResponseSchema = z.object({
+	upgraded: z.boolean().describe('Whether an upgrade was performed'),
+	from: z.string().describe('Version before upgrade'),
+	to: z.string().describe('Version after upgrade'),
+	message: z.string().describe('Status message'),
+});
+
+/**
+ * Check if running from a compiled executable (not via bun/bunx)
+ * @internal Exported for testing
+ */
+export function isRunningFromExecutable(): boolean {
+	const scriptPath = process.argv[1] || '';
+
+	// Check if running from compiled binary (uses Bun's virtual filesystem)
+	// When compiled with `bun build --compile`, the path is in the virtual /$bunfs/root/ directory
+	const isCompiledBinary = process.argv[0] === 'bun' && scriptPath.startsWith('/$bunfs/root/');
+
+	if (isCompiledBinary) {
+		return true;
+	}
+
+	// If running via bun/bunx (from node_modules or .ts files), it's not an executable
+	if (Bun.main.includes('/node_modules/') || Bun.main.includes('.ts')) {
+		return false;
+	}
+
+	// Check if in a bin directory but not in node_modules (globally installed)
+	const normalized = Bun.main;
+	const isGlobal =
+		normalized.includes('/bin/') &&
+		!normalized.includes('/node_modules/') &&
+		!normalized.includes('/packages/cli/bin');
+
+	return isGlobal;
+}
+
+/**
+ * Get the OS and architecture for downloading the binary
+ * @internal Exported for testing
+ */
+export function getPlatformInfo(): { os: string; arch: string } {
+	const platform = process.platform;
+	const arch = process.arch;
+
+	let os: string;
+	let archStr: string;
+
+	switch (platform) {
+		case 'darwin':
+			os = 'darwin';
+			break;
+		case 'linux':
+			os = 'linux';
+			break;
+		default:
+			throw new Error(`Unsupported platform: ${platform}`);
+	}
+
+	switch (arch) {
+		case 'x64':
+			archStr = 'x64';
+			break;
+		case 'arm64':
+			archStr = 'arm64';
+			break;
+		default:
+			throw new Error(`Unsupported architecture: ${arch}`);
+	}
+
+	return { os, arch: archStr };
+}
+
+/**
+ * Fetch the latest version from the API
+ * @internal Exported for testing
+ */
+export async function fetchLatestVersion(): Promise<string> {
+	const response = await fetch('https://agentuity.sh/release/sdk/version', {
+		signal: AbortSignal.timeout(10000), // 10 second timeout
+	});
+	if (!response.ok) {
+		throw new Error(`Failed to fetch version: ${response.statusText}`);
+	}
+
+	const version = await response.text();
+	const trimmedVersion = version.trim();
+
+	// Validate version format
+	if (
+		!/^v?[0-9]+\.[0-9]+\.[0-9]+/.test(trimmedVersion) ||
+		trimmedVersion.includes('message') ||
+		trimmedVersion.includes('error') ||
+		trimmedVersion.includes('<html>')
+	) {
+		throw new Error(`Invalid version format received: ${trimmedVersion}`);
+	}
+
+	// Ensure version has 'v' prefix
+	return trimmedVersion.startsWith('v') ? trimmedVersion : `v${trimmedVersion}`;
+}
+
+/**
+ * Download the binary for the specified version
+ */
+async function downloadBinary(
+	version: string,
+	platform: { os: string; arch: string }
+): Promise<string> {
+	const { os, arch } = platform;
+	const url = `https://agentuity.sh/release/sdk/${version}/${os}/${arch}`;
+
+	const tmpDir = tmpdir();
+	const tmpFile = join(tmpDir, `agentuity-${randomUUID()}`);
+	const gzFile = `${tmpFile}.gz`;
+
+	const stream = await downloadWithProgress({
+		url,
+		message: `Downloading version ${version}...`,
+	});
+
+	// Write to temp file
+	const writer = Bun.file(gzFile).writer();
+	for await (const chunk of stream) {
+		writer.write(chunk);
+	}
+	await writer.end();
+
+	// Verify file was downloaded
+	if (!(await Bun.file(gzFile).exists())) {
+		throw new Error('Download failed - file not created');
+	}
+
+	// Decompress using gunzip
+	try {
+		await $`gunzip ${gzFile}`.quiet();
+	} catch (error) {
+		if (await Bun.file(gzFile).exists()) {
+			await $`rm ${gzFile}`.quiet();
+		}
+		throw new Error(
+			`Decompression failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+		);
+	}
+
+	// Verify decompressed file exists
+	if (!(await Bun.file(tmpFile).exists())) {
+		throw new Error('Decompression failed - file not found');
+	}
+
+	// Verify it's a valid binary
+	const fileType = await $`file ${tmpFile}`.text();
+	if (!fileType.match(/(executable|ELF|Mach-O|PE32)/i)) {
+		throw new Error('Downloaded file is not a valid executable');
+	}
+
+	// Make executable
+	await $`chmod 755 ${tmpFile}`.quiet();
+
+	return tmpFile;
+}
+
+/**
+ * Validate the downloaded binary by running version command
+ */
+async function validateBinary(binaryPath: string, expectedVersion: string): Promise<void> {
+	try {
+		const result = await $`${binaryPath} version`.text();
+		const actualVersion = result.trim();
+
+		// Normalize versions for comparison (remove 'v' prefix)
+		const normalizedExpected = expectedVersion.replace(/^v/, '');
+		const normalizedActual = actualVersion.replace(/^v/, '');
+
+		if (normalizedActual !== normalizedExpected) {
+			throw new Error(`Version mismatch: expected ${expectedVersion}, got ${actualVersion}`);
+		}
+	} catch (error) {
+		if (error instanceof Error) {
+			throw new Error(`Binary validation failed: ${error.message}`);
+		}
+		throw new Error('Binary validation failed');
+	}
+}
+
+/**
+ * Replace the current binary with the new one
+ * Uses platform-specific safe replacement strategies
+ */
+async function replaceBinary(newBinaryPath: string, currentBinaryPath: string): Promise<void> {
+	const platform = process.platform;
+
+	if (platform === 'darwin' || platform === 'linux') {
+		// Unix: Use atomic move via temp file
+		const backupPath = `${currentBinaryPath}.backup`;
+		const tempPath = `${currentBinaryPath}.new`;
+
+		try {
+			// Copy new binary to temp location next to current binary
+			await $`cp ${newBinaryPath} ${tempPath}`.quiet();
+			await $`chmod 755 ${tempPath}`.quiet();
+
+			// Backup current binary
+			if (await Bun.file(currentBinaryPath).exists()) {
+				await $`cp ${currentBinaryPath} ${backupPath}`.quiet();
+			}
+
+			// Atomic rename
+			await $`mv ${tempPath} ${currentBinaryPath}`.quiet();
+
+			// Clean up backup after successful replacement
+			if (await Bun.file(backupPath).exists()) {
+				await $`rm ${backupPath}`.quiet();
+			}
+		} catch (error) {
+			// Try to restore backup if replacement failed
+			if (await Bun.file(backupPath).exists()) {
+				await $`mv ${backupPath} ${currentBinaryPath}`.quiet();
+			}
+			// Clean up temp file if it exists
+			if (await Bun.file(tempPath).exists()) {
+				await $`rm ${tempPath}`.quiet();
+			}
+			throw error;
+		}
+	} else {
+		throw new Error(`Unsupported platform for binary replacement: ${platform}`);
+	}
+}
+
+export const command = createCommand({
+	name: 'upgrade',
+	description: 'Upgrade the CLI to the latest version',
+	executable: true,
+	skipUpgradeCheck: true,
+	tags: ['update'],
+	examples: [
+		{
+			command: getCommand('upgrade'),
+			description: 'Check for updates and prompt to upgrade',
+		},
+		{
+			command: getCommand('upgrade --force'),
+			description: 'Force upgrade even if already on latest version',
+		},
+	],
+	schema: {
+		options: UpgradeOptionsSchema,
+		response: UpgradeResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, options } = ctx;
+		const { force } = ctx.opts;
+
+		const currentVersion = getVersion();
+		// Use process.execPath to get the actual file path (Bun.main is virtual for compiled binaries)
+		const currentBinaryPath = process.execPath;
+
+		try {
+			// Fetch latest version
+			const latestVersion = await tui.spinner({
+				message: 'Checking for updates...',
+				clearOnSuccess: true,
+				callback: async () => await fetchLatestVersion(),
+			});
+
+			// Compare versions
+			const normalizedCurrent = currentVersion.replace(/^v/, '');
+			const normalizedLatest = latestVersion.replace(/^v/, '');
+
+			if (normalizedCurrent === normalizedLatest && !force) {
+				const message = `Already on latest version ${currentVersion}`;
+				tui.success(message);
+				return {
+					upgraded: false,
+					from: currentVersion,
+					to: latestVersion,
+					message,
+				};
+			}
+
+			// Confirm upgrade
+			if (!force) {
+				tui.info(`Current version: ${tui.muted(currentVersion)}`);
+				tui.info(`Latest version:  ${tui.bold(latestVersion)}`);
+				tui.info('');
+
+				const shouldUpgrade = await tui.confirm('Do you want to upgrade?', true);
+
+				if (!shouldUpgrade) {
+					const message = 'Upgrade cancelled';
+					tui.info(message);
+					return {
+						upgraded: false,
+						from: currentVersion,
+						to: latestVersion,
+						message,
+					};
+				}
+			}
+
+			// Get platform info
+			const platform = getPlatformInfo();
+
+			// Download binary
+			const tmpBinaryPath = await tui.spinner({
+				type: 'progress',
+				message: 'Downloading...',
+				callback: async () => await downloadBinary(latestVersion, platform),
+			});
+
+			// Validate binary
+			await tui.spinner({
+				message: 'Validating binary...',
+				callback: async () => await validateBinary(tmpBinaryPath, latestVersion),
+			});
+
+			// Replace binary
+			await tui.spinner({
+				message: 'Installing...',
+				callback: async () => await replaceBinary(tmpBinaryPath, currentBinaryPath),
+			});
+
+			// Clean up temp file
+			if (await Bun.file(tmpBinaryPath).exists()) {
+				await $`rm ${tmpBinaryPath}`.quiet();
+			}
+
+			const message = `Successfully upgraded from ${currentVersion} to ${latestVersion}`;
+			tui.success(message);
+
+			return {
+				upgraded: true,
+				from: currentVersion,
+				to: latestVersion,
+				message,
+			};
+		} catch (error) {
+			exitWithError(
+				createError(ErrorCode.INTERNAL_ERROR, 'Upgrade failed', {
+					error: error instanceof Error ? error.message : 'Unknown error',
+				}),
+				logger,
+				options.errorFormat
+			);
+		}
+	},
+});

package/src/cmd/version/index.ts

@@ -10,6 +10,7 @@ const VersionResponseSchema = z.string().describe('CLI version number');
 export const command = createCommand({
 	name: 'version',
 	description: 'Display version information',
+	skipUpgradeCheck: true,
 	tags: ['read-only', 'fast'],
 	examples: [
 		{ command: getCommand('version'), description: 'Show the CLI semantic version' },

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/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 };