claude-mux 0.7.0

package/web/.svelte-kit/adapter-bun/chunks/pane.js

@@ -0,0 +1,82 @@
+import { execFileSync } from "child_process";
+function isInTmux() {
+  return !!process.env.TMUX;
+}
+function getPaneTitle(target) {
+  try {
+    const result = execFileSync("tmux", ["display-message", "-p", "-t", target, "#{pane_title}"], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e3
+    });
+    return result.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function capturePaneContent(target) {
+  if (!isInTmux()) {
+    return null;
+  }
+  try {
+    const result = execFileSync("tmux", ["capture-pane", "-p", "-t", target], {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: 1e3
+    });
+    return result;
+  } catch {
+    return null;
+  }
+}
+function detectRecentInterruption(content) {
+  if (!content) return null;
+  const lines = content.split("\n");
+  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;
+  }
+  let bottomSepIdx = -1;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    if (lines[i].startsWith("─────")) {
+      bottomSepIdx = i;
+      break;
+    }
+  }
+  if (bottomSepIdx === -1) return null;
+  let topSepIdx = -1;
+  for (let i = bottomSepIdx - 1; i >= 0; i--) {
+    if (lines[i].startsWith("─────")) {
+      topSepIdx = i;
+      break;
+    }
+  }
+  if (topSepIdx === -1) return null;
+  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;
+  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;
+}
+function checkForInterruption(tmuxTarget) {
+  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;
+}
+export {
+  checkForInterruption as c,
+  getPaneTitle as g
+};

package/web/.svelte-kit/adapter-bun/chunks/sessions-json.js

