@agentuity/cli 0.1.43 → 0.1.45

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

@@ -0,0 +1,248 @@
+import { z } from 'zod';
+import { basename } from 'path';
+import { createCommand } from '../../../types';
+import * as tui from '../../../tui';
+import { createStorageAdapter } from './util';
+import { getCommand } from '../../../command-prefix';
+
+const StreamCreateResponseSchema = z.object({
+	id: z.string().describe('Stream ID'),
+	namespace: z.string().describe('Stream namespace'),
+	url: z.string().describe('Public URL'),
+	sizeBytes: z.number().describe('Size in bytes'),
+	metadata: z.record(z.string(), z.string()).describe('Stream metadata'),
+	expiresAt: z.string().optional().describe('Expiration timestamp'),
+});
+
+export const createSubcommand = createCommand({
+	name: 'create',
+	aliases: ['new'],
+	description: 'Create a new stream and upload content',
+	tags: ['mutating', 'creates-resource', 'slow', 'requires-auth', 'uses-stdin'],
+	requires: { auth: true, region: true },
+	optional: { project: true },
+	idempotent: false,
+	examples: [
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md'),
+			description: 'Create stream from file',
+		},
+		{
+			command: getCommand(
+				'cloud stream create memory-share ./data.json --content-type application/json'
+			),
+			description: 'Create stream with explicit content type',
+		},
+		{
+			command: `cat summary.md | ${getCommand('cloud stream create memory-share -')}`,
+			description: 'Create stream from stdin',
+		},
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md --ttl 3600'),
+			description: 'Create stream with 1 hour TTL',
+		},
+		{
+			command: getCommand(
+				'cloud stream create memory-share ./notes.md --metadata type=summary,source=session'
+			),
+			description: 'Create stream with metadata',
+		},
+		{
+			command: getCommand('cloud stream create memory-share ./large.json --compress'),
+			description: 'Create compressed stream',
+		},
+	],
+	schema: {
+		args: z.object({
+			namespace: z.string().min(1).max(254).describe('Stream namespace (1-254 characters)'),
+			filename: z.string().describe('File path to upload or "-" for STDIN'),
+		}),
+		options: z.object({
+			metadata: z
+				.string()
+				.optional()
+				.describe('Metadata key=value pairs (comma-separated: key1=value1,key2=value2)'),
+			contentType: z
+				.string()
+				.optional()
+				.describe('Content type (auto-detected from extension if not provided)'),
+			compress: z.boolean().optional().describe('Enable gzip compression'),
+			ttl: z.coerce
+				.number()
+				.optional()
+				.describe('TTL in seconds (60-7776000, or 0/null for never expires)'),
+		}),
+		response: StreamCreateResponseSchema,
+	},
+	webUrl: '/services/stream',
+
+	async handler(ctx) {
+		const { args, opts, options } = ctx;
+		const started = Date.now();
+		const storage = await createStorageAdapter(ctx);
+
+		// Parse metadata if provided
+		let metadata: Record<string, string> | undefined;
+		if (opts.metadata) {
+			const validPairs: Record<string, string> = {};
+			const malformed: string[] = [];
+			const pairs = opts.metadata.split(',');
+
+			for (const pair of pairs) {
+				const trimmedPair = pair.trim();
+				if (!trimmedPair) continue;
+
+				const firstEqualIdx = trimmedPair.indexOf('=');
+				if (firstEqualIdx === -1) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				const key = trimmedPair.substring(0, firstEqualIdx).trim();
+				const value = trimmedPair.substring(firstEqualIdx + 1).trim();
+
+				if (!key || !value) {
+					malformed.push(trimmedPair);
+					continue;
+				}
+
+				validPairs[key] = value;
+			}
+
+			if (malformed.length > 0) {
+				ctx.logger.warn(`Skipping malformed metadata pairs: ${malformed.join(', ')}`);
+			}
+
+			if (Object.keys(validPairs).length > 0) {
+				metadata = validPairs;
+			}
+		}
+
+		// Determine content type
+		let contentType = opts.contentType;
+		if (!contentType) {
+			// Auto-detect from filename extension
+			const filename = args.filename === '-' ? 'stdin' : args.filename;
+			const dotIndex = filename.lastIndexOf('.');
+			const ext = dotIndex > 0 ? filename.substring(dotIndex + 1).toLowerCase() : undefined;
+			// Text-based types should include charset=utf-8 for proper browser rendering
+			const mimeTypes: Record<string, string> = {
+				txt: 'text/plain; charset=utf-8',
+				md: 'text/markdown; charset=utf-8',
+				html: 'text/html; charset=utf-8',
+				css: 'text/css; charset=utf-8',
+				yaml: 'application/x-yaml; charset=utf-8',
+				yml: 'application/x-yaml; charset=utf-8',
+				js: 'application/javascript; charset=utf-8',
+				ts: 'application/typescript; charset=utf-8',
+				json: 'application/json; charset=utf-8',
+				xml: 'application/xml; charset=utf-8',
+				pdf: 'application/pdf',
+				zip: 'application/zip',
+				jpg: 'image/jpeg',
+				jpeg: 'image/jpeg',
+				png: 'image/png',
+				gif: 'image/gif',
+				svg: 'image/svg+xml; charset=utf-8',
+				mp4: 'video/mp4',
+				mp3: 'audio/mpeg',
+			};
+			contentType = ext ? mimeTypes[ext] : 'application/octet-stream';
+		}
+
+		// Create the stream
+		const stream = await storage.create(args.namespace, {
+			metadata,
+			contentType,
+			compress: opts.compress ? true : undefined,
+			ttl: opts.ttl,
+		});
+
+		// Read and write content
+		let inputStream: ReadableStream<Uint8Array>;
+
+		if (args.filename === '-') {
+			// Stream from STDIN
+			inputStream = Bun.stdin.stream();
+		} else {
+			// Stream from file
+			const file = Bun.file(args.filename);
+			if (!(await file.exists())) {
+				tui.fatal(`File not found: ${args.filename}`);
+			}
+			inputStream = file.stream();
+		}
+
+		// Write content to stream in chunks
+		const reader = inputStream.getReader();
+		const MAX_CHUNK_SIZE = 5 * 1024 * 1024; // 5MB max per write
+
+		try {
+			while (true) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				// If chunk is larger than 5MB, split it
+				if (value.length > MAX_CHUNK_SIZE) {
+					let offset = 0;
+					while (offset < value.length) {
+						const chunk = value.slice(offset, offset + MAX_CHUNK_SIZE);
+						await stream.write(chunk);
+						offset += MAX_CHUNK_SIZE;
+					}
+				} else {
+					await stream.write(value);
+				}
+			}
+		} finally {
+			reader.releaseLock();
+		}
+
+		// Close the stream
+		await stream.close();
+
+		const durationMs = Date.now() - started;
+		const sizeBytes = stream.bytesWritten;
+
+		// Get stream info to retrieve expiresAt
+		let expiresAt: string | undefined;
+		try {
+			const info = await storage.get(stream.id);
+			expiresAt = info.expiresAt;
+		} catch {
+			// expiresAt is optional, ignore errors
+		}
+
+		if (!options.json) {
+			const sourceLabel = args.filename === '-' ? 'stdin' : basename(args.filename);
+			console.log(`Namespace: ${tui.bold(args.namespace)}`);
+			console.log(`ID:        ${stream.id}`);
+			console.log(`Size:      ${tui.formatBytes(sizeBytes)}`);
+			console.log(`URL:       ${tui.link(stream.url)}`);
+			if (expiresAt) {
+				console.log(`Expires:   ${expiresAt}`);
+			}
+			if (metadata && Object.keys(metadata).length > 0) {
+				console.log(`Metadata:`);
+				for (const [key, value] of Object.entries(metadata)) {
+					console.log(`  ${key}: ${value}`);
+				}
+			}
+			if (opts.compress) {
+				console.log(`Compressed: yes`);
+			}
+			tui.success(`created stream from ${sourceLabel} in ${durationMs.toFixed(1)}ms`);
+		}
+
+		return {
+			id: stream.id,
+			namespace: args.namespace,
+			url: stream.url,
+			sizeBytes,
+			metadata: metadata ?? {},
+			expiresAt,
+		};
+	},
+});
+
+export default createSubcommand;

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

