tmux-ide 1.2.1 → 2.0.0

package/src/lib/tunnels/ngrok.ts

@@ -0,0 +1,261 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+
+import { spawn as nodeSpawn, type ChildProcess } from "node:child_process";
+import * as os from "node:os";
+import * as path from "node:path";
+import { log as logger } from "../log.ts";
+import type { TunnelService, TunnelStatus } from "./types.ts";
+
+let spawnImpl: typeof nodeSpawn = nodeSpawn;
+
+/** @internal Restore previous `spawn` with the returned function. */
+export function _setSpawnForTesting(fn: typeof nodeSpawn): () => void {
+  const prev = spawnImpl;
+  spawnImpl = fn;
+  return () => {
+    spawnImpl = prev;
+  };
+}
+
+export interface NgrokConfig {
+  authToken?: string;
+  domain?: string;
+  port: number;
+  region?: string;
+  /** Override startup wait (default 30s). Useful for unit tests. */
+  startupTimeoutMs?: number;
+}
+
+export interface NgrokTunnel {
+  publicUrl: string;
+  proto: string;
+  name: string;
+  uri: string;
+}
+
+export class NgrokService implements TunnelService {
+  private ngrokProcess: ChildProcess | null = null;
+  private currentTunnel: NgrokTunnel | null = null;
+  private isRunning = false;
+
+  constructor(private config: NgrokConfig) {}
+
+  /**
+   * Check if ngrok binary is available
+   */
+  private async checkNgrokBinary(): Promise<string | null> {
+    const possiblePaths = [
+      "ngrok", // Global PATH
+      "/usr/local/bin/ngrok",
+      "/opt/homebrew/bin/ngrok",
+      path.join(os.homedir(), ".local", "bin", "ngrok"),
+      // Windows paths
+      "C:\\Program Files\\ngrok\\ngrok.exe",
+      path.join(os.homedir(), "AppData", "Local", "ngrok", "ngrok.exe"),
+    ];
+
+    for (const ngrokPath of possiblePaths) {
+      try {
+        const result = await new Promise<boolean>((resolve) => {
+          const proc = spawnImpl(ngrokPath, ["version"], { stdio: "ignore" });
+          proc.on("close", (code) => resolve(code === 0));
+          proc.on("error", () => resolve(false));
+          // Timeout after 2 seconds
+          setTimeout(() => {
+            proc.kill();
+            resolve(false);
+          }, 2000);
+        });
+        if (result) {
+          logger.debug(`Found ngrok at: ${ngrokPath}`);
+          return ngrokPath;
+        }
+      } catch {
+        // Continue checking other paths
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Start ngrok tunnel
+   */
+  async start(): Promise<NgrokTunnel> {
+    if (this.isRunning) {
+      logger.warn("Ngrok tunnel is already running");
+      if (this.currentTunnel) {
+        return this.currentTunnel;
+      }
+    }
+
+    const ngrokPath = await this.checkNgrokBinary();
+    if (!ngrokPath) {
+      throw new Error("ngrok binary not found. Please install ngrok: https://ngrok.com/download");
+    }
+
+    // Build ngrok command arguments
+    const args = ["http", String(this.config.port), "--log=stdout", "--log-format=json"];
+
+    if (this.config.authToken) {
+      args.push("--authtoken", this.config.authToken);
+    }
+
+    if (this.config.domain) {
+      args.push("--domain", this.config.domain);
+    }
+
+    if (this.config.region) {
+      args.push("--region", this.config.region);
+    }
+
+    logger.log(`Starting ngrok tunnel on port ${this.config.port}...`);
+
+    return new Promise((resolve, reject) => {
+      this.ngrokProcess = spawnImpl(ngrokPath, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      let startupTimeout: NodeJS.Timeout;
+      let resolved = false;
+
+      const cleanup = () => {
+        if (startupTimeout) clearTimeout(startupTimeout);
+      };
+
+      const handleOutput = (data: Buffer) => {
+        const lines = data.toString().split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const record = JSON.parse(line) as {
+              msg?: string;
+              url?: string;
+              lvl?: string;
+              err?: unknown;
+            };
+
+            // Look for tunnel started message
+            if (record.msg === "started tunnel" && record.url && !resolved) {
+              resolved = true;
+              this.currentTunnel = {
+                publicUrl: record.url,
+                proto: "http",
+                name: "command_line",
+                uri: `http://localhost:${this.config.port}`,
+              };
+              this.isRunning = true;
+              cleanup();
+              logger.log(`Ngrok tunnel started: ${record.url}`);
+              resolve(this.currentTunnel);
+            }
+
+            // Log errors
+            if (record.lvl === "error" || record.err) {
+              logger.error("Ngrok error:", record.err || record.msg);
+            }
+          } catch {
+            // Not JSON, log as debug
+            logger.debug("Ngrok output:", line);
+          }
+        }
+      };
+
+      this.ngrokProcess.stdout?.on("data", handleOutput);
+      this.ngrokProcess.stderr?.on("data", (data) => {
+        logger.error("Ngrok stderr:", data.toString());
+      });
+
+      this.ngrokProcess.on("error", (error) => {
+        if (!resolved) {
+          resolved = true;
+          this.isRunning = false;
+          cleanup();
+          reject(new Error(`Failed to start ngrok: ${error.message}`));
+        }
+      });
+
+      this.ngrokProcess.on("close", (code) => {
+        this.isRunning = false;
+        this.currentTunnel = null;
+        if (code !== 0 && code !== null) {
+          logger.error(`Ngrok process exited with code ${code}`);
+        }
+      });
+
+      // Timeout if tunnel doesn't start
+      startupTimeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          this.stop().catch(() => {});
+          reject(new Error("Ngrok startup timeout - tunnel failed to start"));
+        }
+      }, this.config.startupTimeoutMs ?? 30_000);
+    });
+  }
+
+  /**
+   * Stop ngrok tunnel
+   */
+  async stop(): Promise<void> {
+    if (!this.ngrokProcess) {
+      return;
+    }
+
+    logger.log("Stopping ngrok tunnel...");
+
+    return new Promise((resolve) => {
+      if (!this.ngrokProcess) {
+        resolve();
+        return;
+      }
+
+      const killTimeout = setTimeout(() => {
+        if (this.ngrokProcess) {
+          logger.warn("Ngrok process did not exit gracefully, forcing kill");
+          this.ngrokProcess.kill("SIGKILL");
+        }
+        resolve();
+      }, 5000);
+
+      this.ngrokProcess.on("close", () => {
+        clearTimeout(killTimeout);
+        this.ngrokProcess = null;
+        this.currentTunnel = null;
+        this.isRunning = false;
+        logger.log("Ngrok tunnel stopped");
+        resolve();
+      });
+
+      this.ngrokProcess.kill("SIGTERM");
+    });
+  }
+
+  /**
+   * Get current tunnel information
+   */
+  getTunnel(): NgrokTunnel | null {
+    return this.currentTunnel;
+  }
+
+  /**
+   * Check if tunnel is running
+   */
+  isActive(): boolean {
+    return this.isRunning;
+  }
+
+  /**
+   * Get public URL if available
+   */
+  getPublicUrl(): string | null {
+    return this.currentTunnel?.publicUrl || null;
+  }
+
+  async status(): Promise<TunnelStatus> {
+    return {
+      running: this.isActive(),
+      publicUrl: this.getPublicUrl(),
+      port: this.config.port,
+    };
+  }
+}

