vibecodingmachine-core 1.0.1 → 2025.11.2-7.1239

package/src/utils/electron-update-checker.js

@@ -1,85 +1,113 @@
-const https = require('https');
-
-/**
- * Check for Electron app updates from S3 version manifest
- * @param {string} currentVersion - Current version (e.g., '1.0.0')
- * @returns {Promise<Object>} Update info or null if no update available
- */
-async function checkForElectronUpdates(currentVersion) {
-  return new Promise((resolve, reject) => {
-    const manifestUrl = 'https://vibecodingmachine-website.s3.amazonaws.com/version-manifest.json';
-
-    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;
-
-          if (latestVersion !== currentVersion) {
-            const publishedDate = new Date(manifest.publishedDate);
-
-            // Detect architecture and choose appropriate download URL
-            // For auto-updates, use architecture-specific builds (faster, smaller)
-            const arch = process.arch; // 'arm64' or 'x64'
-            let downloadUrl = manifest.downloadUrl; // Fallback to universal
-
-            if (arch === 'arm64' && manifest.downloadUrlArm64) {
-              downloadUrl = manifest.downloadUrlArm64;
-              console.log('✅ Using Apple Silicon optimized update');
-            } else if (arch === 'x64' && manifest.downloadUrlX64) {
-              downloadUrl = manifest.downloadUrlX64;
-              console.log('✅ Using Intel optimized update');
-            } else {
-              console.log('ℹ️ Using universal build for update');
-            }
-
-            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'
-              }),
-              downloadUrl,
-              releaseNotes: manifest.releaseNotes || ''
-            });
-          } 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 Electron updates:', error);
-      resolve({ hasUpdate: false, currentVersion, error: error.message });
-    });
-  });
-}
-
-module.exports = {
-  checkForElectronUpdates
-};
+const https = require('https');
+
+/**
+ * Format version timestamp to YYYY.MM.DD.HHMM (TIMEZONE)
+ */
+function formatVersionTimestamp(versionString, date) {
+  // Version format: YYYY.MM.DD.HHMM
+  const match = versionString.match(/^(\d{4})\.(\d{2})\.(\d{2})\.(\d{2})(\d{2})$/);
+  if (!match) return versionString;
+
+  try {
+    // Parse the version timestamp to get the actual time zone abbreviation
+    const [, year, month, day, hour, minute] = match;
+    const versionDate = new Date(`${year}-${month}-${day}T${hour}:${minute}:00Z`);
+
+    const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const timeZoneAbbr = new Intl.DateTimeFormat('en-US', {
+      timeZone,
+      timeZoneName: 'short'
+    }).format(versionDate).split(' ').pop();
+
+    return `${versionString} (${timeZoneAbbr})`;
+  } catch (error) {
+    return `${versionString} (UTC)`;
+  }
+}
+
+/**
+ * Check for Electron app updates from S3 version manifest
+ * @param {string} currentVersion - Current version (e.g., '2025.11.26.0519')
+ * @returns {Promise<Object>} Update info or null if no update available
+ */
+async function checkForElectronUpdates(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;
+
+          // Detect architecture and choose appropriate download URL
+          const arch = process.arch; // 'arm64' or 'x64'
+          const platform = process.platform; // 'darwin' or 'win32'
+          const baseUrl = 'https://vibecodingmachine-website.s3.amazonaws.com/downloads';
+
+          let downloadUrl;
+          if (platform === 'darwin') {
+            // Try architecture-specific first, fallback to universal
+            if (arch === 'arm64') {
+              downloadUrl = `${baseUrl}/VibeCodingMachine-${latestVersion}-arm64.dmg`;
+            } else if (arch === 'x64') {
+              downloadUrl = `${baseUrl}/VibeCodingMachine-${latestVersion}-x64.dmg`;
+            } else {
+              downloadUrl = `${baseUrl}/VibeCodingMachine-${latestVersion}.dmg`;
+            }
+          } else if (platform === 'win32') {
+            downloadUrl = `${baseUrl}/VibeCodingMachine-${latestVersion}-win32-x64.zip`;
+          } else {
+            downloadUrl = baseUrl;
+          }
+
+          if (latestVersion !== currentVersion) {
+            resolve({
+              hasUpdate: true,
+              currentVersion,
+              currentVersionFormatted: formatVersionTimestamp(currentVersion, publishedDate),
+              latestVersion,
+              latestVersionFormatted: formatVersionTimestamp(latestVersion, publishedDate),
+              publishedDate: formatVersionTimestamp(latestVersion, publishedDate),
+              commit: manifest.commit || 'Unknown',
+              downloadUrl
+            });
+          } else {
+            resolve({
+              hasUpdate: false,
+              currentVersion,
+              currentVersionFormatted: formatVersionTimestamp(currentVersion, publishedDate),
+              latestVersion,
+              latestVersionFormatted: formatVersionTimestamp(latestVersion, publishedDate)
+            });
+          }
+        } catch (error) {
+          console.error('Error parsing version manifest:', error);
+          resolve({ hasUpdate: false, currentVersion, error: error.message });
+        }
+      });
+    }).on('error', (error) => {
+      console.error('Error checking for Electron updates:', error);
+      resolve({ hasUpdate: false, currentVersion, error: error.message });
+    });
+  });
+}
+
+module.exports = {
+  checkForElectronUpdates,
+  formatVersionTimestamp
+};