opentunnel-cli 1.0.18 → 1.0.20

package/README.md

@@ -421,6 +421,47 @@ server:
   basePath: op
 ```
 
+## Domains Without Wildcard Support (DuckDNS)
+
+Some DNS providers like **DuckDNS** don't support wildcard subdomains (`*.domain`). OpenTunnel automatically detects DuckDNS domains and uses **port-based routing** instead of subdomains.
+
+**Auto-detection:** Domains ending in `.duckdns.org` automatically use port-based mode.
+
+**Important:** DuckDNS domains cannot use `basePath` - it will throw an error:
+
+```yaml
+# ❌ WRONG - Will throw an error
+server:
+  domains:
+    - domain: myapp.duckdns.org
+      basePath: op              # Error! DuckDNS doesn't support subdomains
+
+# ✅ CORRECT
+server:
+  domains:
+    - domain: fjrg2007.com
+      basePath: op              # Subdomain-based: *.op.fjrg2007.com
+    - domain: myapp.duckdns.org
+                                # Port-based: myapp.duckdns.org:<port>
+```
+
+**Manual configuration:** Use `wildcard: false` for other domains without wildcard support:
+
+```yaml
+server:
+  domains:
+    - domain: fjrg2007.com
+      basePath: op              # Subdomain-based: *.op.fjrg2007.com
+    - domain: other-no-wildcard.com
+      wildcard: false           # Manual: port-based
+```
+
+**How it works:**
+- **Wildcard domains:** `https://myapp.op.fjrg2007.com`
+- **Non-wildcard domains:** `https://myapp.duckdns.org:10001`
+
+Clients connecting to non-wildcard domains receive port-based URLs automatically.
+
 ## SSL Certificates
 
 When using self-signed certificates with multiple domains, OpenTunnel automatically generates a **SAN (Subject Alternative Name) certificate** that covers all configured domains and their wildcards.
@@ -690,6 +731,7 @@ opentunnel ps         # Show running processes
 | `opentunnel server -d` | Start tunnel server in background |
 | `opentunnel up` | Start from opentunnel.yml |
 | `opentunnel down` | Stop all tunnels |
+| `opentunnel restart` | Restart tunnels (down + up) |
 | `opentunnel stop` | Stop server |
 | `opentunnel ps` | List running processes |
 | `opentunnel init` | Create config file |
@@ -744,6 +786,10 @@ opentunnel up staging -d            # Named instance "staging"
 # List running instances
 opentunnel ps
 
+# Restart instances
+opentunnel restart                  # Restart all in current directory
+opentunnel restart production       # Restart specific instance
+
 # Stop instances
 opentunnel down production          # Stop specific instance
 opentunnel down                     # Stop all instances

package/dist/cli/index.js

@@ -53,6 +53,28 @@ function getRegistryPath() {
     const registryDir = path.join(os.homedir(), ".opentunnel");
     return path.join(registryDir, "registry.json");
 }
