@towles/tool 0.0.107 → 0.0.108

package/plugins/tt-agentboard/packages/runtime/src/server/session-order.ts

@@ -0,0 +1,127 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+interface PersistedSessionOrder {
+  order?: unknown;
+  hidden?: unknown;
+}
+
+/**
+ * Maintains custom session ordering for reorder-session commands.
+ * Stores an ordered list of session names. The `apply` method takes
+ * the natural session list and returns it sorted by the custom order.
+ *
+ * When a `persistPath` is provided, the order is loaded from disk on
+ * construction and saved after every `reorder()` call.
+ */
+export class SessionOrder {
+  private order: string[] = [];
+  private hidden = new Set<string>();
+  private readonly persistPath: string | null;
+
+  constructor(persistPath?: string) {
+    this.persistPath = persistPath ?? null;
+    if (this.persistPath) {
+      try {
+        if (existsSync(this.persistPath)) {
+          const raw = readFileSync(this.persistPath, "utf-8");
+          const parsed = JSON.parse(raw);
+          if (Array.isArray(parsed)) {
+            this.order = parsed.filter((n): n is string => typeof n === "string");
+          } else if (parsed && typeof parsed === "object") {
+            const persisted = parsed as PersistedSessionOrder;
+            if (Array.isArray(persisted.order)) {
+              this.order = persisted.order.filter((n): n is string => typeof n === "string");
+            }
+            if (Array.isArray(persisted.hidden)) {
+              this.hidden = new Set(
+                persisted.hidden.filter((n): n is string => typeof n === "string"),
+              );
+            }
+          }
+        }
+      } catch {
+        // Ignore corrupt file — start fresh
+      }
+    }
+  }
+
+  /** Sync with current session names — adds new ones alphabetically, removes stale ones. */
+  sync(names: string[]): void {
+    const nameSet = new Set(names);
+    // Remove sessions that no longer exist
+    this.order = this.order.filter((n) => nameSet.has(n));
+    this.hidden = new Set([...this.hidden].filter((n) => nameSet.has(n)));
+    // Add new sessions in sorted position
+    const newNames = names
+      .filter((n) => !this.order.includes(n))
+      .sort((a, b) => a.localeCompare(b));
+    for (const n of newNames) {
+      // Insert alphabetically among existing entries
+      const idx = this.order.findIndex((existing) => existing.localeCompare(n) > 0);
+      if (idx === -1) {
+        this.order.push(n);
+      } else {
+        this.order.splice(idx, 0, n);
+      }
+    }
+  }
+
+  /** Move a session by delta (-1 = up, 1 = down). */
+  reorder(name: string, delta: -1 | 1): void {
+    const idx = this.order.indexOf(name);
+    if (idx === -1) return;
+    const newIdx = idx + delta;
+    if (newIdx < 0 || newIdx >= this.order.length) return;
+    // Swap
+    [this.order[idx], this.order[newIdx]] = [this.order[newIdx]!, this.order[idx]!];
+    this.save();
+  }
+
+  /** Hide a session from the panel without touching the underlying mux session. */
+  hide(name: string): void {
+    if (!this.order.includes(name) || this.hidden.has(name)) return;
+    this.hidden.add(name);
+    this.save();
+  }
+
+  /** Make a previously hidden session visible again. */
+  show(name: string): void {
+    if (!this.hidden.delete(name)) return;
+    if (!this.order.includes(name)) {
+      this.order.push(name);
+    }
+    this.save();
+  }
+
+  /** Restore all hidden sessions back into the panel. */
+  showAll(): void {
+    if (this.hidden.size === 0) return;
+    this.hidden.clear();
+    this.save();
+  }
+
+  /** Apply the custom order to a list of session names. Returns sorted names. */
+  apply(names: string[]): string[] {
+    const posMap = new Map(this.order.map((n, i) => [n, i]));
+    return names
+      .filter((n) => !this.hidden.has(n))
+      .sort((a, b) => {
+        const pa = posMap.get(a) ?? Infinity;
+        const pb = posMap.get(b) ?? Infinity;
+        return pa - pb;
+      });
+  }
+
+  private save(): void {
+    if (!this.persistPath) return;
+    try {
+      mkdirSync(dirname(this.persistPath), { recursive: true });
+      const serialized =
+        this.hidden.size === 0 ? this.order : { order: this.order, hidden: [...this.hidden] };
+      writeFileSync(this.persistPath, JSON.stringify(serialized) + "\n");
+    } catch {
+      // Best-effort — don't crash if write fails
+    }
+  }
+}