@@ -0,0 +1,124 @@
+import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync, renameSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const CLAUDE_WATCH_DIR = join(homedir(), ".claude-watch");
+const DEFAULT_SESSIONS_DIR = join(CLAUDE_WATCH_DIR, "sessions");
+const SCHEMA_VERSION = 1;
+let sessionsDir = DEFAULT_SESSIONS_DIR;
+function ensureSessionsDir() {
+  if (!existsSync(sessionsDir)) {
+    mkdirSync(sessionsDir, { recursive: true });
+  }
+}
+function getSessionPath(id) {
+  return join(sessionsDir, `${id}.json`);
+}
+function writeSessionFile(session) {
+  ensureSessionsDir();
+  const path = getSessionPath(session.id);
+  const tmpPath = path + ".tmp";
+  writeFileSync(tmpPath, JSON.stringify(session, null, 2));
+  renameSync(tmpPath, path);
+}
+function getSession(id) {
+  const path = getSessionPath(id);
+  try {
+    if (!existsSync(path)) return null;
+    const data = readFileSync(path, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+function upsertSession(input) {
+  const existing = getSession(input.id);
+  const session = {
+    v: SCHEMA_VERSION,
+    id: input.id,
+    pid: input.pid,
+    cwd: input.cwd,
+    git_root: input.git_root ?? existing?.git_root ?? null,
+    beads_enabled: input.beads_enabled ?? existing?.beads_enabled ?? false,
+    tmux_target: input.tmux_target ?? existing?.tmux_target ?? null,
+    state: input.state ?? existing?.state ?? "busy",
+    current_action: input.current_action ?? existing?.current_action ?? null,
+    prompt_text: input.prompt_text ?? existing?.prompt_text ?? null,
+    last_update: Date.now()
+  };
+  writeSessionFile(session);
+}
+function updateSession(id, update) {
+  const session = getSession(id);
+  if (!session) return;
+  if (update.state !== void 0) {
+    session.state = update.state;
+  }
+  if (update.current_action !== void 0) {
+    session.current_action = update.current_action;
+  }
+  if (update.prompt_text !== void 0) {
+    session.prompt_text = update.prompt_text;
+  }
+  session.last_update = Date.now();
+  writeSessionFile(session);
+}
+function deleteSession(id) {
+  const path = getSessionPath(id);
+  try {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  } catch {
+  }
+}
+function removeScreenshot(id, screenshotPath) {
+  const session = getSession(id);
+  if (!session || !session.screenshots) return false;
+  const initialLength = session.screenshots.length;
+  session.screenshots = session.screenshots.filter((s) => s.path !== screenshotPath);
+  if (session.screenshots.length === initialLength) {
+    return false;
+  }
+  session.last_update = Date.now();
+  writeSessionFile(session);
+  return true;
+}
+function getAllSessions() {
+  ensureSessionsDir();
+  const sessions = [];
+  try {
+    const files = readdirSync(sessionsDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const data = readFileSync(join(sessionsDir, file), "utf-8");
+        sessions.push(JSON.parse(data));
+      } catch {
+        continue;
+      }
+    }
+  } catch {
+    return [];
+  }
+  const priority = {
+    permission: 1,
+    waiting: 2,
+    idle: 3,
+    busy: 4
+  };
+  sessions.sort((a, b) => {
+    const pa = priority[a.state] ?? 5;
+    const pb = priority[b.state] ?? 5;
+    if (pa !== pb) return pa - pb;
+    return b.last_update - a.last_update;
+  });
+  return sessions;
+}
+export {
+  updateSession as a,
+  getSession as b,
+  deleteSession as d,
+  getAllSessions as g,
+  removeScreenshot as r,
+  upsertSession as u
+};

package/web/.svelte-kit/adapter-bun/chunks/sessions.svelte.js

@@ -0,0 +1,229 @@
+import { f as ssr_context, g as getContext } from "./context.js";
+import { ae as lifecycle_function_unavailable } from "./index2.js";
+import "clsx";
+import "@sveltejs/kit/internal";
+import "./exports.js";
+import "./utils.js";
+import "@sveltejs/kit/internal/server";
+import "./state.svelte.js";
+function onDestroy(fn) {
+  /** @type {SSRContext} */
+  ssr_context.r.on_destroy(fn);
+}
+function mount() {
+  lifecycle_function_unavailable("mount");
+}
+function unmount() {
+  lifecycle_function_unavailable("unmount");
+}
+async function tick() {
+}
+const getStores = () => {
+  const stores$1 = getContext("__svelte__");
+  return {
+    /** @type {typeof page} */
+    page: {
+      subscribe: stores$1.page.subscribe
+    },
+    /** @type {typeof navigating} */
+    navigating: {
+      subscribe: stores$1.navigating.subscribe
+    },
+    /** @type {typeof updated} */
+    updated: stores$1.updated
+  };
+};
+const page = {
+  subscribe(fn) {
+    const store = getStores().page;
+    return store.subscribe(fn);
+  }
+};
+const DEFAULT_CONFIG = {
+  pingInterval: 3e4,
+  pongTimeout: 1e4,
+  baseReconnectDelay: 1e3,
+  maxReconnectDelay: 3e4
+};
+class ReliableWebSocket {
+  connected = false;
+  ws = null;
+  pingTimer = null;
+  reconnectTimer = null;
+  lastPong = 0;
+  reconnectAttempts = 0;
+  visibilityHandler = null;
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  /** Subclass can override to control reconnection (e.g., only reconnect if target is set) */
+  shouldReconnect() {
+    return true;
+  }
+  /** Subclass can override to run code on successful connection */
+  onConnected() {
+  }
+  /** Subclass can override to run code on disconnection */
+  onDisconnected() {
+  }
+  doConnect() {
+    return;
+  }
+  doDisconnect() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    this.stopPingTimer();
+    this.removeVisibilityHandler();
+    this.connected = false;
+    this.reconnectAttempts = 0;
+    if (this.ws) {
+      this.ws.onopen = null;
+      this.ws.onclose = null;
+      this.ws.onerror = null;
+      this.ws.onmessage = null;
+      if (this.ws.readyState !== WebSocket.CLOSED) {
+        this.ws.close();
+      }
+      this.ws = null;
+    }
+  }
+  /** Force reconnection (resets backoff) */
+  forceReconnect() {
+    this.reconnectAttempts = 0;
+    if (this.ws) {
+      this.ws.onclose = null;
+      this.ws.close();
+      this.ws = null;
+    }
+    this.stopPingTimer();
+    this.connected = false;
+    this.doConnect();
+  }
+  startPingTimer() {
+    this.stopPingTimer();
+    this.pingTimer = setInterval(
+      () => {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+          if (Date.now() - this.lastPong > this.config.pingInterval + this.config.pongTimeout) {
+            this.ws?.close();
+            return;
+          }
+          this.ws.send("ping");
+        }
+      },
+      this.config.pingInterval
+    );
+  }
+  stopPingTimer() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    const delay = Math.min(this.config.baseReconnectDelay * Math.pow(2, this.reconnectAttempts) + Math.random() * 1e3, this.config.maxReconnectDelay);
+    this.reconnectAttempts++;
+    this.reconnectTimer = setTimeout(
+      () => {
+        this.reconnectTimer = null;
+        this.doConnect();
+      },
+      delay
+    );
+  }
+  setupVisibilityHandler() {
+    if (this.visibilityHandler) return;
+    this.visibilityHandler = () => {
+      if (document.visibilityState === "visible" && this.shouldReconnect()) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+          this.forceReconnect();
+        } else {
+          this.ws.send("ping");
+        }
+      }
+    };
+    document.addEventListener("visibilitychange", this.visibilityHandler);
+  }
+  removeVisibilityHandler() {
+    if (this.visibilityHandler) {
+      document.removeEventListener("visibilitychange", this.visibilityHandler);
+      this.visibilityHandler = null;
+    }
+  }
+}
+class SessionStore extends ReliableWebSocket {
+  sessions = [];
+  paused = false;
+  // Saved projects from localStorage
+  savedProjects = [];
+  getWsUrl() {
+    const protocol = window.location.protocol === "https:" ? "wss:" : "ws:";
+    return `${protocol}//${window.location.host}/api/sessions/stream`;
+  }
+  getLogPrefix() {
+    return "[sessions]";
+  }
+  handleMessage(event) {
+    if (this.paused) return;
+    const data = JSON.parse(event.data);
+    if (data.sessions) {
+      this.sessions = data.sessions;
+    }
+  }
+  connect() {
+    this.doConnect();
+  }
+  disconnect() {
+    this.doDisconnect();
+  }
+  togglePause() {
+    this.paused = !this.paused;
+  }
+  loadSavedProjects() {
+    return;
+  }
+  saveProject(cwd) {
+    return;
+  }
+  removeProject(cwd) {
+    this.savedProjects = this.savedProjects.filter((p) => p !== cwd);
+    localStorage.setItem("claude-mux-projects", JSON.stringify(this.savedProjects));
+  }
+}
+const sessionStore = new SessionStore();
+function stateColor(state) {
+  switch (state) {
+    case "permission":
+    case "waiting":
+      return "#e74c3c";
+    case "idle":
+      return "#f39c12";
+    case "busy":
+      return "#27ae60";
+    default:
+      return "#666";
+  }
+}
+function getProjectColor(cwd) {
+  let hash = 0;
+  for (let i = 0; i < cwd.length; i++) {
+    hash = cwd.charCodeAt(i) + ((hash << 5) - hash);
+  }
+  const hue = Math.abs(hash) % 360;
+  return `hsl(${hue}, 60%, 40%)`;
+}
+export {
+  ReliableWebSocket as R,
+  stateColor as a,
+  getProjectColor as g,
+  mount as m,
+  onDestroy as o,
+  page as p,
+  sessionStore as s,
+  tick as t,
+  unmount as u
+};