tmux-ide 1.2.1 → 2.0.0

package/src/lib/hq/client.test.ts

@@ -0,0 +1,154 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { HQClient } from "./client.ts";
+
+// Capture fetch calls
+let fetchCalls: { url: string; init: RequestInit }[] = [];
+let fetchResponses: Array<{ ok: boolean; status: number; text: string }> = [];
+
+const originalFetch = globalThis.fetch;
+
+function mockFetch(url: string | URL | Request, init?: RequestInit): Promise<Response> {
+  const urlStr = typeof url === "string" ? url : url instanceof URL ? url.toString() : url.url;
+  fetchCalls.push({ url: urlStr, init: init ?? {} });
+  const next = fetchResponses.shift() ?? { ok: true, status: 200, text: "{}" };
+  return Promise.resolve(
+    new Response(next.text, {
+      status: next.status,
+      headers: { "Content-Type": "application/json" },
+    }),
+  );
+}
+
+describe("HQClient", () => {
+  let client: HQClient;
+
+  beforeEach(() => {
+    fetchCalls = [];
+    fetchResponses = [];
+    globalThis.fetch = mockFetch as typeof fetch;
+
+    client = new HQClient({
+      hqUrl: "https://hq.example.com",
+      secret: "mysecret",
+      machineName: "dev-box",
+      remoteUrl: "https://remote.example.com",
+      bearerToken: "bearer-token-123",
+      heartbeatInterval: 100, // fast for tests
+    });
+  });
+
+  afterEach(async () => {
+    await client.destroy();
+    globalThis.fetch = originalFetch;
+  });
+
+  describe("registration", () => {
+    it("sends POST to /api/hq/register with Basic Auth", async () => {
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' });
+      await client.register();
+
+      expect(fetchCalls.length).toBeGreaterThanOrEqual(1);
+      const reg = fetchCalls[0]!;
+      expect(reg.url).toBe("https://hq.example.com/api/hq/register");
+      expect(reg.init.method).toBe("POST");
+
+      const authHeader = (reg.init.headers as Record<string, string>)["Authorization"];
+      expect(authHeader).toStartWith("Basic ");
+      const decoded = Buffer.from(authHeader!.slice(6), "base64").toString();
+      expect(decoded).toBe("mysecret");
+    });
+
+    it("sends correct payload with id, name, url, token", async () => {
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' });
+      await client.register();
+
+      const body = JSON.parse(fetchCalls[0]!.init.body as string);
+      expect(body.name).toBe("dev-box");
+      expect(body.url).toBe("https://remote.example.com");
+      expect(body.token).toBe("bearer-token-123");
+      expect(body.id).toBeTruthy();
+    });
+
+    it("throws on registration failure", async () => {
+      fetchResponses.push({ ok: false, status: 401, text: "Unauthorized" });
+      await expect(client.register()).rejects.toThrow("Registration failed (401)");
+    });
+  });
+
+  describe("heartbeat", () => {
+    it("fires heartbeat after registration", async () => {
+      // Registration + at least 1 heartbeat
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' });
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' });
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' });
+
+      await client.register();
+
+      // Wait for heartbeat interval to fire
+      await new Promise((r) => setTimeout(r, 250));
+
+      // At least 1 registration + 1 heartbeat
+      expect(fetchCalls.length).toBeGreaterThanOrEqual(2);
+
+      // All calls go to /api/hq/register
+      for (const call of fetchCalls) {
+        expect(call.url).toBe("https://hq.example.com/api/hq/register");
+      }
+    });
+  });
+
+  describe("backoff on failure", () => {
+    it("increases backoff when heartbeat fails", async () => {
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' }); // register OK
+      fetchResponses.push({ ok: false, status: 500, text: "Server Error" }); // heartbeat fail
+      fetchResponses.push({ ok: false, status: 500, text: "Server Error" }); // heartbeat fail
+
+      await client.register();
+      await new Promise((r) => setTimeout(r, 250));
+
+      // Client should still be alive (backoff doesn't crash)
+      expect(client.getRemoteId()).toBeTruthy();
+    });
+  });
+
+  describe("deregister on shutdown", () => {
+    it("sends DELETE on destroy", async () => {
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' }); // register
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' }); // deregister DELETE
+
+      await client.register();
+      await client.destroy();
+
+      const deleteCalls = fetchCalls.filter((c) => c.init.method === "DELETE");
+      expect(deleteCalls.length).toBe(1);
+      expect(deleteCalls[0]!.url).toContain("/api/hq/machines/");
+      expect(deleteCalls[0]!.url).toContain(client.getRemoteId());
+    });
+
+    it("does not throw if deregister fails", async () => {
+      fetchResponses.push({ ok: true, status: 200, text: '{"ok":true}' }); // register
+      // No response for DELETE — will fail
+
+      await client.register();
+      // Should not throw
+      await client.destroy();
+    });
+  });
+
+  describe("accessors", () => {
+    it("returns remote ID", () => {
+      expect(client.getRemoteId()).toMatch(
+        /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/,
+      );
+    });
+
+    it("returns bearer token", () => {
+      expect(client.getToken()).toBe("bearer-token-123");
+    });
+
+    it("returns machine name", () => {
+      expect(client.getName()).toBe("dev-box");
+    });
+  });
+});

