tmux-ide 2.1.5 → 2.6.1

package/packages/daemon/src/tui/team/input.ts

@@ -0,0 +1,34 @@
+/**
+ * Char-input reducer for the team TUI's inline text prompts (e.g. the
+ * register-dir input). Kept pure and separate from `index.tsx` — which runs
+ * `render(...)` on import — so it can be unit-tested in isolation.
+ *
+ * `return`/`escape` are handled by the caller; this only covers the two
+ * text-editing keys. Returns the next value, or `null` when the key isn't a
+ * printable char or backspace (so the caller can ignore it).
+ */
+export interface InputKey {
+  name: string;
+  ctrl?: boolean;
+  alt?: boolean;
+  meta?: boolean;
+}
+
+export function nextInput(prev: string, evt: InputKey): string | null {
+  if (evt.name === "backspace") return prev.slice(0, -1);
+  if (evt.name.length === 1 && !evt.ctrl && !evt.alt && !evt.meta) return prev + evt.name;
+  return null;
+}
+
+/**
+ * Suggest a tmux session name based on `base`, appending a numeric suffix
+ * (`-2`, `-3`, …) until `exists` reports the name free. Used by the team TUI's
+ * new-session prompt to avoid colliding with a live session.
+ */
+export function suggestSessionName(base: string, exists: (name: string) => boolean): string {
+  if (!exists(base)) return base;
+  for (let n = 2; ; n++) {
+    const candidate = `${base}-${n}`;
+    if (!exists(candidate)) return candidate;
+  }
+}

package/packages/daemon/src/tui/team/keymap.ts

@@ -0,0 +1,127 @@
+/**
+ * Central, configurable keymap for the team TUI.
+ *
+ * `DEFAULT_KEYMAP` holds the built-in bindings; `mergeKeymap`/`resolveAction`
+ * are pure so they can be reasoned about (and tested) without io. `loadKeymap`
+ * is the thin io wrapper that reads `~/.tmux-ide/team-keys.json` overrides and
+ * falls back to the defaults on any error.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export type ActionId =
+  | "up"
+  | "down"
+  | "enter"
+  | "launch"
+  | "new"
+  | "rename"
+  | "split"
+  | "register"
+  | "unregister"
+  | "kill"
+  | "filter"
+  | "refresh"
+  | "help"
+  | "quit";
+
+export interface KeyBinding {
+  keys: string[];
+  description: string;
+}
+
+/** Deterministic action order — drives `resolveAction` iteration + help listing. */
+export const ACTION_ORDER: ActionId[] = [
+  "up",
+  "down",
+  "enter",
+  "launch",
+  "new",
+  "rename",
+  "split",
+  "register",
+  "unregister",
+  "kill",
+  "filter",
+  "refresh",
+  "help",
+  "quit",
+];
+
+export const DEFAULT_KEYMAP: Record<ActionId, KeyBinding> = {
+  up: { keys: ["up", "k"], description: "move up" },
+  down: { keys: ["down", "j"], description: "move down" },
+  enter: { keys: ["return"], description: "launch / attach" },
+  launch: { keys: ["l"], description: "launch project" },
+  new: { keys: ["n"], description: "new session" },
+  rename: { keys: ["R"], description: "rename session" },
+  split: { keys: ["s"], description: "split pane" },
+  register: { keys: ["a"], description: "add project" },
+  unregister: { keys: ["d"], description: "unregister project" },
+  kill: { keys: ["x"], description: "kill (confirm)" },
+  filter: { keys: ["/"], description: "fuzzy filter" },
+  refresh: { keys: ["r"], description: "refresh" },
+  help: { keys: ["?"], description: "toggle help" },
+  quit: { keys: ["q"], description: "quit" },
+};
+
+/** Deep-copy a single binding so callers can't mutate the shared defaults. */
+function cloneBinding(binding: KeyBinding): KeyBinding {
+  return { keys: [...binding.keys], description: binding.description };
+}
+
+/**
+ * Return a copy of `DEFAULT_KEYMAP` with `keys` replaced for any action present
+ * in `overrides` (descriptions are always kept from the defaults). Unknown
+ * action ids in `overrides` are ignored. Pure — never touches the filesystem.
+ */
+export function mergeKeymap(
+  overrides: Partial<Record<ActionId, string[]>> | undefined,
+): Record<ActionId, KeyBinding> {
+  const merged = {} as Record<ActionId, KeyBinding>;
+  for (const action of ACTION_ORDER) {
+    merged[action] = cloneBinding(DEFAULT_KEYMAP[action]);
+  }
+  if (!overrides) return merged;
+  for (const action of ACTION_ORDER) {
+    const keys = overrides[action];
+    if (keys && Array.isArray(keys)) {
+      merged[action] = { keys: [...keys], description: DEFAULT_KEYMAP[action].description };
+    }
+  }
+  return merged;
+}
+
+/**
+ * Read `~/.tmux-ide/team-keys.json` overrides (JSON of `{ actionId: [key,…] }`)
+ * and merge them onto the defaults. Any error — missing file, bad JSON, wrong
+ * shape — falls back to `DEFAULT_KEYMAP`.
+ */
+export function loadKeymap(): Record<ActionId, KeyBinding> {
+  try {
+    const path = join(homedir(), ".tmux-ide", "team-keys.json");
+    if (!existsSync(path)) return mergeKeymap(undefined);
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw) as unknown;
+    if (!parsed || typeof parsed !== "object") return mergeKeymap(undefined);
+    return mergeKeymap(parsed as Partial<Record<ActionId, string[]>>);
+  } catch {
+    return mergeKeymap(undefined);
+  }
+}
+
+/**
+ * Resolve a pressed key name to the first `ActionId` whose binding includes it,
+ * iterating in `ACTION_ORDER` for determinism. Returns null when unbound.
+ */
+export function resolveAction(
+  keymap: Record<ActionId, KeyBinding>,
+  keyName: string,
+): ActionId | null {
+  for (const action of ACTION_ORDER) {
+    if (keymap[action].keys.includes(keyName)) return action;
+  }
+  return null;
+}

