@agentuity/cli 3.0.0-alpha.7 → 3.0.0-beta.0

package/src/utils/stream-url.ts

@@ -1,226 +0,0 @@
-import { writeAndDrain } from '@agentuity/server';
-import type { Logger } from '@agentuity/core';
-import * as tui from '../tui';
-
-export interface StreamUrlOptions {
-	signal?: AbortSignal;
-	follow?: boolean;
-	timestamps?: boolean;
-	grep?: string;
-	tail?: number;
-	json?: boolean;
-	label?: string;
-	raw?: boolean;
-	v2?: boolean;
-}
-
-export interface StreamUrlResult {
-	bytesRead: number;
-	chunks: number;
-}
-
-export class StreamFetchError extends Error {
-	constructor(
-		public status: number,
-		public statusText: string,
-		message: string
-	) {
-		super(message);
-		this.name = 'StreamFetchError';
-	}
-}
-
-function escapeRegExp(str: string): string {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-
-export async function streamUrlToWritable(
-	url: string,
-	writable: NodeJS.WritableStream,
-	logger: Logger,
-	options: StreamUrlOptions = {}
-): Promise<StreamUrlResult> {
-	const {
-		signal,
-		follow,
-		timestamps,
-		grep,
-		tail,
-		json,
-		label = 'stream',
-		raw = false,
-		v2 = false,
-	} = options;
-	const streamStart = Date.now();
-	let bytesRead = 0;
-	let chunks = 0;
-
-	try {
-		const fetchUrl = new URL(url);
-
-		if (follow || v2) {
-			fetchUrl.searchParams.set('v', '2');
-		}
-		if (follow) {
-			fetchUrl.searchParams.set('follow', 'true');
-		}
-
-		const redactedUrl =
-			fetchUrl.origin + fetchUrl.pathname + (fetchUrl.search ? '?REDACTED' : '');
-		logger.debug('[%s] fetching: %s', label, redactedUrl);
-		const response = await fetch(fetchUrl.href, { signal });
-		logger.debug(
-			'[%s] response status=%d in %dms',
-			label,
-			response.status,
-			Date.now() - streamStart
-		);
-
-		if (!response.ok || !response.body) {
-			logger.debug('[%s] not ok or no body', label);
-			if (!json) {
-				tui.error(`Failed to fetch stream: ${response.status} ${response.statusText}`);
-			}
-			throw new StreamFetchError(
-				response.status,
-				response.statusText,
-				`Failed to fetch stream: ${response.status} ${response.statusText}`
-			);
-		}
-
-		const reader = response.body.getReader();
-
-		if (raw) {
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					logger.debug(
-						'[%s] EOF after %dms (%d chunks, %d bytes)',
-						label,
-						Date.now() - streamStart,
-						chunks,
-						bytesRead
-					);
-					break;
-				}
-
-				if (value) {
-					chunks++;
-					bytesRead += value.length;
-					if (chunks <= 3 || chunks % 100 === 0) {
-						logger.debug(
-							'[%s] chunk #%d: %d bytes (total: %d bytes, +%dms)',
-							label,
-							chunks,
-							value.length,
-							bytesRead,
-							Date.now() - streamStart
-						);
-					}
-					await writeAndDrain(writable, value);
-				}
-			}
-		} else {
-			const decoder = new TextDecoder();
-			let leftover = '';
-			const grepPattern = grep ? new RegExp(escapeRegExp(grep), 'i') : null;
-			const needsFiltering = tail !== undefined || grepPattern !== null;
-			const tailBuffer: string[] = [];
-			const maxTail = tail ?? Infinity;
-			const liveOutput = follow && needsFiltering;
-
-			const outputLine = async (line: string) => {
-				if (json) {
-					const obj = {
-						timestamp: new Date().toISOString(),
-						stream: label,
-						message: line,
-					};
-					await writeAndDrain(writable, Buffer.from(JSON.stringify(obj) + '\n'));
-				} else {
-					const formatted = timestamps ? formatLineWithTimestamp(line) : line;
-					await writeAndDrain(writable, Buffer.from(formatted + '\n'));
-				}
-			};
-
-			const processFilteredLine = async (line: string) => {
-				if (grepPattern && !grepPattern.test(line)) {
-					return;
-				}
-				if (tail !== undefined) {
-					tailBuffer.push(line);
-					if (tailBuffer.length > maxTail) {
-						tailBuffer.shift();
-					}
-					if (liveOutput) {
-						await outputLine(line);
-					}
-				} else {
-					await outputLine(line);
-				}
-			};
-
-			while (true) {
-				const { done, value } = await reader.read();
-				if (done) {
-					if (leftover) {
-						if (needsFiltering) {
-							await processFilteredLine(leftover);
-						} else {
-							await outputLine(leftover);
-						}
-					}
-					logger.debug(
-						'[%s] EOF after %dms (%d chunks, %d bytes)',
-						label,
-						Date.now() - streamStart,
-						chunks,
-						bytesRead
-					);
-					break;
-				}
-
-				if (value) {
-					chunks++;
-					bytesRead += value.length;
-					const text = leftover + decoder.decode(value, { stream: true });
-					const lines = text.split('\n');
-					leftover = lines.pop() ?? '';
-
-					for (const line of lines) {
-						if (needsFiltering) {
-							await processFilteredLine(line);
-						} else {
-							await outputLine(line);
-						}
-					}
-				}
-			}
-
-			if (!liveOutput && needsFiltering && tailBuffer.length > 0) {
-				for (const line of tailBuffer) {
-					await outputLine(line);
-				}
-			}
-		}
-
-		return { bytesRead, chunks };
-	} catch (err) {
-		if (err instanceof Error && err.name === 'AbortError') {
-			logger.debug('[%s] aborted after %dms', label, Date.now() - streamStart);
-			return { bytesRead, chunks };
-		}
-		logger.debug('[%s] error after %dms: %s', label, Date.now() - streamStart, err);
-		throw err;
-	}
-}
-
-function formatLineWithTimestamp(line: string): string {
-	const timestamp = new Date().toLocaleTimeString('en-US', {
-		hour12: false,
-		hour: '2-digit',
-		minute: '2-digit',
-		second: '2-digit',
-	});
-	return `${tui.muted(timestamp)} ${line}`;
-}

