@agentuity/cli 0.1.43 → 0.1.44

package/src/cmd/upgrade/npm-availability.ts

@@ -0,0 +1,105 @@
+/**
+ * npm registry availability checking utilities.
+ * Used to verify a version is available on npm before attempting upgrade.
+ */
+
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const PACKAGE_NAME = '@agentuity/cli';
+
+/** Default timeout for quick checks (implicit version check) */
+const QUICK_CHECK_TIMEOUT_MS = 1000;
+
+/** Default timeout for explicit upgrade command */
+const EXPLICIT_CHECK_TIMEOUT_MS = 5000;
+
+export interface CheckNpmOptions {
+	/** Timeout in milliseconds (default: 5000 for explicit, 1000 for quick) */
+	timeoutMs?: number;
+}
+
+/**
+ * Check if a specific version of @agentuity/cli is available on npm registry.
+ * Uses the npm registry API directly for faster response than `npm view`.
+ *
+ * @param version - Version to check (with or without 'v' prefix)
+ * @param options - Optional configuration
+ * @returns true if version is available, false otherwise
+ */
+export async function isVersionAvailableOnNpm(
+	version: string,
+	options: CheckNpmOptions = {}
+): Promise<boolean> {
+	const { timeoutMs = EXPLICIT_CHECK_TIMEOUT_MS } = options;
+	const normalizedVersion = version.replace(/^v/, '');
+	const url = `${NPM_REGISTRY_URL}/${encodeURIComponent(PACKAGE_NAME)}/${normalizedVersion}`;
+
+	try {
+		const response = await fetch(url, {
+			method: 'HEAD', // Only need to check existence, not full metadata
+			signal: AbortSignal.timeout(timeoutMs),
+			headers: {
+				Accept: 'application/json',
+			},
+		});
+		return response.ok;
+	} catch {
+		// Network error or timeout - assume not available
+		return false;
+	}
+}
+
+/**
+ * Quick check if a version is available on npm with a short timeout.
+ * Used for implicit version checks (auto-upgrade flow) to avoid blocking the user's command.
+ *
+ * @param version - Version to check (with or without 'v' prefix)
+ * @returns true if version is available, false if unavailable or timeout
+ */
+export async function isVersionAvailableOnNpmQuick(version: string): Promise<boolean> {
+	return isVersionAvailableOnNpm(version, { timeoutMs: QUICK_CHECK_TIMEOUT_MS });
+}
+
+export interface WaitForNpmOptions {
+	/** Maximum number of attempts (default: 6) */
+	maxAttempts?: number;
+	/** Initial delay between attempts in ms (default: 2000) */
+	initialDelayMs?: number;
+	/** Maximum delay between attempts in ms (default: 10000) */
+	maxDelayMs?: number;
+	/** Callback called before each retry */
+	onRetry?: (attempt: number, delayMs: number) => void;
+}
+
+/**
+ * Wait for a version to become available on npm with exponential backoff.
+ *
+ * @param version - Version to wait for (with or without 'v' prefix)
+ * @param options - Configuration options
+ * @returns true if version became available, false if timed out
+ */
+export async function waitForNpmAvailability(
+	version: string,
+	options: WaitForNpmOptions = {}
+): Promise<boolean> {
+	const { maxAttempts = 6, initialDelayMs = 2000, maxDelayMs = 10000, onRetry } = options;
+
+	// First check - no delay
+	if (await isVersionAvailableOnNpm(version)) {
+		return true;
+	}
+
+	// Retry with exponential backoff
+	let delay = initialDelayMs;
+	for (let attempt = 1; attempt < maxAttempts; attempt++) {
+		onRetry?.(attempt, delay);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+
+		if (await isVersionAvailableOnNpm(version)) {
+			return true;
+		}
+
+		delay = Math.min(Math.round(delay * 1.5), maxDelayMs);
+	}
+
+	return false;
+}

package/src/tui.ts

@@ -1764,9 +1764,18 @@ export async function prompt(message: string): Promise<string> {
 	});
 }
 