package/plugins/tt-agentboard/packages/runtime/src/server/sidebar-manager.ts

@@ -0,0 +1,232 @@
+import { debugLog } from "../debug";
+import { saveConfig } from "../config";
+import { resolveSidebarWidthFromResizeContext, snapshotSidebarWindows } from "./sidebar-width-sync";
+import type { SidebarResizeContext } from "./sidebar-width-sync";
+import type { ServerContext } from "./context";
+
+const SIDEBAR_PANE_CACHE_TTL = 300; // ms
+
+export function listSidebarPanesByProviderUncached(ctx: ServerContext) {
+  return ctx.getProvidersWithSidebar().map((provider) => ({
+    provider,
+    panes: provider.listSidebarPanes(),
+  }));
+}
+
+export function listSidebarPanesByProvider(ctx: ServerContext) {
+  const now = Date.now();
+  if (ctx.sidebarPaneCache && now - ctx.sidebarPaneCacheTs < SIDEBAR_PANE_CACHE_TTL)
+    return ctx.sidebarPaneCache;
+  ctx.sidebarPaneCache = listSidebarPanesByProviderUncached(ctx);
+  ctx.sidebarPaneCacheTs = now;
+  return ctx.sidebarPaneCache;
+}
+
+export function invalidateSidebarPaneCache(ctx: ServerContext): void {
+  ctx.sidebarPaneCache = null;
+  ctx.sidebarPaneCacheTs = 0;
+}
+
+export function scheduleSidebarResize(ctx: ServerContext, resizeCtx?: SidebarResizeContext): void {
+  resizeSidebars(ctx, resizeCtx);
+  if (ctx.pendingSidebarResize) clearTimeout(ctx.pendingSidebarResize);
+  ctx.pendingSidebarResize = setTimeout(() => {
+    ctx.pendingSidebarResize = null;
+    resizeSidebars(ctx);
+  }, 120);
+}
+
+export function toggleSidebar(
+  ctx: ServerContext,
+  toggleCtx?: { session: string; windowId: string },
+): void {
+  const providers = ctx.getProvidersWithSidebar();
+  if (providers.length === 0) {
+    debugLog("toggle", "SKIP — no providers with sidebar methods");
+    return;
+  }
+
+  invalidateSidebarPaneCache(ctx);
+  if (ctx.sidebarVisible) {
+    for (const p of providers) {
+      const panes = p.listSidebarPanes();
+      debugLog("toggle", "OFF — hiding panes", { provider: p.name, count: panes.length });
+      for (const pane of panes) {
+        p.hideSidebar(pane.paneId);
+      }
+    }
+    ctx.sidebarVisible = false;
+  } else {
+    ctx.sidebarVisible = true;
+    for (const p of providers) {
+      const allWindows = p.listActiveWindows();
+      debugLog("toggle", "ON — spawning in active windows", {
+        provider: p.name,
+        count: allWindows.length,
+      });
+      for (const w of allWindows) {
+        ensureSidebarInWindow(ctx, p, { session: w.sessionName, windowId: w.id });
+      }
+    }
+    scheduleSidebarResize(ctx);
+    ctx.server.publish("sidebar", JSON.stringify({ type: "re-identify" }));
+  }
+  debugLog("toggle", "done", { sidebarVisible: ctx.sidebarVisible });
+}
+
+export function ensureSidebarInWindow(
+  ctx: ServerContext,
+  provider?: ReturnType<ServerContext["getProvidersWithSidebar"]>[number],
+  windowCtx?: { session: string; windowId: string },
+): void {
+  const p =
+    provider ??
+    (() => {
+      const providers = ctx.getProvidersWithSidebar();
+      if (windowCtx?.session) {
+        const sessionProvider = ctx.sessionProviders.get(windowCtx.session);
+        return providers.find((pp) => pp === sessionProvider) ?? providers[0];
+      }
+      return providers[0];
+    })();
+  if (!p || !ctx.sidebarVisible) {
+    debugLog("ensure", "SKIP", { hasProvider: !!p, sidebarVisible: ctx.sidebarVisible });
+    return;
+  }
+
+  const curSession = windowCtx?.session ?? ctx.getCurrentSession();
+  if (!curSession) {
+    debugLog("ensure", "SKIP — no current session");
+    return;
+  }
+
+  const windowId = windowCtx?.windowId ?? p.getCurrentWindowId();
+  if (!windowId) {
+    debugLog("ensure", "SKIP — could not get window_id");
+    return;
+  }
+
+  const spawnKey = `${p.name}:${windowId}`;
+  if (ctx.pendingSidebarSpawns.has(spawnKey)) {
+    debugLog("ensure", "SKIP — spawn already in progress", {
+      curSession,
+      windowId,
+      provider: p.name,
+    });
+    return;
+  }
+
+  const allPanesByProvider = listSidebarPanesByProvider(ctx);
+  const providerEntry = allPanesByProvider.find((e) => e.provider === p);
+  const existingPanes = providerEntry?.panes ?? [];
+  const hasInWindow = existingPanes.some((ep) => ep.windowId === windowId);
+  debugLog("ensure", "checking window", {
+    curSession,
+    windowId,
+    existingPanes: existingPanes.length,
+    hasInWindow,
+    paneIds: existingPanes.map((x) => `${x.paneId}@${x.windowId}`),
+  });
+
+  if (!hasInWindow) {
+    invalidateSidebarPaneCache(ctx);
+    ctx.pendingSidebarSpawns.add(spawnKey);
+    debugLog("ensure", "SPAWNING sidebar", {
+      curSession,
+      windowId,
+      sidebarWidth: ctx.sidebarWidth,
+      sidebarPosition: ctx.sidebarPosition,
+    });
+    try {
+      const newPaneId = p.spawnSidebar(curSession, windowId, ctx.sidebarWidth, ctx.sidebarPosition);
+      debugLog("ensure", "spawn result", { newPaneId });
+    } finally {
+      ctx.pendingSidebarSpawns.delete(spawnKey);
+    }
+    scheduleSidebarResize(ctx);
+  }
+}
+
+export function debouncedEnsureSidebar(
+  ctx: ServerContext,
+  windowCtx?: { session: string; windowId: string },
+): void {
+  if (windowCtx) ctx.ensureSidebarPendingCtx = windowCtx;
+  if (ctx.ensureSidebarTimer) clearTimeout(ctx.ensureSidebarTimer);
+  ctx.ensureSidebarTimer = setTimeout(() => {
+    ctx.ensureSidebarTimer = null;
+    const nextCtx = ctx.ensureSidebarPendingCtx;
+    ctx.ensureSidebarPendingCtx = undefined;
+    ensureSidebarInWindow(ctx, undefined, nextCtx);
+  }, 150);
+}
+
+export function quitAll(ctx: ServerContext): void {
+  debugLog("quit", "killing all sidebar panes");
+  for (const p of ctx.getProvidersWithSidebar()) {
+    const panes = p.listSidebarPanes();
+    debugLog("quit", "found panes to kill", { provider: p.name, count: panes.length });
+    for (const pane of panes) {
+      p.killSidebarPane(pane.paneId);
+    }
+  }
+  for (const p of ctx.getProvidersWithSidebar()) {
+    p.cleanupSidebar();
+  }
+  ctx.server.publish("sidebar", JSON.stringify({ type: "quit" }));
+  ctx.sidebarVisible = false;
+  ctx.cleanup();
+  process.exit(0);
+}
+
+export function resizeSidebars(ctx: ServerContext, resizeCtx?: SidebarResizeContext): void {
+  const panesByProvider = listSidebarPanesByProvider(ctx);
+  const allPanes = panesByProvider.flatMap(({ panes }) => panes);
+
+  if (allPanes.length === 0) {
+    ctx.sidebarSnapshots = new Map();
+    return;
+  }
+
+  const nextSidebarWidth = resolveSidebarWidthFromResizeContext({
+    ctx: resizeCtx,
+    panes: allPanes,
+    previousByWindow: ctx.sidebarSnapshots,
+    suppressedByPane: ctx.suppressedSidebarResizeAcks,
+  });
+
+  if (nextSidebarWidth != null && nextSidebarWidth !== ctx.sidebarWidth) {
+    ctx.sidebarWidth = nextSidebarWidth;
+    saveConfig({ sidebarWidth: ctx.sidebarWidth });
+    debugLog("resize", "adopted sidebar width from pane resize", {
+      paneId: resizeCtx?.paneId ?? null,
+      sessionName: resizeCtx?.sessionName ?? null,
+      windowId: resizeCtx?.windowId ?? null,
+      sidebarWidth: ctx.sidebarWidth,
+    });
+    ctx.broadcastState();
+  }
+
+  const now = Date.now();
+  for (const { provider, panes } of panesByProvider) {
+    debugLog("resize", "enforcing width on all panes", {
+      provider: provider.name,
+      sidebarWidth: ctx.sidebarWidth,
+      count: panes.length,
+      triggerPaneId: resizeCtx?.paneId ?? null,
+    });
+    for (const pane of panes) {
+      if (pane.width === ctx.sidebarWidth) continue;
+      ctx.suppressedSidebarResizeAcks.set(pane.paneId, {
+        width: ctx.sidebarWidth,
+        expiresAt: now + 1_000,
+      });
+      provider.resizeSidebarPane(pane.paneId, ctx.sidebarWidth);
+    }
+  }
+
+  if (panesByProvider.some(({ panes }) => panes.some((pane) => pane.width !== ctx.sidebarWidth))) {
+    invalidateSidebarPaneCache(ctx);
+  }
+  ctx.sidebarSnapshots = snapshotSidebarWindows(allPanes);
+}

