tmux-ide 2.1.4 → 2.6.0

package/src/lib/github-pr.ts

@@ -1,182 +0,0 @@
-import { execFileSync } from "node:child_process";
-import type { Task, Mission } from "./task-store.ts";
-import type { ProofSchema } from "../types.ts";
-
-export interface PrResult {
-  url: string;
-  number: number;
-}
-
-/**
- * Check if the gh CLI is available.
- */
-export function isGhAvailable(): boolean {
-  try {
-    execFileSync("gh", ["--version"], {
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Create a GitHub PR for a completed task.
- * Returns the PR URL and number, or null if creation failed.
- */
-export function createTaskPr(task: Task, cwd: string, baseBranch?: string): PrResult | null {
-  // Determine the current branch
-  let headBranch: string;
-  try {
-    headBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-      cwd,
-      encoding: "utf-8",
-      stdio: ["ignore", "pipe", "ignore"],
-    }).trim();
-  } catch {
-    return null;
-  }
-
-  // Build PR body
-  const bodyParts: string[] = [];
-  if (task.description) bodyParts.push(task.description);
-  if (task.proof) {
-    bodyParts.push("");
-    bodyParts.push("## Proof");
-    const proof = task.proof as ProofSchema;
-    if (proof.notes) bodyParts.push(proof.notes);
-    if (proof.tests) bodyParts.push(`Tests: ${proof.tests.passed}/${proof.tests.total} passed`);
-    if (proof.ci)
-      bodyParts.push(`CI: ${proof.ci.status}${proof.ci.url ? ` (${proof.ci.url})` : ""}`);
-  }
-  if (task.tags.length > 0) {
-    bodyParts.push("");
-    bodyParts.push(`Tags: ${task.tags.join(", ")}`);
-  }
-
-  const title = `Task ${task.id}: ${task.title}`;
-  const body = bodyParts.join("\n") || task.title;
-
-  try {
-    // Push the branch first (gh pr create needs it on remote)
-    try {
-      execFileSync("git", ["push", "-u", "origin", headBranch], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch {
-      // Branch may already be pushed, or remote may not exist — continue anyway
-    }
-
-    // Create the PR
-    const output = execFileSync(
-      "gh",
-      [
-        "pr",
-        "create",
-        "--title",
-        title,
-        "--body",
-        body,
-        "--head",
-        headBranch,
-        ...(baseBranch ? ["--base", baseBranch] : []),
-      ],
-      {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-      },
-    ).trim();
-
-    // gh pr create outputs the PR URL
-    const url = output;
-    // Extract PR number from URL (e.g. https://github.com/owner/repo/pull/42)
-    const match = url.match(/\/pull\/(\d+)/);
-    const number = match ? parseInt(match[1]!, 10) : 0;
-
-    return { url, number };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Create a GitHub PR for a completed mission.
- * Uses mission.branch as head; if not set, uses current branch.
- */
-export function createMissionPr(
-  mission: Mission,
-  cwd: string,
-  baseBranch?: string,
-): PrResult | null {
-  let headBranch: string;
-  if (mission.branch) {
-    headBranch = mission.branch;
-  } else {
-    try {
-      headBranch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "ignore"],
-      }).trim();
-    } catch {
-      return null;
-    }
-  }
-
-  const milestonesSummary = mission.milestones
-    .sort((a, b) => a.order - b.order)
-    .map((m) => `- ${m.id}: ${m.title} [${m.status}]`)
-    .join("\n");
-
-  const title = `Mission: ${mission.title}`;
-  const bodyParts: string[] = [];
-  if (mission.description) bodyParts.push(mission.description);
-  bodyParts.push("");
-  bodyParts.push("## Milestones");
-  bodyParts.push(milestonesSummary || "No milestones");
-  const body = bodyParts.join("\n");
-
-  try {
-    try {
-      execFileSync("git", ["push", "-u", "origin", headBranch], {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-      });
-    } catch {
-      // Branch may already be pushed
-    }
-
-    const output = execFileSync(
-      "gh",
-      [
-        "pr",
-        "create",
-        "--title",
-        title,
-        "--body",
-        body,
-        "--head",
-        headBranch,
-        ...(baseBranch ? ["--base", baseBranch] : []),
-      ],
-      {
-        cwd,
-        encoding: "utf-8",
-        stdio: ["ignore", "pipe", "pipe"],
-      },
-    ).trim();
-
-    const url = output;
-    const match = url.match(/\/pull\/(\d+)/);
-    const number = match ? parseInt(match[1]!, 10) : 0;
-    return { url, number };
-  } catch {
-    return null;
-  }
-}

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

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

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

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

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