@wangyaoshen/remux 0.3.8-dev.29e114b

package/src/git-service.ts

@@ -0,0 +1,168 @@
+/**
+ * E11: Git service — provides git status, diff, worktree, branch operations.
+ * Uses simple-git (npm). All operations are read-only by default.
+ * Write operations (commit, push) require explicit confirmation.
+ */
+
+import simpleGit, { SimpleGit, StatusResult, DiffResult } from "simple-git";
+
+/** Validate git ref names to prevent flag injection via user-supplied arguments. */
+const SAFE_REF_RE = /^[a-zA-Z0-9._\/@{}\[\]:^~-]+$/;
+function assertSafeRef(ref: string): void {
+  if (!ref || ref.startsWith("-") || !SAFE_REF_RE.test(ref)) {
+    throw new Error(`Invalid git ref: ${ref}`);
+  }
+}
+
+let git: SimpleGit | null = null;
+
+export function initGitService(cwd?: string): void {
+  git = simpleGit(cwd || process.cwd());
+}
+
+function getGit(): SimpleGit {
+  if (!git) initGitService();
+  return git!;
+}
+
+// E11-001: git status query
+export async function getGitStatus(): Promise<{
+  branch: string;
+  status: StatusResult;
+  recentCommits: Array<{ hash: string; message: string; date: string; author: string }>;
+}> {
+  const g = getGit();
+  const status = await g.status();
+  const log = await g.log({ maxCount: 10 });
+
+  return {
+    branch: status.current || "unknown",
+    status,
+    recentCommits: log.all.map((c) => ({
+      hash: c.hash.substring(0, 7),
+      message: c.message,
+      date: c.date,
+      author: c.author_name,
+    })),
+  };
+}
+
+// E11-002: git diff query
+export async function getGitDiff(base?: string): Promise<{
+  diff: string;
+  files: Array<{ file: string; insertions: number; deletions: number }>;
+}> {
+  const g = getGit();
+  const diffBase = base || "HEAD";
+  assertSafeRef(diffBase);
+
+  const diffText = await g.diff([diffBase]);
+  const diffStat = await g.diffSummary([diffBase]);
+
+  return {
+    diff: diffText.substring(0, 1024 * 1024), // 1MB limit
+    files: diffStat.files.map((f) => ({
+      file: f.file,
+      insertions: "binary" in f && f.binary ? 0 : (f as { insertions: number }).insertions,
+      deletions: "binary" in f && f.binary ? 0 : (f as { deletions: number }).deletions,
+    })),
+  };
+}
+
+// E11-003: worktree operations
+export async function getWorktrees(): Promise<
+  Array<{ path: string; branch: string; head: string }>
+> {
+  const g = getGit();
+  const result = await g.raw(["worktree", "list", "--porcelain"]);
+  const worktrees: Array<{ path: string; branch: string; head: string }> = [];
+  let current: Record<string, string> = {};
+
+  for (const line of result.split("\n")) {
+    if (line.startsWith("worktree ")) {
+      if (current.path) worktrees.push({
+        path: current.path,
+        branch: current.branch || "",
+        head: current.head || "",
+      });
+      current = { path: line.replace("worktree ", "") };
+    } else if (line.startsWith("HEAD ")) {
+      current.head = line.replace("HEAD ", "").substring(0, 7);
+    } else if (line.startsWith("branch ")) {
+      current.branch = line.replace("branch refs/heads/", "");
+    }
+  }
+  if (current.path) worktrees.push({
+    path: current.path,
+    branch: current.branch || "",
+    head: current.head || "",
+  });
+
+  return worktrees;
+}
+
+export async function createWorktree(
+  branch: string,
+  worktreePath: string,
+): Promise<void> {
+  assertSafeRef(branch);
+  // Prevent path traversal: worktree path must be relative and within project
+  if (worktreePath.includes("..") || worktreePath.startsWith("/")) {
+    throw new Error(`Invalid worktree path: ${worktreePath}`);
+  }
+  const g = getGit();
+  await g.raw(["worktree", "add", "-b", branch, worktreePath, "dev"]);
+}
+
+// E11-013: branch comparison
+export async function compareBranches(
+  base: string,
+  head: string,
+): Promise<{
+  ahead: number;
+  behind: number;
+  files: Array<{ file: string; insertions: number; deletions: number }>;
+}> {
+  assertSafeRef(base);
+  assertSafeRef(head);
+  const g = getGit();
+  const diffStat = await g.diffSummary([`${base}...${head}`]);
+
+  // Count commits
+  const aheadLog = await g.log({ from: base, to: head });
+  const behindLog = await g.log({ from: head, to: base });
+
+  return {
+    ahead: aheadLog.total,
+    behind: behindLog.total,
+    files: diffStat.files.map((f) => ({
+      file: f.file,
+      insertions: "binary" in f && f.binary ? 0 : (f as { insertions: number }).insertions,
+      deletions: "binary" in f && f.binary ? 0 : (f as { deletions: number }).deletions,
+    })),
+  };
+}
+
+// E11-012: git webhook — watch .git for changes
+export function watchGitChanges(
+  onChange: () => void,
+): () => void {
+  const fs = require("fs");
+  const path = require("path");
+  const gitDir = path.join(process.cwd(), ".git");
+
+  try {
+    const watcher = fs.watch(
+      gitDir,
+      { recursive: false },
+      (eventType: string, filename: string) => {
+        if (filename === "HEAD" || filename?.startsWith("refs")) {
+          onChange();
+        }
+      },
+    );
+    return () => watcher.close();
+  } catch {
+    return () => {};
+  }
+}

package/src/message-buffer.ts

@@ -0,0 +1,137 @@
+/**
+ * Per-device message ring buffer for offline message queuing.
+ * When a client disconnects, messages are buffered here so they can
+ * be replayed on reconnect (session recovery).
+ *
+ * Design influenced by Mosh's approach to state synchronization and
+ * tmux's client-server buffering model.
+ */
+
+export interface BufferedMessage {
+  timestamp: number;
+  data: string; // serialized JSON message
+}
+
+/**
+ * Ring buffer that holds messages for a single device.
+ * Oldest messages are evicted when maxSize is exceeded.
+ * Messages older than maxAgeMs are filtered out on drain/prune.
+ */
+export class MessageBuffer {
+  private buffer: BufferedMessage[] = [];
+  private maxSize: number;
+  private maxAgeMs: number;
+
+  constructor(maxSize = 1000, maxAgeMs = 10 * 60 * 1000) {
+    this.maxSize = maxSize;
+    this.maxAgeMs = maxAgeMs;
+  }
+
+  /**
+   * Add a message to the buffer.
+   * Evicts the oldest message if buffer is at capacity.
+   */
+  push(data: string): void {
+    if (this.buffer.length >= this.maxSize) {
+      this.buffer.shift(); // evict oldest
+    }
+    this.buffer.push({ timestamp: Date.now(), data });
+  }
+
+  /**
+   * Return all messages (optionally since a given timestamp).
+   * Filters out expired messages (older than maxAgeMs).
+   * Clears returned messages from the buffer.
+   */
+  drain(since?: number): BufferedMessage[] {
+    const now = Date.now();
+    const cutoff = now - this.maxAgeMs;
+
+    let result = this.buffer.filter((m) => m.timestamp > cutoff);
+    if (since !== undefined) {
+      result = result.filter((m) => m.timestamp > since);
+    }
+
+    this.buffer = [];
+    return result;
+  }
+
+  /**
+   * Clear all messages from the buffer.
+   */
+  clear(): void {
+    this.buffer = [];
+  }
+
+  /**
+   * Number of messages currently in the buffer.
+   */
+  get size(): number {
+    return this.buffer.length;
+  }
+
+  /**
+   * Remove messages older than maxAgeMs.
+   */
+  pruneExpired(): void {
+    const cutoff = Date.now() - this.maxAgeMs;
+    this.buffer = this.buffer.filter((m) => m.timestamp > cutoff);
+  }
+}
+
+/**
+ * Global registry of message buffers, keyed by deviceId.
+ * Runs periodic cleanup to evict stale/empty buffers.
+ */
+export class BufferRegistry {
+  private buffers = new Map<string, MessageBuffer>();
+  private cleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor() {
+    // Periodic cleanup every 60s
+    this.cleanupInterval = setInterval(() => this.cleanup(), 60_000);
+  }
+
+  /**
+   * Get or create a MessageBuffer for a device.
+   */
+  getOrCreate(deviceId: string): MessageBuffer {
+    let buf = this.buffers.get(deviceId);
+    if (!buf) {
+      buf = new MessageBuffer();
+      this.buffers.set(deviceId, buf);
+    }
+    return buf;
+  }
+
+  /**
+   * Remove the buffer for a device.
+   */
+  remove(deviceId: string): void {
+    this.buffers.delete(deviceId);
+  }
+
+  /**
+   * Remove empty buffers that have no messages (stale).
+   * Prune expired messages in all remaining buffers.
+   */
+  private cleanup(): void {
+    for (const [deviceId, buf] of this.buffers) {
+      buf.pruneExpired();
+      if (buf.size === 0) {
+        this.buffers.delete(deviceId);
+      }
+    }
+  }
+
+  /**
+   * Tear down: clear the cleanup interval and all buffers.
+   */
+  destroy(): void {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = null;
+    }
+    this.buffers.clear();
+  }
+}

