@gguf/coder 0.2.9 → 0.3.1

package/source/commands/update.spec.tsx

@@ -0,0 +1,261 @@
+import test from 'ava';
+import { toolRegistry } from '../tools/index.js';
+import { hasCommandFailed, updateCommand } from './update.js';
+
+console.log(`\nupdate.spec.tsx`);
+
+// Command Metadata Tests
+// These tests verify the command is properly configured
+
+test('updateCommand: has correct name', t => {
+	t.is(updateCommand.name, 'update');
+});
+
+test('updateCommand: has description', t => {
+	t.truthy(updateCommand.description);
+	t.true(updateCommand.description.length > 0);
+	t.regex(updateCommand.description, /update/i);
+});
+
+test('updateCommand: has handler function', t => {
+	t.is(typeof updateCommand.handler, 'function');
+});
+
+test('updateCommand: handler is async', t => {
+	const result = updateCommand.handler([]);
+	t.truthy(result);
+	t.true(result instanceof Promise);
+});
+
+// Basic behavior: when update available and installed via npm, handler runs npm update -g
+test('updateCommand: runs update command when installed via npm', async t => {
+	// Mock fetch to return newer version
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (async () => {
+		return {
+			ok: true,
+			status: 200,
+			statusText: 'OK',
+			json: async () => ({
+				version: '99.99.99',
+				name: '@gguf/coder',
+			}),
+		} as unknown as Response;
+	}) as typeof fetch;
+
+	// Set installation method override
+	process.env.CODER_INSTALL_METHOD = 'npm';
+
+	let called = false;
+	const originalExecuteBash = toolRegistry.execute_bash;
+	toolRegistry.execute_bash = async ({ command }: { command: string }) => {
+		called = true;
+		t.is(command, 'npm update -g @gguf/coder');
+		return 'ok';
+	};
+
+	await updateCommand.handler([]);
+
+	// Cleanup
+	toolRegistry.execute_bash = originalExecuteBash;
+	globalThis.fetch = originalFetch;
+	delete process.env.CODER_INSTALL_METHOD;
+
+	t.true(called);
+});
+
+test('updateCommand: does not run execute_bash for nix installations', async t => {
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (async () => {
+		return {
+			ok: true,
+			status: 200,
+			statusText: 'OK',
+			json: async () => ({
+				version: '99.99.99',
+				name: '@gguf/coder',
+			}),
+		} as unknown as Response;
+	}) as typeof fetch;
+
+	process.env.CODER_INSTALL_METHOD = 'nix';
+
+	let called = false;
+	const originalExecuteBash = toolRegistry.execute_bash;
+	toolRegistry.execute_bash = async ({ command }: { command: string }) => {
+		called = true;
+		return 'ok';
+	};
+
+	await updateCommand.handler([]);
+
+	// Cleanup
+	toolRegistry.execute_bash = originalExecuteBash;
+	globalThis.fetch = originalFetch;
+	delete process.env.CODER_INSTALL_METHOD;
+
+	t.false(called);
+});
+
+test('updateCommand: handles execute_bash failure with error message', async t => {
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (async () => {
+		return {
+			ok: true,
+			status: 200,
+			statusText: 'OK',
+			json: async () => ({
+				version: '99.99.99',
+				name: '@gguf/coder',
+			}),
+		} as unknown as Response;
+	}) as typeof fetch;
+
+	process.env.CODER_INSTALL_METHOD = 'npm';
+
+	const originalExecuteBash = toolRegistry.execute_bash;
+	toolRegistry.execute_bash = async () => {
+		throw new Error('command failed: permission denied');
+	};
+
+	const result = await updateCommand.handler([]);
+	// Expect the result is a React element with props.message containing 'Failed to execute'
+	// @ts-ignore
+	t.truthy(result.props?.message?.includes('Failed to execute'));
+
+	// Cleanup
+	toolRegistry.execute_bash = originalExecuteBash;
+	globalThis.fetch = originalFetch;
+	delete process.env.CODER_INSTALL_METHOD;
+});
+
+// Error Detection Tests
+// These tests verify the hasCommandFailed function correctly identifies failures
+
+test('hasCommandFailed: detects failure via exit code', t => {
+	const output = 'EXIT_CODE: 1\nSome error occurred';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects success via exit code 0', t => {
+	const output = 'EXIT_CODE: 0\nSuccess message';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "command not found" error', t => {
+	const output = 'EXIT_CODE: 127\nSTDERR:\nbash: foobar: command not found';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "permission denied" error', t => {
+	const output = 'EXIT_CODE: 1\nSTDERR:\npermission denied';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "no such file or directory" error', t => {
+	const output = 'EXIT_CODE: 2\nSTDERR:\nno such file or directory';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: does not false positive on "0 errors"', t => {
+	const output = 'EXIT_CODE: 0\nBuild completed with 0 errors';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: does not false positive on "error-free"', t => {
+	const output = 'EXIT_CODE: 0\nThe build was error-free';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: does not false positive on "no errors found"', t => {
+	const output = 'EXIT_CODE: 0\nScan complete: no errors found';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "error:" at start of line', t => {
+	const output = 'EXIT_CODE: 1\nSTDERR:\nerror: something went wrong';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "fatal" error', t => {
+	const output = 'EXIT_CODE: 1\nSTDERR:\nfatal: Not a git repository';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: detects "failed" message', t => {
+	const output = 'EXIT_CODE: 1\nSTDERR:\nOperation failed';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: handles output with only STDERR (non-error)', t => {
+	// Some tools write progress to stderr
+	const output = 'EXIT_CODE: 0\nSTDERR:\nDownloading... 100%\nSTDOUT:\nSuccess';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: handles output with only STDERR (with error)', t => {
+	const output =
+		'EXIT_CODE: 1\nSTDERR:\nDownload failed due to network error\nSTDOUT:\n';
+	t.true(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: handles empty output', t => {
+	const output = '';
+	t.false(hasCommandFailed(output));
+});
+
+test('hasCommandFailed: handles null/undefined output', t => {
+	// @ts-ignore - testing edge case
+	t.false(hasCommandFailed(null));
+	// @ts-ignore - testing edge case
+	t.false(hasCommandFailed(undefined));
+});
+
+test('hasCommandFailed: exit code takes precedence over success messages', t => {
+	// Even if output looks successful, exit code 1 means failure
+	const output = 'EXIT_CODE: 1\nAll tests passed successfully!';
+	t.true(hasCommandFailed(output));
+});
+
+// Homebrew error handling
+test('updateCommand: detects homebrew "not found" error', t => {
+	const output =
+		'EXIT_CODE: 1\nSTDERR:\nError: coder not found in Homebrew\nPlease install it first with: brew install coder';
+	t.true(hasCommandFailed(output));
+});
+
+// Edge case: both updateCommand and updateMessage undefined
+test('updateCommand: handles edge case when both updateCommand and updateMessage are undefined', async t => {
+	const originalFetch = globalThis.fetch;
+	globalThis.fetch = (async () => {
+		return {
+			ok: true,
+			status: 200,
+			statusText: 'OK',
+			json: async () => ({
+				version: '99.99.99',
+				name: '@gguf/coder',
+			}),
+		} as unknown as Response;
+	}) as typeof fetch;
+
+	// Set an unknown installation method that won't return a command or message
+	process.env.CODER_INSTALL_METHOD = 'unknown';
+
+	const result = await updateCommand.handler([]);
+
+	// Should return the fallback InfoMessage
+	// @ts-ignore - accessing React element props
+	t.truthy(result.props?.message);
+	// @ts-ignore
+	t.regex(result.props.message, /package manager/i);
+
+	// Cleanup
+	globalThis.fetch = originalFetch;
+	delete process.env.CODER_INSTALL_METHOD;
+});
+
+// Note: Full integration tests with mocking would require a more sophisticated
+// test setup with module mocking capabilities. The update-checker.spec.ts file
+// provides comprehensive coverage of the update checking logic itself.
+// This file focuses on verifying the command is properly structured and registered.

package/source/commands/update.tsx

@@ -0,0 +1,201 @@
+import {
+	ErrorMessage,
+	InfoMessage,
+	SuccessMessage,
+} from '@/components/message-box';
+import { spawn } from 'node:child_process';
+import { Command } from '@/types/index';
+import { logError, logInfo } from '@/utils/message-queue';
+import { checkForUpdates } from '@/utils/update-checker';
+import React from 'react';
+
+/**
+ * Determines if a command execution failed based on multiple signals.
+ * Checks exit code first (most reliable), then looks for specific error patterns.
+ * Exported for testing purposes.
+ */
+export function hasCommandFailed(output: string): boolean {
+	const outputStr = String(output || '');
+
+	// Strategy 1: Check exit code (most reliable)
+	const exitCodeMatch = outputStr.match(/^EXIT_CODE:\s*(\d+)/m);
+	if (exitCodeMatch) {
+		const exitCode = parseInt(exitCodeMatch[1], 10);
+		// Non-zero exit code indicates failure
+		if (exitCode !== 0) {
+			return true;
+		}
+	}
+
+	// Strategy 2: Check for critical error patterns
+	// Use word boundaries and case-sensitive matching to avoid false positives
+	const normalized = outputStr.toLowerCase();
+
+	// Critical errors that definitively indicate failure
+	const criticalErrors = [
+		/\bcommand not found\b/i,
+		/\bno such file or directory\b/i,
+		/\bpermission denied\b/i,
+		/^error:/im, // Error at start of line
+		/\berror:\s*(?!0\b)/i, // "error:" not followed by 0
+		/\bfatal\b/i,
+		/\bfailed\b/i,
+		/\bcannot\b/i,
+	];
+
+	for (const pattern of criticalErrors) {
+		if (pattern.test(normalized)) {
+			// Additional check: avoid false positives for success messages
+			// like "0 errors", "error-free", "no errors found"
+			if (/0\s*errors?|error-?free|no\s*errors?\s*found/i.test(normalized)) {
+				continue;
+			}
+			return true;
+		}
+	}
+
+	// Strategy 3: Check if STDERR has content (warning: not always an error)
+	// Some tools write progress to stderr, so this is a weak signal
+	// Only use this if no other signals present
+	const hasStderr = /^STDERR:\s*\S/m.test(outputStr);
+	if (hasStderr) {
+		// Check if stderr contains actual error indicators, not just warnings/info
+		const stderrMatch = outputStr.match(/^STDERR:\s*([\s\S]*?)(?:^STDOUT:|$)/m);
+		if (stderrMatch) {
+			const stderrContent = stderrMatch[1].toLowerCase();
+			// Only treat as error if stderr contains error-like content
+			if (/\berror\b|\bfatal\b|\bfailed\b|\bcannot\b/i.test(stderrContent)) {
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+export const updateCommand: Command = {
+	name: 'update',
+	description: 'Update Coder to the latest version',
+	handler: async (_args: string[]) => {
+		// Show initial checking message
+		logInfo('Checking for available updates...', true);
+
+		try {
+			const updateInfo = await checkForUpdates();
+
+			if (updateInfo.error) {
+				const is404 = updateInfo.error.includes('404');
+				const message = is404
+					? 'Update check failed: Package not found in registry (HTTP 404). This version might be a private or local build.'
+					: `Failed to check for updates: ${updateInfo.error}`;
+
+				logError(message, true);
+				return React.createElement(ErrorMessage, {
+					message,
+					hideBox: true,
+				});
+			}
+
+			if (updateInfo.hasUpdate) {
+				// Show updating message
+				logInfo(
+					'Downloading and installing the latest Coder update...',
+					true,
+				);
+
+				// Run update command if provided; otherwise show informative message
+				if (updateInfo.updateCommand) {
+					try {
+						const result = await new Promise<string>((resolve, reject) => {
+							const proc = spawn(updateInfo.updateCommand!, {
+								shell: true,
+								stdio: ['ignore', 'pipe', 'pipe'],
+							});
+							let stdout = '';
+							let stderr = '';
+
+							proc.stdout.on('data', (data: Buffer) => {
+								stdout += data.toString();
+							});
+
+							proc.stderr.on('data', (data: Buffer) => {
+								stderr += data.toString();
+							});
+
+							proc.on('close', (code: number | null) => {
+								const exitCodeInfo =
+									code !== null ? `EXIT_CODE: ${code}\n` : '';
+								if (stderr) {
+									resolve(
+										`${exitCodeInfo}STDERR:\n${stderr}\nSTDOUT:\n${stdout}`,
+									);
+								} else {
+									resolve(`${exitCodeInfo}${stdout}`);
+								}
+							});
+
+							proc.on('error', error => {
+								reject(
+									new Error(`Error executing command: ${error.message}`),
+								);
+							});
+						});
+
+						// Check for command failure using multiple strategies
+						if (hasCommandFailed(result)) {
+							logError('Update command executed but returned an error', true);
+							return React.createElement(ErrorMessage, {
+								message: `Update command failed. Output: ${String(result)}`,
+								hideBox: true,
+							});
+						}
+
+						// Show success message
+						return React.createElement(SuccessMessage, {
+							message:
+								'Coder has been updated to the latest version. Please restart your session to apply the update.',
+							hideBox: true,
+						});
+					} catch (err) {
+						const errorMessage =
+							err instanceof Error ? err.message : String(err);
+						logError(`Failed to execute update command: ${errorMessage}`, true);
+						return React.createElement(ErrorMessage, {
+							message: `Failed to execute update command: ${errorMessage}`,
+							hideBox: true,
+						});
+					}
+				}
+
+				if (updateInfo.updateMessage) {
+					// We cannot run an automated update; show instructions to user
+					return React.createElement(InfoMessage, {
+						message: updateInfo.updateMessage,
+						hideBox: true,
+					});
+				}
+
+				// Fallback for unknown installation method
+				return React.createElement(InfoMessage, {
+					message:
+						'A new version is available. Please update using your package manager.',
+					hideBox: true,
+				});
+			} else {
+				// Already up to date
+				return React.createElement(InfoMessage, {
+					message: 'You are already on the latest version.',
+					hideBox: true,
+				});
+			}
+		} catch (error) {
+			const errorMessage =
+				error instanceof Error ? error.message : String(error);
+			logError(`Failed to update Coder: ${errorMessage}`, true);
+			return React.createElement(ErrorMessage, {
+				message: `Failed to check for updates: ${errorMessage}`,
+				hideBox: true,
+			});
+		}
+	},
+};