@agentuity/cli 1.0.7 → 1.0.9

package/src/cmd/cloud/storage/list.ts

@@ -69,6 +69,7 @@ export const listSubcommand = createSubcommand({
 			prefix: z.string().optional().describe('Path prefix to filter files'),
 		}),
 		options: z.object({
+			orgId: z.string().optional().describe('filter by organization id'),
 			showCredentials: z
 				.boolean()
 				.optional()
@@ -94,7 +95,7 @@ export const listSubcommand = createSubcommand({
 			message: 'Fetching storage',
 			clearOnSuccess: true,
 			callback: async () => {
-				return listOrgResources(catalystClient, { type: 's3' });
+				return listOrgResources(catalystClient, { type: 's3', orgId: opts?.orgId });
 			},
 		});
 

package/src/cmd/cloud/stream/list.ts

@@ -74,8 +74,13 @@ export const listSubcommand = createCommand({
 
 	async handler(ctx) {
 		const { opts, options, apiClient, project } = ctx;
-		// Use project context if available, or explicit flag
-		const projectId = opts.projectId || project?.projectId;
+
+		if (opts?.orgId && opts?.projectId) {
+			tui.fatal('--org-id and --project-id are mutually exclusive. Use one or the other.');
+		}
+
+		// Use explicit projectId flag; only fall back to project context when --org-id is not set
+		const projectId = opts.projectId || (opts.orgId ? undefined : project?.projectId);
 
 		// Parse metadata filter if provided
 		let metadataFilter: Record<string, string> | undefined;

package/src/cmd/cloud/thread/list.ts

@@ -70,7 +70,11 @@ export const listSubcommand = createSubcommand({
 		const { logger, auth, project, opts, options, config } = ctx;
 		const catalystClient = await getGlobalCatalystAPIClient(logger, auth, config?.name);
 
-		const projectId = opts.all ? undefined : opts.projectId || project?.projectId;
+		if (opts?.orgId && opts?.projectId) {
+			tui.fatal('--org-id and --project-id are mutually exclusive. Use one or the other.');
+		}
+
+		const projectId = opts.all || opts.orgId ? undefined : opts.projectId || project?.projectId;
 		const orgId = opts.orgId;
 
 		try {

package/src/cmd/cloud/vector/list-namespaces.ts

@@ -19,14 +19,17 @@ export const listNamespacesSubcommand = createCommand({
 		{ command: getCommand('vector ns'), description: 'List namespaces (short alias)' },
 	],
 	schema: {
+		options: z.object({
+			orgId: z.string().optional().describe('filter by organization id'),
+		}),
 		response: NamespaceListResponseSchema,
 	},
 	webUrl: '/services/vector',
 	idempotent: true,
 
 	async handler(ctx) {
-		const { options } = ctx;
-		const storage = await createStorageAdapter(ctx);
+		const { options, opts } = ctx;
+		const storage = await createStorageAdapter(ctx, opts?.orgId);
 		const namespaces = await storage.getNamespaces();
 
 		if (!options.json) {

package/src/cmd/cloud/vector/util.ts

@@ -4,15 +4,19 @@ import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../ty
 import { getCatalystUrl } from '../../../catalyst';
 import * as tui from '../../../tui';
 
-export function createStorageAdapter(ctx: {
-	logger: Logger;
-	auth: AuthData;
-	region: string;
-	project?: ProjectConfig;
-	config: Config | null;
-	options: GlobalOptions;
-}) {
+export function createStorageAdapter(
+	ctx: {
+		logger: Logger;
+		auth: AuthData;
+		region: string;
+		project?: ProjectConfig;
+		config: Config | null;
+		options: GlobalOptions;
+	},
+	explicitOrgId?: string
+) {
 	const orgId =
+		explicitOrgId ??
 		ctx.project?.orgId ??
 		ctx.options.orgId ??
 		(process.env.AGENTUITY_CLOUD_ORG_ID || ctx.config?.preferences?.orgId);

package/src/cmd/dev/index.ts

@@ -1050,6 +1050,8 @@ export const command = createCommand({
 					}
 					process.env.PORT = String(opts.port);
 					process.env.AGENTUITY_PORT = process.env.PORT;
+					process.env.AGENTUITY_BASE_URL =
+						process.env.AGENTUITY_BASE_URL || `http://localhost:${opts.port}`;
 
 					if (project) {
 						// Set environment variables for LLM provider patches

package/src/cmd/project/add/database.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { listResources } from '@agentuity/server';
+import { listResources, projectEnvUpdate } from '@agentuity/server';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createPrompt } from '../../../tui';
@@ -7,7 +7,13 @@ import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
-import { addResourceEnvVars } from '../../../env-util';
+import {
+	addResourceEnvVars,
+	findExistingEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../../env-util';
 
 export const databaseSubcommand = createSubcommand({
 	name: 'database',
@@ -42,7 +48,7 @@ export const databaseSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, orgId, region, auth, options, projectDir } = ctx;
+		const { logger, args, orgId, region, auth, options, projectDir, project } = ctx;
 
 		if (isDryRunMode(options)) {
 			const message = args.name
@@ -131,6 +137,51 @@ export const databaseSubcommand = createSubcommand({
 				tui.success(`Linked database: ${tui.bold(selectedDatabase.name)}`);
 				tui.info('Environment variables written to .env');
 			}
+
+			// Sync to cloud
+			const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
+			let shouldSync = true;
+
+			if (!isHeadless && !options.json) {
+				shouldSync = await tui.confirm('Sync environment variables to cloud project?', true);
+				if (process.stdin.isTTY) {
+					process.stdin.pause();
+				}
+			}
+
+			if (shouldSync) {
+				try {
+					const envFilePath = await findExistingEnvFile(projectDir);
+					const localEnv = await readEnvFile(envFilePath);
+					const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+					if (Object.keys(filteredEnv).length > 0) {
+						const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+						await tui.spinner({
+							message: 'Syncing environment variables to cloud',
+							clearOnSuccess: true,
+							callback: async () => {
+								await projectEnvUpdate(catalystClient, {
+									id: project.projectId,
+									env,
+									secrets,
+								});
+							},
+						});
+						if (!options.json) {
+							tui.success('Environment variables synced to cloud');
+						}
+					}
+				} catch (error) {
+					if (!options.json) {
+						tui.warning(
+							'Failed to sync environment variables to cloud. You can sync later with: ' +
+								tui.bold(getCommand('cloud env push'))
+						);
+					}
+					logger.debug('Failed to sync env to cloud:', error);
+				}
+			}
 		} else {
 			if (!options.json) {
 				tui.warning(`Database "${selectedDatabase.name}" has no environment variables to add`);

package/src/cmd/project/add/storage.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { listResources } from '@agentuity/server';
+import { listResources, projectEnvUpdate } from '@agentuity/server';
 import { createSubcommand } from '../../../types';
 import * as tui from '../../../tui';
 import { createPrompt } from '../../../tui';
@@ -7,7 +7,13 @@ import { getCatalystAPIClient } from '../../../config';
 import { getCommand } from '../../../command-prefix';
 import { isDryRunMode, outputDryRun } from '../../../explain';
 import { ErrorCode } from '../../../errors';
-import { addResourceEnvVars } from '../../../env-util';
+import {
+	addResourceEnvVars,
+	findExistingEnvFile,
+	readEnvFile,
+	filterAgentuitySdkKeys,
+	splitEnvAndSecrets,
+} from '../../../env-util';
 
 export const storageSubcommand = createSubcommand({
 	name: 'storage',
@@ -42,7 +48,7 @@ export const storageSubcommand = createSubcommand({
 	},
 
 	async handler(ctx) {
-		const { logger, args, orgId, region, auth, options, projectDir } = ctx;
+		const { logger, args, orgId, region, auth, options, projectDir, project } = ctx;
 
 		if (isDryRunMode(options)) {
 			const message = args.name
@@ -131,6 +137,51 @@ export const storageSubcommand = createSubcommand({
 				tui.success(`Linked storage bucket: ${tui.bold(selectedBucket.bucket_name)}`);
 				tui.info('Environment variables written to .env');
 			}
+
+			// Sync to cloud
+			const isHeadless = !process.stdin.isTTY || !process.stdout.isTTY;
+			let shouldSync = true;
+
+			if (!isHeadless && !options.json) {
+				shouldSync = await tui.confirm('Sync environment variables to cloud project?', true);
+				if (process.stdin.isTTY) {
+					process.stdin.pause();
+				}
+			}
+
+			if (shouldSync) {
+				try {
+					const envFilePath = await findExistingEnvFile(projectDir);
+					const localEnv = await readEnvFile(envFilePath);
+					const filteredEnv = filterAgentuitySdkKeys(localEnv);
+
+					if (Object.keys(filteredEnv).length > 0) {
+						const { env, secrets } = splitEnvAndSecrets(filteredEnv);
+						await tui.spinner({
+							message: 'Syncing environment variables to cloud',
+							clearOnSuccess: true,
+							callback: async () => {
+								await projectEnvUpdate(catalystClient, {
+									id: project.projectId,
+									env,
+									secrets,
+								});
+							},
+						});
+						if (!options.json) {
+							tui.success('Environment variables synced to cloud');
+						}
+					}
+				} catch (error) {
+					if (!options.json) {
+						tui.warning(
+							'Failed to sync environment variables to cloud. You can sync later with: ' +
+								tui.bold(getCommand('cloud env push'))
+						);
+					}
+					logger.debug('Failed to sync env to cloud:', error);
+				}
+			}
 		} else {
 			if (!options.json) {
 				tui.warning(

package/src/cmd/upgrade/index.ts

@@ -5,6 +5,7 @@ import { z } from 'zod';
 import { ErrorCode, createError, exitWithError } from '../../errors';
 import * as tui from '../../tui';
 import { $ } from 'bun';
+import { tmpdir } from 'node:os';
 import { getInstallationType, type InstallationType } from '../../utils/installation-type';
 
 const UpgradeOptionsSchema = z.object({
@@ -70,18 +71,35 @@ export async function fetchLatestVersion(): Promise<string> {
 }
 
 /**
- * Upgrade the CLI using bun global install
+ * Upgrade the CLI using bun global install.
+ * Retries on transient resolution errors caused by npm CDN propagation delays.
  */
-async function performBunUpgrade(version: string): Promise<void> {
+async function performBunUpgrade(
+	version: string,
+	onRetry?: (attempt: number, delayMs: number) => void
+): Promise<void> {
 	// Remove 'v' prefix for npm version
 	const npmVersion = version.replace(/^v/, '');
 
-	// Use bun to install the specific version globally
-	const result = await $`bun add -g @agentuity/cli@${npmVersion}`.quiet().nothrow();
-
-	if (result.exitCode !== 0) {
-		const stderr = result.stderr.toString();
-		throw new Error(`Failed to install @agentuity/cli@${npmVersion}: ${stderr}`);
+	const { installWithRetry } = await import('./npm-availability');
+
+	try {
+		await installWithRetry(
+			async () => {
+				// Use bun to install the specific version globally
+				// Run from tmpdir to avoid interference from any local package.json/node_modules
+				const result = await $`bun add -g @agentuity/cli@${npmVersion}`
+					.cwd(tmpdir())
+					.quiet()
+					.nothrow();
+				return { exitCode: result.exitCode, stderr: result.stderr };
+			},
+			{ onRetry }
+		);
+	} catch (error) {
+		throw new Error(
+			`Failed to install @agentuity/cli@${npmVersion}: ${error instanceof Error ? error.message : String(error)}`
+		);
 	}
 }
 
@@ -192,8 +210,9 @@ export const command = createCommand({
 				callback: async () => {
 					const { waitForNpmAvailability } = await import('./npm-availability');
 					return await waitForNpmAvailability(latestVersion, {
-						maxAttempts: 6,
-						initialDelayMs: 2000,
+						maxAttempts: 10,
+						initialDelayMs: 5000,
+						maxDelayMs: 15000,
 					});
 				},
 			});
@@ -242,8 +261,14 @@ export const command = createCommand({
 
 			// Perform the upgrade using bun
 			await tui.spinner({
+				type: 'logger',
 				message: `Installing @agentuity/cli@${normalizedLatest}...`,
-				callback: async () => await performBunUpgrade(latestVersion),
+				callback: async (log) =>
+					await performBunUpgrade(latestVersion, (attempt, delayMs) => {
+						log(
+							`Package not yet available on CDN, retrying in ${Math.round(delayMs / 1000)}s (attempt ${attempt})...`
+						);
+					}),
 			});
 
 			// Verify the upgrade

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

@@ -1,62 +1,51 @@
 /**
  * npm registry availability checking utilities.
- * Used to verify a version is available on npm before attempting upgrade.
+ * Used to verify a version is available via bun's resolver before attempting upgrade.
  */
 
-const NPM_REGISTRY_URL = 'https://registry.npmjs.org';
-const PACKAGE_NAME = '@agentuity/cli';
+import { $ } from 'bun';
+import { tmpdir } from 'node:os';
 
-/** 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;
-}
+const PACKAGE_SPEC = '@agentuity/cli';
 
 /**
- * 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`.
+ * Check if a specific version of @agentuity/cli is resolvable by bun.
+ * Uses `bun info` to verify bun's own resolver/CDN can see the version,
+ * which avoids the race where npm registry returns 200 but bun's CDN
+ * has not yet propagated the version.
  *
  * @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;
+export async function isVersionAvailableOnNpm(version: string): Promise<boolean> {
 	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;
+		const result = await $`bun info ${PACKAGE_SPEC}@${normalizedVersion} --json`
+			.cwd(tmpdir())
+			.quiet()
+			.nothrow();
+		if (result.exitCode !== 0) {
+			return false;
+		}
+		const info = JSON.parse(result.stdout.toString());
+		if (info.error) {
+			return false;
+		}
+		return info.version === normalizedVersion;
 	} 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.
+ * Quick check if a version is available via bun's resolver.
+ * Used for implicit version checks (auto-upgrade flow).
  *
  * @param version - Version to check (with or without 'v' prefix)
- * @returns true if version is available, false if unavailable or timeout
+ * @returns true if version is available, false if unavailable or error
  */
 export async function isVersionAvailableOnNpmQuick(version: string): Promise<boolean> {
-	return isVersionAvailableOnNpm(version, { timeoutMs: QUICK_CHECK_TIMEOUT_MS });
+	return isVersionAvailableOnNpm(version);
 }
 
 export interface WaitForNpmOptions {
@@ -103,3 +92,84 @@ export async function waitForNpmAvailability(
 
 	return false;
 }
+
+/**
+ * Patterns in bun's stderr that indicate a resolution/CDN propagation failure
+ * (as opposed to a permanent install error like permissions or disk space).
+ */
+const RESOLUTION_ERROR_PATTERNS = [/failed to resolve/i, /no version matching/i];
+
+/**
+ * Check whether a bun install failure is a transient resolution error
+ * caused by npm CDN propagation delays.
+ */
+export function isResolutionError(stderr: string): boolean {
+	return RESOLUTION_ERROR_PATTERNS.some((pattern) => pattern.test(stderr));
+}
+
+export interface InstallWithRetryOptions {
+	/** Maximum number of attempts including the first (default: 7 → 1 initial + 6 retries) */
+	maxAttempts?: number;
+	/** Initial delay in ms before the first retry (default: 5000) */
+	initialDelayMs?: number;
+	/** Maximum delay cap in ms (default: 30000) */
+	maxDelayMs?: number;
+	/** Multiplier applied to the delay after each retry (default: 2) */
+	multiplier?: number;
+	/** Callback invoked before each retry with the attempt number and upcoming delay */
+	onRetry?: (attempt: number, delayMs: number) => void;
+}
+
+/**
+ * Run an install function and retry on transient resolution errors with
+ * exponential backoff. This covers the window (~2 min) where npm CDN nodes
+ * have not yet propagated a newly-published version.
+ *
+ * Total wait with defaults: 5 + 10 + 20 + 30 + 30 + 30 = 125 s ≈ 2 min
+ *
+ * @param installFn - Async function that performs the install and returns exitCode + stderr
+ * @param options - Retry configuration
+ * @returns The successful result (exitCode 0)
+ * @throws Error if all retries are exhausted or a non-resolution error occurs
+ */
+export async function installWithRetry(
+	installFn: () => Promise<{ exitCode: number; stderr: Buffer }>,
+	options: InstallWithRetryOptions = {}
+): Promise<{ exitCode: number; stderr: Buffer }> {
+	const {
+		maxAttempts = 7,
+		initialDelayMs = 5000,
+		maxDelayMs = 30000,
+		multiplier = 2,
+		onRetry,
+	} = options;
+
+	let delay = initialDelayMs;
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		const result = await installFn();
+
+		if (result.exitCode === 0) {
+			return result;
+		}
+
+		const stderr = result.stderr.toString();
+
+		// Only retry on resolution/propagation errors — bail immediately for anything else
+		if (!isResolutionError(stderr)) {
+			throw new Error(stderr);
+		}
+
+		// Last attempt exhausted — throw
+		if (attempt === maxAttempts) {
+			throw new Error(stderr);
+		}
+
+		onRetry?.(attempt, delay);
+		await new Promise((resolve) => setTimeout(resolve, delay));
+		delay = Math.min(Math.round(delay * multiplier), maxDelayMs);
+	}
+
+	// Unreachable, but satisfies TypeScript
+	throw new Error('Install failed after retries');
+}

package/src/version-check.ts

@@ -5,6 +5,7 @@ import { getVersion, getCompareUrl, getReleaseUrl, toTag } from './version';
 import * as tui from './tui';
 import { saveConfig } from './config';
 import { $ } from 'bun';
+import { tmpdir } from 'node:os';
 import { getExecutingAgent } from './agent-detection';
 
 const ONE_HOUR_MS = 60 * 60 * 1000;
@@ -171,8 +172,27 @@ async function performUpgrade(logger: Logger, targetVersion: string): Promise<vo
 
 		logger.info('Upgrading to version %s...', npmVersion);
 
-		// Use bun to install the specific version globally
-		await $`bun add -g @agentuity/cli@${npmVersion}`.quiet();
+		// Use bun to install the specific version globally with retry for CDN propagation delays
+		// Run from tmpdir to avoid interference from any local package.json/node_modules
+		const { installWithRetry } = await import('./cmd/upgrade/npm-availability');
+		await installWithRetry(
+			async () => {
+				const result = await $`bun add -g @agentuity/cli@${npmVersion}`
+					.cwd(tmpdir())
+					.quiet()
+					.nothrow();
+				return { exitCode: result.exitCode, stderr: result.stderr };
+			},
+			{
+				onRetry: (attempt, delayMs) => {
+					logger.info(
+						'Package not yet available on CDN, retrying in %ds (attempt %d)...',
+						Math.round(delayMs / 1000),
+						attempt
+					);
+				},
+			}
+		);
 
 		// If we got here, the upgrade succeeded
 		// Re-run the original command with the new binary