@jx0/jmux 0.1.0

package/src/sidebar.ts

@@ -0,0 +1,295 @@
+import type { CellGrid, SessionInfo } from "./types";
+import { ColorMode } from "./types";
+import { createGrid, writeString, type CellAttrs } from "./cell-grid";
+
+const HEADER_ROWS = 2; // "jmux" header + separator
+
+const DIM_ATTRS: CellAttrs = { dim: true };
+const ACCENT_ATTRS: CellAttrs = {
+  fg: 2,
+  fgMode: ColorMode.Palette,
+};
+const ACTIVE_MARKER_ATTRS: CellAttrs = {
+  fg: 2,
+  fgMode: ColorMode.Palette,
+  bold: true,
+};
+const ACTIVITY_ATTRS: CellAttrs = {
+  fg: 2,
+  fgMode: ColorMode.Palette,
+};
+const ATTENTION_ATTRS: CellAttrs = {
+  fg: 3,
+  fgMode: ColorMode.Palette,
+  bold: true,
+};
+const ACTIVE_NAME_ATTRS: CellAttrs = {
+  fg: 15,
+  fgMode: ColorMode.Palette,
+  bold: true,
+};
+const INACTIVE_NAME_ATTRS: CellAttrs = {
+  fg: 7,
+  fgMode: ColorMode.Palette,
+};
+const GROUP_HEADER_ATTRS: CellAttrs = {
+  fg: 8,
+  fgMode: ColorMode.Palette,
+  bold: true,
+};
+
+// --- Grouping logic ---
+
+interface SessionGroup {
+  label: string;
+  sessionIndices: number[];
+}
+
+function getParentLabel(dir: string): string | null {
+  const lastSlash = dir.lastIndexOf("/");
+  if (lastSlash <= 0) return null;
+  const parent = dir.slice(0, lastSlash);
+  const segments = parent.split("/").filter((s) => s.length > 0);
+  if (segments.length === 0) return null;
+  if (segments[0] === "~" && segments.length === 1) return null;
+  return segments.slice(-2).join("/");
+}
+
+type RenderItem =
+  | { type: "group-header"; label: string }
+  | { type: "session"; sessionIndex: number; grouped: boolean }
+  | { type: "spacer" };
+
+function buildRenderPlan(sessions: SessionInfo[]): {
+  items: RenderItem[];
+  displayOrder: number[];
+} {
+  const groupMap = new Map<string, number[]>();
+  const ungrouped: number[] = [];
+
+  for (let i = 0; i < sessions.length; i++) {
+    const dir = sessions[i].directory;
+    if (!dir) {
+      ungrouped.push(i);
+      continue;
+    }
+    const label = getParentLabel(dir);
+    if (!label) {
+      ungrouped.push(i);
+      continue;
+    }
+    const existing = groupMap.get(label);
+    if (existing) {
+      existing.push(i);
+    } else {
+      groupMap.set(label, [i]);
+    }
+  }
+
+  for (const [label, indices] of groupMap) {
+    if (indices.length === 1) {
+      ungrouped.push(indices[0]);
+      groupMap.delete(label);
+    }
+  }
+
+  const sortedGroups: SessionGroup[] = [...groupMap.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([label, indices]) => ({
+      label,
+      sessionIndices: indices.sort((a, b) =>
+        sessions[a].name.localeCompare(sessions[b].name),
+      ),
+    }));
+
+  ungrouped.sort((a, b) => sessions[a].name.localeCompare(sessions[b].name));
+
+  const items: RenderItem[] = [];
+  const displayOrder: number[] = [];
+
+  for (const group of sortedGroups) {
+    items.push({ type: "group-header", label: group.label });
+    for (const idx of group.sessionIndices) {
+      items.push({ type: "session", sessionIndex: idx, grouped: true });
+      displayOrder.push(idx);
+      items.push({ type: "spacer" });
+    }
+  }
+
+  for (const idx of ungrouped) {
+    items.push({ type: "session", sessionIndex: idx, grouped: false });
+    displayOrder.push(idx);
+    items.push({ type: "spacer" });
+  }
+
+  return { items, displayOrder };
+}
+
+// --- Sidebar class ---
+
+export class Sidebar {
+  private width: number;
+  private height: number;
+  private sessions: SessionInfo[] = [];
+  private activeSessionId: string | null = null;
+  private displayOrder: number[] = [];
+  private rowToSessionIndex = new Map<number, number>();
+  private activitySet = new Set<string>();
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+  }
+
+  updateSessions(sessions: SessionInfo[]): void {
+    this.sessions = sessions;
+    const { displayOrder } = buildRenderPlan(sessions);
+    this.displayOrder = displayOrder;
+  }
+
+  setActiveSession(id: string): void {
+    this.activeSessionId = id;
+  }
+
+  setActivity(sessionId: string, active: boolean): void {
+    if (active) {
+      this.activitySet.add(sessionId);
+    } else {
+      this.activitySet.delete(sessionId);
+    }
+  }
+
+  getDisplayOrderIds(): string[] {
+    return this.displayOrder
+      .map((idx) => this.sessions[idx]?.id)
+      .filter(Boolean) as string[];
+  }
+
+  getSessionByRow(row: number): SessionInfo | null {
+    const sessionIdx = this.rowToSessionIndex.get(row);
+    if (sessionIdx === undefined) return null;
+    return this.sessions[sessionIdx] ?? null;
+  }
+
+  resize(width: number, height: number): void {
+    this.width = width;
+    this.height = height;
+  }
+
+  getGrid(): CellGrid {
+    const grid = createGrid(this.width, this.height);
+    this.rowToSessionIndex.clear();
+
+    // Header
+    writeString(grid, 0, 1, "jmux", { ...ACCENT_ATTRS, bold: true });
+    writeString(grid, 1, 0, "\u2500".repeat(this.width), DIM_ATTRS);
+
+    const { items } = buildRenderPlan(this.sessions);
+    let row = HEADER_ROWS;
+
+    for (const item of items) {
+      if (row >= this.height) break;
+
+      if (item.type === "group-header") {
+        let label = item.label;
+        if (label.length > this.width - 2) {
+          label = label.slice(0, this.width - 3) + "\u2026";
+        }
+        writeString(grid, row, 1, label, GROUP_HEADER_ATTRS);
+        row++;
+        continue;
+      }
+
+      if (item.type === "spacer") {
+        row++;
+        continue;
+      }
+
+      const sessionIdx = item.sessionIndex;
+      const session = this.sessions[sessionIdx];
+      if (!session) continue;
+
+      const nameRow = row;
+      const detailRow = row + 1;
+      const isActive = session.id === this.activeSessionId;
+      const hasActivity = this.activitySet.has(session.id);
+
+      // Map rows to session for click handling
+      this.rowToSessionIndex.set(nameRow, sessionIdx);
+      if (detailRow < this.height) {
+        this.rowToSessionIndex.set(detailRow, sessionIdx);
+      }
+
+      // Active marker
+      if (isActive) {
+        writeString(grid, nameRow, 0, "\u258e", ACTIVE_MARKER_ATTRS);
+        if (detailRow < this.height) {
+          writeString(grid, detailRow, 0, "\u258e", ACTIVE_MARKER_ATTRS);
+        }
+      }
+
+      // Indicator
+      if (session.attention) {
+        writeString(grid, nameRow, 1, "!", ATTENTION_ATTRS);
+      } else if (hasActivity) {
+        writeString(grid, nameRow, 1, "\u25CF", ACTIVITY_ATTRS);
+      }
+
+      // Window count right-aligned
+      const windowCountStr = `${session.windowCount}w`;
+      const windowCountCol = this.width - windowCountStr.length - 1;
+
+      // Session name
+      const nameStart = 3;
+      const nameMaxLen = windowCountCol - 1 - nameStart;
+      let displayName = session.name;
+      if (displayName.length > nameMaxLen) {
+        displayName = displayName.slice(0, nameMaxLen - 1) + "\u2026";
+      }
+
+      const nameAttrs: CellAttrs = isActive
+        ? { ...ACTIVE_NAME_ATTRS }
+        : { ...INACTIVE_NAME_ATTRS };
+      writeString(grid, nameRow, nameStart, displayName, nameAttrs);
+
+      if (windowCountCol > nameStart) {
+        writeString(grid, nameRow, windowCountCol, windowCountStr, DIM_ATTRS);
+      }
+
+      // Detail line
+      if (detailRow < this.height) {
+        const detailStart = 3;
+
+        if (item.grouped) {
+          if (session.gitBranch) {
+            const branchCol = this.width - session.gitBranch.length - 1;
+            if (branchCol > detailStart) {
+              writeString(grid, detailRow, branchCol, session.gitBranch, DIM_ATTRS);
+            }
+          }
+        } else {
+          let branchCols = 0;
+          if (session.gitBranch) {
+            const branchCol = this.width - session.gitBranch.length - 1;
+            if (branchCol > detailStart + 1) {
+              writeString(grid, detailRow, branchCol, session.gitBranch, DIM_ATTRS);
+              branchCols = session.gitBranch.length + 2;
+            }
+          }
+          if (session.directory !== undefined) {
+            const dirMaxLen = this.width - detailStart - branchCols - 1;
+            let displayDir = session.directory;
+            if (displayDir.length > dirMaxLen) {
+              displayDir = displayDir.slice(0, dirMaxLen - 1) + "\u2026";
+            }
+            writeString(grid, detailRow, detailStart, displayDir, DIM_ATTRS);
+          }
+        }
+      }
+
+      row += 2;
+    }
+
+    return grid;
+  }
+}

