@overmux/pi 0.0.1

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import { loadConfigOrDefault } from \"@richardgill/pi-config\";\n\nimport { OvermuxPiConfigSchema } from \"./config.js\";\nimport { overmuxPi } from \"./extension.js\";\n\nexport * from \"./extension.js\";\n\nconst config = loadConfigOrDefault({\n  filename: \"overmux-pi.jsonc\",\n  schema: OvermuxPiConfigSchema,\n});\n\nexport default (pi: Parameters<typeof overmuxPi>[0]): void =>\n  overmuxPi(pi, config);\n"],"mappings":";;;;;;;AAOA,MAAM,SAAS,oBAAoB;CACjC,UAAU;CACV,QAAQ;AACV,CAAC;AAED,IAAA,eAAgB,OACd,UAAU,IAAI,MAAM"}

package/dist/jsonl-tail.d.ts

@@ -0,0 +1,13 @@
+//#region src/jsonl-tail.d.ts
+type JsonlRead = {
+  records: unknown[];
+  reset: boolean;
+};
+type JsonlTail = {
+  read: (path: string) => Promise<JsonlRead>;
+};
+declare const parseCompleteJsonlBytes: (bytes: Buffer) => unknown[];
+declare const createJsonlTail: () => JsonlTail;
+//#endregion
+export { JsonlRead, JsonlTail, createJsonlTail, parseCompleteJsonlBytes };
+//# sourceMappingURL=jsonl-tail.d.ts.map

package/dist/jsonl-tail.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-tail.d.ts","names":[],"sources":["../src/jsonl-tail.ts"],"mappings":";KAIY;EAAc;EAAoB;;KAClC;EAAc,OAAO,iBAAiB,QAAQ;;cAE7C,0BAA2B,OAAO;cAkElC,uBAAsB"}

package/dist/jsonl-tail.js

