hoversource 1.0.0

package/dist/custom-jsx-dev-runtime-cjs.cjs

@@ -0,0 +1,21 @@
+const path = require("path");
+const wrapperPath = module.filename;
+const originalPath = (globalThis.__HOVERSOURCE_ORIGINAL_CJS_RUNTIMES__ && globalThis.__HOVERSOURCE_ORIGINAL_CJS_RUNTIMES__[wrapperPath]) || "react/jsx-dev-runtime";
+const original = require(originalPath);
+
+exports.Fragment = original.Fragment;
+
+exports.jsxDEV = function(type, props, key, isStaticChildren, source, self) {
+  if (typeof window === "undefined" && source && props && typeof type === "string") {
+    let filePath = source.fileName || "";
+    try {
+      const relative = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+      filePath = relative;
+    } catch {}
+
+    props["data-hoversource-loc"] = `${filePath}:${source.lineNumber}:${source.columnNumber}`;
+  }
+  return original.jsxDEV(type, props, key, isStaticChildren, source, self);
+};
+
+exports.jsxsDEV = original.jsxsDEV || exports.jsxDEV;

package/dist/custom-jsx-dev-runtime.d.ts

@@ -0,0 +1,3 @@
+export declare const Fragment: any;
+export declare function jsxDEV(type: any, props: any, key: any, isStaticChildren: any, source: any, self: any): any;
+export declare const jsxsDEV: any;

package/dist/custom-jsx-dev-runtime.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+const urlParams = new URL(import.meta.url).searchParams;
+const originalUrl = urlParams.get("original");
+// Dynamically import the original module using top-level await
+// @ts-ignore
+const original = originalUrl ? await import(originalUrl) : await import("react/jsx-dev-runtime");
+export const Fragment = original.Fragment;
+export function jsxDEV(type, props, key, isStaticChildren, source, self) {
+    if (globalThis.window === undefined && source && props && typeof type === "string") {
+        let filePath = source.fileName || "";
+        try {
+            // Normalize absolute path to relative path based on process CWD
+            const relative = path.relative(process.cwd(), filePath).replaceAll("\\", "/");
+            filePath = relative;
+        }
+        catch { }
+        props["data-hoversource-loc"] = `${filePath}:${source.lineNumber}:${source.columnNumber}`;
+    }
+    return original.jsxDEV(type, props, key, isStaticChildren, source, self);
+}
+export const jsxsDEV = original.jsxsDEV || jsxDEV;

package/dist/custom-jsx-runtime-cjs.cjs

@@ -0,0 +1,76 @@
+const path = require("path");
+const wrapperPath = module.filename;
+const originalPath = (globalThis.__HOVERSOURCE_ORIGINAL_CJS_RUNTIMES__ && globalThis.__HOVERSOURCE_ORIGINAL_CJS_RUNTIMES__[wrapperPath]) || "react/jsx-runtime";
+const original = require(originalPath);
+
+exports.Fragment = original.Fragment;
+
+let ssrLogCount = 0;
+function getJSXSourceLocation(type) {
+  const err = new Error();
+  const stack = err.stack || "";
+
+  if (typeof window === "undefined" && ssrLogCount < 200) {
+    ssrLogCount++;
+    try {
+      const lines = stack.split("\n");
+      for (let i = 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line) continue;
+        const normalizedLine = line.replace(/\\\\/g, "/");
+        const isFramework = 
+          line.includes("jsxDEV") ||
+          line.includes("jsxsDEV") ||
+          line.includes("node:internal") ||
+          line.includes("Module._compile") ||
+          line.includes("next-dev-server") ||
+          /node_modules[\\/_]react[\\/_]/i.test(normalizedLine) ||
+          /node_modules[\\/_]react-dom[\\/_]/i.test(normalizedLine) ||
+          /node_modules[\\/_]next[\\/_]/i.test(normalizedLine) ||
+          /node_modules[\\/_]scheduler[\\/_]/i.test(normalizedLine) ||
+          line.includes("react-jsx-dev-runtime") ||
+          line.includes("react-jsx-runtime") ||
+          line.includes("custom-jsx-runtime") ||
+          line.includes("custom-jsx-dev-runtime");
+
+        if (isFramework) {
+          continue;
+        }
+        const match = line.match(/(?:at\\s+.*?\\s+\\(|at\\s+)(.*?):(\\d+):(\\d+)\\)?$/);
+        if (match) {
+          return {
+            fileName: match[1],
+            lineNumber: parseInt(match[2], 10),
+            columnNumber: parseInt(match[3], 10)
+          };
+        }
+      }
+    } catch {}
+  }
+  return null;
+}
+
+function injectSource(type, config) {
+  if (config && typeof type === "string") {
+    const source = getJSXSourceLocation(type);
+    if (source) {
+      let filePath = source.fileName || "";
+      try {
+        if (path.isAbsolute(filePath)) {
+          filePath = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+        }
+      } catch {}
+      config["data-hoversource-loc"] = `${filePath}:${source.lineNumber}:${source.columnNumber}`;
+    }
+  }
+}
+
+exports.jsx = function(type, config, maybeKey, ...args) {
+  injectSource(type, config);
+  return original.jsx.call(this, type, config, maybeKey, ...args);
+};
+
+exports.jsxs = function(type, config, maybeKey, ...args) {
+  injectSource(type, config);
+  return original.jsxs.call(this, type, config, maybeKey, ...args);
+};

