sliftutils 1.2.10 → 1.2.12

package/builders/extensionBuild.ts

@@ -1,4 +1,5 @@
 import fs from "fs";
+import crypto from "crypto";
 import { delay } from "socket-function/src/batching";
 import { bundleEntryCaller } from "../bundler/bundleEntryCaller";
 import yargs from "yargs";
@@ -6,6 +7,8 @@ import { formatTime } from "socket-function/src/formatting/format";
 import path from "path";
 import { getAllFiles } from "../misc/fs";
 
+const BUILD_HASH_PREFIX = "::SLIFT_HOT_RELOAD_BUILD_HASH::";
+
 async function main() {
     let time = Date.now();
     //todonext
@@ -138,6 +141,22 @@ async function main() {
         console.log(`Copied ${filesCopied} changed assets`);
     }
 
+    // Hash the bundled JS outputs so the watch server can broadcast a version
+    // identifier the extension can compare against on a poll.
+    let jsOutputs = (await fs.promises.readdir(yargObj.outputFolder))
+        .filter(f => f.endsWith(".js"))
+        .sort();
+    let hasher = crypto.createHash("sha256");
+    for (let file of jsOutputs) {
+        let buf = await fs.promises.readFile(path.join(yargObj.outputFolder, file));
+        hasher.update(file);
+        hasher.update("\0");
+        hasher.update(buf);
+        hasher.update("\0");
+    }
+    let buildHash = hasher.digest("hex").slice(0, 16);
+    console.log(`${BUILD_HASH_PREFIX} ${buildHash}`);
+
     let duration = Date.now() - time;
     console.log(`Extension build completed in ${formatTime(duration)}`);
 }

package/builders/hotReload.ts

@@ -2,6 +2,8 @@ import { watchFilesAndTriggerHotReloading } from "socket-function/hot/HotReloadC
 import { isInBrowser, isInChromeExtension, isInChromeExtensionBackground, isInChromeExtensionContentScript } from "../misc/environment";
 
 const DEFAULT_WATCH_PORT = 9876;