package/plugins/tt-agentboard/packages/runtime/src/server/sidebar-width-sync.ts

@@ -0,0 +1,66 @@
+import type { SidebarPane } from "../contracts/mux";
+
+export interface SidebarResizeContext {
+  paneId?: string;
+  sessionName?: string;
+  windowId?: string;
+  width?: number;
+  windowWidth?: number;
+}
+
+export interface SidebarWindowSnapshot {
+  width?: number;
+  windowWidth?: number;
+}
+
+export interface SidebarResizeSuppression {
+  width: number;
+  expiresAt: number;
+}
+
+export function snapshotSidebarWindows(panes: SidebarPane[]): Map<string, SidebarWindowSnapshot> {
+  const snapshots = new Map<string, SidebarWindowSnapshot>();
+  for (const pane of panes) {
+    snapshots.set(pane.windowId, {
+      width: pane.width,
+      windowWidth: pane.windowWidth,
+    });
+  }
+  return snapshots;
+}
+
+export function resolveSidebarWidthFromResizeContext(params: {
+  ctx?: SidebarResizeContext;
+  panes: SidebarPane[];
+  previousByWindow: Map<string, SidebarWindowSnapshot>;
+  suppressedByPane: Map<string, SidebarResizeSuppression>;
+  now?: number;
+}): number | null {
+  const { ctx, panes, previousByWindow, suppressedByPane, now = Date.now() } = params;
+  if (!ctx?.paneId) return null;
+
+  const pane = panes.find((candidate) => candidate.paneId === ctx.paneId);
+  if (!pane) return null;
+
+  const width = ctx.width ?? pane.width;
+  const windowWidth = ctx.windowWidth ?? pane.windowWidth;
+  if (width == null || windowWidth == null) return null;
+
+  const suppressed = suppressedByPane.get(pane.paneId);
+  if (suppressed) {
+    if (suppressed.width === width && suppressed.expiresAt >= now) {
+      suppressedByPane.delete(pane.paneId);
+      return null;
+    }
+    if (suppressed.expiresAt < now || suppressed.width !== width) {
+      suppressedByPane.delete(pane.paneId);
+    }
+  }
+
+  const previous = previousByWindow.get(pane.windowId);
+  if (!previous || previous.width == null || previous.windowWidth == null) return null;
+  if (previous.windowWidth !== windowWidth) return null;
+  if (previous.width === width) return null;
+
+  return width;
+}