package/packages/daemon/src/tui/team/mouse.ts

@@ -0,0 +1,29 @@
+/**
+ * Mouse helpers for the team TUI. Kept pure and separate from `index.tsx` —
+ * which runs `render(...)` on import — so the double-click logic can be
+ * unit-tested in isolation.
+ */
+
+/** A recorded click: which row index, and when (ms epoch). */
+export interface ClickRecord {
+  index: number;
+  at: number;
+}
+
+/** Default window in which a second click on the same row counts as a double. */
+export const DOUBLE_CLICK_MS = 400;
+
+/**
+ * A click at `index`/`now` is a double-click when the previous click was on the
+ * SAME row and landed within `thresholdMs`. `prev === null` (no prior click) is
+ * never a double-click.
+ */
+export function isDoubleClick(
+  prev: ClickRecord | null,
+  index: number,
+  now: number,
+  thresholdMs: number = DOUBLE_CLICK_MS,
+): boolean {
+  if (!prev) return false;
+  return prev.index === index && now - prev.at <= thresholdMs;
+}

package/packages/daemon/src/tui/team/nav.ts

@@ -0,0 +1,31 @@
+/**
+ * Index arithmetic for the team TUI's app-shell navigation. Kept pure and
+ * separate from `index.tsx` — which runs `render(...)` on import — so the
+ * project/session cursor maths can be unit-tested in isolation.
+ *
+ * The shell tracks two cursors: the active PROJECT (into the visible project
+ * list) and the active SESSION (into that project's sessions). Both need the
+ * same two operations — clamp an index after the underlying list changes under
+ * a refresh, and wrap it as the user pages up/down.
+ */
+
+/**
+ * Clamp `i` into `[0, len - 1]`. An empty (or negative-length) list clamps to
+ * `0` so a cursor never dangles past the end after a refresh shrinks the list.
+ */
+export function clampIndex(i: number, len: number): number {
+  if (len <= 0) return 0;
+  if (i < 0) return 0;
+  if (i >= len) return len - 1;
+  return i;
+}
+
+/**
+ * Move `i` by `delta` within a list of `len`, wrapping around both ends (so
+ * up from the top lands on the bottom and vice versa). An empty list yields
+ * `0`. `delta` may be any integer.
+ */
+export function wrapIndex(i: number, delta: number, len: number): number {
+  if (len <= 0) return 0;
+  return (((i + delta) % len) + len) % len;
+}