package/src/lib/tunnels/tailscale.test.ts

@@ -0,0 +1,103 @@
+/**
+ * Uses `_setSpawnForTesting` only — `tailscale.ts` does not call `execFileSync` (no stub needed).
+ */
+import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import {
+  TailscaleServeServiceImpl,
+  _setSpawnForTesting,
+  _setTestSkipTailscaleFsPaths,
+} from "./tailscale.ts";
+
+function makeChild(emitOnSpawn: (c: EventEmitter & Partial<ChildProcess>) => void): ChildProcess {
+  const stdout = new EventEmitter();
+  const stderr = new EventEmitter();
+  const proc = new EventEmitter() as EventEmitter & Partial<ChildProcess>;
+  proc.stdout = stdout as NodeJS.ReadableStream;
+  proc.stderr = stderr as NodeJS.ReadableStream;
+  proc.pid = 4242;
+  proc.killed = false;
+  proc.kill = () => {
+    proc.killed = true;
+    queueMicrotask(() => proc.emit("exit", 0, null));
+    return true;
+  };
+  queueMicrotask(() => emitOnSpawn(proc));
+  return proc as ChildProcess;
+}
+
+describe("TailscaleServeServiceImpl", () => {
+  let restoreSpawn: () => void;
+
+  beforeEach(() => {
+    _setTestSkipTailscaleFsPaths(true);
+  });
+
+  afterEach(() => {
+    _setTestSkipTailscaleFsPaths(false);
+    restoreSpawn?.();
+    restoreSpawn = () => {};
+  });
+
+  it("rejects when Tailscale is not installed (which exits non-zero)", async () => {
+    const mockSpawn = mock((_cmd: string, args: string[]) => {
+      return makeChild((proc) => {
+        if (_cmd === "which" && args[0] === "tailscale") {
+          proc.emit("exit", 1, null);
+        } else {
+          proc.emit("exit", 0, null);
+        }
+      });
+    });
+    restoreSpawn = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new TailscaleServeServiceImpl();
+    await expect(svc.start(4020, false)).rejects.toThrow(/Tailscale command not found/);
+  });
+
+  it("start completes when serve --bg exits 0 and stop resets serve", async () => {
+    const mockSpawn = mock((cmd: string, args: string[]) => {
+      return makeChild((proc) => {
+        if (cmd === "which") {
+          proc.emit("exit", 0, null);
+          return;
+        }
+        if (args[0] === "serve" && args[1] === "reset") {
+          proc.emit("exit", 0, null);
+          return;
+        }
+        if (args[0] === "serve" && args[1] === "--bg") {
+          proc.emit("exit", 0, null);
+          return;
+        }
+        proc.emit("exit", 0, null);
+      });
+    });
+    restoreSpawn = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new TailscaleServeServiceImpl();
+    await svc.start(4020, false);
+    // With `serve --bg`, the CLI exits after configuring; `cleanup()` clears `currentPort` (VibeTunnel behavior).
+    await svc.stop();
+    const serveResets = mockSpawn.mock.calls.filter(
+      (c) => Array.isArray(c[1]) && c[1][0] === "serve" && c[1][1] === "reset",
+    );
+    expect(serveResets.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it("status() returns a TunnelStatus-shaped object", async () => {
+    const mockSpawn = mock(() =>
+      makeChild((proc) => {
+        proc.emit("exit", 0, null);
+      }),
+    );
+    restoreSpawn = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new TailscaleServeServiceImpl();
+    await svc.start(4020, false);
+    const st = await svc.status();
+    expect(typeof st.running).toBe("boolean");
+    expect(st).toHaveProperty("meta");
+  });
+});