hoversource 1.0.0

package/dist/proxy.js

@@ -0,0 +1,220 @@
+import http from "node:http";
+import https from "node:https";
+import { URL } from "node:url";
+import { ProxyResponsePipeline } from "./pipeline.js";
+import { getOrCreateLocalSslCert } from "./cert.js";
+export function rewriteCookieHeaders(headers, useHttps) {
+    const setCookie = headers["set-cookie"];
+    if (setCookie) {
+        headers["set-cookie"] = setCookie.map((cookie) => {
+            let rewritten = cookie.replace(/;\s*domain\s*=\s*[^;]+/gi, "");
+            if (!useHttps) {
+                rewritten = rewritten.replace(/;\s*secure\b/gi, "");
+            }
+            return rewritten;
+        });
+    }
+}
+/**
+ * Starts a reverse HTTP/HTTPS proxy that forwards requests to `targetUrl` and
+ * injects `<script src="${overlayScriptUrl}"></script>` into HTML responses.
+ */
+export function startProxy(options) {
+    const { targetUrl, proxyPort, companionPort, overlayScriptUrl, useHttps, sslKeyPath, sslCertPath } = options;
+    const target = new URL(targetUrl);
+    const pipeline = new ProxyResponsePipeline();
+    const requestHandler = (req, res) => {
+        // ─── PART A: Proxy requests under /hoversource/ to Companion Server ──────
+        if (req.url?.startsWith("/hoversource/")) {
+            const rewrittenPath = req.url.replace(/^\/hoversource/, "") || "/";
+            const isOverlayScript = rewrittenPath === "/hoversource-overlay.js";
+            const companionReqOpts = {
+                hostname: "127.0.0.1",
+                port: companionPort,
+                path: rewrittenPath,
+                method: req.method,
+                headers: {
+                    ...req.headers,
+                    host: `127.0.0.1:${companionPort}`,
+                },
+            };
+            const companionReq = http.request(companionReqOpts, (companionRes) => {
+                const responseHeaders = { ...companionRes.headers };
+                // Ensure CSP is stripped from companion server responses just in case
+                delete responseHeaders["content-security-policy"];
+                delete responseHeaders["content-security-policy-report-only"];
+                if (isOverlayScript) {
+                    const chunks = [];
+                    companionRes.on("data", (chunk) => chunks.push(chunk));
+                    companionRes.on("end", () => {
+                        let body = Buffer.concat(chunks).toString("utf-8");
+                        body = `globalThis.__HOVERSOURCE_PROXY__ = true;\n` + body;
+                        const bodyBuf = Buffer.from(body, "utf-8");
+                        delete responseHeaders["content-length"];
+                        res.writeHead(companionRes.statusCode || 200, responseHeaders);
+                        res.end(bodyBuf);
+                    });
+                }
+                else {
+                    res.writeHead(companionRes.statusCode || 200, responseHeaders);
+                    companionRes.pipe(res, { end: true });
+                }
+            });
+            companionReq.on("error", (err) => {
+                console.error(`[HoverSource Proxy] Failed to proxy request to companion server:`, err.message);
+                if (!res.headersSent) {
+                    res.writeHead(502, { "Content-Type": "text/plain" });
+                    res.end(`HoverSource proxy: companion server upstream error.`);
+                }
+            });
+            req.pipe(companionReq, { end: true });
+            return;
+        }
+        // ─── PART B: Proxy target application requests ─────────────────────────
+        const headers = { ...req.headers };
+        // Filter accept-encoding to only allow compression formats that our pipeline/zlib can handle
+        if (headers["accept-encoding"]) {
+            const accepted = String(headers["accept-encoding"]).toLowerCase();
+            const supported = [];
+            if (accepted.includes("gzip"))
+                supported.push("gzip");
+            if (accepted.includes("deflate"))
+                supported.push("deflate");
+            if (accepted.includes("br"))
+                supported.push("br");
+            if (supported.length > 0) {
+                headers["accept-encoding"] = supported.join(", ");
+            }
+            else {
+                delete headers["accept-encoding"];
+            }
+        }
+        // Map upstream agent request based on target protocol
+        const isTargetHttps = target.protocol === "https:";
+        const agent = isTargetHttps ? https : http;
+        const requestOptions = {
+            hostname: target.hostname,
+            port: target.port || (isTargetHttps ? 443 : 80),
+            path: req.url,
+            method: req.method,
+            headers: {
+                ...headers,
+                host: target.host,
+            },
+        };
+        const proxyReq = agent.request(requestOptions, (proxyRes) => {
+            const contentType = proxyRes.headers["content-type"] || "";
+            // Performance Optimization: Stream non-HTML responses directly
+            if (!pipeline.shouldTransform(contentType)) {
+                const responseHeaders = { ...proxyRes.headers };
+                // Strip CSP headers to avoid iframe and asset restrictions
+                delete responseHeaders["content-security-policy"];
+                delete responseHeaders["content-security-policy-report-only"];
+                // Rewrite cookie domains and secure flag
+                rewriteCookieHeaders(responseHeaders, !!useHttps);
+                res.writeHead(proxyRes.statusCode || 200, responseHeaders);
+                proxyRes.pipe(res, { end: true });
+                return;
+            }
+            // HTML Content: Buffer and transform
+            const chunks = [];
+            proxyRes.on("data", (chunk) => chunks.push(chunk));
+            proxyRes.on("end", () => {
+                const rawBody = Buffer.concat(chunks);
+                const contentEncoding = (proxyRes.headers["content-encoding"] || "").toString();
+                const transformedBody = pipeline.transform(rawBody, contentEncoding, {
+                    overlayScriptUrl,
+                });
+                const responseHeaders = { ...proxyRes.headers };
+                // Recalculate content headers after modification
+                delete responseHeaders["content-length"];
+                delete responseHeaders["content-encoding"];
+                // Strip CSP headers to ensure the browser loads the overlay script
+                delete responseHeaders["content-security-policy"];
+                delete responseHeaders["content-security-policy-report-only"];
+                responseHeaders["content-type"] = "text/html; charset=utf-8";
+                // Rewrite cookie domains and secure flag
+                rewriteCookieHeaders(responseHeaders, !!useHttps);
+                res.writeHead(proxyRes.statusCode || 200, responseHeaders);
+                res.end(transformedBody);
+            });
+        });
+        proxyReq.on("error", (err) => {
+            console.error(`[HoverSource Proxy] Error forwarding request to ${targetUrl}:`, err.message);
+            if (!res.headersSent) {
+                res.writeHead(502, { "Content-Type": "text/plain" });
+                res.end(`HoverSource proxy: upstream error -- is your dev server running at ${targetUrl}?`);
+            }
+        });
+        req.pipe(proxyReq, { end: true });
+    };
+    let server;
+    if (useHttps) {
+        const credentials = getOrCreateLocalSslCert({
+            keyPath: sslKeyPath,
+            certPath: sslCertPath,
+            targetHost: target.hostname,
+        });
+        server = https.createServer(credentials, requestHandler);
+    }
+    else {
+        server = http.createServer(requestHandler);
+    }
+    const upgradeHandler = (req, socket, head) => {
+        const isTargetHttps = target.protocol === "https:";
+        const agent = isTargetHttps ? https : http;
+        const requestOptions = {
+            hostname: target.hostname,
+            port: target.port || (isTargetHttps ? 443 : 80),
+            path: req.url,
+            method: req.method,
+            headers: {
+                ...req.headers,
+                host: target.host,
+            },
+        };
+        const proxyReq = agent.request(requestOptions);
+        proxyReq.on("upgrade", (proxyRes, proxySocket, proxyHead) => {
+            socket.on("error", (err) => {
+                if (process.env.DEBUG) {
+                    console.debug("[HoverSource Proxy] Client socket error:", err.message);
+                }
+                proxySocket.destroy();
+            });
+            proxySocket.on("error", (err) => {
+                if (process.env.DEBUG) {
+                    console.debug("[HoverSource Proxy] Target socket error:", err.message);
+                }
+                socket.destroy();
+            });
+            let responseHeader = `HTTP/${req.httpVersion} 101 Switching Protocols\r\n`;
+            for (const [key, value] of Object.entries(proxyRes.headers)) {
+                if (Array.isArray(value)) {
+                    for (const val of value) {
+                        responseHeader += `${key}: ${val}\r\n`;
+                    }
+                }
+                else if (value !== undefined) {
+                    responseHeader += `${key}: ${value}\r\n`;
+                }
+            }
+            responseHeader += "\r\n";
+            socket.write(responseHeader);
+            proxySocket.write(proxyHead);
+            socket.pipe(proxySocket);
+            proxySocket.pipe(socket);
+        });
+        proxyReq.on("error", (err) => {
+            console.error(`[HoverSource Proxy] WebSocket proxy error forwarding upgrade to ${targetUrl}:`, err.message);
+            socket.end();
+        });
+        proxyReq.end();
+    };
+    server.on("upgrade", upgradeHandler);
+    return new Promise((resolve, reject) => {
+        server.listen(proxyPort, () => {
+            resolve();
+        });
+        server.on("error", reject);
+    });
+}