package/src/tmux-control.ts

@@ -0,0 +1,223 @@
+import type { Subprocess } from "bun";
+
+// --- Protocol Parser (unit-testable) ---
+
+export type ControlEvent =
+  | { type: "sessions-changed" }
+  | { type: "session-changed"; args: string }
+  | { type: "window-renamed"; args: string }
+  | { type: "client-session-changed"; args: string }
+  | {
+      type: "subscription-changed";
+      name: string;
+      value: string;
+    }
+  | {
+      type: "response";
+      commandNumber: number;
+      flags: number;
+      lines: string[];
+    }
+  | {
+      type: "error";
+      commandNumber: number;
+      flags: number;
+      lines: string[];
+    };
+
+type EventListener = (event: ControlEvent) => void;
+
+export class ControlParser {
+  private buffer = "";
+  private listeners: EventListener[] = [];
+  private inBlock = false;
+  private blockCommandNumber = 0;
+  private blockFlags = 0;
+  private blockLines: string[] = [];
+
+  onEvent(listener: EventListener): void {
+    this.listeners.push(listener);
+  }
+
+  feed(data: string): void {
+    this.buffer += data;
+    let newlineIdx: number;
+    while ((newlineIdx = this.buffer.indexOf("\n")) !== -1) {
+      const line = this.buffer.slice(0, newlineIdx);
+      this.buffer = this.buffer.slice(newlineIdx + 1);
+      this.processLine(line);
+    }
+  }
+
+  private processLine(line: string): void {
+    if (this.inBlock) {
+      if (line.startsWith("%end ") || line.startsWith("%error ")) {
+        const isError = line.startsWith("%error ");
+        this.inBlock = false;
+        this.emit({
+          type: isError ? "error" : "response",
+          commandNumber: this.blockCommandNumber,
+          flags: this.blockFlags,
+          lines: this.blockLines,
+        });
+        this.blockLines = [];
+      } else {
+        this.blockLines.push(line);
+      }
+      return;
+    }
+
+    if (line.startsWith("%begin ")) {
+      const parts = line.split(" ");
+      this.blockCommandNumber = parseInt(parts[2], 10);
+      this.blockFlags = parseInt(parts[3], 10) || 0;
+      this.inBlock = true;
+      this.blockLines = [];
+      return;
+    }
+
+    if (line === "%sessions-changed") {
+      this.emit({ type: "sessions-changed" });
+    } else if (line.startsWith("%session-changed ")) {
+      this.emit({
+        type: "session-changed",
+        args: line.slice("%session-changed ".length),
+      });
+    } else if (line.startsWith("%window-renamed ")) {
+      this.emit({
+        type: "window-renamed",
+        args: line.slice("%window-renamed ".length),
+      });
+    } else if (line.startsWith("%client-session-changed ")) {
+      this.emit({
+        type: "client-session-changed",
+        args: line.slice("%client-session-changed ".length),
+      });
+    } else if (line.startsWith("%subscription-changed ")) {
+      const rest = line.slice("%subscription-changed ".length);
+      const spaceIdx = rest.indexOf(" ");
+      if (spaceIdx === -1) {
+        this.emit({
+          type: "subscription-changed",
+          name: rest,
+          value: "",
+        });
+      } else {
+        this.emit({
+          type: "subscription-changed",
+          name: rest.slice(0, spaceIdx),
+          value: rest.slice(spaceIdx + 1),
+        });
+      }
+    }
+    // Ignore unknown % lines (e.g. %output if not suppressed)
+  }
+
+  private emit(event: ControlEvent): void {
+    for (const listener of this.listeners) {
+      listener(event);
+    }
+  }
+}
+
+// --- Control Client (subprocess management) ---
+
+export class TmuxControl {
+  private proc: Subprocess | null = null;
+  private parser = new ControlParser();
+  // FIFO queue — tmux command numbers are global server counters,
+  // not sequential from 0. We match responses in order instead.
+  private pendingQueue: Array<{
+    resolve: (lines: string[]) => void;
+    reject: (err: Error) => void;
+  }> = [];
+
+  constructor() {
+    this.parser.onEvent((event) => {
+      if (event.type === "response" || event.type === "error") {
+        // flags=1 means this response is for a command sent by THIS client.
+        // flags=0 means it's from the initial attach or another client — skip it.
+        if (event.flags !== 1) return;
+
+        const pending = this.pendingQueue.shift();
+        if (pending) {
+          if (event.type === "error") {
+            pending.reject(new Error(event.lines.join("\n")));
+          } else {
+            pending.resolve(event.lines);
+          }
+        }
+      }
+    });
+  }
+
+  onEvent(listener: EventListener): void {
+    this.parser.onEvent(listener);
+  }
+
+  async start(opts?: { socketName?: string; configFile?: string }): Promise<void> {
+    const args = ["tmux"];
+    if (opts?.configFile) args.push("-f", opts.configFile);
+    if (opts?.socketName) args.push("-L", opts.socketName);
+    args.push("-C", "attach");
+    this.proc = Bun.spawn(args, {
+      stdin: "pipe",
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+
+    // Read stdout in background
+    this.readOutput();
+
+    // Suppress %output notifications
+    await this.sendCommand("refresh-client -f no-output");
+  }
+
+  private async readOutput(): Promise<void> {
+    if (!this.proc?.stdout) return;
+    const reader = this.proc.stdout.getReader();
+    const decoder = new TextDecoder();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        this.parser.feed(decoder.decode(value, { stream: true }));
+      }
+    } catch {
+      // Process exited
+    }
+  }
+
+  async sendCommand(cmd: string): Promise<string[]> {
+    if (!this.proc?.stdin) throw new Error("TmuxControl not started");
+    const promise = new Promise<string[]>((resolve, reject) => {
+      this.pendingQueue.push({ resolve, reject });
+    });
+    // Bun.spawn with stdin:"pipe" gives a FileSink, not a WritableStream
+    this.proc.stdin.write(cmd + "\n");
+    this.proc.stdin.flush();
+    return promise;
+  }
+
+  async registerSubscription(
+    name: string,
+    interval: number,
+    format: string,
+  ): Promise<void> {
+    await this.sendCommand(
+      `refresh-client -B "${name}:${interval}:${format}"`,
+    );
+  }
+
+  async close(): Promise<void> {
+    if (this.proc?.stdin) {
+      try {
+        this.proc.stdin.end();
+      } catch {
+        // Already closed
+      }
+    }
+    this.proc?.kill();
+    this.proc = null;
+  }
+}

