tmux-ide 1.2.1 → 2.0.0

package/src/lib/hq/registry.ts

@@ -0,0 +1,145 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { logger } from "../log.ts";
+import type { RemoteMachine } from "./types.ts";
+
+const LOG = "remote-registry";
+
+export class RemoteRegistry {
+  private machines = new Map<string, RemoteMachine>();
+  private machinesByName = new Map<string, RemoteMachine>();
+  private sessionToMachine = new Map<string, string>();
+  private healthCheckTimer: ReturnType<typeof setInterval> | null = null;
+  private readonly healthInterval: number;
+  private readonly healthTimeout: number;
+  private isShuttingDown: () => boolean;
+
+  constructor(opts?: {
+    healthInterval?: number;
+    healthTimeout?: number;
+    isShuttingDown?: () => boolean;
+  }) {
+    this.healthInterval = opts?.healthInterval ?? 15_000;
+    this.healthTimeout = opts?.healthTimeout ?? 5_000;
+    this.isShuttingDown = opts?.isShuttingDown ?? (() => false);
+    this.startHealthChecker();
+  }
+
+  register(
+    remote: Omit<RemoteMachine, "registeredAt" | "lastHeartbeat" | "sessionIds">,
+  ): RemoteMachine {
+    // If same ID already registered, update it (heartbeat / re-registration)
+    const existing = this.machines.get(remote.id);
+    if (existing) {
+      existing.name = remote.name;
+      existing.url = remote.url;
+      existing.token = remote.token;
+      existing.lastHeartbeat = new Date();
+      this.machinesByName.set(remote.name, existing);
+      logger.debug(LOG, `Machine re-registered: ${remote.name} (${remote.id})`);
+      return existing;
+    }
+
+    // Block duplicate names (different ID)
+    if (this.machinesByName.has(remote.name)) {
+      throw new Error(`Machine with name '${remote.name}' is already registered`);
+    }
+
+    const now = new Date();
+    const machine: RemoteMachine = {
+      ...remote,
+      registeredAt: now,
+      lastHeartbeat: now,
+      sessionIds: new Set(),
+    };
+
+    this.machines.set(remote.id, machine);
+    this.machinesByName.set(remote.name, machine);
+    logger.info(LOG, `Machine registered: ${remote.name} (${remote.id}) from ${remote.url}`);
+
+    void this.checkMachineHealth(machine);
+    return machine;
+  }
+
+  unregister(id: string): boolean {
+    const machine = this.machines.get(id);
+    if (!machine) return false;
+
+    for (const sid of machine.sessionIds) {
+      this.sessionToMachine.delete(sid);
+    }
+    this.machinesByName.delete(machine.name);
+    this.machines.delete(id);
+    logger.info(LOG, `Machine unregistered: ${machine.name} (${id})`);
+    return true;
+  }
+
+  getMachine(id: string): RemoteMachine | undefined {
+    return this.machines.get(id);
+  }
+
+  getMachines(): RemoteMachine[] {
+    return Array.from(this.machines.values());
+  }
+
+  getMachineBySession(sessionId: string): RemoteMachine | undefined {
+    const mid = this.sessionToMachine.get(sessionId);
+    return mid ? this.machines.get(mid) : undefined;
+  }
+
+  updateSessions(machineId: string, sessionIds: string[]): void {
+    const machine = this.machines.get(machineId);
+    if (!machine) return;
+
+    for (const old of machine.sessionIds) {
+      this.sessionToMachine.delete(old);
+    }
+    machine.sessionIds = new Set(sessionIds);
+    for (const sid of sessionIds) {
+      this.sessionToMachine.set(sid, machineId);
+    }
+  }
+
+  private async checkMachineHealth(machine: RemoteMachine): Promise<void> {
+    if (this.isShuttingDown()) return;
+
+    try {
+      const controller = new AbortController();
+      const tid = setTimeout(() => controller.abort(), this.healthTimeout);
+
+      const res = await fetch(`${machine.url}/health`, {
+        headers: { Authorization: `Bearer ${machine.token}` },
+        signal: controller.signal,
+      });
+
+      clearTimeout(tid);
+      if (res.ok) {
+        machine.lastHeartbeat = new Date();
+        logger.debug(LOG, `Health OK: ${machine.name}`);
+      } else {
+        throw new Error(`HTTP ${res.status}`);
+      }
+    } catch (err) {
+      if (this.isShuttingDown()) return;
+      logger.warn(LOG, `Health check failed, pruning: ${machine.name} (${machine.id})`, {
+        error: String(err),
+      });
+      this.unregister(machine.id);
+    }
+  }
+
+  private startHealthChecker(): void {
+    this.healthCheckTimer = setInterval(() => {
+      if (this.isShuttingDown()) return;
+      const checks = this.getMachines().map((m) => this.checkMachineHealth(m));
+      Promise.all(checks).catch(() => {});
+    }, this.healthInterval);
+  }
+
+  destroy(): void {
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
+    logger.info(LOG, "Registry destroyed");
+  }
+}

