claude-mux 0.7.0 → 0.7.1

package/web/.svelte-kit/adapter-node/chunks/ws-handlers.js

@@ -0,0 +1,782 @@
+import { execFileSync } from "child_process";
+import { g as getAllSessions, a as updateSession } from "./sessions-json.js";
+import { c as checkForInterruption, g as getPaneTitle } from "./pane.js";
+import { readdirSync, statSync, existsSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+function resizeTmuxWindow(target, cols, rows) {
+  try {
+    const safeCols = Math.max(20, Math.min(500, Math.floor(cols)));
+    const safeRows = Math.max(5, Math.min(200, Math.floor(rows)));
+    const windowTarget = target.replace(/\.\d+$/, "");
+    execFileSync(
+      "tmux",
+      ["resize-window", "-t", windowTarget, "-x", String(safeCols), "-y", String(safeRows)],
+      {
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 2e3
+      }
+    );
+  } catch {
+  }
+}
+const CLAUDE_WATCH_DIR = join(homedir(), ".claude-watch");
+const SESSIONS_DIR = join(CLAUDE_WATCH_DIR, "sessions");
+join(CLAUDE_WATCH_DIR, "config.json");
+const CLAUDE_DIR = join(homedir(), ".claude");
+join(CLAUDE_DIR, "settings.json");
+class SessionWatcher {
+  subscribers = /* @__PURE__ */ new Set();
+  pollTimer = null;
+  lastState = /* @__PURE__ */ new Map();
+  // filename -> mtime
+  pollInterval = 500;
+  start() {
+    if (this.pollTimer) return;
+    console.log("[watcher] Started polling", SESSIONS_DIR, `(${this.pollInterval}ms)`);
+    this.updateState();
+    this.pollTimer = setInterval(() => {
+      if (this.checkForChanges()) {
+        this.notifySubscribers();
+      }
+    }, this.pollInterval);
+  }
+  updateState() {
+    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 {
+        }
+      }
+    } catch {
+    }
+  }
+  checkForChanges() {
+    const newState = /* @__PURE__ */ new Map();
+    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 === void 0) {
+            console.log("[watcher] File added:", file);
+            changed = true;
+          } else if (oldMtime !== stat.mtimeMs) {
+            console.log("[watcher] File changed:", file);
+            changed = true;
+          }
+        } catch {
+        }
+      }
+      for (const file of this.lastState.keys()) {
+        if (!newState.has(file)) {
+          console.log("[watcher] File removed:", file);
+          changed = true;
+        }
+      }
+    } catch {
+    }
+    this.lastState = newState;
+    return changed;
+  }
+  notifySubscribers() {
+    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) {
+    this.subscribers.add(callback);
+    if (this.subscribers.size === 1) {
+      this.start();
+    }
+    return () => {
+      this.subscribers.delete(callback);
+      if (this.subscribers.size === 0) {
+        this.stop();
+      }
+    };
+  }
+  stop() {
+    if (this.pollTimer) {
+      clearInterval(this.pollTimer);
+      this.pollTimer = null;
+    }
+    this.lastState.clear();
+    console.log("[watcher] Stopped");
+  }
+}
+const sessionWatcher = new SessionWatcher();
+const DEFAULT_CONFIG = {
+  maxSessionsClients: 50,
+  maxTerminalClientsPerTarget: 10,
+  maxTerminalClientsTotal: 100,
+  maxQueuedMessages: 100,
+  debug: false
+};
+function log(entry, config) {
+  if (entry.level === "debug" && !config.debug) return;
+  const prefix = `[ws:${entry.component}]`;
+  const msg = entry.data ? `${prefix} ${entry.message} ${JSON.stringify(entry.data)}` : `${prefix} ${entry.message}`;
+  switch (entry.level) {
+    case "debug":
+      console.debug(msg);
+      break;
+    case "info":
+      console.info(msg);
+      break;
+    case "warn":
+      console.warn(msg);
+      break;
+    case "error":
+      console.error(msg);
+      break;
+  }
+}
+function syncSessionStates() {
+  const sessions = getAllSessions().filter((s) => s.tmux_target);
+  for (const session of sessions) {
+    if (!session.tmux_target) continue;
+    const update = checkForInterruption(session.tmux_target);
+    if (update && session.state !== "idle") {
+      updateSession(session.id, update);
+    }
+  }
+}
+function deduplicateByTmuxTarget(sessions) {
+  const byTarget = /* @__PURE__ */ new Map();
+  const noTarget = [];
+  for (const session of sessions) {
+    if (!session.tmux_target) {
+      noTarget.push(session);
+      continue;
+    }
+    const existing = byTarget.get(session.tmux_target);
+    if (!existing || session.last_update > existing.last_update) {
+      byTarget.set(session.tmux_target, session);
+    }
+  }
+  return [...byTarget.values(), ...noTarget];
+}
+function getEnrichedSessions() {
+  syncSessionStates();
+  const sessions = getAllSessions();
+  const enrichedSessions = sessions.map((s) => ({
+    ...s,
+    pane_title: s.tmux_target ? getPaneTitle(s.tmux_target) : null
+  }));
+  return deduplicateByTmuxTarget(enrichedSessions);
+}
+function capturePaneOutput(target) {
+  try {
+    return execFileSync("tmux", ["capture-pane", "-t", target, "-p", "-S", "-100"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 2e3
+    });
+  } catch {
+    return null;
+  }
+}
+function resizePane(target, cols, rows) {
+  resizeTmuxWindow(target, cols, rows);
+}
+class SessionsWsManager {
+  clients = /* @__PURE__ */ new Set();
+  unsubscribe = null;
+  interruptCheckTimer = null;
+  lastHash = "";
+  config;
+  droppedClients = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /** Get current stats */
+  getStats() {
+    return {
+      clients: this.clients.size,
+      droppedClients: this.droppedClients
+    };
+  }
+  /**
+   * Add a client. Returns false if max clients reached.
+   */
+  addClient(client) {
+    if (this.clients.size >= this.config.maxSessionsClients) {
+      log(
+        {
+          level: "warn",
+          component: "sessions",
+          message: "Max clients reached, rejecting connection",
+          data: { current: this.clients.size, max: this.config.maxSessionsClients }
+        },
+        this.config
+      );
+      return false;
+    }
+    this.clients.add(client);
+    log(
+      {
+        level: "debug",
+        component: "sessions",
+        message: "Client connected",
+        data: { total: this.clients.size }
+      },
+      this.config
+    );
+    if (this.clients.size === 1 && !this.unsubscribe) {
+      console.log("[ws:sessions] First client, subscribing to watcher");
+      this.unsubscribe = sessionWatcher.subscribe(() => this.broadcastIfChanged());
+      this.interruptCheckTimer = setInterval(() => {
+        syncSessionStates();
+        this.broadcastIfChanged();
+      }, 500);
+    } else {
+      console.log("[ws:sessions] addClient: clients=", this.clients.size, "hasUnsubscribe=", !!this.unsubscribe);
+    }
+    this.sendToClient(client, this.createMessage("connected"));
+    return true;
+  }
+  removeClient(client) {
+    const had = this.clients.delete(client);
+    if (had) {
+      log(
+        {
+          level: "debug",
+          component: "sessions",
+          message: "Client disconnected",
+          data: { total: this.clients.size }
+        },
+        this.config
+      );
+    }
+    if (this.clients.size === 0 && this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+      this.lastHash = "";
+      if (this.interruptCheckTimer) {
+        clearInterval(this.interruptCheckTimer);
+        this.interruptCheckTimer = null;
+      }
+    }
+  }
+  createMessage(type) {
+    const sessions = getEnrichedSessions();
+    return { type, sessions, count: sessions.length, timestamp: Date.now() };
+  }
+  broadcastIfChanged() {
+    console.log("[ws:sessions] broadcastIfChanged called, clients:", this.clients.size);
+    const message = this.createMessage("sessions");
+    const hash = JSON.stringify(message.sessions);
+    if (hash === this.lastHash) {
+      console.log("[ws:sessions] Hash unchanged, skipping broadcast");
+      return;
+    }
+    console.log("[ws:sessions] Broadcasting to", this.clients.size, "clients");
+    this.lastHash = hash;
+    const data = JSON.stringify(message);
+    for (const client of this.clients) {
+      if (!this.sendToClient(client, message, data)) {
+        this.clients.delete(client);
+        this.droppedClients++;
+        log(
+          {
+            level: "warn",
+            component: "sessions",
+            message: "Dropped slow client",
+            data: { total: this.clients.size }
+          },
+          this.config
+        );
+      }
+    }
+  }
+  sendToClient(client, _message, data) {
+    try {
+      if (!client.isOpen()) return false;
+      if (client.getBufferedAmount) {
+        const buffered = client.getBufferedAmount();
+        if (buffered > 64 * 1024) {
+          log(
+            {
+              level: "warn",
+              component: "sessions",
+              message: "Client backpressure detected",
+              data: { buffered }
+            },
+            this.config
+          );
+          return false;
+        }
+      }
+      client.send(data ?? JSON.stringify(_message));
+      return true;
+    } catch (err) {
+      log(
+        {
+          level: "error",
+          component: "sessions",
+          message: "Failed to send to client",
+          data: { error: String(err) }
+        },
+        this.config
+      );
+      return false;
+    }
+  }
+}
+class TerminalWsManager {
+  clients = /* @__PURE__ */ new Map();
+  pollTimers = /* @__PURE__ */ new Map();
+  lastOutput = /* @__PURE__ */ new Map();
+  config;
+  totalClients = 0;
+  droppedClients = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /** Get current stats */
+  getStats() {
+    return {
+      totalClients: this.totalClients,
+      targets: this.clients.size,
+      droppedClients: this.droppedClients
+    };
+  }
+  /**
+   * Add a client for a target. Returns false if max clients reached.
+   */
+  addClient(client, target) {
+    if (this.totalClients >= this.config.maxTerminalClientsTotal) {
+      log(
+        {
+          level: "warn",
+          component: "terminal",
+          message: "Max total clients reached",
+          data: { current: this.totalClients, max: this.config.maxTerminalClientsTotal }
+        },
+        this.config
+      );
+      return false;
+    }
+    const targetClients = this.clients.get(target);
+    if (targetClients && targetClients.size >= this.config.maxTerminalClientsPerTarget) {
+      log(
+        {
+          level: "warn",
+          component: "terminal",
+          message: "Max clients per target reached",
+          data: { target, current: targetClients.size, max: this.config.maxTerminalClientsPerTarget }
+        },
+        this.config
+      );
+      return false;
+    }
+    if (!this.clients.has(target)) {
+      this.clients.set(target, /* @__PURE__ */ new Set());
+    }
+    this.clients.get(target).add(client);
+    this.totalClients++;
+    log(
+      {
+        level: "debug",
+        component: "terminal",
+        message: "Client connected",
+        data: { target, targetClients: this.clients.get(target).size, total: this.totalClients }
+      },
+      this.config
+    );
+    if (this.clients.get(target).size === 1) {
+      this.startPolling(target);
+    }
+    const output = capturePaneOutput(target) ?? "";
+    this.sendToClient(client, { type: "output", output, timestamp: Date.now() });
+    return true;
+  }
+  removeClient(client, target) {
+    if (target) {
+      const targetClients = this.clients.get(target);
+      if (targetClients && targetClients.delete(client)) {
+        this.totalClients--;
+        log(
+          {
+            level: "debug",
+            component: "terminal",
+            message: "Client disconnected",
+            data: { target, targetClients: targetClients.size, total: this.totalClients }
+          },
+          this.config
+        );
+        if (targetClients.size === 0) {
+          this.stopPolling(target);
+          this.clients.delete(target);
+          this.lastOutput.delete(target);
+        }
+      }
+    } else {
+      for (const [t, clients] of this.clients) {
+        if (clients.delete(client)) {
+          this.totalClients--;
+          if (clients.size === 0) {
+            this.stopPolling(t);
+            this.clients.delete(t);
+            this.lastOutput.delete(t);
+          }
+          break;
+        }
+      }
+    }
+  }
+  startPolling(target) {
+    if (this.pollTimers.has(target)) return;
+    const timer = setInterval(() => this.pollAndBroadcast(target), 200);
+    this.pollTimers.set(target, timer);
+  }
+  stopPolling(target) {
+    const timer = this.pollTimers.get(target);
+    if (timer) {
+      clearInterval(timer);
+      this.pollTimers.delete(target);
+    }
+  }
+  pollAndBroadcast(target) {
+    const output = capturePaneOutput(target) ?? "";
+    const lastOutput = this.lastOutput.get(target) ?? "";
+    if (output === lastOutput) return;
+    this.lastOutput.set(target, output);
+    const message = { type: "output", output, timestamp: Date.now() };
+    const data = JSON.stringify(message);
+    const clients = this.clients.get(target);
+    if (clients) {
+      for (const client of clients) {
+        if (!this.sendToClient(client, message, data)) {
+          clients.delete(client);
+          this.totalClients--;
+          this.droppedClients++;
+          log(
+            {
+              level: "warn",
+              component: "terminal",
+              message: "Dropped slow client",
+              data: { target, total: this.totalClients }
+            },
+            this.config
+          );
+        }
+      }
+      if (clients.size === 0) {
+        this.stopPolling(target);
+        this.clients.delete(target);
+        this.lastOutput.delete(target);
+      }
+    }
+  }
+  sendToClient(client, _message, data) {
+    try {
+      if (!client.isOpen()) return false;
+      if (client.getBufferedAmount) {
+        const buffered = client.getBufferedAmount();
+        if (buffered > 64 * 1024) {
+          log(
+            {
+              level: "warn",
+              component: "terminal",
+              message: "Client backpressure detected",
+              data: { buffered }
+            },
+            this.config
+          );
+          return false;
+        }
+      }
+      client.send(data ?? JSON.stringify(_message));
+      return true;
+    } catch (err) {
+      log(
+        {
+          level: "error",
+          component: "terminal",
+          message: "Failed to send to client",
+          data: { error: String(err) }
+        },
+        this.config
+      );
+      return false;
+    }
+  }
+}
+function handleWsMessage(msgStr, onResize) {
+  if (msgStr === "ping") {
+    return "pong";
+  }
+  if (onResize) {
+    try {
+      const msg = JSON.parse(msgStr);
+      if (msg.type === "resize" && typeof msg.cols === "number" && typeof msg.rows === "number") {
+        onResize(msg.cols, msg.rows);
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function getBeadsIssues(projectPath) {
+  try {
+    const result = execFileSync("bd", ["list", "--json"], {
+      encoding: "utf-8",
+      cwd: projectPath,
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 5e3
+    });
+    return JSON.parse(result);
+  } catch {
+    return [];
+  }
+}
+class BeadsProjectWatcher {
+  subscribers = /* @__PURE__ */ new Map();
+  pollTimers = /* @__PURE__ */ new Map();
+  lastMtime = /* @__PURE__ */ new Map();
+  pollInterval = 1e3;
+  /**
+   * Subscribe to changes in a project's beads issues
+   */
+  subscribe(projectPath, callback) {
+    if (!this.subscribers.has(projectPath)) {
+      this.subscribers.set(projectPath, /* @__PURE__ */ new Set());
+    }
+    this.subscribers.get(projectPath).add(callback);
+    if (this.subscribers.get(projectPath).size === 1) {
+      this.startWatching(projectPath);
+    }
+    return () => {
+      const subs = this.subscribers.get(projectPath);
+      if (subs) {
+        subs.delete(callback);
+        if (subs.size === 0) {
+          this.stopWatching(projectPath);
+          this.subscribers.delete(projectPath);
+        }
+      }
+    };
+  }
+  startWatching(projectPath) {
+    const issuesFile = join(projectPath, ".beads", "issues.jsonl");
+    try {
+      if (existsSync(issuesFile)) {
+        this.lastMtime.set(projectPath, statSync(issuesFile).mtimeMs);
+      }
+    } catch {
+    }
+    console.log("[beads-watcher] Started watching", projectPath);
+    const timer = setInterval(() => {
+      this.checkForChanges(projectPath, issuesFile);
+    }, this.pollInterval);
+    this.pollTimers.set(projectPath, timer);
+  }
+  stopWatching(projectPath) {
+    const timer = this.pollTimers.get(projectPath);
+    if (timer) {
+      clearInterval(timer);
+      this.pollTimers.delete(projectPath);
+    }
+    this.lastMtime.delete(projectPath);
+    console.log("[beads-watcher] Stopped watching", projectPath);
+  }
+  checkForChanges(projectPath, issuesFile) {
+    try {
+      if (!existsSync(issuesFile)) {
+        if (this.lastMtime.has(projectPath)) {
+          this.lastMtime.delete(projectPath);
+          this.notifySubscribers(projectPath);
+        }
+        return;
+      }
+      const currentMtime = statSync(issuesFile).mtimeMs;
+      const lastMtime = this.lastMtime.get(projectPath);
+      if (lastMtime === void 0 || currentMtime !== lastMtime) {
+        this.lastMtime.set(projectPath, currentMtime);
+        if (lastMtime !== void 0) {
+          console.log("[beads-watcher] Issues changed in", projectPath);
+          this.notifySubscribers(projectPath);
+        }
+      }
+    } catch {
+    }
+  }
+  notifySubscribers(projectPath) {
+    const subs = this.subscribers.get(projectPath);
+    if (subs) {
+      for (const callback of subs) {
+        try {
+          callback();
+        } catch (error) {
+          console.error("[beads-watcher] Subscriber error:", error);
+        }
+      }
+    }
+  }
+}
+const beadsWatcher = new BeadsProjectWatcher();
+class BeadsWsManager {
+  clients = /* @__PURE__ */ new Map();
+  unsubscribes = /* @__PURE__ */ new Map();
+  lastHash = /* @__PURE__ */ new Map();
+  config;
+  totalClients = 0;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  getStats() {
+    return {
+      totalClients: this.totalClients,
+      projects: this.clients.size
+    };
+  }
+  addClient(client, projectPath) {
+    if (!projectPath) return false;
+    if (!this.clients.has(projectPath)) {
+      this.clients.set(projectPath, /* @__PURE__ */ new Set());
+    }
+    this.clients.get(projectPath).add(client);
+    this.totalClients++;
+    log(
+      {
+        level: "debug",
+        component: "beads",
+        message: "Client connected",
+        data: { project: projectPath, total: this.totalClients }
+      },
+      this.config
+    );
+    if (this.clients.get(projectPath).size === 1 && !this.unsubscribes.has(projectPath)) {
+      console.log("[ws:beads] First client for project, subscribing to watcher");
+      const unsub = beadsWatcher.subscribe(
+        projectPath,
+        () => this.broadcastIfChanged(projectPath)
+      );
+      this.unsubscribes.set(projectPath, unsub);
+    }
+    this.sendToClient(client, this.createMessage(projectPath, "connected"));
+    return true;
+  }
+  removeClient(client, projectPath) {
+    if (projectPath) {
+      const projectClients = this.clients.get(projectPath);
+      if (projectClients && projectClients.delete(client)) {
+        this.totalClients--;
+        if (projectClients.size === 0) {
+          this.clients.delete(projectPath);
+          this.lastHash.delete(projectPath);
+          const unsub = this.unsubscribes.get(projectPath);
+          if (unsub) {
+            unsub();
+            this.unsubscribes.delete(projectPath);
+          }
+        }
+      }
+    } else {
+      for (const [project, clients] of this.clients) {
+        if (clients.delete(client)) {
+          this.totalClients--;
+          if (clients.size === 0) {
+            this.clients.delete(project);
+            this.lastHash.delete(project);
+            const unsub = this.unsubscribes.get(project);
+            if (unsub) {
+              unsub();
+              this.unsubscribes.delete(project);
+            }
+          }
+          break;
+        }
+      }
+    }
+  }
+  createMessage(projectPath, type) {
+    const issues = getBeadsIssues(projectPath);
+    return { type, issues, project: projectPath, timestamp: Date.now() };
+  }
+  broadcastIfChanged(projectPath) {
+    const message = this.createMessage(projectPath, "issues");
+    const hash = JSON.stringify(message.issues);
+    if (hash === this.lastHash.get(projectPath)) {
+      return;
+    }
+    this.lastHash.set(projectPath, hash);
+    const data = JSON.stringify(message);
+    const clients = this.clients.get(projectPath);
+    if (clients) {
+      console.log("[ws:beads] Broadcasting to", clients.size, "clients for", projectPath);
+      for (const client of clients) {
+        if (!this.sendToClient(client, message, data)) {
+          clients.delete(client);
+          this.totalClients--;
+        }
+      }
+      if (clients.size === 0) {
+        this.clients.delete(projectPath);
+        this.lastHash.delete(projectPath);
+        const unsub = this.unsubscribes.get(projectPath);
+        if (unsub) {
+          unsub();
+          this.unsubscribes.delete(projectPath);
+        }
+      }
+    }
+  }
+  sendToClient(client, _message, data) {
+    try {
+      if (!client.isOpen()) return false;
+      if (client.getBufferedAmount) {
+        const buffered = client.getBufferedAmount();
+        if (buffered > 64 * 1024) {
+          return false;
+        }
+      }
+      client.send(data ?? JSON.stringify(_message));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+function parseWsPath(pathname, searchParams) {
+  if (pathname === "/api/sessions/stream") {
+    return { type: "sessions" };
+  }
+  if (pathname === "/api/beads/stream") {
+    const project = searchParams?.get("project");
+    if (project) {
+      return { type: "beads", project: decodeURIComponent(project) };
+    }
+    return null;
+  }
+  const termMatch = pathname.match(/^\/api\/sessions\/([^/]+)\/stream$/);
+  if (termMatch) {
+    return { type: "terminal", target: decodeURIComponent(termMatch[1]) };
+  }
+  return null;
+}
+export {
+  BeadsWsManager as B,
+  SessionsWsManager as S,
+  TerminalWsManager as T,
+  getBeadsIssues as g,
+  handleWsMessage as h,
+  parseWsPath as p,
+  resizePane as r
+};