@kikkimo/claude-launcher 1.0.0 → 2.1.0

package/lib/utils/string-width.js

@@ -0,0 +1,180 @@
+/**
+ * String Width Utilities - Handle multi-language character width calculations
+ * Properly calculates display width for CJK (Chinese, Japanese, Korean) characters
+ */
+
+/**
+ * Get the display width of a string in terminal
+ * @param {string} str - The string to measure
+ * @returns {number} - Display width in terminal columns
+ */
+function getStringWidth(str) {
+    if (!str || typeof str !== 'string') {
+        return 0;
+    }
+
+    let width = 0;
+
+    // Remove ANSI color codes for accurate width calculation
+    const cleanStr = str.replace(/\x1b\[[0-9;]*m/g, '');
+
+    for (const char of cleanStr) {
+        const code = char.codePointAt(0);
+
+        if (code == null) {
+            continue;
+        }
+
+        // East Asian Full Width characters (including Chinese)
+        if (isFullWidth(code)) {
+            width += 2;
+        }
+        // Control characters (width 0)
+        else if (isControlCharacter(code)) {
+            width += 0;
+        }
+        // Normal characters (width 1)
+        else {
+            width += 1;
+        }
+    }
+
+    return width;
+}
+
+/**
+ * Pad string to specified display width (considering CJK characters)
+ * @param {string} str - String to pad
+ * @param {number} targetWidth - Target display width
+ * @param {string} padChar - Character to pad with (default: space)
+ * @param {string} padDirection - 'end' or 'start' (default: 'end')
+ * @returns {string} - Padded string
+ */
+function padStringToWidth(str, targetWidth, padChar = ' ', padDirection = 'end') {
+    const currentWidth = getStringWidth(str);
+    const paddingNeeded = Math.max(0, targetWidth - currentWidth);
+    const padding = padChar.repeat(paddingNeeded);
+
+    return padDirection === 'start' ? padding + str : str + padding;
+}
+
+/**
+ * Truncate string to specified display width (considering CJK characters)
+ * @param {string} str - String to truncate
+ * @param {number} maxWidth - Maximum display width
+ * @param {string} ellipsis - Ellipsis string (default: '...')
+ * @returns {string} - Truncated string
+ */
+function truncateStringToWidth(str, maxWidth, ellipsis = '...') {
+    const ellipsisWidth = getStringWidth(ellipsis);
+
+    if (getStringWidth(str) <= maxWidth) {
+        return str;
+    }
+
+    if (maxWidth <= ellipsisWidth) {
+        return ellipsis.substring(0, maxWidth);
+    }
+
+    let width = 0;
+    let result = '';
+
+    for (const char of str) {
+        const charWidth = getStringWidth(char);
+
+        if (width + charWidth + ellipsisWidth > maxWidth) {
+            break;
+        }
+
+        result += char;
+        width += charWidth;
+    }
+
+    return result + ellipsis;
+}
+
+/**
+ * Check if a character code represents a full-width character
+ * @param {number} code - Unicode code point
+ * @returns {boolean} - True if full-width
+ */
+function isFullWidth(code) {
+    // Based on Unicode East Asian Width property
+    // Full Width (F) and Wide (W) characters
+    return (
+        // CJK Unified Ideographs
+        (code >= 0x4E00 && code <= 0x9FFF) ||
+        // CJK Compatibility Ideographs
+        (code >= 0xF900 && code <= 0xFAFF) ||
+        // CJK Unified Ideographs Extension A
+        (code >= 0x3400 && code <= 0x4DBF) ||
+        // CJK Unified Ideographs Extension B
+        (code >= 0x20000 && code <= 0x2A6DF) ||
+        // CJK Unified Ideographs Extension C
+        (code >= 0x2A700 && code <= 0x2B73F) ||
+        // CJK Unified Ideographs Extension D
+        (code >= 0x2B740 && code <= 0x2B81F) ||
+        // CJK Unified Ideographs Extension E
+        (code >= 0x2B820 && code <= 0x2CEAF) ||
+        // CJK Symbols and Punctuation
+        (code >= 0x3000 && code <= 0x303F) ||
+        // Hiragana
+        (code >= 0x3040 && code <= 0x309F) ||
+        // Katakana
+        (code >= 0x30A0 && code <= 0x30FF) ||
+        // Halfwidth and Fullwidth Forms (Fullwidth part)
+        (code >= 0xFF01 && code <= 0xFF60) ||
+        // CJK Compatibility Forms
+        (code >= 0xFE30 && code <= 0xFE4F) ||
+        // Other common full-width characters
+        code === 0x3000 || // Ideographic space
+        code === 0xFF0C || // Fullwidth comma
+        code === 0xFF0E || // Fullwidth full stop
+        code === 0xFF1A || // Fullwidth colon
+        code === 0xFF1B || // Fullwidth semicolon
+        code === 0xFF1F || // Fullwidth question mark
+        code === 0xFF01   // Fullwidth exclamation mark
+    );
+}
+
+/**
+ * Check if a character code represents a control character
+ * @param {number} code - Unicode code point
+ * @returns {boolean} - True if control character
+ */
+function isControlCharacter(code) {
+    return (
+        // C0 Controls
+        (code >= 0x0000 && code <= 0x001F) ||
+        // DEL
+        code === 0x007F ||
+        // C1 Controls
+        (code >= 0x0080 && code <= 0x009F)
+    );
+}
+
+/**
+ * Create a line with proper alignment for mixed-width content
+ * @param {string} left - Left content
+ * @param {string} right - Right content
+ * @param {number} totalWidth - Total line width
+ * @param {string} fillChar - Fill character (default: space)
+ * @returns {string} - Aligned line
+ */
+function createAlignedLine(left, right, totalWidth, fillChar = ' ') {
+    const leftWidth = getStringWidth(left);
+    const rightWidth = getStringWidth(right);
+    const fillWidth = Math.max(0, totalWidth - leftWidth - rightWidth);
+    const fill = fillChar.repeat(fillWidth);
+
+    return left + fill + right;
+}
+
+module.exports = {
+    getStringWidth,
+    padStringToWidth,
+    truncateStringToWidth,
+    createAlignedLine,
+    isFullWidth,
+    isControlCharacter
+};

package/lib/utils/version-checker.js

@@ -0,0 +1,240 @@
+/**
+ * Version Check Module
+ * Checks for updates from npm registry with persistent config file caching
+ */
+
+const https = require('https');
+const fs = require('fs').promises;
+const path = require('path');
+const os = require('os');
+
+/**
+ * Get configuration file path
+ */
+function getConfigPath() {
+    return path.join(os.homedir(), '.claude-launcher-config.json');
+}
+
+/**
+ * Load configuration from file
+ */
+async function loadConfig() {
+    try {
+        const configPath = getConfigPath();
+        const data = await fs.readFile(configPath, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        // Return default config if file doesn't exist
+        return {
+            language: 'zh',
+            lastVersionCheck: 0,
+            cachedLatestVersion: null
+        };
+    }
+}
+
+/**
+ * Save configuration to file
+ */
+async function saveConfig(config) {
+    try {
+        const configPath = getConfigPath();
+        await fs.writeFile(configPath, JSON.stringify(config, null, 2), 'utf8');
+    } catch (error) {
+        // Silently fail - not critical
+    }
+}
+
+/**
+ * Fetch latest version from npm registry with timeout
+ * @param {string} packageName - Package name to check
+ * @param {number} timeoutMs - Timeout in milliseconds (default: 15000)
+ */
+function fetchLatestVersion(packageName, timeoutMs = 15000) {
+    return new Promise((resolve, reject) => {
+        const url = `https://registry.npmjs.org/${packageName}/latest`;
+
+        const req = https.get(url, (res) => {
+            let data = '';
+
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                try {
+                    const json = JSON.parse(data);
+                    resolve(json.version);
+                } catch (error) {
+                    reject(new Error(`Failed to parse response: ${error.message}`));
+                }
+            });
+        }).on('error', (err) => {
+            reject(new Error(`Network error: ${err.message}`));
+        });
+
+        // Set timeout
+        req.setTimeout(timeoutMs, () => {
+            req.destroy();
+            reject(new Error(`Request timeout (${timeoutMs}ms)`));
+        });
+    });
+}
+
+/**
+ * Compare version strings (semantic versioning)
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+function compareVersions(v1, v2) {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+
+    for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+        const part1 = parts1[i] || 0;
+        const part2 = parts2[i] || 0;
+
+        if (part1 > part2) return 1;
+        if (part1 < part2) return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Check for updates with persistent config file caching
+ * @param {boolean} force - Force check regardless of cache
+ * @param {number} intervalHours - Cache duration in hours (default: 12)
+ * @returns {Promise<{available: boolean, currentVersion: string, latestVersion: string, packageUrl: string}>}
+ */
+async function checkForUpdates(force = false, intervalHours = 12) {
+    const CACHE_DURATION = intervalHours * 60 * 60 * 1000; // Convert hours to milliseconds
+    try {
+        const packageInfo = require('../../package.json');
+        const currentVersion = packageInfo.version;
+        const packageName = packageInfo.name;
+        const packageUrl = `https://www.npmjs.com/package/${packageName}`;
+
+        // Load config to check cache
+        const config = await loadConfig();
+        const now = Date.now();
+
+        // Check if we need to fetch the online version
+        const needsCheck = force ||
+                          !config.cachedLatestVersion ||
+                          !config.lastVersionCheck ||
+                          (now - config.lastVersionCheck > CACHE_DURATION);
+
+        let latestVersion;
+
+        if (needsCheck) {
+            // Need to check online
+            try {
+                latestVersion = await fetchLatestVersion(packageName);
+
+                // Update config file cache
+                config.cachedLatestVersion = latestVersion;
+                config.lastVersionCheck = now;
+                await saveConfig(config);
+
+            } catch (networkError) {
+                // Use cached version on network error, fallback to current version if no cache
+                latestVersion = config.cachedLatestVersion || currentVersion;
+            }
+        } else {
+            // Use cached version from config file
+            latestVersion = config.cachedLatestVersion;
+        }
+
+        // Compare versions
+        const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+
+        return {
+            available: updateAvailable,
+            currentVersion,
+            latestVersion,
+            packageUrl,
+            fromCache: !needsCheck
+        };
+
+    } catch (error) {
+        // Return current version info on error
+        const packageInfo = require('../../package.json');
+        return {
+            available: false,
+            currentVersion: packageInfo.version,
+            latestVersion: packageInfo.version,
+            packageUrl: `https://www.npmjs.com/package/${packageInfo.name}`,
+            error: true
+        };
+    }
+}
+
+/**
+ * Clear the config file cache (force next check to be from network)
+ */
+async function clearCache() {
+    try {
+        const config = await loadConfig();
+        config.lastVersionCheck = 0;
+        config.cachedLatestVersion = null;
+        await saveConfig(config);
+    } catch (error) {
+        // Silently fail
+    }
+}
+
+/**
+ * Force check for updates (always check online, ignore cache, with custom timeout)
+ * @param {number} timeoutMs - Timeout in milliseconds (default: 15000)
+ * @returns {Promise<{available: boolean, currentVersion: string, latestVersion: string, packageUrl: string, error?: string}>}
+ */
+async function forceCheckForUpdates(timeoutMs = 15000) {
+    try {
+        const packageInfo = require('../../package.json');
+        const currentVersion = packageInfo.version;
+        const packageName = packageInfo.name;
+        const packageUrl = `https://www.npmjs.com/package/${packageName}`;
+
+        // Always fetch from network
+        const latestVersion = await fetchLatestVersion(packageName, timeoutMs);
+
+        // Update config cache with new result
+        try {
+            const config = await loadConfig();
+            config.cachedLatestVersion = latestVersion;
+            config.lastVersionCheck = Date.now();
+            await saveConfig(config);
+        } catch (configError) {
+            // Ignore config save errors
+        }
+
+        // Compare versions
+        const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
+
+        return {
+            available: updateAvailable,
+            currentVersion,
+            latestVersion,
+            packageUrl
+        };
+
+    } catch (error) {
+        // Return error information
+        const packageInfo = require('../../package.json');
+        return {
+            available: false,
+            currentVersion: packageInfo.version,
+            latestVersion: packageInfo.version,
+            packageUrl: `https://www.npmjs.com/package/${packageInfo.name}`,
+            error: error.message
+        };
+    }
+}
+
+module.exports = {
+    checkForUpdates,
+    forceCheckForUpdates,
+    clearCache,
+    loadConfig,
+    saveConfig
+};