package/packages/daemon/src/tui/team/preview.ts

@@ -0,0 +1,34 @@
+/**
+ * Pure text shaping for the team TUI live-preview pane.
+ *
+ * The preview mirrors a session's active pane (captured via tmux). This helper
+ * takes the raw capture and shapes it to fit the preview region: keep the tail
+ * of the output, drop the trailing blank lines tmux leaves behind, and clip
+ * each line to the column budget so nothing wraps chaotically.
+ */
+
+/**
+ * Shape raw captured pane text into a bounded list of lines.
+ *
+ * - Splits on "\n".
+ * - Drops trailing blank/whitespace-only lines (internal blanks are kept).
+ * - Returns the LAST `maxLines` lines.
+ * - Truncates each line to `maxWidth` chars; `maxWidth <= 0` skips truncation.
+ *
+ * Never throws. Empty or whitespace-only input yields `[]`.
+ */
+export function previewLines(raw: string, maxLines: number, maxWidth: number): string[] {
+  if (!raw) return [];
+  const lines = raw.split("\n");
+  // Drop trailing empty/whitespace lines, keeping internal blanks intact.
+  let end = lines.length;
+  while (end > 0 && lines[end - 1]!.trim() === "") end--;
+  if (end === 0) return [];
+
+  const limit = maxLines > 0 ? maxLines : 0;
+  const start = limit > 0 ? Math.max(0, end - limit) : 0;
+  const tail = lines.slice(start, end);
+
+  if (maxWidth <= 0) return tail;
+  return tail.map((line) => (line.length > maxWidth ? line.slice(0, maxWidth) : line));
+}

package/packages/daemon/src/tui/team/projects.ts