+/**
+ * Select an organization from a list.
+ *
+ * @param orgs - List of organizations to choose from
+ * @param initial - Preferred org ID to pre-select (from saved preferences)
+ * @param autoSelect - If true, auto-select preferred org without prompting (for --confirm or non-interactive)
+ * @returns The selected organization ID
+ */
 export async function selectOrganization(
 	orgs: OrganizationList,
-	initial?: string
+	initial?: string,
+	autoSelect?: boolean
 ): Promise<string> {
 	if (orgs.length === 0) {
 		fatal(
@@ -1775,6 +1784,7 @@ export async function selectOrganization(
 		);
 	}
 
+	// 1. Environment variable always takes precedence
 	if (process.env.AGENTUITY_CLOUD_ORG_ID) {
 		const org = orgs.find((o) => o.id === process.env.AGENTUITY_CLOUD_ORG_ID);
 		if (org) {
@@ -1782,41 +1792,59 @@ export async function selectOrganization(
 		}
 	}
 
-	// Auto-select if only one org (regardless of TTY mode)
+	// 2. Auto-select if only one org (regardless of TTY mode or autoSelect)
 	if (orgs.length === 1 && orgs[0]) {
 		return orgs[0].id;
 	}
 
-	// Use saved preference if available (regardless of TTY mode)
-	// This allows consistent behavior without prompting on every command
-	if (initial) {
-		const initialOrg = orgs.find((o) => o.id === initial);
-		if (initialOrg) {
-			return initialOrg.id;
+	// 3. Auto-select mode (--confirm flag or explicit autoSelect)
+	// Use preferred org if set, otherwise fall back to first org
+	if (autoSelect) {
+		if (initial) {
+			const initialOrg = orgs.find((o) => o.id === initial);
+			if (initialOrg) {
+				return initialOrg.id;
+			}
+		}
+		// Fall back to first org with warning
+		const firstOrg = orgs[0];
+		if (firstOrg) {
+			warning(
+				`Multiple organizations found. Auto-selecting first org: ${firstOrg.name}. ` +
+					`Set AGENTUITY_CLOUD_ORG_ID, use --org-id, or run 'agentuity auth org select' to set a default.`
+			);
+			return firstOrg.id;
 		}
 	}
 
-	// Check for non-interactive environment (check both stdin and stdout)
+	// 4. Check for non-interactive environment (check both stdin and stdout)
 	const isNonInteractive = !process.stdin.isTTY || !process.stdout.isTTY;
 	if (isNonInteractive) {
-		// In non-interactive mode with multiple orgs, auto-select first org
-		// This allows scripts and CI/CD to work without explicit org selection
+		// In non-interactive mode, use preferred org if set
+		if (initial) {
+			const initialOrg = orgs.find((o) => o.id === initial);
+			if (initialOrg) {
+				return initialOrg.id;
+			}
+		}
+		// Fall back to first org with warning
 		const firstOrg = orgs[0];
 		if (firstOrg) {
 			warning(
 				`Multiple organizations found. Auto-selecting first org: ${firstOrg.name}. ` +
-					`Set AGENTUITY_CLOUD_ORG_ID or use --org-id to specify a different org.`
+					`Set AGENTUITY_CLOUD_ORG_ID, use --org-id, or run 'agentuity auth org select' to set a default.`
 			);
 			return firstOrg.id;
 		}
 	}
 
-	// Interactive mode with no saved preference - prompt user
+	// 5. Interactive mode - show selector with preferred org pre-selected
+	const initialIndex = initial ? orgs.findIndex((o) => o.id === initial) : 0;
 	const response = await enquirer.prompt<{ action: string }>({
 		type: 'select',
 		name: 'action',
 		message: 'Select an organization',
-		initial: 0,
+		initial: initialIndex >= 0 ? initialIndex : 0,
 		choices: orgs.map((o) => ({ message: o.name, name: o.id })),
 	});
 

package/src/version-check.ts

@@ -233,18 +233,34 @@ export async function checkForUpdates(
 		const currentVersion = getVersion();
 		const latestVersion = await fetchLatestVersion();
 
-		// Update the timestamp since we successfully checked
-		await updateCheckTimestamp(config, logger);
-
 		// Compare versions
 		const normalizedCurrent = currentVersion.replace(/^v/, '');
 		const normalizedLatest = latestVersion.replace(/^v/, '');
 
 		if (normalizedCurrent === normalizedLatest) {
+			// Update timestamp - we confirmed we're on latest version
+			await updateCheckTimestamp(config, logger);
 			logger.trace('Already on latest version: %s', currentVersion);
 			return;
 		}
 
+		// Quick npm availability check before prompting (short timeout, no retries)
+		// This avoids blocking the user's command if npm is slow or version not yet available
+		const { isVersionAvailableOnNpmQuick } = await import('./cmd/upgrade/npm-availability');
+		const isAvailable = await isVersionAvailableOnNpmQuick(latestVersion);
+
+		if (!isAvailable) {
+			// Don't update timestamp - we want to check again soon since npm may propagate
+			logger.debug(
+				'Version %s not yet available on npm, skipping upgrade prompt',
+				latestVersion
+			);
+			return;
+		}
+
+		// Update timestamp - npm availability confirmed, we can proceed with prompt
+		await updateCheckTimestamp(config, logger);
+
 		// New version available - prompt user
 		const shouldUpgrade = await promptUpgrade(currentVersion, latestVersion);