tmux-ide 2.1.4 → 2.6.0

package/src/lib/tunnels/cloudflare.ts

@@ -1,254 +0,0 @@
-// 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

@@ -1,63 +0,0 @@
-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

@@ -1,132 +0,0 @@
-// 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

@@ -1,94 +0,0 @@
-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/);
-  });
-});