vibecodingmachine-core 1.0.2 → 2025.11.2-7.1302

package/src/utils/update-checker.js

@@ -1,167 +1,227 @@
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Check for updates from npm registry
- * @param {string} packageName - Name of the package to check (e.g., 'vibecodingmachine-cli')
- * @param {string} currentVersion - Current version (e.g., '1.0.0')
- * @returns {Promise<Object>} Update info or null if no update available
- */
-async function checkForUpdates(packageName, currentVersion) {
-  return new Promise((resolve, reject) => {
-    const registryUrl = `https://registry.npmjs.org/${packageName}`;
-
-    https.get(registryUrl, (res) => {
-      let data = '';
-
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-
-      res.on('end', () => {
-        try {
-          const packageInfo = JSON.parse(data);
-          const latestVersion = packageInfo['dist-tags'].latest;
-
-          if (latestVersion !== currentVersion) {
-            const versionInfo = packageInfo.versions[latestVersion];
-            const publishedDate = new Date(packageInfo.time[latestVersion]);
-
-            resolve({
-              hasUpdate: true,
-              currentVersion,
-              latestVersion,
-              publishedDate: publishedDate.toLocaleString('en-US', {
-                year: 'numeric',
-                month: '2-digit',
-                day: '2-digit',
-                hour: '2-digit',
-                minute: '2-digit',
-                timeZoneName: 'short'
-              }),
-              packageName,
-              description: versionInfo.description || ''
-            });
-          } else {
-            resolve({
-              hasUpdate: false,
-              currentVersion,
-              latestVersion,
-              packageName
-            });
-          }
-        } catch (error) {
-          console.error('Error parsing registry response:', error);
-          resolve({ hasUpdate: false, currentVersion, packageName, error: error.message });
-        }
-      });
-    }).on('error', (error) => {
-      console.error('Error checking for updates:', error);
-      resolve({ hasUpdate: false, currentVersion, packageName, error: error.message });
-    });
-  });
-}
-
-/**
- * Get update info cache file path
- * @param {string} packageName - Package name
- * @returns {string} Path to cache file
- */
-function getUpdateCachePath(packageName) {
-  const homeDir = require('os').homedir();
-  const cacheDir = path.join(homeDir, '.config', 'vibecodingmachine');
-
-  // Ensure cache directory exists
-  if (!fs.existsSync(cacheDir)) {
-    fs.mkdirSync(cacheDir, { recursive: true });
-  }
-
-  return path.join(cacheDir, `${packageName}-update-cache.json`);
-}
-
-/**
- * Load cached update info
- * @param {string} packageName - Package name
- * @returns {Object|null} Cached update info or null
- */
-function loadUpdateCache(packageName) {
-  try {
-    const cachePath = getUpdateCachePath(packageName);
-    if (fs.existsSync(cachePath)) {
-      const data = fs.readFileSync(cachePath, 'utf8');
-      const cache = JSON.parse(data);
-
-      // Cache is valid for 1 hour
-      const cacheAge = Date.now() - cache.checkedAt;
-      if (cacheAge < 3600000) { // 1 hour
-        return cache.updateInfo;
-      }
-    }
-  } catch (error) {
-    console.error('Error loading update cache:', error);
-  }
-  return null;
-}
-
-/**
- * Save update info to cache
- * @param {string} packageName - Package name
- * @param {Object} updateInfo - Update info to cache
- */
-function saveUpdateCache(packageName, updateInfo) {
-  try {
-    const cachePath = getUpdateCachePath(packageName);
-    const cache = {
-      checkedAt: Date.now(),
-      updateInfo
-    };
-    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
-  } catch (error) {
-    console.error('Error saving update cache:', error);
-  }
-}
-
-/**
- * Check for updates with caching
- * @param {string} packageName - Package name
- * @param {string} currentVersion - Current version
- * @param {boolean} forceCheck - Force check even if cache is valid
- * @returns {Promise<Object>} Update info
- */
-async function checkForUpdatesWithCache(packageName, currentVersion, forceCheck = false) {
-  if (!forceCheck) {
-    const cached = loadUpdateCache(packageName);
-    if (cached) {
-      return cached;
-    }
-  }
-
-  const updateInfo = await checkForUpdates(packageName, currentVersion);
-  saveUpdateCache(packageName, updateInfo);
-  return updateInfo;
-}
-
-/**
- * Clear update notification (mark as dismissed)
- * @param {string} packageName - Package name
- */
-function clearUpdateNotification(packageName) {
-  try {
-    const cachePath = getUpdateCachePath(packageName);
-    if (fs.existsSync(cachePath)) {
-      fs.unlinkSync(cachePath);
-    }
-  } catch (error) {
-    console.error('Error clearing update notification:', error);
-  }
-}
-
-module.exports = {
-  checkForUpdates,
-  checkForUpdatesWithCache,
-  loadUpdateCache,
-  saveUpdateCache,
-  clearUpdateNotification,
-  getUpdateCachePath
-};
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Check for updates from npm registry
+ * @param {string} packageName - Name of the package to check (e.g., 'vibecodingmachine-cli')
+ * @param {string} currentVersion - Current version (e.g., '1.0.0')
+ * @returns {Promise<Object>} Update info or null if no update available
+ */
+async function checkForUpdates(packageName, currentVersion) {
+  return new Promise((resolve, reject) => {
+    const registryUrl = `https://registry.npmjs.org/${packageName}`;
+
+    https.get(registryUrl, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const packageInfo = JSON.parse(data);
+          const latestVersion = packageInfo['dist-tags'].latest;
+
+          if (latestVersion !== currentVersion) {
+            const versionInfo = packageInfo.versions[latestVersion];
+            const publishedDate = new Date(packageInfo.time[latestVersion]);
+
+            // Format date as YYYY-MM-DD
+            const year = publishedDate.getFullYear();
+            const month = String(publishedDate.getMonth() + 1).padStart(2, '0');
+            const day = String(publishedDate.getDate()).padStart(2, '0');
+            const formattedDate = `${year}-${month}-${day}`;
+
+            resolve({
+              hasUpdate: true,
+              currentVersion,
+              latestVersion,
+              publishedDate: formattedDate,
+              packageName,
+              description: versionInfo.description || ''
+            });
+          } else {
+            resolve({
+              hasUpdate: false,
+              currentVersion,
+              latestVersion,
+              packageName
+            });
+          }
+        } catch (error) {
+          console.error('Error parsing registry response:', error);
+          resolve({ hasUpdate: false, currentVersion, packageName, error: error.message });
+        }
+      });
+    }).on('error', (error) => {
+      console.error('Error checking for updates:', error);
+      resolve({ hasUpdate: false, currentVersion, packageName, error: error.message });
+    });
+  });
+}
+
+/**
+ * Check for CLI updates from S3 version manifest (unified with Electron)
+ * Both CLI and Electron now use the same timestamp-based versioning from git commits
+ * @param {string} currentVersion - Current CLI version (e.g., '2025.11.26.0519')
+ * @returns {Promise<Object>} Update info or null if no update available
+ */
+async function checkForCLIUpdates(currentVersion) {
+  return new Promise((resolve, reject) => {
+    const manifestUrl = `https://vibecodingmachine-website.s3.amazonaws.com/downloads/version.json?t=${Date.now()}`;
+
+    https.get(manifestUrl, (res) => {
+      let data = '';
+
+      // Check HTTP status code
+      if (res.statusCode !== 200) {
+        console.log(`ℹ️ Update check skipped: version manifest not available (HTTP ${res.statusCode})`);
+        resolve({ hasUpdate: false, currentVersion, error: `HTTP ${res.statusCode}` });
+        return;
+      }
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        try {
+          const manifest = JSON.parse(data);
+          const latestVersion = manifest.version;
+          const publishedDate = manifest.date;
+
+          if (latestVersion !== currentVersion) {
+            resolve({
+              hasUpdate: true,
+              currentVersion,
+              latestVersion,
+              publishedDate,
+              commit: manifest.commit || 'Unknown',
+              packageName: 'vibecodingmachine-cli'
+            });
+          } else {
+            resolve({
+              hasUpdate: false,
+              currentVersion,
+              latestVersion
+            });
+          }
+        } catch (error) {
+          console.error('Error parsing version manifest:', error);
+          resolve({ hasUpdate: false, currentVersion, error: error.message });
+        }
+      });
+    }).on('error', (error) => {
+      console.error('Error checking for CLI updates:', error);
+      resolve({ hasUpdate: false, currentVersion, error: error.message });
+    });
+  });
+}
+
+
+/**
+ * Get update info cache file path
+ * @param {string} packageName - Package name
+ * @returns {string} Path to cache file
+ */
+function getUpdateCachePath(packageName) {
+  const homeDir = require('os').homedir();
+  const cacheDir = path.join(homeDir, '.config', 'vibecodingmachine');
+
+  // Ensure cache directory exists
+  if (!fs.existsSync(cacheDir)) {
+    fs.mkdirSync(cacheDir, { recursive: true });
+  }
+
+  return path.join(cacheDir, `${packageName}-update-cache.json`);
+}
+
+/**
+ * Load cached update info
+ * @param {string} packageName - Package name
+ * @returns {Object|null} Cached update info or null
+ */
+function loadUpdateCache(packageName) {
+  try {
+    const cachePath = getUpdateCachePath(packageName);
+    if (fs.existsSync(cachePath)) {
+      const data = fs.readFileSync(cachePath, 'utf8');
+      const cache = JSON.parse(data);
+
+      // Cache is valid for 1 hour
+      const cacheAge = Date.now() - cache.checkedAt;
+      if (cacheAge < 3600000) { // 1 hour
+        return cache.updateInfo;
+      }
+    }
+  } catch (error) {
+    console.error('Error loading update cache:', error);
+  }
+  return null;
+}
+
+/**
+ * Save update info to cache
+ * @param {string} packageName - Package name
+ * @param {Object} updateInfo - Update info to cache
+ */
+function saveUpdateCache(packageName, updateInfo) {
+  try {
+    const cachePath = getUpdateCachePath(packageName);
+    const cache = {
+      checkedAt: Date.now(),
+      updateInfo
+    };
+    fs.writeFileSync(cachePath, JSON.stringify(cache, null, 2));
+  } catch (error) {
+    console.error('Error saving update cache:', error);
+  }
+}
+
+/**
+ * Check for updates with caching
+ * @param {string} packageName - Package name
+ * @param {string} currentVersion - Current version
+ * @param {boolean} forceCheck - Force check even if cache is valid
+ * @returns {Promise<Object>} Update info
+ */
+async function checkForUpdatesWithCache(packageName, currentVersion, forceCheck = false) {
+  if (!forceCheck) {
+    const cached = loadUpdateCache(packageName);
+    if (cached) {
+      return cached;
+    }
+  }
+
+  const updateInfo = await checkForUpdates(packageName, currentVersion);
+  saveUpdateCache(packageName, updateInfo);
+  return updateInfo;
+}
+
+/**
+ * Clear update notification (mark as dismissed)
+ * @param {string} packageName - Package name
+ */
+function clearUpdateNotification(packageName) {
+  try {
+    const cachePath = getUpdateCachePath(packageName);
+    if (fs.existsSync(cachePath)) {
+      fs.unlinkSync(cachePath);
+    }
+  } catch (error) {
+    console.error('Error clearing update notification:', error);
+  }
+}
+
+module.exports = {
+  checkForUpdates,
+  checkForCLIUpdates,
+  checkForUpdatesWithCache,
+  loadUpdateCache,
+  saveUpdateCache,
+  clearUpdateNotification,
+  getUpdateCachePath
+};
+

