claude-mux 0.7.0

package/src/hooks/claude-mux-hook.ts

@@ -0,0 +1,498 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Mux Hook Script
+ *
+ * This script is called by Claude Code hooks to update the session state
+ * using JSON files (one per session).
+ *
+ * Usage: node claude-mux-hook.js <event>
+ * Events: session-start, stop, permission-request, notification-idle,
+ *         notification-permission, pre-tool-use, post-tool-use, session-end
+ *
+ * Hook input is received via stdin as JSON.
+ */
+
+import { execSync } from "child_process";
+import {
+  existsSync,
+  mkdirSync,
+  appendFileSync,
+  readFileSync,
+  writeFileSync,
+  renameSync,
+  unlinkSync,
+  readdirSync,
+} from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+// Paths
+const CLAUDE_WATCH_DIR = join(homedir(), ".claude-watch");
+const SESSIONS_DIR = join(CLAUDE_WATCH_DIR, "sessions");
+const DEBUG_LOG_PATH = join(CLAUDE_WATCH_DIR, "debug.log");
+
+// Schema version
+const SCHEMA_VERSION = 1;
+
+function debugLog(message: string): void {
+  const timestamp = new Date().toISOString();
+  appendFileSync(DEBUG_LOG_PATH, `${timestamp} ${message}\n`);
+}
+
+interface Screenshot {
+  path: string;
+  timestamp: number;
+}
+
+interface Session {
+  v: number;
+  id: string;
+  pid: number;
+  cwd: string;
+  git_root: string | null;
+  beads_enabled: boolean;
+  tmux_target: string | null;
+  state: string;
+  current_action: string | null;
+  prompt_text: string | null;
+  last_update: number;
+  screenshots?: Screenshot[];
+  chrome_active?: boolean;
+}
+
+interface HookInput {
+  session_id: string;
+  cwd: string;
+  tool_name?: string;
+  tool_input?: {
+    command?: string;
+    file_path?: string;
+    filePath?: string;
+    description?: string;
+  };
+}
+
+function ensureSessionsDir(): void {
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+  }
+}
+
+function getSessionPath(id: string): string {
+  return join(SESSIONS_DIR, `${id}.json`);
+}
+
+function readSession(id: string): Session | null {
+  const path = getSessionPath(id);
+  try {
+    if (!existsSync(path)) return null;
+    return JSON.parse(readFileSync(path, "utf-8")) as Session;
+  } catch {
+    return null;
+  }
+}
+
+function writeSession(session: Session): void {
+  ensureSessionsDir();
+  const path = getSessionPath(session.id);
+  const tmpPath = path + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(session, null, 2));
+  renameSync(tmpPath, path);
+}
+
+function deleteSessionFile(id: string): void {
+  const path = getSessionPath(id);
+  try {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  } catch {
+    // Ignore
+  }
+}
+
+// Delete any existing sessions with the same tmux_target (cleanup stale sessions)
+function deleteSessionsByTmuxTarget(tmuxTarget: string, excludeId?: string): void {
+  try {
+    if (!existsSync(SESSIONS_DIR)) return;
+
+    const files = readdirSync(SESSIONS_DIR).filter(f => f.endsWith(".json"));
+    for (const file of files) {
+      const id = file.replace(".json", "");
+      if (id === excludeId) continue;
+
+      const session = readSession(id);
+      if (session && session.tmux_target === tmuxTarget) {
+        debugLog(`deleteSessionsByTmuxTarget: removing stale session ${id} with target ${tmuxTarget}`);
+        deleteSessionFile(id);
+      }
+    }
+  } catch {
+    // Ignore errors during cleanup
+  }
+}
+
+function getTmuxTarget(): string | null {
+  if (!process.env.TMUX) {
+    return null;
+  }
+
+  try {
+    const result = execSync(
+      'tmux display-message -p "#{session_name}:#{window_index}.#{pane_index}"',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+function getGitRoot(cwd: string): string | null {
+  try {
+    const result = execSync("git rev-parse --show-toplevel", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      cwd,
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+function isBeadsEnabled(gitRoot: string | null): boolean {
+  if (!gitRoot) return false;
+  const beadsDir = join(gitRoot, ".beads");
+  return existsSync(beadsDir);
+}
+
+function getClaudePid(): number {
+  try {
+    let pid = process.ppid;
+    debugLog(`getClaudePid: starting from ppid=${pid}`);
+
+    for (let i = 0; i < 10; i++) {
+      if (pid <= 1) break;
+
+      const psOutput = execSync(`ps -p ${pid} -o ppid=,comm=,args=`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+      }).trim();
+
+      debugLog(`getClaudePid: level ${i}, pid=${pid}, ps output: ${psOutput}`);
+
+      const isClaudeCode =
+        psOutput.includes("claude") && !psOutput.includes("claude-mux");
+
+      if (isClaudeCode) {
+        debugLog(`getClaudePid: found Claude at pid=${pid}`);
+        return pid;
+      }
+
+      const ppid = parseInt(psOutput.split(/\s+/)[0], 10);
+      if (isNaN(ppid) || ppid <= 1) break;
+
+      pid = ppid;
+    }
+  } catch (e) {
+    debugLog(`getClaudePid: error - ${e}`);
+  }
+
+  debugLog(`getClaudePid: returning 0 (not found)`);
+  return 0;
+}
+
+function formatToolAction(
+  toolName: string,
+  toolInput?: HookInput["tool_input"]
+): string {
+  const name = toolName.replace(/^mcp__[^_]+__/, "");
+
+  switch (toolName) {
+    case "Bash":
+      if (toolInput?.command) {
+        const cmd = toolInput.command.slice(0, 30);
+        return `Bash: ${cmd}${toolInput.command.length > 30 ? "..." : ""}`;
+      }
+      return "Running: Bash";
+
+    case "Read":
+    case "Edit":
+    case "Write":
+      if (toolInput?.file_path) {
+        const file = toolInput.file_path.split("/").pop() || toolInput.file_path;
+        return `${toolName}: ${file}`;
+      }
+      return `Running: ${toolName}`;
+
+    case "Grep":
+    case "Glob":
+      return `Searching...`;
+
+    case "Task":
+      return "Running agent...";
+
+    default:
+      return `Running: ${name}`;
+  }
+}
+
+async function readStdin(): Promise<HookInput> {
+  return new Promise((resolve, reject) => {
+    let data = "";
+
+    const timeout = setTimeout(() => {
+      reject(new Error("Timeout reading stdin"));
+    }, 5000);
+
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => {
+      data += chunk;
+    });
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      try {
+        resolve(JSON.parse(data));
+      } catch {
+        reject(new Error("Failed to parse hook input"));
+      }
+    });
+    process.stdin.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+}
+
+function handleSessionStart(input: HookInput): void {
+  const tmuxTarget = getTmuxTarget();
+
+  // Clean up any stale sessions with the same tmux_target before creating new one
+  if (tmuxTarget) {
+    deleteSessionsByTmuxTarget(tmuxTarget, input.session_id);
+  }
+
+  const gitRoot = getGitRoot(input.cwd);
+  const beadsEnabled = isBeadsEnabled(gitRoot);
+
+  const session: Session = {
+    v: SCHEMA_VERSION,
+    id: input.session_id,
+    pid: getClaudePid(),
+    cwd: input.cwd,
+    git_root: gitRoot,
+    beads_enabled: beadsEnabled,
+    tmux_target: tmuxTarget,
+    state: "idle",
+    current_action: null,
+    prompt_text: null,
+    last_update: Date.now(),
+  };
+  writeSession(session);
+}
+
+function getOrCreateSession(input: HookInput): Session {
+  const existing = readSession(input.session_id);
+  if (existing) return existing;
+
+  // Session doesn't exist (e.g., resumed session) - create it
+  const tmuxTarget = getTmuxTarget();
+  if (tmuxTarget) {
+    deleteSessionsByTmuxTarget(tmuxTarget, input.session_id);
+  }
+
+  const gitRoot = getGitRoot(input.cwd);
+  return {
+    v: SCHEMA_VERSION,
+    id: input.session_id,
+    pid: getClaudePid(),
+    cwd: input.cwd,
+    git_root: gitRoot,
+    beads_enabled: isBeadsEnabled(gitRoot),
+    tmux_target: tmuxTarget,
+    state: "idle",
+    current_action: null,
+    prompt_text: null,
+    last_update: Date.now(),
+  };
+}
+
+function handleUserPromptSubmit(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "busy";
+  session.current_action = "Thinking...";
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handleStop(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "idle";
+  session.current_action = null;
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handlePermissionRequest(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "waiting";
+  session.current_action = "Waiting...";
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handleNotificationIdle(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "idle";
+  session.current_action = null;
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handleNotificationPermission(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "permission";
+  session.current_action = "Waiting for permission";
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handleNotificationElicitation(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "waiting";
+  session.current_action = "Waiting for input";
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handlePreToolUse(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "busy";
+  session.current_action = input.tool_name
+    ? formatToolAction(input.tool_name, input.tool_input)
+    : "Working...";
+  session.last_update = Date.now();
+
+  // Capture screenshots from Chrome MCP
+  if (input.tool_name?.includes("take_screenshot") && input.tool_input?.filePath) {
+    session.screenshots = session.screenshots || [];
+    session.screenshots.push({
+      path: input.tool_input.filePath,
+      timestamp: Date.now(),
+    });
+  }
+
+  writeSession(session);
+}
+
+function handlePostToolUse(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "busy";
+  session.current_action = null;
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handlePostToolUseFailure(input: HookInput): void {
+  const session = getOrCreateSession(input);
+
+  session.tmux_target = getTmuxTarget() ?? session.tmux_target;
+  session.state = "busy";
+  session.current_action = null;
+  session.last_update = Date.now();
+  writeSession(session);
+}
+
+function handleSessionEnd(input: HookInput): void {
+  deleteSessionFile(input.session_id);
+}
+
+async function main(): Promise<void> {
+  const event = process.argv[2];
+
+  debugLog(`main: event=${event}`);
+
+  if (!event) {
+    console.error("Usage: claude-mux-hook <event>");
+    process.exit(1);
+  }
+
+  try {
+    const input = await readStdin();
+    debugLog(`main: session_id=${input.session_id}, cwd=${input.cwd}`);
+
+    switch (event) {
+      case "session-start":
+        handleSessionStart(input);
+        debugLog(`main: session-start completed`);
+        break;
+      case "user-prompt-submit":
+        handleUserPromptSubmit(input);
+        debugLog(`main: user-prompt-submit completed`);
+        break;
+      case "stop":
+        handleStop(input);
+        debugLog(`main: stop completed`);
+        break;
+      case "permission-request":
+        handlePermissionRequest(input);
+        debugLog(`main: permission-request completed`);
+        break;
+      case "notification-idle":
+        handleNotificationIdle(input);
+        debugLog(`main: notification-idle completed`);
+        break;
+      case "notification-permission":
+        handleNotificationPermission(input);
+        debugLog(`main: notification-permission completed`);
+        break;
+      case "notification-elicitation":
+        handleNotificationElicitation(input);
+        debugLog(`main: notification-elicitation completed`);
+        break;
+      case "pre-tool-use":
+        handlePreToolUse(input);
+        debugLog(`main: pre-tool-use completed`);
+        break;
+      case "post-tool-use":
+        handlePostToolUse(input);
+        debugLog(`main: post-tool-use completed`);
+        break;
+      case "post-tool-use-failure":
+        handlePostToolUseFailure(input);
+        debugLog(`main: post-tool-use-failure completed`);
+        break;
+      case "session-end":
+        handleSessionEnd(input);
+        debugLog(`main: session-end completed`);
+        break;
+      default:
+        debugLog(`main: unknown event ${event}`);
+        console.error(`Unknown event: ${event}`);
+        process.exit(1);
+    }
+  } catch (error) {
+    debugLog(`main: error - ${error}`);
+    process.exit(0);
+  }
+}
+
+main();

package/src/server/watcher.ts

@@ -0,0 +1,128 @@
+import { readdirSync, statSync } from "fs";
+import { SESSIONS_DIR } from "../utils/paths.js";
+import { join } from "path";
+
+export interface WatcherCallback {
+  (): void;
+}
+
+/**
+ * Simple polling-based file watcher for session JSON files.
+ * More reliable than inotify for long-running processes.
+ */
+class SessionWatcher {
+  private subscribers = new Set<WatcherCallback>();
+  private pollTimer: ReturnType<typeof setInterval> | null = null;
+  private lastState = new Map<string, number>(); // filename -> mtime
+  private readonly pollInterval = 500;
+
+  private start(): void {
+    if (this.pollTimer) return;
+
+    console.log("[watcher] Started polling", SESSIONS_DIR, `(${this.pollInterval}ms)`);
+
+    // Initialize state
+    this.updateState();
+
+    this.pollTimer = setInterval(() => {
+      if (this.checkForChanges()) {
+        this.notifySubscribers();
+      }
+    }, this.pollInterval);
+  }
+
+  private updateState(): void {
+    this.lastState.clear();
+    try {
+      const files = readdirSync(SESSIONS_DIR);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const stat = statSync(join(SESSIONS_DIR, file));
+          this.lastState.set(file, stat.mtimeMs);
+        } catch {
+          // File may have been deleted
+        }
+      }
+    } catch {
+      // Directory may not exist yet
+    }
+  }
+
+  private checkForChanges(): boolean {
+    const newState = new Map<string, number>();
+    let changed = false;
+
+    try {
+      const files = readdirSync(SESSIONS_DIR);
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        try {
+          const stat = statSync(join(SESSIONS_DIR, file));
+          newState.set(file, stat.mtimeMs);
+
+          const oldMtime = this.lastState.get(file);
+          if (oldMtime === undefined) {
+            // New file
+            console.log("[watcher] File added:", file);
+            changed = true;
+          } else if (oldMtime !== stat.mtimeMs) {
+            // Modified file
+            console.log("[watcher] File changed:", file);
+            changed = true;
+          }
+        } catch {
+          // File may have been deleted during iteration
+        }
+      }
+
+      // Check for deleted files
+      for (const file of this.lastState.keys()) {
+        if (!newState.has(file)) {
+          console.log("[watcher] File removed:", file);
+          changed = true;
+        }
+      }
+    } catch {
+      // Directory may not exist
+    }
+
+    this.lastState = newState;
+    return changed;
+  }
+
+  private notifySubscribers(): void {
+    console.log("[watcher] Notifying", this.subscribers.size, "subscribers");
+    for (const callback of this.subscribers) {
+      try {
+        callback();
+      } catch (error) {
+        console.error("[watcher] Subscriber error:", error);
+      }
+    }
+  }
+
+  subscribe(callback: WatcherCallback): () => void {
+    this.subscribers.add(callback);
+    if (this.subscribers.size === 1) {
+      this.start();
+    }
+    return () => {
+      this.subscribers.delete(callback);
+      if (this.subscribers.size === 0) {
+        this.stop();
+      }
+    };
+  }
+
+  private stop(): void {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.lastState.clear();
+    console.log("[watcher] Stopped");
+  }
+}
+
+export const sessionWatcher = new SessionWatcher();