tmux-ide 1.3.1 → 2.1.0

package/src/lib/tunnels/cloudflare.ts

@@ -0,0 +1,254 @@
+// 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 CloudflareTunnel {
+  publicUrl: string;
+  proto: string;
+  name: string;
+  uri: string;
+}
+
+export class CloudflareService implements TunnelService {
+  private cloudflaredProcess: ChildProcess | null = null;
+  private currentTunnel: CloudflareTunnel | null = null;
+  private isRunning = false;
+  private cloudflaredPath: string | null = null;
+
+  constructor(
+    private port: number,
+    private options?: { startupTimeoutMs?: number },
+  ) {}
+
+  /**
+   * Standard paths to check for cloudflared binary
+   */
+  private static readonly cloudflaredPaths = [
+    "cloudflared", // Global PATH
+    "/usr/local/bin/cloudflared",
+    "/opt/homebrew/bin/cloudflared",
+    "/usr/bin/cloudflared",
+    path.join(os.homedir(), ".cloudflared", "cloudflared"),
+    // Windows paths
+    "C:\\Program Files\\Cloudflare\\cloudflared\\cloudflared.exe",
+    path.join(os.homedir(), "AppData", "Local", "cloudflared", "cloudflared.exe"),
+  ];
+
+  /**
+   * Check if cloudflared binary is available
+   */
+  private async checkCloudflaredBinary(): Promise<string | null> {
+    for (const cloudflaredPath of CloudflareService.cloudflaredPaths) {
+      try {
+        const result = await new Promise<boolean>((resolve) => {
+          const proc = spawnImpl(cloudflaredPath, ["--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 cloudflared at: ${cloudflaredPath}`);
+          return cloudflaredPath;
+        }
+      } catch {
+        // Continue checking other paths
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Start Cloudflare tunnel (Quick Tunnel)
+   */
+  async start(): Promise<CloudflareTunnel> {
+    if (this.isRunning) {
+      logger.warn("Cloudflare tunnel is already running");
+      if (this.currentTunnel) {
+        return this.currentTunnel;
+      }
+    }
+
+    this.cloudflaredPath = await this.checkCloudflaredBinary();
+    if (!this.cloudflaredPath) {
+      throw new Error(
+        "cloudflared binary not found. Please install cloudflared: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/",
+      );
+    }
+
+    // Use Quick Tunnel (no auth required)
+    const args = ["tunnel", "--url", `http://localhost:${this.port}`];
+
+    logger.log(`Starting Cloudflare tunnel on port ${this.port}...`);
+
+    const cloudflaredPath = this.cloudflaredPath;
+    if (!cloudflaredPath) {
+      throw new Error(
+        "cloudflared binary not found. Please install cloudflared: https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/installation/",
+      );
+    }
+
+    return new Promise((resolve, reject) => {
+      this.cloudflaredProcess = spawnImpl(cloudflaredPath, args, {
+        stdio: ["ignore", "pipe", "pipe"],
+      });
+
+      let startupTimeout: NodeJS.Timeout;
+      let resolved = false;
+
+      const cleanup = () => {
+        if (startupTimeout) clearTimeout(startupTimeout);
+      };
+
+      const handleOutput = (data: Buffer) => {
+        const output = data.toString();
+        logger.debug("Cloudflare output:", output);
+
+        // Look for tunnel URL in output
+        // Cloudflare outputs something like: "https://random-words.trycloudflare.com"
+        const urlMatch = output.match(/https:\/\/[a-z0-9-]+\.trycloudflare\.com/);
+        if (urlMatch && !resolved) {
+          resolved = true;
+          const publicUrl = urlMatch[0];
+          this.currentTunnel = {
+            publicUrl,
+            proto: "https",
+            name: "cloudflare-quick-tunnel",
+            uri: `http://localhost:${this.port}`,
+          };
+          this.isRunning = true;
+          cleanup();
+          logger.log(`Cloudflare tunnel started: ${publicUrl}`);
+          resolve(this.currentTunnel);
+        }
+
+        // Look for error messages
+        if (output.toLowerCase().includes("error") && !resolved) {
+          logger.error("Cloudflare error:", output);
+        }
+      };
+
+      this.cloudflaredProcess.stdout?.on("data", handleOutput);
+      this.cloudflaredProcess.stderr?.on("data", handleOutput);
+
+      this.cloudflaredProcess.on("error", (error) => {
+        if (!resolved) {
+          resolved = true;
+          this.isRunning = false;
+          cleanup();
+          reject(new Error(`Failed to start cloudflared: ${error.message}`));
+        }
+      });
+
+      this.cloudflaredProcess.on("close", (code) => {
+        this.isRunning = false;
+        this.currentTunnel = null;
+        if (code !== 0 && code !== null) {
+          logger.error(`Cloudflared process exited with code ${code}`);
+        }
+      });
+
+      // Timeout if tunnel doesn't start
+      startupTimeout = setTimeout(() => {
+        if (!resolved) {
+          resolved = true;
+          this.stop().catch(() => {});
+          reject(new Error("Cloudflare tunnel startup timeout - tunnel failed to start"));
+        }
+      }, this.options?.startupTimeoutMs ?? 30_000);
+    });
+  }
+
+  /**
+   * Stop Cloudflare tunnel
+   */
+  async stop(): Promise<void> {
+    if (!this.cloudflaredProcess) {
+      return;
+    }
+
+    logger.log("Stopping Cloudflare tunnel...");
+
+    return new Promise((resolve) => {
+      if (!this.cloudflaredProcess) {
+        resolve();
+        return;
+      }
+
+      const killTimeout = setTimeout(() => {
+        if (this.cloudflaredProcess) {
+          logger.warn("Cloudflared process did not exit gracefully, forcing kill");
+          this.cloudflaredProcess.kill("SIGKILL");
+        }
+        resolve();
+      }, 5000);
+
+      this.cloudflaredProcess.on("close", () => {
+        clearTimeout(killTimeout);
+        this.cloudflaredProcess = null;
+        this.currentTunnel = null;
+        this.isRunning = false;
+        logger.log("Cloudflare tunnel stopped");
+        resolve();
+      });
+
+      this.cloudflaredProcess.kill("SIGTERM");
+    });
+  }
+
+  /**
+   * Get current tunnel information
+   */
+  getTunnel(): CloudflareTunnel | 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.port,
+    };
+  }
+
+  /**
+   * Check if cloudflared is installed
+   */
+  async checkInstallation(): Promise<boolean> {
+    this.cloudflaredPath = await this.checkCloudflaredBinary();
+    return this.cloudflaredPath !== null;
+  }
+}

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

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { TunnelManager } from "./manager.ts";
+
+describe("TunnelManager", () => {
+  let mgr: TunnelManager;
+
+  beforeEach(() => {
+    // Use a temp dir so event-log writes don't clutter
+    mgr = new TunnelManager({ dir: "/tmp/tunnel-test-" + Date.now() });
+  });
+
+  it("starts with status not running", async () => {
+    const status = await mgr.status();
+    expect(status.running).toBe(false);
+    expect(status.provider).toBeNull();
+  });
+
+  it("url() returns null when no tunnel running", async () => {
+    const url = await mgr.url();
+    expect(url).toBeNull();
+  });
+
+  it("stop() is a no-op when no tunnel running", async () => {
+    // Should not throw
+    await mgr.stop();
+  });
+
+  describe("provider resolution", () => {
+    it("constructs a TailscaleServeServiceImpl for tailscale provider", async () => {
+      // We can't actually start tailscale in tests, but we can verify the
+      // manager accepts the config and fails gracefully
+      try {
+        await mgr.start({ provider: "tailscale", port: 4000 });
+      } catch {
+        // Expected: tailscale binary not found in CI
+      }
+    });
+
+    it("constructs an NgrokService for ngrok provider", async () => {
+      try {
+        await mgr.start({
+          provider: "ngrok",
+          port: 4000,
+          startupTimeoutMs: 100, // fail fast
+        });
+      } catch {
+        // Expected: ngrok binary not found in CI
+      }
+    });
+
+    it("constructs a CloudflareService for cloudflare provider", async () => {
+      try {
+        await mgr.start({
+          provider: "cloudflare",
+          port: 4000,
+          startupTimeoutMs: 100,
+        });
+      } catch {
+        // Expected: cloudflared binary not found in CI
+      }
+    });
+  });
+});

package/src/lib/tunnels/manager.ts

@@ -0,0 +1,132 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { execFileSync } from "node:child_process";
+import type { TunnelService, TunnelStatus, TunnelConfig } from "./types.ts";
+import { TailscaleServeServiceImpl } from "./tailscale.ts";
+import { NgrokService } from "./ngrok.ts";
+import { CloudflareService } from "./cloudflare.ts";
+import { appendEvent } from "../event-log.ts";
+
+export class TunnelManager {
+  private service: TunnelService | null = null;
+  private provider: TunnelConfig["provider"] | null = null;
+  private session: string | null;
+  private dir: string;
+
+  constructor(opts: { session?: string; dir: string }) {
+    this.session = opts.session ?? null;
+    this.dir = opts.dir;
+  }
+
+  async start(config: TunnelConfig): Promise<TunnelStatus> {
+    if (this.service) {
+      const current = await this.service.status();
+      if (current.running) {
+        return current;
+      }
+    }
+
+    this.provider = config.provider;
+    this.service = this.createService(config);
+
+    try {
+      await this.service.start();
+      const status = await this.service.status();
+
+      if (status.publicUrl) {
+        this.setTmuxVar(status.publicUrl);
+      }
+
+      this.emitEvent("info", `Tunnel started via ${config.provider}`, status.publicUrl);
+      return status;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      this.emitEvent("error", `Tunnel start failed: ${msg}`, null);
+      throw err;
+    }
+  }
+
+  async stop(): Promise<void> {
+    if (!this.service) return;
+
+    try {
+      await this.service.stop();
+      this.clearTmuxVar();
+      this.emitEvent("info", `Tunnel stopped (${this.provider})`, null);
+    } finally {
+      this.service = null;
+      this.provider = null;
+    }
+  }
+
+  async status(): Promise<TunnelStatus & { provider: string | null }> {
+    if (!this.service) {
+      return { running: false, provider: null };
+    }
+    const s = await this.service.status();
+    return { ...s, provider: this.provider };
+  }
+
+  async url(): Promise<string | null> {
+    if (!this.service) return null;
+    const s = await this.service.status();
+    return s.publicUrl ?? null;
+  }
+
+  private createService(config: TunnelConfig): TunnelService {
+    switch (config.provider) {
+      case "tailscale":
+        return new TailscaleServeServiceImpl();
+      case "ngrok":
+        return new NgrokService({
+          port: config.port,
+          authToken: config.authToken,
+          domain: config.domain,
+          region: config.region,
+          startupTimeoutMs: config.startupTimeoutMs,
+        });
+      case "cloudflare":
+        return new CloudflareService(config.port, {
+          startupTimeoutMs: config.startupTimeoutMs,
+        });
+    }
+  }
+
+  private setTmuxVar(url: string): void {
+    if (!this.session) return;
+    try {
+      execFileSync("tmux", ["set-option", "-t", this.session, "@tunnel_url", url], {
+        stdio: "ignore",
+      });
+    } catch {
+      // tmux not available or session gone
+    }
+  }
+
+  private clearTmuxVar(): void {
+    if (!this.session) return;
+    try {
+      execFileSync("tmux", ["set-option", "-t", this.session, "-u", "@tunnel_url"], {
+        stdio: "ignore",
+      });
+    } catch {
+      // tmux not available or session gone
+    }
+  }
+
+  private emitEvent(
+    level: "info" | "error",
+    message: string,
+    url: string | null | undefined,
+  ): void {
+    try {
+      appendEvent(this.dir, {
+        timestamp: new Date().toISOString(),
+        type: level === "error" ? "error" : ("notify" as const),
+        target: "tunnel",
+        message: url ? `${message} — ${url}` : message,
+      });
+    } catch {
+      // event log unavailable
+    }
+  }
+}

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

@@ -0,0 +1,94 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import { EventEmitter } from "node:events";
+import type { ChildProcess } from "node:child_process";
+import { NgrokService, _setSpawnForTesting } from "./ngrok.ts";
+
+function makeChild(hooks: {
+  onReady?: (stdout: EventEmitter, stderr: EventEmitter, proc: EventEmitter) => 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 = 9001;
+  proc.killed = false;
+  proc.kill = () => {
+    proc.killed = true;
+    queueMicrotask(() => proc.emit("close", 0));
+    return true;
+  };
+  queueMicrotask(() => hooks.onReady?.(stdout, stderr, proc));
+  return proc as ChildProcess;
+}
+
+describe("NgrokService", () => {
+  let restore: () => void = () => {};
+
+  afterEach(() => {
+    restore();
+    restore = () => {};
+  });
+
+  it("parses public URL from JSON log line on stdout", async () => {
+    const mockSpawn = (_cmd: string, args: string[]) => {
+      if (args[0] === "version") {
+        return makeChild({
+          onReady: (_out, _err, proc) => proc.emit("close", 0),
+        });
+      }
+      if (args[0] === "http") {
+        return makeChild({
+          onReady: (stdout) => {
+            const line = `${JSON.stringify({
+              msg: "started tunnel",
+              url: "https://abc-123.ngrok-free.app",
+            })}\n`;
+            stdout.emit("data", Buffer.from(line, "utf8"));
+          },
+        });
+      }
+      return makeChild({ onReady: (_o, _e, proc) => proc.emit("close", 0) });
+    };
+    restore = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new NgrokService({ port: 5555, startupTimeoutMs: 5000 });
+    const tunnel = await svc.start();
+    expect(tunnel.publicUrl).toBe("https://abc-123.ngrok-free.app");
+    await svc.stop();
+  });
+
+  it("rejects when ngrok binary is not found", async () => {
+    const mockSpawn = (_cmd: string, args: string[]) => {
+      if (args[0] === "version") {
+        return makeChild({
+          onReady: (_o, _e, proc) => proc.emit("close", 1),
+        });
+      }
+      return makeChild({ onReady: (_o, _e, proc) => proc.emit("close", 0) });
+    };
+    restore = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new NgrokService({ port: 5555 });
+    await expect(svc.start()).rejects.toThrow(/ngrok binary not found/);
+  });
+
+  it("rejects on startup timeout when no tunnel URL appears", async () => {
+    const mockSpawn = (cmd: string, args: string[]) => {
+      if (args[0] === "version") {
+        return makeChild({
+          onReady: (_o, _e, proc) => proc.emit("close", 0),
+        });
+      }
+      return makeChild({
+        onReady: () => {
+          /* no stdout */
+        },
+      });
+    };
+    restore = _setSpawnForTesting(mockSpawn as typeof import("node:child_process").spawn);
+
+    const svc = new NgrokService({ port: 5555, startupTimeoutMs: 40 });
+    await expect(svc.start()).rejects.toThrow(/Ngrok startup timeout/);
+  });
+});