tuiboard 0.11.0 → 0.13.0

package/src/config/loader.ts

@@ -19,6 +19,7 @@ import { dirname, isAbsolute, join, resolve } from "node:path";
 import * as YAML from "js-yaml";
 
 import { isBoardFile } from "~/boards/scan";
+import { LAUNCHERS, SHELLS, type Launcher, type Shell } from "~/input/open-session";
 
 export interface BoardConfig {
   /** Path to the .md file, absolute or relative to the config directory. */
@@ -38,20 +39,39 @@ export interface Config {
   archiveColumn: string;
   /**
    * Optional override for "open the selected agent session" (Enter in the
-   * agents zone). An argv array; the tokens `{cwd}` and `{sessionId}` are
-   * substituted, then it's spawned directly (no shell). Point it at your own
+   * agents zone). An argv array; the tokens `{cwd}`, `{sessionId}` and
+   * `{resume}` (the agent's own resume command, e.g. `claude --resume <id>`)
+   * are substituted, then it's spawned directly (no shell). Point it at your own
    * script to launch a custom terminal layout — e.g.
    *   ["pwsh", "-NoProfile", "-File", "C:/.../code-resume.ps1", "{cwd}", "{sessionId}"]
-   * When unset, tuiboard falls back to opening a tab + `claude --resume <id>`.
+   * When unset, tuiboard falls back to opening a tab + the agent's resume command.
    */
   resumeCommand?: string[];
+  /**
+   * Terminal Enter opens sessions in (config `resume_terminal`). `auto`
+   * detects it from the environment; set one explicitly when detection
+   * guesses wrong. Ignored when `resumeCommand` is set.
+   */
+  resumeTerminal: "auto" | Launcher;
+  /**
+   * Shell the resumed session runs in (config `resume_shell`). `auto` = the
+   * shell tuiboard was started from (Git Bash / Nushell / PowerShell on
+   * Windows, `$SHELL` elsewhere). Ignored when `resumeCommand` is set.
+   */
+  resumeShell: "auto" | Shell;
+  /**
+   * Agent status glyphs (config `status_indicators`): `symbols` (default —
+   * the same × ◐ ✓ ○ · herdr uses) or `dots` (● ○ ·).
+   */
+  statusIndicators: "dots" | "symbols";
   /**
    * Template for the shell command copied to the clipboard by `c` in the agents
    * zone — one paste that `cd`s into the session's directory and resumes it.
-   * The tokens `{cwd}` and `{sessionId}` are substituted. Default:
-   *   cd "{cwd}" && claude --resume {sessionId}
+   * The tokens `{cwd}`, `{sessionId}` and `{resume}` (the agent's own resume
+   * command, e.g. `claude --resume <id>`) are substituted. Default:
+   *   cd "{cwd}" && {resume}
    * `&&` works in bash/zsh/pwsh/cmd; Nushell users may prefer
-   *   cd "{cwd}"; claude --resume {sessionId}
+   *   cd "{cwd}"; {resume}
    */
   copyResumeCommand: string;
   /**
@@ -118,12 +138,15 @@ export interface CalendarsConfig {
  * paste. `&&` chains in bash/zsh/pwsh/cmd (Nushell users override with `;`).
  */
 export const DEFAULT_COPY_RESUME_COMMAND =
-  'cd "{cwd}" && claude --resume {sessionId}';
+  'cd "{cwd}" && {resume}';
 
 export const DEFAULT_CONFIG: Omit<Config, "root" | "loaded" | "boards"> = {
   assignees: [],
   doneColumn: "Done",
   archiveColumn: "Archive",
+  resumeTerminal: "auto",
+  resumeShell: "auto",
+  statusIndicators: "symbols",
   copyResumeCommand: DEFAULT_COPY_RESUME_COMMAND,
   zones: { planner: "on", agenda: "on", agents: "on" },
 };
@@ -197,6 +220,9 @@ interface RawConfig {
   done_column: string;
   archive_column: string;
   resume_command: string[];
+  resume_terminal: string;
+  resume_shell: string;
+  status_indicators: string;
   copy_resume_command: string;
   calendars: {
     google?: {
@@ -342,6 +368,13 @@ function normalize(raw: Partial<RawConfig>, root: string, loaded: boolean): Conf
       Array.isArray(raw.resume_command) && raw.resume_command.length > 0
         ? raw.resume_command.map(String)
         : undefined,
+    resumeTerminal: (LAUNCHERS as readonly string[]).includes(raw.resume_terminal ?? "")
+      ? (raw.resume_terminal as Launcher)
+      : "auto",
+    resumeShell: (SHELLS as readonly string[]).includes(raw.resume_shell ?? "")
+      ? (raw.resume_shell as Shell)
+      : "auto",
+    statusIndicators: raw.status_indicators === "dots" ? "dots" : "symbols",
     copyResumeCommand:
       typeof raw.copy_resume_command === "string" &&
       raw.copy_resume_command.trim().length > 0

package/src/input/handleKey.ts

@@ -13,7 +13,19 @@
  * shares the same input contract.
  */
 
+import { quitApp } from "~/app-exit";
 import { isHiddenColumn } from "~/config/loader";
+import {
+  LAUNCHER_NAME,
+  describePlan,
+  detectLauncher,
+  planLaunch,
+  runLaunchPlan,
+  systemLaunchEnv,
+} from "~/input/open-session";
+import { planHerdrFocus, planHerdrResume } from "~/input/herdr-open";
+import { HARNESS, type AgentSession } from "~/store/agents";
+import { herdrBin, herdrPlace } from "~/store/herdr";
 import { googleTokenCanWrite } from "~/store/calendar";
 import { isTask } from "~/parser/markdown";
 import {
@@ -126,7 +138,7 @@ export function handleKey(
 
   // Quit
   if (key.name === "q" || (key.ctrl && key.name === "c")) {
-    store.dispose().finally(() => process.exit(0));
+    void quitApp(() => store.dispose());
     return;
   }
 
@@ -227,6 +239,13 @@ export function handleKey(
   // Cycle the board filter — affects which open tasks show up in board
   // columns. Mirrors Python kanban `action_cycle_filter`. Cycle order:
   // all → today → overdue → tomorrow → followup → all.
+  // In the Agents zone `f` filters sessions by harness instead.
+  if (key.name === "f" && ui.activeZone === "agents") {
+    const next = store.cycleAgentsFilter();
+    const label = next === "all" ? "all harnesses" : `${HARNESS[next].code} · ${HARNESS[next].name}`;
+    store.flashBanner("info", `Agents: ${label}`);
+    return;
+  }
   if (key.name === "f") {
     const cycle = ["all", "today", "overdue", "tomorrow", "followup"] as const;
     const idx = cycle.indexOf(ui.filter);
@@ -477,24 +496,31 @@ function handleTimelineZone(
 
 function handleAgentsZone(store: TuiStore, key: KeyEvent): void {
   const ui = store.state.ui;
-  const sessions = store.agents.sessions();
+  const sessions = store.agentSessions();
   if (key.name === "j" || key.name === "down") {
     store.setCursor(0, Math.min(sessions.length - 1, ui.row + 1));
   } else if (key.name === "k" || key.name === "up") {
     store.setCursor(0, Math.max(0, ui.row - 1));
+  } else if (key.name === "H" || (key.name === "h" && key.shift)) {
+    // Jump to the session in herdr, or resume it there.
+    const target = sessions[ui.row];
+    if (target) void openInHerdr(store, target);
   } else if (key.name === "enter" || key.name === "return") {
-    // Open (resume) the selected session in a new WezTerm tab.
+    // Open (resume) the selected session in a new terminal tab/window —
+    // or, when it's already open in herdr, go there instead of a second copy.
     const target = sessions[ui.row];
-    if (target) void openSessionInWezterm(store, target.cwd, target.sessionId);
+    if (target?.herdr) void openInHerdr(store, target);
+    else if (target) void openSession(store, target);
   } else if (key.name === "c") {
     // Copy a one-paste "cd + resume" command for the selected session, so you
     // can drop it into any tab/pane anywhere and land in the right directory
-    // resuming the right session (no WezTerm dependency, unlike Enter).
+    // resuming the right session (works in any terminal, unlike Enter).
     const target = sessions[ui.row];
     if (target) {
       const cmd = store.config.copyResumeCommand
         .replaceAll("{cwd}", target.cwd)
-        .replaceAll("{sessionId}", target.sessionId);
+        .replaceAll("{sessionId}", target.sessionId)
+        .replaceAll("{resume}", target.resumeCommand);
       copyToClipboard(cmd).then(
         () => store.flashBanner("info", `📋 Copied resume command (${target.sessionId.slice(0, 8)})`),
         (err) => store.flashBanner("error", `Copy failed: ${err}`),
@@ -867,33 +893,26 @@ function fmtHm(m: number): string {
 }
 
 /**
- * Open (resume) a Claude Code session in a new WezTerm tab.
- *
- * Two steps:
- *   1. `wezterm cli spawn --cwd <cwd>` opens a new tab running your DEFAULT
- *      shell in the session's directory (prints the new pane id).
- *   2. `wezterm cli send-text` types `claude --resume <id>` + Enter into it.
- *
- * Running it through the interactive shell (rather than `spawn -- claude …`
- * directly) means `claude` gets your full shell environment — PATH, env vars,
- * any wrapper — which is why the direct form exited 1. And if `claude` still
- * errors, you're left at a live prompt that shows it instead of a vanishing
- * tab. Failures (not inside WezTerm, `wezterm` off PATH) surface as a banner.
+ * Open (resume) an agent session in a new tab/window of the terminal tuiboard
+ * runs in — tmux, herdr, WezTerm, Windows Terminal, Ghostty, or the OS default
+ * — inside the user's shell (see open-session.ts). Config `resume_terminal` /
+ * `resume_shell` force them. When nothing can open it, the resume command lands
+ * on the clipboard instead. The outcome is kept for the session's detail modal.
  */
-async function openSessionInWezterm(
-  store: TuiStore,
-  cwd: string,
-  sessionId: string,
-): Promise<void> {
-  const { spawn, spawnSync } = await import("node:child_process");
+async function openSession(store: TuiStore, session: AgentSession): Promise<void> {
+  const { spawn } = await import("node:child_process");
+  const { cwd, sessionId } = session;
 
   // Custom override (config `resume_command`): an argv array with {cwd} /
-  // {sessionId} placeholders, spawned directly (no shell). Lets you launch a
-  // personal terminal layout without baking it into the distributed tool.
+  // {sessionId} / {resume} placeholders, spawned directly (no shell). Lets you
+  // launch a personal terminal layout without baking it into the distributed tool.
   const custom = store.config.resumeCommand;
   if (custom && custom.length > 0) {
     const argv = custom.map((arg) =>
-      arg.replaceAll("{cwd}", cwd).replaceAll("{sessionId}", sessionId),
+      arg
+        .replaceAll("{cwd}", cwd)
+        .replaceAll("{sessionId}", sessionId)
+        .replaceAll("{resume}", session.resumeCommand),
     );
     const [cmd, ...rest] = argv;
     try {
@@ -909,39 +928,83 @@ async function openSessionInWezterm(
         store.flashBanner("error", `resume_command failed: ${e.message}`),
       );
       child.unref();
-      store.flashBanner("info", `↗ Opening session (${sessionId.slice(0, 8)})`);
+      store.flashBanner("info", `↗ Opening session via resume_command (${sessionId.slice(0, 8)})`);
     } catch (e) {
       store.flashBanner("error", `resume_command failed: ${String(e)}`);
     }
     return;
   }
 
-  try {
-    const spawned = spawnSync("wezterm", ["cli", "spawn", "--cwd", cwd], {
-      encoding: "utf8",
-      windowsHide: true,
-    });
-    if (spawned.error) {
-      store.flashBanner("error", `WezTerm launch failed: ${spawned.error.message}`);
-      return;
-    }
-    if (spawned.status !== 0) {
-      store.flashBanner(
-        "error",
-        `WezTerm spawn failed: ${(spawned.stderr || "").trim() || `exit ${spawned.status}`}`,
-      );
-      return;
-    }
-    const paneId = spawned.stdout.trim();
-    // Type the resume command into the fresh pane (\r submits, like Enter).
-    spawnSync(
-      "wezterm",
-      ["cli", "send-text", "--pane-id", paneId, "--no-paste"],
-      { input: `claude --resume ${sessionId}\r`, encoding: "utf8", windowsHide: true },
+  const launchEnv = systemLaunchEnv();
+  const forced = store.config.resumeTerminal;
+  const launcher = forced === "auto" ? detectLauncher(launchEnv) : forced;
+  const fail = async (why: string) => {
+    const copied = await copyToClipboard(session.resumeCommand).then(
+      () => true,
+      () => false,
     );
-    store.flashBanner("info", `↗ Opened session in WezTerm (${sessionId.slice(0, 8)})`);
+    const text = copied ? `${why} — resume command copied, paste it in ${cwd}` : why;
+    store.setLastLaunch(sessionId, false, text);
+    store.flashBanner(copied ? "warn" : "error", text);
+  };
+
+  if (!launcher) {
+    await fail("No supported terminal detected (set resume_terminal)");
+    return;
+  }
+  const plan = planLaunch(
+    launcher,
+    { cwd, resume: session.resumeCommand, shell: store.config.resumeShell },
+    launchEnv,
+  );
+  try {
+    await runLaunchPlan(plan);
+    const text = `↗ Opened session in ${LAUNCHER_NAME[launcher]} (${sessionId.slice(0, 8)})`;
+    store.setLastLaunch(sessionId, true, `${text}\n${describePlan(plan)}`);
+    store.flashBanner("info", text);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    await fail(`${LAUNCHER_NAME[launcher]} launch failed: ${msg}`);
+  }
+}
+
+/**
+ * `H` in the Agents zone: focus the herdr pane the session is open in, or
+ * resume it in herdr — a new tab in the workspace that holds its project,
+ * started with `herdr agent start` (see herdr-open.ts).
+ */
+async function openInHerdr(store: TuiStore, session: AgentSession): Promise<void> {
+  const bin = herdrBin();
+  const snap = store.agents.herdr();
+  const { sessionId } = session;
+  if (!bin || !snap) {
+    const text = bin ? "herdr isn't running" : "herdr isn't installed (https://herdr.dev)";
+    store.setLastLaunch(sessionId, false, text);
+    store.flashBanner("warn", text);
+    return;
+  }
+  let steps;
+  let done: string;
+  if (session.herdr) {
+    steps = planHerdrFocus(bin, session);
+    done = `↗ ${herdrPlace(session.herdr)}`;
+  } else {
+    const plan = planHerdrResume(bin, session, snap);
+    steps = plan.steps;
+    done =
+      plan.where.kind === "new"
+        ? `↗ Resumed in a new herdr workspace "${plan.where.label}"`
+        : `↗ Resumed in herdr ${plan.where.label}`;
+    store.flashBanner("info", `Starting ${HARNESS[session.provider].name} in herdr…`);
+  }
+  try {
+    await runLaunchPlan(steps);
+    store.setLastLaunch(sessionId, true, `${done}\n${describePlan(steps)}`);
+    store.flashBanner("info", `${done} (${sessionId.slice(0, 8)})`);
   } catch (e) {
-    store.flashBanner("error", `WezTerm launch failed: ${String(e)}`);
+    const text = `herdr: ${e instanceof Error ? e.message : String(e)}`;
+    store.setLastLaunch(sessionId, false, text);
+    store.flashBanner("error", text);
   }
 }
 

package/src/input/herdr-open.ts

@@ -0,0 +1,132 @@
+/**
+ * Open agent sessions inside herdr (the `H` key, and Enter for sessions
+ * already open there): focus the pane a session lives in, or resume it in a
+ * new tab of the workspace that holds its project, started through
+ * `herdr agent start` so herdr tracks it as an agent from the first second.
+ *
+ * Planning is pure; the steps run through `runLaunchPlan`.
+ */
+
+import { basename } from "node:path";
+
+import type { LaunchStep } from "~/input/open-session";
+import type { AgentSession } from "~/store/agents";
+import { HERDR_AGENT, samePath, type HerdrSnapshot } from "~/store/herdr";
+
+/** Focus the herdr pane a session is open in. */
+export function planHerdrFocus(bin: string, session: AgentSession): LaunchStep[] {
+  if (!session.herdr) throw new Error("session isn't open in herdr");
+  return [{ cmd: bin, args: ["agent", "focus", session.herdr.paneId] }];
+}
+
+export type WorkspaceChoice =
+  | { kind: "existing"; workspaceId: string; label: string; why: "cwd" | "name" | "focused" }
+  | { kind: "new"; label: string };
+
+/**
+ * Where a session should open: the workspace already holding a pane in its
+ * directory, else one named like the directory, else the focused one — or a
+ * new workspace named after the directory when herdr has none.
+ */
+export function chooseWorkspace(snap: HerdrSnapshot, cwd: string): WorkspaceChoice {
+  const label = (id: string) => snap.workspaces.get(id)?.label ?? id;
+  const byCwd = snap.panes.find((p) => p.workspaceId && samePath(p.cwd, cwd));
+  if (byCwd) return { kind: "existing", workspaceId: byCwd.workspaceId, label: label(byCwd.workspaceId), why: "cwd" };
+  const folder = basename(cwd.replaceAll("\\", "/")).toLowerCase();
+  for (const [id, w] of snap.workspaces) {
+    if (folder && w.label.toLowerCase() === folder) return { kind: "existing", workspaceId: id, label: w.label, why: "name" };
+  }
+  const focused = snap.focusedWorkspaceId ?? [...snap.workspaces.keys()][0];
+  if (focused) return { kind: "existing", workspaceId: focused, label: label(focused), why: "focused" };
+  return { kind: "new", label: basename(cwd.replaceAll("\\", "/")) || "agents" };
+}
+
+/** Pane id from a `tab create` / `workspace create` response. */
+function rootPaneId(out: string): string | undefined {
+  try {
+    const r = JSON.parse(out)?.result;
+    return r?.root_pane?.pane_id ?? r?.pane?.pane_id ?? r?.tab?.root_pane?.pane_id;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Tab titles: short, single line. */
+function tabLabel(name: string): string {
+  const line = name.split("\n")[0]!.trim();
+  return line.length > 32 ? `${line.slice(0, 31).trimEnd()}…` : line || "agent";
+}
+
+/**
+ * herdr agent names: lowercase letter first, then `[a-z0-9_-]`, ≤ 32 chars.
+ * Title slug + short session id, so two sessions with the same title differ.
+ */
+export function herdrAgentName(title: string, sessionId: string, fallback: string): string {
+  const id = sessionId.toLowerCase().replace(/[^a-z0-9]/g, "").slice(-6);
+  const slug = title
+    .split("\n")[0]!
+    .toLowerCase()
+    .normalize("NFKD")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^[^a-z]+/, "")
+    .replace(/-+$/, "")
+    .slice(0, 32 - id.length - 1)
+    .replace(/-+$/, "");
+  return `${slug || fallback}-${id}`.slice(0, 32);
+}
+
+/**
+ * Resume a session in herdr: new tab (or workspace) in the session's
+ * directory, then start the agent there.
+ *
+ * POSIX: `herdr agent start --kind <agent> -- <resume args>`, so herdr tracks
+ * it from the first second. Windows: herdr launches the agent's executable
+ * directly, which fails for npm-installed CLIs (codex, opencode, pi are an
+ * extensionless sh shim next to `.cmd`/`.ps1` — "not a valid Win32
+ * application"), so the resume command is typed into the pane's shell
+ * instead (`herdr pane run`), which resolves it through PATHEXT; herdr still
+ * detects the agent from the running process.
+ */
+export function planHerdrResume(
+  bin: string,
+  session: AgentSession,
+  snap: HerdrSnapshot,
+  platform: NodeJS.Platform = process.platform,
+): { steps: LaunchStep[]; where: WorkspaceChoice } {
+  const where = chooseWorkspace(snap, session.cwd);
+  const label = tabLabel(session.displayName);
+  const create: LaunchStep =
+    where.kind === "existing"
+      ? {
+          cmd: bin,
+          args: ["tab", "create", "--workspace", where.workspaceId, "--cwd", session.cwd, "--label", label, "--focus"],
+          captureId: rootPaneId,
+          undo: { cmd: bin, args: ["pane", "close", "{id}"] },
+        }
+      : {
+          cmd: bin,
+          args: ["workspace", "create", "--cwd", session.cwd, "--label", where.label, "--focus"],
+          captureId: rootPaneId,
+          undo: { cmd: bin, args: ["pane", "close", "{id}"] },
+        };
+  if (platform === "win32") {
+    return {
+      steps: [create, { cmd: bin, args: ["pane", "run", "{id}", session.resumeCommand] }],
+      where,
+    };
+  }
+  const [, ...agentArgs] = session.resumeArgv;
+  const start: LaunchStep = {
+    cmd: bin,
+    args: [
+      "agent", "start", herdrAgentName(session.displayName, session.sessionId, HERDR_AGENT[session.provider]),
+      "--kind", HERDR_AGENT[session.provider],
+      "--pane", "{id}",
+      "--timeout", "30000",
+      "--", ...agentArgs,
+    ],
+    // herdr waits for the agent to be ready (up to the --timeout above).
+    timeoutMs: 40_000,
+  };
+  return { steps: [create, start], where };
+}