tmux-agent-monitor 0.0.1 → 0.0.4

package/dist/index.js

@@ -0,0 +1,2575 @@
+#!/usr/bin/env node
+import { a as resolveServerKey, c as allowedKeys, i as resolveLogPaths, l as defaultConfig, n as configSchema, o as compileDangerPatterns, r as wsClientMessageSchema, s as isDangerousCommand, t as claudeHookEventSchema } from "./src-CFxYk-pF.mjs";
+import { serve } from "@hono/node-server";
+import { execa } from "execa";
+import qrcode from "qrcode-terminal";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { serveStatic } from "@hono/node-server/serve-static";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { Hono } from "hono";
+import crypto, { randomUUID } from "node:crypto";
+import os, { networkInterfaces } from "node:os";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import fs$1 from "node:fs/promises";
+import { createServer } from "node:net";
+
+//#region packages/tmux/src/adapter.ts
+const buildArgs = (args, options) => {
+	const prefix = [];
+	if (options.socketName) prefix.push("-L", options.socketName);
+	if (options.socketPath) prefix.push("-S", options.socketPath);
+	return [...prefix, ...args];
+};
+const createTmuxAdapter = (options = {}) => {
+	const run = async (args) => {
+		const result = await execa("tmux", buildArgs(args, options), { reject: false });
+		return {
+			stdout: result.stdout,
+			stderr: result.stderr,
+			exitCode: result.exitCode ?? 0
+		};
+	};
+	return { run };
+};
+
+//#endregion
+//#region packages/tmux/src/inspector.ts
+const format = [
+	"#{pane_id}",
+	"#{session_name}",
+	"#{window_index}",
+	"#{pane_index}",
+	"#{window_activity}",
+	"#{pane_active}",
+	"#{pane_current_command}",
+	"#{pane_current_path}",
+	"#{pane_tty}",
+	"#{pane_dead}",
+	"#{pane_pipe}",
+	"#{alternate_on}",
+	"#{pane_pid}",
+	"#{pane_title}",
+	"#{pane_start_command}",
+	"#{@tmux-agent-monitor_pipe}"
+].join("	");
+const toNullable = (value) => {
+	if (!value) return null;
+	const trimmed = value.trim();
+	return trimmed.length === 0 ? null : trimmed;
+};
+const toNumber = (value) => {
+	if (!value) return null;
+	const parsed = Number.parseInt(value, 10);
+	return Number.isNaN(parsed) ? null : parsed;
+};
+const toEpochSeconds = (value) => {
+	if (!value) return null;
+	const parsed = Number.parseInt(value, 10);
+	if (Number.isNaN(parsed) || parsed <= 0) return null;
+	return parsed;
+};
+const toBool = (value) => {
+	return value === "1" || value === "on" || value === "true";
+};
+const parseLine = (line) => {
+	if (!line) return null;
+	const parts = line.split("	");
+	if (parts.length < 16) return null;
+	const [paneIdRaw, sessionNameRaw, windowIndexRaw, paneIndexRaw, windowActivityRaw, paneActiveRaw, currentCommand, currentPath, paneTty, paneDead, panePipe, alternateOn, panePid, paneTitle, paneStartCommand, pipeTagValue] = parts;
+	if (!paneIdRaw || !sessionNameRaw) return null;
+	const paneId = paneIdRaw;
+	const sessionName = sessionNameRaw;
+	const windowIndex = windowIndexRaw ?? "0";
+	const paneIndex = paneIndexRaw ?? "0";
+	return {
+		paneId,
+		sessionName,
+		windowIndex: Number.parseInt(windowIndex, 10),
+		paneIndex: Number.parseInt(paneIndex, 10),
+		windowActivity: toEpochSeconds(windowActivityRaw),
+		paneActive: toBool(paneActiveRaw),
+		currentCommand: toNullable(currentCommand),
+		currentPath: toNullable(currentPath),
+		paneTty: toNullable(paneTty),
+		paneDead: toBool(paneDead),
+		panePipe: toBool(panePipe),
+		alternateOn: toBool(alternateOn),
+		panePid: toNumber(panePid),
+		paneTitle: toNullable(paneTitle),
+		paneStartCommand: toNullable(paneStartCommand),
+		pipeTagValue: toNullable(pipeTagValue)
+	};
+};
+const createInspector = (adapter) => {
+	const listPanes = async () => {
+		const result = await adapter.run([
+			"list-panes",
+			"-a",
+			"-F",
+			format
+		]);
+		if (result.exitCode !== 0) throw new Error(result.stderr || "tmux list-panes failed");
+		return result.stdout.split("\n").map((line) => line.replace(/\r$/, "")).filter((line) => line.length > 0).map(parseLine).filter((pane) => pane !== null);
+	};
+	const readUserOption = async (paneId, key) => {
+		const result = await adapter.run([
+			"show-options",
+			"-t",
+			paneId,
+			"-v",
+			key
+		]);
+		if (result.exitCode !== 0) return null;
+		return toNullable(result.stdout);
+	};
+	const writeUserOption = async (paneId, key, value) => {
+		if (value === null) {
+			await adapter.run([
+				"set-option",
+				"-t",
+				paneId,
+				"-u",
+				key
+			]);
+			return;
+		}
+		await adapter.run([
+			"set-option",
+			"-t",
+			paneId,
+			key,
+			value
+		]);
+	};
+	return {
+		listPanes,
+		readUserOption,
+		writeUserOption
+	};
+};
+
+//#endregion
+//#region packages/tmux/src/pipe.ts
+const buildPipeCommand = (logPath) => {
+	return `cat >> "${logPath.replace(/"/g, "\\\"")}"`;
+};
+const hasConflict = (state) => {
+	return state.panePipe && state.pipeTagValue !== "1";
+};
+const createPipeManager = (adapter) => {
+	const attachPipe = async (paneId, logPath, state) => {
+		if (hasConflict(state)) return {
+			attached: false,
+			conflict: true
+		};
+		const command = buildPipeCommand(logPath);
+		if ((await adapter.run([
+			"pipe-pane",
+			"-o",
+			"-t",
+			paneId,
+			command
+		])).exitCode !== 0) return {
+			attached: false,
+			conflict: false
+		};
+		await adapter.run([
+			"set-option",
+			"-t",
+			paneId,
+			"@tmux-agent-monitor_pipe",
+			"1"
+		]);
+		return {
+			attached: true,
+			conflict: false
+		};
+	};
+	return {
+		attachPipe,
+		hasConflict
+	};
+};
+
+//#endregion
+//#region packages/tmux/src/screen.ts
+const normalizeScreen = (text, lineLimit) => {
+	const lines = text.replace(/\r/g, "").split("\n");
+	while (lines.length > 0 && lines[lines.length - 1]?.trim() === "") lines.pop();
+	if (lines.length > lineLimit) return lines.slice(-lineLimit).join("\n");
+	return lines.join("\n");
+};
+const resolveAltFlag = (altScreen, alternateOn) => {
+	if (altScreen === "on") return true;
+	if (altScreen === "off") return false;
+	return alternateOn;
+};
+const getPaneSize = async (adapter, paneId) => {
+	const result = await adapter.run([
+		"display-message",
+		"-p",
+		"-t",
+		paneId,
+		"#{history_size}	#{pane_height}"
+	]);
+	if (result.exitCode !== 0) return null;
+	const [historySize, paneHeight] = result.stdout.trim().split("	");
+	const history = Number.parseInt(historySize ?? "", 10);
+	const height = Number.parseInt(paneHeight ?? "", 10);
+	if (Number.isNaN(history) || Number.isNaN(height)) return null;
+	return {
+		historySize: history,
+		paneHeight: height
+	};
+};
+const createScreenCapture = (adapter) => {
+	const captureText = async (options) => {
+		const args = [
+			"capture-pane",
+			"-p",
+			"-t",
+			options.paneId
+		];
+		if (options.joinLines) args.push("-J");
+		if (options.includeAnsi) args.push("-e");
+		if (resolveAltFlag(options.altScreen, options.alternateOn)) args.push("-a");
+		args.push("-S", `-${options.lines}`, "-E", "-");
+		const result = await adapter.run(args);
+		if (result.exitCode !== 0) throw new Error(result.stderr || "capture-pane failed");
+		const size = await getPaneSize(adapter, options.paneId);
+		const truncated = size === null ? null : size.historySize + size.paneHeight > options.lines;
+		return {
+			screen: normalizeScreen(result.stdout, options.lines),
+			truncated,
+			alternateOn: options.alternateOn
+		};
+	};
+	return { captureText };
+};
+
+//#endregion
+//#region apps/server/src/config.ts
+const configDirName = ".tmux-agent-monitor";
+const getConfigDir = () => {
+	return path.join(os.homedir(), configDirName);
+};
+const getConfigPath = () => {
+	return path.join(getConfigDir(), "config.json");
+};
+const ensureDir$1 = (dir) => {
+	fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+};
+const writeFileSafe = (filePath, data) => {
+	fs.writeFileSync(filePath, data, {
+		encoding: "utf8",
+		mode: 384
+	});
+	try {
+		fs.chmodSync(filePath, 384);
+	} catch {}
+};
+const generateToken = () => {
+	return crypto.randomBytes(32).toString("hex");
+};
+const loadConfig = () => {
+	const configPath = getConfigPath();
+	try {
+		const raw = fs.readFileSync(configPath, "utf8");
+		const parsed = configSchema.safeParse(JSON.parse(raw));
+		if (!parsed.success) return null;
+		return parsed.data;
+	} catch {
+		return null;
+	}
+};
+const saveConfig = (config) => {
+	ensureDir$1(getConfigDir());
+	writeFileSafe(getConfigPath(), `${JSON.stringify(config, null, 2)}\n`);
+};
+const ensureConfig = (overrides) => {
+	const existing = loadConfig();
+	if (existing) {
+		let next = existing;
+		let migrated = false;
+		if (existing.port === 10080 && defaultConfig.port === 11080) {
+			next = {
+				...existing,
+				port: defaultConfig.port
+			};
+			migrated = true;
+		}
+		if (existing.screen?.image?.enabled === false && defaultConfig.screen.image.enabled === true) {
+			next = {
+				...next,
+				screen: {
+					...next.screen,
+					image: {
+						...next.screen.image,
+						enabled: true
+					}
+				}
+			};
+			migrated = true;
+		}
+		if (migrated) saveConfig(next);
+		return {
+			...next,
+			...overrides
+		};
+	}
+	const token = generateToken();
+	const config = {
+		...defaultConfig,
+		...overrides,
+		token
+	};
+	saveConfig(config);
+	return config;
+};
+const rotateToken = () => {
+	const config = ensureConfig();
+	const token = generateToken();
+	const next = {
+		...config,
+		token
+	};
+	saveConfig(next);
+	return next;
+};
+
+//#endregion
+//#region apps/server/src/git-commits.ts
+const execFileAsync$3 = promisify(execFile);
+const LOG_TTL_MS = 3e3;
+const DETAIL_TTL_MS = 3e3;
+const FILE_TTL_MS$1 = 3e3;
+const MAX_PATCH_BYTES$1 = 2e6;
+const MAX_OUTPUT_BUFFER$1 = 2e7;
+const RECORD_SEPARATOR = "";
+const FIELD_SEPARATOR = "";
+const nowIso$1 = () => (/* @__PURE__ */ new Date()).toISOString();
+const logCache = /* @__PURE__ */ new Map();
+const detailCache = /* @__PURE__ */ new Map();
+const fileCache$1 = /* @__PURE__ */ new Map();
+const runGit$1 = async (cwd, args) => {
+	try {
+		return (await execFileAsync$3("git", [
+			"-C",
+			cwd,
+			...args
+		], {
+			encoding: "utf8",
+			timeout: 5e3,
+			maxBuffer: MAX_OUTPUT_BUFFER$1
+		})).stdout ?? "";
+	} catch (err) {
+		if (err && typeof err === "object" && "stdout" in err) return err.stdout ?? "";
+		throw err;
+	}
+};
+const resolveRepoRoot$1 = async (cwd) => {
+	try {
+		const trimmed = (await runGit$1(cwd, ["rev-parse", "--show-toplevel"])).trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+};
+const resolveHead = async (repoRoot) => {
+	try {
+		const trimmed = (await runGit$1(repoRoot, ["rev-parse", "HEAD"])).trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+};
+const pickStatus$1 = (value) => {
+	const allowed = [
+		"A",
+		"M",
+		"D",
+		"R",
+		"C",
+		"U",
+		"?"
+	];
+	const status = value.toUpperCase().slice(0, 1);
+	return allowed.includes(status) ? status : "?";
+};
+const isBinaryPatch$1 = (patch) => patch.includes("Binary files ") || patch.includes("GIT binary patch") || patch.includes("literal ");
+const parseCommitLogOutput = (output) => {
+	if (!output) return [];
+	const records = output.split(RECORD_SEPARATOR).filter((record) => record.trim().length > 0);
+	const commits = [];
+	for (const record of records) {
+		const [hash = "", shortHash = "", authorName = "", authorEmailRaw = "", authoredAt = "", subject = "", bodyRaw = ""] = record.split(FIELD_SEPARATOR);
+		if (!hash) continue;
+		const body = bodyRaw.trim().length > 0 ? bodyRaw : null;
+		const authorEmail = authorEmailRaw.trim().length > 0 ? authorEmailRaw : null;
+		commits.push({
+			hash,
+			shortHash,
+			subject,
+			body,
+			authorName,
+			authorEmail,
+			authoredAt
+		});
+	}
+	return commits;
+};
+const parseNumstat$1 = (output) => {
+	const stats = /* @__PURE__ */ new Map();
+	const lines = output.split("\n").filter((line) => line.trim().length > 0);
+	for (const line of lines) {
+		const parts = line.split("	");
+		if (parts.length < 3) continue;
+		const addRaw = parts[0] ?? "";
+		const delRaw = parts[1] ?? "";
+		const pathValue = parts[parts.length - 1] ?? "";
+		const additions = addRaw === "-" ? null : Number.parseInt(addRaw, 10);
+		const deletions = delRaw === "-" ? null : Number.parseInt(delRaw, 10);
+		stats.set(pathValue, {
+			additions: Number.isFinite(additions) ? additions : null,
+			deletions: Number.isFinite(deletions) ? deletions : null
+		});
+	}
+	return stats;
+};
+const parseNameStatusOutput = (output) => {
+	const files = [];
+	const lines = output.split("\n").filter((line) => line.trim().length > 0);
+	for (const line of lines) {
+		const parts = line.split("	");
+		if (parts.length < 2) continue;
+		const status = pickStatus$1(parts[0] ?? "");
+		if (status === "R" || status === "C") {
+			if (parts.length >= 3) files.push({
+				status,
+				renamedFrom: parts[1] ?? void 0,
+				path: parts[2] ?? parts[1] ?? "",
+				additions: null,
+				deletions: null
+			});
+			continue;
+		}
+		files.push({
+			status,
+			path: parts[1] ?? "",
+			additions: null,
+			deletions: null
+		});
+	}
+	return files.filter((file) => file.path.length > 0);
+};
+const findStatForFile = (stats, file) => {
+	const direct = stats.get(file.path);
+	if (direct) return direct;
+	if (file.renamedFrom) {
+		const renameDirect = stats.get(file.renamedFrom);
+		if (renameDirect) return renameDirect;
+	}
+	for (const [key, value] of stats.entries()) {
+		if (file.renamedFrom && key.includes(file.renamedFrom) && key.includes(file.path)) return value;
+		if (key.includes(file.path)) return value;
+	}
+	return null;
+};
+const buildCommitLogSignature = (log) => {
+	return JSON.stringify({
+		repoRoot: log.repoRoot ?? null,
+		rev: log.rev ?? null,
+		reason: log.reason ?? null,
+		commits: log.commits.map((commit) => commit.hash)
+	});
+};
+const fetchCommitLog = async (cwd, options) => {
+	if (!cwd) return {
+		repoRoot: null,
+		rev: null,
+		generatedAt: nowIso$1(),
+		commits: [],
+		reason: "cwd_unknown"
+	};
+	const repoRoot = await resolveRepoRoot$1(cwd);
+	if (!repoRoot) return {
+		repoRoot: null,
+		rev: null,
+		generatedAt: nowIso$1(),
+		commits: [],
+		reason: "not_git"
+	};
+	const limit = Math.max(1, Math.min(options?.limit ?? 10, 50));
+	const skip = Math.max(0, options?.skip ?? 0);
+	const head = await resolveHead(repoRoot);
+	const cacheKey = `${repoRoot}:${limit}:${skip}`;
+	const cached = logCache.get(cacheKey);
+	const nowMs = Date.now();
+	if (!options?.force && cached && nowMs - cached.at < LOG_TTL_MS && cached.rev === head) return cached.log;
+	try {
+		const format = [
+			RECORD_SEPARATOR,
+			"%H",
+			FIELD_SEPARATOR,
+			"%h",
+			FIELD_SEPARATOR,
+			"%an",
+			FIELD_SEPARATOR,
+			"%ae",
+			FIELD_SEPARATOR,
+			"%ad",
+			FIELD_SEPARATOR,
+			"%s",
+			FIELD_SEPARATOR,
+			"%b"
+		].join("");
+		const commits = parseCommitLogOutput(await runGit$1(repoRoot, [
+			"log",
+			"-n",
+			String(limit),
+			"--skip",
+			String(skip),
+			"--date=iso-strict",
+			`--format=${format}`
+		]));
+		const log = {
+			repoRoot,
+			rev: head,
+			generatedAt: nowIso$1(),
+			commits
+		};
+		logCache.set(cacheKey, {
+			at: nowMs,
+			rev: head,
+			log,
+			signature: buildCommitLogSignature(log)
+		});
+		return log;
+	} catch {
+		return {
+			repoRoot,
+			rev: head,
+			generatedAt: nowIso$1(),
+			commits: [],
+			reason: "error"
+		};
+	}
+};
+const fetchCommitDetail = async (repoRoot, hash, options) => {
+	const cacheKey = `${repoRoot}:${hash}`;
+	const cached = detailCache.get(cacheKey);
+	const nowMs = Date.now();
+	if (!options?.force && cached && nowMs - cached.at < DETAIL_TTL_MS) return cached.detail;
+	try {
+		const meta = parseCommitLogOutput(await runGit$1(repoRoot, [
+			"show",
+			"-s",
+			"--date=iso-strict",
+			`--format=${[
+				RECORD_SEPARATOR,
+				"%H",
+				FIELD_SEPARATOR,
+				"%h",
+				FIELD_SEPARATOR,
+				"%an",
+				FIELD_SEPARATOR,
+				"%ae",
+				FIELD_SEPARATOR,
+				"%ad",
+				FIELD_SEPARATOR,
+				"%s",
+				FIELD_SEPARATOR,
+				"%b"
+			].join("")}`,
+			hash
+		]))[0];
+		if (!meta) return null;
+		const nameStatusOutput = await runGit$1(repoRoot, [
+			"show",
+			"--name-status",
+			"--format=",
+			hash
+		]);
+		const numstatOutput = await runGit$1(repoRoot, [
+			"show",
+			"--numstat",
+			"--format=",
+			hash
+		]);
+		const files = parseNameStatusOutput(nameStatusOutput);
+		const stats = parseNumstat$1(numstatOutput);
+		const withStats = files.map((file) => {
+			const stat = findStatForFile(stats, file);
+			return {
+				...file,
+				additions: stat?.additions ?? null,
+				deletions: stat?.deletions ?? null
+			};
+		});
+		const detail = {
+			...meta,
+			files: withStats
+		};
+		detailCache.set(cacheKey, {
+			at: nowMs,
+			detail
+		});
+		return detail;
+	} catch {
+		return null;
+	}
+};
+const fetchCommitFile = async (repoRoot, hash, file, options) => {
+	const cacheKey = `${repoRoot}:${hash}:${file.path}`;
+	const cached = fileCache$1.get(cacheKey);
+	const nowMs = Date.now();
+	if (!options?.force && cached && nowMs - cached.at < FILE_TTL_MS$1) return cached.file;
+	let patch = "";
+	try {
+		patch = await runGit$1(repoRoot, [
+			"show",
+			"--find-renames",
+			hash,
+			"--",
+			file.path
+		]);
+		if (!patch && file.renamedFrom) patch = await runGit$1(repoRoot, [
+			"show",
+			"--find-renames",
+			hash,
+			"--",
+			file.renamedFrom
+		]);
+	} catch {
+		patch = "";
+	}
+	const binary = isBinaryPatch$1(patch) || file.additions === null || file.deletions === null;
+	let truncated = false;
+	if (patch.length > MAX_PATCH_BYTES$1) {
+		truncated = true;
+		patch = patch.slice(0, MAX_PATCH_BYTES$1);
+	}
+	const diff = {
+		path: file.path,
+		status: file.status,
+		patch: patch.length > 0 ? patch : null,
+		binary,
+		truncated
+	};
+	fileCache$1.set(cacheKey, {
+		at: nowMs,
+		file: diff
+	});
+	return diff;
+};
+
+//#endregion
+//#region apps/server/src/git-diff.ts
+const execFileAsync$2 = promisify(execFile);
+const SUMMARY_TTL_MS = 3e3;
+const FILE_TTL_MS = 3e3;
+const MAX_PATCH_BYTES = 2e6;
+const MAX_OUTPUT_BUFFER = 2e7;
+const nowIso = () => (/* @__PURE__ */ new Date()).toISOString();
+const summaryCache = /* @__PURE__ */ new Map();
+const fileCache = /* @__PURE__ */ new Map();
+const createRevision = (statusOutput) => crypto.createHash("sha1").update(statusOutput).digest("hex");
+const runGit = async (cwd, args) => {
+	try {
+		return (await execFileAsync$2("git", [
+			"-C",
+			cwd,
+			...args
+		], {
+			encoding: "utf8",
+			timeout: 5e3,
+			maxBuffer: MAX_OUTPUT_BUFFER
+		})).stdout ?? "";
+	} catch (err) {
+		if (err && typeof err === "object" && "stdout" in err) return err.stdout ?? "";
+		throw err;
+	}
+};
+const resolveRepoRoot = async (cwd) => {
+	try {
+		const trimmed = (await runGit(cwd, ["rev-parse", "--show-toplevel"])).trim();
+		return trimmed.length > 0 ? trimmed : null;
+	} catch {
+		return null;
+	}
+};
+const pickStatus = (value) => {
+	return [
+		"A",
+		"M",
+		"D",
+		"R",
+		"C",
+		"U",
+		"?"
+	].includes(value) ? value : "?";
+};
+const parseNumstat = (output) => {
+	const stats = /* @__PURE__ */ new Map();
+	const lines = output.split("\n").filter((line) => line.trim().length > 0);
+	for (const line of lines) {
+		const parts = line.split("	");
+		if (parts.length < 3) continue;
+		const addRaw = parts[0] ?? "";
+		const delRaw = parts[1] ?? "";
+		const pathValue = parts[parts.length - 1] ?? "";
+		const additions = addRaw === "-" ? null : Number.parseInt(addRaw, 10);
+		const deletions = delRaw === "-" ? null : Number.parseInt(delRaw, 10);
+		stats.set(pathValue, {
+			additions: Number.isFinite(additions) ? additions : null,
+			deletions: Number.isFinite(deletions) ? deletions : null
+		});
+	}
+	return stats;
+};
+const parseNumstatLine = (output) => {
+	const line = output.split("\n").map((value) => value.trim()).find((value) => value.length > 0);
+	if (!line) return null;
+	const parts = line.split("	");
+	if (parts.length < 2) return null;
+	const addRaw = parts[0] ?? "";
+	const delRaw = parts[1] ?? "";
+	const additions = addRaw === "-" ? null : Number.parseInt(addRaw, 10);
+	const deletions = delRaw === "-" ? null : Number.parseInt(delRaw, 10);
+	return {
+		additions: Number.isFinite(additions) ? additions : null,
+		deletions: Number.isFinite(deletions) ? deletions : null
+	};
+};
+const parseGitStatus = (statusOutput) => {
+	if (!statusOutput) return [];
+	const tokens = statusOutput.split("\0").filter((token) => token.length > 0);
+	const files = [];
+	for (let i = 0; i < tokens.length; i += 1) {
+		const token = tokens[i] ?? "";
+		if (token.length < 3) continue;
+		const statusCode = token.slice(0, 2);
+		if (statusCode === "!!") continue;
+		const rawPath = token.length > 3 ? token.slice(3) : "";
+		if (!rawPath) continue;
+		let pathValue = rawPath;
+		let renamedFrom;
+		const xStatus = statusCode[0] ?? " ";
+		const yStatus = statusCode[1] ?? " ";
+		if ((xStatus === "R" || xStatus === "C" || yStatus === "R" || yStatus === "C") && tokens[i + 1]) {
+			renamedFrom = rawPath;
+			pathValue = tokens[i + 1] ?? rawPath;
+			i += 1;
+		}
+		const staged = xStatus !== " " && xStatus !== "?";
+		let status;
+		if (statusCode === "??") status = "?";
+		else if (xStatus !== " ") status = pickStatus(xStatus);
+		else status = pickStatus(yStatus);
+		files.push({
+			path: pathValue,
+			status,
+			staged,
+			renamedFrom
+		});
+	}
+	return files;
+};
+const resolveSafePath = (repoRoot, filePath) => {
+	const resolved = path.resolve(repoRoot, filePath);
+	const normalizedRoot = repoRoot.endsWith(path.sep) ? repoRoot : `${repoRoot}${path.sep}`;
+	if (!resolved.startsWith(normalizedRoot)) return null;
+	return resolved;
+};
+const fetchDiffSummary = async (cwd, options) => {
+	if (!cwd) return {
+		repoRoot: null,
+		rev: null,
+		generatedAt: nowIso(),
+		files: [],
+		reason: "cwd_unknown"
+	};
+	const repoRoot = await resolveRepoRoot(cwd);
+	if (!repoRoot) return {
+		repoRoot: null,
+		rev: null,
+		generatedAt: nowIso(),
+		files: [],
+		reason: "not_git"
+	};
+	const cached = summaryCache.get(repoRoot);
+	const nowMs = Date.now();
+	if (!options?.force && cached && nowMs - cached.at < SUMMARY_TTL_MS) return cached.summary;
+	try {
+		const statusOutput = await runGit(repoRoot, [
+			"status",
+			"--porcelain",
+			"-z"
+		]);
+		const files = parseGitStatus(statusOutput);
+		const stats = parseNumstat(await runGit(repoRoot, [
+			"diff",
+			"HEAD",
+			"--numstat",
+			"--"
+		]));
+		const untrackedStats = /* @__PURE__ */ new Map();
+		for (const file of files) {
+			if (file.status !== "?") continue;
+			const safePath = resolveSafePath(repoRoot, file.path);
+			if (!safePath) continue;
+			const parsed = parseNumstatLine(await runGit(repoRoot, [
+				"diff",
+				"--no-index",
+				"--numstat",
+				"--",
+				"/dev/null",
+				safePath
+			]));
+			if (parsed) untrackedStats.set(file.path, parsed);
+		}
+		const withStats = files.map((file) => {
+			const stat = file.status === "?" ? untrackedStats.get(file.path) : stats.get(file.path);
+			return {
+				...file,
+				additions: stat?.additions ?? null,
+				deletions: stat?.deletions ?? null
+			};
+		});
+		const summary = {
+			repoRoot,
+			rev: createRevision(statusOutput),
+			generatedAt: nowIso(),
+			files: withStats
+		};
+		summaryCache.set(repoRoot, {
+			at: nowMs,
+			summary,
+			statusOutput
+		});
+		return summary;
+	} catch {
+		return {
+			repoRoot,
+			rev: null,
+			generatedAt: nowIso(),
+			files: [],
+			reason: "error"
+		};
+	}
+};
+const isBinaryPatch = (patch) => patch.includes("Binary files ") || patch.includes("GIT binary patch") || patch.includes("literal ");
+const fetchDiffFile = async (repoRoot, file, rev, options) => {
+	const cacheKey = `${repoRoot}:${file.path}:${rev}`;
+	const cached = fileCache.get(cacheKey);
+	const nowMs = Date.now();
+	if (!options?.force && cached && nowMs - cached.at < FILE_TTL_MS) return cached.file;
+	const safePath = resolveSafePath(repoRoot, file.path);
+	if (!safePath) return {
+		path: file.path,
+		status: file.status,
+		patch: null,
+		binary: false,
+		truncated: false,
+		rev
+	};
+	let patch = "";
+	let numstat = null;
+	try {
+		if (file.status === "?") {
+			patch = await runGit(repoRoot, [
+				"diff",
+				"--no-index",
+				"--",
+				"/dev/null",
+				safePath
+			]);
+			numstat = parseNumstatLine(await runGit(repoRoot, [
+				"diff",
+				"--no-index",
+				"--numstat",
+				"--",
+				"/dev/null",
+				safePath
+			]));
+		} else {
+			patch = await runGit(repoRoot, [
+				"diff",
+				"HEAD",
+				"--",
+				file.path
+			]);
+			numstat = parseNumstatLine(await runGit(repoRoot, [
+				"diff",
+				"HEAD",
+				"--numstat",
+				"--",
+				file.path
+			]));
+		}
+	} catch {
+		patch = "";
+	}
+	const binary = isBinaryPatch(patch) || numstat?.additions === null || numstat?.deletions === null;
+	let truncated = false;
+	if (patch.length > MAX_PATCH_BYTES) {
+		truncated = true;
+		patch = patch.slice(0, MAX_PATCH_BYTES);
+	}
+	const diffFile = {
+		path: file.path,
+		status: file.status,
+		patch: patch.length > 0 ? patch : null,
+		binary,
+		truncated,
+		rev
+	};
+	fileCache.set(cacheKey, {
+		at: nowMs,
+		rev,
+		file: diffFile
+	});
+	return diffFile;
+};
+
+//#endregion
+//#region apps/server/src/activity-suppressor.ts
+const lastPaneFocusAt = /* @__PURE__ */ new Map();
+const SUPPRESS_WINDOW_MS = 2e3;
+const STALE_WINDOW_MS = 15e3;
+const markPaneFocus = (paneId) => {
+	if (!paneId) return;
+	lastPaneFocusAt.set(paneId, Date.now());
+};
+const shouldSuppressActivity = (paneId, activityIso) => {
+	if (!paneId || !activityIso) return false;
+	const lastFocus = lastPaneFocusAt.get(paneId);
+	if (!lastFocus) return false;
+	const activityTs = Date.parse(activityIso);
+	if (Number.isNaN(activityTs)) return false;
+	if (Date.now() - lastFocus > STALE_WINDOW_MS) {
+		lastPaneFocusAt.delete(paneId);
+		return false;
+	}
+	return activityTs >= lastFocus && activityTs - lastFocus <= SUPPRESS_WINDOW_MS;
+};
+
+//#endregion
+//#region apps/server/src/screen-service.ts
+const execFileAsync$1 = promisify(execFile);
+const isMacOS = () => process.platform === "darwin";
+const TTY_PATH_PATTERN = /^\/dev\/(ttys?\d+|pts\/\d+)$/;
+const normalizeTty$1 = (tty) => tty.startsWith("/dev/") ? tty : `/dev/${tty}`;
+const isValidTty = (tty) => TTY_PATH_PATTERN.test(normalizeTty$1(tty));
+const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const parseBounds = (input) => {
+	const parts = input.split(",").map((value) => Number.parseInt(value.trim(), 10)).filter((value) => !Number.isNaN(value));
+	if (parts.length !== 4) return null;
+	const [x, y, width, height] = parts;
+	if (x === void 0 || y === void 0 || width === void 0 || height === void 0) return null;
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+};
+const runAppleScript = async (script) => {
+	try {
+		return ((await execFileAsync$1("osascript", ["-e", script], { encoding: "utf8" })).stdout ?? "").trim();
+	} catch {
+		return "";
+	}
+};
+const buildTerminalBoundsScript = (appName) => `
+tell application "System Events"
+  if not (exists process "${appName}") then return ""
+  tell process "${appName}"
+    try
+      set windowFrame to value of attribute "AXFrame" of front window
+      set pos to {item 1 of windowFrame, item 2 of windowFrame}
+      set sz to {item 3 of windowFrame, item 4 of windowFrame}
+      set contentPos to pos
+      set contentSize to sz
+      try
+        set scrollArea to first UI element of front window whose role is "AXScrollArea"
+        set contentFrame to value of attribute "AXFrame" of scrollArea
+        set contentPos to {item 1 of contentFrame, item 2 of contentFrame}
+        set contentSize to {item 3 of contentFrame, item 4 of contentFrame}
+      end try
+      return (item 1 of contentPos as text) & ", " & (item 2 of contentPos as text) & ", " & (item 1 of contentSize as text) & ", " & (item 2 of contentSize as text) & "|" & (item 1 of pos as text) & ", " & (item 2 of pos as text) & ", " & (item 1 of sz as text) & ", " & (item 2 of sz as text)
+    end try
+  end tell
+end tell
+return ""
+`;
+const focusTerminalApp = async (appName) => {
+	await runAppleScript(`tell application "${appName}" to activate`);
+};
+const captureRegion = async (bounds) => {
+	const tempPath = `/tmp/tmux-agent-monitor-${randomUUID()}.png`;
+	const region = `${bounds.x},${bounds.y},${bounds.width},${bounds.height}`;
+	try {
+		await execFileAsync$1("screencapture", [
+			"-R",
+			region,
+			"-x",
+			tempPath
+		], { timeout: 1e4 });
+		const data = await fs$1.readFile(tempPath);
+		await fs$1.unlink(tempPath).catch(() => null);
+		return data.toString("base64");
+	} catch {
+		await fs$1.unlink(tempPath).catch(() => null);
+		return null;
+	}
+};
+const parsePaneGeometry = (input) => {
+	const parts = input.trim().split("	").map((value) => Number.parseInt(value.trim(), 10));
+	if (parts.length !== 6 || parts.some((value) => Number.isNaN(value))) return null;
+	const [left, top, width, height, windowWidth, windowHeight] = parts;
+	if (left === void 0 || top === void 0 || width === void 0 || height === void 0 || windowWidth === void 0 || windowHeight === void 0) return null;
+	return {
+		left,
+		top,
+		width,
+		height,
+		windowWidth,
+		windowHeight
+	};
+};
+const buildTmuxArgs = (args, options) => {
+	const prefix = [];
+	if (options?.socketName) prefix.push("-L", options.socketName);
+	if (options?.socketPath) prefix.push("-S", options.socketPath);
+	return [...prefix, ...args];
+};
+const getPaneSession = async (paneId, options) => {
+	try {
+		const name = ((await execFileAsync$1("tmux", buildTmuxArgs([
+			"display-message",
+			"-p",
+			"-t",
+			paneId,
+			"-F",
+			"#{session_name}"
+		], options), {
+			encoding: "utf8",
+			timeout: 2e3
+		})).stdout ?? "").trim();
+		return name.length > 0 ? name : null;
+	} catch {
+		return null;
+	}
+};
+const focusTmuxPane = async (paneId, options) => {
+	if (!paneId) return;
+	if (options?.primaryClient) await execFileAsync$1("tmux", buildTmuxArgs([
+		"switch-client",
+		"-t",
+		options.primaryClient
+	], options), {
+		encoding: "utf8",
+		timeout: 2e3
+	}).catch(() => null);
+	const sessionName = await getPaneSession(paneId, options);
+	if (sessionName) await execFileAsync$1("tmux", buildTmuxArgs([
+		"switch-client",
+		"-t",
+		sessionName
+	], options), {
+		encoding: "utf8",
+		timeout: 2e3
+	}).catch(() => null);
+	await execFileAsync$1("tmux", buildTmuxArgs([
+		"select-window",
+		"-t",
+		paneId
+	], options), {
+		encoding: "utf8",
+		timeout: 2e3
+	}).catch(() => null);
+	await execFileAsync$1("tmux", buildTmuxArgs([
+		"select-pane",
+		"-t",
+		paneId
+	], options), {
+		encoding: "utf8",
+		timeout: 2e3
+	}).catch(() => null);
+};
+const getPaneGeometry = async (paneId, options) => {
+	try {
+		return parsePaneGeometry((await execFileAsync$1("tmux", buildTmuxArgs([
+			"display-message",
+			"-p",
+			"-t",
+			paneId,
+			"-F",
+			[
+				"#{pane_left}",
+				"#{pane_top}",
+				"#{pane_width}",
+				"#{pane_height}",
+				"#{window_width}",
+				"#{window_height}"
+			].join("	")
+		], options), {
+			encoding: "utf8",
+			timeout: 2e3
+		})).stdout ?? "");
+	} catch {
+		return null;
+	}
+};
+const parseBoundsSet = (input) => {
+	const [contentRaw, windowRaw] = input.split("|").map((part) => part.trim());
+	const content = contentRaw ? parseBounds(contentRaw) : null;
+	return {
+		content,
+		window: (windowRaw ? parseBounds(windowRaw) : null) ?? content
+	};
+};
+const cropPaneBounds = (base, geometry) => {
+	if (geometry.windowWidth <= 0 || geometry.windowHeight <= 0) return null;
+	const cellWidth = base.width / geometry.windowWidth;
+	const cellHeight = base.height / geometry.windowHeight;
+	const x = Math.round(base.x + geometry.left * cellWidth);
+	const y = Math.round(base.y + geometry.top * cellHeight);
+	const width = Math.round(geometry.width * cellWidth);
+	const height = Math.round(geometry.height * cellHeight);
+	if (width <= 0 || height <= 0) return null;
+	return {
+		x,
+		y,
+		width,
+		height
+	};
+};
+const captureTerminalScreen = async (tty, options = {}) => {
+	if (!isMacOS()) return null;
+	if (tty && !isValidTty(tty)) return null;
+	const backend = options.backend ?? "terminal";
+	const candidates = [
+		{
+			key: "alacritty",
+			appName: "Alacritty"
+		},
+		{
+			key: "terminal",
+			appName: "Terminal"
+		},
+		{
+			key: "iterm",
+			appName: "iTerm2"
+		},
+		{
+			key: "wezterm",
+			appName: "WezTerm"
+		},
+		{
+			key: "ghostty",
+			appName: "Ghostty"
+		}
+	];
+	const isRunning = async (appName) => {
+		return (await runAppleScript(`tell application "System Events" to (exists process "${appName}")`)).trim() === "true";
+	};
+	const app = candidates.find((candidate) => candidate.key === backend) ?? null;
+	if (!app) return null;
+	if (!await isRunning(app.appName)) return null;
+	await focusTerminalApp(app.appName);
+	await wait(200);
+	if (options.paneId) {
+		markPaneFocus(options.paneId);
+		await focusTmuxPane(options.paneId, options.tmux);
+		await wait(200);
+	}
+	const maxAttempts = 3;
+	for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+		const boundsRaw = await runAppleScript(buildTerminalBoundsScript(app.appName));
+		const boundsSet = boundsRaw ? parseBoundsSet(boundsRaw) : {
+			content: null,
+			window: null
+		};
+		const bounds = boundsSet.content ?? boundsSet.window;
+		const paneGeometry = options.cropPane !== false && options.paneId ? await getPaneGeometry(options.paneId, options.tmux) : null;
+		if (bounds) {
+			const croppedBounds = paneGeometry ? cropPaneBounds(bounds, paneGeometry) : null;
+			const imageBase64 = await captureRegion(croppedBounds ?? bounds);
+			if (imageBase64) return {
+				imageBase64,
+				cropped: Boolean(croppedBounds)
+			};
+		}
+		if (attempt < maxAttempts - 1) await wait(200);
+	}
+	return null;
+};
+
+//#endregion
+//#region apps/server/src/app.ts
+const now = () => (/* @__PURE__ */ new Date()).toISOString();
+const buildError$1 = (code, message) => ({
+	code,
+	message
+});
+const buildEnvelope = (type, data, reqId) => ({
+	type,
+	ts: now(),
+	reqId,
+	data
+});
+const createRateLimiter = (windowMs, max) => {
+	const hits = /* @__PURE__ */ new Map();
+	return (key) => {
+		const nowMs = Date.now();
+		const entry = hits.get(key);
+		if (!entry || entry.expiresAt <= nowMs) {
+			hits.set(key, {
+				count: 1,
+				expiresAt: nowMs + windowMs
+			});
+			return true;
+		}
+		if (entry.count >= max) return false;
+		entry.count += 1;
+		return true;
+	};
+};
+const createApp = ({ config, monitor, tmuxActions }) => {
+	const app = new Hono();
+	const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+	const wsClients = /* @__PURE__ */ new Set();
+	const sendLimiter = createRateLimiter(config.rateLimit.send.windowMs, config.rateLimit.send.max);
+	const screenLimiter = createRateLimiter(config.rateLimit.screen.windowMs, config.rateLimit.screen.max);
+	const requireAuth = (c) => {
+		const auth = c.req.header("authorization") ?? c.req.header("Authorization");
+		if (!auth?.startsWith("Bearer ")) return false;
+		return auth.replace("Bearer ", "").trim() === config.token;
+	};
+	const requireStaticAuth = (c) => {
+		const token = c.req.query("token");
+		if (!token) return false;
+		return token === config.token;
+	};
+	const isOriginAllowed = (origin, host) => {
+		if (!origin || config.allowedOrigins.length === 0) return config.allowedOrigins.length === 0 || (host ? config.allowedOrigins.includes(host) : true);
+		return config.allowedOrigins.includes(origin) || (host ? config.allowedOrigins.includes(host) : false);
+	};
+	const sendWs = (ws, message) => {
+		ws.send(JSON.stringify(message));
+	};
+	const broadcast = (message) => {
+		const payload = JSON.stringify(message);
+		wsClients.forEach((ws) => ws.send(payload));
+	};
+	monitor.registry.onChanged((session) => {
+		broadcast(buildEnvelope("session.updated", { session }));
+	});
+	monitor.registry.onRemoved((paneId) => {
+		broadcast(buildEnvelope("session.removed", { paneId }));
+	});
+	app.use("/api/*", async (c, next) => {
+		if (!requireAuth(c)) return c.json({ error: buildError$1("INVALID_PAYLOAD", "unauthorized") }, 401);
+		if (!isOriginAllowed(c.req.header("origin"), c.req.header("host"))) return c.json({ error: buildError$1("INVALID_PAYLOAD", "origin not allowed") }, 403);
+		await next();
+	});
+	app.get("/api/sessions", (c) => {
+		return c.json({
+			sessions: monitor.registry.snapshot(),
+			serverTime: now()
+		});
+	});
+	app.get("/api/sessions/:paneId", (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		return c.json({ session: detail });
+	});
+	app.get("/api/sessions/:paneId/diff", async (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		const force = c.req.query("force") === "1";
+		const summary = await fetchDiffSummary(detail.currentPath, { force });
+		return c.json({ summary });
+	});
+	app.get("/api/sessions/:paneId/diff/file", async (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		const pathParam = c.req.query("path");
+		if (!pathParam) return c.json({ error: buildError$1("INVALID_PAYLOAD", "missing path") }, 400);
+		const force = c.req.query("force") === "1";
+		const summary = await fetchDiffSummary(detail.currentPath, { force });
+		if (!summary.repoRoot || summary.reason || !summary.rev) return c.json({ error: buildError$1("INVALID_PAYLOAD", "diff summary unavailable") }, 400);
+		const target = summary.files.find((file) => file.path === pathParam);
+		if (!target) return c.json({ error: buildError$1("NOT_FOUND", "file not found") }, 404);
+		const file = await fetchDiffFile(summary.repoRoot, target, summary.rev, { force });
+		return c.json({ file });
+	});
+	app.get("/api/sessions/:paneId/commits", async (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		const limit = Number.parseInt(c.req.query("limit") ?? "10", 10);
+		const skip = Number.parseInt(c.req.query("skip") ?? "0", 10);
+		const force = c.req.query("force") === "1";
+		const log = await fetchCommitLog(detail.currentPath, {
+			limit: Number.isFinite(limit) ? limit : 10,
+			skip: Number.isFinite(skip) ? skip : 0,
+			force
+		});
+		return c.json({ log });
+	});
+	app.get("/api/sessions/:paneId/commits/:hash", async (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		const hash = c.req.param("hash");
+		if (!hash) return c.json({ error: buildError$1("INVALID_PAYLOAD", "missing hash") }, 400);
+		const log = await fetchCommitLog(detail.currentPath, {
+			limit: 1,
+			skip: 0
+		});
+		if (!log.repoRoot || log.reason) return c.json({ error: buildError$1("INVALID_PAYLOAD", "commit log unavailable") }, 400);
+		const commit = await fetchCommitDetail(log.repoRoot, hash, { force: c.req.query("force") === "1" });
+		if (!commit) return c.json({ error: buildError$1("NOT_FOUND", "commit not found") }, 404);
+		return c.json({ commit });
+	});
+	app.get("/api/sessions/:paneId/commits/:hash/file", async (c) => {
+		const paneId = c.req.param("paneId");
+		if (!paneId) return c.json({ error: buildError$1("INVALID_PAYLOAD", "invalid pane id") }, 400);
+		const detail = monitor.registry.getDetail(paneId);
+		if (!detail) return c.json({ error: buildError$1("NOT_FOUND", "pane not found") }, 404);
+		const hash = c.req.param("hash");
+		const pathParam = c.req.query("path");
+		if (!hash || !pathParam) return c.json({ error: buildError$1("INVALID_PAYLOAD", "missing hash or path") }, 400);
+		const log = await fetchCommitLog(detail.currentPath, {
+			limit: 1,
+			skip: 0
+		});
+		if (!log.repoRoot || log.reason) return c.json({ error: buildError$1("INVALID_PAYLOAD", "commit log unavailable") }, 400);
+		const commit = await fetchCommitDetail(log.repoRoot, hash, { force: true });
+		if (!commit) return c.json({ error: buildError$1("NOT_FOUND", "commit not found") }, 404);
+		const target = commit.files.find((file) => file.path === pathParam) ?? commit.files.find((file) => file.renamedFrom === pathParam);
+		if (!target) return c.json({ error: buildError$1("NOT_FOUND", "file not found") }, 404);
+		const file = await fetchCommitFile(log.repoRoot, hash, target, { force: c.req.query("force") === "1" });
+		return c.json({ file });
+	});
+	app.post("/api/admin/token/rotate", (c) => {
+		const next = rotateToken();
+		config.token = next.token;
+		return c.json({ token: next.token });
+	});
+	const wsHandler = upgradeWebSocket(() => ({
+		onOpen: (_event, ws) => {
+			wsClients.add(ws);
+			sendWs(ws, buildEnvelope("sessions.snapshot", { sessions: monitor.registry.snapshot() }));
+			sendWs(ws, buildEnvelope("server.health", { version: "0.0.1" }));
+		},
+		onClose: (_event, ws) => {
+			wsClients.delete(ws);
+		},
+		onMessage: async (event, ws) => {
+			let parsedJson;
+			try {
+				parsedJson = JSON.parse(event.data.toString());
+			} catch {
+				sendWs(ws, buildEnvelope("command.response", {
+					ok: false,
+					error: buildError$1("INVALID_PAYLOAD", "invalid json")
+				}));
+				return;
+			}
+			const parsed = wsClientMessageSchema.safeParse(parsedJson);
+			if (!parsed.success) {
+				sendWs(ws, buildEnvelope("command.response", {
+					ok: false,
+					error: buildError$1("INVALID_PAYLOAD", "invalid payload")
+				}));
+				return;
+			}
+			const message = parsed.data;
+			const reqId = message.reqId;
+			if (message.type === "client.ping") {
+				sendWs(ws, buildEnvelope("server.health", { version: "0.0.1" }, reqId));
+				return;
+			}
+			const target = monitor.registry.getDetail(message.data.paneId);
+			if (!target) {
+				if (message.type === "screen.request") sendWs(ws, buildEnvelope("screen.response", {
+					ok: false,
+					paneId: message.data.paneId,
+					mode: message.data.mode ?? config.screen.mode,
+					capturedAt: now(),
+					error: buildError$1("NOT_FOUND", "pane not found")
+				}, reqId));
+				else sendWs(ws, buildEnvelope("command.response", {
+					ok: false,
+					error: buildError$1("NOT_FOUND", "pane not found")
+				}, reqId));
+				return;
+			}
+			if (message.type === "screen.request") {
+				if (!screenLimiter("ws")) {
+					sendWs(ws, buildEnvelope("screen.response", {
+						ok: false,
+						paneId: message.data.paneId,
+						mode: "text",
+						capturedAt: now(),
+						error: buildError$1("RATE_LIMIT", "rate limited")
+					}, reqId));
+					return;
+				}
+				const mode = message.data.mode ?? config.screen.mode;
+				const lineCount = Math.min(message.data.lines ?? config.screen.defaultLines, config.screen.maxLines);
+				if (mode === "image") {
+					if (!config.screen.image.enabled) try {
+						const text = await monitor.getScreenCapture().captureText({
+							paneId: message.data.paneId,
+							lines: lineCount,
+							joinLines: config.screen.joinLines,
+							includeAnsi: config.screen.ansi,
+							altScreen: config.screen.altScreen,
+							alternateOn: target.alternateOn
+						});
+						sendWs(ws, buildEnvelope("screen.response", {
+							ok: true,
+							paneId: message.data.paneId,
+							mode: "text",
+							capturedAt: now(),
+							lines: lineCount,
+							truncated: text.truncated,
+							alternateOn: target.alternateOn,
+							screen: text.screen,
+							fallbackReason: "image_disabled"
+						}, reqId));
+						return;
+					} catch {
+						sendWs(ws, buildEnvelope("screen.response", {
+							ok: false,
+							paneId: message.data.paneId,
+							mode: "text",
+							capturedAt: now(),
+							error: buildError$1("INTERNAL", "screen capture failed")
+						}, reqId));
+						return;
+					}
+					const imageResult = await captureTerminalScreen(target.paneTty, {
+						paneId: message.data.paneId,
+						tmux: config.tmux,
+						cropPane: config.screen.image.cropPane,
+						backend: config.screen.image.backend
+					});
+					if (imageResult) {
+						sendWs(ws, buildEnvelope("screen.response", {
+							ok: true,
+							paneId: message.data.paneId,
+							mode: "image",
+							capturedAt: now(),
+							imageBase64: imageResult.imageBase64,
+							cropped: imageResult.cropped
+						}, reqId));
+						return;
+					}
+					try {
+						const text = await monitor.getScreenCapture().captureText({
+							paneId: message.data.paneId,
+							lines: lineCount,
+							joinLines: config.screen.joinLines,
+							includeAnsi: config.screen.ansi,
+							altScreen: config.screen.altScreen,
+							alternateOn: target.alternateOn
+						});
+						sendWs(ws, buildEnvelope("screen.response", {
+							ok: true,
+							paneId: message.data.paneId,
+							mode: "text",
+							capturedAt: now(),
+							lines: lineCount,
+							truncated: text.truncated,
+							alternateOn: target.alternateOn,
+							screen: text.screen,
+							fallbackReason: "image_failed"
+						}, reqId));
+						return;
+					} catch {
+						sendWs(ws, buildEnvelope("screen.response", {
+							ok: false,
+							paneId: message.data.paneId,
+							mode: "text",
+							capturedAt: now(),
+							error: buildError$1("INTERNAL", "screen capture failed")
+						}, reqId));
+						return;
+					}
+				}
+				try {
+					const text = await monitor.getScreenCapture().captureText({
+						paneId: message.data.paneId,
+						lines: lineCount,
+						joinLines: config.screen.joinLines,
+						includeAnsi: config.screen.ansi,
+						altScreen: config.screen.altScreen,
+						alternateOn: target.alternateOn
+					});
+					sendWs(ws, buildEnvelope("screen.response", {
+						ok: true,
+						paneId: message.data.paneId,
+						mode: "text",
+						capturedAt: now(),
+						lines: lineCount,
+						truncated: text.truncated,
+						alternateOn: target.alternateOn,
+						screen: text.screen
+					}, reqId));
+					return;
+				} catch {
+					sendWs(ws, buildEnvelope("screen.response", {
+						ok: false,
+						paneId: message.data.paneId,
+						mode: "text",
+						capturedAt: now(),
+						error: buildError$1("INTERNAL", "screen capture failed")
+					}, reqId));
+					return;
+				}
+			}
+			if (config.readOnly) {
+				sendWs(ws, buildEnvelope("command.response", {
+					ok: false,
+					error: buildError$1("READ_ONLY", "read-only mode")
+				}, reqId));
+				return;
+			}
+			if (!sendLimiter("ws")) {
+				sendWs(ws, buildEnvelope("command.response", {
+					ok: false,
+					error: buildError$1("RATE_LIMIT", "rate limited")
+				}, reqId));
+				return;
+			}
+			if (message.type === "send.text") {
+				sendWs(ws, buildEnvelope("command.response", await tmuxActions.sendText(message.data.paneId, message.data.text, message.data.enter ?? true), reqId));
+				return;
+			}
+			if (message.type === "send.keys") {
+				sendWs(ws, buildEnvelope("command.response", await tmuxActions.sendKeys(message.data.paneId, message.data.keys), reqId));
+				return;
+			}
+		}
+	}));
+	app.use("/ws", async (c, next) => {
+		const token = c.req.query("token");
+		if (!token || token !== config.token) return c.text("Unauthorized", 401);
+		if (!isOriginAllowed(c.req.header("origin"), c.req.header("host"))) return c.text("Forbidden", 403);
+		await next();
+	});
+	app.get("/ws", wsHandler);
+	const distRoot = path.dirname(fileURLToPath(import.meta.url));
+	const bundledDistDir = path.resolve(distRoot, "web");
+	const workspaceDistDir = path.resolve(distRoot, "../../web/dist");
+	const distDir = fs.existsSync(bundledDistDir) ? bundledDistDir : workspaceDistDir;
+	if (fs.existsSync(distDir)) {
+		app.use("/*", async (c, next) => {
+			if (!config.staticAuth) return next();
+			if (!requireStaticAuth(c)) return c.text("Unauthorized", 401);
+			return next();
+		});
+		app.use("/*", serveStatic({ root: distDir }));
+		app.get("/*", serveStatic({
+			root: distDir,
+			path: "index.html"
+		}));
+	}
+	return {
+		app,
+		injectWebSocket
+	};
+};
+
+//#endregion
+//#region packages/agents/src/state-estimator.ts
+const toTimestamp = (value) => {
+	if (!value) return null;
+	const ts = Date.parse(value);
+	return Number.isNaN(ts) ? null : ts;
+};
+const mapHookState = (hookState) => {
+	return {
+		state: hookState.state,
+		reason: hookState.reason
+	};
+};
+const estimateState = (signals) => {
+	if (signals.paneDead) return {
+		state: "UNKNOWN",
+		reason: "pane_dead"
+	};
+	if (signals.hookState) return mapHookState(signals.hookState);
+	const lastOutputTs = toTimestamp(signals.lastOutputAt);
+	if (lastOutputTs !== null) {
+		const diff = Date.now() - lastOutputTs;
+		if (diff <= signals.thresholds.runningThresholdMs) return {
+			state: "RUNNING",
+			reason: "recent_output"
+		};
+		if (diff >= signals.thresholds.inactiveThresholdMs) return {
+			state: "WAITING_INPUT",
+			reason: "inactive_timeout"
+		};
+		return {
+			state: "WAITING_INPUT",
+			reason: "recently_inactive"
+		};
+	}
+	return {
+		state: "UNKNOWN",
+		reason: "no_signal"
+	};
+};
+
+//#endregion
+//#region apps/server/src/logs.ts
+const ensureDir = async (dir) => {
+	await fs$1.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+};
+const rotateLogIfNeeded = async (filePath, maxBytes, retainRotations) => {
+	const stat = await fs$1.stat(filePath).catch(() => null);
+	if (!stat || stat.size <= maxBytes) return;
+	const dir = path.dirname(filePath);
+	const base = path.basename(filePath);
+	const rotatedPath = path.join(dir, `${base}.${Date.now()}`);
+	const data = await fs$1.readFile(filePath);
+	await fs$1.writeFile(rotatedPath, data);
+	await fs$1.truncate(filePath, 0);
+	const rotations = (await fs$1.readdir(dir)).filter((name) => name.startsWith(`${base}.`)).map((name) => ({
+		name,
+		fullPath: path.join(dir, name)
+	}));
+	if (rotations.length > retainRotations) {
+		const toDelete = rotations.sort((a, b) => a.name.localeCompare(b.name)).slice(0, rotations.length - retainRotations);
+		await Promise.all(toDelete.map((entry) => fs$1.unlink(entry.fullPath).catch(() => null)));
+	}
+};
+const createLogActivityPoller = (pollIntervalMs) => {
+	const entries = /* @__PURE__ */ new Map();
+	const listeners = /* @__PURE__ */ new Set();
+	let timer = null;
+	const register = (paneId, filePath) => {
+		if (!entries.has(filePath)) entries.set(filePath, {
+			paneId,
+			size: 0
+		});
+	};
+	const onActivity = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const start = () => {
+		if (timer) return;
+		timer = setInterval(async () => {
+			await Promise.all(Array.from(entries.entries()).map(async ([filePath, entry]) => {
+				const stat = await fs$1.stat(filePath).catch(() => null);
+				if (!stat) return;
+				if (stat.size < entry.size) {
+					entry.size = stat.size;
+					return;
+				}
+				if (stat.size > entry.size) {
+					entry.size = stat.size;
+					const at = (/* @__PURE__ */ new Date()).toISOString();
+					listeners.forEach((listener) => listener(entry.paneId, at));
+				}
+			}));
+		}, pollIntervalMs);
+	};
+	const stop = () => {
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+	};
+	return {
+		register,
+		onActivity,
+		start,
+		stop
+	};
+};
+const createJsonlTailer = (pollIntervalMs) => {
+	let offset = 0;
+	let buffer = "";
+	let timer = null;
+	const listeners = /* @__PURE__ */ new Set();
+	const onLine = (listener) => {
+		listeners.add(listener);
+		return () => listeners.delete(listener);
+	};
+	const start = (filePath) => {
+		if (timer) return;
+		timer = setInterval(async () => {
+			const stat = await fs$1.stat(filePath).catch(() => null);
+			if (!stat) return;
+			if (stat.size < offset) {
+				offset = 0;
+				buffer = "";
+			}
+			if (stat.size === offset) return;
+			const fd = await fs$1.open(filePath, "r");
+			const length = stat.size - offset;
+			const chunk = Buffer.alloc(length);
+			await fd.read(chunk, 0, length, offset);
+			await fd.close();
+			offset = stat.size;
+			buffer += chunk.toString("utf8");
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+			lines.forEach((line) => {
+				if (line.trim().length === 0) return;
+				listeners.forEach((listener) => listener(line));
+			});
+		}, pollIntervalMs);
+	};
+	const stop = () => {
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+	};
+	return {
+		onLine,
+		start,
+		stop
+	};
+};
+
+//#endregion
+//#region apps/server/src/session-registry.ts
+const toSummary = (detail) => {
+	const { startCommand: _startCommand, panePid: _panePid, ...summary } = detail;
+	return summary;
+};
+const createSessionRegistry = () => {
+	const sessions = /* @__PURE__ */ new Map();
+	const changeListeners = /* @__PURE__ */ new Set();
+	const removedListeners = /* @__PURE__ */ new Set();
+	const snapshot = () => {
+		return Array.from(sessions.values()).map(toSummary);
+	};
+	const getDetail = (paneId) => {
+		return sessions.get(paneId) ?? null;
+	};
+	const update = (detail) => {
+		const existing = sessions.get(detail.paneId);
+		const next = detail;
+		sessions.set(detail.paneId, next);
+		if (!existing || JSON.stringify(toSummary(existing)) !== JSON.stringify(toSummary(next))) {
+			const summary = toSummary(next);
+			changeListeners.forEach((listener) => listener(summary));
+		}
+	};
+	const removeMissing = (activePaneIds) => {
+		const removed = [];
+		sessions.forEach((_, paneId) => {
+			if (!activePaneIds.has(paneId)) {
+				sessions.delete(paneId);
+				removed.push(paneId);
+				removedListeners.forEach((listener) => listener(paneId));
+			}
+		});
+		return removed;
+	};
+	const onChanged = (listener) => {
+		changeListeners.add(listener);
+		return () => changeListeners.delete(listener);
+	};
+	const onRemoved = (listener) => {
+		removedListeners.add(listener);
+		return () => removedListeners.delete(listener);
+	};
+	const values = () => Array.from(sessions.values());
+	return {
+		snapshot,
+		getDetail,
+		update,
+		removeMissing,
+		onChanged,
+		onRemoved,
+		values
+	};
+};
+
+//#endregion
+//#region apps/server/src/state-store.ts
+const getStatePath = () => {
+	return path.join(os.homedir(), ".tmux-agent-monitor", "state.json");
+};
+const loadState = () => {
+	try {
+		const raw = fs.readFileSync(getStatePath(), "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+};
+const saveState = (sessions) => {
+	const data = {
+		version: 1,
+		savedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		sessions: Object.fromEntries(sessions.map((session) => [session.paneId, {
+			paneId: session.paneId,
+			lastOutputAt: session.lastOutputAt,
+			lastEventAt: session.lastEventAt,
+			lastMessage: session.lastMessage,
+			state: session.state,
+			stateReason: session.stateReason
+		}]))
+	};
+	const dir = path.dirname(getStatePath());
+	fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(getStatePath(), `${JSON.stringify(data, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+};
+const restoreSessions = () => {
+	const state = loadState();
+	if (!state) return /* @__PURE__ */ new Map();
+	return new Map(Object.entries(state.sessions));
+};
+
+//#endregion
+//#region apps/server/src/monitor.ts
+const baseDir = path.join(os.homedir(), ".tmux-agent-monitor");
+const execFileAsync = promisify(execFile);
+const buildAgent = (hint) => {
+	const normalized = hint.toLowerCase();
+	if (normalized.includes("codex")) return "codex";
+	if (normalized.includes("claude")) return "claude";
+	return "unknown";
+};
+const mergeHints = (...parts) => parts.filter((part) => Boolean(part && part.trim().length > 0)).join(" ");
+const processCacheTtlMs = 5e3;
+const processCommandCache = /* @__PURE__ */ new Map();
+const ttyAgentCache = /* @__PURE__ */ new Map();
+const processSnapshotCache = {
+	at: 0,
+	byPid: /* @__PURE__ */ new Map(),
+	children: /* @__PURE__ */ new Map()
+};
+const normalizeTty = (tty) => tty.replace(/^\/dev\//, "");
+const normalizeFingerprint = (text) => text.replace(/\r/g, "").split("\n").map((line) => line.replace(/\s+$/, "")).join("\n").trimEnd();
+const normalizeTitle = (value) => {
+	if (!value) return null;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+};
+const buildDefaultTitle = (currentPath, paneId, sessionName) => {
+	if (!currentPath) return `${sessionName}:${paneId}`;
+	return `${currentPath.replace(/\/+$/, "").split("/").pop() || "unknown"}:${paneId}`;
+};
+const hostCandidates = (() => {
+	const host = os.hostname();
+	const short = host.split(".")[0] ?? host;
+	return new Set([
+		host,
+		short,
+		`${host}.local`,
+		`${short}.local`
+	]);
+})();
+const toIsoFromEpochSeconds = (value) => {
+	if (!value) return null;
+	const date = /* @__PURE__ */ new Date(value * 1e3);
+	if (Number.isNaN(date.getTime())) return null;
+	return date.toISOString();
+};
+const getProcessCommand = async (pid) => {
+	if (!pid) return null;
+	const cached = processCommandCache.get(pid);
+	const nowMs = Date.now();
+	if (cached && nowMs - cached.at < processCacheTtlMs) return cached.command;
+	try {
+		const command = ((await execFileAsync("ps", [
+			"-p",
+			String(pid),
+			"-o",
+			"command="
+		], {
+			encoding: "utf8",
+			timeout: 1e3
+		})).stdout ?? "").trim();
+		if (command.length === 0) return null;
+		processCommandCache.set(pid, {
+			command,
+			at: nowMs
+		});
+		return command;
+	} catch {
+		return null;
+	}
+};
+const loadProcessSnapshot = async () => {
+	const nowMs = Date.now();
+	if (nowMs - processSnapshotCache.at < processCacheTtlMs) return processSnapshotCache;
+	try {
+		const result = await execFileAsync("ps", [
+			"-ax",
+			"-o",
+			"pid=,ppid=,command="
+		], {
+			encoding: "utf8",
+			timeout: 2e3
+		});
+		const byPid = /* @__PURE__ */ new Map();
+		const children = /* @__PURE__ */ new Map();
+		const lines = (result.stdout ?? "").split("\n").filter((line) => line.trim().length > 0);
+		for (const line of lines) {
+			const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
+			if (!match) continue;
+			const pid = Number.parseInt(match[1] ?? "", 10);
+			const ppid = Number.parseInt(match[2] ?? "", 10);
+			if (Number.isNaN(pid) || Number.isNaN(ppid)) continue;
+			const command = match[3] ?? "";
+			byPid.set(pid, {
+				pid,
+				ppid,
+				command
+			});
+			const list = children.get(ppid) ?? [];
+			list.push(pid);
+			children.set(ppid, list);
+		}
+		processSnapshotCache.at = nowMs;
+		processSnapshotCache.byPid = byPid;
+		processSnapshotCache.children = children;
+	} catch {}
+	return processSnapshotCache;
+};
+const findAgentFromPidTree = async (pid) => {
+	if (!pid) return "unknown";
+	const snapshot = await loadProcessSnapshot();
+	const visited = /* @__PURE__ */ new Set();
+	const stack = [pid];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || visited.has(current)) continue;
+		visited.add(current);
+		const entry = snapshot.byPid.get(current);
+		if (entry) {
+			const agent = buildAgent(entry.command);
+			if (agent !== "unknown") return agent;
+		}
+		(snapshot.children.get(current) ?? []).forEach((child) => {
+			if (!visited.has(child)) stack.push(child);
+		});
+	}
+	return "unknown";
+};
+const getAgentFromTty = async (tty) => {
+	if (!tty) return "unknown";
+	const normalized = normalizeTty(tty);
+	const cached = ttyAgentCache.get(normalized);
+	const nowMs = Date.now();
+	if (cached && nowMs - cached.at < processCacheTtlMs) return cached.agent;
+	try {
+		const agent = buildAgent(((await execFileAsync("ps", [
+			"-o",
+			"command=",
+			"-t",
+			normalized
+		], {
+			encoding: "utf8",
+			timeout: 1e3
+		})).stdout ?? "").split("\n").map((line) => line.trim()).filter((line) => line.length > 0).join(" "));
+		ttyAgentCache.set(normalized, {
+			agent,
+			at: nowMs
+		});
+		return agent;
+	} catch {
+		return "unknown";
+	}
+};
+const deriveHookState = (hookEventName, notificationType) => {
+	if (hookEventName === "Notification" && notificationType === "permission_prompt") return {
+		state: "WAITING_PERMISSION",
+		reason: "hook:permission_prompt"
+	};
+	if (hookEventName === "Stop") return {
+		state: "WAITING_INPUT",
+		reason: "hook:stop"
+	};
+	if (hookEventName === "UserPromptSubmit" || hookEventName === "PreToolUse" || hookEventName === "PostToolUse") return {
+		state: "RUNNING",
+		reason: `hook:${hookEventName}`
+	};
+	return null;
+};
+const mapHookToPane = (panes, hook) => {
+	if (hook.tmux_pane) return hook.tmux_pane;
+	if (hook.tty) {
+		const matches = panes.filter((pane) => pane.paneTty === hook.tty);
+		if (matches.length === 1) return matches[0]?.paneId ?? null;
+		return null;
+	}
+	if (hook.cwd) {
+		const matches = panes.filter((pane) => pane.currentPath === hook.cwd);
+		if (matches.length === 1) return matches[0]?.paneId ?? null;
+	}
+	return null;
+};
+const createSessionMonitor = (adapter, config) => {
+	const inspector = createInspector(adapter);
+	const pipeManager = createPipeManager(adapter);
+	const screenCapture = createScreenCapture(adapter);
+	const registry = createSessionRegistry();
+	const hookStates = /* @__PURE__ */ new Map();
+	const lastOutputAt = /* @__PURE__ */ new Map();
+	const lastEventAt = /* @__PURE__ */ new Map();
+	const lastMessage = /* @__PURE__ */ new Map();
+	const lastFingerprint = /* @__PURE__ */ new Map();
+	const restored = restoreSessions();
+	const restoredReason = /* @__PURE__ */ new Set();
+	const serverKey = resolveServerKey(config.tmux.socketName, config.tmux.socketPath);
+	const eventsDir = path.join(baseDir, "events", serverKey);
+	const eventLogPath = path.join(eventsDir, "claude.jsonl");
+	const logActivity = createLogActivityPoller(config.activity.pollIntervalMs);
+	const jsonlTailer = createJsonlTailer(config.activity.pollIntervalMs);
+	let timer = null;
+	restored.forEach((session, paneId) => {
+		lastOutputAt.set(paneId, session.lastOutputAt ?? null);
+		lastEventAt.set(paneId, session.lastEventAt ?? null);
+		lastMessage.set(paneId, session.lastMessage ?? null);
+	});
+	const getPaneLogPath = (paneId) => {
+		return resolveLogPaths(baseDir, serverKey, paneId).paneLogPath;
+	};
+	const ensureLogFiles = async (paneId) => {
+		const { panesDir, paneLogPath } = resolveLogPaths(baseDir, serverKey, paneId);
+		await ensureDir(panesDir);
+		await fs$1.open(paneLogPath, "a").then((handle) => handle.close());
+	};
+	const applyRestored = (paneId) => {
+		if (restored.has(paneId) && !restoredReason.has(paneId)) {
+			restoredReason.add(paneId);
+			return restored.get(paneId) ?? null;
+		}
+		return null;
+	};
+	const capturePaneFingerprint = async (paneId, useAlt) => {
+		const args = [
+			"capture-pane",
+			"-p",
+			"-t",
+			paneId,
+			"-S",
+			"-5",
+			"-E",
+			"-1"
+		];
+		if (useAlt) args.push("-a");
+		const result = await adapter.run(args);
+		if (result.exitCode !== 0) return null;
+		return normalizeFingerprint(result.stdout ?? "");
+	};
+	const updateFromPanes = async () => {
+		const panes = await inspector.listPanes();
+		const activePaneIds = /* @__PURE__ */ new Set();
+		for (const pane of panes) {
+			if (pane.pipeTagValue === null) pane.pipeTagValue = await inspector.readUserOption(pane.paneId, "@tmux-agent-monitor_pipe");
+			let agent = buildAgent(mergeHints(pane.currentCommand, pane.paneStartCommand, pane.paneTitle));
+			if (agent === "unknown") {
+				const processCommand = await getProcessCommand(pane.panePid);
+				if (processCommand) agent = buildAgent(processCommand);
+			}
+			if (agent === "unknown") agent = await findAgentFromPidTree(pane.panePid);
+			if (agent === "unknown") agent = await getAgentFromTty(pane.paneTty);
+			const monitored = agent !== "unknown";
+			if (!monitored) continue;
+			activePaneIds.add(pane.paneId);
+			const pipeState = {
+				panePipe: pane.panePipe,
+				pipeTagValue: pane.pipeTagValue
+			};
+			let pipeAttached = pane.pipeTagValue === "1";
+			let pipeConflict = pipeManager.hasConflict(pipeState);
+			if (config.attachOnServe && monitored && !pipeConflict) {
+				await ensureLogFiles(pane.paneId);
+				const attachResult = await pipeManager.attachPipe(pane.paneId, getPaneLogPath(pane.paneId), pipeState);
+				pipeAttached = pipeAttached || attachResult.attached;
+				pipeConflict = attachResult.conflict;
+			}
+			if (config.attachOnServe && monitored) logActivity.register(pane.paneId, getPaneLogPath(pane.paneId));
+			await rotateLogIfNeeded(getPaneLogPath(pane.paneId), config.logs.maxPaneLogBytes, config.logs.retainRotations);
+			const hookState = hookStates.get(pane.paneId) ?? null;
+			let outputAt = lastOutputAt.get(pane.paneId) ?? null;
+			const updateOutputAt = (next) => {
+				if (!next) return;
+				const nextTs = Date.parse(next);
+				if (Number.isNaN(nextTs)) return;
+				const prevTs = outputAt ? Date.parse(outputAt) : null;
+				if (!prevTs || Number.isNaN(prevTs) || nextTs > prevTs) {
+					outputAt = new Date(nextTs).toISOString();
+					lastOutputAt.set(pane.paneId, outputAt);
+				}
+			};
+			const logPath = getPaneLogPath(pane.paneId);
+			const stat = await fs$1.stat(logPath).catch(() => null);
+			if (stat && stat.size > 0) updateOutputAt(stat.mtime.toISOString());
+			const windowActivityAt = toIsoFromEpochSeconds(pane.windowActivity);
+			if (windowActivityAt && !shouldSuppressActivity(pane.paneId, windowActivityAt)) updateOutputAt(windowActivityAt);
+			if (agent === "codex" && !pane.paneDead) {
+				const fingerprint = await capturePaneFingerprint(pane.paneId, pane.alternateOn);
+				if (fingerprint) {
+					if (lastFingerprint.get(pane.paneId) !== fingerprint) {
+						lastFingerprint.set(pane.paneId, fingerprint);
+						updateOutputAt((/* @__PURE__ */ new Date()).toISOString());
+					}
+				}
+			}
+			if (!outputAt) updateOutputAt((/* @__PURE__ */ new Date(Date.now() - config.activity.inactiveThresholdMs - 1e3)).toISOString());
+			const eventAt = lastEventAt.get(pane.paneId) ?? null;
+			const message = lastMessage.get(pane.paneId) ?? null;
+			const restoredSession = applyRestored(pane.paneId);
+			const estimated = estimateState({
+				paneDead: pane.paneDead,
+				lastOutputAt: outputAt,
+				hookState,
+				thresholds: {
+					runningThresholdMs: agent === "codex" ? Math.min(config.activity.runningThresholdMs, 1e4) : config.activity.runningThresholdMs,
+					inactiveThresholdMs: config.activity.inactiveThresholdMs
+				}
+			});
+			const finalState = restoredSession ? restoredSession.state : estimated.state;
+			const finalReason = restoredSession ? "restored" : estimated.reason;
+			const paneTitle = normalizeTitle(pane.paneTitle);
+			const defaultTitle = buildDefaultTitle(pane.currentPath, pane.paneId, pane.sessionName);
+			const title = paneTitle && !hostCandidates.has(paneTitle) ? paneTitle : defaultTitle;
+			const detail = {
+				paneId: pane.paneId,
+				sessionName: pane.sessionName,
+				windowIndex: pane.windowIndex,
+				paneIndex: pane.paneIndex,
+				windowActivity: pane.windowActivity,
+				paneActive: pane.paneActive,
+				currentCommand: pane.currentCommand,
+				currentPath: pane.currentPath,
+				paneTty: pane.paneTty,
+				title,
+				agent,
+				state: finalState,
+				stateReason: finalReason,
+				lastMessage: message,
+				lastOutputAt: outputAt,
+				lastEventAt: eventAt,
+				paneDead: pane.paneDead,
+				alternateOn: pane.alternateOn,
+				pipeAttached,
+				pipeConflict,
+				startCommand: pane.paneStartCommand,
+				panePid: pane.panePid
+			};
+			registry.update(detail);
+		}
+		registry.removeMissing(activePaneIds);
+		lastOutputAt.forEach((_, paneId) => {
+			if (!activePaneIds.has(paneId)) {
+				lastOutputAt.delete(paneId);
+				lastEventAt.delete(paneId);
+				lastMessage.delete(paneId);
+				lastFingerprint.delete(paneId);
+				hookStates.delete(paneId);
+			}
+		});
+		saveState(registry.values());
+	};
+	const handleHookEvent = (context) => {
+		hookStates.set(context.paneId, context.hookState);
+		lastEventAt.set(context.paneId, context.hookState.at);
+	};
+	const startHookTailer = async () => {
+		await ensureDir(eventsDir);
+		await fs$1.open(eventLogPath, "a").then((handle) => handle.close());
+		jsonlTailer.onLine((line) => {
+			const parsed = claudeHookEventSchema.safeParse(JSON.parse(line));
+			if (!parsed.success) return;
+			const event = parsed.data;
+			const hookState = deriveHookState(event.hook_event_name, event.notification_type);
+			if (!hookState) return;
+			const paneId = mapHookToPane(registry.values(), {
+				tmux_pane: event.tmux_pane ?? null,
+				tty: event.tty,
+				cwd: event.cwd
+			});
+			if (!paneId) return;
+			handleHookEvent({
+				paneId,
+				hookState: {
+					...hookState,
+					at: event.ts
+				}
+			});
+		});
+		jsonlTailer.start(eventLogPath);
+	};
+	const start = async () => {
+		logActivity.onActivity((paneId, at) => {
+			lastOutputAt.set(paneId, at);
+		});
+		logActivity.start();
+		await startHookTailer();
+		timer = setInterval(() => {
+			updateFromPanes().catch(() => null);
+			rotateLogIfNeeded(eventLogPath, config.logs.maxEventLogBytes, config.logs.retainRotations).catch(() => null);
+		}, config.activity.pollIntervalMs);
+		await updateFromPanes();
+	};
+	const stop = () => {
+		if (timer) {
+			clearInterval(timer);
+			timer = null;
+		}
+		logActivity.stop();
+		jsonlTailer.stop();
+	};
+	const getScreenCapture = () => screenCapture;
+	return {
+		registry,
+		start,
+		stop,
+		handleHookEvent,
+		getScreenCapture
+	};
+};
+
+//#endregion
+//#region apps/server/src/network.ts
+const isValidOctets = (parts) => {
+	return parts.every((value) => !Number.isNaN(value) && value >= 0 && value <= 255);
+};
+const isPrivateIP = (address) => {
+	const parts = address.split(".").map(Number);
+	if (parts.length !== 4 || !isValidOctets(parts)) return false;
+	const [first, second] = parts;
+	if (first === void 0 || second === void 0) return false;
+	if (first === 10) return true;
+	if (first === 172 && second >= 16 && second <= 31) return true;
+	return first === 192 && second === 168;
+};
+const isTailscaleIP = (address) => {
+	const parts = address.split(".").map(Number);
+	if (parts.length !== 4 || !isValidOctets(parts)) return false;
+	const [first, second] = parts;
+	if (first === void 0 || second === void 0) return false;
+	return first === 100 && second >= 64 && second <= 127;
+};
+const getTailscaleFromCLI = () => {
+	for (const bin of ["tailscale", "/Applications/Tailscale.app/Contents/MacOS/Tailscale"]) try {
+		const ip = execFileSync(bin, ["ip", "-4"], {
+			encoding: "utf8",
+			timeout: 2e3,
+			stdio: [
+				"pipe",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (ip && isTailscaleIP(ip)) return ip;
+	} catch {}
+	return null;
+};
+const getTailscaleFromInterfaces = () => {
+	const interfaces = networkInterfaces();
+	return Object.values(interfaces).flat().filter((info) => Boolean(info)).find((info) => info.family === "IPv4" && isTailscaleIP(info.address))?.address ?? null;
+};
+const getTailscaleIP = () => {
+	return getTailscaleFromCLI() ?? getTailscaleFromInterfaces();
+};
+const getLocalIP = () => {
+	const interfaces = networkInterfaces();
+	const candidates = Object.values(interfaces).flat().filter((info) => Boolean(info)).filter((info) => info.family === "IPv4" && !info.internal && !isTailscaleIP(info.address));
+	const privateMatch = candidates.find((info) => isPrivateIP(info.address));
+	if (privateMatch) return privateMatch.address;
+	return candidates[0]?.address ?? "localhost";
+};
+
+//#endregion
+//#region apps/server/src/ports.ts
+const isPortAvailable = (port, host) => new Promise((resolve) => {
+	const server = createServer();
+	server.once("error", () => {
+		server.close();
+		resolve(false);
+	});
+	server.once("listening", () => {
+		server.close(() => resolve(true));
+	});
+	server.listen(port, host);
+});
+const findAvailablePort = async (startPort, host, attempts) => {
+	for (let i = 0; i < attempts; i += 1) {
+		const port = startPort + i;
+		if (await isPortAvailable(port, host)) return port;
+	}
+	throw new Error(`No available port found in range ${startPort}-${startPort + attempts - 1}`);
+};
+
+//#endregion
+//#region apps/server/src/tmux-actions.ts
+const buildError = (code, message) => ({
+	code,
+	message
+});
+const createTmuxActions = (adapter, config) => {
+	const dangerPatterns = compileDangerPatterns(config.dangerCommandPatterns);
+	const enterKey = config.input.enterKey || "C-m";
+	const enterDelayMs = config.input.enterDelayMs ?? 0;
+	const bracketedPaste = (value) => `\u001b[200~${value}\u001b[201~`;
+	const sendText = async (paneId, text, enter = true) => {
+		if (!text || text.trim().length === 0) return {
+			ok: false,
+			error: buildError("INVALID_PAYLOAD", "text is required")
+		};
+		if (text.length > config.input.maxTextLength) return {
+			ok: false,
+			error: buildError("INVALID_PAYLOAD", "text too long")
+		};
+		if (isDangerousCommand(text, dangerPatterns)) return {
+			ok: false,
+			error: buildError("DANGEROUS_COMMAND", "dangerous command blocked")
+		};
+		await adapter.run([
+			"if-shell",
+			"-t",
+			paneId,
+			"[ \"#{pane_in_mode}\" = \"1\" ]",
+			`copy-mode -q -t ${paneId}`
+		]);
+		const normalized = text.replace(/\r\n/g, "\n");
+		if (normalized.includes("\n")) {
+			const result = await adapter.run([
+				"send-keys",
+				"-l",
+				"-t",
+				paneId,
+				bracketedPaste(normalized)
+			]);
+			if (result.exitCode !== 0) return {
+				ok: false,
+				error: buildError("INTERNAL", result.stderr || "send-keys failed")
+			};
+			if (enter) {
+				if (enterDelayMs > 0) await new Promise((resolve) => setTimeout(resolve, enterDelayMs));
+				const enterResult = await adapter.run([
+					"send-keys",
+					"-t",
+					paneId,
+					enterKey
+				]);
+				if (enterResult.exitCode !== 0) return {
+					ok: false,
+					error: buildError("INTERNAL", enterResult.stderr || "send-keys Enter failed")
+				};
+			}
+			return { ok: true };
+		}
+		const result = await adapter.run([
+			"send-keys",
+			"-l",
+			"-t",
+			paneId,
+			normalized
+		]);
+		if (result.exitCode !== 0) return {
+			ok: false,
+			error: buildError("INTERNAL", result.stderr || "send-keys failed")
+		};
+		if (enter) {
+			if (enterDelayMs > 0) await new Promise((resolve) => setTimeout(resolve, enterDelayMs));
+			const enterResult = await adapter.run([
+				"send-keys",
+				"-t",
+				paneId,
+				enterKey
+			]);
+			if (enterResult.exitCode !== 0) return {
+				ok: false,
+				error: buildError("INTERNAL", enterResult.stderr || "send-keys Enter failed")
+			};
+		}
+		return { ok: true };
+	};
+	const sendKeys = async (paneId, keys) => {
+		const allowed = new Set(allowedKeys);
+		if (keys.length === 0 || keys.some((key) => !allowed.has(key))) return {
+			ok: false,
+			error: buildError("INVALID_PAYLOAD", "invalid keys")
+		};
+		for (const key of keys) {
+			const result = await adapter.run([
+				"send-keys",
+				"-t",
+				paneId,
+				key
+			]);
+			if (result.exitCode !== 0) return {
+				ok: false,
+				error: buildError("INTERNAL", result.stderr || "send-keys failed")
+			};
+		}
+		return { ok: true };
+	};
+	return {
+		sendText,
+		sendKeys
+	};
+};
+
+//#endregion
+//#region apps/server/src/index.ts
+const parseArgs = () => {
+	const args = process.argv.slice(2);
+	const flags = /* @__PURE__ */ new Map();
+	let command = null;
+	const positional = [];
+	for (let i = 0; i < args.length; i += 1) {
+		const arg = args[i];
+		if (!arg) continue;
+		if (arg.startsWith("--")) {
+			const next = args[i + 1];
+			if (next && !next.startsWith("--")) {
+				flags.set(arg, next);
+				i += 1;
+			} else flags.set(arg, true);
+		} else if (!command) command = arg;
+		else positional.push(arg);
+	}
+	return {
+		command,
+		flags,
+		positional
+	};
+};
+const printHooksSnippet = () => {
+	console.log(JSON.stringify({ hooks: {
+		PreToolUse: [{
+			matcher: "*",
+			hooks: [{
+				type: "command",
+				command: "tmux-agent-monitor-hook PreToolUse"
+			}]
+		}],
+		PostToolUse: [{
+			matcher: "*",
+			hooks: [{
+				type: "command",
+				command: "tmux-agent-monitor-hook PostToolUse"
+			}]
+		}],
+		Notification: [{ hooks: [{
+			type: "command",
+			command: "tmux-agent-monitor-hook Notification"
+		}] }],
+		Stop: [{ hooks: [{
+			type: "command",
+			command: "tmux-agent-monitor-hook Stop"
+		}] }],
+		UserPromptSubmit: [{ hooks: [{
+			type: "command",
+			command: "tmux-agent-monitor-hook UserPromptSubmit"
+		}] }]
+	} }, null, 2));
+};
+const ensureTmuxAvailable = async (adapter) => {
+	if ((await adapter.run(["-V"])).exitCode !== 0) throw new Error("tmux not available");
+	if ((await adapter.run(["list-sessions"])).exitCode !== 0) throw new Error("tmux server not running");
+};
+const parsePort = (value) => {
+	if (typeof value !== "string") return null;
+	const parsed = Number.parseInt(value, 10);
+	if (Number.isNaN(parsed) || parsed <= 0) return null;
+	return parsed;
+};
+const runServe = async (flags) => {
+	const config = ensureConfig();
+	const publicBind = flags.has("--public");
+	const tailscale = flags.has("--tailscale");
+	const noAttach = flags.has("--no-attach");
+	const portFlag = flags.get("--port");
+	const webPortFlag = flags.get("--web-port");
+	const socketName = flags.get("--socket-name");
+	const socketPath = flags.get("--socket-path");
+	config.bind = publicBind ? "0.0.0.0" : config.bind;
+	config.attachOnServe = !noAttach;
+	const parsedPort = parsePort(portFlag);
+	if (parsedPort) config.port = parsedPort;
+	if (typeof socketName === "string") config.tmux.socketName = socketName;
+	if (typeof socketPath === "string") config.tmux.socketPath = socketPath;
+	const host = config.bind;
+	const port = await findAvailablePort(config.port, host, 10);
+	const adapter = createTmuxAdapter({
+		socketName: config.tmux.socketName,
+		socketPath: config.tmux.socketPath
+	});
+	await ensureTmuxAvailable(adapter);
+	const monitor = createSessionMonitor(adapter, config);
+	await monitor.start();
+	const { app, injectWebSocket } = createApp({
+		config,
+		monitor,
+		tmuxActions: createTmuxActions(adapter, config)
+	});
+	injectWebSocket(serve({
+		fetch: app.fetch,
+		port,
+		hostname: host
+	}));
+	const url = `http://${tailscale ? getTailscaleIP() ?? getLocalIP() : host === "0.0.0.0" ? getLocalIP() : "localhost"}:${parsePort(webPortFlag) ?? port}/?token=${config.token}`;
+	console.log(`tmux-agent-monitor: ${url}`);
+	qrcode.generate(url, { small: true });
+	process.on("SIGINT", () => {
+		monitor.stop();
+		process.exit(0);
+	});
+};
+const main = async () => {
+	const { command, positional, flags } = parseArgs();
+	if (command === "token" && positional[0] === "rotate") {
+		const next = rotateToken();
+		console.log(next.token);
+		return;
+	}
+	if (command === "claude" && positional[0] === "hooks" && positional[1] === "print") {
+		printHooksSnippet();
+		return;
+	}
+	await runServe(flags);
+};
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };