opentunnel-cli 1.0.19 → 1.0.21

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");
@@ -98,6 +120,49 @@ function unregisterInstanceByPid(pid) {
     registry.instances = registry.instances.filter(i => i.pid !== pid);
     saveRegistry(registry);
 }
+function getConfigPath() {
+    const os = require("os");
+    const configDir = path.join(os.homedir(), ".opentunnel");
+    return path.join(configDir, "config.json");
+}
+function loadCLIConfig() {
+    const configPath = getConfigPath();
+    try {
+        if (fs.existsSync(configPath)) {
+            return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        }
+    }
+    catch { }
+    return {};
+}
+function saveCLIConfig(config) {
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function getDefaultDomain() {
+    const config = loadCLIConfig();
+    return config.defaultDomain || null;
+}
+function setDefaultDomain(domain, basePath) {
+    const config = loadCLIConfig();
+    config.defaultDomain = { domain };
+    if (basePath)
+        config.defaultDomain.basePath = basePath;
+    saveCLIConfig(config);
+}
+function clearDefaultDomain() {
+    const config = loadCLIConfig();
+    if (config.defaultDomain) {
+        delete config.defaultDomain;
+        saveCLIConfig(config);
+        return true;
+    }
+    return false;
+}
 // Load .env file if exists
 function loadEnvFile() {
     const envPath = path.join(process.cwd(), ".env");
@@ -156,7 +221,7 @@ program
     .name("opentunnel")
     .alias("ot")
     .description("Expose local ports to the internet via custom domains or ngrok")
-    .version("1.0.19");
+    .version("1.0.21");
 // 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
@@ -351,6 +416,178 @@ program
         process.exit(1);
     }
 });
