tmux-agent-monitor 0.0.1 → 0.0.3

package/dist/src-C_y43gN3.mjs

@@ -0,0 +1,369 @@
+import path from "node:path";
+import { z } from "zod";
+
+//#region packages/shared/src/constants.ts
+const allowedKeys = [
+	"Enter",
+	"Escape",
+	"Tab",
+	"BTab",
+	"C-Tab",
+	"C-BTab",
+	"Space",
+	"BSpace",
+	"Up",
+	"Down",
+	"Left",
+	"Right",
+	"C-Up",
+	"C-Down",
+	"C-Left",
+	"C-Right",
+	"C-Enter",
+	"C-Escape",
+	"Home",
+	"End",
+	"PageUp",
+	"PageDown",
+	"C-c",
+	"C-d",
+	"C-z",
+	"C-\\",
+	"C-u",
+	"C-k",
+	"F1",
+	"F2",
+	"F3",
+	"F4",
+	"F5",
+	"F6",
+	"F7",
+	"F8",
+	"F9",
+	"F10",
+	"F11",
+	"F12"
+];
+const defaultDangerKeys = [
+	"C-c",
+	"C-d",
+	"C-z",
+	"C-\\",
+	"F12"
+];
+const defaultDangerCommandPatterns = [
+	"rm\\s+(-rf?|--recursive)",
+	"sudo\\s+rm",
+	"mkfs",
+	"dd\\s+if=",
+	">\\s*/dev/",
+	"chmod\\s+777",
+	"curl.*\\|\\s*(ba)?sh",
+	"wget.*\\|\\s*(ba)?sh"
+];
+const defaultConfig = {
+	bind: "127.0.0.1",
+	port: 11080,
+	token: "",
+	readOnly: false,
+	attachOnServe: true,
+	staticAuth: false,
+	allowedOrigins: [],
+	rateLimit: {
+		send: {
+			windowMs: 1e3,
+			max: 10
+		},
+		screen: {
+			windowMs: 1e3,
+			max: 10
+		}
+	},
+	dangerKeys: [...defaultDangerKeys],
+	dangerCommandPatterns: [...defaultDangerCommandPatterns],
+	activity: {
+		pollIntervalMs: 1e3,
+		runningThresholdMs: 15e3,
+		inactiveThresholdMs: 6e4
+	},
+	hooks: {
+		ttyCacheTtlMs: 6e4,
+		ttyCacheMax: 200
+	},
+	input: {
+		maxTextLength: 2e3,
+		enterKey: "C-m",
+		enterDelayMs: 100
+	},
+	screen: {
+		mode: "text",
+		defaultLines: 2e3,
+		maxLines: 2e3,
+		joinLines: false,
+		ansi: true,
+		altScreen: "auto",
+		image: {
+			enabled: true,
+			backend: "terminal",
+			format: "png",
+			cropPane: true,
+			timeoutMs: 5e3
+		}
+	},
+	logs: {
+		maxPaneLogBytes: 2e6,
+		maxEventLogBytes: 2e6,
+		retainRotations: 5
+	},
+	tmux: {
+		socketName: null,
+		socketPath: null,
+		primaryClient: null
+	}
+};
+
+//#endregion
+//#region packages/shared/src/danger.ts
+const normalizeCommandLines = (text) => {
+	return text.replace(/\r\n/g, "\n").split("\n").map((line) => line.toLowerCase().replace(/\s+/g, " ").trim()).filter((line) => line.length > 0);
+};
+const compileDangerPatterns = (patterns) => {
+	return patterns.map((pattern) => new RegExp(pattern, "i"));
+};
+const isDangerousCommand = (text, patterns) => {
+	return normalizeCommandLines(text).some((line) => patterns.some((pattern) => pattern.test(line)));
+};
+
+//#endregion
+//#region packages/shared/src/paths.ts
+const encodePaneId = (paneId) => {
+	return encodeURIComponent(paneId);
+};
+const decodePaneId = (paneIdEncoded) => {
+	try {
+		const decoded = decodeURIComponent(paneIdEncoded);
+		for (let i = 0; i < decoded.length; i += 1) {
+			const code = decoded.charCodeAt(i);
+			if (code < 32 || code === 127) return paneIdEncoded;
+		}
+		return decoded;
+	} catch {
+		return paneIdEncoded;
+	}
+};
+const sanitizeServerKey = (value) => {
+	return value.replace(/\//g, "_").replace(/[^a-zA-Z0-9_-]/g, "-");
+};
+const resolveServerKey = (socketName, socketPath) => {
+	if (socketName && socketName.trim().length > 0) return sanitizeServerKey(socketName);
+	if (socketPath && socketPath.trim().length > 0) return sanitizeServerKey(socketPath);
+	return "default";
+};
+const resolveLogPaths = (baseDir, serverKey, paneId) => {
+	const paneIdEncoded = encodePaneId(paneId);
+	const panesDir = path.join(baseDir, "panes", serverKey);
+	const eventsDir = path.join(baseDir, "events", serverKey);
+	return {
+		paneIdEncoded,
+		panesDir,
+		eventsDir,
+		paneLogPath: path.join(panesDir, `${paneIdEncoded}.log`),
+		eventLogPath: path.join(eventsDir, "claude.jsonl")
+	};
+};
+
+//#endregion
+//#region packages/shared/src/schemas.ts
+const sessionStateSchema = z.enum([
+	"RUNNING",
+	"WAITING_INPUT",
+	"WAITING_PERMISSION",
+	"UNKNOWN"
+]);
+const allowedKeySchema = z.enum(allowedKeys);
+const apiErrorSchema = z.object({
+	code: z.enum([
+		"INVALID_PANE",
+		"INVALID_PAYLOAD",
+		"DANGEROUS_COMMAND",
+		"READ_ONLY",
+		"NOT_FOUND",
+		"TMUX_UNAVAILABLE",
+		"RATE_LIMIT",
+		"INTERNAL"
+	]),
+	message: z.string()
+});
+const screenResponseSchema = z.object({
+	ok: z.boolean(),
+	paneId: z.string(),
+	mode: z.enum(["text", "image"]),
+	capturedAt: z.string(),
+	lines: z.number().optional(),
+	truncated: z.boolean().nullable().optional(),
+	alternateOn: z.boolean().optional(),
+	screen: z.string().optional(),
+	imageBase64: z.string().optional(),
+	cropped: z.boolean().optional(),
+	fallbackReason: z.enum(["image_failed", "image_disabled"]).optional(),
+	error: apiErrorSchema.optional()
+});
+const commandResponseSchema = z.object({
+	ok: z.boolean(),
+	error: apiErrorSchema.optional()
+});
+const sessionSummarySchema = z.object({
+	paneId: z.string(),
+	sessionName: z.string(),
+	windowIndex: z.number(),
+	paneIndex: z.number(),
+	windowActivity: z.number().nullable(),
+	paneActive: z.boolean(),
+	currentCommand: z.string().nullable(),
+	currentPath: z.string().nullable(),
+	paneTty: z.string().nullable(),
+	title: z.string().nullable(),
+	agent: z.enum([
+		"codex",
+		"claude",
+		"unknown"
+	]),
+	state: sessionStateSchema,
+	stateReason: z.string(),
+	lastMessage: z.string().nullable(),
+	lastOutputAt: z.string().nullable(),
+	lastEventAt: z.string().nullable(),
+	paneDead: z.boolean(),
+	alternateOn: z.boolean(),
+	pipeAttached: z.boolean(),
+	pipeConflict: z.boolean()
+});
+const sessionDetailSchema = sessionSummarySchema.extend({
+	startCommand: z.string().nullable(),
+	panePid: z.number().nullable()
+});
+const wsEnvelopeSchema = (typeSchema, dataSchema) => z.object({
+	type: typeSchema,
+	ts: z.string(),
+	reqId: z.string().optional(),
+	data: dataSchema
+});
+const wsClientMessageSchema = z.discriminatedUnion("type", [
+	wsEnvelopeSchema(z.literal("screen.request"), z.object({
+		paneId: z.string(),
+		lines: z.number().optional(),
+		mode: z.enum(["text", "image"]).optional()
+	})),
+	wsEnvelopeSchema(z.literal("send.text"), z.object({
+		paneId: z.string(),
+		text: z.string(),
+		enter: z.boolean().optional()
+	})),
+	wsEnvelopeSchema(z.literal("send.keys"), z.object({
+		paneId: z.string(),
+		keys: z.array(allowedKeySchema)
+	})),
+	wsEnvelopeSchema(z.literal("client.ping"), z.object({}).strict())
+]);
+const wsServerMessageSchema = z.discriminatedUnion("type", [
+	wsEnvelopeSchema(z.literal("sessions.snapshot"), z.object({ sessions: z.array(sessionSummarySchema) })),
+	wsEnvelopeSchema(z.literal("session.updated"), z.object({ session: sessionSummarySchema })),
+	wsEnvelopeSchema(z.literal("session.removed"), z.object({ paneId: z.string() })),
+	wsEnvelopeSchema(z.literal("server.health"), z.object({ version: z.string() })),
+	wsEnvelopeSchema(z.literal("screen.response"), screenResponseSchema),
+	wsEnvelopeSchema(z.literal("command.response"), commandResponseSchema)
+]);
+const claudeHookEventSchema = z.object({
+	ts: z.string(),
+	hook_event_name: z.enum([
+		"PreToolUse",
+		"PostToolUse",
+		"Notification",
+		"Stop",
+		"UserPromptSubmit"
+	]),
+	notification_type: z.enum(["permission_prompt"]).optional(),
+	session_id: z.string(),
+	cwd: z.string().optional(),
+	tty: z.string().optional(),
+	tmux_pane: z.string().nullable().optional(),
+	transcript_path: z.string().optional(),
+	fallback: z.object({
+		cwd: z.string().optional(),
+		transcript_path: z.string().optional()
+	}).optional(),
+	payload: z.object({ raw: z.string() })
+});
+const configSchema = z.object({
+	bind: z.enum(["127.0.0.1", "0.0.0.0"]),
+	port: z.number(),
+	token: z.string(),
+	readOnly: z.boolean(),
+	attachOnServe: z.boolean(),
+	staticAuth: z.boolean(),
+	allowedOrigins: z.array(z.string()),
+	rateLimit: z.object({
+		send: z.object({
+			windowMs: z.number(),
+			max: z.number()
+		}),
+		screen: z.object({
+			windowMs: z.number(),
+			max: z.number()
+		})
+	}),
+	dangerKeys: z.array(z.string()),
+	dangerCommandPatterns: z.array(z.string()),
+	activity: z.object({
+		pollIntervalMs: z.number(),
+		runningThresholdMs: z.number(),
+		inactiveThresholdMs: z.number()
+	}),
+	hooks: z.object({
+		ttyCacheTtlMs: z.number(),
+		ttyCacheMax: z.number()
+	}),
+	input: z.object({
+		maxTextLength: z.number(),
+		enterKey: z.string().default("C-m"),
+		enterDelayMs: z.number().default(100)
+	}),
+	screen: z.object({
+		mode: z.enum(["text", "image"]),
+		defaultLines: z.number(),
+		maxLines: z.number(),
+		joinLines: z.boolean(),
+		ansi: z.boolean().default(true),
+		altScreen: z.enum([
+			"auto",
+			"on",
+			"off"
+		]),
+		image: z.object({
+			enabled: z.boolean(),
+			backend: z.enum([
+				"alacritty",
+				"terminal",
+				"iterm",
+				"wezterm",
+				"ghostty"
+			]),
+			format: z.enum(["png"]),
+			cropPane: z.boolean(),
+			timeoutMs: z.number()
+		})
+	}),
+	logs: z.object({
+		maxPaneLogBytes: z.number(),
+		maxEventLogBytes: z.number(),
+		retainRotations: z.number()
+	}),
+	tmux: z.object({
+		socketName: z.string().nullable(),
+		socketPath: z.string().nullable(),
+		primaryClient: z.string().nullable()
+	})
+});
+
+//#endregion
+export { resolveLogPaths as a, isDangerousCommand as c, decodePaneId as i, allowedKeys as l, configSchema as n, resolveServerKey as o, wsClientMessageSchema as r, compileDangerPatterns as s, claudeHookEventSchema as t, defaultConfig as u };

package/dist/tmux-agent-monitor-hook.js

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import { o as resolveServerKey } from "./src-C_y43gN3.mjs";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+//#region packages/hooks/src/cli.ts
+const readStdin = () => {
+	try {
+		return fs.readFileSync(0, "utf8");
+	} catch {
+		return "";
+	}
+};
+const encodeClaudeCwd = (cwd) => {
+	return cwd.replace(/[/.]/g, "-");
+};
+const resolveTranscriptPath = (cwd, sessionId) => {
+	if (!cwd || !sessionId) return null;
+	const encoded = encodeClaudeCwd(cwd);
+	return path.join(os.homedir(), ".claude", "projects", encoded, `${sessionId}.jsonl`);
+};
+const loadConfig = () => {
+	const configPath = path.join(os.homedir(), ".tmux-agent-monitor", "config.json");
+	try {
+		const raw = fs.readFileSync(configPath, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+};
+const ensureDir = (dir) => {
+	fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+};
+const main = () => {
+	const hookEventName = process.argv[2];
+	if (!hookEventName) {
+		console.error("Usage: tmux-agent-monitor-hook <HookEventName>");
+		process.exit(1);
+	}
+	const rawInput = readStdin().trim();
+	if (!rawInput) process.exit(0);
+	let payload = {};
+	try {
+		payload = JSON.parse(rawInput);
+	} catch {
+		console.error("Invalid JSON payload");
+		process.exit(1);
+	}
+	const sessionId = typeof payload.session_id === "string" ? payload.session_id : void 0;
+	const cwd = typeof payload.cwd === "string" ? payload.cwd : void 0;
+	const tty = typeof payload.tty === "string" ? payload.tty : void 0;
+	const tmuxPane = typeof payload.tmux_pane === "string" ? payload.tmux_pane : process.env.TMUX_PANE ?? null;
+	const notificationType = typeof payload.notification_type === "string" ? payload.notification_type : void 0;
+	const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : resolveTranscriptPath(cwd, sessionId);
+	const event = {
+		ts: (/* @__PURE__ */ new Date()).toISOString(),
+		hook_event_name: hookEventName,
+		notification_type: notificationType,
+		session_id: sessionId ?? "",
+		cwd,
+		tty,
+		tmux_pane: tmuxPane ?? null,
+		transcript_path: transcriptPath ?? void 0,
+		fallback: tmuxPane === null ? {
+			cwd,
+			transcript_path: transcriptPath ?? void 0
+		} : void 0,
+		payload: { raw: rawInput }
+	};
+	const config = loadConfig();
+	const serverKey = resolveServerKey(config?.tmux?.socketName ?? null, config?.tmux?.socketPath ?? null);
+	const baseDir = path.join(os.homedir(), ".tmux-agent-monitor");
+	const eventsDir = path.join(baseDir, "events", serverKey);
+	const eventsPath = path.join(eventsDir, "claude.jsonl");
+	ensureDir(eventsDir);
+	fs.appendFileSync(eventsPath, `${JSON.stringify(event)}\n`, "utf8");
+};
+main();
+
+//#endregion
+export {  };