+function getLogsDir() {
+    const os = require("os");
+    const path = require("path");
+    const fs = require("fs");
+    const logsDir = path.join(os.homedir(), ".opentunnel", "logs");
+    // Ensure directory exists
+    if (!fs.existsSync(logsDir)) {
+        fs.mkdirSync(logsDir, { recursive: true });
+    }
+    return logsDir;
+}
+function getLogFilePath(instanceName) {
+    const path = require("path");
+    // Sanitize instance name for filename
+    const safeName = instanceName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(getLogsDir(), `${safeName}.log`);
+}
+function getPidFilePath(instanceName) {
+    const path = require("path");
+    const safeName = instanceName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    return path.join(getLogsDir(), `${safeName}.pid`);
+}
 function loadRegistry() {
     const fs = require("fs");
     const path = require("path");
@@ -156,7 +178,7 @@ program
     .name("opentunnel")
     .alias("ot")
     .description("Expose local ports to the internet via custom domains or ngrok")
-    .version("1.0.18");
+    .version("1.0.20");
 // Helper function to build WebSocket URL from domain
 // User only provides base domain (e.g., fjrg2007.com), system handles the rest
 // Note: --insecure flag only affects certificate verification, not the protocol
@@ -550,8 +572,8 @@ program
         const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
         const fsAsync = await Promise.resolve().then(() => __importStar(require("fs")));
         const pathAsync = await Promise.resolve().then(() => __importStar(require("path")));
-        const pidFile = pathAsync.join(process.cwd(), ".opentunnel.pid");
-        const logFile = pathAsync.join(process.cwd(), "opentunnel.log");
+        const pidFile = getPidFilePath("server");
+        const logFile = getLogFilePath("server");
         // Check if already running
         if (fsAsync.existsSync(pidFile)) {
             const oldPid = fsAsync.readFileSync(pidFile, "utf-8").trim();
@@ -722,7 +744,7 @@ program
     .action(async () => {
     const fs = await Promise.resolve().then(() => __importStar(require("fs")));
     const path = await Promise.resolve().then(() => __importStar(require("path")));
-    const pidFile = path.join(process.cwd(), ".opentunnel.pid");
+    const pidFile = getPidFilePath("server");
     if (!fs.existsSync(pidFile)) {
         console.log(chalk_1.default.yellow("No server running (PID file not found)"));
         return;
@@ -742,43 +764,6 @@ program
             console.log(chalk_1.default.red(`Failed to stop server: ${err.message}`));
     }
 });
-// Logs command
-program
-    .command("logs")
-    .description("Show server logs")
-    .option("-f, --follow", "Follow log output")
-    .option("-n, --lines <n>", "Number of lines to show", "50")
-    .action(async (options) => {
-    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
-    const path = await Promise.resolve().then(() => __importStar(require("path")));
-    const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
-    const logFile = path.join(process.cwd(), "opentunnel.log");
-    if (!fs.existsSync(logFile)) {
-        console.log(chalk_1.default.yellow("No log file found"));
-        return;
-    }
-    if (options.follow) {
-        // Use tail -f on Unix or PowerShell on Windows
-        const isWindows = process.platform === "win32";
-        if (isWindows) {
-            const child = spawn("powershell", ["-Command", `Get-Content -Path "${logFile}" -Tail ${options.lines} -Wait`], {
-                stdio: "inherit"
-            });
-            child.on("error", () => {
-                // Fallback: just read the file
-                console.log(fs.readFileSync(logFile, "utf-8"));
-            });
-        }
-        else
-            spawn("tail", ["-f", "-n", options.lines, logFile], { stdio: "inherit" });
-    }
-    else {
-        const content = fs.readFileSync(logFile, "utf-8");
-        const lines = content.split("\n");
-        const lastLines = lines.slice(-parseInt(options.lines));
-        console.log(lastLines.join("\n"));
-    }
-});
 // Status command
 program
     .command("status")
@@ -1158,8 +1143,8 @@ program
     const shouldDetach = options.detach === true;
     if (shouldDetach) {
         const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
-        const pidFile = pathModule.join(process.cwd(), `.opentunnel-${instanceName}.pid`);
-        const logFile = pathModule.join(process.cwd(), `opentunnel-${instanceName}.log`);
+        const pidFile = getPidFilePath(instanceName);
+        const logFile = getLogFilePath(instanceName);
         // Check if already running
         if (fsModule.existsSync(pidFile)) {
             const oldPid = fsModule.readFileSync(pidFile, "utf-8").trim();
@@ -1298,13 +1283,25 @@ program
     const useHttps = config.server?.https !== false;
     const hasTunnels = tunnelsToStart.length > 0;
     // Parse multiple domains from config
+    // Helper to check if domain is DuckDNS
+    const isDuckDns = (domain) => domain.toLowerCase().endsWith(".duckdns.org");
     let serverDomains;
     if (config.server?.domains && config.server.domains.length > 0) {
         serverDomains = config.server.domains.map(d => {
             if (typeof d === "string") {
-                return { domain: d, basePath: basePath };
+                // DuckDNS domains don't use basePath
+                return { domain: d, basePath: isDuckDns(d) ? "" : basePath };
             }
-            return { domain: d.domain, basePath: d.basePath || basePath };
+            // If basePath is explicitly set for DuckDNS, it will error in TunnelServer
+            // If not set, default to empty for DuckDNS, or global basePath for others
+            const domainBasePath = d.basePath !== undefined
+                ? d.basePath
+                : (isDuckDns(d.domain) ? "" : basePath);
+            return {
+                domain: d.domain,
+                basePath: domainBasePath,
+                wildcard: d.wildcard,
+            };
         });
     }
     // Check if we have domain configuration (single or multiple)
@@ -1490,6 +1487,143 @@ program
         console.log(chalk_1.default.green(`\n${stoppedCount} instance(s) stopped`));
     }
 });
+// Restart command - stop and start again
+program
+    .command("restart [name]")
+    .description("Restart tunnels (equivalent to down + up)")
+    .option("-f, --file <file>", "Config file", "opentunnel.yml")
+    .action(async (name, options) => {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const pathModule = await Promise.resolve().then(() => __importStar(require("path")));
+    const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
+    const registry = loadRegistry();
+    let instancesToRestart = [];
+    if (name) {
+        // Restart specific instance by name
+        instancesToRestart = registry.instances.filter(i => i.name === name);
+        if (instancesToRestart.length === 0) {
+            console.log(chalk_1.default.yellow(`Instance "${name}" not found`));
+            console.log(chalk_1.default.gray(`Use 'opentunnel ps' to list running instances`));
+            return;
+        }
+    }
+    else {
+        // Restart instances from current directory
+        instancesToRestart = registry.instances.filter(i => i.cwd === process.cwd());
+    }
+    if (instancesToRestart.length === 0) {
+        console.log(chalk_1.default.yellow("No tunnels running to restart"));
+        console.log(chalk_1.default.gray("Use 'opentunnel up -d' to start tunnels"));
+        return;
+    }
+    console.log(chalk_1.default.cyan(`Restarting ${instancesToRestart.length} instance(s)...\n`));
+    for (const instance of instancesToRestart) {
+        // Step 1: Stop the instance
+        try {
+            process.kill(instance.pid, "SIGTERM");
+            console.log(chalk_1.default.yellow(`  ↓ Stopped ${instance.name}`));
+        }
+        catch (err) {
+            if (err.code !== "ESRCH") {
+                console.log(chalk_1.default.red(`  ✗ Failed to stop ${instance.name}: ${err.message}`));
+                continue;
+            }
+        }
+        // Remove PID file
+        try {
+            if (fs.existsSync(instance.pidFile)) {
+                fs.unlinkSync(instance.pidFile);
+            }
+        }
+        catch { }
+        // Unregister from registry
+        unregisterInstanceByPid(instance.pid);
+        // Wait a bit for the process to fully stop
+        await new Promise(resolve => setTimeout(resolve, 500));
+        // Step 2: Start the instance again
+        const configPath = instance.configPath;
+        if (!fs.existsSync(configPath)) {
+            console.log(chalk_1.default.red(`  ✗ Config file not found: ${configPath}`));
+            continue;
+        }
+        // Spawn new process
+        const logFile = instance.logFile;
+        const pidFile = instance.pidFile;
+        const instanceName = instance.name;
+        const cwd = instance.cwd;
+        // Open file descriptor for logging (required for detached processes)
+        const logFd = fs.openSync(logFile, "a");
+        const child = spawn(process.execPath, [process.argv[1], "up", "-f", pathModule.basename(configPath)], {
+            cwd,
+            detached: true,
+            stdio: ["ignore", logFd, logFd],
+            env: { ...process.env, OPENTUNNEL_INSTANCE_NAME: instanceName },
+        });
+        child.unref();
+        fs.closeSync(logFd);
+        // Wait and check if process started successfully
+        await new Promise(resolve => setTimeout(resolve, 1500));
+        let processRunning = false;
+        try {
+            process.kill(child.pid, 0);
+            processRunning = true;
+        }
+        catch {
+            processRunning = false;
+        }
+        if (processRunning) {
+            // Process is running, register it
+            registerInstance({
+                name: instanceName,
+                pid: child.pid,
+                configPath,
+                logFile,
+                pidFile,
+                cwd,
+                startedAt: new Date().toISOString(),
+            });
+            // Write PID file
+            fs.writeFileSync(pidFile, child.pid.toString());
+            console.log(chalk_1.default.green(`  ↑ Started ${instanceName} (PID: ${child.pid})`));
+        }
+        else {
+            // Process failed - check logs for error
+            console.log(chalk_1.default.red(`  ✗ Failed to start ${instanceName}`));
+            // Read last lines of log to show error
+            if (fs.existsSync(logFile)) {
+                const logContent = fs.readFileSync(logFile, "utf-8");
+                const lines = logContent.split("\n");
+                // Find error lines
+                const errorLines = [];
+                let capturing = false;
+                for (let i = lines.length - 1; i >= 0 && errorLines.length < 10; i--) {
+                    const line = lines[i];
+                    if (line.includes("Error:") || line.includes("error:") || capturing) {
+                        errorLines.unshift(line);
+                        capturing = true;
+                    }
+                    if (line.includes("throw new Error") || line.includes("at new")) {
+                        capturing = true;
+                    }
+                }
+                if (errorLines.length > 0) {
+                    console.log(chalk_1.default.red("\n  Error details:"));
+                    console.log(chalk_1.default.gray("  " + "─".repeat(60)));
+                    // Find the actual error message
+                    const errorMsg = errorLines.find(l => l.includes("Error:"));
+                    if (errorMsg) {
+                        const match = errorMsg.match(/Error:\s*(.+)/);
+                        if (match) {
+                            console.log(chalk_1.default.red(`  ${match[1]}`));
+                        }
+                    }
+                    console.log(chalk_1.default.gray("  " + "─".repeat(60)));
+                }
+            }
+        }
+    }
+    console.log();
+});
 // PS command - list running tunnel processes (global)
 program
     .command("ps")
@@ -1629,6 +1763,104 @@ program
         console.log(lines.join("\n"));
     }
 });
