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

package/src/lib/tmux-lite/process-run.integration.test.ts

@@ -1,266 +0,0 @@
-import { describe, expect, test, beforeEach, afterEach } from "bun:test";
-import { spawn } from "bun";
-import { existsSync, mkdirSync, rmSync, unlinkSync } from "fs";
-import { dirname, join } from "path";
-import {
-  encodeRouterMessage,
-  decodeRouterMessages,
-  encodeControl,
-  parseFrames,
-  decodeControl,
-  FrameType,
-} from "./protocol";
-
-const TEST_SOCKET = "/tmp/tmux-lite-test.sock";
-const TEST_SESSION_DIR = "/tmp/tmux-lite-test";
-const TEST_PID_FILE = "/tmp/tmux-lite-test.pid";
-const SERVER_SCRIPT = join(import.meta.dir, "server.ts");
-const SESSION_NAME = "proc:wide-events:sample-events:1";
-const SAMPLE_SCRIPT = join(import.meta.dir, "../../../scripts/sample-events.ts");
-const BUN_PATH = "/opt/homebrew/bin/bun";
-
-function getTestSessionSocketPath(id: string): string {
-  return join(TEST_SESSION_DIR, `tmux-lite-${id}.sock`);
-}
-
-function cleanup(): void {
-  try { unlinkSync(TEST_SOCKET); } catch {}
-  try { unlinkSync(TEST_PID_FILE); } catch {}
-  try { rmSync(TEST_SESSION_DIR, { recursive: true, force: true }); } catch {}
-}
-
-async function waitFor(condition: () => Promise<boolean>, timeoutMs = 5000, intervalMs = 50): Promise<void> {
-  const start = Date.now();
-  while (Date.now() - start < timeoutMs) {
-    if (await condition()) return;
-    await Bun.sleep(intervalMs);
-  }
-  throw new Error("Timed out waiting for condition");
-}
-
-async function waitWithTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
-  return await Promise.race([
-    promise,
-    new Promise<T>((_resolve, reject) =>
-      setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs)
-    ),
-  ]);
-}
-
-async function startServer(): Promise<void> {
-  spawn({
-    cmd: ["bun", "run", SERVER_SCRIPT, "--test"],
-    stdout: "ignore",
-    stderr: "ignore",
-    env: {
-      ...process.env,
-      TMUX_LITE_SOCKET: TEST_SOCKET,
-      TMUX_LITE_SESSION_DIR: TEST_SESSION_DIR,
-      TMUX_LITE_PID_FILE: TEST_PID_FILE,
-    },
-  });
-
-  await waitFor(async () => existsSync(TEST_SOCKET));
-}
-
-async function sendRouterCommand(command: Record<string, unknown>) {
-  return await new Promise<any>((resolve, reject) => {
-    let buffer = Buffer.alloc(0);
-    let settled = false;
-    let socketRef: any;
-
-    const timer = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      socketRef?.end();
-      reject(new Error(`Router timeout for command ${String(command.type)}`));
-    }, 3000);
-
-    const finish = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      socketRef?.end();
-      fn();
-    };
-
-    Bun.connect({
-      unix: TEST_SOCKET,
-      socket: {
-        open(socket) {
-          socketRef = socket;
-          socket.write(encodeRouterMessage(command as any));
-        },
-        data(_socket, data) {
-          buffer = Buffer.concat([buffer, Buffer.from(data)]);
-          try {
-            const decoded = decodeRouterMessages(buffer);
-            buffer = Buffer.from(decoded.remaining as Buffer);
-            if (decoded.messages.length > 0) {
-              finish(() => resolve(decoded.messages[0]));
-            }
-          } catch (err) {
-            finish(() => reject(err));
-          }
-        },
-        close() {
-          finish(() => reject(new Error("Router socket closed before response")));
-        },
-        error(_socket, err) {
-          finish(() => reject(err));
-        },
-        connectError(_socket, err) {
-          finish(() => reject(err));
-        },
-        drain() {},
-      },
-    }).catch((err) => finish(() => reject(err)));
-  });
-}
-
-async function attachAndWaitForEvent(socketPath: string): Promise<{ output: string }> {
-  return await new Promise((resolve, reject) => {
-    let buffer = Buffer.alloc(0);
-    let output = "";
-    let attached = false;
-    let settled = false;
-    let socketRef: any;
-
-    const timeout = setTimeout(() => {
-      if (settled) return;
-      settled = true;
-      socketRef?.end();
-      reject(new Error(`Timed out waiting for @event output. Collected output: ${output.slice(-500)}`));
-    }, 2000);
-
-    const finish = (fn: () => void) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timeout);
-      socketRef?.end();
-      fn();
-    };
-
-    const connectOnce = () => {
-    Bun.connect({
-      unix: socketPath,
-      socket: {
-        open(socket) {
-          socketRef = socket;
-          socket.write(encodeControl({ type: "attach-init", cols: 80, rows: 24, clientType: "cli" }));
-        },
-
-          data(_socket, data) {
-            buffer = Buffer.concat([buffer, Buffer.from(data)]);
-            try {
-              const parsed = parseFrames(buffer);
-              buffer = Buffer.from(parsed.remaining as Buffer);
-            for (const frame of parsed.frames) {
-              if (frame.type === FrameType.CONTROL) {
-                const msg = decodeControl(frame.payload);
-                if (msg.type === "attached") {
-                  attached = true;
-                }
-                if (msg.type === "wide_event") {
-                  output += JSON.stringify(msg.event);
-                  if (attached) {
-                    finish(() => resolve({ output }));
-                  }
-                }
-              } else if (frame.type === FrameType.PTY) {
-                const text = frame.payload.toString("utf-8");
-                output += text;
-                if (attached && output.includes("[event:")) {
-                  finish(() => resolve({ output }));
-                }
-              }
-            }
-
-            } catch (err) {
-              finish(() => reject(err));
-            }
-          },
-          close() {
-            finish(() => reject(new Error("Session socket closed before output")));
-          },
-          error(_socket, err) {
-            finish(() => reject(err));
-          },
-          connectError(_socket, err) {
-            if ((err as { code?: string }).code === "ENOENT") {
-              if (!settled) {
-                setTimeout(connectOnce, 50);
-              }
-              return;
-            }
-            finish(() => reject(err));
-          },
-          drain() {},
-        },
-      }).catch((err) => {
-        if ((err as { code?: string }).code === "ENOENT") {
-          if (!settled) {
-            setTimeout(connectOnce, 50);
-          }
-          return;
-        }
-        finish(() => reject(err));
-      });
-    };
-
-    connectOnce();
-  });
-}
-
-describe("tmux-lite process execution", () => {
-  beforeEach(() => {
-    cleanup();
-    mkdirSync(TEST_SESSION_DIR, { recursive: true });
-  });
-
-  afterEach(async () => {
-    try {
-      if (existsSync(TEST_SOCKET)) {
-        await waitWithTimeout(sendRouterCommand({ type: "kill-server" }), 2000, "kill-server");
-      }
-    } catch (err) {
-      console.warn("Failed to kill test server:", err);
-    }
-    await Bun.sleep(200);
-    cleanup();
-  });
-
-  test("starts process session and streams output", async () => {
-    await startServer();
-
-    if (!existsSync(BUN_PATH)) {
-      throw new Error(`bun not found at ${BUN_PATH}`);
-    }
-
-    const response = await sendRouterCommand({
-      type: "new",
-      name: SESSION_NAME,
-      cwd: join(import.meta.dir, "../../.."),
-      command: process.execPath,
-      args: [
-        join(import.meta.dir, "../../index.ts"),
-        "--internal-process-runner",
-        "--workspace",
-        join(import.meta.dir, "../../.."),
-        "--process",
-        "sample-events",
-        "--instance",
-        "1",
-      ],
-    });
-
-    if (response.type !== "session") {
-      throw new Error(`Expected session response, got: ${JSON.stringify(response)}`);
-    }
-
-    const socketPath = getTestSessionSocketPath(response.session.id);
-    const { output } = await waitWithTimeout(attachAndWaitForEvent(socketPath), 8000, "attachAndWaitForEvent");
-    expect(output).toContain("[event:");
-
-  }, 10000);
-});