@@ -0,0 +1,83 @@
+import { open, stat } from "node:fs/promises";
+//#region src/jsonl-tail.ts
+const parseCompleteJsonlBytes = (bytes) => {
+	const records = [];
+	let offset = 0;
+	bytes.forEach((byte, index) => {
+		if (byte !== 10) return;
+		const line = bytes.subarray(offset, index);
+		offset = index + 1;
+		if (!line.length) return;
+		try {
+			records.push(JSON.parse(line.toString("utf8")));
+		} catch {}
+	});
+	return records;
+};
+const parseJsonlLines = (bytes) => {
+	const newline = bytes.lastIndexOf(10);
+	if (newline < 0) return {
+		records: [],
+		remainder: bytes
+	};
+	return {
+		records: parseCompleteJsonlBytes(bytes.subarray(0, newline + 1)),
+		remainder: bytes.subarray(newline + 1)
+	};
+};
+const readBytes = async (path, offset, length) => {
+	const handle = await open(path, "r");
+	try {
+		const bytes = Buffer.alloc(length);
+		const { bytesRead } = await handle.read(bytes, 0, length, offset);
+		return bytes.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+};
+const anchorMatches = async (path, cursor, anchor) => {
+	if (!anchor.length) return true;
+	return (await readBytes(path, cursor - anchor.length, anchor.length)).equals(anchor);
+};
+const nextAnchor = (previous, appended) => Buffer.concat([previous, appended]).subarray(-512);
+const createJsonlTail = () => {
+	let anchor = Buffer.alloc(0);
+	let cursor = 0;
+	let identity;
+	let remainder = Buffer.alloc(0);
+	return { read: async (path) => {
+		const metadata = await stat(path).catch(() => void 0);
+		if (!metadata?.isFile()) return {
+			records: [],
+			reset: false
+		};
+		const nextIdentity = `${metadata.dev}:${metadata.ino}`;
+		const replaced = identity !== void 0 && identity !== nextIdentity;
+		const truncated = metadata.size < cursor;
+		const rewritten = !replaced && !truncated && !await anchorMatches(path, cursor, anchor);
+		const reset = replaced || truncated || rewritten;
+		if (reset) {
+			anchor = Buffer.alloc(0);
+			cursor = 0;
+			remainder = Buffer.alloc(0);
+		}
+		identity = nextIdentity;
+		if (metadata.size === cursor) return {
+			records: [],
+			reset
+		};
+		const bytes = await readBytes(path, cursor, metadata.size - cursor);
+		cursor += bytes.length;
+		anchor = nextAnchor(anchor, bytes);
+		const parsed = parseJsonlLines(Buffer.concat([remainder, bytes]));
+		remainder = parsed.remainder;
+		return {
+			records: parsed.records,
+			reset
+		};
+	} };
+};
+//#endregion
+export { createJsonlTail, parseCompleteJsonlBytes };
+
+//# sourceMappingURL=jsonl-tail.js.map

package/dist/jsonl-tail.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsonl-tail.js","names":[],"sources":["../src/jsonl-tail.ts"],"sourcesContent":["import { open, stat } from \"node:fs/promises\";\n\nconst ANCHOR_BYTES = 512;\n\nexport type JsonlRead = { records: unknown[]; reset: boolean };\nexport type JsonlTail = { read: (path: string) => Promise<JsonlRead> };\n\nexport const parseCompleteJsonlBytes = (bytes: Buffer): unknown[] => {\n  const records: unknown[] = [];\n  let offset = 0;\n  bytes.forEach((byte, index) => {\n    if (byte !== 10) {\n      return;\n    }\n    const line = bytes.subarray(offset, index);\n    offset = index + 1;\n    if (!line.length) {\n      return;\n    }\n    try {\n      records.push(JSON.parse(line.toString(\"utf8\")) as unknown);\n    } catch {}\n  });\n  return records;\n};\n\nconst parseJsonlLines = (bytes: Buffer) => {\n  const newline = bytes.lastIndexOf(10);\n  if (newline < 0) {\n    return { records: [] as unknown[], remainder: bytes };\n  }\n  return {\n    records: parseCompleteJsonlBytes(bytes.subarray(0, newline + 1)),\n    remainder: bytes.subarray(newline + 1),\n  };\n};\n\nconst readBytes = async (\n  path: string,\n  offset: number,\n  length: number,\n): Promise<Buffer<ArrayBufferLike>> => {\n  const handle = await open(path, \"r\");\n  try {\n    const bytes = Buffer.alloc(length);\n    const { bytesRead } = await handle.read(bytes, 0, length, offset);\n    return bytes.subarray(0, bytesRead);\n  } finally {\n    await handle.close();\n  }\n};\n\nconst anchorMatches = async (\n  path: string,\n  cursor: number,\n  anchor: Buffer<ArrayBufferLike>,\n) => {\n  if (!anchor.length) {\n    return true;\n  }\n  const committed = await readBytes(\n    path,\n    cursor - anchor.length,\n    anchor.length,\n  );\n  return committed.equals(anchor);\n};\n\nconst nextAnchor = (\n  previous: Buffer<ArrayBufferLike>,\n  appended: Buffer<ArrayBufferLike>,\n) => Buffer.concat([previous, appended]).subarray(-ANCHOR_BYTES);\n\nexport const createJsonlTail = (): JsonlTail => {\n  let anchor: Buffer<ArrayBufferLike> = Buffer.alloc(0);\n  let cursor = 0;\n  let identity: string | undefined;\n  let remainder: Buffer<ArrayBufferLike> = Buffer.alloc(0);\n\n  return {\n    read: async (path) => {\n      const metadata = await stat(path).catch(() => undefined);\n      if (!metadata?.isFile()) {\n        return { records: [], reset: false };\n      }\n      const nextIdentity = `${metadata.dev}:${metadata.ino}`;\n      const replaced = identity !== undefined && identity !== nextIdentity;\n      const truncated = metadata.size < cursor;\n      const rewritten =\n        !replaced && !truncated && !(await anchorMatches(path, cursor, anchor));\n      const reset = replaced || truncated || rewritten;\n      if (reset) {\n        anchor = Buffer.alloc(0);\n        cursor = 0;\n        remainder = Buffer.alloc(0);\n      }\n      identity = nextIdentity;\n      if (metadata.size === cursor) {\n        return { records: [], reset };\n      }\n\n      const bytes = await readBytes(path, cursor, metadata.size - cursor);\n      cursor += bytes.length;\n      anchor = nextAnchor(anchor, bytes);\n      const parsed = parseJsonlLines(Buffer.concat([remainder, bytes]));\n      remainder = parsed.remainder;\n      return { records: parsed.records, reset };\n    },\n  };\n};\n"],"mappings":";;AAOA,MAAa,2BAA2B,UAA6B;CACnE,MAAM,UAAqB,CAAC;CAC5B,IAAI,SAAS;CACb,MAAM,SAAS,MAAM,UAAU;EAC7B,IAAI,SAAS,IACX;EAEF,MAAM,OAAO,MAAM,SAAS,QAAQ,KAAK;EACzC,SAAS,QAAQ;EACjB,IAAI,CAAC,KAAK,QACR;EAEF,IAAI;GACF,QAAQ,KAAK,KAAK,MAAM,KAAK,SAAS,MAAM,CAAC,CAAY;EAC3D,QAAQ,CAAC;CACX,CAAC;CACD,OAAO;AACT;AAEA,MAAM,mBAAmB,UAAkB;CACzC,MAAM,UAAU,MAAM,YAAY,EAAE;CACpC,IAAI,UAAU,GACZ,OAAO;EAAE,SAAS,CAAC;EAAgB,WAAW;CAAM;CAEtD,OAAO;EACL,SAAS,wBAAwB,MAAM,SAAS,GAAG,UAAU,CAAC,CAAC;EAC/D,WAAW,MAAM,SAAS,UAAU,CAAC;CACvC;AACF;AAEA,MAAM,YAAY,OAChB,MACA,QACA,WACqC;CACrC,MAAM,SAAS,MAAM,KAAK,MAAM,GAAG;CACnC,IAAI;EACF,MAAM,QAAQ,OAAO,MAAM,MAAM;EACjC,MAAM,EAAE,cAAc,MAAM,OAAO,KAAK,OAAO,GAAG,QAAQ,MAAM;EAChE,OAAO,MAAM,SAAS,GAAG,SAAS;CACpC,UAAU;EACR,MAAM,OAAO,MAAM;CACrB;AACF;AAEA,MAAM,gBAAgB,OACpB,MACA,QACA,WACG;CACH,IAAI,CAAC,OAAO,QACV,OAAO;CAOT,QAAO,MALiB,UACtB,MACA,SAAS,OAAO,QAChB,OAAO,MACT,EAAA,CACiB,OAAO,MAAM;AAChC;AAEA,MAAM,cACJ,UACA,aACG,OAAO,OAAO,CAAC,UAAU,QAAQ,CAAC,CAAC,CAAC,SAAS,IAAa;AAE/D,MAAa,wBAAmC;CAC9C,IAAI,SAAkC,OAAO,MAAM,CAAC;CACpD,IAAI,SAAS;CACb,IAAI;CACJ,IAAI,YAAqC,OAAO,MAAM,CAAC;CAEvD,OAAO,EACL,MAAM,OAAO,SAAS;EACpB,MAAM,WAAW,MAAM,KAAK,IAAI,CAAC,CAAC,YAAY,KAAA,CAAS;EACvD,IAAI,CAAC,UAAU,OAAO,GACpB,OAAO;GAAE,SAAS,CAAC;GAAG,OAAO;EAAM;EAErC,MAAM,eAAe,GAAG,SAAS,IAAI,GAAG,SAAS;EACjD,MAAM,WAAW,aAAa,KAAA,KAAa,aAAa;EACxD,MAAM,YAAY,SAAS,OAAO;EAClC,MAAM,YACJ,CAAC,YAAY,CAAC,aAAa,CAAE,MAAM,cAAc,MAAM,QAAQ,MAAM;EACvE,MAAM,QAAQ,YAAY,aAAa;EACvC,IAAI,OAAO;GACT,SAAS,OAAO,MAAM,CAAC;GACvB,SAAS;GACT,YAAY,OAAO,MAAM,CAAC;EAC5B;EACA,WAAW;EACX,IAAI,SAAS,SAAS,QACpB,OAAO;GAAE,SAAS,CAAC;GAAG;EAAM;EAG9B,MAAM,QAAQ,MAAM,UAAU,MAAM,QAAQ,SAAS,OAAO,MAAM;EAClE,UAAU,MAAM;EAChB,SAAS,WAAW,QAAQ,KAAK;EACjC,MAAM,SAAS,gBAAgB,OAAO,OAAO,CAAC,WAAW,KAAK,CAAC,CAAC;EAChE,YAAY,OAAO;EACnB,OAAO;GAAE,SAAS,OAAO;GAAS;EAAM;CAC1C,EACF;AACF"}