package/src/tmux-pty.ts

@@ -0,0 +1,80 @@
+import { Terminal } from "bun-pty";
+
+export interface TmuxPtyOptions {
+  sessionName?: string;
+  socketName?: string;
+  configFile?: string;
+  jmuxDir?: string;
+  cols: number;
+  rows: number;
+}
+
+export class TmuxPty {
+  private pty: Terminal;
+  private _pid: number;
+  private dataListeners: Array<(data: string) => void> = [];
+  private exitListeners: Array<(code: number) => void> = [];
+
+  constructor(options: TmuxPtyOptions) {
+    const args: string[] = [];
+    if (options.configFile) {
+      args.push("-f", options.configFile);
+    }
+    if (options.socketName) {
+      args.push("-L", options.socketName);
+    }
+    args.push("new-session", "-A");
+    if (options.sessionName) {
+      args.push("-s", options.sessionName);
+    }
+
+    this.pty = new Terminal("tmux", args, {
+      name: "xterm-256color",
+      cols: options.cols,
+      rows: options.rows,
+      env: {
+        ...process.env,
+        TERM: "xterm-256color",
+        JMUX_DIR: options.jmuxDir || "",
+      },
+    });
+
+    this._pid = this.pty.pid;
+
+    this.pty.onData((data: string) => {
+      for (const listener of this.dataListeners) {
+        listener(data);
+      }
+    });
+
+    this.pty.onExit((event: { exitCode: number }) => {
+      for (const listener of this.exitListeners) {
+        listener(event.exitCode);
+      }
+    });
+  }
+
+  get pid(): number {
+    return this._pid;
+  }
+
+  onData(listener: (data: string) => void): void {
+    this.dataListeners.push(listener);
+  }
+
+  onExit(listener: (code: number) => void): void {
+    this.exitListeners.push(listener);
+  }
+
+  write(data: string): void {
+    this.pty.write(data);
+  }
+
+  resize(cols: number, rows: number): void {
+    this.pty.resize(cols, rows);
+  }
+
+  kill(): void {
+    this.pty.kill();
+  }
+}

package/src/types.ts

@@ -0,0 +1,39 @@
+export const enum ColorMode {
+  Default = 0,
+  Palette = 1,
+  RGB = 2,
+}
+
+export interface Cell {
+  char: string;
+  fg: number;
+  bg: number;
+  fgMode: ColorMode;
+  bgMode: ColorMode;
+  bold: boolean;
+  italic: boolean;
+  underline: boolean;
+  dim: boolean;
+}
+
+export interface CellGrid {
+  cols: number;
+  rows: number;
+  cells: Cell[][];
+}
+
+export interface CursorPosition {
+  x: number;
+  y: number;
+}
+
+export interface SessionInfo {
+  id: string;
+  name: string;
+  attached: boolean;
+  activity: number;
+  gitBranch?: string;
+  attention: boolean;
+  windowCount: number;
+  directory?: string;
+}