package/dist/custom-jsx-runtime.d.ts

@@ -0,0 +1,3 @@
+export declare const Fragment: any;
+export declare function jsx(type: any, config: any, maybeKey: any, ...args: any[]): any;
+export declare function jsxs(type: any, config: any, maybeKey: any, ...args: any[]): any;

package/dist/custom-jsx-runtime.js

@@ -0,0 +1,72 @@
+import path from "node:path";
+const urlParams = new URL(import.meta.url).searchParams;
+const originalUrl = urlParams.get("original");
+// @ts-ignore
+const original = originalUrl ? await import(originalUrl) : await import("react/jsx-runtime");
+export const Fragment = original.Fragment;
+let ssrLogCount = 0;
+function getJSXSourceLocation(type) {
+    const err = new Error();
+    const stack = err.stack || "";
+    if (typeof window === "undefined" && ssrLogCount < 200) {
+        ssrLogCount++;
+        try {
+            const lines = stack.split("\n");
+            for (let i = 1; i < lines.length; i++) {
+                const line = lines[i];
+                if (!line)
+                    continue;
+                const normalizedLine = line.replace(/\\/g, "/");
+                const isFramework = line.includes("jsxDEV") ||
+                    line.includes("jsxsDEV") ||
+                    line.includes("node:internal") ||
+                    line.includes("Module._compile") ||
+                    line.includes("next-dev-server") ||
+                    /node_modules[\/_]react[\/_]/i.test(normalizedLine) ||
+                    /node_modules[\/_]react-dom[\/_]/i.test(normalizedLine) ||
+                    /node_modules[\/_]next[\/_]/i.test(normalizedLine) ||
+                    /node_modules[\/_]scheduler[\/_]/i.test(normalizedLine) ||
+                    line.includes("react-jsx-dev-runtime") ||
+                    line.includes("react-jsx-runtime") ||
+                    line.includes("custom-jsx-runtime") ||
+                    line.includes("custom-jsx-dev-runtime");
+                if (isFramework) {
+                    continue;
+                }
+                const match = line.match(/(?:at\s+.*?\s+\(|at\s+)(.*?):(\d+):(\d+)\)?$/);
+                if (match) {
+                    return {
+                        fileName: match[1],
+                        lineNumber: parseInt(match[2], 10),
+                        columnNumber: parseInt(match[3], 10)
+                    };
+                }
+            }
+        }
+        catch { }
+    }
+    return null;
+}
+function injectSource(type, config) {
+    if (config && typeof type === "string") {
+        const source = getJSXSourceLocation(type);
+        if (source) {
+            let filePath = source.fileName || "";
+            try {
+                if (path.isAbsolute(filePath)) {
+                    filePath = path.relative(process.cwd(), filePath).replace(/\\/g, "/");
+                }
+            }
+            catch { }
+            config["data-hoversource-loc"] = `${filePath}:${source.lineNumber}:${source.columnNumber}`;
+        }
+    }
+}
+export function jsx(type, config, maybeKey, ...args) {
+    injectSource(type, config);
+    return original.jsx(type, config, maybeKey, ...args);
+}
+export function jsxs(type, config, maybeKey, ...args) {
+    injectSource(type, config);
+    return original.jsxs(type, config, maybeKey, ...args);
+}