+// Logs clean command - remove log files
+program
+    .command("logs-clean [name]")
+    .description("Clean log files")
+    .option("--all", "Clean all log files")
+    .action(async (name, options) => {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const logsDir = getLogsDir();
+    if (!fs.existsSync(logsDir)) {
+        console.log(chalk_1.default.yellow("No logs directory found"));
+        return;
+    }
+    let files;
+    if (options.all) {
+        // Clean all log files
+        files = fs.readdirSync(logsDir).filter(f => f.endsWith(".log"));
+    }
+    else if (name) {
+        // Clean specific instance logs
+        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, "_");
+        const logFile = `${safeName}.log`;
+        files = fs.existsSync(path.join(logsDir, logFile)) ? [logFile] : [];
+    }
+    else {
+        console.log(chalk_1.default.yellow("Specify instance name or use --all to clean all logs"));
+        console.log(chalk_1.default.gray(`  opentunnel logs-clean <name>    Clean logs for specific instance`));
+        console.log(chalk_1.default.gray(`  opentunnel logs-clean --all     Clean all log files`));
+        return;
+    }
+    if (files.length === 0) {
+        console.log(chalk_1.default.yellow(name ? `No logs found for "${name}"` : "No log files found"));
+        return;
+    }
+    let totalSize = 0;
+    for (const file of files) {
+        const filePath = path.join(logsDir, file);
+        try {
+            const stat = fs.statSync(filePath);
+            totalSize += stat.size;
+            fs.unlinkSync(filePath);
+            console.log(chalk_1.default.green(`  ✓ Deleted ${file} (${(stat.size / 1024).toFixed(1)} KB)`));
+        }
+        catch (err) {
+            console.log(chalk_1.default.red(`  ✗ Failed to delete ${file}: ${err.message}`));
+        }
+    }
+    console.log(chalk_1.default.gray(`\nCleaned ${files.length} file(s), freed ${(totalSize / 1024).toFixed(1)} KB`));
+    console.log(chalk_1.default.gray(`Logs directory: ${logsDir}`));
+});
+// Logs list command - show logs directory and list log files
+program
+    .command("logs-list")
+    .description("List all log files and show logs directory")
+    .action(async () => {
+    const fs = await Promise.resolve().then(() => __importStar(require("fs")));
+    const logsDir = getLogsDir();
+    console.log(chalk_1.default.cyan(`Logs directory: ${logsDir}\n`));
+    if (!fs.existsSync(logsDir)) {
+        console.log(chalk_1.default.yellow("No logs directory found"));
+        return;
+    }
+    const files = fs.readdirSync(logsDir).filter(f => f.endsWith(".log") || f.endsWith(".pid"));
+    if (files.length === 0) {
+        console.log(chalk_1.default.yellow("No log files found"));
+        return;
+    }
+    const logFiles = files.filter(f => f.endsWith(".log"));
+    const pidFiles = files.filter(f => f.endsWith(".pid"));
+    if (logFiles.length > 0) {
+        console.log(chalk_1.default.white("Log files:"));
+        let totalSize = 0;
+        for (const file of logFiles) {
+            const filePath = path.join(logsDir, file);
+            const stat = fs.statSync(filePath);
+            const size = (stat.size / 1024).toFixed(1);
+            const modified = stat.mtime.toLocaleString();
+            totalSize += stat.size;
+            console.log(chalk_1.default.gray(`  ${file.padEnd(35)} ${size.padStart(8)} KB  ${modified}`));
+        }
+        console.log(chalk_1.default.gray(`\n  Total: ${logFiles.length} file(s), ${(totalSize / 1024).toFixed(1)} KB`));
+    }
+    if (pidFiles.length > 0) {
+        console.log(chalk_1.default.white("\nPID files (active instances):"));
+        for (const file of pidFiles) {
+            const filePath = path.join(logsDir, file);
+            const pid = fs.readFileSync(filePath, "utf-8").trim();
+            const name = file.replace(".pid", "");
+            let status = chalk_1.default.green("running");
+            try {
+                process.kill(parseInt(pid), 0);
+            }
+            catch {
+                status = chalk_1.default.red("stale");
+            }
+            console.log(chalk_1.default.gray(`  ${name.padEnd(35)} PID: ${pid.padStart(6)}  ${status}`));
+        }
+    }
+});
 // Test server command - simple HTTP server for testing tunnels
 program
     .command("test-server")