package/plugins/tt-agentboard/packages/runtime/src/shared.ts

@@ -0,0 +1,179 @@
+import type { AgentStatus, AgentEvent } from "./contracts/agent";
+
+export const SERVER_PORT = 4201;
+export const SERVER_HOST = "127.0.0.1";
+export const PID_FILE = "/tmp/agentboard.pid";
+export const SERVER_IDLE_TIMEOUT_MS = 30_000;
+export const STUCK_RUNNING_TIMEOUT_MS = 3 * 60 * 1000;
+
+export interface SessionData {
+  name: string;
+  createdAt: number;
+  dir: string;
+  branch: string;
+  dirty: boolean;
+  isWorktree: boolean;
+  filesChanged: number;
+  linesAdded: number;
+  linesRemoved: number;
+  commitsDelta: number;
+  unseen: boolean;
+  panes: number;
+  ports: number[];
+  windows: number;
+  uptime: string;
+  agentState: AgentEvent | null;
+  agents: AgentEvent[];
+  eventTimestamps: number[];
+  metadata?: SessionMetadata | null;
+}
+
+export interface ServerState {
+  type: "state";
+  sessions: SessionData[];
+  focusedSession: string | null;
+  currentSession: string | null;
+  theme: string | undefined;
+  sidebarWidth: number;
+  ts: number;
+}
+
+export interface FocusUpdate {
+  type: "focus";
+  focusedSession: string | null;
+  currentSession: string | null;
+}
+
+export interface ResizeNotify {
+  type: "resize";
+  width: number;
+}
+
+export interface QuitNotify {
+  type: "quit";
+}
+
+export interface YourSession {
+  type: "your-session";
+  name: string;
+  clientTty: string | null;
+}
+
+export interface ReIdentify {
+  type: "re-identify";
+}
+
+export type ServerMessage =
+  | ServerState
+  | FocusUpdate
+  | ResizeNotify
+  | QuitNotify
+  | YourSession
+  | ReIdentify;
+
+// --- Programmatic metadata (agent/script-pushed) ---
+
+export type MetadataTone = "neutral" | "info" | "success" | "warn" | "error";
+
+export interface MetadataStatus {
+  text: string;
+  tone?: MetadataTone;
+  ts: number;
+}
+
+export interface MetadataProgress {
+  current?: number;
+  total?: number;
+  percent?: number;
+  label?: string;
+  ts: number;
+}
+
+export interface MetadataLogEntry {
+  message: string;
+  tone?: MetadataTone;
+  source?: string;
+  ts: number;
+}
+
+export interface SessionMetadata {
+  status: MetadataStatus | null;
+  progress: MetadataProgress | null;
+  logs: MetadataLogEntry[];
+}
+
+export type ClientCommand =
+  | { type: "switch-session"; name: string; clientTty?: string }
+  | { type: "switch-index"; index: number }
+  | { type: "new-session" }
+  | { type: "hide-session"; name: string }
+  | { type: "show-all-sessions" }
+  | { type: "kill-session"; name: string }
+  | { type: "reorder-session"; name: string; delta: -1 | 1 }
+  | { type: "refresh" }
+  | { type: "move-focus"; delta: -1 | 1 }
+  | { type: "focus-session"; name: string }
+  | { type: "mark-seen"; name: string }
+  | { type: "dismiss-agent"; session: string; agent: string; threadId?: string }
+  | { type: "set-theme"; theme: string }
+  | { type: "identify"; clientTty: string }
+  | { type: "report-width"; width: number }
+  | { type: "quit" }
+  | { type: "identify-pane"; paneId: string; sessionName: string }
+  | {
+      type: "focus-agent-pane";
+      session: string;
+      agent: string;
+      threadId?: string;
+      threadName?: string;
+    }
+  | {
+      type: "kill-agent-pane";
+      session: string;
+      agent: string;
+      threadId?: string;
+      threadName?: string;
+    };
+
+// Catppuccin Mocha palette
+export const C = {
+  blue: "#89b4fa",
+  lavender: "#b4befe",
+  pink: "#cba6f7",
+  mauve: "#cba6f7",
+  yellow: "#f9e2af",
+  green: "#a6e3a1",
+  red: "#f38ba8",
+  peach: "#fab387",
+  teal: "#94e2d5",
+  sky: "#89dceb",
+  text: "#cdd6f4",
+  subtext0: "#a6adc8",
+  subtext1: "#bac2de",
+  overlay0: "#6c7086",
+  overlay1: "#7f849c",
+  surface0: "#313244",
+  surface1: "#45475a",
+  surface2: "#585b70",
+  base: "#1e1e2e",
+  mantle: "#181825",
+  crust: "#11111b",
+} as const;
+
+export const STATUS_COLORS: Record<AgentStatus, string> = {
+  idle: C.surface2,
+  running: C.yellow,
+  done: C.green,
+  error: C.red,
+  waiting: C.blue,
+  interrupted: C.peach,
+};
+
+export const STATUS_ICONS: Record<AgentStatus, string> = {
+  idle: "○",
+  running: "●",
+  done: "✓",
+  error: "✗",
+  waiting: "◉",
+  interrupted: "⚠",
+};