package/dist/launcher/ElectronCdpLauncher.d.ts

@@ -0,0 +1,4 @@
+import { AppLauncher, LaunchConfig } from "./types.js";
+export declare class ElectronCdpLauncher implements AppLauncher {
+    launch(config: LaunchConfig): Promise<void>;
+}

package/dist/launcher/ElectronCdpLauncher.js

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+import { parseCommand, resolveWindowsCommand, validateSafeCommand, validateSafePath, findScriptPath, startCdpInjectionWatch, resolveDebugPortConflicts, detectDevServerPort, } from "../cli.js";
+import { resolveDevServerPort } from "../port.js";
+export class ElectronCdpLauncher {
+    async launch(config) {
+        const { execCommand, projectRoot, serverPort, debugPort, args } = config;
+        const { command, args: cmdArgs } = parseCommand(execCommand);
+        const resolvedCmd = resolveWindowsCommand(validateSafeCommand(command));
+        const autoResolve = args["auto-resolve"] === true;
+        // Check if the dev server port is occupied and resolve it
+        const devPort = detectDevServerPort(projectRoot, execCommand);
+        const devResult = await resolveDevServerPort({
+            projectRoot,
+            execCommand,
+            expectedPort: devPort,
+            mode: "electron",
+            autoResolve,
+            excludePorts: [serverPort, debugPort]
+        });
+        const runWithCdp = (portToUse, patchRestorer) => {
+            console.log(`[HoverSource] Launching target command with remote debugging: ${[resolvedCmd, ...cmdArgs].join(" ")}`);
+            const env = {
+                ...process.env,
+                ...devResult.env,
+                ELECTRON_EXTRA_LAUNCH_ARGS: `--remote-debugging-port=${portToUse}`
+            };
+            const useShell = process.platform === "win32";
+            const child = useShell
+                ? spawn([resolvedCmd, ...cmdArgs].join(" "), {
+                    shell: true,
+                    env,
+                    cwd: validateSafePath(projectRoot),
+                    stdio: "inherit",
+                })
+                : spawn(resolvedCmd, cmdArgs, {
+                    shell: false,
+                    env,
+                    cwd: validateSafePath(projectRoot),
+                    stdio: "inherit",
+                    detached: true,
+                });
+            child.on("error", (err) => {
+                console.error(`[HoverSource] Exec command failed to start: ${err.message}`);
+            });
+            const scriptPath = findScriptPath(projectRoot);
+            const scriptContent = fs.readFileSync(validateSafePath(scriptPath), "utf-8");
+            const portBootstrap = `globalThis.__HOVERSOURCE_PORT__ = ${serverPort};\n`;
+            const scriptWithPort = portBootstrap + scriptContent;
+            startCdpInjectionWatch(portToUse, scriptWithPort);
+            const cleanup = () => {
+                if (patchRestorer)
+                    patchRestorer();
+                process.exit();
+            };
+            process.once("SIGINT", cleanup);
+            process.once("SIGTERM", cleanup);
+            child.on("exit", cleanup);
+        };
+        const resolved = await resolveDebugPortConflicts(debugPort, projectRoot, autoResolve, args);
+        runWithCdp(resolved.resolvedDebugPort, resolved.patchRestorer);
+    }
+}

package/dist/launcher/WebProxyLauncher.d.ts

