claude-mux 0.7.0

package/src/tmux/resize.ts

@@ -0,0 +1,28 @@
+import { execFileSync } from "child_process";
+
+/**
+ * Resize a tmux window to the specified dimensions.
+ * Uses resize-window instead of resize-pane for detached sessions.
+ *
+ * @param target - The tmux target in format "session:window.pane"
+ * @param cols - Number of columns (clamped to 20-500)
+ * @param rows - Number of rows (clamped to 5-200)
+ */
+export function resizeTmuxWindow(target: string, cols: number, rows: number): void {
+  try {
+    const safeCols = Math.max(20, Math.min(500, Math.floor(cols)));
+    const safeRows = Math.max(5, Math.min(200, Math.floor(rows)));
+    // Extract window target (session:window) from full target (session:window.pane)
+    const windowTarget = target.replace(/\.\d+$/, "");
+    execFileSync(
+      "tmux",
+      ["resize-window", "-t", windowTarget, "-x", String(safeCols), "-y", String(safeRows)],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 2000,
+      }
+    );
+  } catch {
+    // Pane may not exist or tmux error - ignore
+  }
+}

package/src/utils/paths.ts

@@ -0,0 +1,11 @@
+import { homedir } from "os";
+import { join } from "path";
+
+export const CLAUDE_WATCH_DIR = join(homedir(), ".claude-watch");
+export const SESSIONS_DIR = join(CLAUDE_WATCH_DIR, "sessions");
+export const CONFIG_PATH = join(CLAUDE_WATCH_DIR, "config.json");
+
+export const CLAUDE_DIR = join(homedir(), ".claude");
+export const CLAUDE_SETTINGS_PATH = join(CLAUDE_DIR, "settings.json");
+
+export const DEFAULT_SERVER_PORT = 3456;

package/src/utils/pid.ts