@@ -13,7 +13,8 @@ export const deleteSubcommand = createCommand({
 	description: 'Delete a stream by ID (soft delete)',
 	tags: ['destructive', 'deletes-resource', 'slow', 'requires-auth'],
 	idempotent: true,
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	examples: [
 		{ command: getCommand('stream delete stream-id-123'), description: 'Delete a stream' },
 		{

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

@@ -16,7 +16,8 @@ export const getSubcommand = createCommand({
 	name: 'get',
 	description: 'Get detailed information about a specific stream',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('stream get stream-id-123'), description: 'Get stream details' },

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

@@ -1,4 +1,5 @@
 import { createCommand } from '../../../types';
+import createSubcommand from './create';
 import listSubcommand from './list';
 import getSubcommand from './get';
 import deleteSubcommand from './delete';
@@ -10,10 +11,18 @@ export const streamCommand = createCommand({
 	description: 'Manage durable streams',
 	tags: ['slow', 'requires-auth'],
 	examples: [
+		{
+			command: getCommand('cloud stream create memory-share ./notes.md'),
+			description: 'Create stream from file',
+		},
+		{
+			command: `cat data.json | ${getCommand('cloud stream create memory-share -')}`,
+			description: 'Create stream from stdin',
+		},
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },
 		{ command: getCommand('cloud stream get <id>'), description: 'Get stream details' },
 	],
-	subcommands: [listSubcommand, getSubcommand, deleteSubcommand],
+	subcommands: [createSubcommand, listSubcommand, getSubcommand, deleteSubcommand],
 });
 
 export default streamCommand;

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

@@ -22,7 +22,8 @@ export const listSubcommand = createCommand({
 	aliases: ['ls'],
 	description: 'List recent streams with optional filtering',
 	tags: ['read-only', 'slow', 'requires-auth'],
-	requires: { auth: true, project: true },
+	requires: { auth: true, region: true },
+	optional: { project: true },
 	idempotent: true,
 	examples: [
 		{ command: getCommand('cloud stream list'), description: 'List all streams' },

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

@@ -1,35 +1,62 @@
-import { StreamStorageService, Logger } from '@agentuity/core';
+import { StreamStorageService, type Logger } from '@agentuity/core';
 import { createServerFetchAdapter, getServiceUrls } from '@agentuity/server';
 import { loadProjectSDKKey } from '../../../config';
-import { ErrorCode } from '../../../errors';
-import type { Config } from '../../../types';
+import type { AuthData, Config, GlobalOptions, ProjectConfig } from '../../../types';
 import * as tui from '../../../tui';
 
 export async function createStorageAdapter(ctx: {
 	logger: Logger;
 	projectDir: string;
+	auth: AuthData;
+	region: string;
+	project?: ProjectConfig;
 	config: Config | null;
-	project: { region: string };
+	options: GlobalOptions;
 }) {
+	// Try to get SDK key from project context first (preferred for project-based auth)
 	const sdkKey = await loadProjectSDKKey(ctx.logger, ctx.projectDir);
-	if (!sdkKey) {
-		tui.fatal(
-			`Couldn't find the AGENTUITY_SDK_KEY in ${ctx.projectDir} .env file`,
-			ErrorCode.CONFIG_NOT_FOUND
-		);
+
+	let authToken: string;
+	let queryParams: Record<string, string> | undefined;
+
+	if (sdkKey) {
+		// Use SDK key auth (project context available)
+		authToken = sdkKey;
+		ctx.logger.trace('using SDK key auth for stream');
+	} else {
+		// Use CLI key auth with orgId query param
+		// Pulse server expects orgId as query param for CLI tokens (ck_*)
+		// IMPORTANT: For CLI key auth, prefer user's org ID over project's org ID
+		// because the CLI key is validated against the user's orgs, not the project's org
+		const orgId =
+			ctx.options.orgId ??
+			process.env.AGENTUITY_CLOUD_ORG_ID ??
+			ctx.config?.preferences?.orgId ??
+			ctx.project?.orgId;
+
+		if (!orgId) {
+			tui.fatal(
+				'Organization ID is required. Either run from a project directory, use --org-id flag, or set AGENTUITY_CLOUD_ORG_ID environment variable.'
+			);
+		}
+
+		authToken = ctx.auth.apiKey;
+		queryParams = { orgId };
+		ctx.logger.trace('using CLI key auth with orgId query param for stream');
 	}
 
+	const baseUrl = getServiceUrls(ctx.region).stream;
+
 	const adapter = createServerFetchAdapter(
 		{
 			headers: {
-				Authorization: `Bearer ${sdkKey}`,
+				Authorization: `Bearer ${authToken}`,
 			},
+			queryParams,
 		},
 		ctx.logger
 	);
 
-	const baseUrl = getServiceUrls(ctx.project.region).stream;
-
 	ctx.logger.trace('using stream url: %s', baseUrl);
 
 	return new StreamStorageService(baseUrl, adapter);

package/src/cmd/upgrade/index.ts

@@ -185,6 +185,31 @@ export const command = createCommand({
 				};
 			}
 
+			// Verify the version is available on npm before proceeding
+			const isAvailable = await tui.spinner({
+				message: 'Verifying npm availability...',
+				clearOnSuccess: true,
+				callback: async () => {
+					const { waitForNpmAvailability } = await import('./npm-availability');
+					return await waitForNpmAvailability(latestVersion, {
+						maxAttempts: 6,
+						initialDelayMs: 2000,
+					});
+				},
+			});
+
+			if (!isAvailable) {
+				tui.warning('The new version is not yet available on npm.');
+				tui.info('This can happen right after a release. Please try again in a few minutes.');
+				tui.info(`You can also run: ${tui.muted('bun add -g @agentuity/cli@latest')}`);
+				return {
+					upgraded: false,
+					from: currentVersion,
+					to: latestVersion,
+					message: 'Version not yet available on npm',
+				};
+			}
+
 			// Show version info
 			if (!force) {
 				tui.info(`Current version: ${tui.muted(normalizedCurrent)}`);

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);