@@ -0,0 +1,5 @@
+import { AppLauncher, LaunchConfig } from "./types.js";
+export declare class WebProxyLauncher implements AppLauncher {
+    private readonly patcher;
+    launch(config: LaunchConfig): Promise<void>;
+}

package/dist/launcher/WebProxyLauncher.js

@@ -0,0 +1,114 @@
+import path from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { spawn } from "node:child_process";
+import fs from "node:fs";
+import { ReactRuntimePatcher } from "../patcher/ReactRuntimePatcher.js";
+import { loadMergedConfig } from "@hoversource/companion-server";
+import { detectDevServerPort, parseCommand, resolveWindowsCommand, validateSafeCommand, validateSafePath, waitForServer, runProxyMode } from "../cli.js";
+import { resolveDevServerPort } from "../port.js";
+export class WebProxyLauncher {
+    patcher = new ReactRuntimePatcher();
+    async launch(config) {
+        const { execCommand, projectRoot, serverPort, args } = config;
+        // Apply React runtime patching
+        this.patcher.patch(projectRoot);
+        const mergedConfig = loadMergedConfig(projectRoot);
+        const timeoutSec = mergedConfig.webAppDevServerTimeout ?? 120;
+        const timeoutMs = timeoutSec * 1000;
+        const expectedDevPort = detectDevServerPort(projectRoot, execCommand);
+        console.log(`[HoverSource] Web app detected. Dev server expected on port ${expectedDevPort}.`);
+        const autoResolve = args["auto-resolve"] === true;
+        const devResult = await resolveDevServerPort({
+            projectRoot,
+            execCommand,
+            expectedPort: expectedDevPort,
+            mode: "web",
+            autoResolve,
+            excludePorts: [serverPort]
+        });
+        const targetDevPort = devResult.port;
+        if (targetDevPort !== expectedDevPort) {
+            console.log(`[HoverSource] Dev server will use port ${targetDevPort} instead of ${expectedDevPort}.`);
+        }
+        // Set NODE_OPTIONS to preload our bootstrap script in all Node processes spawned by the dev server
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = path.dirname(__filename);
+        const localBootstrap = path.resolve(__dirname, "../bootstrap.js");
+        const projectBootstrap = path.resolve(projectRoot, "node_modules/@hoversource/cli/dist/bootstrap.js");
+        const bootstrapPath = fs.existsSync(projectBootstrap) ? projectBootstrap : localBootstrap;
+        const bootstrapUrl = pathToFileURL(bootstrapPath).href;
+        const env = { ...process.env, ...devResult.env };
+        const currentOptions = env.NODE_OPTIONS || "";
+        env.NODE_OPTIONS = `${currentOptions} --import "${bootstrapUrl}"`.trim();
+        // Spawn the dev server
+        const { command, args: cmdArgs } = parseCommand(execCommand);
+        const finalArgs = [...cmdArgs, ...devResult.extraArgs];
+        const resolvedCmd = resolveWindowsCommand(validateSafeCommand(command));
+        const useShell = process.platform === "win32";
+        const child = useShell
+            ? spawn([resolvedCmd, ...finalArgs].join(" "), {
+                shell: true,
+                env,
+                cwd: validateSafePath(projectRoot),
+                stdio: "inherit",
+            })
+            : spawn(resolvedCmd, finalArgs, {
+                shell: false,
+                env,
+                cwd: validateSafePath(projectRoot),
+                stdio: "inherit",
+                detached: true,
+            });
+        child.on("error", (err) => {
+            console.error(`[HoverSource] Dev server failed to start:`, err.message);
+        });
+        let hasExited = false;
+        let exitCode = null;
+        child.on("exit", (code) => {
+            hasExited = true;
+            exitCode = code;
+        });
+        // Wait for the dev server to be ready
+        console.log(`[HoverSource] Waiting for dev server on port ${targetDevPort} (timeout: ${timeoutSec}s)...`);
+        const ready = await waitForServer(targetDevPort, timeoutMs, () => hasExited);
+        if (!ready) {
+            if (hasExited) {
+                console.error(`\n\x1b[31m[HoverSource] Error: Dev server process exited early with code ${exitCode}.\x1b[0m`);
+                console.error(`[HoverSource] Please make sure your dev server is built and can run successfully.`);
+                console.error(`[HoverSource] If it's a production server, ensure you have built it first (e.g. npm run build)`);
+                console.error(`[HoverSource] or run the development server instead (e.g. hs dev).`);
+                return;
+            }
+            console.error(`[HoverSource] Dev server did not respond on port ${targetDevPort} within timeout.`);
+            console.error(`[HoverSource] If your dev server uses a different port, run it separately and use:`);
+            console.error(`\x1b[36m[HoverSource]   hs -t http://localhost:<your-port>\x1b[0m`);
+            return;
+        }
+        console.log(`[HoverSource] Dev server is ready on port ${targetDevPort}.`);
+        // Register cleanup to restore runtimes on exit
+        const cleanup = () => {
+            this.patcher.restore();
+            if (child.pid) {
+                try {
+                    if (process.platform === "win32") {
+                        const taskkillPath = process.env.SystemRoot
+                            ? path.join(process.env.SystemRoot, "System32", "taskkill.exe")
+                            : "taskkill";
+                        spawn(taskkillPath, ["/F", "/T", "/PID", String(child.pid)]);
+                    }
+                    else {
+                        process.kill(-child.pid, "SIGKILL");
+                    }
+                }
+                catch {
+                    child.kill();
+                }
+            }
+            process.exit();
+        };
+        process.once("SIGINT", cleanup);
+        process.once("SIGTERM", cleanup);
+        child.on("exit", cleanup);
+        await runProxyMode(`http://localhost:${targetDevPort}`, serverPort, args);
+    }
+}

