@agentuity/cli 0.1.43 → 0.1.44

package/src/cmd/build/vite/public-asset-path-plugin.ts

@@ -1,20 +1,21 @@
 /**
  * Vite plugin to fix incorrect public asset paths
  *
- * Developers sometimes accidentally use source paths or relative paths instead
- * of the correct absolute root path. This plugin:
+ * Developers should use /public/ paths for static assets from src/web/public/.
+ * In production, these paths are transformed to CDN URLs.
  *
- * 1. During build: Rewrites all public asset paths to root paths (/)
- * 2. During dev: Warns about incorrect paths so developers can fix them
+ * This plugin:
+ * 1. During build: Rewrites /public/* paths to CDN URLs
+ * 2. During dev: Warns only about incorrect source paths (src/web/public/)
  *
- * Patterns handled (all rewritten to root path in production):
- * - '/src/web/public/foo.svg'  → '/foo.svg'
- * - './src/web/public/foo.svg' → '/foo.svg'
- * - 'src/web/public/foo.svg'   → '/foo.svg'
- * - './public/foo.svg'         → '/foo.svg'
- * - '/public/foo.svg'          → '/foo.svg'
+ * Supported patterns (work in dev, rewritten to CDN in production):
+ * - '/public/foo.svg'   → CDN URL (recommended)
+ * - './public/foo.svg'  → CDN URL
  *
- * Vite's base config then rewrites these to CDN URLs (e.g., https://cdn.example.com/deploy/client/foo.svg)
+ * Incorrect patterns (warned in dev, rewritten in production):
+ * - '/src/web/public/foo.svg'  → CDN URL
+ * - './src/web/public/foo.svg' → CDN URL
+ * - 'src/web/public/foo.svg'   → CDN URL
  */
 
 import type { Plugin } from 'vite';
