markupr 2.1.8

package/site/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "markupr-landing",
+  "version": "1.0.0",
+  "private": true,
+  "scripts": {
+    "start": "node server.js"
+  },
+  "engines": {
+    "node": ">=18"
+  }
+}

package/site/railway.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://railway.com/railway.schema.json",
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "node server.js",
+    "healthcheckPath": "/",
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 3
+  }
+}

package/site/server.js

@@ -0,0 +1,31 @@
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const zlib = require('zlib');
+
+const PORT = process.env.PORT || 3000;
+const indexPath = path.join(__dirname, 'index.html');
+const indexHtml = fs.readFileSync(indexPath);
+const indexGzip = zlib.gzipSync(indexHtml);
+
+const headers = {
+  'Content-Type': 'text/html; charset=utf-8',
+  'X-Content-Type-Options': 'nosniff',
+  'Cache-Control': 'public, max-age=3600',
+};
+
+const server = http.createServer((req, res) => {
+  const acceptGzip = (req.headers['accept-encoding'] || '').includes('gzip');
+
+  if (acceptGzip) {
+    res.writeHead(200, { ...headers, 'Content-Encoding': 'gzip' });
+    res.end(indexGzip);
+  } else {
+    res.writeHead(200, headers);
+    res.end(indexHtml);
+  }
+});
+
+server.listen(PORT, () => {
+  console.log(`markupR landing page serving on port ${PORT}`);
+});

package/src/main/AutoUpdater.ts