@@ -0,0 +1,191 @@
+/**
+ * Project-level data layer for the team TUI.
+ *
+ * Where `sessions.ts` enumerates the LIVE tmux sessions, this module lifts
+ * that list into the two-level PROJECT model the TUI actually navigates:
+ * every registered project appears (even with no running session), with its
+ * live sessions nested underneath. Live sessions that don't belong to any
+ * registered project surface as ad-hoc projects so nothing is hidden.
+ *
+ * The grouping is a PURE function (`groupSessions`) so it can be tested
+ * without touching tmux or the on-disk registry; `listTeamProjects` is the
+ * thin io wrapper that feeds it real data and never throws.
+ */
+import { getSessionCwd } from "@tmux-ide/tmux-bridge";
+import type { AgentStatus, StatusTracker } from "../detect/classify.ts";
+import { listProjects } from "../../lib/project-registry.ts";
+import {
+  listTeamSessions,
+  rollupStatus,
+  type ListTeamSessionsOpts,
+  type TeamSession,
+} from "./sessions.ts";
+
+export interface TeamProject {
+  name: string;
+  dir: string | null;
+  hasIdeYml: boolean;
+  gitBranch: string | null;
+  /** True when the project comes from the registry (vs. an ad-hoc session). */
+  registered: boolean;
+  /** True when at least one live tmux session maps to this project. */
+  running: boolean;
+  status: AgentStatus;
+  sessions: TeamSession[];
+}
+
+/** The plain project shape `groupSessions` needs — a subset of RegisteredProject. */
+export interface ProjectInput {
+  name: string;
+  dir: string;
+  hasIdeYml?: boolean;
+  gitBranch?: string | null;
+}
+
+/**
+ * Normalize a directory for prefix comparison. Strips a trailing slash so
+ * `/a/b` and `/a/b/` compare equal, but keeps the root `/` intact.
+ */
+function normalizeDir(dir: string): string {
+  if (dir.length > 1 && dir.endsWith("/")) return dir.slice(0, -1);
+  return dir;
+}
+
+/**
+ * Whether `cwd` is `dir` itself or nested inside it. Trailing-slash aware so
+ * `/a/bee` is NOT considered inside `/a/b`.
+ */
+function isInside(cwd: string, dir: string): boolean {
+  const base = normalizeDir(dir);
+  const path = normalizeDir(cwd);
+  if (path === base) return true;
+  return path.startsWith(base === "/" ? "/" : `${base}/`);
+}
+
+/**
+ * Group live sessions under registered projects.
+ *
+ * Each session is assigned to at most one project: a name match wins first,
+ * then a cwd match (the session's `pane_current_path` equalling or nested
+ * inside the project's `dir`); when several projects' dirs prefix the same
+ * cwd, the longest (most specific) dir wins. Every registered project appears
+ * — with an empty `sessions` list and `running:false` when nothing matched.
+ * Any session left unmatched becomes an ad-hoc project.
+ *
+ * PURE: takes a `sessionCwd` resolver so tests can supply a fake map.
+ */
+export function groupSessions(
+  projectsIn: ProjectInput[],
+  sessionsIn: TeamSession[],
+  sessionCwd: (name: string) => string | null,
+): TeamProject[] {
+  // Hide INTERNAL plumbing from the whole team model (bar + switcher): the
+  // host shell (`_tmux-ide`) and any `_`-prefixed scratch session/project.
+  // Mirrors `isInternalName` in ../chrome/statusline.ts (kept inline to avoid a
+  // dependency cycle — statusline.ts imports TeamProject from here).
+  const projects = projectsIn.filter((p) => !p.name.startsWith("_"));
+  const sessions = sessionsIn.filter((s) => !s.name.startsWith("_"));
+
+  const buckets = new Map<string, TeamSession[]>();
+  for (const p of projects) buckets.set(p.name, []);
+
+  const matched = new Set<TeamSession>();
+
+  // Pass 1 — name matches take precedence.
+  const byName = new Map(projects.map((p) => [p.name, p]));
+  for (const session of sessions) {
+    if (byName.has(session.name)) {
+      buckets.get(session.name)!.push(session);
+      matched.add(session);
+    }
+  }
+
+  // Pass 2 — cwd matches for whatever's left; longest dir wins.
+  for (const session of sessions) {
+    if (matched.has(session)) continue;
+    const cwd = sessionCwd(session.name);
+    if (!cwd) continue;
+    let best: ProjectInput | undefined;
+    for (const p of projects) {
+      if (!isInside(cwd, p.dir)) continue;
+      if (!best || normalizeDir(p.dir).length > normalizeDir(best.dir).length) best = p;
+    }
+    if (best) {
+      buckets.get(best.name)!.push(session);
+      matched.add(session);
+    }
+  }
+
+  const registered: TeamProject[] = projects
+    .slice()
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map((p) => {
+      const own = buckets.get(p.name) ?? [];
+      return {
+        name: p.name,
+        dir: p.dir,
+        hasIdeYml: p.hasIdeYml ?? false,
+        gitBranch: p.gitBranch ?? null,
+        registered: true,
+        running: own.length > 0,
+        status: rollupStatus(own.map((s) => s.status)),
+        sessions: own,
+      };
+    });
+
+  // Ad-hoc projects: live sessions that matched no registered project.
+  const adhoc: TeamProject[] = sessions
+    .filter((s) => !matched.has(s))
+    .map((s) => ({
+      name: s.name,
+      dir: sessionCwd(s.name) ?? null,
+      hasIdeYml: false,
+      gitBranch: null,
+      registered: false,
+      running: true,
+      status: rollupStatus([s.status]),
+      sessions: [s],
+    }));
+
+  return [...registered, ...adhoc];
+}
+
+/**
+ * Assemble the two-level project view from the live registry + tmux.
+ *
+ * Wraps the registry and tmux reads so any failure degrades to a sane partial
+ * (an empty registry, or empty sessions) rather than throwing at the TUI.
+ *
+ * @param opts.viewed Forwarded to {@link listTeamSessions} to acknowledge the
+ *   currently-attached session's pending `done`.
+ * @param opts.onPane Forwarded to {@link listTeamSessions} so a caller (the
+ *   chrome updater) can collect per-pane detail during the same scan.
+ */
+export function listTeamProjects(
+  tracker: StatusTracker,
+  opts: Pick<ListTeamSessionsOpts, "viewed" | "onPane"> = {},
+): TeamProject[] {
+  let projects: ProjectInput[];
+  try {
+    projects = listProjects();
+  } catch {
+    projects = [];
+  }
+
+  let sessions: TeamSession[];
+  try {
+    sessions = listTeamSessions(tracker, opts);
+  } catch {
+    sessions = [];
+  }
+
+  const cwd = (name: string): string | null => {
+    try {
+      return getSessionCwd(name);
+    } catch {
+      return null;
+    }
+  };
+
+  return groupSessions(projects, sessions, cwd);
+}