+const CONTENT_SCRIPT_POLL_INTERVAL_MS = 1000;
+const HOT_RELOAD_HASH_MESSAGE = "hotReload:getHash";
 
 export async function enableHotReloading(config?: {
     port?: number;
@@ -20,7 +22,7 @@ export async function enableHotReloading(config?: {
     }
 }
 
-function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void) {
+function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void, onHash?: (hash: string | undefined) => void) {
     let reconnectTimer: number | undefined;
     let ws: WebSocket | undefined;
 
@@ -39,8 +41,12 @@ function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void) {
                 try {
                     let data = JSON.parse(event.data);
                     if (data.type === "build-complete" && data.success) {
-                        console.log("[Hot Reload] Build complete, reloading page...");
-                        onReload();
+                        if (onHash) {
+                            onHash(data.hash);
+                        } else {
+                            console.log("[Hot Reload] Build complete, reloading page...");
+                            onReload();
+                        }
                     }
                 } catch (error) {
                     console.error("[Hot Reload] Failed to parse message:", error);
@@ -71,29 +77,57 @@ function watchPortHotReload(port = DEFAULT_WATCH_PORT, onReload: () => void) {
 }
 
 function chromeExtensionBackgroundHotReload(port = DEFAULT_WATCH_PORT) {
-    chrome.runtime.onConnect.addListener((port) => {
-        if (port.name === "hotReload") {
-            // Keep the port open so content scripts can detect when we disconnect
+    let currentHash: string | undefined;
+
+    // Content scripts poll the background for the latest build hash and reload
+    // themselves when it changes.
+    chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
+        if (message && message.type === HOT_RELOAD_HASH_MESSAGE) {
+            sendResponse({ hash: currentHash });
+            return; // synchronous response
         }
+        return undefined;
     });
 
-    watchPortHotReload(port, () => {
-        chrome.runtime.reload();
+    watchPortHotReload(port, () => { /* unused — hash callback drives reloads */ }, (hash) => {
+        if (!hash) return;
+        if (currentHash === undefined) {
+            currentHash = hash;
+            console.log(`[Hot Reload] Initial build hash: ${hash}`);
+            return;
+        }
+        if (hash !== currentHash) {
+            console.log(`[Hot Reload] Build hash changed (${currentHash} -> ${hash}), reloading extension...`);
+            currentHash = hash;
+            chrome.runtime.reload();
+        }
     });
 }
 
 function chromeExtensionContentScriptHotReload() {
-    let port = chrome.runtime.connect({ name: "hotReload" });
-
-    let startTime = Date.now();
+    let lastHash: string | undefined;
 
-    port.onDisconnect.addListener(() => {
-        let timeToFail = Date.now() - startTime;
-        if (timeToFail < 3000) {
-            console.warn("[Hot Reload] Could not connect to background script. Make sure the background script calls enableHotReloading().");
-            return;
+    setInterval(() => {
+        try {
+            chrome.runtime.sendMessage({ type: HOT_RELOAD_HASH_MESSAGE }, (response) => {
+                if (chrome.runtime.lastError) {
+                    // Background may be reloading — try again on the next tick.
+                    return;
+                }
+                let hash: string | undefined = response?.hash;
+                if (!hash) return;
+                if (lastHash === undefined) {
+                    lastHash = hash;
+                    return;
+                }
+                if (hash !== lastHash) {
+                    console.log(`[Hot Reload] Build hash changed (${lastHash} -> ${hash}), refreshing page...`);
+                    lastHash = hash;
+                    window.location.reload();
+                }
+            });
+        } catch (error) {
+            // Ignore — extension context can be transiently invalidated during reload.
         }
-        console.log("[Hot Reload] Extension reloaded, refreshing page...");
-        window.location.reload();
-    });
+    }, CONTENT_SCRIPT_POLL_INTERVAL_MS);
 }

package/builders/watch.ts

@@ -5,6 +5,7 @@ import { WebSocketServer } from "ws";
 
 const DEBOUNCE_DELAY_MS = 250;
 const DEFAULT_WATCH_PORT = 9876;
+const BUILD_HASH_REGEX = /::SLIFT_HOT_RELOAD_BUILD_HASH::\s+(\S+)/g;
 
 async function main() {
     let args = process.argv.slice(2);
@@ -48,6 +49,9 @@ async function main() {
 
         wss.on("connection", (ws) => {
             console.log(`[${new Date().toLocaleTimeString()}] WebSocket client connected`);
+            if (latestBuildHash) {
+                ws.send(JSON.stringify({ type: "build-complete", success: true, hash: latestBuildHash }));
+            }
             ws.on("close", () => {
                 console.log(`[${new Date().toLocaleTimeString()}] WebSocket client disconnected`);
             });
@@ -63,6 +67,7 @@ async function main() {
     let debounceTimer: NodeJS.Timeout | undefined;
     let isRunning = false;
     let needsRerun = false;
+    let latestBuildHash: string | undefined;
 
     async function executeCommand() {
         if (isRunning) {
@@ -75,14 +80,25 @@ async function main() {
 
         try {
             console.log(`\n[${new Date().toLocaleTimeString()}] Running: ${command}`);
-            await runPromise(command);
+            let output = await runPromise(command);
             console.log(`[${new Date().toLocaleTimeString()}] Completed successfully`);
 
+            // Extract the most recent [BUILD_HASH] line emitted by the build.
+            let match: RegExpExecArray | null;
+            let lastHash: string | undefined;
+            BUILD_HASH_REGEX.lastIndex = 0;
+            while ((match = BUILD_HASH_REGEX.exec(output)) !== null) {
+                lastHash = match[1];
+            }
+            if (lastHash) {
+                latestBuildHash = lastHash;
+            }
+
             // Notify all connected WebSocket clients
             if (wss) {
                 wss.clients.forEach((client) => {
                     if (client.readyState === 1) { // 1 = OPEN
-                        client.send(JSON.stringify({ type: "build-complete", success: true }));
+                        client.send(JSON.stringify({ type: "build-complete", success: true, hash: latestBuildHash }));
                     }
                 });
             }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "sliftutils",
-    "version": "1.2.10",
+    "version": "1.2.12",
     "main": "index.js",
     "license": "MIT",
     "files": [