@@ -1642,8 +1874,8 @@ program
         const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
         const fs = await Promise.resolve().then(() => __importStar(require("fs")));
         const path = await Promise.resolve().then(() => __importStar(require("path")));
-        const pidFile = path.join(process.cwd(), `.test-server-${port}.pid`);
-        const logFile = path.join(process.cwd(), `test-server-${port}.log`);
+        const pidFile = getPidFilePath(`test-server-${port}`);
+        const logFile = getLogFilePath(`test-server-${port}`);
         if (fs.existsSync(pidFile)) {
             const oldPid = fs.readFileSync(pidFile, "utf-8").trim();
             try {
@@ -1731,22 +1963,25 @@ program
     .option("-p, --port <port>", "Stop specific port")
     .action(async (options) => {
     const fs = await Promise.resolve().then(() => __importStar(require("fs")));
-    const path = await Promise.resolve().then(() => __importStar(require("path")));
+    const logsDir = getLogsDir();
     let pidFiles;
     if (options.port) {
-        const specific = `.test-server-${options.port}.pid`;
-        pidFiles = fs.existsSync(path.join(process.cwd(), specific)) ? [specific] : [];
+        const pidPath = getPidFilePath(`test-server-${options.port}`);
+        pidFiles = fs.existsSync(pidPath) ? [pidPath] : [];
+    }
+    else {
+        pidFiles = fs.readdirSync(logsDir)
+            .filter(f => f.startsWith("test-server-") && f.endsWith(".pid"))
+            .map(f => path.join(logsDir, f));
     }
-    else
-        pidFiles = fs.readdirSync(process.cwd()).filter(f => f.startsWith(".test-server-") && f.endsWith(".pid"));
     if (pidFiles.length === 0) {
         console.log(chalk_1.default.yellow("No test servers running"));
         return;
     }
-    for (const pidFile of pidFiles) {
-        const pidPath = path.join(process.cwd(), pidFile);
+    for (const pidPath of pidFiles) {
         const pid = parseInt(fs.readFileSync(pidPath, "utf-8").trim());
-        const port = pidFile.replace(".test-server-", "").replace(".pid", "");
+        const fileName = path.basename(pidPath);
+        const port = fileName.replace("test-server-", "").replace(".pid", "");
         try {
             process.kill(pid, "SIGTERM");
             fs.unlinkSync(pidPath);
@@ -1764,8 +1999,8 @@ async function runTunnelInBackgroundFromConfig(name, protocol, port, options) {
     const { spawn } = await Promise.resolve().then(() => __importStar(require("child_process")));
     const fs = await Promise.resolve().then(() => __importStar(require("fs")));
     const path = await Promise.resolve().then(() => __importStar(require("path")));
-    const pidFile = path.join(process.cwd(), `.opentunnel-${name}.pid`);
-    const logFile = path.join(process.cwd(), `opentunnel-${name}.log`);
+    const pidFile = getPidFilePath(name);
+    const logFile = getLogFilePath(name);
     // Check if already running
     if (fs.existsSync(pidFile)) {
         const oldPid = fs.readFileSync(pidFile, "utf-8").trim();
@@ -1882,8 +2117,8 @@ async function runTunnelInBackground(command, port, options) {
     const fs = await Promise.resolve().then(() => __importStar(require("fs")));
     const path = await Promise.resolve().then(() => __importStar(require("path")));
     const tunnelId = `tunnel-${port}-${Date.now()}`;
-    const pidFile = path.join(process.cwd(), `.opentunnel-${port}.pid`);
-    const logFile = path.join(process.cwd(), `opentunnel-${port}.log`);
+    const pidFile = getPidFilePath(`tunnel-${port}`);
+    const logFile = getLogFilePath(`tunnel-${port}`);
     // Check if already running
     if (fs.existsSync(pidFile)) {
         const oldPid = fs.readFileSync(pidFile, "utf-8").trim();