gitspace 0.2.0-rc.20 → 0.2.0-rc.21

package/src/lib/tmux-lite/relay-client.ts

@@ -1,506 +0,0 @@
-/**
- * Relay client - WebSocket connection from client to relay
- *
- * Handles:
- * - Connection to relay server
- * - X3DH handshake for mutual authentication and key exchange
- * - Reconnection with exponential backoff
- * - Sending/receiving encrypted frames
- */
-
-import { createHash } from "crypto";
-import {
-  createFrame,
-  openFrame,
-  MASTER_STREAM_ID,
-} from "./crypto";
-import {
-  createClientHello,
-  processServerHello,
-  createClientAuth,
-  processServerAuth,
-  type X3DHClientState,
-} from "./crypto/handshake.js";
-import type {
-  Identity,
-  SessionKeys,
-  AccessType,
-  X3DHResponseMessage,
-  X3DHAuthMessage,
-  X3DHResultMessage,
-} from "../../types/identity.js";
-import { signMessage, type SignatureBlock } from "../../relay/signing.js";
-
-/** Relay client configuration (identity/X3DH handshake) */
-export interface RelayClientConfig {
-  /** Relay WebSocket URL (e.g., wss://relay.example.com/ws) */
-  relayUrl: string;
-  /** Machine ID hint for relay routing */
-  machineId?: string;
-  /** Client's identity for authentication */
-  identity: Identity;
-  /** Invite token (if connecting via invite) */
-  inviteToken?: string;
-}
-
-/** Connection state */
-export type ConnectionState =
-  | "disconnected"
-  | "connecting"
-  | "handshaking"
-  | "connected"
-  | "reconnecting";
-
-/** Relay client events */
-export interface RelayClientEvents {
-  /** Called when connected to relay */
-  onConnect?: () => void;
-  /** Called when disconnected from relay */
-  onDisconnect?: (code: number, reason: string) => void;
-  /** Called when a message is received (already decrypted) */
-  onMessage?: (streamId: number, data: Buffer) => void;
-  /** Called on connection error */
-  onError?: (error: Error) => void;
-  /** Called when connection state changes */
-  onStateChange?: (state: ConnectionState) => void;
-  /** Called when handshake completes */
-  onHandshakeComplete?: (peerIdentityId: string, accessType: AccessType, sessionId?: string) => void;
-}
-
-/**
- * Relay client for identity-based connections
- *
- * Uses X3DH handshake with Ed25519/X25519 keys.
- */
-export class RelayClient {
-  private ws: WebSocket | null = null;
-  private config: RelayClientConfig;
-  private events: RelayClientEvents;
-  private state: ConnectionState = "disconnected";
-  private reconnectAttempts = 0;
-  private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
-  private readKey: Buffer | null = null;
-  private writeKey: Buffer | null = null;
-
-  // X3DH handshake state (identity mode)
-  private handshakeState: X3DHClientState | null = null;
-  private sessionKeys: SessionKeys | null = null;
-  private peerIdentityId: string | null = null;
-  private accessType: AccessType | null = null;
-  private sessionId: string | undefined = undefined;
-
-  /** Maximum reconnect attempts */
-  private readonly maxReconnectAttempts = 10;
-  /** Base reconnect delay in ms */
-  private readonly baseReconnectDelay = 1000;
-  /** Maximum reconnect delay in ms */
-  private readonly maxReconnectDelay = 30000;
-
-  /**
-   * Create a new relay client
-   *
-   * @param config - Client configuration
-   * @param events - Event handlers
-   */
-  constructor(config: RelayClientConfig, events: RelayClientEvents = {}) {
-    this.config = config;
-    this.events = events;
-  }
-
-  /** Get current connection state */
-  getState(): ConnectionState {
-    return this.state;
-  }
-
-  /** Check if connected */
-  isConnected(): boolean {
-    return this.state === "connected" && this.ws?.readyState === WebSocket.OPEN;
-  }
-
-  /** Get peer identity ID */
-  getPeerIdentityId(): string | null {
-    return this.peerIdentityId;
-  }
-
-  /** Get current access type */
-  getAccessType(): AccessType | null {
-    return this.accessType;
-  }
-
-  /** Get current session ID */
-  getSessionId(): string | undefined {
-    return this.sessionId;
-  }
-
-  /**
-   * Connect to the relay server
-   */
-  async connect(): Promise<void> {
-    if (this.state === "connecting" || this.state === "connected" || this.state === "handshaking") {
-      return;
-    }
-
-    this.setState("connecting");
-    this.doConnect();
-  }
-
-  /**
-   * Disconnect from the relay server
-   */
-  disconnect(): void {
-    this.cancelReconnect();
-    if (this.ws) {
-      this.ws.close(1000, "Client disconnect");
-      this.ws = null;
-    }
-    this.setState("disconnected");
-  }
-
-  /**
-   * Send data to all connected clients (via relay)
-   *
-   * @param data - Plaintext data to send (will be encrypted)
-   * @param streamId - Stream ID (default: master stream)
-   */
-  send(data: Buffer | Uint8Array, streamId = MASTER_STREAM_ID): boolean {
-    if (!this.isConnected() || !this.writeKey) {
-      return false;
-    }
-
-    try {
-      const frame = createFrame(streamId, data, this.writeKey);
-
-      // Relay mode: wrap encrypted frame in JSON data message
-      this.ws!.send(JSON.stringify({
-        type: "data",
-        data: Buffer.from(frame).toString("base64"),
-      }));
-      return true;
-    } catch (e) {
-      console.error("[relay-client] Send error:", e);
-      return false;
-    }
-  }
-
-  private setState(state: ConnectionState): void {
-    if (this.state !== state) {
-      this.state = state;
-      this.events.onStateChange?.(state);
-    }
-  }
-
-  private doConnect(): void {
-    const { relayUrl, machineId } = this.config;
-
-    // Build WebSocket URL
-    const url = new URL(relayUrl);
-    if (machineId) {
-      url.searchParams.set("m", machineId);
-    }
-    url.searchParams.set("role", "client");
-
-    try {
-      this.ws = new WebSocket(url.toString());
-      this.ws.binaryType = "arraybuffer";
-
-      this.ws.onopen = () => {
-        console.log("[relay-client] Connected to relay");
-        this.reconnectAttempts = 0;
-
-        // Need to send protocol message for routing
-        // Then wait for connection_established before starting handshake
-        if (this.config.inviteToken) {
-          // Client connecting via invite - send connect_with_invite
-          this.sendConnectWithInvite();
-        } else {
-          // Direct connection to machine - send connect_to_machine
-          this.sendConnectToMachine();
-        }
-        // Handshake will start when we receive connection_established
-      };
-
-      this.ws.onclose = (event) => {
-        console.log(
-          `[relay-client] Disconnected: ${event.code} ${event.reason}`
-        );
-        this.ws = null;
-        this.handshakeState = null;
-        this.events.onDisconnect?.(event.code, event.reason);
-
-        // Auto-reconnect unless explicitly disconnected
-        if (this.state !== "disconnected") {
-          this.scheduleReconnect();
-        }
-      };
-
-      this.ws.onerror = (event) => {
-        console.error("[relay-client] WebSocket error:", event);
-        this.events.onError?.(new Error("WebSocket error"));
-      };
-
-      this.ws.onmessage = (event) => {
-        this.handleMessage(event.data);
-      };
-    } catch (e) {
-      console.error("[relay-client] Connection error:", e);
-      this.events.onError?.(e as Error);
-      this.scheduleReconnect();
-    }
-  }
-
-  /**
-   * Start X3DH handshake (identity mode)
-   */
-  private startHandshake(): void {
-    if (!this.ws) {
-      return;
-    }
-
-    console.log("[relay-client] Starting X3DH handshake");
-
-    // Create ClientHello
-    const { state, message } = createClientHello(this.config.machineId);
-    this.handshakeState = state;
-
-    // Send as JSON (handshake messages are not encrypted)
-    this.ws.send(JSON.stringify({ type: "handshake", phase: "client_hello", data: message }));
-  }
-
-  private signClientMessage<T extends object>(message: T): T & { signature: SignatureBlock } {
-    const privateKey = this.config.identity.signing.secretKey.slice(0, 32);
-    const publicKey = this.config.identity.signing.publicKey;
-    return signMessage(message, privateKey, publicKey);
-  }
-
-  /**
-   * Send connect_with_invite protocol message for relay routing
-   */
-  private sendConnectWithInvite(): void {
-    if (!this.ws || !this.config.inviteToken) {
-      return;
-    }
-
-    // Generate inviteId from token hash (same as share.ts)
-    const inviteId = createHash("sha256")
-      .update(this.config.inviteToken)
-      .digest("hex")
-      .substring(0, 16);
-
-    const clientIdentityId = this.config.identity.id;
-
-    console.log("[relay-client] Sending connect_with_invite");
-    const signed = this.signClientMessage({
-      type: "connect_with_invite",
-      inviteId,
-      clientIdentityId,
-    });
-    this.ws.send(JSON.stringify(signed));
-  }
-
-  /**
-   * Send connect_to_machine protocol message for direct connection
-   */
-  private sendConnectToMachine(): void {
-    if (!this.ws) {
-      return;
-    }
-
-    const clientIdentityId = this.config.identity.id;
-    const machineId = this.config.machineId;
-
-    console.log("[relay-client] Sending connect_to_machine");
-    const signed = this.signClientMessage({
-      type: "connect_to_machine",
-      machineId,
-      clientIdentityId,
-    });
-    this.ws.send(JSON.stringify(signed));
-  }
-
-  private handleMessage(data: ArrayBuffer | string): void {
-    try {
-      const jsonData = data instanceof ArrayBuffer
-        ? new TextDecoder().decode(data)
-        : data;
-
-      const msg = JSON.parse(jsonData);
-
-      // Handle relay protocol messages
-      if (msg.type === "connection_established") {
-        console.log("[relay-client] Connection established to machine:", msg.machineId);
-        // Now start X3DH handshake - relay has set up the connection
-        this.setState("handshaking");
-        this.startHandshake();
-        return;
-      }
-
-      if (msg.type === "error") {
-        console.error("[relay-client] Relay error:", msg.message);
-        this.events.onError?.(new Error(msg.message || "Relay error"));
-        this.disconnect();
-        return;
-      }
-
-      if (msg.type === "handshake" && this.state === "handshaking") {
-        this.handleHandshakeMessage(msg);
-        return;
-      }
-
-      if (msg.type === "data" && msg.data && this.state === "handshaking") {
-        // Handle handshake wrapped in data message from relay
-        try {
-          const decodedData = Buffer.from(msg.data, "base64").toString("utf-8");
-          const innerMsg = JSON.parse(decodedData);
-          if (innerMsg.type === "handshake") {
-            this.handleHandshakeMessage(innerMsg);
-          }
-        } catch {
-          // Ignore non-handshake data during handshaking
-        }
-        return;
-      }
-
-      if (msg.type === "data" && msg.data && this.state === "connected" && this.readKey) {
-        const frameBuffer = Buffer.from(msg.data, "base64");
-        const result = openFrame(frameBuffer, this.readKey);
-        if (result) {
-          this.events.onMessage?.(result.streamId, result.data);
-        } else {
-          console.warn("[relay-client] Failed to decrypt frame");
-        }
-      }
-    } catch (e) {
-      console.error("[relay-client] Message handling error:", e);
-    }
-  }
-
-  /**
-   * Handle X3DH handshake messages
-   */
-  private handleHandshakeMessage(msg: { type: string; phase: string; data: unknown }): void {
-    if (!this.handshakeState || !this.ws) {
-      return;
-    }
-
-    try {
-      switch (msg.phase) {
-        case "server_hello": {
-          console.log("[relay-client] Received ServerHello");
-
-          // Process ServerHello
-          const serverHello = msg.data as X3DHResponseMessage;
-          const newState = processServerHello(this.handshakeState, serverHello);
-
-          if (!newState) {
-            console.error("[relay-client] Invalid ServerHello");
-            this.events.onError?.(new Error("Handshake failed: invalid ServerHello"));
-            this.disconnect();
-            return;
-          }
-
-          // Create and send ClientAuth
-          const authorization: X3DHAuthMessage["authorization"] = this.config.inviteToken
-            ? { type: "invite", inviteToken: this.config.inviteToken }
-            : { type: "access_list" };
-
-          const { state, message, sessionKeys } = createClientAuth(
-            newState,
-            this.config.identity,
-            authorization
-          );
-
-          this.handshakeState = state;
-          this.sessionKeys = sessionKeys;
-
-          console.log("[relay-client] Sending ClientAuth");
-          this.ws.send(JSON.stringify({ type: "handshake", phase: "client_auth", data: message }));
-          break;
-        }
-
-        case "server_auth": {
-          console.log("[relay-client] Received ServerAuth");
-
-          if (!this.sessionKeys) {
-            console.error("[relay-client] Missing session keys");
-            this.disconnect();
-            return;
-          }
-
-          // Process ServerAuth
-          const serverAuth = msg.data as X3DHResultMessage;
-          const result = processServerAuth(this.handshakeState, serverAuth, this.sessionKeys);
-
-          if (!result) {
-            console.error("[relay-client] Handshake failed: invalid ServerAuth");
-            this.events.onError?.(new Error("Handshake failed: authentication rejected"));
-            this.disconnect();
-            return;
-          }
-
-          // Check if accepted
-          if (result.authResult.type === "rejected") {
-            console.error("[relay-client] Access denied:", result.authResult.reason);
-            this.events.onError?.(new Error(`Access denied: ${result.authResult.reason}`));
-            this.disconnect();
-            return;
-          }
-
-          // Handshake complete - set up encryption keys
-          this.peerIdentityId = result.peerIdentityId;
-          this.accessType = result.authResult.accessType;
-          this.sessionId = result.authResult.sessionId;
-
-          // Convert session keys to Buffers for frame encryption
-          this.writeKey = Buffer.from(result.sessionKeys.sendKey);
-          this.readKey = Buffer.from(result.sessionKeys.receiveKey);
-
-          console.log("[relay-client] Handshake complete, session established");
-          this.setState("connected");
-          this.events.onConnect?.();
-          this.events.onHandshakeComplete?.(this.peerIdentityId, this.accessType, this.sessionId);
-          break;
-        }
-
-        default:
-          console.warn("[relay-client] Unknown handshake phase:", msg.phase);
-      }
-    } catch (e) {
-      console.error("[relay-client] Handshake error:", e);
-      this.events.onError?.(new Error(`Handshake error: ${e instanceof Error ? e.message : String(e)}`));
-      this.disconnect();
-    }
-  }
-
-  private scheduleReconnect(): void {
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      console.error("[relay-client] Max reconnect attempts reached");
-      this.setState("disconnected");
-      return;
-    }
-
-    this.setState("reconnecting");
-    this.reconnectAttempts++;
-
-    // Exponential backoff with jitter
-    const delay = Math.min(
-      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) +
-        Math.random() * 1000,
-      this.maxReconnectDelay
-    );
-
-    console.log(
-      `[relay-client] Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts})`
-    );
-
-    this.reconnectTimer = setTimeout(() => {
-      this.doConnect();
-    }, delay);
-  }
-
-  private cancelReconnect(): void {
-    if (this.reconnectTimer) {
-      clearTimeout(this.reconnectTimer);
-      this.reconnectTimer = null;
-    }
-  }
-}

