@agentuity/cli 0.0.86 → 0.0.88

package/src/cmd/cloud/index.ts

@@ -1,6 +1,7 @@
 import { createCommand } from '../../types';
 import { deploySubcommand } from './deploy';
 import { dbCommand } from './db';
+import { redisCommand } from './redis';
 import { storageCommand } from './storage';
 import { sessionCommand } from './session';
 import { threadCommand } from './thread';
@@ -34,6 +35,7 @@ export const command = createCommand({
 		secretCommand,
 		deploySubcommand,
 		dbCommand,
+		redisCommand,
 		storageCommand,
 		sessionCommand,
 		threadCommand,

package/src/cmd/cloud/redis/get.ts

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+import { listResources } from '@agentuity/server';
+import { createSubcommand } from '../../../types';
+import * as tui from '../../../tui';
+import { getCatalystAPIClient } from '../../../config';
+import { getCommand } from '../../../command-prefix';
+
+const RedisGetResponseSchema = z.object({
+	url: z.string().optional().describe('Redis connection URL'),
+});
+
+export const showSubcommand = createSubcommand({
+	name: 'show',
+	aliases: ['info'],
+	description: 'Show Redis connection URL',
+	tags: ['read-only', 'fast', 'requires-auth'],
+	requires: { auth: true, org: true, region: true },
+	idempotent: true,
+	examples: [
+		{ command: getCommand('cloud redis show'), description: 'Show Redis connection URL' },
+		{
+			command: getCommand('cloud redis show --show-credentials'),
+			description: 'Show Redis URL with credentials visible',
+		},
+		{
+			command: getCommand('--json cloud redis show'),
+			description: 'Show Redis URL as JSON',
+		},
+	],
+	schema: {
+		options: z.object({
+			showCredentials: z
+				.boolean()
+				.optional()
+				.describe(
+					'Show credentials in plain text (default: masked in terminal, unmasked in JSON)'
+				),
+		}),
+		response: RedisGetResponseSchema,
+	},
+
+	async handler(ctx) {
+		const { logger, opts, options, orgId, region, auth } = ctx;
+
+		const catalystClient = getCatalystAPIClient(logger, auth, region);
+
+		const resources = await tui.spinner({
+			message: `Fetching Redis for ${orgId} in ${region}`,
+			clearOnSuccess: true,
+			callback: async () => {
+				return listResources(catalystClient, orgId, region);
+			},
+		});
+
+		if (!resources.redis) {
+			tui.info('No Redis provisioned for this organization');
+			return { url: undefined };
+		}
+
+		const shouldShowCredentials = opts.showCredentials === true;
+		const shouldMask = !options.json && !shouldShowCredentials;
+
+		if (!options.json) {
+			const displayUrl = shouldMask ? tui.maskSecret(resources.redis.url) : resources.redis.url;
+			tui.output(tui.bold('Redis URL: ') + displayUrl);
+		}
+
+		return {
+			url: resources.redis.url,
+		};
+	},
+});

package/src/cmd/cloud/redis/index.ts

@@ -0,0 +1,13 @@
+import { createCommand } from '../../../types';
+import { showSubcommand } from './get';
+import { getCommand } from '../../../command-prefix';
+
+export const redisCommand = createCommand({
+	name: 'redis',
+	description: 'Manage Redis resources',
+	tags: ['slow', 'requires-auth'],
+	examples: [
+		{ command: getCommand('cloud redis show'), description: 'Show Redis connection URL' },
+	],
+	subcommands: [showSubcommand],
+});

package/src/cmd/cloud/scp/download.ts

@@ -36,7 +36,7 @@ export const downloadCommand = createSubcommand({
 			description: 'Download multiple files',
 		},
 	],
-	requires: { apiClient: true, auth: true },
+	requires: { apiClient: true, auth: true, region: true },
 	optional: { project: true },
 	prerequisites: ['cloud deploy'],
 	schema: {
@@ -51,7 +51,7 @@ export const downloadCommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { apiClient, args, opts, project, projectDir, config } = ctx;
+		const { apiClient, args, opts, project, projectDir, config, region } = ctx;
 
 		let identifier = opts?.identifier ?? project?.projectId;
 
@@ -59,7 +59,7 @@ export const downloadCommand = createSubcommand({
 			identifier = await tui.showProjectList(apiClient, true);
 		}
 
-		const hostname = getIONHost(config);
+		const hostname = getIONHost(config, region);
 		const destination = args.destination ?? projectDir;
 
 		try {

package/src/cmd/cloud/scp/upload.ts

@@ -39,7 +39,7 @@ export const uploadCommand = createSubcommand({
 			description: 'Upload multiple files',
 		},
 	],
-	requires: { apiClient: true, auth: true },
+	requires: { apiClient: true, auth: true, region: true },
 	schema: {
 		args,
 		options,
@@ -54,7 +54,7 @@ export const uploadCommand = createSubcommand({
 	prerequisites: ['cloud deploy'],
 
 	async handler(ctx) {
-		const { apiClient, args, opts, project, projectDir, config } = ctx;
+		const { apiClient, args, opts, project, projectDir, config, region } = ctx;
 
 		let identifier = opts?.identifier ?? project?.projectId;
 
@@ -62,7 +62,7 @@ export const uploadCommand = createSubcommand({
 			identifier = await tui.showProjectList(apiClient, true);
 		}
 
-		const hostname = getIONHost(config);
+		const hostname = getIONHost(config, region);
 		const destination = args.destination ?? '.';
 
 		try {

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' },