package/src/utils/zip.ts

@@ -1,68 +0,0 @@
-import { createWriteStream, lstatSync } from 'node:fs';
-import { mkdir } from 'node:fs/promises';
-import { dirname, relative } from 'node:path';
-import { Glob } from 'bun';
-import archiver from 'archiver';
-import { toForwardSlash } from './normalize-path';
-
-interface Options {
-	progress?: (val: number) => void;
-	filter?: (filename: string, relative: string) => boolean;
-}
-
-export async function zipDir(dir: string, outdir: string, options?: Options) {
-	await mkdir(dirname(outdir), { recursive: true });
-	const output = createWriteStream(outdir);
-	const zip = archiver('zip', {
-		zlib: { level: 9 },
-	});
-
-	const writeDone = new Promise<void>((resolve, reject) => {
-		output.on('close', resolve);
-		output.on('error', reject);
-		zip.on('error', reject);
-	});
-
-	zip.pipe(output);
-
-	const files = await Array.fromAsync(
-		new Glob('**/*').scan({ cwd: dir, absolute: true, dot: true, followSymlinks: false })
-	);
-	const total = files.length;
-	let count = 0;
-	for (const file of files) {
-		const rel = toForwardSlash(relative(dir, file));
-		let skip = false;
-		if (options?.filter) {
-			if (!options.filter(file, rel)) {
-				skip = true;
-			}
-		}
-		if (!skip) {
-			try {
-				// Skip symlinks and directories — symlinks are workspace artefacts
-				// (e.g. bun's node_modules links) that cannot be resolved portably
-				// across machines and would cause EISDIR errors on extraction.
-				const stat = lstatSync(file);
-				if (!stat.isSymbolicLink() && !stat.isDirectory()) {
-					// Set explicit Unix permissions (0o644) for portability across OSes.
-					zip.file(file, { name: rel, mode: 0o644 });
-				}
-			} catch (err) {
-				throw new Error(`Failed to add file to zip: ${rel} (${file})`, { cause: err });
-			}
-		}
-		count++;
-		if (options?.progress) {
-			const progress = Math.floor((count / total) * 100);
-			options.progress(progress);
-			await Bun.sleep(10); // give some time for the progress bar to render
-		}
-	}
-	await zip.finalize();
-	await writeDone;
-	if (options?.progress) {
-		options.progress(100);
-		await Bun.sleep(100); // give some time for the progress bar to render
-	}
-}