@@ -0,0 +1,12 @@
+/**
+ * Check if a process with the given PID is still alive.
+ */
+export function isPidAlive(pid: number): boolean {
+  try {
+    // Sending signal 0 doesn't kill the process but checks if it exists
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/utils/version.ts

@@ -0,0 +1,5 @@
+/**
+ * Central version constant for claude-watch.
+ * Keep in sync with package.json version.
+ */
+export const VERSION = "0.7.0";

package/tests/components/Header.test.tsx

@@ -0,0 +1,42 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { Header } from "../../src/components/Header.js";
+
+describe("Header", () => {
+  it("should render title", () => {
+    const { lastFrame } = render(<Header claudeCount={0} tmuxCount={0} />);
+
+    const output = lastFrame();
+    expect(output).toContain("claude-watch");
+  });
+
+  it("should show claude count", () => {
+    const { lastFrame } = render(<Header claudeCount={2} tmuxCount={0} />);
+
+    const output = lastFrame();
+    expect(output).toContain("2 claude");
+  });
+
+  it("should show tmux count", () => {
+    const { lastFrame } = render(<Header claudeCount={0} tmuxCount={3} />);
+
+    const output = lastFrame();
+    expect(output).toContain("3 tmux");
+  });
+
+  it("should show both counts", () => {
+    const { lastFrame } = render(<Header claudeCount={2} tmuxCount={3} />);
+
+    const output = lastFrame();
+    expect(output).toContain("2 claude");
+    expect(output).toContain("3 tmux");
+  });
+
+  it("should show no sessions when both are zero", () => {
+    const { lastFrame } = render(<Header claudeCount={0} tmuxCount={0} />);
+
+    const output = lastFrame();
+    expect(output).toContain("no sessions");
+  });
+});

package/tests/components/SessionEntry-extended.test.tsx

@@ -0,0 +1,165 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { SessionEntry } from "../../src/components/SessionEntry.js";
+import type { Session } from "../../src/db/index.js";
+import type { DisplayItem } from "../../src/components/SessionEntry.js";
+
+describe("SessionEntry extended", () => {
+  const baseSession: Session = {
+    id: "test-session",
+    pid: 1234,
+    cwd: "/home/user/project",
+    tmux_target: "main:0.1",
+    state: "busy",
+    current_action: null,
+    prompt_text: null,
+    last_update: Date.now(),
+    metadata: null,
+  };
+
+  function makeClaudeItem(session: Session): DisplayItem {
+    return { type: "claude", session };
+  }
+
+  describe("getStateText edge cases", () => {
+    it("should show prompt text for waiting state when available", () => {
+      const session: Session = {
+        ...baseSession,
+        state: "waiting",
+        prompt_text: "What should I do?",
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} width={120} />
+      );
+
+      const output = lastFrame();
+      // Prompt text appears in the state column (may be truncated due to column width)
+      expect(output).toContain("Waiting: What should");
+    });
+
+    it("should truncate long prompt text", () => {
+      const session: Session = {
+        ...baseSession,
+        state: "waiting",
+        prompt_text: "This is a very long prompt that should be truncated because it exceeds the maximum length",
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toContain("…");
+    });
+
+    it("should show Working... when busy with no action", () => {
+      const session: Session = {
+        ...baseSession,
+        state: "busy",
+        current_action: null,
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toContain("Working...");
+    });
+
+    it("should handle unknown state gracefully", () => {
+      const session: Session = {
+        ...baseSession,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        state: "unknown" as any,
+        current_action: null,
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toContain("unknown");
+    });
+  });
+
+  describe("truncatePath edge cases", () => {
+    it("should handle path that starts with HOME", () => {
+      const originalHome = process.env.HOME;
+      process.env.HOME = "/home/testuser";
+
+      const session: Session = {
+        ...baseSession,
+        cwd: "/home/testuser/projects/myproject",
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      // Should show ~ instead of full home path
+      expect(output).toBeDefined();
+
+      process.env.HOME = originalHome;
+    });
+
+    it("should handle USERPROFILE on Windows-like systems", () => {
+      const originalHome = process.env.HOME;
+      const originalUserProfile = process.env.USERPROFILE;
+
+      delete process.env.HOME;
+      process.env.USERPROFILE = "/home/winuser";
+
+      const session: Session = {
+        ...baseSession,
+        cwd: "/home/winuser/documents/project",
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={makeClaudeItem(session)} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toBeDefined();
+
+      process.env.HOME = originalHome;
+      process.env.USERPROFILE = originalUserProfile;
+    });
+  });
+
+  describe("tmux session entries", () => {
+    it("should render tmux session with window count", () => {
+      const item: DisplayItem = {
+        type: "tmux",
+        tmuxSession: { name: "dev", windowCount: 3, attached: false },
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={item} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toContain("tmux");
+      expect(output).toContain("dev");
+      expect(output).toContain("3 windows");
+    });
+
+    it("should show attached status for tmux session", () => {
+      const item: DisplayItem = {
+        type: "tmux",
+        tmuxSession: { name: "main", windowCount: 1, attached: true },
+      };
+
+      const { lastFrame } = render(
+        <SessionEntry item={item} isSelected={false} showBlink={true} />
+      );
+
+      const output = lastFrame();
+      expect(output).toContain("attached");
+    });
+  });
+});

package/tests/components/SessionEntry.test.tsx

@@ -0,0 +1,138 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { SessionEntry, type DisplayItem } from "../../src/components/SessionEntry.js";
+import type { Session } from "../../src/db/index.js";
+
+const mockSession: Session = {
+  id: "test-session",
+  pid: 1234,
+  cwd: "/home/user/project",
+  tmux_target: "main:0.1",
+  state: "busy",
+  current_action: "Running: Bash",
+  prompt_text: null,
+  last_update: Date.now(),
+  metadata: null,
+};
+
+function makeClaudeItem(session: Session): DisplayItem {
+  return { type: "claude", session };
+}
+
+describe("SessionEntry", () => {
+  it("should render session with busy state", () => {
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(mockSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("●");
+    expect(output).toContain("project");
+    expect(output).toContain("main:0.1");
+    expect(output).toContain("Running: Bash");
+  });
+
+  it("should render selection indicator when selected", () => {
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(mockSession)} isSelected={true} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("▶");
+  });
+
+  it("should not show selection indicator when not selected", () => {
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(mockSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).not.toContain("▶");
+  });
+
+  it("should render waiting state correctly", () => {
+    const waitingSession: Session = {
+      ...mockSession,
+      state: "waiting",
+      current_action: null,
+    };
+
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(waitingSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("Waiting");
+  });
+
+  it("should render permission state correctly", () => {
+    const permissionSession: Session = {
+      ...mockSession,
+      state: "permission",
+      current_action: null,
+    };
+
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(permissionSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("permission");
+  });
+
+  it("should render idle state correctly", () => {
+    const idleSession: Session = {
+      ...mockSession,
+      state: "idle",
+      current_action: null,
+    };
+
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(idleSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("Idle");
+  });
+
+  it("should hide bullet for busy state when showBlink is false", () => {
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(mockSession)} isSelected={false} showBlink={false} />
+    );
+
+    const output = lastFrame();
+    // The bullet should be replaced with a space during blink-off phase
+    // We just verify the component renders without error
+    expect(output).toBeDefined();
+  });
+
+  it("should show dash when tmux_target is null", () => {
+    const noTmuxSession: Session = {
+      ...mockSession,
+      tmux_target: null,
+    };
+
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(noTmuxSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    // Now shows "—" instead of "no tmux"
+    expect(output).toContain("—");
+  });
+
+  it("should truncate long paths", () => {
+    const longPathSession: Session = {
+      ...mockSession,
+      cwd: "/home/user/very/long/path/to/some/deeply/nested/project",
+    };
+
+    const { lastFrame } = render(
+      <SessionEntry item={makeClaudeItem(longPathSession)} isSelected={false} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("…");
+  });
+});

package/tests/components/SessionList.test.tsx

@@ -0,0 +1,110 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { SessionList } from "../../src/components/SessionList.js";
+import type { Session } from "../../src/db/index.js";
+
+const mockSessions: Session[] = [
+  {
+    id: "session-1",
+    pid: 1001,
+    cwd: "/home/user/project1",
+    tmux_target: "main:0.0",
+    state: "busy",
+    current_action: "Running: Bash",
+    prompt_text: null,
+    last_update: Date.now(),
+    metadata: null,
+  },
+  {
+    id: "session-2",
+    pid: 1002,
+    cwd: "/home/user/project2",
+    tmux_target: "dev:1.0",
+    state: "idle",
+    current_action: null,
+    prompt_text: null,
+    last_update: Date.now(),
+    metadata: null,
+  },
+];
+
+describe("SessionList", () => {
+  it("should render empty state when no sessions", () => {
+    const { lastFrame } = render(
+      <SessionList sessions={[]} tmuxSessions={[]} selectedIndex={0} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("No sessions");
+  });
+
+  it("should render multiple sessions", () => {
+    const { lastFrame } = render(
+      <SessionList sessions={mockSessions} tmuxSessions={[]} selectedIndex={0} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("project1");
+    expect(output).toContain("project2");
+    expect(output).toContain("main:0.0");
+    expect(output).toContain("dev:1.0");
+  });
+
+  it("should highlight selected session", () => {
+    const { lastFrame } = render(
+      <SessionList sessions={mockSessions} tmuxSessions={[]} selectedIndex={1} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    // The second session should have the selection indicator
+    expect(output).toContain("▶");
+  });
+
+  it("should show all session states", () => {
+    const sessionsWithStates: Session[] = [
+      { ...mockSessions[0], state: "permission" },
+      { ...mockSessions[1], state: "waiting" },
+    ];
+
+    const { lastFrame } = render(
+      <SessionList sessions={sessionsWithStates} tmuxSessions={[]} selectedIndex={0} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("permission");
+    expect(output).toContain("Waiting");
+  });
+
+  it("should show tmux sessions without claude instances", () => {
+    const tmuxSessions = [
+      { name: "other", windowCount: 2, attached: false },
+    ];
+
+    const { lastFrame } = render(
+      <SessionList sessions={mockSessions} tmuxSessions={tmuxSessions} selectedIndex={0} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    expect(output).toContain("other");
+    expect(output).toContain("tmux");
+    expect(output).toContain("2 windows");
+  });
+
+  it("should not duplicate tmux sessions that have claude instances", () => {
+    // main session is already used by mockSessions[0]
+    const tmuxSessions = [
+      { name: "main", windowCount: 1, attached: true },
+      { name: "other", windowCount: 2, attached: false },
+    ];
+
+    const { lastFrame } = render(
+      <SessionList sessions={mockSessions} tmuxSessions={tmuxSessions} selectedIndex={0} showBlink={true} />
+    );
+
+    const output = lastFrame();
+    // "main" should only appear once (from claude session, not as separate tmux entry)
+    // "other" should appear as tmux session
+    expect(output).toContain("other");
+  });
+});

package/tests/components/StatusBar.test.tsx

@@ -0,0 +1,31 @@
+import React from "react";
+import { describe, it, expect } from "vitest";
+import { render } from "ink-testing-library";
+import { StatusBar } from "../../src/components/StatusBar.js";
+
+describe("StatusBar", () => {
+  it("should show keyboard shortcuts", () => {
+    const { lastFrame } = render(<StatusBar inTmux={true} />);
+
+    const output = lastFrame();
+    expect(output).toContain("[h]");
+    expect(output).toContain("Help");
+    expect(output).toContain("[prefix+W]");
+    expect(output).toContain("[q]");
+    expect(output).toContain("Quit");
+  });
+
+  it("should show warning when not in tmux", () => {
+    const { lastFrame } = render(<StatusBar inTmux={false} />);
+
+    const output = lastFrame();
+    expect(output).toContain("not in tmux");
+  });
+
+  it("should not show warning when in tmux", () => {
+    const { lastFrame } = render(<StatusBar inTmux={true} />);
+
+    const output = lastFrame();
+    expect(output).not.toContain("not in tmux");
+  });
+});

package/tests/db/index.test.ts

@@ -0,0 +1,78 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import {
+  cleanupStaleSessions,
+  upsertSession,
+  getAllSessions,
+  setSessionsDir,
+} from "../../src/db/index.js";
+
+const testDir = join(tmpdir(), `claude-watch-index-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+
+describe("db/index (JSON files)", () => {
+  beforeEach(() => {
+    mkdirSync(testDir, { recursive: true });
+    setSessionsDir(testDir);
+  });
+
+  afterEach(() => {
+    setSessionsDir(null); // Reset to default
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe("cleanupStaleSessions", () => {
+    it("should remove sessions with dead PIDs", () => {
+      // Insert a session with a non-existent PID
+      upsertSession({
+        id: "dead-session",
+        pid: 999999999, // Very unlikely to exist
+        cwd: "/test",
+      });
+
+      const removed = cleanupStaleSessions();
+      expect(removed).toBe(1);
+
+      const sessions = getAllSessions();
+      expect(sessions.find((s) => s.id === "dead-session")).toBeUndefined();
+    });
+
+    it("should keep sessions with alive PIDs", () => {
+      // Insert a session with our current PID
+      upsertSession({
+        id: "alive-session",
+        pid: process.pid,
+        cwd: "/test",
+      });
+
+      const removed = cleanupStaleSessions();
+      expect(removed).toBe(0);
+
+      const sessions = getAllSessions();
+      expect(sessions.find((s) => s.id === "alive-session")).toBeDefined();
+    });
+
+    it("should handle empty directory", () => {
+      const removed = cleanupStaleSessions();
+      expect(removed).toBe(0);
+    });
+
+    it("should skip sessions with PID 0", () => {
+      // Sessions with PID 0 should only be cleaned by session-end
+      upsertSession({
+        id: "unknown-pid-session",
+        pid: 0,
+        cwd: "/test",
+      });
+
+      const removed = cleanupStaleSessions();
+      expect(removed).toBe(0);
+
+      const sessions = getAllSessions();
+      expect(sessions.find((s) => s.id === "unknown-pid-session")).toBeDefined();
+    });
+  });
+});