blun-king-cli 9.1.589 → 9.1.595

package/telegram-plugin/dist/bridge.mjs

@@ -1,5 +1,5 @@
 import { createRequire } from "node:module";
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { appendFileSync, chmodSync, closeSync, existsSync, fstatSync, lstatSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
 import { homedir } from "node:os";
@@ -59522,6 +59522,380 @@ function isMentioned(ctx, botUsername, extraPatterns) {
 	return false;
 }
 //#endregion
+//#region src/launcher-status.ts
+const MAX_READ_BYTES = 256 * 1024;
+const MAX_RECORD_BYTES = 8192;
+const MAX_RECEIPTS = 128;
+const MAX_SENDS = 16;
+const MAX_RECORDS = 2048;
+const CHECKPOINT_SCHEMA = "blun.launcher-status-checkpoint/v2";
+function resolveStatusChatId(access, configuredChatId) {
+	const allowed = (chatId) => /^-?[1-9]\d*$/.test(chatId) && (Object.hasOwn(access.groups, chatId) || access.dmPolicy !== "disabled" && access.allowFrom.includes(chatId));
+	const requested = configuredChatId?.trim();
+	if (requested) return allowed(requested) ? requested : null;
+	const groups = Object.keys(access.groups).filter(allowed);
+	if (groups.length > 0) return groups.length === 1 ? groups[0] : null;
+	const direct = [...new Set(access.allowFrom.filter(allowed))];
+	return direct.length === 1 ? direct[0] : null;
+}
+function regularFile(file) {
+	const before = lstatSync(file, { bigint: true });
+	if (!before.isFile() || before.isSymbolicLink()) throw new Error("launcher-status.invalid-file");
+	const fd = openSync(file, "r");
+	const after = fstatSync(fd, { bigint: true });
+	if (!after.isFile() || before.dev !== after.dev || before.ino !== after.ino) {
+		closeSync(fd);
+		throw new Error("launcher-status.file-changed");
+	}
+	return fd;
+}
+function openOutbox(file) {
+	try {
+		const stat = lstatSync(file);
+		if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1) throw new Error("launcher-status.invalid-file");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	const fd = openSync(file, "a", 384);
+	try {
+		verifyOutbox(file, fd);
+	} catch (error) {
+		closeSync(fd);
+		throw error;
+	}
+	return fd;
+}
+function verifyOutbox(file, fd) {
+	const pathStat = lstatSync(file, { bigint: true });
+	const handleStat = fstatSync(fd, { bigint: true });
+	if (!pathStat.isFile() || pathStat.isSymbolicLink() || pathStat.nlink !== 1n || handleStat.nlink !== 1n || pathStat.dev !== handleStat.dev || pathStat.ino !== handleStat.ino) throw new Error("launcher-status.file-changed");
+}
+function readRange(fd, start, length) {
+	const bytes = Buffer.alloc(length);
+	const size = readSync(fd, bytes, 0, length, start);
+	return bytes.subarray(0, size);
+}
+function hash(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+function readSmallJson(file) {
+	let fd;
+	try {
+		fd = regularFile(file);
+		const size = fstatSync(fd).size;
+		if (size > 64 * 1024) throw new Error("launcher-status.checkpoint-too-large");
+		return JSON.parse(readRange(fd, 0, size).toString("utf8"));
+	} catch (error) {
+		if (error.code === "ENOENT" || error instanceof SyntaxError) return void 0;
+		throw error;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+function writeCheckpoint(file, checkpoint) {
+	const temporary = `${file}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		writeFileSync(temporary, JSON.stringify(checkpoint) + "\n", {
+			flag: "wx",
+			mode: 384
+		});
+		renameSync(temporary, file);
+	} finally {
+		rmSync(temporary, { force: true });
+	}
+}
+function object$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function recentReceipts(file) {
+	let fd;
+	try {
+		fd = regularFile(file);
+		const size = fstatSync(fd).size;
+		const start = Math.max(0, size - MAX_READ_BYTES);
+		const lines = readRange(fd, start, size - start).toString("utf8").split("\n");
+		if (start > 0) lines.shift();
+		const ids = [];
+		for (let i = lines.length - 1, count = 0; i >= 0 && count < MAX_RECORDS; i--, count++) {
+			const line = lines[i];
+			if (Buffer.byteLength(line) > MAX_RECORD_BYTES) continue;
+			try {
+				const record = JSON.parse(line);
+				if (object$1(record) && record.kind === "launcher-status" && Number.isSafeInteger(record.message_id) && typeof record.event_id === "string" && record.event_id.length <= 128) ids.push(record.event_id);
+			} catch {}
+		}
+		return ids.slice(0, MAX_RECEIPTS).reverse();
+	} catch (error) {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	} finally {
+		if (fd !== void 0) closeSync(fd);
+	}
+}
+function parseEvent(line) {
+	if (line.length > MAX_RECORD_BYTES) return void 0;
+	let event;
+	try {
+		event = JSON.parse(line.toString("utf8"));
+	} catch {
+		return;
+	}
+	if (!object$1(event) || event.schema !== "blun.launcher-status/v1" || typeof event.id !== "string" || !/^[\w-]{1,128}$/.test(event.id) || !["launcher-restart", "launcher-restart-exhausted"].includes(String(event.kind)) || !Number.isSafeInteger(event.attempt) || !Number.isSafeInteger(event.limit) || Number(event.attempt) < 1 || Number(event.limit) < 1 || Number(event.limit) > 100 || Number(event.attempt) > Number(event.limit) || !Number.isSafeInteger(event.exitCode) || event.signal != null && (typeof event.signal !== "string" || !/^SIG[A-Z0-9]{1,16}$/.test(event.signal))) return;
+	const stopped = event.kind === "launcher-restart-exhausted" ? "stopped " : "";
+	const signal = event.signal ? ` signal=${event.signal}` : "";
+	return {
+		id: event.id,
+		text: `[launcher.restart] ${stopped}${event.attempt}/${event.limit} exit=${event.exitCode}${signal}`
+	};
+}
+function cursorValue(value) {
+	if (!object$1(value) || typeof value.identity !== "string" || value.identity.length > 256 || !Number.isSafeInteger(value.offset) || Number(value.offset) < 0 || !Number.isSafeInteger(value.prefixBytes) || Number(value.prefixBytes) < 0 || Number(value.prefixBytes) > 128 || typeof value.prefixHash !== "string" || !/^[a-f0-9]{64}$/.test(value.prefixHash)) return void 0;
+	return {
+		identity: value.identity,
+		offset: Number(value.offset),
+		prefixBytes: Number(value.prefixBytes),
+		prefixHash: value.prefixHash,
+		dropping: value.dropping === true
+	};
+}
+function fileCursor(fd, saved) {
+	const stat = fstatSync(fd, { bigint: true });
+	const identity = `${stat.dev}:${stat.ino}:${stat.birthtimeMs}`;
+	const size = Number(stat.size);
+	const prefixBytes = Math.min(size, 128);
+	const cursor = {
+		identity,
+		prefixBytes,
+		prefixHash: hash(readRange(fd, 0, prefixBytes)),
+		offset: 0,
+		dropping: false
+	};
+	const previous = cursorValue(saved);
+	if (!previous || previous.identity !== identity || previous.offset > size || previous.prefixBytes > Math.min(128, size) || previous.prefixHash !== hash(readRange(fd, 0, previous.prefixBytes))) return {
+		cursor,
+		restored: false
+	};
+	cursor.offset = previous.offset;
+	cursor.dropping = previous.dropping;
+	return {
+		cursor,
+		restored: true
+	};
+}
+function initialCheckpoint(fd, saved) {
+	const { cursor, restored } = fileCursor(fd, saved);
+	const checkpoint = {
+		schema: CHECKPOINT_SCHEMA,
+		...cursor,
+		deliveredIds: []
+	};
+	if (!object$1(saved)) return checkpoint;
+	const size = fstatSync(fd).size;
+	if (saved.schema === "blun.launcher-status-checkpoint/v1") {
+		if (Number.isSafeInteger(saved.offset) && Number(saved.offset) > 0 && Number(saved.offset) <= size && readRange(fd, Number(saved.offset) - 1, 1)[0] === 10) checkpoint.legacy = { until: Number(saved.offset) };
+		return checkpoint;
+	}
+	if (saved.schema !== CHECKPOINT_SCHEMA) return {
+		...checkpoint,
+		offset: 0,
+		dropping: false
+	};
+	if (Array.isArray(saved.deliveredIds)) checkpoint.deliveredIds = saved.deliveredIds.filter((id) => typeof id === "string" && /^[\w-]{1,128}$/.test(id)).slice(-MAX_RECEIPTS);
+	if (restored && object$1(saved.legacy) && Number.isSafeInteger(saved.legacy.until) && Number(saved.legacy.until) > checkpoint.offset && Number(saved.legacy.until) <= size) {
+		checkpoint.legacy = { until: Number(saved.legacy.until) };
+		const receipt = cursorValue(saved.legacy.receipt);
+		if (receipt && object$1(saved.legacy.receipt) && typeof saved.legacy.receipt.eventId === "string" && /^[\w-]{1,128}$/.test(saved.legacy.receipt.eventId)) checkpoint.legacy.receipt = {
+			...receipt,
+			eventId: saved.legacy.receipt.eventId
+		};
+	}
+	return checkpoint;
+}
+function confirmLegacyReceipt(file, legacy, eventId, budget, changed) {
+	if (budget.bytes === 0 || budget.records === 0) return false;
+	let fd;
+	try {
+		fd = regularFile(file);
+	} catch (error) {
+		if (error.code === "ENOENT") throw new Error("launcher-status.legacy-cursor-unverified");
+		throw error;
+	}
+	try {
+		const previous = legacy.receipt?.eventId === eventId ? legacy.receipt : void 0;
+		const { cursor, restored } = fileCursor(fd, previous);
+		if (!restored || cursor.prefixBytes !== previous?.prefixBytes) changed();
+		const scan = legacy.receipt = {
+			...cursor,
+			eventId
+		};
+		const size = fstatSync(fd).size;
+		const bytes = readRange(fd, scan.offset, Math.min(budget.bytes, size - scan.offset));
+		budget.bytes -= bytes.length;
+		let start = 0;
+		const advance = (count) => {
+			scan.offset += count;
+			changed();
+		};
+		while (start < bytes.length && budget.records > 0) {
+			const newline = bytes.indexOf(10, start);
+			if (newline < 0) {
+				if (scan.dropping || bytes.length - start > MAX_RECORD_BYTES) {
+					scan.dropping = true;
+					advance(bytes.length - start);
+				}
+				return false;
+			}
+			budget.records--;
+			const line = bytes.subarray(start, newline);
+			const complete = !scan.dropping && line.length <= MAX_RECORD_BYTES;
+			scan.dropping = false;
+			advance(newline + 1 - start);
+			start = newline + 1;
+			if (complete) try {
+				const record = JSON.parse(line.toString("utf8"));
+				if (object$1(record) && record.kind === "launcher-status" && record.event_id === eventId && Number.isSafeInteger(record.message_id)) return true;
+			} catch {}
+		}
+		if (scan.offset >= size) throw new Error("launcher-status.legacy-cursor-unverified");
+		return false;
+	} finally {
+		closeSync(fd);
+	}
+}
+const drains = /* @__PURE__ */ new Map();
+function drainLauncherStatusQueue(options) {
+	const directory = resolve(options.stateDir);
+	const pending = drains.get(directory);
+	if (pending) return pending;
+	const result = drain({
+		...options,
+		stateDir: directory
+	}).finally(() => drains.delete(directory));
+	drains.set(directory, result);
+	return result;
+}
+async function drain(options) {
+	const queue = join(options.stateDir, "launcher-status-queue.jsonl");
+	const cursorFile = join(options.stateDir, "launcher-status.checkpoint.json");
+	const outbox = join(options.stateDir, "outbox.jsonl");
+	let fd;
+	try {
+		fd = regularFile(queue);
+	} catch (error) {
+		if (error.code === "ENOENT") return { delivered: 0 };
+		throw error;
+	}
+	try {
+		const checkpoint = initialCheckpoint(fd, readSmallJson(cursorFile));
+		const bytes = readRange(fd, checkpoint.offset, Math.min(MAX_READ_BYTES, fstatSync(fd).size - checkpoint.offset));
+		if (bytes.length === 0) return { delivered: 0 };
+		const migrating = checkpoint.legacy !== void 0;
+		const ids = new Set([...migrating ? [] : recentReceipts(outbox), ...checkpoint.deliveredIds]);
+		let start = 0;
+		let delivered = 0;
+		let records = 0;
+		let dirty = false;
+		const receiptBudget = {
+			bytes: MAX_READ_BYTES,
+			records: MAX_RECORDS
+		};
+		const advance = (count) => {
+			checkpoint.offset += count;
+			if (checkpoint.legacy && checkpoint.offset >= checkpoint.legacy.until) checkpoint.legacy = void 0;
+			dirty = true;
+		};
+		const flush = () => {
+			if (!dirty) return;
+			checkpoint.deliveredIds = [...ids].slice(-MAX_RECEIPTS);
+			writeCheckpoint(cursorFile, checkpoint);
+			dirty = false;
+		};
+		try {
+			while (start < bytes.length && delivered < MAX_SENDS && records < MAX_RECORDS && !options.isDisposed?.()) {
+				const newline = bytes.indexOf(10, start);
+				if (newline < 0) {
+					if (checkpoint.dropping || bytes.length - start > MAX_RECORD_BYTES) {
+						checkpoint.dropping = true;
+						advance(bytes.length - start);
+					}
+					break;
+				}
+				const count = newline + 1 - start;
+				records++;
+				const event = checkpoint.dropping ? void 0 : parseEvent(bytes.subarray(start, newline));
+				checkpoint.dropping = false;
+				if (event && !ids.has(event.id) && checkpoint.legacy) {
+					if (!confirmLegacyReceipt(outbox, checkpoint.legacy, event.id, receiptBudget, () => {
+						dirty = true;
+					})) break;
+					ids.add(event.id);
+				}
+				if (event && !ids.has(event.id)) {
+					const chatId = resolveStatusChatId(options.readAccess(), options.configuredChatId);
+					if (chatId === null) break;
+					const outboxFd = openOutbox(outbox);
+					try {
+						const sent = await options.sendMessage(chatId, event.text);
+						if (!Number.isSafeInteger(sent.message_id)) throw new Error("launcher-status.missing-receipt");
+						ids.add(event.id);
+						delivered++;
+						try {
+							verifyOutbox(outbox, outboxFd);
+							appendFileSync(outboxFd, JSON.stringify({
+								ts: (/* @__PURE__ */ new Date()).toISOString(),
+								direction: "out",
+								kind: "launcher-status",
+								chat_id: chatId,
+								message_id: sent.message_id,
+								event_id: event.id,
+								text: event.text
+							}) + "\n");
+						} finally {
+							advance(count);
+							flush();
+						}
+					} finally {
+						closeSync(outboxFd);
+					}
+				} else advance(count);
+				start = newline + 1;
+				if (migrating && !checkpoint.legacy) break;
+			}
+			return { delivered };
+		} finally {
+			flush();
+		}
+	} finally {
+		closeSync(fd);
+	}
+}
+function startLauncherStatusWatcher(options) {
+	let disposed = false;
+	let active;
+	const run = () => {
+		if (disposed || active) return;
+		active = drainLauncherStatusQueue({
+			...options,
+			isDisposed: () => disposed
+		}).then(() => {}, (error) => {
+			options.onError?.(error);
+		}).finally(() => {
+			active = void 0;
+		});
+		active.catch(() => {});
+	};
+	const timer = setInterval(() => {
+		run();
+	}, options.intervalMs ?? 1e3);
+	timer.unref();
+	run();
+	return { dispose() {
+		disposed = true;
+		clearInterval(timer);
+		return active ?? Promise.resolve();
+	} };
+}
+//#endregion
 //#region src/format.ts
 /**
 * Filenames and titles are uploader-controlled. They land inside the
@@ -68035,6 +68409,13 @@ const session = new KingSession(KING_ENTRY, (msg) => {
 	process.stderr.write(`telegram bridge: ${msg}\n`);
 });
 const headlessContext = new BoundedChannelContextBuffer();
+const launcherStatusWatcher = startLauncherStatusWatcher({
+	stateDir: stateDir(),
+	readAccess,
+	configuredChatId: process.env["BLUN_TELEGRAM_STATUS_CHAT_ID"],
+	sendMessage: (chatId, text) => bot.api.sendMessage(chatId, text),
+	onError: () => process.stderr.write("telegram bridge: launcher-status.delivery-failed\n")
+});
 const SEEN_FILE = join(stateDir(), "seen-inbound.json");
 const SEEN_MAX = 500;
 let seenIds = [];
@@ -68153,10 +68534,15 @@ function shutdown() {
 	if (shuttingDown) return;
 	shuttingDown = true;
 	process.stderr.write("telegram bridge: shutting down\n");
-	releasePollerPid();
+	const drained = launcherStatusWatcher.dispose();
 	session.dispose();
-	setTimeout(() => process.exit(0), 2e3).unref();
-	Promise.resolve(bot.stop()).finally(() => process.exit(0));
+	const forcedExit = setTimeout(() => process.exit(0), 2e3);
+	forcedExit.unref();
+	Promise.allSettled([drained, bot.stop()]).then(() => {
+		releasePollerPid();
+		clearTimeout(forcedExit);
+		process.exit(0);
+	});
 }
 process.on("SIGTERM", shutdown);
 process.on("SIGINT", shutdown);