package/src/version-check.ts

@@ -1,329 +0,0 @@
-import type { Config, Logger, CommandDefinition, SubcommandDefinition } from './types';
-import { getInstallationType } from './utils/installation-type';
-import { fetchLatestVersion } from './cmd/upgrade';
-import { getVersion, getCompareUrl, getReleaseUrl, toTag } from './version';
-import * as tui from './tui';
-import { saveConfig } from './config';
-import { tmpdir } from 'node:os';
-import { getExecutingAgent } from './agent-detection';
-
-const ONE_HOUR_MS = 60 * 60 * 1000;
-
-// Tags that indicate a command should skip the upgrade prompt
-const SKIP_UPGRADE_TAGS = ['read-only', 'fast'];
-
-/**
- * Check if we should skip the version check based on environment and config
- */
-function shouldSkipCheck(
-	config: Config | null,
-	options: {
-		json?: boolean;
-		quiet?: boolean;
-		validate?: boolean;
-		dryRun?: boolean;
-		skipVersionCheck?: boolean;
-	},
-	commandDef: CommandDefinition | undefined,
-	subcommandDef: SubcommandDefinition | undefined,
-	args: string[]
-): boolean {
-	// Skip if not a global installation (can't auto-upgrade local/source installs)
-	const installationType = getInstallationType();
-	if (installationType !== 'global') {
-		return true;
-	}
-
-	// Skip if running from an AI coding agent (don't interrupt with upgrade prompts)
-	if (getExecutingAgent()) {
-		return true;
-	}
-
-	// Skip if no TTY (CI, redirected output, etc.)
-	if (!process.stdin.isTTY || !process.stdout.isTTY) {
-		return true;
-	}
-
-	// Skip if any of these flags are set
-	if (options.json || options.quiet || options.validate || options.dryRun) {
-		return true;
-	}
-
-	// Skip if explicitly disabled via flag
-	if (options.skipVersionCheck) {
-		return true;
-	}
-
-	// Skip if explicitly disabled via environment variable
-	if (process.env.AGENTUITY_SKIP_VERSION_CHECK === '1') {
-		return true;
-	}
-
-	// Skip if explicitly disabled via config
-	if (config?.overrides?.skip_version_check) {
-		return true;
-	}
-
-	// Skip if development version (0.0.x or 'dev')
-	const currentVersion = getVersion();
-	if (currentVersion.startsWith('0.0.') || currentVersion === 'dev') {
-		return true;
-	}
-
-	// Skip if command explicitly opts out of upgrade check
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	if (commandDef && (commandDef as any).skipUpgradeCheck === true) {
-		return true;
-	}
-
-	// Skip if subcommand explicitly opts out of upgrade check
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	if (subcommandDef && (subcommandDef as any).skipUpgradeCheck === true) {
-		return true;
-	}
-
-	// Skip if command or subcommand has tags indicating it's read-only or fast
-	// These commands shouldn't be interrupted with upgrade prompts
-	const commandTags = commandDef?.tags ?? [];
-	const subcommandTags = subcommandDef?.tags ?? [];
-	const allTags = [...commandTags, ...subcommandTags];
-	if (allTags.some((tag) => SKIP_UPGRADE_TAGS.includes(tag))) {
-		return true;
-	}
-
-	// Skip for help commands
-	const helpFlags = ['--help', '-h', 'help'];
-	if (args.some((arg) => helpFlags.includes(arg))) {
-		return true;
-	}
-
-	return false;
-}
-
-/**
- * Check if enough time has passed since last check (at least 1 hour)
- */
-function shouldCheckNow(config: Config | null): boolean {
-	const lastCheck = config?.preferences?.last_update_check;
-	if (!lastCheck) {
-		return true;
-	}
-
-	const now = Date.now();
-	const elapsed = now - lastCheck;
-	return elapsed >= ONE_HOUR_MS;
-}
-
-/**
- * Prompt user to upgrade to a new version
- * Returns true if user wants to upgrade, false otherwise
- */
-async function promptUpgrade(currentVersion: string, latestVersion: string): Promise<boolean> {
-	// Strip 'v' prefix for display
-	const displayCurrent = currentVersion.replace(/^v/, '');
-	const displayLatest = latestVersion.replace(/^v/, '');
-
-	tui.newline();
-	tui.info(`${tui.bold('A new version of the CLI is available!')}`);
-	tui.info(`Current version: ${tui.muted(displayCurrent)}`);
-	tui.info(`Latest version:  ${tui.bold(displayLatest)}`);
-	tui.newline();
-	if (toTag(currentVersion) !== toTag(latestVersion)) {
-		tui.warning(`What's changed:  ${tui.link(getCompareUrl(currentVersion, latestVersion))}`);
-	}
-	tui.success(`Release notes:   ${tui.link(getReleaseUrl(latestVersion))}`);
-	tui.newline();
-
-	return await tui.confirm('Would you like to upgrade now?', true);
-}
-
-/**
- * Update the last check timestamp in config
- */
-async function updateCheckTimestamp(config: Config | null, logger: Logger): Promise<void> {
-	if (!config) {
-		return;
-	}
-
-	const updatedConfig: Config = {
-		...config,
-		preferences: {
-			...config.preferences,
-			last_update_check: Date.now(),
-		},
-	};
-
-	try {
-		await saveConfig(updatedConfig);
-	} catch (error) {
-		// Non-fatal - log but continue
-		logger.debug('Failed to save config after version check: %s', error);
-	}
-}
-
-/**
- * Perform the upgrade using bun global install and re-run the command
- */
-async function performUpgrade(logger: Logger, targetVersion: string): Promise<void> {
-	try {
-		// Remove 'v' prefix for npm version
-		const npmVersion = targetVersion.replace(/^v/, '');
-
-		logger.info('Upgrading to version %s...', npmVersion);
-
-		// 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, spawnWithTimeout } = await import('./cmd/upgrade/npm-availability');
-		await installWithRetry(
-			async () => {
-				// spawnWithTimeout kills the process if it exceeds 30s
-				const result = await spawnWithTimeout(
-					['bun', 'add', '-g', `@agentuity/cli@${npmVersion}`],
-					{ cwd: tmpdir(), timeout: 30_000 }
-				);
-				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
-		const args = process.argv.slice(2);
-
-		logger.info('Upgrade successful! Restarting with new version...');
-		console.log('');
-
-		// Spawn new process using the global agentuity command
-		// This will use the newly installed version
-		const proc = Bun.spawn(['agentuity', ...args], {
-			stdin: 'inherit',
-			stdout: 'inherit',
-			stderr: 'inherit',
-		});
-
-		// Wait for the new process to complete
-		await proc.exited;
-
-		// Exit with the same exit code as the new process
-		process.exit(proc.exitCode ?? 0);
-	} catch (error) {
-		const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-		logger.error('Upgrade failed: %s', errorMessage);
-
-		// Check for known bun package manager bug (oven-sh/bun#18354)
-		if (errorMessage.includes('BadPathName')) {
-			tui.newline();
-			tui.warning(
-				'This appears to be a known bun package manager issue with stale global packages.'
-			);
-			tui.info('To fix this, run one of the following:');
-			tui.newline();
-			tui.info(`  ${tui.bold('Option 1:')} Clear stale packages and reinstall`);
-			tui.info(`  ${tui.muted('$')} rm -rf ~/.bun/install/global`);
-			tui.info(`  ${tui.muted('$')} bun add -g @agentuity/cli@latest`);
-			tui.newline();
-			tui.info(`  ${tui.bold('Option 2:')} Use the install script`);
-			tui.info(`  ${tui.muted('$')} curl -fsSL https://agentuity.sh | sh`);
-			tui.newline();
-		}
-
-		tui.warning('Continuing with current version...');
-		tui.info('You can upgrade later by running: agentuity upgrade');
-		tui.newline();
-	}
-}
-
-/**
- * Check for updates and optionally prompt to upgrade
- * Should be called early in the CLI initialization, before commands execute
- */
-export async function checkForUpdates(
-	config: Config | null,
-	logger: Logger,
-	options: {
-		json?: boolean;
-		quiet?: boolean;
-		validate?: boolean;
-		dryRun?: boolean;
-		skipVersionCheck?: boolean;
-	},
-	commandDef: CommandDefinition | undefined,
-	subcommandDef: SubcommandDefinition | undefined,
-	args: string[]
-): Promise<void> {
-	// Determine if we should skip the check
-	if (shouldSkipCheck(config, options, commandDef, subcommandDef, args)) {
-		logger.trace('Skipping version check (disabled or not applicable)');
-		return;
-	}
-
-	// Check if enough time has passed
-	if (!shouldCheckNow(config)) {
-		logger.trace('Skipping version check (checked recently)');
-		return;
-	}
-
-	// Perform the actual version check
-	logger.trace('Checking for updates...');
-
-	try {
-		const currentVersion = getVersion();
-		const latestVersion = await fetchLatestVersion();
-
-		// 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);
-
-		if (!shouldUpgrade) {
-			// User declined - just continue
-			tui.info('You can upgrade later by running: agentuity upgrade');
-			tui.newline();
-			return;
-		}
-
-		// User wants to upgrade - perform it
-		await performUpgrade(logger, latestVersion);
-	} catch (error) {
-		// Non-fatal - if we can't fetch the latest version (network error, timeout, etc.),
-		// just log at debug level and continue without interrupting the user's command
-		logger.debug(
-			'Version check failed: %s',
-			error instanceof Error ? error.message : 'Unknown error'
-		);
-	}
-}

package/src/version.ts

@@ -1,57 +0,0 @@
-/**
- * Centralized version and package information
- * Loads package.json once and caches it
- */
-
-import pkg from '../package.json' with { type: 'json' };
-
-// Cache the package data
-let cachedPackage: typeof pkg | null = null;
-
-export function getPackage(): typeof pkg {
-	if (!cachedPackage) {
-		cachedPackage = pkg;
-	}
-	return cachedPackage;
-}
-
-export function getVersion(): string {
-	return getPackage().version || 'dev';
-}
-
-export function getPackageName(): string {
-	return getPackage().name || '@agentuity/cli';
-}
-
-export function getRevision(): string {
-	// Bun provides git SHA via Bun.revision
-	return typeof Bun !== 'undefined' && Bun.revision ? Bun.revision.substring(0, 8) : 'unknown';
-}
-
-const GITHUB_REPO_URL = 'https://github.com/agentuity/sdk';
-
-/**
- * Normalize a version string to a Git tag format (with 'v' prefix)
- */
-export function toTag(version: string): string {
-	return version.startsWith('v') ? version : `v${version}`;
-}
-
-/**
- * Get the GitHub URL for comparing two versions
- * @param fromVersion - The current/old version
- * @param toVersion - The new/target version
- * @returns GitHub compare URL
- */
-export function getCompareUrl(fromVersion: string, toVersion: string): string {
-	return `${GITHUB_REPO_URL}/compare/${toTag(fromVersion)}...${toTag(toVersion)}`;
-}
-
-/**
- * Get the GitHub URL for a specific release
- * @param version - The version to get the release URL for
- * @returns GitHub release URL
- */
-export function getReleaseUrl(version: string): string {
-	return `${GITHUB_REPO_URL}/releases/tag/${toTag(version)}`;
-}