package/src/lib/hq/types.ts

@@ -0,0 +1,44 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+import { z } from "zod";
+
+export interface RemoteMachine {
+  id: string;
+  name: string;
+  url: string;
+  token: string;
+  registeredAt: Date;
+  lastHeartbeat: Date;
+  sessionIds: Set<string>;
+}
+
+export interface HQConfig {
+  enabled: boolean;
+  role: "hq" | "remote";
+  hq_url?: string;
+  secret?: string;
+  heartbeat_interval?: number;
+  machine_name?: string;
+}
+
+export interface RegistrationPayload {
+  id: string;
+  name: string;
+  url: string;
+  token: string;
+}
+
+export const RegistrationPayloadSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  url: z.string().url(),
+  token: z.string().min(1),
+});
+
+export const HQConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  role: z.enum(["hq", "remote"]),
+  hq_url: z.string().url().optional(),
+  secret: z.string().optional(),
+  heartbeat_interval: z.number().min(1000).default(15000),
+  machine_name: z.string().optional(),
+});

package/src/lib/ipc/socket-protocol.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect } from "bun:test";
+import { Buffer } from "node:buffer";
+import {
+  MessageType,
+  frameMessage,
+  MessageParser,
+  MessageBuilder,
+  parsePayload,
+} from "./socket-protocol.ts";
+
+describe("socket-protocol", () => {
+  it("frameMessage round-trips through MessageParser for each JSON-backed type", () => {
+    const samples: { type: MessageType; payload: Buffer | string | object }[] = [
+      { type: MessageType.CONTROL_CMD, payload: { cmd: "resize", cols: 80, rows: 24 } },
+      { type: MessageType.STATUS_UPDATE, payload: { app: "vt", status: "ok" } },
+      { type: MessageType.ERROR, payload: { code: "E1", message: "m" } },
+      { type: MessageType.STATUS_REQUEST, payload: {} },
+      {
+        type: MessageType.STATUS_RESPONSE,
+        payload: { running: true, port: 4000 },
+      },
+      {
+        type: MessageType.GIT_FOLLOW_REQUEST,
+        payload: { enable: true },
+      },
+      {
+        type: MessageType.GIT_FOLLOW_RESPONSE,
+        payload: { success: true },
+      },
+      {
+        type: MessageType.GIT_EVENT_NOTIFY,
+        payload: { repoPath: "/r", type: "commit" },
+      },
+      { type: MessageType.GIT_EVENT_ACK, payload: { handled: true } },
+    ];
+
+    for (const { type, payload } of samples) {
+      const framed = frameMessage(type, payload);
+      const p = new MessageParser();
+      p.addData(framed);
+      const msgs = [...p.parseMessages()];
+      expect(msgs.length).toBe(1);
+      expect(msgs[0]!.type).toBe(type);
+      const decoded = JSON.parse(msgs[0]!.payload.toString("utf8")) as object;
+      expect(decoded).toEqual(payload as object);
+    }
+  });
+
+  it("frameMessage supports raw Buffer and string payloads", () => {
+    const buf = frameMessage(MessageType.STDIN_DATA, Buffer.from([0, 1, 2]));
+    const p = new MessageParser();
+    p.addData(buf);
+    const [m] = [...p.parseMessages()];
+    expect(m!.type).toBe(MessageType.STDIN_DATA);
+    expect(Buffer.from(m!.payload).equals(Buffer.from([0, 1, 2]))).toBe(true);
+  });
+
+  it("MessageParser handles fragmented input across chunks", () => {
+    const msg = MessageBuilder.resize(100, 50);
+    const a = msg.subarray(0, 3);
+    const b = msg.subarray(3);
+    const p = new MessageParser();
+    p.addData(a);
+    expect([...p.parseMessages()].length).toBe(0);
+    expect(p.pendingBytes).toBe(3);
+    p.addData(b);
+    const out = [...p.parseMessages()];
+    expect(out.length).toBe(1);
+    expect(out[0]!.type).toBe(MessageType.CONTROL_CMD);
+    expect(p.pendingBytes).toBe(0);
+  });
+
+  it("MessageParser yields multiple messages in one chunk", () => {
+    const m1 = MessageBuilder.heartbeat();
+    const m2 = MessageBuilder.stdin("hi");
+    const p = new MessageParser();
+    p.addData(Buffer.concat([m1, m2]));
+    const out = [...p.parseMessages()];
+    expect(out.length).toBe(2);
+    expect(out[0]!.type).toBe(MessageType.HEARTBEAT);
+    expect(out[1]!.type).toBe(MessageType.STDIN_DATA);
+    expect(out[1]!.payload.toString("utf8")).toBe("hi");
+  });
+
+  it("MessageParser waits when payload length exceeds available bytes", () => {
+    const framed = frameMessage(MessageType.HEARTBEAT, Buffer.alloc(0));
+    const partial = framed.subarray(0, framed.length - 1);
+    const p = new MessageParser();
+    p.addData(partial);
+    expect([...p.parseMessages()].length).toBe(0);
+    expect(p.pendingBytes).toBe(partial.length);
+  });
+
+  it("clear resets pending buffer", () => {
+    const p = new MessageParser();
+    p.addData(Buffer.from([1, 2, 3]));
+    p.clear();
+    expect(p.pendingBytes).toBe(0);
+  });
+
+  it("parsePayload maps types correctly", () => {
+    expect(parsePayload(MessageType.STDIN_DATA, Buffer.from("abc", "utf8"))).toBe("abc");
+    expect(parsePayload(MessageType.HEARTBEAT, Buffer.alloc(0))).toBeNull();
+    const ctrl = Buffer.from(JSON.stringify({ cmd: "resize", cols: 1, rows: 2 }), "utf8");
+    expect(parsePayload(MessageType.CONTROL_CMD, ctrl)).toEqual({
+      cmd: "resize",
+      cols: 1,
+      rows: 2,
+    });
+  });
+
+  it("parsePayload throws on invalid JSON for JSON message types", () => {
+    expect(() => parsePayload(MessageType.ERROR, Buffer.from("not-json", "utf8"))).toThrow(
+      /Failed to parse JSON payload/,
+    );
+  });
+
+  it("MessageBuilder helpers produce decodable frames", () => {
+    const parser = new MessageParser();
+    parser.addData(MessageBuilder.statusRequest());
+    parser.addData(MessageBuilder.statusResponse({ running: false }));
+    const [a, b] = [...parser.parseMessages()];
+    expect(parsePayload(a!.type, a!.payload)).toEqual({});
+    expect(parsePayload(b!.type, b!.payload)).toEqual({ running: false });
+  });
+});