package/lib/validators.js

@@ -0,0 +1,130 @@
+/**
+ * Validators Module - Input validation functions
+ */
+
+const i18n = require('./i18n');
+
+/**
+ * Validate base URL format
+ */
+function validateBaseUrl(url) {
+    if (!url || url.trim() === '') {
+        return { valid: false, error: i18n.tSync('errors.validation.base_url_empty') };
+    }
+
+    try {
+        const urlObj = new URL(url);
+
+        // Ensure it's HTTP or HTTPS
+        if (!['http:', 'https:'].includes(urlObj.protocol)) {
+            return { valid: false, error: 'URL must use HTTP or HTTPS protocol' };
+        }
+
+        return { valid: true, value: url.trim() };
+    } catch (error) {
+        return { valid: false, error: i18n.tSync('errors.validation.invalid_url_format') };
+    }
+}
+
+/**
+ * Validate authentication token
+ */
+function validateAuthToken(token) {
+    if (!token || token.trim() === '') {
+        return { valid: false, error: i18n.tSync('errors.validation.auth_token_empty') };
+    }
+
+    if (token.length < 10) {
+        return { valid: false, error: i18n.tSync('errors.validation.auth_token_too_short') };
+    }
+
+    return { valid: true, value: token.trim() };
+}
+
+/**
+ * Validate model name
+ */
+function validateModel(model) {
+    if (!model || model.trim() === '') {
+        return { valid: false, error: i18n.tSync('errors.validation.model_name_empty') };
+    }
+
+    // Check for common model name patterns
+    const validPatterns = [
+        /^claude-/i,           // Claude models
+        /^gpt-/i,              // OpenAI models
+        /^gemini-/i,           // Google models
+        /^llama-/i,            // Meta models
+        /^mistral-/i,          // Mistral models
+        /^deepseek-/i,         // DeepSeek models
+        /^qwen-/i,             // Qwen models
+        /^moonshot-/i,         // Moonshot models
+    ];
+
+    const hasValidPattern = validPatterns.some(pattern => pattern.test(model));
+
+    if (!hasValidPattern && model.length < 3) {
+        return { valid: false, error: i18n.tSync('errors.validation.model_name_invalid') };
+    }
+
+    return { valid: true, value: model.trim() };
+}
+
+/**
+ * Validate API name
+ */
+function validateApiName(name) {
+    if (!name || name.trim() === '') {
+        return { valid: true, value: '' }; // Name is optional
+    }
+
+    if (name.length > 20) {
+        return { valid: false, error: 'Name is too long (maximum 20 characters)' };
+    }
+
+    // Check for invalid characters
+    if (!/^[a-zA-Z0-9\s\-_\.]+$/.test(name)) {
+        return { valid: false, error: 'Name contains invalid characters' };
+    }
+
+    return { valid: true, value: name.trim() };
+}
+
+/**
+ * Mask sensitive data for display
+ */
+function maskSensitiveData(data, visibleChars = 4) {
+    if (!data || data.length <= visibleChars * 2) {
+        return '***';
+    }
+    return data.substring(0, visibleChars) + '***' + data.substring(data.length - visibleChars);
+}
+
+/**
+ * Mask API token for display with optimized formatting
+ */
+function maskApiToken(token) {
+    if (!token || typeof token !== 'string') {
+        return '***INVALID***';
+    }
+
+    // Handle different token lengths according to requirements
+    if (token.length < 10) {
+        return '***INVALID_API***';
+    } else if (token.length >= 16) {
+        // Show first 10, last 6, middle 16 stars: sk-a53*************e2bc
+        return token.substring(0, 10) + '*'.repeat(16) + token.substring(token.length - 6);
+    } else {
+        // Length 10-15: Show first 5, last 5, middle 16 stars
+        return token.substring(0, 5) + '*'.repeat(16) + token.substring(token.length - 5);
+    }
+}
+
+module.exports = {
+    validateBaseUrl,
+    validateAuthToken,
+    validateModel,
+    validateApiName,
+    maskSensitiveData,
+    maskApiToken
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kikkimo/claude-launcher",
-  "version": "1.0.0",
+  "version": "2.1.0",
   "description": "Interactive launcher for Claude Code with beautiful Claude-style interface",
   "main": "claude-launcher",
   "bin": {
@@ -18,7 +18,7 @@
   },
   "files": [
     "claude-launcher",
-    "claude-launcher-template.env",
+    "lib/",
     "README.md",
     "LICENSE",
     "CHANGELOG.md",