@@ -29,23 +30,41 @@ export interface PublicAssetPathPluginOptions {
 interface PathPattern {
 	regex: RegExp;
 	description: string;
+	/** Replacement template - use {base} for the target base URL */
+	replacement: string;
 }
 
 /**
- * Create fresh regex instances for each transform call
- * (RegExp with global flag maintains state via lastIndex)
+ * Patterns that are incorrect - reference source paths directly
  */
-function createPatterns(): PathPattern[] {
+function createIncorrectPatterns(): PathPattern[] {
 	return [
 		// '/src/web/public/...' or './src/web/public/...' or 'src/web/public/...'
 		{
 			regex: /(['"`])(?:\.?\/)?src\/web\/public\//g,
 			description: 'src/web/public/',
+			replacement: '$1{base}',
 		},
-		// './public/...' (relative public path - should be absolute)
+	];
+}
+
+/**
+ * Patterns that need rewriting for production CDN
+ * Both patterns simply replace the prefix while preserving the rest of the path naturally.
+ */
+function createPublicPatterns(): PathPattern[] {
+	return [
+		// './public/...' (relative public path) - replace prefix, keep rest
 		{
 			regex: /(['"`])\.\/public\//g,
 			description: './public/',
+			replacement: '$1{base}',
+		},
+		// '/public/...' (absolute public path) - replace prefix, keep rest
+		{
+			regex: /(['"`])\/public\//g,
+			description: '/public/',
+			replacement: '$1{base}',
 		},
 	];
 }
@@ -53,21 +72,17 @@ function createPatterns(): PathPattern[] {
 /**
  * Vite plugin that fixes public asset paths and rewrites to CDN URLs
  *
- * Rewrites all public asset paths to CDN URLs in production, or root paths
- * if no CDN base URL is provided.
+ * Rewrites all public asset paths to CDN URLs in production.
  *
  * @example
  * // In vite config:
  * plugins: [publicAssetPathPlugin({ cdnBaseUrl: 'https://cdn.example.com/deploy/client/' })]
  *
- * // Transforms in production with CDN:
- * // '/src/web/public/logo.svg'  → 'https://cdn.example.com/deploy/client/logo.svg'
- * // './src/web/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
- * // '/public/logo.svg'          → 'https://cdn.example.com/deploy/client/logo.svg'
+ * // In code, use /public/ paths:
+ * <img src="/public/logo.svg" />
  *
- * // Transforms in production without CDN:
- * // '/src/web/public/logo.svg'  → '/logo.svg'
- * // '/public/logo.svg'          → '/logo.svg'
+ * // Transforms in production:
+ * // '/public/logo.svg' → 'https://cdn.example.com/deploy/client/logo.svg'
  */
 export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}): Plugin {
 	const { warnInDev = true, cdnBaseUrl } = options;
@@ -89,17 +104,18 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 			}
 
 			// Quick check: does the code contain any patterns we care about?
-			const hasIncorrectPaths = code.includes('src/web/public/') || code.includes('./public/');
-			const hasPublicPaths = code.includes('/public/');
+			const hasIncorrectSourcePaths = code.includes('src/web/public/');
+			const hasPublicPaths = code.includes('/public/') || code.includes('./public/');
 
-			if (!hasIncorrectPaths && !hasPublicPaths) {
+			if (!hasIncorrectSourcePaths && !hasPublicPaths) {
 				return null;
 			}
 
-			// In dev mode, optionally warn about incorrect paths but don't transform
+			// In dev mode, only warn about incorrect source paths (src/web/public/)
+			// /public/ and ./public/ paths work correctly in dev mode
 			if (isDev) {
-				if (warnInDev && hasIncorrectPaths) {
-					const patterns = createPatterns();
+				if (warnInDev && hasIncorrectSourcePaths) {
+					const patterns = createIncorrectPatterns();
 					const foundPatterns: string[] = [];
 
 					for (const { regex, description } of patterns) {
@@ -121,37 +137,43 @@ export function publicAssetPathPlugin(options: PublicAssetPathPluginOptions = {}
 							this.warn(
 								`Found incorrect asset path(s) in ${id}:\n` +
 									newWarnings.map((p) => `  - '${p}' should be '/public/'`).join('\n') +
-									`\nUse absolute '/public/...' paths for production compatibility.`
+									`\nUse '/public/...' paths for static assets.`
 							);
 						}
 					}
 				}
 				// In dev mode, never transform - Vite serves from source paths
+				// and the Bun server proxies /public/* to Vite
 				return null;
 			}
 
-		// Build mode: transform paths
-		let transformed = code;
-
-		// Determine target URL: CDN base if provided, otherwise root
-		const targetBase = cdnBaseUrl ? (cdnBaseUrl.endsWith('/') ? cdnBaseUrl : `${cdnBaseUrl}/`) : '/';
+			// Build mode: transform paths to CDN URLs
+			let transformed = code;
+
+			// Determine target URL: CDN base if provided, otherwise root
+			const targetBase = cdnBaseUrl
+				? cdnBaseUrl.endsWith('/')
+					? cdnBaseUrl
+					: `${cdnBaseUrl}/`
+				: '/';
+
+			// Transform incorrect source paths (src/web/public/) → CDN
+			if (hasIncorrectSourcePaths) {
+				const patterns = createIncorrectPatterns();
+				for (const { regex, replacement } of patterns) {
+					const replaceRegex = new RegExp(regex.source, regex.flags);
+					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+				}
+			}
 
-		// First, fix incorrect source paths (src/web/public/, ./public/) → targetBase
-		if (hasIncorrectPaths) {
-			const patterns = createPatterns();
-			for (const { regex } of patterns) {
-				const replaceRegex = new RegExp(regex.source, regex.flags);
-				transformed = transformed.replace(replaceRegex, `$1${targetBase}`);
+			// Transform public paths → CDN
+			if (hasPublicPaths) {
+				const publicPatterns = createPublicPatterns();
+				for (const { regex, replacement } of publicPatterns) {
+					const replaceRegex = new RegExp(regex.source, regex.flags);
+					transformed = transformed.replace(replaceRegex, replacement.replace('{base}', targetBase));
+				}
 			}
-		}
-
-		// Then, rewrite /public/foo → {targetBase}foo
-		if (hasPublicPaths) {
-			// Match '/public/...' paths in strings (single, double, or backtick quotes)
-			// Captures: $1 = quote char, $2 = path after /public/
-			const publicPathRegex = /(['"`])\/public\/([^'"`\s]+)/g;
-			transformed = transformed.replace(publicPathRegex, `$1${targetBase}$2`);
-		}
 
 			// Return transformed code if changed
 			if (transformed !== code) {

package/src/cmd/build/vite/vite-asset-server-config.ts

@@ -68,7 +68,9 @@ export async function generateAssetServerConfig(
 		root: rootDir,
 		base: '/',
 		clearScreen: false,
-		publicDir: false, // Don't serve public dir - Bun server handles that
+		// Serve public assets from src/web/public/ at root path (e.g., /favicon.png)
+		// The Bun server proxies /public/* requests to Vite, rewriting to root paths
+		publicDir: join(rootDir, 'src', 'web', 'public'),
 
 		resolve: {
 			alias,

package/src/cmd/cloud/env/org-util.ts

@@ -9,12 +9,14 @@ import { listOrganizations } from '@agentuity/server';
  * @param apiClient - The API client
  * @param config - The CLI config (may be null)
  * @param orgOption - The --org option value (true for default/prompt, or explicit org ID)
+ * @param autoSelect - If true, auto-select preferred org without prompting (for --confirm)
  * @returns The resolved organization ID
  */
 export async function resolveOrgId(
 	apiClient: APIClient,
 	config: Config | null,
-	orgOption: boolean | string
+	orgOption: boolean | string,
+	autoSelect?: boolean
 ): Promise<string> {
 	// If an explicit org ID was provided (string), use it directly
 	if (typeof orgOption === 'string' && orgOption !== 'true') {
@@ -25,8 +27,9 @@ export async function resolveOrgId(
 	const orgs = await tui.spinner('Fetching organizations', () => listOrganizations(apiClient));
 
 	// Use preference if available, otherwise prompt
+	// Pass autoSelect to skip prompting when --confirm is used
 	const preferredOrgId = config?.preferences?.orgId;
-	return tui.selectOrganization(orgs, preferredOrgId);
+	return tui.selectOrganization(orgs, preferredOrgId, autoSelect);
 }
 
 /**

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