jettypod 4.4.116 → 4.4.120

package/apps/dashboard/scripts/upload-to-r2.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+/**
+ * Upload release artifacts to Cloudflare R2.
+ * Run after electron-builder: npm run upload:r2
+ *
+ * Requires CLOUDFLARE_API_TOKEN env var (or wrangler login).
+ * Uploads: latest-mac.yml, DMG, ZIP, and blockmap files.
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const BUCKET_NAME = 'jettypod-releases';
+const DIST_DIR = path.join(__dirname, '..', 'dist');
+
+// File patterns to upload
+const UPLOAD_PATTERNS = [
+  /^latest-mac\.yml$/,
+  /\.dmg$/,
+  /\.zip$/,
+  /\.blockmap$/,
+];
+
+function findArtifacts() {
+  if (!fs.existsSync(DIST_DIR)) {
+    console.error(`❌ dist/ directory not found at ${DIST_DIR}`);
+    console.error('Run electron:build first.');
+    process.exit(1);
+  }
+
+  const files = fs.readdirSync(DIST_DIR);
+  return files.filter((file) =>
+    UPLOAD_PATTERNS.some((pattern) => pattern.test(file))
+  );
+}
+
+function uploadFile(filename) {
+  const filePath = path.join(DIST_DIR, filename);
+  const stats = fs.statSync(filePath);
+  const sizeMB = (stats.size / (1024 * 1024)).toFixed(1);
+
+  console.log(`  Uploading ${filename} (${sizeMB} MB)...`);
+
+  try {
+    execSync(
+      `npx wrangler r2 object put "${BUCKET_NAME}/${filename}" --file="${filePath}" --remote`,
+      { stdio: 'pipe' }
+    );
+    console.log(`  ✅ ${filename}`);
+    return true;
+  } catch (error) {
+    console.error(`  ❌ Failed to upload ${filename}: ${error.message}`);
+    return false;
+  }
+}
+
+function main() {
+  console.log('🚀 Uploading release artifacts to R2...\n');
+
+  const artifacts = findArtifacts();
+  if (artifacts.length === 0) {
+    console.error('❌ No release artifacts found in dist/');
+    console.error('Expected: latest-mac.yml, .dmg, .zip, or .blockmap files');
+    process.exit(1);
+  }
+
+  console.log(`Found ${artifacts.length} artifact(s):\n`);
+
+  let success = 0;
+  let failed = 0;
+
+  for (const artifact of artifacts) {
+    if (uploadFile(artifact)) {
+      success++;
+    } else {
+      failed++;
+    }
+  }
+
+  console.log(`\n📦 Upload complete: ${success} uploaded, ${failed} failed`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main();

package/apps/dashboard/scripts/ws-server.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * Standalone WebSocket server for browser dev mode.
+ *
+ * Polls the JettyPod SQLite database and cucumber-results.json for changes
+ * and broadcasts notifications to connected clients.  This is the same
+ * behaviour embedded in electron/main.js, extracted so `npm run dev` can
+ * provide live updates without Electron running.
+ *
+ * Usage:
+ *   node scripts/ws-server.js [project-path]
+ *
+ * project-path defaults to the repository root (two levels up from this script).
+ */
+
+const { WebSocketServer } = require('ws');
+const fs = require('fs');
+const path = require('path');
+
+const WS_PORT = 47808;
+const DB_POLL_MS = 500;
+
+const projectRoot = process.argv[2] || path.resolve(__dirname, '..', '..', '..');
+
+// ---------------------------------------------------------------------------
+// State
+// ---------------------------------------------------------------------------
+const clients = new Set();
+let dbPollInterval = null;
+let testResultsPollInterval = null;
+let lastDbMtimes = { db: null, wal: null };
+let lastTestResultsMtime = null;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+function log(msg) {
+  console.log(`[ws-server] ${msg}`);
+}
+
+function broadcast(message) {
+  const payload = JSON.stringify(message);
+  for (const client of clients) {
+    if (client.readyState === 1) { // WebSocket.OPEN
+      client.send(payload);
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Database polling (WAL-aware)
+// ---------------------------------------------------------------------------
+function startDatabasePolling() {
+  const dbPath = path.join(projectRoot, '.jettypod', 'work.db');
+
+  if (!fs.existsSync(dbPath)) {
+    log(`Database not found at ${dbPath}, retrying in 5s...`);
+    setTimeout(startDatabasePolling, 5000);
+    return;
+  }
+
+  try {
+    const dbStats = fs.statSync(dbPath);
+    lastDbMtimes.db = dbStats.mtimeMs;
+
+    const walPath = dbPath + '-wal';
+    if (fs.existsSync(walPath)) {
+      lastDbMtimes.wal = fs.statSync(walPath).mtimeMs;
+    }
+  } catch (err) {
+    log(`Failed to get initial db stats: ${err.message}`);
+    return;
+  }
+
+  log(`Polling database for changes (WAL-aware)...`);
+
+  dbPollInterval = setInterval(() => {
+    try {
+      let changed = false;
+
+      const dbStats = fs.statSync(dbPath);
+      if (dbStats.mtimeMs !== lastDbMtimes.db) {
+        lastDbMtimes.db = dbStats.mtimeMs;
+        changed = true;
+      }
+
+      const walPath = dbPath + '-wal';
+      if (fs.existsSync(walPath)) {
+        const walStats = fs.statSync(walPath);
+        if (walStats.mtimeMs !== lastDbMtimes.wal) {
+          lastDbMtimes.wal = walStats.mtimeMs;
+          changed = true;
+        }
+      }
+
+      if (changed) {
+        broadcast({ type: 'db_change', timestamp: Date.now() });
+      }
+    } catch {
+      // File might be temporarily locked during writes — ignore
+    }
+  }, DB_POLL_MS);
+}
+
+// ---------------------------------------------------------------------------
+// Test results polling
+// ---------------------------------------------------------------------------
+function startTestResultsPolling() {
+  const testResultsPath = path.join(projectRoot, 'cucumber-results.json');
+
+  if (fs.existsSync(testResultsPath)) {
+    try {
+      lastTestResultsMtime = fs.statSync(testResultsPath).mtimeMs;
+      log(`Watching test results at ${testResultsPath}`);
+    } catch (err) {
+      log(`Failed to get initial test results stats: ${err.message}`);
+    }
+  } else {
+    log(`Test results file not found at ${testResultsPath}, will watch for creation`);
+  }
+
+  testResultsPollInterval = setInterval(() => {
+    try {
+      if (!fs.existsSync(testResultsPath)) {
+        if (lastTestResultsMtime !== null) {
+          lastTestResultsMtime = null;
+        }
+        return;
+      }
+
+      const stats = fs.statSync(testResultsPath);
+      if (stats.mtimeMs !== lastTestResultsMtime) {
+        lastTestResultsMtime = stats.mtimeMs;
+        broadcast({ type: 'test_change', timestamp: Date.now() });
+      }
+    } catch {
+      // ignore
+    }
+  }, DB_POLL_MS);
+}
+
+// ---------------------------------------------------------------------------
+// Server
+// ---------------------------------------------------------------------------
+const wss = new WebSocketServer({ port: WS_PORT });
+
+wss.on('connection', (ws) => {
+  clients.add(ws);
+  log(`Client connected. Total: ${clients.size}`);
+  ws.send(JSON.stringify({ type: 'connected', timestamp: Date.now() }));
+
+  ws.on('close', () => {
+    clients.delete(ws);
+    log(`Client disconnected. Total: ${clients.size}`);
+  });
+
+  ws.on('error', (err) => {
+    log(`Client error: ${err.message}`);
+    ws.close();
+    clients.delete(ws);
+  });
+});
+
+wss.on('error', (err) => {
+  if (err.code === 'EADDRINUSE') {
+    log(`Port ${WS_PORT} already in use (Electron running?). Exiting.`);
+    process.exit(0);
+  }
+  log(`Server error: ${err.message}`);
+});
+
+wss.on('listening', () => {
+  log(`WebSocket server running on ws://localhost:${WS_PORT}`);
+  log(`Watching project: ${projectRoot}`);
+  startDatabasePolling();
+  startTestResultsPolling();
+});
+
+// Graceful shutdown
+function shutdown() {
+  log('Shutting down...');
+  if (dbPollInterval) clearInterval(dbPollInterval);
+  if (testResultsPollInterval) clearInterval(testResultsPollInterval);
+  for (const client of clients) client.close();
+  clients.clear();
+  wss.close(() => process.exit(0));
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);