claude-mux 0.7.0

package/dist/web/server/chunks/ws-handlers-B4r5eSP2.js

@@ -0,0 +1,733 @@
+import { a as updateSession, n as getAllSessions } from "./sessions-json-DgfkCLO7.js";
+import { n as getPaneTitle, t as checkForInterruption } from "./pane-Dg3pKvsm.js";
+import { execFileSync } from "child_process";
+import { existsSync, readdirSync, statSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+//#region .svelte-kit/adapter-bun/chunks/ws-handlers.js
+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)));
+		execFileSync("tmux", [
+			"resize-window",
+			"-t",
+			target.replace(/\.\d+$/, ""),
+			"-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");
+join(join(homedir(), ".claude"), "settings.json");
+var SessionWatcher = class {
+	subscribers = /* @__PURE__ */ new Set();
+	pollTimer = null;
+	lastState = /* @__PURE__ */ new Map();
+	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();
+	return deduplicateByTmuxTarget(getAllSessions().map((s) => ({
+		...s,
+		pane_title: s.tmux_target ? getPaneTitle(s.tmux_target) : null
+	})));
+}
+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);
+}
+var SessionsWsManager = class {
+	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) {
+		if (this.clients.delete(client)) 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;
+		}
+	}
+};
+var TerminalWsManager = class {
+	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) ?? "";
+		if (output === (this.lastOutput.get(target) ?? "")) 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 [];
+	}
+}
+var BeadsProjectWatcher = class {
+	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();
+var BeadsWsManager = class {
+	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) {
+		return {
+			type,
+			issues: getBeadsIssues(projectPath),
+			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) {
+				if (client.getBufferedAmount() > 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;
+}
+
+//#endregion
+export { handleWsMessage as a, getBeadsIssues as i, SessionsWsManager as n, parseWsPath as o, TerminalWsManager as r, resizePane as s, BeadsWsManager as t };
+//# sourceMappingURL=ws-handlers-B4r5eSP2.js.map