package/dist/live-events-ClhFOMGW.js

@@ -0,0 +1,497 @@
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, readFile, readdir, rename, rm, writeFile } from "node:fs/promises";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { hostname } from "node:os";
+import { watch } from "node:fs";
+//#region src/session-status.ts
+const piSessionStatusSchema = z.object({
+	version: z.literal(1),
+	sessionId: z.string().min(1),
+	sessionFile: z.string().min(1),
+	streamId: z.string().min(1),
+	processInstanceId: z.string().min(1),
+	pid: z.number().int().positive(),
+	hostname: z.string().min(1),
+	tmuxPane: z.string().min(1).optional(),
+	startedAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative(),
+	state: z.enum([
+		"idle",
+		"busy",
+		"stopped"
+	]),
+	model: z.object({
+		provider: z.string().min(1),
+		id: z.string().min(1),
+		name: z.string().min(1)
+	}).strict().optional(),
+	thinkingLevel: z.string().min(1),
+	modelOptions: z.array(z.object({
+		provider: z.string().min(1),
+		id: z.string().min(1),
+		name: z.string().min(1)
+	}).strict()).max(256).optional(),
+	contextUsage: z.object({
+		tokens: z.number().nonnegative(),
+		contextWindow: z.number().positive(),
+		percent: z.number().nonnegative()
+	}).strict().optional()
+}).strict();
+const SAFE_PATH_SEGMENT$1 = /^[A-Za-z0-9._-]{1,128}$/;
+const requirePathSegment$1 = (value, label) => {
+	if (!SAFE_PATH_SEGMENT$1.test(value)) throw new Error(`Invalid ${label} for Pi session status path`);
+	return value;
+};
+const piSessionStatusPath = (rootDir, sessionId, streamId) => join(resolve(rootDir), requirePathSegment$1(sessionId, "session ID"), `${requirePathSegment$1(streamId, "stream ID")}.status.json`);
+const parsePiSessionStatus = (value) => {
+	const result = piSessionStatusSchema.safeParse(value);
+	return result.success ? result.data : void 0;
+};
+const reportError$1 = (onError, error) => {
+	try {
+		onError?.(error);
+	} catch {}
+};
+const replaceStatusFile = async (state, status) => {
+	await mkdir(state.sessionDir, {
+		recursive: true,
+		mode: 448
+	});
+	const temporaryPath = `${state.filePath}.${randomUUID()}.tmp`;
+	try {
+		await writeFile(temporaryPath, `${JSON.stringify(status)}\n`, {
+			encoding: "utf8",
+			flag: "wx",
+			mode: 384
+		});
+		await rename(temporaryPath, state.filePath);
+	} catch (error) {
+		await rm(temporaryPath, { force: true }).catch(() => void 0);
+		throw error;
+	}
+};
+const updateStatus = (state, update) => {
+	if (!state.accepting) return state.writeChain;
+	const status = piSessionStatusSchema.parse({
+		...state.current,
+		...update,
+		updatedAt: Date.now()
+	});
+	state.current = status;
+	state.writeChain = state.writeChain.then(() => replaceStatusFile(state, status)).catch((error) => reportError$1(state.onError, error));
+	return state.writeChain;
+};
+const createPiSessionStatusWriter = ({ rootDir, status, onError }) => {
+	const filePath = piSessionStatusPath(rootDir, status.sessionId, status.streamId);
+	const state = {
+		accepting: true,
+		current: piSessionStatusSchema.parse({
+			...status,
+			updatedAt: status.startedAt,
+			version: 1
+		}),
+		filePath,
+		onError,
+		sessionDir: join(resolve(rootDir), status.sessionId),
+		writeChain: Promise.resolve()
+	};
+	return {
+		filePath,
+		streamId: status.streamId,
+		update: (update) => updateStatus(state, update),
+		close: async () => {
+			if (!state.accepting) {
+				await state.writeChain;
+				return;
+			}
+			const closing = updateStatus(state, { state: "stopped" });
+			state.accepting = false;
+			await closing;
+		}
+	};
+};
+const readStatus = async (filePath, sessionId, streamId) => {
+	try {
+		const status = parsePiSessionStatus(JSON.parse(await readFile(filePath, "utf8")));
+		return status?.sessionId === sessionId && status.streamId === streamId ? status : void 0;
+	} catch {
+		return;
+	}
+};
+const compareRecency = (left, right) => left.updatedAt - right.updatedAt || left.startedAt - right.startedAt || left.streamId.localeCompare(right.streamId);
+const newestBy = (statuses, keyOf) => {
+	const newest = /* @__PURE__ */ new Map();
+	statuses.forEach((status) => {
+		const key = keyOf(status);
+		const previous = newest.get(key);
+		if (!previous || compareRecency(previous, status) < 0) newest.set(key, status);
+	});
+	return [...newest.values()];
+};
+const isLocalPidAlive = (pid) => {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch (error) {
+		return error.code === "EPERM";
+	}
+};
+const listPiSessionStatuses = async ({ rootDir, hostname: hostname$1 = hostname(), pidAlive = isLocalPidAlive }) => {
+	const sessionDirectories = (await readdir(resolve(rootDir), { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isDirectory() && SAFE_PATH_SEGMENT$1.test(entry.name)).map((entry) => entry.name);
+	const statuses = (await Promise.all(sessionDirectories.map(async (sessionId) => {
+		const sessionDir = join(resolve(rootDir), sessionId);
+		const files = (await readdir(sessionDir, { withFileTypes: true }).catch(() => [])).filter((entry) => entry.isFile() && entry.name.endsWith(".status.json") && SAFE_PATH_SEGMENT$1.test(entry.name.slice(0, -12)));
+		return Promise.all(files.map((entry) => {
+			const streamId = entry.name.slice(0, -12);
+			return readStatus(join(sessionDir, entry.name), sessionId, streamId);
+		}));
+	}))).flatMap((values) => values).filter((status) => status !== void 0);
+	const processStatuses = newestBy(statuses, ({ hostname: statusHostname, processInstanceId }) => `${statusHostname}\0${processInstanceId}`).filter((status) => status.state !== "stopped" && status.hostname === hostname$1 && pidAlive(status.pid));
+	return newestBy(processStatuses, ({ sessionId }) => sessionId).sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+};
+const createPiSessionStatusSource = ({ rootDir, pollIntervalMs = 250, hostname, pidAlive }) => ({
+	list: () => listPiSessionStatuses({
+		rootDir,
+		hostname,
+		pidAlive
+	}),
+	subscribe: (invalidate, { signal }) => {
+		if (signal.aborted) return () => void 0;
+		let watcher;
+		let scheduled;
+		let fingerprint;
+		let checkQueue = Promise.resolve();
+		const check = () => {
+			checkQueue = checkQueue.then(async () => {
+				const next = JSON.stringify(await listPiSessionStatuses({
+					rootDir,
+					hostname,
+					pidAlive
+				}));
+				if (next === fingerprint || signal.aborted) return;
+				fingerprint = next;
+				invalidate();
+			}).catch(() => void 0);
+		};
+		const schedule = () => {
+			if (scheduled || signal.aborted) return;
+			scheduled = setTimeout(() => {
+				scheduled = void 0;
+				check();
+			}, 10);
+			scheduled.unref();
+		};
+		try {
+			watcher = watch(resolve(rootDir), { recursive: true }, schedule);
+		} catch {}
+		check();
+		const timer = setInterval(schedule, pollIntervalMs);
+		timer.unref();
+		const dispose = () => {
+			signal.removeEventListener("abort", dispose);
+			if (scheduled) clearTimeout(scheduled);
+			clearInterval(timer);
+			watcher?.close();
+		};
+		signal.addEventListener("abort", dispose, { once: true });
+		return dispose;
+	}
+});
+//#endregion
+//#region src/live-events.ts
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const parseLiveEventRecord = (value, sessionId) => {
+	if (!isRecord(value) || value.version !== 1) return;
+	if (sessionId !== void 0 && value.sessionId !== sessionId) return;
+	if (typeof value.sessionId !== "string" || typeof value.processInstanceId !== "string" || typeof value.streamId !== "string" || !Number.isSafeInteger(value.sequence) || value.sequence < 1 || typeof value.timestamp !== "number" || !isRecord(value.event) || typeof value.event.type !== "string") return;
+	return value;
+};
+const PROCESS_INSTANCE_KEY = Symbol.for("overmux-pi.live-events.process-instance-id");
+const processGlobals = globalThis;
+const PROCESS_INSTANCE_ID = processGlobals[PROCESS_INSTANCE_KEY] ?? `${process.pid}-${randomUUID()}`;
+processGlobals[PROCESS_INSTANCE_KEY] = PROCESS_INSTANCE_ID;
+const SAFE_PATH_SEGMENT = /^[A-Za-z0-9._-]{1,128}$/;
+const requirePathSegment = (value, label) => {
+	if (!SAFE_PATH_SEGMENT.test(value)) throw new Error(`Invalid ${label} for live event path`);
+	return value;
+};
+const liveEventSessionDir = (rootDir, sessionId) => join(resolve(rootDir), requirePathSegment(sessionId, "session ID"));
+const liveEventStreamPath = (rootDir, sessionId, streamId) => join(liveEventSessionDir(rootDir, sessionId), `${requirePathSegment(streamId, "stream ID")}.jsonl`);
+const isSameOrWithin = (parent, candidate) => {
+	const relativePath = relative(resolve(parent), resolve(candidate));
+	return relativePath === "" || relativePath !== ".." && !relativePath.startsWith(`..${sep}`);
+};
+const assertSeparateFromSessionFile = (rootDir, sessionFile) => {
+	if (!sessionFile) return;
+	const sessionDir = dirname(sessionFile);
+	if (isSameOrWithin(rootDir, sessionDir) || isSameOrWithin(sessionDir, rootDir)) throw new Error("Live events directory must be outside the Pi session directory tree");
+};
+const reportError = (onError, error) => {
+	try {
+		onError?.(error);
+	} catch {}
+};
+const reportWriterError = (state, error) => {
+	state.failed = true;
+	reportError(state.onError, error);
+};
+const appendLiveEvent = (state, event) => {
+	if (!state.accepting || state.failed) return;
+	const record = {
+		version: 1,
+		sessionId: state.sessionId,
+		processInstanceId: state.processInstanceId,
+		streamId: state.streamId,
+		sequence: state.sequence,
+		timestamp: Date.now(),
+		event
+	};
+	state.sequence += 1;
+	let line;
+	try {
+		line = `${JSON.stringify(record)}\n`;
+	} catch (error) {
+		reportWriterError(state, error);
+		return;
+	}
+	state.writeChain = state.writeChain.then(async () => {
+		if (!state.directoryReady) {
+			await mkdir(state.sessionDir, {
+				recursive: true,
+				mode: 448
+			});
+			state.directoryReady = true;
+		}
+		await appendFile(state.filePath, line, {
+			encoding: "utf8",
+			mode: 384
+		});
+	}).catch((error) => reportWriterError(state, error));
+};
+const closeLiveEventWriter = async (state, event) => {
+	if (!state.accepting) {
+		await state.writeChain;
+		return;
+	}
+	appendLiveEvent(state, event);
+	state.accepting = false;
+	await state.writeChain;
+};
+const createLiveEventWriter = ({ rootDir, sessionId, processInstanceId = PROCESS_INSTANCE_ID, streamId = randomUUID(), onError }) => {
+	const state = {
+		filePath: liveEventStreamPath(rootDir, sessionId, streamId),
+		sessionDir: liveEventSessionDir(rootDir, sessionId),
+		sessionId,
+		processInstanceId,
+		streamId,
+		sequence: 1,
+		accepting: true,
+		directoryReady: false,
+		failed: false,
+		writeChain: Promise.resolve(),
+		onError
+	};
+	return {
+		filePath: state.filePath,
+		streamId: state.streamId,
+		append: (event) => appendLiveEvent(state, event),
+		close: (event) => closeLiveEventWriter(state, event)
+	};
+};
+const compactAssistantMessageEvent = (event) => {
+	if (event.type === "start") return { type: event.type };
+	if (event.type === "done") return {
+		type: event.type,
+		reason: event.reason
+	};
+	if (event.type === "error") {
+		const errorMessage = event.error.errorMessage;
+		return {
+			type: event.type,
+			reason: event.reason,
+			...errorMessage ? { errorMessage } : {}
+		};
+	}
+	if (event.type === "text_delta" || event.type === "thinking_delta" || event.type === "toolcall_delta") return {
+		type: event.type,
+		contentIndex: event.contentIndex,
+		delta: event.delta
+	};
+	return {
+		type: event.type,
+		contentIndex: event.contentIndex
+	};
+};
+const modelIdentity = (model) => ({
+	provider: model.provider,
+	id: model.id,
+	name: model.name
+});
+const modelOptions = (ctx) => {
+	const scopedModels = ctx.scopedModels ?? [];
+	const availableModels = ctx.modelRegistry?.getAvailable?.() ?? [];
+	const models = scopedModels.length ? scopedModels.map(({ model }) => model) : availableModels.length ? availableModels : ctx.modelRegistry?.getAll?.() ?? [];
+	return [...new Map(models.map((model) => {
+		const identity = modelIdentity(model);
+		return [`${identity.provider}\0${identity.id}`, identity];
+	})).values()].slice(0, 256);
+};
+const statusContextUsage = (ctx) => {
+	const usage = ctx.getContextUsage();
+	return usage && usage.tokens !== null && usage.percent !== null ? {
+		...usage,
+		tokens: usage.tokens,
+		percent: usage.percent
+	} : void 0;
+};
+const messageRole = (event) => event.message.role;
+const registerLiveEventCapture = (pi, options) => {
+	const state = { messageSequence: 0 };
+	const append = (event) => state.writer?.append(event);
+	const updateStatus = (ctx, update) => state.statusWriter?.update({
+		contextUsage: statusContextUsage(ctx),
+		...update
+	});
+	pi.on("session_info_changed", (event) => append(event));
+	pi.on("session_compact", (event) => append(event));
+	pi.on("session_tree", (event) => append(event));
+	pi.on("agent_start", (event, ctx) => {
+		append(event);
+		return updateStatus(ctx, { state: "busy" });
+	});
+	pi.on("agent_end", (event) => append({ type: event.type }));
+	pi.on("agent_settled", (event, ctx) => {
+		append(event);
+		return updateStatus(ctx, { state: "idle" });
+	});
+	pi.on("turn_start", (event) => append(event));
+	pi.on("turn_end", (event, ctx) => {
+		append({
+			type: event.type,
+			turnIndex: event.turnIndex
+		});
+		return updateStatus(ctx, {});
+	});
+	pi.on("message_start", (event) => {
+		state.messageSequence += 1;
+		const activeMessage = {
+			id: `${state.writer?.streamId ?? "inactive"}:${state.messageSequence}`,
+			sequence: state.messageSequence,
+			role: messageRole(event)
+		};
+		state.activeMessage = activeMessage;
+		append({
+			type: event.type,
+			messageId: activeMessage.id,
+			messageSequence: activeMessage.sequence,
+			message: event.message
+		});
+	});
+	pi.on("message_update", (event) => {
+		const activeMessage = state.activeMessage;
+		if (!activeMessage || activeMessage.role !== "assistant") return;
+		append({
+			type: event.type,
+			messageId: activeMessage.id,
+			messageSequence: activeMessage.sequence,
+			assistantMessageEvent: compactAssistantMessageEvent(event.assistantMessageEvent)
+		});
+	});
+	pi.on("message_end", (event, ctx) => {
+		const activeMessage = state.activeMessage;
+		if (!activeMessage) state.messageSequence += 1;
+		const identity = activeMessage ?? {
+			id: `${state.writer?.streamId ?? "inactive"}:${state.messageSequence}`,
+			sequence: state.messageSequence,
+			role: messageRole(event)
+		};
+		append({
+			type: event.type,
+			messageId: identity.id,
+			messageSequence: identity.sequence,
+			message: event.message
+		});
+		state.activeMessage = void 0;
+		return updateStatus(ctx, {});
+	});
+	pi.on("tool_execution_start", (event) => append(event));
+	pi.on("tool_execution_end", (event) => append(event));
+	pi.on("model_select", (event, ctx) => {
+		const model = modelIdentity(event.model);
+		append({
+			type: event.type,
+			source: event.source,
+			model,
+			...event.previousModel ? { previousModel: modelIdentity(event.previousModel) } : {}
+		});
+		return updateStatus(ctx, { model });
+	});
+	pi.on("thinking_level_select", (event, ctx) => {
+		append(event);
+		return updateStatus(ctx, { thinkingLevel: event.level });
+	});
+	return {
+		start: async (event, ctx) => {
+			state.messageSequence = 0;
+			state.activeMessage = void 0;
+			if (!options.rootDir) return;
+			try {
+				const sessionId = ctx.sessionManager.getSessionId();
+				const sessionFile = ctx.sessionManager.getSessionFile();
+				if (!sessionFile) throw new Error("Pi session has no session file");
+				assertSeparateFromSessionFile(options.rootDir, sessionFile);
+				state.writer = createLiveEventWriter({
+					rootDir: options.rootDir,
+					sessionId,
+					onError: options.onError
+				});
+				const startedAt = Date.now();
+				const contextUsage = statusContextUsage(ctx);
+				const availableModelOptions = modelOptions(ctx);
+				state.statusWriter = createPiSessionStatusWriter({
+					rootDir: options.rootDir,
+					onError: options.onError,
+					status: {
+						sessionId,
+						sessionFile,
+						streamId: state.writer.streamId,
+						processInstanceId: PROCESS_INSTANCE_ID,
+						pid: process.pid,
+						hostname: hostname(),
+						...options.env.TMUX_PANE ? { tmuxPane: options.env.TMUX_PANE } : {},
+						startedAt,
+						state: "idle",
+						...ctx.model ? { model: modelIdentity(ctx.model) } : {},
+						...availableModelOptions.length ? { modelOptions: availableModelOptions } : {},
+						thinkingLevel: ctx.thinkingLevel ?? pi.getThinkingLevel(),
+						...contextUsage ? { contextUsage } : {}
+					}
+				});
+				append({
+					...event,
+					cwd: ctx.cwd,
+					sessionFile,
+					pid: process.pid
+				});
+				await state.statusWriter.update({});
+			} catch (error) {
+				state.writer = void 0;
+				state.statusWriter = void 0;
+				reportError(options.onError, error);
+			}
+		},
+		stop: async (event) => {
+			const writer = state.writer;
+			const statusWriter = state.statusWriter;
+			state.writer = void 0;
+			state.statusWriter = void 0;
+			state.activeMessage = void 0;
+			await Promise.all([writer?.close(event), statusWriter?.close()]);
+		}
+	};
+};
+//#endregion
+export { liveEventStreamPath as a, createPiSessionStatusSource as c, listPiSessionStatuses as d, parsePiSessionStatus as f, liveEventSessionDir as i, createPiSessionStatusWriter as l, piSessionStatusSchema as m, compactAssistantMessageEvent as n, parseLiveEventRecord as o, piSessionStatusPath as p, createLiveEventWriter as r, registerLiveEventCapture as s, PROCESS_INSTANCE_ID as t, isLocalPidAlive as u };
+
+//# sourceMappingURL=live-events-ClhFOMGW.js.map