package/packages/daemon/src/tui/team/report.ts

@@ -0,0 +1,73 @@
+/**
+ * Serialization + lookup for the team control API.
+ *
+ * The team TUI's data layer (`projects.ts` / `sessions.ts`) produces the rich
+ * `TeamProject` / `TeamSession` models the cockpit navigates. This module is
+ * the CLI-facing counterpart: two PURE functions that shape that model into a
+ * stable JSON contract (`tmux-ide team --json`) and answer a single-session
+ * status lookup (`tmux-ide wait agent-status`). Kept OpenTUI-free so the CLI
+ * can import it without pulling in the renderer.
+ */
+import type { AgentStatus } from "../detect/classify.ts";
+import type { TeamProject } from "./projects.ts";
+import type { TeamSession } from "./sessions.ts";
+
+/** The stable JSON shape emitted by `tmux-ide team --json`. */
+export interface FleetJson {
+  projects: Array<{
+    name: string;
+    dir: string | null;
+    registered: boolean;
+    running: boolean;
+    status: AgentStatus;
+    sessions: Array<{
+      name: string;
+      status: AgentStatus;
+      panes: number;
+      attached: boolean;
+      windows: Array<{
+        index: number;
+        name: string;
+        active: boolean;
+        panes: number;
+        status: AgentStatus;
+      }>;
+    }>;
+  }>;
+}
+
+/** Map the rich project model to the plain JSON contract — PURE. */
+export function toFleetJson(projects: TeamProject[]): FleetJson {
+  return {
+    projects: projects.map((p) => ({
+      name: p.name,
+      dir: p.dir,
+      registered: p.registered,
+      running: p.running,
+      status: p.status,
+      sessions: p.sessions.map((s) => ({
+        name: s.name,
+        status: s.status,
+        panes: s.panes,
+        attached: s.attached,
+        windows: (s.windowList ?? []).map((w) => ({
+          index: w.index,
+          name: w.name,
+          active: w.active,
+          panes: w.panes,
+          status: w.status,
+        })),
+      })),
+    })),
+  };
+}
+
+/**
+ * Look up a single session's status by name — PURE. Returns the status of the
+ * matching session, or `null` when no session by that name is present (it may
+ * not exist yet, which `wait` treats as "keep polling").
+ */
+export function findSessionStatus(sessions: TeamSession[], name: string): AgentStatus | null {
+  const match = sessions.find((s) => s.name === name);
+  return match ? match.status : null;
+}