package/src/lib/tmux-lite/protocol.test.ts

@@ -1,307 +0,0 @@
-/**
- * Tests for the tmux-lite session framed protocol
- */
-import { describe, it, expect } from "bun:test";
-import {
-  FrameType,
-  encodeFrame,
-  encodePTY,
-  encodeControl,
-  parseFrames,
-  decodeControl,
-  type SessionCtrl,
-  type SessionEvent,
-  type SessionFrame,
-} from "./protocol";
-
-describe("protocol", () => {
-  describe("encodeFrame", () => {
-    it("encodes a PTY frame with correct header", () => {
-      const payload = Buffer.from("hello");
-      const frame = encodeFrame(FrameType.PTY, payload);
-
-      // Header: 1 byte type + 4 bytes length
-      expect(frame.length).toBe(5 + payload.length);
-      expect(frame[0]).toBe(FrameType.PTY); // type
-      expect(frame.readUInt32BE(1)).toBe(payload.length); // length
-      expect(frame.subarray(5).toString()).toBe("hello"); // payload
-    });
-
-    it("encodes a CONTROL frame with correct header", () => {
-      const payload = Buffer.from('{"type":"resize"}');
-      const frame = encodeFrame(FrameType.CONTROL, payload);
-
-      expect(frame.length).toBe(5 + payload.length);
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      expect(frame.readUInt32BE(1)).toBe(payload.length);
-      expect(frame.subarray(5).toString()).toBe('{"type":"resize"}');
-    });
-
-    it("handles empty payload", () => {
-      const frame = encodeFrame(FrameType.PTY, Buffer.alloc(0));
-
-      expect(frame.length).toBe(5);
-      expect(frame[0]).toBe(FrameType.PTY);
-      expect(frame.readUInt32BE(1)).toBe(0);
-    });
-
-    it("handles Uint8Array payload", () => {
-      const payload = new Uint8Array([1, 2, 3, 4, 5]);
-      const frame = encodeFrame(FrameType.PTY, payload);
-
-      expect(frame.length).toBe(5 + 5);
-      expect(frame.subarray(5)).toEqual(Buffer.from([1, 2, 3, 4, 5]));
-    });
-  });
-
-  describe("encodePTY", () => {
-    it("wraps data in a PTY frame", () => {
-      const data = Buffer.from("terminal output");
-      const frame = encodePTY(data);
-
-      expect(frame[0]).toBe(FrameType.PTY);
-      expect(frame.subarray(5).toString()).toBe("terminal output");
-    });
-  });
-
-  describe("encodeControl", () => {
-    it("encodes resize message", () => {
-      const msg: SessionCtrl = { type: "resize", cols: 120, rows: 40 };
-      const frame = encodeControl(msg);
-
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      const payload = frame.subarray(5).toString();
-      expect(JSON.parse(payload)).toEqual(msg);
-    });
-
-    it("encodes attach-init message", () => {
-      const msg: SessionCtrl = { type: "attach-init", cols: 80, rows: 24, clientType: "cli" };
-      const frame = encodeControl(msg);
-
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      const payload = frame.subarray(5).toString();
-      expect(JSON.parse(payload)).toEqual(msg);
-    });
-
-    it("encodes detach message", () => {
-      const msg: SessionCtrl = { type: "detach" };
-      const frame = encodeControl(msg);
-
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      const payload = frame.subarray(5).toString();
-      expect(JSON.parse(payload)).toEqual(msg);
-    });
-
-    it("encodes exited event", () => {
-      const msg: SessionEvent = { type: "exited", code: 0 };
-      const frame = encodeControl(msg);
-
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      const payload = frame.subarray(5).toString();
-      expect(JSON.parse(payload)).toEqual(msg);
-    });
-
-    it("encodes kicked event", () => {
-      const msg: SessionEvent = { type: "kicked" };
-      const frame = encodeControl(msg);
-
-      expect(frame[0]).toBe(FrameType.CONTROL);
-      const payload = frame.subarray(5).toString();
-      expect(JSON.parse(payload)).toEqual(msg);
-    });
-  });
-
-  describe("parseFrames", () => {
-    it("parses a single complete frame", () => {
-      const frame = encodePTY(Buffer.from("hello"));
-      const result = parseFrames(frame);
-
-      expect(result.frames.length).toBe(1);
-      expect(result.frames[0].type).toBe(FrameType.PTY);
-      expect(result.frames[0].payload.toString()).toBe("hello");
-      expect(result.remaining.length).toBe(0);
-    });
-
-    it("parses multiple complete frames", () => {
-      const frame1 = encodePTY(Buffer.from("first"));
-      const frame2 = encodeControl({ type: "resize", cols: 80, rows: 24 });
-      const frame3 = encodePTY(Buffer.from("third"));
-
-      const combined = Buffer.concat([frame1, frame2, frame3]);
-      const result = parseFrames(combined);
-
-      expect(result.frames.length).toBe(3);
-      expect(result.frames[0].type).toBe(FrameType.PTY);
-      expect(result.frames[0].payload.toString()).toBe("first");
-      expect(result.frames[1].type).toBe(FrameType.CONTROL);
-      expect(result.frames[2].type).toBe(FrameType.PTY);
-      expect(result.frames[2].payload.toString()).toBe("third");
-      expect(result.remaining.length).toBe(0);
-    });
-
-    it("handles incomplete frame (missing payload)", () => {
-      const frame = encodePTY(Buffer.from("hello world"));
-      // Only send header + partial payload
-      const partial = frame.subarray(0, 8);
-      const result = parseFrames(partial);
-
-      expect(result.frames.length).toBe(0);
-      expect(result.remaining.length).toBe(8);
-      expect(result.remaining).toEqual(partial);
-    });
-
-    it("handles incomplete header", () => {
-      const frame = encodePTY(Buffer.from("hello"));
-      // Only send 3 bytes (incomplete header)
-      const partial = frame.subarray(0, 3);
-      const result = parseFrames(partial);
-
-      expect(result.frames.length).toBe(0);
-      expect(result.remaining.length).toBe(3);
-    });
-
-    it("handles empty buffer", () => {
-      const result = parseFrames(Buffer.alloc(0));
-
-      expect(result.frames.length).toBe(0);
-      expect(result.remaining.length).toBe(0);
-    });
-
-    it("returns remaining bytes after complete frames", () => {
-      const frame1 = encodePTY(Buffer.from("complete"));
-      const frame2 = encodePTY(Buffer.from("incomplete"));
-      const partial2 = frame2.subarray(0, 7); // incomplete second frame
-
-      const combined = Buffer.concat([frame1, partial2]);
-      const result = parseFrames(combined);
-
-      expect(result.frames.length).toBe(1);
-      expect(result.frames[0].payload.toString()).toBe("complete");
-      expect(result.remaining.length).toBe(7);
-    });
-
-    it("rejects oversized frames", () => {
-      // Create a frame header claiming 2MB payload (over 1MB limit)
-      const header = Buffer.alloc(5);
-      header.writeUInt8(FrameType.PTY, 0);
-      header.writeUInt32BE(2 * 1024 * 1024, 1);
-
-      expect(() => parseFrames(header)).toThrow(/exceeds maximum/);
-    });
-
-    it("rejects invalid frame types", () => {
-      // Create a frame header with invalid type (0xFF)
-      const header = Buffer.alloc(10);
-      header.writeUInt8(0xFF, 0); // Invalid type
-      header.writeUInt32BE(5, 1); // 5 bytes payload
-      header.write("hello", 5);
-
-      expect(() => parseFrames(header)).toThrow(/Invalid frame type.*protocol desync/);
-    });
-  });
-
-  describe("decodeControl", () => {
-    it("decodes resize message", () => {
-      const json = JSON.stringify({ type: "resize", cols: 100, rows: 50 });
-      const msg = decodeControl(Buffer.from(json)) as SessionCtrl;
-
-      expect(msg.type).toBe("resize");
-      if (msg.type === "resize") {
-        expect(msg.cols).toBe(100);
-        expect(msg.rows).toBe(50);
-      }
-    });
-
-    it("decodes exited event", () => {
-      const json = JSON.stringify({ type: "exited", code: 1 });
-      const msg = decodeControl(Buffer.from(json)) as SessionEvent;
-
-      expect(msg.type).toBe("exited");
-      if (msg.type === "exited") {
-        expect(msg.code).toBe(1);
-      }
-    });
-
-    it("throws on invalid JSON", () => {
-      expect(() => decodeControl(Buffer.from("not json"))).toThrow();
-    });
-  });
-
-  describe("round-trip", () => {
-    it("encodes and parses PTY data correctly", () => {
-      const original = Buffer.from("Hello, terminal!\x1b[32mGreen\x1b[0m");
-      const frame = encodePTY(original);
-      const { frames } = parseFrames(frame);
-
-      expect(frames.length).toBe(1);
-      expect(frames[0].type).toBe(FrameType.PTY);
-      expect(frames[0].payload).toEqual(original);
-    });
-
-    it("encodes and parses control messages correctly", () => {
-      const original: SessionCtrl = { type: "attach-init", cols: 120, rows: 40, clientType: "web" };
-      const frame = encodeControl(original);
-      const { frames } = parseFrames(frame);
-
-      expect(frames.length).toBe(1);
-      expect(frames[0].type).toBe(FrameType.CONTROL);
-
-      const decoded = decodeControl(frames[0].payload);
-      expect(decoded).toEqual(original);
-    });
-
-    it("handles binary data with all byte values", () => {
-      // Create buffer with all possible byte values
-      const original = Buffer.alloc(256);
-      for (let i = 0; i < 256; i++) {
-        original[i] = i;
-      }
-
-      const frame = encodePTY(original);
-      const { frames } = parseFrames(frame);
-
-      expect(frames[0].payload).toEqual(original);
-    });
-
-    it("handles data that looks like old CTRL_MAGIC", () => {
-      // ESC ] 9 9 - the old magic bytes that caused collisions with OSC 99
-      const oscSequence = Buffer.from([0x1b, 0x5d, 0x39, 0x39, 0x3b, 0x74, 0x65, 0x73, 0x74, 0x07]);
-      const frame = encodePTY(oscSequence);
-      const { frames } = parseFrames(frame);
-
-      expect(frames.length).toBe(1);
-      expect(frames[0].type).toBe(FrameType.PTY);
-      expect(frames[0].payload).toEqual(oscSequence);
-    });
-  });
-
-  describe("streaming simulation", () => {
-    it("handles data arriving in chunks", () => {
-      // Simulate streaming: multiple frames arriving in arbitrary chunks
-      const frame1 = encodePTY(Buffer.from("first message"));
-      const frame2 = encodeControl({ type: "resize", cols: 80, rows: 24 });
-      const frame3 = encodePTY(Buffer.from("second message"));
-
-      const allData = Buffer.concat([frame1, frame2, frame3]);
-
-      // Simulate receiving in 7-byte chunks
-      let buffer: Buffer = Buffer.alloc(0);
-      const allFrames: SessionFrame[] = [];
-
-      for (let i = 0; i < allData.length; i += 7) {
-        const chunk = allData.subarray(i, Math.min(i + 7, allData.length));
-        buffer = Buffer.concat([buffer, chunk]);
-
-        const { frames, remaining } = parseFrames(buffer);
-        allFrames.push(...frames);
-        buffer = remaining;
-      }
-
-      expect(allFrames.length).toBe(3);
-      expect(allFrames[0].payload.toString()).toBe("first message");
-      expect(allFrames[1].type).toBe(FrameType.CONTROL);
-      expect(allFrames[2].payload.toString()).toBe("second message");
-      expect(buffer.length).toBe(0);
-    });
-  });
-});