package/dist/launcher/types.d.ts

@@ -0,0 +1,10 @@
+export interface LaunchConfig {
+    execCommand: string;
+    projectRoot: string;
+    serverPort: number;
+    debugPort: number;
+    args: any;
+}
+export interface AppLauncher {
+    launch(config: LaunchConfig): Promise<void>;
+}

package/dist/launcher/types.js

@@ -0,0 +1 @@
+export {};

package/dist/loader.d.ts

@@ -0,0 +1 @@
+export declare function resolve(specifier: string, context: any, nextResolve: any): Promise<any>;

package/dist/loader.js

@@ -0,0 +1,31 @@
+import { pathToFileURL, fileURLToPath } from "node:url";
+import path from "node:path";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const wrapperUrl = pathToFileURL(path.resolve(__dirname, "./custom-jsx-dev-runtime.js")).href;
+export async function resolve(specifier, context, nextResolve) {
+    const parentUrl = context.parentURL || "";
+    // Recursion guard: if parent is our wrapper, do not redirect
+    if (parentUrl.startsWith(wrapperUrl)) {
+        return nextResolve(specifier, context);
+    }
+    const isTarget = specifier === "react/jsx-dev-runtime" ||
+        specifier.endsWith("/react/jsx-dev-runtime") ||
+        specifier.replaceAll("\\", "/").includes("react/jsx-dev-runtime") ||
+        specifier.includes("next/dist/compiled/react/jsx-dev-runtime");
+    if (isTarget) {
+        try {
+            const originalResult = await nextResolve(specifier, context);
+            const originalUrl = originalResult.url;
+            // Append the original module URL as a query parameter to the wrapper URL
+            const redirectUrl = `${wrapperUrl}?original=${encodeURIComponent(originalUrl)}`;
+            return {
+                format: "module",
+                shortCircuit: true,
+                url: redirectUrl
+            };
+        }
+        catch { }
+    }
+    return nextResolve(specifier, context);
+}

package/dist/patcher/ReactRuntimePatcher.d.ts

@@ -0,0 +1,5 @@
+import { RuntimePatcher } from "./types.js";
+export declare class ReactRuntimePatcher implements RuntimePatcher {
+    patch(projectRoot: string): void;
+    restore(): void;
+}