+// Domain management commands
+program
+    .command("setdomain <domain>")
+    .description("Set a default domain for quick tunnels")
+    .option("-b, --base-path <path>", "Server base path (default: op)")
+    .action((domain, options) => {
+    setDefaultDomain(domain, options.basePath);
+    console.log(chalk_1.default.green(`\n  Default domain set to: ${chalk_1.default.cyan(domain)}`));
+    if (options.basePath) {
+        console.log(chalk_1.default.gray(`  Base path: ${options.basePath}`));
+    }
+    console.log(chalk_1.default.gray(`\n  Now you can use 'opentunnel expl <port>' without specifying -s\n`));
+});
+program
+    .command("getdomain")
+    .description("Show the default domain configuration")
+    .action(() => {
+    const config = getDefaultDomain();
+    if (config) {
+        console.log(chalk_1.default.cyan("\n  Default Domain Configuration"));
+        console.log(chalk_1.default.gray("  ─────────────────────────────"));
+        console.log(`  ${chalk_1.default.white("Domain:")}    ${chalk_1.default.green(config.domain)}`);
+        if (config.basePath) {
+            console.log(`  ${chalk_1.default.white("Base Path:")} ${chalk_1.default.gray(config.basePath)}`);
+        }
+        console.log("");
+    }
+    else {
+        console.log(chalk_1.default.yellow("\n  No default domain configured"));
+        console.log(chalk_1.default.gray("  Use 'opentunnel setdomain <domain>' to set one\n"));
+    }
+});
+program
+    .command("cleardomain")
+    .description("Remove the default domain configuration")
+    .action(() => {
+    if (clearDefaultDomain()) {
+        console.log(chalk_1.default.green("\n  Default domain configuration removed\n"));
+    }
+    else {
+        console.log(chalk_1.default.yellow("\n  No default domain was configured\n"));
+    }
+});
+// Expose Local Server command (shortcut for quick --local-server)
+program
+    .command("expl <port>")
+    .description("Expose local port via local server (shortcut for 'quick <port> --local-server')")
+    .option("-s, --domain <domain>", "Server domain (uses default if not specified)")
+    .option("-b, --base-path <path>", "Server base path (default: op)")
+    .option("-n, --subdomain <name>", "Request a specific subdomain (e.g., 'myapp')")
+    .option("-p, --protocol <proto>", "Protocol (http, https, tcp)", "http")
+    .option("-h, --host <host>", "Local host to forward to", "localhost")
+    .option("-t, --token <token>", "Authentication token (if server requires it)")
+    .option("--insecure", "Skip SSL certificate verification (for self-signed certs)")
+    .option("--server-port <port>", "Port for the local server (default: 443)", "443")
+    .action(async (port, options) => {
+    // Get domain from options or default config
+    let domain = options.domain;
+    let basePath = options.basePath;
+    if (!domain) {
+        const defaultConfig = getDefaultDomain();
+        if (defaultConfig) {
+            domain = defaultConfig.domain;
+            if (!basePath && defaultConfig.basePath) {
+                basePath = defaultConfig.basePath;
+            }
+        }
+    }
+    if (!domain) {
+        console.log(chalk_1.default.red("Error: No domain specified and no default domain configured"));
+        console.log(chalk_1.default.gray("\nOptions:"));
+        console.log(chalk_1.default.cyan("  1. Specify domain: opentunnel expl 3000 -s example.com"));
+        console.log(chalk_1.default.cyan("  2. Set default:    opentunnel setdomain example.com"));
+        process.exit(1);
+    }
+    const { TunnelServer } = await Promise.resolve().then(() => __importStar(require("../server/TunnelServer")));
+    const serverPort = parseInt(options.serverPort);
+    console.log(chalk_1.default.cyan(`
+ ██████╗ ██████╗ ███████╗███╗   ██╗████████╗██╗   ██╗███╗   ██╗███╗   ██╗███████╗██╗
+██╔═══██╗██╔══██╗██╔════╝████╗  ██║╚══██╔══╝██║   ██║████╗  ██║████╗  ██║██╔════╝██║
+██║   ██║██████╔╝█████╗  ██╔██╗ ██║   ██║   ██║   ██║██╔██╗ ██║██╔██╗ ██║█████╗  ██║
+██║   ██║██╔═══╝ ██╔══╝  ██║╚██╗██║   ██║   ██║   ██║██║╚██╗██║██║╚██╗██║██╔══╝  ██║
+╚██████╔╝██║     ███████╗██║ ╚████║   ██║   ╚██████╔╝██║ ╚████║██║ ╚████║███████╗███████╗
+ ╚═════╝ ╚═╝     ╚══════╝╚═╝  ╚═══╝   ╚═╝    ╚═════╝ ╚═╝  ╚═══╝╚═╝  ╚═══╝╚══════╝╚══════╝
+`));
+    console.log(chalk_1.default.gray(`  Starting local server on port ${serverPort}...\n`));
+    let localServer;
+    try {
+        localServer = new TunnelServer({
+            port: serverPort,
+            host: "0.0.0.0",
+            domain: domain,
+            basePath: basePath || "op",
+            tunnelPortRange: { min: 10000, max: 20000 },
+            selfSignedHttps: { enabled: true },
+            auth: options.token ? { required: true, tokens: [options.token] } : undefined,
+        });
+        await localServer.start();
+        console.log(chalk_1.default.green(`  Server running on port ${serverPort}\n`));
+    }
+    catch (err) {
+        console.log(chalk_1.default.red(`Failed to start server: ${err.message}`));
+        process.exit(1);
+    }
+    // Connect to local server
+    const serverUrl = `wss://localhost:${serverPort}/_tunnel`;
+    const spinner = (0, ora_1.default)("Connecting to local server...").start();
+    try {
+        const client = new TunnelClient_1.TunnelClient({
+            serverUrl,
+            token: options.token,
+            reconnect: true,
+            silent: true,
+            rejectUnauthorized: false // Local server uses self-signed cert
+        });
+        await client.connect();
+        spinner.text = "Creating tunnel...";
+        const { tunnelId, publicUrl } = await client.createTunnel({
+            protocol: options.protocol,
+            localHost: options.host,
+            localPort: parseInt(port),
+            subdomain: options.subdomain,
+        });
+        spinner.succeed("Tunnel established!");
+        console.log("");
+        console.log(chalk_1.default.cyan(`  OpenTunnel ${chalk_1.default.gray(`(local server → ${domain})`)}`));
+        console.log(chalk_1.default.gray("  ─────────────────────────────────────────"));
+        console.log(`  ${chalk_1.default.white("Status:")}    ${chalk_1.default.green("● Online")}`);
+        console.log(`  ${chalk_1.default.white("Protocol:")}  ${chalk_1.default.yellow(options.protocol.toUpperCase())}`);
+        console.log(`  ${chalk_1.default.white("Local:")}     ${chalk_1.default.gray(`${options.host}:${port}`)}`);
+        console.log(`  ${chalk_1.default.white("Public:")}    ${chalk_1.default.green(publicUrl)}`);
+        console.log(chalk_1.default.gray("  ─────────────────────────────────────────"));
+        console.log("");
+        console.log(chalk_1.default.gray("  Press Ctrl+C to close the tunnel"));
+        console.log("");
+        // Keep alive with uptime counter
+        const startTime = Date.now();
+        const statsInterval = setInterval(() => {
+            const uptime = (0, utils_1.formatDuration)(Date.now() - startTime);
+            process.stdout.write(`\r  ${chalk_1.default.gray(`Uptime: ${uptime}`)}`);
+        }, 1000);
+        // Handle exit
+        const cleanup = async () => {
+            clearInterval(statsInterval);
+            console.log("\n");
+            const closeSpinner = (0, ora_1.default)("Closing tunnel...").start();
+            await client.closeTunnel(tunnelId);
+            await client.disconnect();
+            if (localServer) {
+                await localServer.stop();
+            }
+            closeSpinner.succeed("Tunnel closed");
+            process.exit(0);
+        };
+        process.on("SIGINT", cleanup);
+        process.on("SIGTERM", cleanup);
+        // Handle reconnection
+        client.on("disconnected", () => {
+            console.log(chalk_1.default.yellow("\n  Disconnected, reconnecting..."));
+        });
+        client.on("connected", () => {
+            console.log(chalk_1.default.green("  Reconnected!"));
+        });
+    }
+    catch (err) {
+        spinner.fail(`Failed: ${err.message}`);
+        if (localServer) {
+            await localServer.stop();
+        }
+        process.exit(1);
+    }
+});
 // HTTP tunnel command
 program
     .command("http <port>")
@@ -550,8 +787,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 +959,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 +979,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 +1358,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 +1498,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)
@@ -1554,18 +1766,27 @@ program
         const pidFile = instance.pidFile;
         const instanceName = instance.name;
         const cwd = instance.cwd;
-        const logStream = fs.createWriteStream(logFile, { flags: "a" });
+        // 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", logStream, logStream],
+            stdio: ["ignore", logFd, logFd],
             env: { ...process.env, OPENTUNNEL_INSTANCE_NAME: instanceName },
         });
         child.unref();
-        // Wait and check if process started
-        await new Promise(resolve => setTimeout(resolve, 1000));
+        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,
@@ -1580,11 +1801,43 @@ program
             fs.writeFileSync(pidFile, child.pid.toString());
             console.log(chalk_1.default.green(`  ↑ Started ${instanceName} (PID: ${child.pid})`));
         }
-        catch {
+        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(chalk_1.default.green(`\nRestart complete`));
+    console.log();
 });
 // PS command - list running tunnel processes (global)
 program
@@ -1725,6 +1978,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")
@@ -1738,8 +2089,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 {
@@ -1827,22 +2178,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);
@@ -1860,8 +2214,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();
@@ -1978,8 +2332,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();