package/src/utils/version-checker.js

@@ -0,0 +1,169 @@
+/**
+ * Version Checker - Check for updates and manage version display
+ */
+
+const fetch = require('node-fetch');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const CACHE_FILE = path.join(os.tmpdir(), 'vibecodingmachine-version-cache.json');
+const CACHE_DURATION = 1000 * 60 * 60; // 1 hour
+const VERSION_URL = 'https://vibecodingmachine-website.s3.amazonaws.com/downloads/version.json';
+
+/**
+ * Format version timestamp to YYYY.MM.DD.HHMM UTC
+ */
+function formatVersionTimestamp(versionString) {
+  // Version format: YYYY.MM.DD.HHMM
+  const match = versionString.match(/^(\d{4})\.(\d{2})\.(\d{2})\.(\d{2})(\d{2})$/);
+  if (!match) return versionString;
+
+  const [, year, month, day, hour, minute] = match;
+  return `${year}.${month}.${day}.${hour}${minute} UTC`;
+}
+
+/**
+ * Get formatted local time from UTC timestamp
+ */
+function formatLocalTime(isoTimestamp) {
+  try {
+    const date = new Date(isoTimestamp);
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timeZoneAbbr = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      timeZoneName: 'short'
+    }).format(date).split(' ').pop();
+
+    const formatted = new Intl.DateTimeFormat('en-US', {
+      year: 'numeric',
+      month: '2-digit',
+      day: '2-digit',
+      hour: '2-digit',
+      minute: '2-digit',
+      hour12: false
+    }).format(date);
+
+    // Convert to YYYY.MM.DD.HHMM format
+    const parts = formatted.match(/(\d{2})\/(\d{2})\/(\d{4}), (\d{2}):(\d{2})/);
+    if (parts) {
+      const [, month, day, year, hour, minute] = parts;
+      return `${year}.${month}.${day}.${hour}${minute} ${timeZoneAbbr}`;
+    }
+
+    return formatted + ' ' + timeZoneAbbr;
+  } catch (error) {
+    return isoTimestamp;
+  }
+}
+
+/**
+ * Check for updates with caching
+ */
+async function checkForUpdatesWithCache(packageName, currentVersion) {
+  try {
+    // Check cache first
+    if (fs.existsSync(CACHE_FILE)) {
+      const cache = JSON.parse(fs.readFileSync(CACHE_FILE, 'utf8'));
+      if (cache.timestamp && Date.now() - cache.timestamp < CACHE_DURATION) {
+        return {
+          ...cache.data,
+          fromCache: true
+        };
+      }
+    }
+
+    // Fetch latest version info
+    const response = await fetch(VERSION_URL);
+    if (!response.ok) {
+      return { hasUpdate: false, currentVersion };
+    }
+
+    const versionInfo = await response.json();
+    const latestVersion = versionInfo.version;
+
+    const result = {
+      hasUpdate: latestVersion !== currentVersion,
+      currentVersion,
+      latestVersion,
+      publishedDate: versionInfo.date ? formatLocalTime(versionInfo.date) : 'Unknown',
+      commit: versionInfo.commit || 'Unknown',
+      downloadUrl: getDownloadUrl()
+    };
+
+    // Cache result
+    fs.writeFileSync(CACHE_FILE, JSON.stringify({
+      timestamp: Date.now(),
+      data: result
+    }));
+
+    return result;
+  } catch (error) {
+    return {
+      hasUpdate: false,
+      currentVersion,
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Get download URL for current platform
+ */
+function getDownloadUrl() {
+  const platform = os.platform();
+  const baseUrl = 'https://vibecodingmachine-website.s3.amazonaws.com/downloads';
+
+  if (platform === 'darwin') {
+    return `${baseUrl}/VibeCodingMachine.dmg`;
+  } else if (platform === 'win32') {
+    return `${baseUrl}/VibeCodingMachine-win32-x64.zip`;
+  }
+
+  return baseUrl;
+}
+
+/**
+ * Get current Electron app version
+ */
+async function getCurrentElectronVersion() {
+  try {
+    const response = await fetch(VERSION_URL);
+    if (!response.ok) {
+      return null;
+    }
+
+    const versionInfo = await response.json();
+    return {
+      version: versionInfo.version,
+      date: versionInfo.date,
+      commit: versionInfo.commit,
+      formatted: formatVersionTimestamp(versionInfo.version)
+    };
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Clear version cache
+ */
+function clearVersionCache() {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      fs.unlinkSync(CACHE_FILE);
+    }
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  checkForUpdatesWithCache,
+  getCurrentElectronVersion,
+  formatVersionTimestamp,
+  formatLocalTime,
+  getDownloadUrl,
+  clearVersionCache
+};