claude-mux 0.7.0

package/src/setup/hooks.ts

@@ -0,0 +1,333 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { CLAUDE_SETTINGS_PATH, CLAUDE_DIR } from "../utils/paths.js";
+import { VERSION } from "../utils/version.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+interface Hook {
+  type: "command";
+  command: string;
+  timeout?: number;
+}
+
+interface HookMatcher {
+  matcher?: string;
+  hooks: Hook[];
+}
+
+interface HooksConfig {
+  [eventName: string]: HookMatcher[];
+}
+
+interface ClaudeWatchMetadata {
+  version: string;
+  installedAt: string;
+}
+
+interface ClaudeSettings {
+  hooks?: HooksConfig;
+  "claude-watch"?: ClaudeWatchMetadata;
+  [key: string]: unknown;
+}
+
+function getHookScriptPath(scriptName: string): string {
+  // In production, scripts are in dist/hooks/
+  // During development, they might be in src/hooks/
+  const distPath = join(__dirname, "..", "hooks", scriptName);
+  return distPath;
+}
+
+export function getClaudeWatchHooks(): HooksConfig {
+  const hookScript = getHookScriptPath("claude-mux-hook.js");
+
+  return {
+    SessionStart: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" session-start`,
+          },
+        ],
+      },
+    ],
+    UserPromptSubmit: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" user-prompt-submit`,
+          },
+        ],
+      },
+    ],
+    Stop: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" stop`,
+          },
+        ],
+      },
+    ],
+    PermissionRequest: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" permission-request`,
+          },
+        ],
+      },
+    ],
+    Notification: [
+      {
+        matcher: "idle_prompt",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" notification-idle`,
+          },
+        ],
+      },
+      {
+        matcher: "permission_prompt",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" notification-permission`,
+          },
+        ],
+      },
+      {
+        matcher: "elicitation_dialog",
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" notification-elicitation`,
+          },
+        ],
+      },
+    ],
+    PreToolUse: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" pre-tool-use`,
+          },
+        ],
+      },
+    ],
+    PostToolUse: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" post-tool-use`,
+          },
+        ],
+      },
+    ],
+    PostToolUseFailure: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" post-tool-use-failure`,
+          },
+        ],
+      },
+    ],
+    SessionEnd: [
+      {
+        hooks: [
+          {
+            type: "command",
+            command: `node "${hookScript}" session-end`,
+          },
+        ],
+      },
+    ],
+  };
+}
+
+export function loadClaudeSettings(): ClaudeSettings {
+  if (!existsSync(CLAUDE_SETTINGS_PATH)) {
+    return {};
+  }
+
+  try {
+    const content = readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+    return JSON.parse(content) as ClaudeSettings;
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Get the version of installed claude-watch hooks.
+ * Returns null if hooks are not installed or version is not tracked.
+ */
+export function getInstalledHooksVersion(): string | null {
+  const settings = loadClaudeSettings();
+  return settings["claude-watch"]?.version ?? null;
+}
+
+/**
+ * Check if hooks need to be installed or updated.
+ * Returns: 'install' | 'update' | 'current'
+ */
+export function checkHooksStatus(): "install" | "update" | "current" {
+  const settings = loadClaudeSettings();
+
+  // Check if hooks are installed at all
+  if (!settings.hooks) {
+    return "install";
+  }
+
+  // Check if any claude-watch hooks exist
+  const hasClaudeWatchHooks = Object.values(settings.hooks).some((matchers) =>
+    matchers.some((m) => m.hooks.some((h) => h.command.includes("claude-mux-hook")))
+  );
+
+  if (!hasClaudeWatchHooks) {
+    return "install";
+  }
+
+  // Check version
+  const installedVersion = settings["claude-watch"]?.version;
+  if (!installedVersion || installedVersion !== VERSION) {
+    return "update";
+  }
+
+  return "current";
+}
+
+export function mergeHooks(existing: HooksConfig | undefined, newHooks: HooksConfig): HooksConfig {
+  const merged: HooksConfig = { ...existing };
+
+  for (const [eventName, matchers] of Object.entries(newHooks)) {
+    if (!merged[eventName]) {
+      merged[eventName] = [];
+    } else {
+      // Remove any existing claude-watch hooks for this event (so we can replace them)
+      merged[eventName] = merged[eventName].filter((existingMatcher) => {
+        return !existingMatcher.hooks.some((h) => h.command.includes("claude-mux-hook"));
+      });
+    }
+
+    // Add new claude-watch matchers
+    for (const newMatcher of matchers) {
+      merged[eventName].push(newMatcher);
+    }
+  }
+
+  return merged;
+}
+
+export function removeClaudeWatchHooks(hooks: HooksConfig): HooksConfig {
+  const cleaned: HooksConfig = {};
+
+  for (const [eventName, matchers] of Object.entries(hooks)) {
+    const filteredMatchers = matchers.filter((matcher) => {
+      // Remove matchers that have claude-mux-hook commands
+      return !matcher.hooks.some((h) => h.command.includes("claude-mux-hook"));
+    });
+
+    if (filteredMatchers.length > 0) {
+      cleaned[eventName] = filteredMatchers;
+    }
+  }
+
+  return cleaned;
+}
+
+export function generateDiff(
+  oldSettings: ClaudeSettings,
+  newSettings: ClaudeSettings
+): string {
+  const oldJson = JSON.stringify(oldSettings, null, 2);
+  const newJson = JSON.stringify(newSettings, null, 2);
+
+  if (oldJson === newJson) {
+    return "No changes needed.";
+  }
+
+  // Simple diff display
+  const lines: string[] = [];
+  lines.push("Changes to ~/.claude/settings.json:");
+  lines.push("");
+
+  if (!oldSettings.hooks) {
+    lines.push("+ Adding hooks configuration");
+  } else {
+    lines.push("~ Updating hooks configuration");
+  }
+
+  lines.push("");
+  lines.push("New hooks to be added:");
+  const hookEvents = Object.keys(getClaudeWatchHooks());
+  for (const event of hookEvents) {
+    lines.push(`  + ${event}: claude-mux-hook`);
+  }
+
+  return lines.join("\n");
+}
+
+export function saveClaudeSettings(settings: ClaudeSettings): void {
+  // Ensure directory exists
+  if (!existsSync(CLAUDE_DIR)) {
+    mkdirSync(CLAUDE_DIR, { recursive: true });
+  }
+
+  const content = JSON.stringify(settings, null, 2);
+  writeFileSync(CLAUDE_SETTINGS_PATH, content, "utf-8");
+}
+
+export function installHooks(): { diff: string; newSettings: ClaudeSettings } {
+  const currentSettings = loadClaudeSettings();
+  const claudeWatchHooks = getClaudeWatchHooks();
+  const mergedHooks = mergeHooks(currentSettings.hooks, claudeWatchHooks);
+
+  const newSettings: ClaudeSettings = {
+    ...currentSettings,
+    hooks: mergedHooks,
+    "claude-watch": {
+      version: VERSION,
+      installedAt: new Date().toISOString(),
+    },
+  };
+
+  const diff = generateDiff(currentSettings, newSettings);
+
+  return { diff, newSettings };
+}
+
+export function uninstallHooks(): void {
+  const currentSettings = loadClaudeSettings();
+
+  if (!currentSettings.hooks) {
+    return;
+  }
+
+  const cleanedHooks = removeClaudeWatchHooks(currentSettings.hooks);
+
+  const newSettings: ClaudeSettings = {
+    ...currentSettings,
+  };
+
+  if (Object.keys(cleanedHooks).length === 0) {
+    delete newSettings.hooks;
+  } else {
+    newSettings.hooks = cleanedHooks;
+  }
+
+  // Remove claude-watch metadata
+  delete newSettings["claude-watch"];
+
+  saveClaudeSettings(newSettings);
+}

package/src/setup/index.ts

@@ -0,0 +1,2 @@
+export { runSetup, runCleanup } from "./wizard.js";
+export { installHooks, uninstallHooks } from "./hooks.js";

package/src/setup/wizard.ts

@@ -0,0 +1,81 @@
+import { createInterface } from "readline";
+import { mkdirSync, existsSync } from "fs";
+import { CLAUDE_WATCH_DIR, SESSIONS_DIR } from "../utils/paths.js";
+import { installHooks, saveClaudeSettings, uninstallHooks } from "./hooks.js";
+
+async function prompt(question: string): Promise<string> {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+async function confirm(question: string): Promise<boolean> {
+  const answer = await prompt(`${question} [y/N] `);
+  return answer === "y" || answer === "yes";
+}
+
+export async function runSetup(): Promise<void> {
+  console.log("\n claude-mux Setup\n");
+
+  // Step 1: Create data directories
+  console.log("Step 1: Creating data directories...");
+  if (!existsSync(CLAUDE_WATCH_DIR)) {
+    mkdirSync(CLAUDE_WATCH_DIR, { recursive: true });
+    console.log(`  Created ${CLAUDE_WATCH_DIR}`);
+  } else {
+    console.log(`  ${CLAUDE_WATCH_DIR} already exists`);
+  }
+  if (!existsSync(SESSIONS_DIR)) {
+    mkdirSync(SESSIONS_DIR, { recursive: true });
+    console.log(`  Created ${SESSIONS_DIR}`);
+  } else {
+    console.log(`  ${SESSIONS_DIR} already exists`);
+  }
+
+  // Step 2: Configure Claude hooks
+  console.log("\nStep 2: Configuring Claude Code hooks...");
+  const { diff, newSettings } = installHooks();
+  console.log("");
+  console.log(diff);
+  console.log("");
+
+  const confirmHooks = await confirm("Apply these changes to Claude settings?");
+  if (confirmHooks) {
+    saveClaudeSettings(newSettings);
+    console.log("  Hooks installed successfully");
+  } else {
+    console.log("  Skipped hook installation");
+  }
+
+  // Done
+  console.log("\n Setup complete!\n");
+  console.log("To start claude-mux, run from any tmux session:");
+  console.log("  claude-mux");
+  console.log("");
+  console.log("This will automatically create a 'watch' session and add");
+  console.log("a keybinding (prefix + W) to quickly return to the dashboard.");
+  console.log("");
+}
+
+export async function runCleanup(): Promise<void> {
+  console.log("\n claude-mux Cleanup\n");
+
+  console.log("Removing Claude Code hooks...");
+  uninstallHooks();
+  console.log("  Hooks removed successfully");
+
+  console.log("\nData directory: " + CLAUDE_WATCH_DIR);
+  console.log("  (Manual removal: rm -rf ~/.claude-mux)");
+
+  console.log("\n Cleanup complete!\n");
+}
+
+export { installHooks, uninstallHooks } from "./hooks.js";

package/src/tmux/detect.ts

@@ -0,0 +1,87 @@
+import { execSync } from "child_process";
+
+/**
+ * Check if we're running inside tmux.
+ */
+export function isInTmux(): boolean {
+  return !!process.env.TMUX;
+}
+
+/**
+ * Get the current tmux target in the format session:window.pane.
+ * Returns null if not running in tmux.
+ */
+export function getTmuxTarget(): string | null {
+  if (!isInTmux()) {
+    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;
+  }
+}
+
+/**
+ * Get just the tmux session name.
+ * Returns null if not running in tmux.
+ */
+export function getTmuxSessionName(): string | null {
+  if (!isInTmux()) {
+    return null;
+  }
+
+  try {
+    const result = execSync('tmux display-message -p "#{session_name}"', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+
+export interface TmuxSession {
+  name: string;
+  windowCount: number;
+  attached: boolean;
+}
+
+/**
+ * Get all tmux sessions.
+ * Returns empty array if not running in tmux or on error.
+ */
+export function getAllTmuxSessions(): TmuxSession[] {
+  if (!isInTmux()) {
+    return [];
+  }
+
+  try {
+    // Format: session_name:window_count:attached_flag
+    const result = execSync(
+      'tmux list-sessions -F "#{session_name}:#{session_windows}:#{session_attached}"',
+      { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+    );
+
+    return result
+      .trim()
+      .split("\n")
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        const [name, windowCount, attached] = line.split(":");
+        return {
+          name,
+          windowCount: parseInt(windowCount, 10) || 1,
+          attached: attached === "1",
+        };
+      });
+  } catch {
+    return [];
+  }
+}

package/src/tmux/navigate.ts

@@ -0,0 +1,42 @@
+import { execFileSync } from "child_process";
+import { isInTmux } from "./detect.js";
+
+/**
+ * Switch to a different tmux session/window/pane.
+ * @param target - The target in format "session:window.pane"
+ * @returns true if successful, false otherwise
+ */
+export function switchToTarget(target: string): boolean {
+  if (!isInTmux()) {
+    return false;
+  }
+
+  try {
+    execFileSync("tmux", ["switch-client", "-t", target], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Switch to a specific session (useful for the dashboard binding).
+ * @param sessionName - The tmux session name
+ * @returns true if successful, false otherwise
+ */
+export function switchToSession(sessionName: string): boolean {
+  if (!isInTmux()) {
+    return false;
+  }
+
+  try {
+    execFileSync("tmux", ["switch-client", "-t", sessionName], {
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/tmux/pane.ts

@@ -0,0 +1,167 @@
+import { execFileSync } from "child_process";
+import { isInTmux } from "./detect.js";
+
+/**
+ * Get the title of a tmux pane.
+ * @param target - The tmux target in format "session:window.pane"
+ * @returns The pane title, or null if failed
+ */
+export function getPaneTitle(target: string): string | null {
+  try {
+    const result = execFileSync("tmux", ["display-message", "-p", "-t", target, "#{pane_title}"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1000,
+    });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Capture the contents of a tmux pane.
+ * @param target - The tmux target in format "session:window.pane"
+ * @returns The pane contents as a string, or null if capture failed
+ */
+export function capturePaneContent(target: string): string | null {
+  if (!isInTmux()) {
+    return null;
+  }
+
+  try {
+    const result = execFileSync("tmux", ["capture-pane", "-p", "-t", target], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1000,
+    });
+    return result;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Check if the pane content shows Claude is actively working.
+ * Looks for interrupt hints which appear when Claude is processing.
+ */
+export function isPaneShowingWorking(content: string): boolean {
+  if (!content) return false;
+
+  // These patterns appear when Claude is actively working
+  return (
+    content.includes("Esc to interrupt") ||
+    content.includes("esc to interrupt") ||
+    content.includes("ctrl+c to interrupt")
+  );
+}
+
+/**
+ * Check if the pane content shows Claude is at the prompt (idle).
+ * Claude is idle if "Esc to interrupt" is NOT present.
+ */
+export function isPaneShowingPrompt(content: string): boolean {
+  if (!content) return false;
+
+  // If "Esc to interrupt" is present, Claude is still working
+  if (isPaneShowingWorking(content)) {
+    return false;
+  }
+
+  return true;
+}
+
+/**
+ * Detect if the pane shows user interruption or cancellation.
+ * Only detects FRESH signals from the most recent interaction.
+ *
+ * Structure of Claude Code pane:
+ *   ❯ user command           ← interaction start (● or ❯)
+ *     ⎿  Interrupted...      ← signal we're looking for
+ *   ─────────────────────    ← TOP separator
+ *   ❯ [user input]           ← prompt area (may have text)
+ *   ─────────────────────    ← BOTTOM separator
+ *     status line
+ *
+ * Algorithm:
+ * 1. Find the two separators around the prompt area
+ * 2. Scan backwards from TOP separator to find ● or ❯ (interaction start)
+ * 3. Check the slice between interaction start and TOP separator for signals
+ *
+ * @returns 'interrupted' if user pressed Esc during work,
+ *          'declined' if user cancelled a prompt,
+ *          null if no interruption detected
+ */
+export function detectRecentInterruption(content: string): 'interrupted' | 'declined' | null {
+  if (!content) return null;
+
+  const lines = content.split('\n');
+
+  // If there's active UI (menu or working), don't detect old interruptions
+  const bottomLines = lines.slice(-5).join('\n');
+  if (
+    bottomLines.includes('Esc to cancel') ||
+    bottomLines.includes('Esc to interrupt') ||
+    bottomLines.includes('ctrl+c to interrupt')
+  ) {
+    return null;
+  }
+
+  // Find the BOTTOM separator (last separator in the pane)
+  let bottomSepIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].startsWith('─────')) {
+      bottomSepIdx = i;
+      break;
+    }
+  }
+  if (bottomSepIdx === -1) return null;
+
+  // Find the TOP separator (second-to-last separator, above the prompt)
+  let topSepIdx = -1;
+  for (let i = bottomSepIdx - 1; i >= 0; i--) {
+    if (lines[i].startsWith('─────')) {
+      topSepIdx = i;
+      break;
+    }
+  }
+  if (topSepIdx === -1) return null;
+
+  // Scan backwards from TOP separator to find the interaction start (● or ❯)
+  let interactionStartIdx = -1;
+  const maxScan = Math.max(0, topSepIdx - 15);
+  for (let i = topSepIdx - 1; i >= maxScan; i--) {
+    const line = lines[i];
+    if (line.startsWith('●') || line.startsWith('❯')) {
+      interactionStartIdx = i;
+      break;
+    }
+  }
+  if (interactionStartIdx === -1) return null;
+
+  // Check the slice from interaction start to TOP separator for signals
+  const slice = lines.slice(interactionStartIdx, topSepIdx).join('\n');
+
+  if (slice.includes('Interrupted')) return 'interrupted';
+  if (slice.includes('User declined to answer')) return 'declined';
+
+  return null;
+}
+
+/**
+ * Check if a tmux pane shows a recent interruption/cancellation.
+ * Returns the session update to apply, or null if no update needed.
+ *
+ * @param tmuxTarget - The tmux target in format "session:window.pane"
+ * @returns Session fields to update if interruption detected, null otherwise
+ */
+export function checkForInterruption(tmuxTarget: string): { state: 'idle'; current_action: null; prompt_text: null } | null {
+  const content = capturePaneContent(tmuxTarget);
+  if (!content) return null;
+
+  const interruption = detectRecentInterruption(content);
+  if (interruption) {
+    return { state: 'idle', current_action: null, prompt_text: null };
+  }
+  return null;
+}