package/src/pty-daemon.ts

@@ -0,0 +1,357 @@
+/**
+ * PTY Daemon — independent Node.js process that holds a PTY alive.
+ * Each tab spawns one daemon. The daemon survives server restarts.
+ * Communication is via a Unix domain socket using a TLV frame protocol.
+ *
+ * Adapted from tmux client-server model and tsm's VT tracking pattern.
+ *
+ * Usage: node pty-daemon.js --socket <path> --shell <shell> --cols <n> --rows <n> --cwd <dir> --tab-id <id>
+ */
+
+import net from "net";
+import pty from "node-pty";
+import { parseArgs } from "util";
+import type { IPty } from "node-pty";
+
+// ── TLV Frame Tags ──────────────────────────────────────────────
+
+export const TAG_PTY_OUTPUT = 0x01;
+export const TAG_CLIENT_INPUT = 0x02;
+export const TAG_RESIZE = 0x03;
+export const TAG_STATUS_REQ = 0x04;
+export const TAG_STATUS_RES = 0x05;
+export const TAG_SNAPSHOT_REQ = 0x06;
+export const TAG_SNAPSHOT_RES = 0x07;
+export const TAG_SCROLLBACK_REQ = 0x08;
+export const TAG_SCROLLBACK_RES = 0x09;
+export const TAG_SHUTDOWN = 0xff;
+
+// ── TLV Frame Codec ─────────────────────────────────────────────
+
+/**
+ * Encode a TLV frame: [1 byte tag][4 bytes length (big-endian)][payload].
+ */
+export function encodeFrame(tag: number, payload: Buffer | string): Buffer {
+  const data = typeof payload === "string" ? Buffer.from(payload, "utf8") : payload;
+  const frame = Buffer.alloc(5 + data.length);
+  frame[0] = tag;
+  frame.writeUInt32BE(data.length, 1);
+  data.copy(frame, 5);
+  return frame;
+}
+
+/**
+ * TLV frame parser — accumulates data and emits complete frames.
+ */
+export class FrameParser {
+  private buffer = Buffer.alloc(0);
+  private onFrame: (tag: number, payload: Buffer) => void;
+
+  constructor(onFrame: (tag: number, payload: Buffer) => void) {
+    this.onFrame = onFrame;
+  }
+
+  feed(data: Buffer): void {
+    this.buffer = Buffer.concat([this.buffer, data]);
+    while (this.buffer.length >= 5) {
+      const tag = this.buffer[0];
+      const length = this.buffer.readUInt32BE(1);
+      if (this.buffer.length < 5 + length) break; // incomplete frame
+      const payload = this.buffer.subarray(5, 5 + length);
+      this.buffer = this.buffer.subarray(5 + length);
+      this.onFrame(tag, payload);
+    }
+  }
+}
+
+// ── RingBuffer (scrollback) ─────────────────────────────────────
+
+class RingBuffer {
+  private buf: Buffer;
+  private maxBytes: number;
+  private writePos: number;
+  private length: number;
+
+  constructor(maxBytes = 10 * 1024 * 1024) {
+    this.buf = Buffer.alloc(maxBytes);
+    this.maxBytes = maxBytes;
+    this.writePos = 0;
+    this.length = 0;
+  }
+
+  write(data: string | Buffer): void {
+    const bytes = typeof data === "string" ? Buffer.from(data) : data;
+    if (bytes.length >= this.maxBytes) {
+      bytes.copy(this.buf, 0, bytes.length - this.maxBytes);
+      this.writePos = 0;
+      this.length = this.maxBytes;
+      return;
+    }
+    const space = this.maxBytes - this.writePos;
+    if (bytes.length <= space) {
+      bytes.copy(this.buf, this.writePos);
+    } else {
+      bytes.copy(this.buf, this.writePos, 0, space);
+      bytes.copy(this.buf, 0, space);
+    }
+    this.writePos = (this.writePos + bytes.length) % this.maxBytes;
+    this.length = Math.min(this.length + bytes.length, this.maxBytes);
+  }
+
+  read(): Buffer {
+    if (this.length === 0) return Buffer.alloc(0);
+    if (this.length < this.maxBytes) {
+      return Buffer.from(this.buf.subarray(this.writePos - this.length, this.writePos));
+    }
+    return Buffer.concat([
+      this.buf.subarray(this.writePos),
+      this.buf.subarray(0, this.writePos),
+    ]);
+  }
+}
+
+// ── CLI argument parsing ────────────────────────────────────────
+
+function parseCliArgs(): {
+  socket: string;
+  shell: string;
+  cols: number;
+  rows: number;
+  cwd: string;
+  tabId: string;
+} {
+  const { values } = parseArgs({
+    options: {
+      socket: { type: "string" },
+      shell: { type: "string" },
+      cols: { type: "string" },
+      rows: { type: "string" },
+      cwd: { type: "string" },
+      "tab-id": { type: "string" },
+    },
+    strict: true,
+  });
+
+  if (!values.socket || !values.shell) {
+    console.error("Usage: pty-daemon --socket <path> --shell <shell> [--cols N] [--rows N] [--cwd dir] [--tab-id id]");
+    process.exit(1);
+  }
+
+  return {
+    socket: values.socket,
+    shell: values.shell,
+    cols: parseInt(values.cols || "80", 10),
+    rows: parseInt(values.rows || "24", 10),
+    cwd: values.cwd || process.env.HOME || "/",
+    tabId: values["tab-id"] || "0",
+  };
+}
+
+// ── Daemon main ─────────────────────────────────────────────────
+
+function main(): void {
+  const args = parseCliArgs();
+
+  // Sequence counter for durable stream (Step 4)
+  let seq = 0;
+
+  // Detach from parent process if possible (survive server restarts)
+  if (typeof process.disconnect === "function") {
+    try { process.disconnect(); } catch { /* already disconnected */ }
+  }
+
+  // Create PTY
+  const ptyProcess: IPty = pty.spawn(args.shell, [], {
+    name: "xterm-256color",
+    cols: args.cols,
+    rows: args.rows,
+    cwd: args.cwd,
+    env: {
+      ...process.env,
+      TERM: "xterm-256color",
+      COLORTERM: "truecolor",
+    },
+  });
+
+  const scrollback = new RingBuffer();
+  const clients = new Set<net.Socket>();
+  let alive = true;
+
+  console.log(`[pty-daemon] started: pid=${ptyProcess.pid} socket=${args.socket} tab-id=${args.tabId}`);
+
+  // ── PTY output → broadcast to all clients + scrollback ──
+
+  ptyProcess.onData((data: string) => {
+    seq++;
+    scrollback.write(data);
+    const frame = encodeFrame(TAG_PTY_OUTPUT, data);
+    for (const client of clients) {
+      try {
+        client.write(frame);
+      } catch {
+        // Client write error — will be cleaned up on close
+      }
+    }
+  });
+
+  // ── PTY exit ──
+
+  ptyProcess.onExit(({ exitCode }) => {
+    alive = false;
+    console.log(`[pty-daemon] PTY exited: code=${exitCode} tab-id=${args.tabId}`);
+
+    // Notify all clients
+    const exitMsg = `\r\n\x1b[33mShell exited (code: ${exitCode})\x1b[0m\r\n`;
+    const frame = encodeFrame(TAG_PTY_OUTPUT, exitMsg);
+    for (const client of clients) {
+      try { client.write(frame); } catch { /* ignore */ }
+    }
+
+    // Wait briefly for clients to disconnect, then clean up
+    setTimeout(() => {
+      for (const client of clients) {
+        try { client.end(); } catch { /* ignore */ }
+      }
+      cleanup();
+    }, 2000);
+  });
+
+  // ── Unix socket server ──
+
+  const server = net.createServer((socket) => {
+    clients.add(socket);
+    console.log(`[pty-daemon] client connected (total: ${clients.size})`);
+
+    const parser = new FrameParser((tag, payload) => {
+      switch (tag) {
+        case TAG_CLIENT_INPUT:
+          if (alive) {
+            ptyProcess.write(payload.toString("utf8"));
+          }
+          break;
+
+        case TAG_RESIZE: {
+          try {
+            const { cols, rows } = JSON.parse(payload.toString("utf8"));
+            if (alive && cols > 0 && rows > 0) {
+              ptyProcess.resize(
+                Math.max(1, Math.min(cols, 500)),
+                Math.max(1, Math.min(rows, 200)),
+              );
+            }
+          } catch { /* invalid resize payload */ }
+          break;
+        }
+
+        case TAG_STATUS_REQ: {
+          const status = JSON.stringify({
+            pid: ptyProcess.pid,
+            cols: args.cols,
+            rows: args.rows,
+            alive,
+            cwd: args.cwd,
+            tabId: args.tabId,
+            seq,
+          });
+          socket.write(encodeFrame(TAG_STATUS_RES, status));
+          break;
+        }
+
+        case TAG_SNAPSHOT_REQ: {
+          const data = scrollback.read();
+          socket.write(encodeFrame(TAG_SNAPSHOT_RES, data));
+          break;
+        }
+
+        case TAG_SCROLLBACK_REQ: {
+          // Return full scrollback (future: support since-seq filtering)
+          const data = scrollback.read();
+          socket.write(encodeFrame(TAG_SCROLLBACK_RES, data));
+          break;
+        }
+
+        case TAG_SHUTDOWN:
+          console.log(`[pty-daemon] shutdown requested`);
+          if (alive) {
+            try { ptyProcess.kill(); } catch { /* already dead */ }
+          }
+          // Close all clients and clean up
+          for (const c of clients) {
+            try { c.end(); } catch { /* ignore */ }
+          }
+          cleanup();
+          break;
+      }
+    });
+
+    socket.on("data", (data) => {
+      parser.feed(Buffer.isBuffer(data) ? data : Buffer.from(data));
+    });
+
+    socket.on("close", () => {
+      clients.delete(socket);
+      console.log(`[pty-daemon] client disconnected (total: ${clients.size})`);
+    });
+
+    socket.on("error", (err) => {
+      console.error(`[pty-daemon] client socket error:`, err.message);
+      clients.delete(socket);
+    });
+  });
+
+  // Clean up stale socket file before listening
+  try {
+    const fs = require("fs");
+    if (fs.existsSync(args.socket)) {
+      fs.unlinkSync(args.socket);
+    }
+  } catch { /* ignore */ }
+
+  server.listen(args.socket, () => {
+    console.log(`[pty-daemon] listening on ${args.socket}`);
+  });
+
+  server.on("error", (err) => {
+    console.error(`[pty-daemon] server error:`, err.message);
+    cleanup();
+  });
+
+  // ── Cleanup ──
+
+  function cleanup(): void {
+    try {
+      const fs = require("fs");
+      if (fs.existsSync(args.socket)) {
+        fs.unlinkSync(args.socket);
+      }
+    } catch { /* ignore */ }
+    server.close();
+    process.exit(0);
+  }
+
+  // ── Signal handling ──
+
+  process.on("SIGTERM", () => {
+    console.log(`[pty-daemon] SIGTERM received`);
+    if (alive) {
+      try { ptyProcess.kill(); } catch { /* already dead */ }
+    }
+    cleanup();
+  });
+
+  process.on("SIGINT", () => {
+    // Ignore SIGINT in daemon — only respond to SIGTERM or explicit shutdown
+  });
+}
+
+// Run only when executed as the main entry point (not when imported).
+// When esbuild bundles this file as pty-daemon.js, it becomes the main module.
+// When imported by session.ts (for encodeFrame/FrameParser), we skip main().
+//
+// Detection: if process.argv[1] contains "pty-daemon" or if CLI args include --socket,
+// this is being run as the daemon entry point.
+const isMainEntry = process.argv[1]?.includes("pty-daemon") ||
+  process.argv.includes("--socket");
+if (isMainEntry) {
+  main();
+}