package/src/lib/tmux-lite/server-lifecycle.test.ts

@@ -1,212 +0,0 @@
-/**
- * E2E tests for tmux-lite server lifecycle
- *
- * Tests server start, stop, and restart scenarios including
- * proper cleanup of socket files.
- */
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { spawn } from "bun";
-import { existsSync, unlinkSync, mkdirSync, rmSync } from "fs";
-import { join } from "path";
-
-// Use the same paths as --test mode in cli.ts and server.ts
-const TEST_SOCKET = "/tmp/tmux-lite-test.sock";
-const TEST_SESSION_DIR = "/tmp/tmux-lite-test";
-const CLI_SCRIPT = join(import.meta.dir, "cli.ts");
-
-/**
- * Helper to run CLI commands in test mode
- */
-async function runCli(command: string): Promise<{ stdout: string; stderr: string; exitCode: number }> {
-  const proc = spawn({
-    cmd: ["bun", "run", CLI_SCRIPT, command, "--test"],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      TMUX_LITE: "",
-    },
-  });
-
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-
-  // Give server time to initialize after CLI returns
-  await Bun.sleep(500);
-
-  return { stdout, stderr, exitCode };
-}
-
-/**
- * Helper to check if server is running by checking socket exists and responds
- */
-async function isServerRunning(): Promise<boolean> {
-  if (!existsSync(TEST_SOCKET)) return false;
-
-  try {
-    const result = await runCli("list");
-    // If we can list sessions, server is running
-    return result.exitCode === 0;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Helper to wait for a condition with timeout
- */
-async function waitFor(
-  condition: () => Promise<boolean>,
-  timeoutMs: number = 5000,
-  intervalMs: number = 100
-): Promise<boolean> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (await condition()) return true;
-    await Bun.sleep(intervalMs);
-  }
-  return false;
-}
-
-/**
- * Force cleanup any leftover test artifacts
- */
-function forceCleanup(): void {
-  try { unlinkSync(TEST_SOCKET); } catch {}
-  try { rmSync(TEST_SESSION_DIR, { recursive: true, force: true }); } catch {}
-}
-
-describe("tmux-lite server lifecycle", () => {
-  beforeEach(() => {
-    // Ensure clean state before each test
-    forceCleanup();
-    mkdirSync(TEST_SESSION_DIR, { recursive: true });
-  });
-
-  afterEach(async () => {
-    // Kill server if still running and cleanup
-    try {
-      await runCli("kill-server");
-      await Bun.sleep(200); // Wait for cleanup
-    } catch {}
-    forceCleanup();
-  });
-
-  describe("server start", () => {
-    it("should start server and create socket file", async () => {
-      // Socket should not exist initially
-      expect(existsSync(TEST_SOCKET)).toBe(false);
-
-      // Start server by running any command (list auto-starts)
-      const result = await runCli("list");
-
-      // Wait for server to be ready
-      const started = await waitFor(async () => existsSync(TEST_SOCKET));
-      expect(started).toBe(true);
-
-      // Server should be running
-      const running = await isServerRunning();
-      expect(running).toBe(true);
-    });
-
-    it("should not fail if server is already running", async () => {
-      // Start server first time
-      await runCli("list");
-      await waitFor(async () => existsSync(TEST_SOCKET));
-
-      // Run another command - should not fail
-      const result = await runCli("list");
-      expect(result.exitCode).toBe(0);
-    });
-  });
-
-  describe("server stop", () => {
-    it("should stop server and remove socket file", async () => {
-      // Start server
-      await runCli("list");
-      await waitFor(async () => existsSync(TEST_SOCKET));
-      expect(existsSync(TEST_SOCKET)).toBe(true);
-
-      // Stop server
-      await runCli("kill-server");
-
-      // Wait for socket to be cleaned up
-      const cleaned = await waitFor(async () => !existsSync(TEST_SOCKET), 2000);
-      expect(cleaned).toBe(true);
-
-      // Socket file should be removed
-      expect(existsSync(TEST_SOCKET)).toBe(false);
-    });
-
-    it("should not fail if server is not running", async () => {
-      // Ensure server is not running
-      expect(existsSync(TEST_SOCKET)).toBe(false);
-
-      // Stop should handle gracefully
-      const result = await runCli("kill-server");
-      // CLI shows "Server not running" but exits cleanly
-      expect(result.exitCode).toBe(0);
-    });
-  });
-
-  describe("server restart cycle", () => {
-    it("should successfully restart after stop (socket cleanup regression test)", async () => {
-      // This is the main regression test for the socket cleanup fix
-
-      // Start server
-      await runCli("list");
-      const started1 = await waitFor(async () => existsSync(TEST_SOCKET));
-      expect(started1).toBe(true);
-
-      // Stop server
-      await runCli("kill-server");
-      const stopped = await waitFor(async () => !existsSync(TEST_SOCKET), 2000);
-      expect(stopped).toBe(true);
-
-      // Start server again - THIS WAS FAILING before the fix
-      // because the socket file wasn't being cleaned up
-      await runCli("list");
-      const started2 = await waitFor(async () => existsSync(TEST_SOCKET));
-      expect(started2).toBe(true);
-
-      // Verify server is actually running
-      const running = await isServerRunning();
-      expect(running).toBe(true);
-    });
-
-    it("should handle multiple restart cycles", async () => {
-      for (let i = 0; i < 3; i++) {
-        // Start
-        await runCli("list");
-        const started = await waitFor(async () => existsSync(TEST_SOCKET));
-        expect(started).toBe(true);
-
-        // Verify running
-        const running = await isServerRunning();
-        expect(running).toBe(true);
-
-        // Stop
-        await runCli("kill-server");
-        const stopped = await waitFor(async () => !existsSync(TEST_SOCKET), 2000);
-        expect(stopped).toBe(true);
-      }
-    }, 15000); // Increase timeout for 3 cycles
-  });
-
-  describe("stale socket handling", () => {
-    it("should clean up stale socket on server start", async () => {
-      // Create a stale socket file (simulating crashed server)
-      Bun.write(TEST_SOCKET, "stale");
-      expect(existsSync(TEST_SOCKET)).toBe(true);
-
-      // Start server - should clean up stale socket and start fresh
-      await runCli("list");
-      const started = await waitFor(async () => {
-        // Socket exists AND server responds
-        return await isServerRunning();
-      });
-      expect(started).toBe(true);
-    });
-  });
-});