package/src/lib/hq/client.ts

@@ -0,0 +1,142 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import * as crypto from "node:crypto";
+import { logger } from "../log.ts";
+import type { RegistrationPayload } from "./types.ts";
+
+const LOG = "hq-client";
+
+export interface HQClientConfig {
+  hqUrl: string;
+  secret: string;
+  machineName: string;
+  remoteUrl: string;
+  bearerToken?: string;
+  heartbeatInterval?: number;
+}
+
+export class HQClient {
+  private readonly hqUrl: string;
+  private readonly remoteId: string;
+  private readonly machineName: string;
+  private readonly secret: string;
+  private readonly remoteUrl: string;
+  private readonly bearerToken: string;
+  private readonly heartbeatInterval: number;
+  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private backoffMs = 1000;
+  private destroyed = false;
+
+  constructor(config: HQClientConfig) {
+    this.hqUrl = config.hqUrl;
+    this.remoteId = crypto.randomUUID();
+    this.machineName = config.machineName;
+    this.secret = config.secret;
+    this.remoteUrl = config.remoteUrl;
+    this.bearerToken = config.bearerToken ?? crypto.randomBytes(32).toString("hex");
+    this.heartbeatInterval = config.heartbeatInterval ?? 15_000;
+
+    logger.debug(LOG, "HQ client initialized", {
+      hqUrl: this.hqUrl,
+      machineName: this.machineName,
+      remoteId: this.remoteId,
+    });
+  }
+
+  private basicAuth(): string {
+    return `Basic ${Buffer.from(this.secret).toString("base64")}`;
+  }
+
+  async register(): Promise<void> {
+    logger.info(LOG, `Registering with HQ at ${this.hqUrl}`);
+
+    const payload: RegistrationPayload = {
+      id: this.remoteId,
+      name: this.machineName,
+      url: this.remoteUrl,
+      token: this.bearerToken,
+    };
+
+    const response = await fetch(`${this.hqUrl}/api/hq/register`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: this.basicAuth(),
+      },
+      body: JSON.stringify(payload),
+    });
+
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Registration failed (${response.status}): ${text}`);
+    }
+
+    logger.info(LOG, `Registered: ${this.machineName} (${this.remoteId})`);
+    this.backoffMs = 1000;
+    this.startHeartbeat();
+  }
+
+  private startHeartbeat(): void {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = setInterval(() => void this.sendHeartbeat(), this.heartbeatInterval);
+  }
+
+  private async sendHeartbeat(): Promise<void> {
+    if (this.destroyed) return;
+    try {
+      const res = await fetch(`${this.hqUrl}/api/hq/register`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: this.basicAuth(),
+        },
+        body: JSON.stringify({
+          id: this.remoteId,
+          name: this.machineName,
+          url: this.remoteUrl,
+          token: this.bearerToken,
+        }),
+      });
+      if (res.ok) {
+        this.backoffMs = 1000;
+        logger.debug(LOG, "Heartbeat OK");
+      } else {
+        throw new Error(`HTTP ${res.status}`);
+      }
+    } catch (err) {
+      logger.warn(LOG, `Heartbeat failed, backoff ${this.backoffMs}ms`, {
+        error: String(err),
+      });
+      this.backoffMs = Math.min(this.backoffMs * 2, 60_000);
+    }
+  }
+
+  async destroy(): Promise<void> {
+    this.destroyed = true;
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+
+    logger.info(LOG, `Deregistering from HQ: ${this.machineName} (${this.remoteId})`);
+    try {
+      await fetch(`${this.hqUrl}/api/hq/machines/${this.remoteId}`, {
+        method: "DELETE",
+        headers: { Authorization: this.basicAuth() },
+      });
+    } catch {
+      // Best-effort during shutdown
+    }
+  }
+
+  getRemoteId(): string {
+    return this.remoteId;
+  }
+
+  getToken(): string {
+    return this.bearerToken;
+  }
+
+  getName(): string {
+    return this.machineName;
+  }
+}

package/src/lib/hq/mdns.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, afterEach } from "bun:test";
+import { MDNSService } from "./mdns.ts";
+
+describe("MDNSService", () => {
+  let svc: MDNSService;
+
+  afterEach(async () => {
+    if (svc) await svc.stopAdvertising();
+  });
+
+  it("starts inactive", () => {
+    svc = new MDNSService();
+    expect(svc.isActive()).toBe(false);
+  });
+
+  it("stopAdvertising is a no-op when not active", async () => {
+    svc = new MDNSService();
+    await svc.stopAdvertising(); // should not throw
+    expect(svc.isActive()).toBe(false);
+  });
+
+  if (process.platform === "darwin") {
+    it("advertises via dns-sd on macOS", async () => {
+      svc = new MDNSService();
+      await svc.startAdvertising(19876, "test-tmux-ide");
+      expect(svc.isActive()).toBe(true);
+
+      await svc.stopAdvertising();
+      expect(svc.isActive()).toBe(false);
+    });
+
+    it("skips duplicate startAdvertising", async () => {
+      svc = new MDNSService();
+      await svc.startAdvertising(19877, "dup-test");
+      await svc.startAdvertising(19877, "dup-test"); // should warn but not throw
+      expect(svc.isActive()).toBe(true);
+    });
+
+    it("advertises _tmux-ide._tcp service type", async () => {
+      // The service type is hardcoded in the module. We just verify the
+      // service starts successfully (dns-sd logs the type on stdout).
+      svc = new MDNSService();
+      await svc.startAdvertising(19878);
+      expect(svc.isActive()).toBe(true);
+    });
+  } else {
+    it("skips advertisement on non-macOS", async () => {
+      svc = new MDNSService();
+      await svc.startAdvertising(19876, "test");
+      // On non-macOS the service doesn't actually start dns-sd
+      expect(svc.isActive()).toBe(false);
+    });
+  }
+});

package/src/lib/hq/mdns.ts

@@ -0,0 +1,88 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { spawn, type ChildProcess } from "node:child_process";
+import { hostname } from "node:os";
+import { logger } from "../log.ts";
+
+const LOG = "mdns";
+const SERVICE_TYPE = "_tmux-ide._tcp";
+
+export class MDNSService {
+  private dnsSdProcess: ChildProcess | null = null;
+  private advertising = false;
+
+  async startAdvertising(port: number, instanceName?: string): Promise<void> {
+    if (this.advertising) {
+      logger.warn(LOG, "mDNS already advertising");
+      return;
+    }
+
+    const name = instanceName ?? hostname() ?? "tmux-ide";
+
+    if (process.platform === "darwin") {
+      await this.startDnsSd(name, port);
+    } else {
+      logger.info(LOG, "mDNS advertisement skipped (not macOS)");
+    }
+  }
+
+  async stopAdvertising(): Promise<void> {
+    if (!this.advertising) return;
+
+    if (this.dnsSdProcess) {
+      await new Promise<void>((resolve) => {
+        const proc = this.dnsSdProcess!;
+        this.dnsSdProcess = null;
+        proc.once("exit", () => resolve());
+        proc.kill();
+        setTimeout(resolve, 1000);
+      });
+    }
+
+    this.advertising = false;
+    logger.info(LOG, "Stopped mDNS advertisement");
+  }
+
+  isActive(): boolean {
+    return this.advertising;
+  }
+
+  private async startDnsSd(name: string, port: number): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        const proc = spawn("dns-sd", ["-R", name, SERVICE_TYPE, "local.", String(port)], {
+          stdio: ["ignore", "pipe", "pipe"],
+        });
+
+        proc.on("error", (err) => {
+          logger.warn(LOG, `dns-sd error: ${err.message}`);
+          if (!this.advertising) reject(err);
+        });
+
+        proc.stdout?.on("data", (data: Buffer) => {
+          const msg = data.toString().trim();
+          if (msg) logger.debug(LOG, `dns-sd: ${msg}`);
+        });
+
+        proc.stderr?.on("data", (data: Buffer) => {
+          const msg = data.toString().trim();
+          if (msg) logger.warn(LOG, `dns-sd stderr: ${msg}`);
+        });
+
+        proc.on("close", () => {
+          this.advertising = false;
+        });
+
+        this.dnsSdProcess = proc;
+        this.advertising = true;
+        logger.info(LOG, `mDNS advertising: ${name} on port ${port} (${SERVICE_TYPE})`);
+
+        // dns-sd stays running, resolve immediately
+        resolve();
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+}
+
+export const mdnsService = new MDNSService();

package/src/lib/hq/registry.test.ts

@@ -0,0 +1,237 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import { RemoteRegistry } from "./registry.ts";
+
+// Mock fetch for health checks (always succeed in tests to avoid pruning)
+const originalFetch = globalThis.fetch;
+
+describe("RemoteRegistry", () => {
+  let registry: RemoteRegistry;
+  let shuttingDown = false;
+
+  beforeEach(() => {
+    shuttingDown = false;
+    // Mock fetch so health checks succeed
+    globalThis.fetch = (() =>
+      Promise.resolve(new Response('{"ok":true}', { status: 200 }))) as typeof fetch;
+
+    registry = new RemoteRegistry({
+      healthInterval: 60_000, // long interval so health checks don't interfere
+      healthTimeout: 1000,
+      isShuttingDown: () => shuttingDown,
+    });
+  });
+
+  afterEach(() => {
+    registry.destroy();
+    globalThis.fetch = originalFetch;
+  });
+
+  describe("register", () => {
+    it("registers a machine and it appears in list", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://dev.example.com",
+        token: "tok-1",
+      });
+
+      const machines = registry.getMachines();
+      expect(machines.length).toBe(1);
+      expect(machines[0]!.name).toBe("dev-box");
+      expect(machines[0]!.url).toBe("https://dev.example.com");
+    });
+
+    it("sets registeredAt and lastHeartbeat to now", () => {
+      const before = Date.now();
+      const m = registry.register({
+        id: "m2",
+        name: "prod-1",
+        url: "https://prod.example.com",
+        token: "tok-2",
+      });
+      const after = Date.now();
+
+      expect(m.registeredAt.getTime()).toBeGreaterThanOrEqual(before);
+      expect(m.registeredAt.getTime()).toBeLessThanOrEqual(after);
+      expect(m.lastHeartbeat.getTime()).toBeGreaterThanOrEqual(before);
+    });
+
+    it("initializes sessionIds as empty set", () => {
+      const m = registry.register({
+        id: "m3",
+        name: "staging",
+        url: "https://staging.example.com",
+        token: "tok-3",
+      });
+      expect(m.sessionIds.size).toBe(0);
+    });
+  });
+
+  describe("duplicate registration updates", () => {
+    it("re-registration with same ID updates fields", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://old.example.com",
+        token: "tok-old",
+      });
+
+      const updated = registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://new.example.com",
+        token: "tok-new",
+      });
+
+      expect(registry.getMachines().length).toBe(1);
+      expect(updated.url).toBe("https://new.example.com");
+      expect(updated.token).toBe("tok-new");
+    });
+
+    it("rejects different ID with same name", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://one.example.com",
+        token: "tok-1",
+      });
+
+      expect(() =>
+        registry.register({
+          id: "m2",
+          name: "dev-box",
+          url: "https://two.example.com",
+          token: "tok-2",
+        }),
+      ).toThrow("already registered");
+    });
+  });
+
+  describe("unregister", () => {
+    it("removes machine from list", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://dev.example.com",
+        token: "tok-1",
+      });
+      expect(registry.getMachines().length).toBe(1);
+
+      const result = registry.unregister("m1");
+      expect(result).toBe(true);
+      expect(registry.getMachines().length).toBe(0);
+    });
+
+    it("returns false for unknown ID", () => {
+      expect(registry.unregister("nonexistent")).toBe(false);
+    });
+  });
+
+  describe("session-to-remote mapping", () => {
+    it("maps sessions to machines", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://dev.example.com",
+        token: "tok-1",
+      });
+
+      registry.updateSessions("m1", ["sess-a", "sess-b"]);
+
+      const found = registry.getMachineBySession("sess-a");
+      expect(found).toBeDefined();
+      expect(found!.id).toBe("m1");
+
+      const foundB = registry.getMachineBySession("sess-b");
+      expect(foundB).toBeDefined();
+      expect(foundB!.id).toBe("m1");
+    });
+
+    it("returns undefined for unmapped session", () => {
+      expect(registry.getMachineBySession("unknown")).toBeUndefined();
+    });
+
+    it("cleans up session mappings on unregister", () => {
+      registry.register({
+        id: "m1",
+        name: "dev-box",
+        url: "https://dev.example.com",
+        token: "tok-1",
+      });
+      registry.updateSessions("m1", ["sess-a"]);
+      expect(registry.getMachineBySession("sess-a")).toBeDefined();
+
+      registry.unregister("m1");
+      expect(registry.getMachineBySession("sess-a")).toBeUndefined();
+    });
+  });
+
+  describe("health check failure prunes", () => {
+    it("removes machine when health check fails", async () => {
+      // Make health check fail
+      globalThis.fetch = (() =>
+        Promise.resolve(new Response("Server Error", { status: 500 }))) as typeof fetch;
+
+      // Use short health interval
+      registry.destroy();
+      registry = new RemoteRegistry({
+        healthInterval: 50,
+        healthTimeout: 50,
+        isShuttingDown: () => shuttingDown,
+      });
+
+      registry.register({
+        id: "m1",
+        name: "unhealthy",
+        url: "https://dead.example.com",
+        token: "tok-1",
+      });
+
+      // Wait for health check to fire and prune
+      await new Promise((r) => setTimeout(r, 200));
+
+      expect(registry.getMachines().length).toBe(0);
+    });
+
+    it("does not prune during shutdown", async () => {
+      globalThis.fetch = (() =>
+        Promise.resolve(new Response("Server Error", { status: 500 }))) as typeof fetch;
+
+      registry.destroy();
+      registry = new RemoteRegistry({
+        healthInterval: 50,
+        healthTimeout: 50,
+        isShuttingDown: () => shuttingDown,
+      });
+
+      registry.register({
+        id: "m1",
+        name: "box",
+        url: "https://box.example.com",
+        token: "tok-1",
+      });
+
+      shuttingDown = true;
+      await new Promise((r) => setTimeout(r, 200));
+
+      // Should still be registered because shutdown flag prevents pruning
+      expect(registry.getMachines().length).toBe(1);
+    });
+  });
+
+  describe("getMachine", () => {
+    it("returns machine by ID", () => {
+      registry.register({
+        id: "m1",
+        name: "dev",
+        url: "https://dev.example.com",
+        token: "tok",
+      });
+
+      expect(registry.getMachine("m1")).toBeDefined();
+      expect(registry.getMachine("m1")!.name).toBe("dev");
+      expect(registry.getMachine("unknown")).toBeUndefined();
+    });
+  });
+});