pinggy 0.1.1 → 0.1.3

package/dist/cli/buildConfig.js

@@ -181,9 +181,12 @@ function parseForwarding(forwarding) {
 }
 function parseReverseTunnelAddr(finalConfig, values) {
     const reverseTunnel = values.R;
-    if (!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) {
+    if ((!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) && !values.localport) {
         return new Error("local port not specified. Please use '-h' option for help.");
     }
+    if (!Array.isArray(reverseTunnel) || reverseTunnel.length === 0) {
+        return null;
+    }
     const forwarding = parseForwarding(reverseTunnel[0]);
     if (forwarding instanceof Error) {
         return forwarding;
@@ -277,6 +280,13 @@ function isSaveConfOption(values) {
     }
     return null;
 }
+function parseServe(finalConfig, values) {
+    const sv = values.serve;
+    if (typeof sv !== 'string' || sv.trim().length === 0)
+        return null;
+    finalConfig.serve = sv;
+    return null;
+}
 export function buildFinalConfig(values, positionals) {
     let token;
     let server;
@@ -297,7 +307,7 @@ export function buildFinalConfig(values, positionals) {
     qrCode = userParse.qrCode;
     const remainingPositionals = userParse.remaining;
     const initialTunnel = (type || values.type);
-    finalConfig = Object.assign(Object.assign({}, defaultOptions), { configid: uuidv4(), token: token || (typeof values.token === 'string' ? values.token : ''), serverAddress: server || defaultOptions.serverAddress, tunnelType: initialTunnel ? [initialTunnel] : defaultOptions.tunnelType, NoTUI: values.NoTUI || false, qrCode: qrCode || false });
+    finalConfig = Object.assign(Object.assign({}, defaultOptions), { configid: uuidv4(), token: token || (typeof values.token === 'string' ? values.token : ''), serverAddress: server || defaultOptions.serverAddress, tunnelType: initialTunnel ? [initialTunnel] : defaultOptions.tunnelType, NoTUI: values.notui || false, qrCode: qrCode || false });
     parseType(finalConfig, values, type);
     // Apply token
     parseToken(finalConfig, token || values.token);
@@ -313,6 +323,9 @@ export function buildFinalConfig(values, positionals) {
     const lErr = parseLocalTunnelAddr(finalConfig, values);
     if (lErr instanceof Error)
         throw lErr;
+    const serveErr = parseServe(finalConfig, values);
+    if (serveErr instanceof Error)
+        throw serveErr;
     // Apply force flag if indicated via user
     if (forceFlag)
         finalConfig.force = true;

package/dist/cli/defaults.js

@@ -9,7 +9,7 @@ export const defaultOptions = {
     basicAuth: [],
     bearerTokenAuth: [],
     headerModification: [],
-    force: true,
+    force: false,
     xForwardedFor: false,
     httpsOnly: false,
     originalRequestUrl: false,

package/dist/cli/help.js

@@ -2,7 +2,7 @@ import { cliOptions } from "./options.js";
 export function printHelpMessage() {
     console.log("\nPinggy CLI Tool - Create secure tunnels to your localhost.");
     console.log("\nUsage:");
-    console.log("  pinggy [options] [user@domain]             # Domain can be any valid domain\n");
+    console.log("   pinggy [options] -l <port>\n");
     console.log("Options:");
     for (const [key, value] of Object.entries(cliOptions)) {
         if (value.hidden)
@@ -21,17 +21,17 @@ export function printHelpMessage() {
     console.log("  r:Key                   Remove header");
     console.log("  b:user:pass             Basic auth");
     console.log("  k:BEARER                Bearer token");
-    console.log("  w:192.168.1.0/24        IP whitelist (CIDR)\n");
-    console.log("Examples (SSH-style):");
+    console.log("  w:192.168.1.0/24        IP whitelist (CIDR)");
+    console.log("\nExamples (User-friendly):");
+    console.log("  pinggy -l 3000                           # HTTP(S) tunnel to localhost port 3000");
+    console.log("  pinggy --type tcp -l 22                  # TCP tunnel for SSH (port 22)");
+    console.log("  pinggy -l 8080 -d 4300                   # HTTP tunnel to port 8080 with debugger running at localhost:4300");
+    console.log("  pinggy --token mytoken -l 3000           # Authenticated tunnel");
+    console.log("  pinggy x:https x:xff -l https://localhost:8443  # HTTPS-only + XFF");
+    console.log("  pinggy w:192.168.1.0/24 -l 8080          # IP whitelist restriction");
+    console.log("\nExamples (SSH-style):");
     console.log("  pinggy -R0:localhost:3000                        # Basic HTTP tunnel");
     console.log("  pinggy --type tcp -R0:localhost:22               # TCP tunnel for SSH");
     console.log("  pinggy -R0:localhost:8080 -L4300:localhost:4300  # HTTP tunnel with debugger");
     console.log("  pinggy tcp@ap.example.com -R0:localhost:22       # TCP tunnel to region\n");
-    console.log("Examples (User-friendly):");
-    console.log("  pinggy -p 3000                           # Basic HTTP tunnel");
-    console.log("  pinggy --type tcp -p 22                  # TCP tunnel for SSH");
-    console.log("  pinggy -l 8080 -d 4300                   # HTTP tunnel with debugger");
-    console.log("  pinggy mytoken@a.example.com -p 3000     # Authenticated tunnel");
-    console.log("  pinggy x:https x:xff -l https://localhost:8443  # HTTPS-only + XFF");
-    console.log("  pinggy w:192.168.1.0/24 -l 8080          # IP whitelist restriction");
 }

package/dist/cli/options.js

@@ -28,7 +28,7 @@ export const cliOptions = {
     // Remote Control
     'remote-management': { type: 'string', description: 'Enable remote management of tunnels with token. Eg. --remote-management API_KEY' },
     manage: { type: 'string', description: 'Provide a server address to manage tunnels. Eg --manage dashboard.pinggy.io' },
-    NoTUI: { type: 'boolean', description: 'Disable TUI in remote management mode' },
+    notui: { type: 'boolean', description: 'Disable TUI in remote management mode' },
     // Misc
     version: { type: 'boolean', description: 'Print version' },
     // Help

package/dist/cli/starCli.js

@@ -15,11 +15,29 @@ import { withFullScreen } from "fullscreen-ink";
 import path from "node:path";
 import { Worker } from "node:worker_threads";
 import { getFreePort } from "../utils/getFreePort.js";
+import { fileURLToPath } from "url";
+import { logger } from "../logger.js";
+import React, { useState } from "react";
 const TunnelData = {
     urls: null,
     greet: null,
     usage: null,
 };
+let activeTui = null;
+let disconnectState = null;
+let updateDisconnectState = null;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const TunnelTuiWrapper = ({ finalConfig, urls, greet }) => {
+    const [disconnectInfo, setDisconnectInfo] = useState(null);
+    React.useEffect(() => {
+        updateDisconnectState = setDisconnectInfo;
+        return () => {
+            updateDisconnectState = null;
+        };
+    }, []);
+    return (_jsx(TunnelTui, { urls: urls !== null && urls !== void 0 ? urls : [], greet: greet !== null && greet !== void 0 ? greet : "", tunnelConfig: finalConfig, disconnectInfo: disconnectInfo }));
+};
 export function startCli(finalConfig, manager) {
     return __awaiter(this, void 0, void 0, function* () {
         if (!finalConfig.NoTUI && finalConfig.webDebugger === "") {
@@ -27,13 +45,13 @@ export function startCli(finalConfig, manager) {
             const freePort = yield getFreePort(finalConfig.webDebugger || "");
             finalConfig.webDebugger = `localhost:${freePort}`;
         }
-        const workerPath = path.resolve("./dist/cli/worker.js");
+        const workerPath = path.resolve(__dirname, "../workers/worker.js");
         try {
             const worker = new Worker(workerPath, {
                 workerData: { finalConfig },
             });
             worker.on("message", (msg) => __awaiter(this, void 0, void 0, function* () {
-                var _a, _b, _c, _d, _e, _f;
+                var _a, _b, _c, _d, _e;
                 switch (msg.type) {
                     case "created":
                         CLIPrinter.startSpinner(msg.message);
@@ -70,15 +88,52 @@ export function startCli(finalConfig, manager) {
                         CLIPrinter.info(msg.message || "Status update from worker");
                         break;
                     case "usage":
-                        console.log("Usage update:", msg.usage);
                         TunnelData.usage = msg.usage;
                         (_d = globalThis.__PINGGY_TUNNEL_STATS__) === null || _d === void 0 ? void 0 : _d.call(globalThis, msg.usage);
                         break;
                     case "TUI":
                         if (!finalConfig.NoTUI) {
-                            const tui = withFullScreen(_jsx(TunnelTui, { urls: (_e = TunnelData.urls) !== null && _e !== void 0 ? _e : [], greet: (_f = TunnelData.greet) !== null && _f !== void 0 ? _f : "", tunnelConfig: finalConfig }));
-                            yield tui.start();
+                            const tui = withFullScreen(_jsx(TunnelTuiWrapper, { finalConfig: finalConfig, urls: TunnelData.urls, greet: TunnelData.greet }));
+                            activeTui = tui;
+                            try {
+                                yield tui.start();
+                                yield tui.waitUntilExit();
+                            }
+                            catch (e) {
+                                logger.warn("TUI error", e);
+                            }
+                            finally {
+                                activeTui = null;
+                            }
+                        }
+                        break;
+                    case "warnings":
+                        CLIPrinter.warn(msg.message);
+                        break;
+                    case "disconnected":
+                        if (activeTui && updateDisconnectState) {
+                            disconnectState = {
+                                disconnected: true,
+                                error: msg.error,
+                                messages: msg.messages
+                            };
+                            updateDisconnectState(disconnectState);
+                            try {
+                                // Wait for Ink to fully exit
+                                yield activeTui.waitUntilExit();
+                            }
+                            catch (e) {
+                                logger.warn("Failed to wait for TUI exit", e);
+                            }
+                            finally {
+                                activeTui = null;
+                            }
+                        }
+                        if ((_e = msg.messages) === null || _e === void 0 ? void 0 : _e.length) {
+                            msg.messages.forEach((m) => CLIPrinter.print(m));
                         }
+                        // Exit ONLY after fullscreen ink has restored the terminal
+                        process.exit(0);
                         break;
                     case "error":
                         CLIPrinter.error(msg.message || "Unknown error from worker");
@@ -86,7 +141,8 @@ export function startCli(finalConfig, manager) {
                 }
             }));
             worker.on("error", (err) => {
-                CLIPrinter.error(`Worker thread error: ${err}`);
+                logger.error("Worker thread error:", err);
+                CLIPrinter.error(`${err}`);
             });
             worker.on("exit", (code) => {
                 if (code !== 0) {

package/dist/index.js

@@ -22,10 +22,10 @@ function main() {
     return __awaiter(this, void 0, void 0, function* () {
         try {
             // Parse arguments from the command line
-            const { values, positionals } = parseCliArgs(cliOptions);
+            const { values, positionals, hasAnyArgs } = parseCliArgs(cliOptions);
             // Configure logger from CLI args
             configureLogger(values);
-            if (values.help) {
+            if (!hasAnyArgs || values.help) {
                 printHelpMessage();
                 return;
             }

package/dist/tui/index.js

@@ -8,8 +8,8 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
-import { useState } from "react";
-import { Box, Text, useInput } from "ink";
+import { useEffect, useState } from "react";
+import { Box, Text, useApp, useInput } from "ink";
 import { useTerminalSize } from "./hooks/useTerminalSize.js";
 import { Container } from "./layout/Container.js";
 import { Borders } from "./layout/Borders.js";
@@ -26,7 +26,8 @@ import { getStatusColor } from "./utils/utils.js";
 import { KeyBindings } from "./sections/KeyBindings.js";
 const MIN_WIDTH_WARNING = 60;
 const SIMPLE_LAYOUT_THRESHOLD = 80;
-const TunnelTui = ({ urls, greet, tunnelConfig }) => {
+const TunnelTui = ({ urls, greet, tunnelConfig, disconnectInfo }) => {
+    const { exit } = useApp();
     const { columns: terminalWidth } = useTerminalSize();
     const isQrCodeRequested = (tunnelConfig === null || tunnelConfig === void 0 ? void 0 : tunnelConfig.qrCode) || false;
     // States
@@ -40,6 +41,11 @@ const TunnelTui = ({ urls, greet, tunnelConfig }) => {
     const { pairs } = useWebDebugger(tunnelConfig === null || tunnelConfig === void 0 ? void 0 : tunnelConfig.webDebugger);
     const { headers, fetchHeaders, clear } = useReqResHeaders(tunnelConfig === null || tunnelConfig === void 0 ? void 0 : tunnelConfig.webDebugger);
     const allPairs = [...pairs.values()];
+    useEffect(() => {
+        if (disconnectInfo === null || disconnectInfo === void 0 ? void 0 : disconnectInfo.disconnected) {
+            exit();
+        }
+    }, [disconnectInfo, exit]);
     // Key handling
     useInput((input, key) => {
         if (inDetailView && key.escape) {
@@ -95,6 +101,6 @@ const TunnelTui = ({ urls, greet, tunnelConfig }) => {
     return (_jsxs(_Fragment, { children: [_jsx(Container, { children: _jsx(Borders, { children: _jsxs(Box, { flexDirection: "column", height: "100%", justifyContent: "space-between", children: [_jsxs(Box, { flexDirection: "column", children: [greet && (_jsx(Box, { justifyContent: "center", width: "94%", marginBottom: 1, children: _jsx(Text, { color: "cyanBright", bold: true, children: greet }) })), _jsxs(Box, { flexDirection: "row", justifyContent: "space-evenly", width: "100%", paddingY: 1, children: [_jsx(URLsSection, { urls: urls, currentQrIndex: currentQrIndex }), _jsx(StatsSection, { stats: stats })] }), _jsxs(Box, { flexDirection: "row", justifyContent: "space-evenly", width: "100%", paddingY: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, width: isQrCodeRequested ? "60%" : "80%", children: [_jsx(Text, { color: "yellowBright", children: "HTTP Requests:" }), visiblePairs.map((pair, i) => {
                                                         var _a, _b, _c, _d;
                                                         return (_jsx(Text, { children: _jsxs(Text, { color: selectedIndex === startIndex + i ? "cyanBright" : getStatusColor(((_a = pair.response) === null || _a === void 0 ? void 0 : _a.status) || ""), children: [selectedIndex === startIndex + i ? "> " : "  ", ((_b = pair.request) === null || _b === void 0 ? void 0 : _b.method) || "", pair.response ? (_jsxs(Text, { color: selectedIndex === startIndex + i ? "cyanBright" : getStatusColor(((_c = pair.response) === null || _c === void 0 ? void 0 : _c.status) || ""), children: [" ", "  ", pair.response.status] })) : (_jsx(Text, { dimColor: true, children: "..." })), " ", ((_d = pair.request) === null || _d === void 0 ? void 0 : _d.uri) || ""] }) }, i));
-                                                    })] }), isQrCodeRequested && (_jsx(QrCodeSection, { qrCodes: qrCodes, urls: urls, currentQrIndex: currentQrIndex }))] })] }), _jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Ctrl+C to stop the tunnel." }) })] }) }) }), inDetailView && (_jsx(DebuggerDetailModal, { requestText: headers === null || headers === void 0 ? void 0 : headers.req, responseText: headers === null || headers === void 0 ? void 0 : headers.res, onClose: () => setInDetailView(false) })), keyBindingView && _jsx(KeyBindings, {})] }));
+                                                    })] }), isQrCodeRequested && (_jsx(QrCodeSection, { qrCodes: qrCodes, urls: urls, currentQrIndex: currentQrIndex }))] })] }), _jsx(Box, { justifyContent: "center", marginTop: 1, children: _jsx(Text, { dimColor: true, children: "Press Ctrl+C to stop the tunnel Or press h for key bindings" }) })] }) }) }), inDetailView && (_jsx(DebuggerDetailModal, { requestText: headers === null || headers === void 0 ? void 0 : headers.req, responseText: headers === null || headers === void 0 ? void 0 : headers.res, onClose: () => setInDetailView(false) })), keyBindingView && _jsx(KeyBindings, {})] }));
 };
 export default TunnelTui;

package/dist/tunnel_manager/TunnelManager.js

@@ -25,12 +25,20 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { pinggy } from "@pinggy/pinggy";
 import { logger } from "../logger.js";
 import { v4 as uuidv4 } from "uuid";
+import path from "node:path";
+import { Worker } from "node:worker_threads";
+import { fileURLToPath } from "node:url";
+import CLIPrinter from "../utils/printer.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 export class TunnelManager {
     constructor() {
         this.tunnelsByTunnelId = new Map();
         this.tunnelsByConfigId = new Map();
         this.tunnelStats = new Map();
         this.tunnelStatsListeners = new Map();
+        this.tunnelErrorListeners = new Map();
+        this.tunnelDisconnectListeners = new Map();
     }
     static getInstance() {
         if (!TunnelManager.instance) {
@@ -69,9 +77,13 @@ export class TunnelManager {
             instance,
             tunnelConfig: config,
             additionalForwarding,
+            serve: config.serve,
+            warnings: []
         };
-        // Register stats callback for this tunnel
+        // Register stats & error callback for this tunnel
         this.setupStatsCallback(tunnelid, managed);
+        this.setupErrorCallback(tunnelid, managed);
+        this.setupDisconnectCallback(tunnelid, managed);
         this.tunnelsByTunnelId.set(tunnelid, managed);
         this.tunnelsByConfigId.set(configid, managed);
         logger.info("Tunnel created", { configid, tunnelid });
@@ -114,6 +126,9 @@ export class TunnelManager {
                     }
                 }
             }
+            if (managed.serve) {
+                this.startStaticFileServer(managed);
+            }
             return urls;
         });
     }
@@ -134,6 +149,10 @@ export class TunnelManager {
         logger.info("Stopping tunnel", { tunnelId, configId: managed.configid });
         try {
             managed.instance.stop();
+            if (managed.serveWorker) {
+                logger.info("terminating serveWorker");
+                managed.serveWorker.terminate();
+            }
             this.tunnelStats.delete(tunnelId);
             this.tunnelStatsListeners.delete(tunnelId);
             logger.info("Tunnel stopped", { tunnelId });
@@ -435,6 +454,34 @@ export class TunnelManager {
         logger.info("Stats listener registered for tunnel", { tunnelId, listenerId });
         return listenerId;
     }
+    registerErrorListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelErrorListeners.has(tunnelId)) {
+            this.tunnelErrorListeners.set(tunnelId, new Map());
+        }
+        const listenerId = uuidv4();
+        const tunnelErrorListeners = this.tunnelErrorListeners.get(tunnelId);
+        tunnelErrorListeners.set(listenerId, listener);
+        logger.info("Error listener registered for tunnel", { tunnelId, listenerId });
+        return listenerId;
+    }
+    registerDisconnectListener(tunnelId, listener) {
+        const managed = this.tunnelsByTunnelId.get(tunnelId);
+        if (!managed) {
+            throw new Error(`Tunnel "${tunnelId}" not found`);
+        }
+        if (!this.tunnelDisconnectListeners.has(tunnelId)) {
+            this.tunnelDisconnectListeners.set(tunnelId, new Map());
+        }
+        const listenerId = uuidv4();
+        const tunnelDisconnectListeners = this.tunnelDisconnectListeners.get(tunnelId);
+        tunnelDisconnectListeners.set(listenerId, listener);
+        logger.info("Disconnect listener registered for tunnel", { tunnelId, listenerId });
+        return listenerId;
+    }
     /**
      * Removes a previously registered stats listener.
      *
@@ -459,6 +506,40 @@ export class TunnelManager {
             logger.warn("Attempted to deregister non-existent stats listener", { tunnelId, listenerId });
         }
     }
+    deregisterErrorListener(tunnelId, listenerId) {
+        const listeners = this.tunnelErrorListeners.get(tunnelId);
+        if (!listeners) {
+            logger.warn("No error listeners found for tunnel", { tunnelId });
+            return;
+        }
+        const removed = listeners.delete(listenerId);
+        if (removed) {
+            logger.info("Error listener deregistered", { tunnelId, listenerId });
+            if (listeners.size === 0) {
+                this.tunnelErrorListeners.delete(tunnelId);
+            }
+        }
+        else {
+            logger.warn("Attempted to deregister non-existent error listener", { tunnelId, listenerId });
+        }
+    }
+    deregisterDisconnectListener(tunnelId, listenerId) {
+        const listeners = this.tunnelDisconnectListeners.get(tunnelId);
+        if (!listeners) {
+            logger.warn("No disconnect listeners found for tunnel", { tunnelId });
+            return;
+        }
+        const removed = listeners.delete(listenerId);
+        if (removed) {
+            logger.info("Disconnect listener deregistered", { tunnelId, listenerId });
+            if (listeners.size === 0) {
+                this.tunnelDisconnectListeners.delete(tunnelId);
+            }
+        }
+        else {
+            logger.warn("Attempted to deregister non-existent disconnect listener", { tunnelId, listenerId });
+        }
+    }
     getLocalserverTlsInfo(tunnelId) {
         const managed = this.tunnelsByTunnelId.get(tunnelId);
         if (!managed) {
@@ -494,6 +575,73 @@ export class TunnelManager {
             logger.warn("Failed to set up stats callback", { tunnelId, error });
         }
     }
+    notifyErrorListeners(tunnelId, errorMsg, isFatal) {
+        try {
+            const listeners = this.tunnelErrorListeners.get(tunnelId);
+            if (!listeners)
+                return;
+            for (const [id, listener] of listeners) {
+                try {
+                    listener(tunnelId, errorMsg, isFatal);
+                }
+                catch (err) {
+                    logger.debug("Error in error-listener callback", { listenerId: id, tunnelId, err });
+                }
+            }
+        }
+        catch (err) {
+            logger.debug("Failed to notify error listeners", { tunnelId, err });
+        }
+    }
+    setupErrorCallback(tunnelId, managed) {
+        try {
+            const callback = (errorNo, errorMsg, recoverable) => {
+                try {
+                    const msg = typeof errorMsg === "string" ? errorMsg : String(errorMsg);
+                    const isFatal = true;
+                    logger.debug("Tunnel reported error", { tunnelId, errorNo, errorMsg: msg, recoverable });
+                    this.notifyErrorListeners(tunnelId, msg, isFatal);
+                    // TODO: IF the error is fatal, we can stop the tunnel and exit.
+                }
+                catch (e) {
+                    logger.warn("Error handling tunnel error callback", { tunnelId, e });
+                }
+            };
+            managed.instance.setTunnelErrorCallback(callback);
+            logger.debug("Error callback set up for tunnel", { tunnelId });
+        }
+        catch (error) {
+            logger.warn("Failed to set up error callback", { tunnelId, error });
+        }
+    }
+    setupDisconnectCallback(tunnelId, managed) {
+        try {
+            const callback = (error, messages) => {
+                try {
+                    logger.debug("Tunnel disconnected", { tunnelId, error, messages });
+                    const listeners = this.tunnelDisconnectListeners.get(tunnelId);
+                    if (!listeners)
+                        return;
+                    for (const [id, listener] of listeners) {
+                        try {
+                            listener(tunnelId, error, messages);
+                        }
+                        catch (err) {
+                            logger.debug("Error in disconnect-listener callback", { listenerId: id, tunnelId, err });
+                        }
+                    }
+                }
+                catch (e) {
+                    logger.warn("Error handling tunnel disconnect callback", { tunnelId, e });
+                }
+            };
+            managed.instance.setTunnelDisconnectedCallback(callback);
+            logger.debug("Disconnect callback set up for tunnel", { tunnelId });
+        }
+        catch (error) {
+            logger.warn("Failed to set up disconnect callback", { tunnelId, error });
+        }
+    }
     /**
      * Updates the stored stats for a tunnel and notifies all registered listeners.
      */
@@ -548,4 +696,42 @@ export class TunnelManager {
         const parsed = typeof value === 'number' ? value : parseInt(String(value), 10);
         return isNaN(parsed) ? 0 : parsed;
     }
+    startStaticFileServer(managed) {
+        var _a;
+        try {
+            const fileServerWorkerPath = path.resolve(__dirname, "../workers/file_serve_worker.js");
+            const staticServerWorker = new Worker(fileServerWorkerPath, {
+                workerData: {
+                    dir: managed.serve,
+                    port: (_a = managed.tunnelConfig) === null || _a === void 0 ? void 0 : _a.forwarding,
+                },
+            });
+            staticServerWorker.on("message", (msg) => {
+                var _a, _b;
+                switch (msg.type) {
+                    case "started":
+                        logger.info("Static file server started", { dir: managed.serve });
+                        break;
+                    case "warning":
+                        if (msg.code === "INVALID_TUNNEL_SERVE_PATH") {
+                            managed.warnings = (_a = managed.warnings) !== null && _a !== void 0 ? _a : [];
+                            managed.warnings.push({ code: msg.code, message: msg.message });
+                        }
+                        CLIPrinter.warn(msg.message);
+                        break;
+                    case "error":
+                        managed.warnings = (_b = managed.warnings) !== null && _b !== void 0 ? _b : [];
+                        managed.warnings.push({
+                            code: "UNKNOWN_WARNING",
+                            message: msg.message,
+                        });
+                        break;
+                }
+            });
+            managed.serveWorker = staticServerWorker;
+        }
+        catch (error) {
+            logger.error("Error starting static file server", error);
+        }
+    }
 }

package/dist/types.js

@@ -21,6 +21,7 @@ export var TunnelErrorCodeType;
 export var TunnelWarningCode;
 (function (TunnelWarningCode) {
     TunnelWarningCode["InvalidTunnelServePath"] = "INVALID_TUNNEL_SERVE_PATH";
+    TunnelWarningCode["UnknownWarning"] = "UNKNOWN_WARNING";
 })(TunnelWarningCode || (TunnelWarningCode = {}));
 export const ErrorCode = {
     InvalidRequestMethodError: "INVALID_REQUEST_METHOD",

package/dist/utils/FileServer.js

@@ -0,0 +1,112 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createServer } from "http";
+import { readFile, readdir, stat } from "fs/promises";
+import { existsSync } from "fs";
+import { extname, join, resolve, relative } from "path";
+import { URL } from "url";
+import mime from "mime";
+import { logger } from "../logger.js";
+import { directoryListingHtml, invalidPathErrorHtml } from "./htmlTemplates.js";
+export class FileServerError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.name = "FileServerError";
+        this.code = code;
+    }
+}
+export function startFileServer(dirPath_1) {
+    return __awaiter(this, arguments, void 0, function* (dirPath, port = 8080) {
+        let invalidPathError = null;
+        const root = resolve(dirPath);
+        logger.debug("Starting file server with root:", root, "on port:", port);
+        if (!existsSync(root)) {
+            logger.debug("Invalid root path for file server:", root);
+            invalidPathError = new FileServerError(`The path ${dirPath} does not exist. Please check the path and try again.`, "INVALID_TUNNEL_SERVE_PATH");
+        }
+        const server = createServer((req, res) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // If invalid root, show an HTML error page
+                if (invalidPathError) {
+                    const html = invalidPathErrorHtml(invalidPathError);
+                    res.writeHead(200, { "Content-Type": "text/html" });
+                    res.end(html);
+                    return;
+                }
+                const reqUrl = new URL(req.url || "/", `http://${req.headers.host}`);
+                let filePath = join(root, decodeURIComponent(reqUrl.pathname));
+                let stats;
+                try {
+                    stats = yield stat(filePath);
+                }
+                catch (_a) {
+                    res.statusCode = 404;
+                    res.end("404 Not Found");
+                    return;
+                }
+                if (stats.isDirectory() && !reqUrl.pathname.endsWith("/")) {
+                    res.writeHead(301, { Location: reqUrl.pathname + "/" });
+                    res.end();
+                    return;
+                }
+                // Directory handling
+                if (stats.isDirectory()) {
+                    const indexPath = join(filePath, "index.html");
+                    if (existsSync(indexPath)) {
+                        filePath = indexPath;
+                    }
+                    else {
+                        // No index.html — show directory listing
+                        const items = yield readdir(filePath, { withFileTypes: true });
+                        const list = items
+                            .map((item) => {
+                            // Get the display name
+                            const name = item.name + (item.isDirectory() ? "/" : "");
+                            // Construct the current base URL
+                            const base = new URL(reqUrl.pathname, `http://${req.headers.host}`);
+                            // Create the full URL
+                            const hrefUrl = new URL(encodeURIComponent(name), base);
+                            return `<li><a href="${hrefUrl.pathname}">${name}</a></li>`;
+                        })
+                            .join("");
+                        const relativePath = relative(root, filePath) || "/";
+                        const html = directoryListingHtml(relativePath, list);
+                        res.writeHead(200, { "Content-Type": "text/html" });
+                        res.end(html);
+                        return;
+                    }
+                }
+                // Normal file serving
+                const content = yield readFile(filePath);
+                const type = mime.getType(extname(filePath)) || "application/octet-stream";
+                res.writeHead(200, { "Content-Type": type });
+                res.end(content);
+            }
+            catch (err) {
+                logger.debug("Error in handling request", err);
+                res.statusCode = 500;
+                res.end(`Internal Server Error: ${err.message}`);
+            }
+        }));
+        yield new Promise((resolve, reject) => {
+            server.listen(port, () => {
+                resolve();
+            });
+            server.on("error", (err) => {
+                logger.debug("Error starting file server", err);
+                reject(err);
+            });
+        });
+        return {
+            hasInvalidPath: !!invalidPathError,
+            error: invalidPathError ? { message: invalidPathError.message, code: invalidPathError.code } : null
+        };
+    });
+}