@@ -0,0 +1,392 @@
+/**
+ * markupr - Auto Updater Manager
+ *
+ * Handles automatic updates using electron-updater with GitHub Releases.
+ *
+ * Features:
+ * - Check for updates on app launch
+ * - Background download of updates
+ * - Show release notes to user
+ * - User-controlled restart for installation
+ * - Download progress indicator
+ *
+ * The update flow:
+ * 1. App launches -> check for updates
+ * 2. Update available -> notify renderer with version & release notes
+ * 3. User clicks "Download" -> download in background with progress
+ * 4. Download complete -> notify renderer that update is ready
+ * 5. User clicks "Restart Now" -> quit and install
+ */
+
+import electronUpdater from 'electron-updater';
+const { autoUpdater } = electronUpdater;
+type UpdateCheckResult = electronUpdater.UpdateCheckResult;
+type UpdateInfo = electronUpdater.UpdateInfo;
+type ProgressInfo = electronUpdater.ProgressInfo;
+import { BrowserWindow, ipcMain, app } from 'electron';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import electronLog from 'electron-log';
+const log = electronLog.default ?? electronLog;
+import { IPC_CHANNELS, type UpdateStatusPayload, type UpdateStatusType } from '../shared/types';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+interface UpdateManagerState {
+  status: UpdateStatusType;
+  currentVersion: string;
+  availableVersion?: string;
+  releaseNotes?: string | null;
+  downloadProgress?: number;
+}
+
+// =============================================================================
+// AutoUpdater Manager Class
+// =============================================================================
+
+class AutoUpdaterManager {
+  private mainWindow: BrowserWindow | null = null;
+  private state: UpdateManagerState;
+  private initialized = false;
+  private updaterAvailable = false;
+  private autoCheckEnabled = true;
+  private isChecking = false;
+  private startupCheckTimer: NodeJS.Timeout | null = null;
+  private periodicCheckTimer: NodeJS.Timeout | null = null;
+  private readonly STARTUP_CHECK_DELAY_MS = 5000;
+  private readonly PERIODIC_CHECK_INTERVAL_MS = 4 * 60 * 60 * 1000;
+
+  constructor() {
+    this.state = {
+      status: 'idle',
+      currentVersion: app.getVersion(),
+    };
+  }
+
+  /**
+   * Initialize the auto-updater with a reference to the main window
+   */
+  initialize(window: BrowserWindow): void {
+    if (this.initialized) {
+      console.warn('[AutoUpdater] Already initialized');
+      return;
+    }
+
+    this.mainWindow = window;
+    this.initialized = true;
+    this.updaterAvailable = this.canUseUpdater();
+
+    // Set up IPC handlers even if updater is unavailable, so renderer calls remain safe.
+    this.setupIPCHandlers();
+
+    if (!this.updaterAvailable) {
+      log.info('[AutoUpdater] Updater disabled (unpackaged app or missing app-update.yml)');
+      this.updateState('not-available');
+      return;
+    }
+
+    // Configure logging
+    log.transports.file.level = 'info';
+    autoUpdater.logger = log;
+    log.info('[AutoUpdater] Initializing auto-updater');
+
+    // Configure update behavior
+    autoUpdater.autoDownload = false; // Let user decide when to download
+    autoUpdater.autoInstallOnAppQuit = true; // Install on quit if downloaded
+    autoUpdater.allowDowngrade = false;
+    autoUpdater.allowPrerelease = false;
+
+    // Set up event handlers
+    this.setupEventHandlers();
+
+    this.scheduleAutoChecks();
+
+    log.info('[AutoUpdater] Initialized successfully');
+  }
+
+  setAutoCheckEnabled(enabled: boolean): void {
+    this.autoCheckEnabled = enabled;
+    log.info(`[AutoUpdater] Auto-check ${enabled ? 'enabled' : 'disabled'}`);
+
+    if (!this.initialized || !this.updaterAvailable) {
+      return;
+    }
+
+    this.scheduleAutoChecks();
+  }
+
+  private scheduleAutoChecks(): void {
+    this.clearAutoCheckTimers();
+
+    if (!this.autoCheckEnabled) {
+      return;
+    }
+
+    this.startupCheckTimer = setTimeout(() => {
+      void this.checkForUpdates();
+    }, this.STARTUP_CHECK_DELAY_MS);
+
+    this.periodicCheckTimer = setInterval(() => {
+      void this.checkForUpdates();
+    }, this.PERIODIC_CHECK_INTERVAL_MS);
+  }
+
+  private clearAutoCheckTimers(): void {
+    if (this.startupCheckTimer) {
+      clearTimeout(this.startupCheckTimer);
+      this.startupCheckTimer = null;
+    }
+    if (this.periodicCheckTimer) {
+      clearInterval(this.periodicCheckTimer);
+      this.periodicCheckTimer = null;
+    }
+  }
+
+  /**
+   * Set up auto-updater event handlers
+   */
+  private setupEventHandlers(): void {
+    // Checking for updates
+    autoUpdater.on('checking-for-update', () => {
+      log.info('[AutoUpdater] Checking for update...');
+      this.updateState('checking');
+    });
+
+    // Update available
+    autoUpdater.on('update-available', (info: UpdateInfo) => {
+      log.info(`[AutoUpdater] Update available: ${info.version}`);
+      this.state.availableVersion = info.version;
+      this.state.releaseNotes = this.parseReleaseNotes(info.releaseNotes);
+      this.sendStatus('available', {
+        version: info.version,
+        releaseNotes: this.state.releaseNotes,
+        releaseDate: info.releaseDate,
+      });
+    });
+
+    // No update available
+    autoUpdater.on('update-not-available', (info: UpdateInfo) => {
+      log.info(`[AutoUpdater] No update available. Current: ${this.state.currentVersion}, Latest: ${info.version}`);
+      this.updateState('not-available');
+    });
+
+    // Download progress
+    autoUpdater.on('download-progress', (progress: ProgressInfo) => {
+      const percent = Math.round(progress.percent);
+      log.info(`[AutoUpdater] Download progress: ${percent}%`);
+      this.state.downloadProgress = percent;
+      this.sendStatus('downloading', {
+        percent: progress.percent,
+        bytesPerSecond: progress.bytesPerSecond,
+        total: progress.total,
+        transferred: progress.transferred,
+      });
+    });
+
+    // Update downloaded
+    autoUpdater.on('update-downloaded', (info: UpdateInfo) => {
+      log.info(`[AutoUpdater] Update downloaded: ${info.version}`);
+      this.sendStatus('ready', {
+        version: info.version,
+        releaseNotes: this.parseReleaseNotes(info.releaseNotes),
+      });
+    });
+
+    // Error handling
+    autoUpdater.on('error', (error: Error) => {
+      if (this.shouldSuppressUpdateError(error)) {
+        log.warn('[AutoUpdater] Suppressing expected updater error:', error.message);
+        this.updateState('not-available');
+        return;
+      }
+
+      log.error('[AutoUpdater] Error:', error);
+      this.sendStatus('error', {
+        message: error.message,
+      });
+    });
+  }
+
+  /**
+   * Set up IPC handlers for renderer communication
+   */
+  private setupIPCHandlers(): void {
+    // Check for updates
+    ipcMain.handle(IPC_CHANNELS.UPDATE_CHECK, async () => {
+      return this.checkForUpdates();
+    });
+
+    // Download update
+    ipcMain.handle(IPC_CHANNELS.UPDATE_DOWNLOAD, async () => {
+      return this.downloadUpdate();
+    });
+
+    // Install update (quit and install)
+    ipcMain.handle(IPC_CHANNELS.UPDATE_INSTALL, () => {
+      return this.installUpdate();
+    });
+  }
+
+  /**
+   * Check for available updates
+   */
+  async checkForUpdates(): Promise<UpdateCheckResult | null> {
+    if (!this.updaterAvailable) {
+      this.updateState('not-available');
+      return null;
+    }
+    if (this.isChecking) {
+      return null;
+    }
+    if (this.state.status === 'downloading') {
+      return null;
+    }
+
+    try {
+      this.isChecking = true;
+      log.info('[AutoUpdater] Checking for updates');
+      const result = await autoUpdater.checkForUpdates();
+      return result;
+    } catch (error) {
+      if (error instanceof Error && this.shouldSuppressUpdateError(error)) {
+        log.warn('[AutoUpdater] Update check skipped:', error.message);
+        this.updateState('not-available');
+        return null;
+      }
+
+      log.error('[AutoUpdater] Check for updates failed:', error);
+      this.sendStatus('error', {
+        message: error instanceof Error ? error.message : 'Failed to check for updates',
+      });
+      return null;
+    } finally {
+      this.isChecking = false;
+    }
+  }
+
+  /**
+   * Download the available update
+   */
+  async downloadUpdate(): Promise<void> {
+    if (!this.updaterAvailable) {
+      this.updateState('not-available');
+      return;
+    }
+
+    try {
+      log.info('[AutoUpdater] Starting download');
+      this.updateState('downloading');
+      await autoUpdater.downloadUpdate();
+    } catch (error) {
+      log.error('[AutoUpdater] Download failed:', error);
+      this.sendStatus('error', {
+        message: error instanceof Error ? error.message : 'Failed to download update',
+      });
+    }
+  }
+
+  /**
+   * Install the downloaded update (quits app and installs)
+   */
+  installUpdate(): void {
+    if (!this.updaterAvailable) {
+      this.updateState('not-available');
+      return;
+    }
+
+    log.info('[AutoUpdater] Installing update and restarting');
+    // Quit and install
+    // isSilent: false - show installer UI
+    // isForceRunAfter: true - restart app after update
+    autoUpdater.quitAndInstall(false, true);
+  }
+
+  /**
+   * Update internal state and send to renderer
+   */
+  private updateState(status: UpdateStatusType): void {
+    this.state.status = status;
+    this.sendStatus(status);
+  }
+
+  /**
+   * Send status update to renderer process
+   */
+  private sendStatus(status: UpdateStatusType, data?: Partial<UpdateStatusPayload>): void {
+    const payload: UpdateStatusPayload = {
+      status,
+      ...data,
+    };
+
+    this.mainWindow?.webContents.send(IPC_CHANNELS.UPDATE_STATUS, payload);
+  }
+
+  /**
+   * Parse release notes from various formats
+   */
+  private parseReleaseNotes(notes: string | UpdateInfo['releaseNotes'] | null | undefined): string | null {
+    if (!notes) return null;
+
+    if (typeof notes === 'string') {
+      return notes;
+    }
+
+    // Handle array of release notes (multiple releases)
+    if (Array.isArray(notes)) {
+      return notes
+        .map((note) => {
+          if (typeof note === 'string') return note;
+          return note.note || '';
+        })
+        .join('\n\n');
+    }
+
+    return null;
+  }
+
+  /**
+   * Electron auto-updater requires a packaged app and app-update.yml.
+   * Local --dir installs and dev runs do not have updater metadata.
+   */
+  private canUseUpdater(): boolean {
+    if (!app.isPackaged) {
+      return false;
+    }
+
+    const configPath = join(process.resourcesPath, 'app-update.yml');
+    return existsSync(configPath);
+  }
+
+  /**
+   * Suppress known local-install update errors (not actionable for users).
+   */
+  private shouldSuppressUpdateError(error: Error): boolean {
+    const message = error.message.toLowerCase();
+    return message.includes('app-update.yml') || message.includes('latest.yml') || message.includes('enoent');
+  }
+
+  /**
+   * Get current update state
+   */
+  getState(): UpdateManagerState {
+    return { ...this.state };
+  }
+
+  /**
+   * Clean up resources
+   */
+  destroy(): void {
+    this.clearAutoCheckTimers();
+    this.mainWindow = null;
+    this.initialized = false;
+    log.info('[AutoUpdater] Destroyed');
+  }
+}
+
+// =============================================================================
+// Singleton Export
+// =============================================================================
+
+export const autoUpdaterManager = new AutoUpdaterManager();