package/dist/utils/patchState.d.ts

@@ -0,0 +1,3 @@
+export declare function recordPatchState(filePath: string, originalContent: string): void;
+export declare function removePatchState(filePath: string): void;
+export declare function restoreLeftoverPatches(): void;

package/dist/utils/patchState.js

@@ -0,0 +1,59 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+const PATCH_STATE_FILE = path.join(os.tmpdir(), "hoversource_patches.json");
+export function recordPatchState(filePath, originalContent) {
+    let state = {};
+    if (fs.existsSync(PATCH_STATE_FILE)) {
+        try {
+            state = JSON.parse(fs.readFileSync(PATCH_STATE_FILE, "utf-8"));
+        }
+        catch (err) {
+            console.debug("[HoverSource] Failed to parse patch state:", err);
+        }
+    }
+    state[filePath] = originalContent;
+    try {
+        fs.writeFileSync(PATCH_STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+    }
+    catch (err) {
+        console.debug("[HoverSource] Failed to write patch state:", err);
+    }
+}
+export function removePatchState(filePath) {
+    if (!fs.existsSync(PATCH_STATE_FILE))
+        return;
+    try {
+        const state = JSON.parse(fs.readFileSync(PATCH_STATE_FILE, "utf-8"));
+        delete state[filePath];
+        if (Object.keys(state).length === 0) {
+            fs.unlinkSync(PATCH_STATE_FILE);
+        }
+        else {
+            fs.writeFileSync(PATCH_STATE_FILE, JSON.stringify(state, null, 2), "utf-8");
+        }
+    }
+    catch (err) {
+        console.debug("[HoverSource] Failed to remove patch state:", err);
+    }
+}
+export function restoreLeftoverPatches() {
+    if (!fs.existsSync(PATCH_STATE_FILE))
+        return;
+    try {
+        const state = JSON.parse(fs.readFileSync(PATCH_STATE_FILE, "utf-8"));
+        for (const [filePath, originalContent] of Object.entries(state)) {
+            try {
+                fs.writeFileSync(filePath, originalContent, "utf-8");
+                console.log(`[HoverSource] [Self-Healing] Restored leftover patch in ${filePath}`);
+            }
+            catch (err) {
+                console.warn(`[HoverSource] [Self-Healing] Failed to restore leftover patch in ${filePath}:`, err.message);
+            }
+        }
+        fs.unlinkSync(PATCH_STATE_FILE);
+    }
+    catch (err) {
+        console.debug("[HoverSource] Leftover patch restore failed:", err);
+    }
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "hoversource",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./dist/cli.js",
+  "bin": {
+    "hs": "./dist/cli.js",
+    "hoversource": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "!dist/**/__tests__",
+    "!dist/**/*.test.*"
+  ],
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run src"
+  },
+  "dependencies": {
+    "@hoversource/companion-server": "*",
+    "@hoversource/client-injector": "*"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.8"
+  }
+}