package/src/lib/ipc/socket-protocol.ts

@@ -0,0 +1,324 @@
+// Based on VibeTunnel (MIT) — github.com/amantus-ai/vibetunnel
+
+/**
+ * Unix socket protocol for VibeTunnel IPC
+ *
+ * Message format (binary):
+ * [1 byte: message type]
+ * [4 bytes: payload length (big-endian)]
+ * [N bytes: payload]
+ */
+
+import { Buffer } from "node:buffer";
+
+/**
+ * Message types for the socket protocol
+ */
+export enum MessageType {
+  STDIN_DATA = 0x01, // Raw stdin data (keyboard input)
+  CONTROL_CMD = 0x02, // Control commands (resize, kill, etc)
+  STATUS_UPDATE = 0x03, // Legacy status updates (ignored)
+  HEARTBEAT = 0x04, // Keep-alive ping/pong
+  ERROR = 0x05, // Error messages
+  // Reserved for future use
+  STDOUT_SUBSCRIBE = 0x10,
+  METRICS = 0x11,
+  // Status operations
+  STATUS_REQUEST = 0x20, // Request server status
+  STATUS_RESPONSE = 0x21, // Server status response
+  // Git operations
+  GIT_FOLLOW_REQUEST = 0x30, // Enable/disable Git follow mode
+  GIT_FOLLOW_RESPONSE = 0x31, // Response to follow request
+  GIT_EVENT_NOTIFY = 0x32, // Git event notification
+  GIT_EVENT_ACK = 0x33, // Git event acknowledgment
+}
+
+/**
+ * Control command types
+ */
+export interface ControlCommand {
+  cmd: string;
+  [key: string]: unknown;
+}
+
+export interface ResizeCommand extends ControlCommand {
+  cmd: "resize";
+  cols: number;
+  rows: number;
+}
+
+export interface KillCommand extends ControlCommand {
+  cmd: "kill";
+  signal?: string | number;
+}
+
+export interface ResetSizeCommand extends ControlCommand {
+  cmd: "reset-size";
+}
+
+export interface UpdateTitleCommand extends ControlCommand {
+  cmd: "update-title";
+  title: string;
+}
+
+/**
+ * Status update payload
+ */
+export interface StatusUpdate {
+  app: string;
+  status: string;
+  timestamp?: number;
+  [key: string]: unknown;
+}
+
+/**
+ * Error message payload
+ */
+export interface ErrorMessage {
+  code: string;
+  message: string;
+  details?: unknown;
+}
+
+/**
+ * Server status request (empty payload)
+ */
+export type StatusRequest = Record<string, never>;
+
+/**
+ * Server status response
+ */
+export interface StatusResponse {
+  running: boolean;
+  port?: number;
+  url?: string;
+  version?: string;
+  buildDate?: string;
+  followMode?: {
+    enabled: boolean;
+    branch?: string;
+    repoPath?: string;
+  };
+}
+
+/**
+ * Git follow mode request
+ */
+export interface GitFollowRequest {
+  repoPath?: string; // Main repo path (for backward compatibility)
+  branch?: string; // Optional - branch name (for backward compatibility)
+  enable: boolean;
+  mainRepoPath?: string; // The main repository path
+}
+
+/**
+ * Git follow mode response
+ */
+export interface GitFollowResponse {
+  success: boolean;
+  currentBranch?: string;
+  previousBranch?: string;
+  error?: string;
+}
+
+/**
+ * Git event notification
+ */
+export interface GitEventNotify {
+  repoPath: string;
+  type: "checkout" | "commit" | "merge" | "rebase" | "other";
+}
+
+/**
+ * Git event acknowledgment
+ */
+export interface GitEventAck {
+  handled: boolean;
+}
+
+/**
+ * Type-safe mapping of message types to their payload types
+ */
+export type MessagePayloadMap = {
+  [MessageType.STDIN_DATA]: string;
+  [MessageType.CONTROL_CMD]: ControlCommand;
+  [MessageType.STATUS_UPDATE]: StatusUpdate;
+  [MessageType.HEARTBEAT]: Record<string, never>;
+  [MessageType.ERROR]: ErrorMessage;
+  [MessageType.STATUS_REQUEST]: StatusRequest;
+  [MessageType.STATUS_RESPONSE]: StatusResponse;
+  [MessageType.GIT_FOLLOW_REQUEST]: GitFollowRequest;
+  [MessageType.GIT_FOLLOW_RESPONSE]: GitFollowResponse;
+  [MessageType.GIT_EVENT_NOTIFY]: GitEventNotify;
+  [MessageType.GIT_EVENT_ACK]: GitEventAck;
+};
+
+/**
+ * Get the payload type for a given message type
+ */
+export type MessagePayload<T extends MessageType> = T extends keyof MessagePayloadMap
+  ? MessagePayloadMap[T]
+  : never;
+
+/**
+ * Frame a message for transmission
+ */
+export function frameMessage(type: MessageType, payload: Buffer | string | object): Buffer {
+  const payloadBuffer = Buffer.isBuffer(payload)
+    ? payload
+    : Buffer.from(typeof payload === "string" ? payload : JSON.stringify(payload), "utf8");
+
+  const message = Buffer.allocUnsafe(5 + payloadBuffer.length);
+  message[0] = type;
+  message.writeUInt32BE(payloadBuffer.length, 1);
+  payloadBuffer.copy(message, 5);
+
+  return message;
+}
+
+/**
+ * Parse messages from a buffer
+ */
+export class MessageParser {
+  private buffer = Buffer.alloc(0);
+
+  /**
+   * Add data to the parser
+   */
+  addData(chunk: Buffer | Uint8Array | string): void {
+    const bufferChunk = Buffer.isBuffer(chunk)
+      ? chunk
+      : Buffer.from(typeof chunk === "string" ? chunk : chunk);
+    this.buffer = Buffer.concat([this.buffer, bufferChunk]);
+  }
+
+  /**
+   * Parse complete messages from the buffer
+   */
+  *parseMessages(): Generator<{ type: MessageType; payload: Buffer }> {
+    while (this.buffer.length >= 5) {
+      const messageType = this.buffer[0] as MessageType;
+      const payloadLength = this.buffer.readUInt32BE(1);
+
+      // Check if we have the complete message
+      if (this.buffer.length < 5 + payloadLength) {
+        break;
+      }
+
+      // Extract the message
+      const payload = this.buffer.subarray(5, 5 + payloadLength);
+      this.buffer = this.buffer.subarray(5 + payloadLength);
+
+      yield { type: messageType, payload };
+    }
+  }
+
+  /**
+   * Get the number of bytes waiting to be parsed
+   */
+  get pendingBytes(): number {
+    return this.buffer.length;
+  }
+
+  /**
+   * Clear the buffer
+   */
+  clear(): void {
+    this.buffer = Buffer.alloc(0);
+  }
+}
+
+/**
+ * High-level message creation helpers
+ */
+export const MessageBuilder = {
+  stdin(data: string): Buffer {
+    return frameMessage(MessageType.STDIN_DATA, data);
+  },
+
+  resize(cols: number, rows: number): Buffer {
+    return frameMessage(MessageType.CONTROL_CMD, { cmd: "resize", cols, rows });
+  },
+
+  kill(signal?: string | number): Buffer {
+    return frameMessage(MessageType.CONTROL_CMD, { cmd: "kill", signal });
+  },
+
+  resetSize(): Buffer {
+    return frameMessage(MessageType.CONTROL_CMD, { cmd: "reset-size" });
+  },
+
+  updateTitle(title: string): Buffer {
+    return frameMessage(MessageType.CONTROL_CMD, { cmd: "update-title", title });
+  },
+
+  status(app: string, status: string, extra?: Record<string, unknown>): Buffer {
+    return frameMessage(MessageType.STATUS_UPDATE, { app, status, ...extra });
+  },
+
+  heartbeat(): Buffer {
+    return frameMessage(MessageType.HEARTBEAT, Buffer.alloc(0));
+  },
+
+  error(code: string, message: string, details?: unknown): Buffer {
+    return frameMessage(MessageType.ERROR, { code, message, details });
+  },
+
+  gitFollowRequest(request: GitFollowRequest): Buffer {
+    return frameMessage(MessageType.GIT_FOLLOW_REQUEST, request);
+  },
+
+  gitFollowResponse(response: GitFollowResponse): Buffer {
+    return frameMessage(MessageType.GIT_FOLLOW_RESPONSE, response);
+  },
+
+  gitEventNotify(event: GitEventNotify): Buffer {
+    return frameMessage(MessageType.GIT_EVENT_NOTIFY, event);
+  },
+
+  gitEventAck(ack: GitEventAck): Buffer {
+    return frameMessage(MessageType.GIT_EVENT_ACK, ack);
+  },
+
+  statusRequest(): Buffer {
+    return frameMessage(MessageType.STATUS_REQUEST, {});
+  },
+
+  statusResponse(response: StatusResponse): Buffer {
+    return frameMessage(MessageType.STATUS_RESPONSE, response);
+  },
+} as const;
+
+/**
+ * Parse payload based on message type
+ */
+export function parsePayload(type: MessageType, payload: Buffer): unknown {
+  switch (type) {
+    case MessageType.STDIN_DATA:
+      return payload.toString("utf8");
+
+    case MessageType.CONTROL_CMD:
+    case MessageType.STATUS_UPDATE:
+    case MessageType.ERROR:
+    case MessageType.STATUS_REQUEST:
+    case MessageType.STATUS_RESPONSE:
+    case MessageType.GIT_FOLLOW_REQUEST:
+    case MessageType.GIT_FOLLOW_RESPONSE:
+    case MessageType.GIT_EVENT_NOTIFY:
+    case MessageType.GIT_EVENT_ACK:
+      try {
+        return JSON.parse(payload.toString("utf8"));
+      } catch (e) {
+        throw new Error(
+          `Failed to parse JSON payload for message type ${type}: ${e instanceof Error ? e.message : String(e)}`,
+          { cause: e },
+        );
+      }
+
+    case MessageType.HEARTBEAT:
+      return null;
+
+    default:
+      return payload;
+  }
+}