@towles/tool 0.0.111 → 0.0.113

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@towles/tool",
-  "version": "0.0.111",
+  "version": "0.0.113",
   "description": "One off quality of life scripts that I use on a daily basis.",
   "homepage": "https://github.com/ChrisTowles/towles-tool#readme",
   "bugs": {

package/packages/agentboard/apps/tui/src/components/SessionCard.tsx

@@ -33,6 +33,7 @@ export function SessionCard(props: SessionCardProps) {
     if (s === "error") return P().red;
     if (s === "interrupted") return P().peach;
     if (s === "running") return P().yellow;
+    if (s === "waiting") return P().blue;
     if (props.isFocused) return P().lavender;
     return "transparent";
   };
@@ -47,6 +48,7 @@ export function SessionCard(props: SessionCardProps) {
   const statusIcon = () => {
     const s = status();
     if (s === "running") return SPINNERS[props.spinIdx() % SPINNERS.length]!;
+    if (s === "waiting") return "◉";
     if (isUnseenTerminal()) return UNSEEN_ICON;
     return "";
   };

package/packages/agentboard/apps/tui/src/index.tsx

@@ -110,6 +110,16 @@ function App() {
   const [modal, setModal] = createSignal<"none" | "confirm-kill" | "help">("none");
   const [killTarget, setKillTarget] = createSignal<string | null>(null);
 
+  // --- Transient toast (footer) ---
+  type ToastTone = "error" | "info" | "success";
+  const [toast, setToast] = createSignal<{ message: string; tone: ToastTone } | null>(null);
+  let toastTimer: ReturnType<typeof setTimeout> | null = null;
+  function showToast(message: string, tone: ToastTone = "info") {
+    setToast({ message, tone });
+    if (toastTimer) clearTimeout(toastTimer);
+    toastTimer = setTimeout(() => setToast(null), 4000);
+  }
+
   const [clientTty, setClientTty] = createSignal(getClientTty(muxCtx));
   let ws: WebSocket | null = null;
   let startupFocusSynced = false;
@@ -119,8 +129,14 @@ function App() {
 
   const focusedData = createMemo(() => sessions.find((s) => s.name === focusedSession()) ?? null);
 
-  function send(cmd: ClientCommand) {
-    if (connected() && ws) ws.send(JSON.stringify(cmd));
+  function send(cmd: ClientCommand, successMsg?: string): boolean {
+    if (connected() && ws) {
+      ws.send(JSON.stringify(cmd));
+      if (successMsg) showToast(successMsg, "success");
+      return true;
+    }
+    showToast("not connected to agentboard server", "error");
+    return false;
   }
 
   function switchToSession(name: string) {
@@ -180,13 +196,16 @@ function App() {
         "/tmp/agentboard-tui-agent-click.log",
         `[${new Date().toISOString()}] keyboard focus-agent-pane session=${data.name} agent=${agent.agent} threadId=${agent.threadId} threadName=${agent.threadName}\n`,
       );
-    send({
-      type: "focus-agent-pane",
-      session: data.name,
-      agent: agent.agent,
-      threadId: agent.threadId,
-      threadName: agent.threadName,
-    });
+    send(
+      {
+        type: "focus-agent-pane",
+        session: data.name,
+        agent: agent.agent,
+        threadId: agent.threadId,
+        threadName: agent.threadName,
+      },
+      `focusing ${agent.agent}`,
+    );
   }
 
   function dismissFocusedAgent() {
@@ -194,17 +213,13 @@ function App() {
     const agents = data?.agents ?? [];
     const agent = agents[focusedAgentIdx()];
     if (!agent || !data) return;
-    send({
-      type: "dismiss-agent",
-      session: data.name,
-      agent: agent.agent,
-      threadId: agent.threadId,
-    });
-    // Adjust index if we dismissed the last item
+    send(
+      { type: "dismiss-agent", session: data.name, agent: agent.agent, threadId: agent.threadId },
+      `dismissed ${agent.agent}`,
+    );
     if (focusedAgentIdx() >= agents.length - 1 && agents.length > 1) {
       setFocusedAgentIdx(agents.length - 2);
     }
-    // If no agents left, go back to sessions
     if (agents.length <= 1) setPanelFocus("sessions");
   }
 
@@ -213,13 +228,16 @@ function App() {
     const agents = data?.agents ?? [];
     const agent = agents[focusedAgentIdx()];
     if (!agent || !data) return;
-    send({
-      type: "kill-agent-pane",
-      session: data.name,
-      agent: agent.agent,
-      threadId: agent.threadId,
-      threadName: agent.threadName,
-    });
+    send(
+      {
+        type: "kill-agent-pane",
+        session: data.name,
+        agent: agent.agent,
+        threadId: agent.threadId,
+        threadName: agent.threadName,
+      },
+      `killed ${agent.agent} pane`,
+    );
   }
 
   function beginDetailResize(event: MouseEvent) {
@@ -311,11 +329,27 @@ function App() {
     const data = focusedData();
     if (!data?.dir) return;
     const editor = preferredEditor();
-    Bun.spawn([editor, data.dir], {
-      stdout: "ignore",
-      stderr: "ignore",
-      stdin: "ignore",
-    });
+    try {
+      const proc = Bun.spawn([editor, data.dir], {
+        stdout: "ignore",
+        stderr: "ignore",
+        stdin: "ignore",
+      });
+      showToast(`opening ${data.dir} in ${editor}`, "success");
+      void proc.exited.then((code) => {
+        if (code !== 0) {
+          logResizeDebug("openInEditor failed", { editor, dir: data.dir, code });
+          showToast(`failed to open editor "${editor}" (exit ${code})`, "error");
+        }
+      });
+    } catch (err) {
+      logResizeDebug("openInEditor spawn threw", {
+        editor,
+        dir: data.dir,
+        error: String(err),
+      });
+      showToast(`failed to spawn editor "${editor}": ${String(err)}`, "error");
+    }
   }
 
   onMount(() => {
@@ -340,6 +374,7 @@ function App() {
     const refocusTimeout = setTimeout(doStartupRefocus, 2000);
 
     onCleanup(() => {
+      if (toastTimer) clearTimeout(toastTimer);
       clearTimeout(refocusTimeout);
       renderer.removeListener("capabilities", doStartupRefocus);
     });
@@ -460,7 +495,7 @@ function App() {
     if (currentModal === "confirm-kill") {
       if (key.name === "y") {
         const target = killTarget();
-        if (target) send({ type: "kill-session", name: target });
+        if (target) send({ type: "kill-session", name: target }, `killed ${target}`);
         setKillTarget(null);
         setModal("none");
       } else {
@@ -541,20 +576,11 @@ function App() {
         break;
       }
       case "r":
-        send({ type: "refresh" });
+        send({ type: "refresh" }, "refreshing sessions");
         break;
-      case "u":
-        send({ type: "show-all-sessions" });
+      case "d":
+        if (panelFocus() === "agents") dismissFocusedAgent();
         break;
-      case "d": {
-        if (panelFocus() === "agents") {
-          dismissFocusedAgent();
-        } else {
-          const focused = focusedSession();
-          if (focused) send({ type: "hide-session", name: focused });
-        }
-        break;
-      }
       case "x": {
         if (panelFocus() === "agents") {
           killFocusedAgentPane();
@@ -682,6 +708,20 @@ function App() {
         <box height={1}>
           <text style={{ fg: P().surface2 }}>{DIVIDER}</text>
         </box>
+        <Show when={toast()}>
+          {(t) => (
+            <box height={1}>
+              <text
+                style={{
+                  fg:
+                    t().tone === "error" ? P().red : t().tone === "success" ? P().green : P().blue,
+                }}
+              >
+                {t().message}
+              </text>
+            </box>
+          )}
+        </Show>
         <Show
           when={panelFocus() === "sessions"}
           fallback={
@@ -700,11 +740,10 @@ function App() {
             palette={P}
             hints={[
               ["⇥", "cycle"],
-              ["⏎", "go"],
-              ["→", "select"],
+              ["⏎", "switch"],
+              ["→", "agents"],
               ["n", "new"],
               ["e", "edit"],
-              ["d", "hide"],
               ["x", "kill"],
               ["r", "refresh"],
               ["q", "quit"],
@@ -768,11 +807,9 @@ const HELP_KEYS: [string, string][] = [
   ["Tab", "Cycle sessions"],
   ["n", "New session"],
   ["e", "Open in editor"],
-  ["d", "Hide session"],
   ["x", "Kill session"],
   ["r", "Refresh"],
-  ["u", "Show all sessions"],
-  ["→/l", "Select panel"],
+  ["→/l", "Agents panel"],
   ["←/h/Esc", "Back to sessions"],
   ["Alt+↑↓", "Reorder sessions"],
   ["q", "Quit"],

package/packages/agentboard/packages/runtime/src/agents/watchers/claude-code.test.ts

@@ -2,13 +2,13 @@ import { describe, it, expect } from "bun:test";
 import { determineStatus } from "./claude-code";
 
 describe("determineStatus", () => {
-  it('returns "idle" when no message', () => {
-    expect(determineStatus({})).toBe("idle");
-    expect(determineStatus({ message: undefined })).toBe("idle");
+  it("returns null when no message", () => {
+    expect(determineStatus({})).toBeNull();
+    expect(determineStatus({ message: undefined })).toBeNull();
   });
 
-  it('returns "idle" when message has no role', () => {
-    expect(determineStatus({ message: { content: "hi" } })).toBe("idle");
+  it("returns null when message has no role", () => {
+    expect(determineStatus({ message: { content: "hi" } })).toBeNull();
   });
 
   it('returns "running" for user messages', () => {
@@ -53,11 +53,11 @@ describe("determineStatus", () => {
     ).toBe("done");
   });
 
-  it('returns "idle" for unknown roles', () => {
+  it("returns null for unknown roles", () => {
     expect(
       determineStatus({
         message: { role: "system", content: "system message" },
       }),
-    ).toBe("idle");
+    ).toBeNull();
   });
 });

package/packages/agentboard/packages/runtime/src/agents/watchers/claude-code.ts

@@ -47,9 +47,9 @@ const STALE_MS = 5 * 60 * 1000;
 
 // --- Status detection ---
 
-export function determineStatus(entry: JournalEntry): AgentStatus {
+export function determineStatus(entry: JournalEntry): AgentStatus | null {
   const msg = entry.message;
-  if (!msg?.role) return "idle";
+  if (!msg?.role) return null;
 
   const content = msg.content;
   const items: ContentItem[] = Array.isArray(content)
@@ -59,13 +59,16 @@ export function determineStatus(entry: JournalEntry): AgentStatus {
       : [];
 
   if (msg.role === "assistant") {
-    const hasToolUse = items.some((c) => c.type === "tool_use");
-    return hasToolUse ? "running" : "done";
+    const toolUses = items.filter((c) => c.type === "tool_use");
+    if (toolUses.length === 0) return "done";
+    // AskUserQuestion means the agent is waiting for user input, not running
+    const allWaiting = toolUses.every((c) => (c as any).name === "AskUserQuestion");
+    return allWaiting ? "waiting" : "running";
   }
 
   if (msg.role === "user") return "running";
 
-  return "idle";
+  return null;
 }
 
 function extractThreadName(entry: JournalEntry): string | undefined {
@@ -195,7 +198,7 @@ export class ClaudeCodeAgentWatcher implements AgentWatcher {
           const name = extractThreadName(entry);
           if (name) threadName = name;
         }
-        latestStatus = determineStatus(entry);
+        latestStatus = determineStatus(entry) ?? latestStatus;
       }
 
       // If "running" but journal file is stale, the process likely exited
@@ -238,7 +241,7 @@ export class ClaudeCodeAgentWatcher implements AgentWatcher {
         if (name) threadName = name;
       }
 
-      latestStatus = determineStatus(entry);
+      latestStatus = determineStatus(entry) ?? latestStatus;
     }
 
     const prevStatus = prev?.status;

package/packages/agentboard/packages/runtime/src/server/index.ts

@@ -187,6 +187,22 @@ export function startServer(
     return null;
   }
 
+  /** If any pane agent is alive for this session, override terminal agentState to waiting. */
+  function overrideTerminalIfPaneAlive(
+    sessionName: string,
+    state: AgentEvent | null,
+  ): AgentEvent | null {
+    if (!state || !TERMINAL_STATUSES.has(state.status)) return state;
+    const paneAgents = paneAgentsBySession.get(sessionName);
+    if (!paneAgents || paneAgents.size === 0) return state;
+    for (const presence of paneAgents.values()) {
+      if (presence.agent === state.agent && presence.threadId === state.threadId) {
+        return { ...state, status: "waiting" };
+      }
+    }
+    return state;
+  }
+
   /** Merge pane-detected agents into watcher-provided agents for a session.
    *  Watcher events take precedence — pane presence only adds synthetic entries
    *  for agents that aren't already tracked by watchers. */
@@ -205,12 +221,11 @@ export function startServer(
       const trackedIdx = trackedByKey.get(key);
 
       if (trackedIdx != null) {
-        // Watcher already tracks this agent — correct terminal statuses
-        // using pane liveness (process is confirmed alive, so terminal
-        // journal status is a between-turn artifact).
+        // Watcher already tracks this agent — process is confirmed alive,
+        // so terminal journal status means it's waiting for user input.
         const tracked = result[trackedIdx]!;
         if (TERMINAL_STATUSES.has(tracked.status)) {
-          tracked.status = "running";
+          tracked.status = "waiting";
           tracked.paneId = presence.paneId;
         }
         continue;
@@ -248,13 +263,8 @@ export function startServer(
       return a.name.localeCompare(b.name);
     });
 
-    const currentSession = getCurrentSession();
-
     // Sync custom ordering with current session list
     sessionOrder.sync(allMuxSessions.map((s) => s.name));
-    if (currentSession) {
-      sessionOrder.show(currentSession);
-    }
 
     // Apply custom ordering
     const orderedNames = sessionOrder.apply(allMuxSessions.map((s) => s.name));
@@ -303,7 +313,7 @@ export function startServer(
           ports: getSessionPorts(name),
           windows,
           uptime,
-          agentState: tracker.getState(name),
+          agentState: overrideTerminalIfPaneAlive(name, tracker.getState(name)),
           agents: mergeAgentsWithPanePresence(name, tracker.getAgents(name)),
           eventTimestamps: tracker.getEventTimestamps(name),
           metadata: metadataStore.get(name),
@@ -1084,8 +1094,12 @@ export function startServer(
       const data = JSON.parse(readFileSync(join(sessionsDir, `${agentPid}.json`), "utf-8"));
       const threadId: string | undefined = data.sessionId;
       if (!threadId) return {};
-      // Try to get thread name and status from the journal
       const journalInfo = resolveClaudeCodeJournalInfo(threadId);
+      // Process is alive (found via process tree), so terminal journal status
+      // means it's waiting for user input.
+      if (journalInfo.status && TERMINAL_STATUSES.has(journalInfo.status)) {
+        journalInfo.status = "waiting";
+      }
       return { threadId, ...journalInfo };
     } catch {
       return {};
@@ -1124,10 +1138,16 @@ export function startServer(
                 if (t && !t.startsWith("<") && !t.startsWith("{")) threadName = t.slice(0, 80);
               }
 
-              // Determine status from last entry (same logic as ClaudeCodeAgentWatcher)
               if (msg.role === "assistant") {
                 const items = Array.isArray(msg.content) ? msg.content : [];
-                lastStatus = items.some((c: any) => c.type === "tool_use") ? "running" : "done";
+                const toolUses = items.filter((c: any) => c.type === "tool_use");
+                if (toolUses.length === 0) {
+                  lastStatus = "done";
+                } else {
+                  lastStatus = toolUses.every((c: any) => c.name === "AskUserQuestion")
+                    ? "waiting"
+                    : "running";
+                }
               } else if (msg.role === "user") {
                 lastStatus = "running";
               }
@@ -1366,14 +1386,6 @@ export function startServer(
         mux.createSession();
         broadcastState();
         break;
-      case "hide-session":
-        sessionOrder.hide(cmd.name);
-        broadcastState();
-        break;
-      case "show-all-sessions":
-        sessionOrder.showAll();
-        broadcastState();
-        break;
       case "kill-session": {
         const p = sessionProviders.get(cmd.name) ?? mux;
         p.killSession(cmd.name);

package/packages/agentboard/packages/runtime/src/server/pane-scanner.ts

@@ -100,9 +100,9 @@ function resolveClaudeCodePaneInfo(
     if (!threadId) return {};
     const journalInfo = resolveClaudeCodeJournalInfo(threadId);
     // Process is alive (found via process tree), so terminal journal status
-    // is a between-turn artifact — override to running.
+    // means it's waiting for user input.
     if (journalInfo.status && TERMINAL_STATUSES.has(journalInfo.status)) {
-      journalInfo.status = "running";
+      journalInfo.status = "waiting";
     }
     return { threadId, ...journalInfo };
   } catch {
@@ -143,7 +143,14 @@ function resolveClaudeCodeJournalInfo(threadId: string): {
 
             if (msg.role === "assistant") {
               const items = Array.isArray(msg.content) ? msg.content : [];
-              lastStatus = items.some((c: any) => c.type === "tool_use") ? "running" : "done";
+              const toolUses = items.filter((c: any) => c.type === "tool_use");
+              if (toolUses.length === 0) {
+                lastStatus = "done";
+              } else {
+                lastStatus = toolUses.every((c: any) => c.name === "AskUserQuestion")
+                  ? "waiting"
+                  : "running";
+              }
             } else if (msg.role === "user") {
               lastStatus = "running";
             }

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

@@ -3,7 +3,6 @@ import { dirname } from "node:path";
 
 interface PersistedSessionOrder {
   order?: unknown;
-  hidden?: unknown;
 }
 
 /**
@@ -16,7 +15,6 @@ interface PersistedSessionOrder {
  */
 export class SessionOrder {
   private order: string[] = [];
-  private hidden = new Set<string>();
   private readonly persistPath: string | null;
 
   constructor(persistPath?: string) {
@@ -33,11 +31,6 @@ export class SessionOrder {
             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 {
@@ -51,7 +44,6 @@ export class SessionOrder {
     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))
@@ -78,48 +70,21 @@ export class SessionOrder {
     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;
-      });
+    return [...names].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");
+      writeFileSync(this.persistPath, JSON.stringify(this.order) + "\n");
     } catch {
       // Best-effort — don't crash if write fails
     }

package/packages/agentboard/packages/runtime/src/shared.ts

@@ -111,8 +111,6 @@ 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" }

package/src/commands/agentboard.ts

@@ -1,6 +1,6 @@
 import { defineCommand } from "citty";
 import { execSync, spawn, spawnSync } from "node:child_process";
-import { readFileSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, realpathSync, unlinkSync } from "node:fs";
 import { resolve } from "node:path";
 import consola from "consola";
 import { colors } from "consola/utils";
@@ -186,6 +186,23 @@ async function serverAlive(): Promise<boolean> {
   }
 }
 
+const PID_FILE = "/tmp/agentboard.pid";
+
+function stopServer(): boolean {
+  if (!existsSync(PID_FILE)) return false;
+  const pid = Number.parseInt(readFileSync(PID_FILE, "utf8").trim(), 10);
+  if (Number.isNaN(pid)) return false;
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // process already dead
+  }
+  try {
+    unlinkSync(PID_FILE);
+  } catch {}
+  return true;
+}
+
 async function ensureServerUp(): Promise<boolean> {
   if (await serverAlive()) return true;
 
@@ -374,7 +391,15 @@ async function restart(): Promise<void> {
     // no tmux or no sessions
   }
 
-  // 2. Ensure server is running
+  // 2. Stop existing server, then start fresh
+  const wasStopped = stopServer();
+  if (wasStopped) {
+    // Wait for port to free up
+    for (let i = 0; i < 20; i++) {
+      if (!(await serverAlive())) break;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+  }
   if (!(await ensureServerUp())) {
     consola.error("Failed to start agentboard server");
     process.exit(1);