blun-king-cli 9.1.416 → 9.1.417

package/LIESMICH.txt

@@ -67,6 +67,14 @@ Bereinigung und Mikrokompaktierung verwenden dafür dieselbe semantische Grenze.
 Erst nach der nachweislichen Auswertung darf ein Ergebnis archiviert oder
 gekürzt werden.
 
+Ab BLUN King 9.1.417 schneiden automatische Telegram-Rückfallantworten Texte
+nicht mehr bei 4.096 Zeichen ab. Längere Antworten werden in
+aufeinanderfolgenden Nachrichten vollständig zugestellt; dabei bleiben jedes
+Zeichen und jedes Unicode-Surrogatpaar erhalten. Im Ausgangsprotokoll stehen
+sämtliche zurückgegebenen Nachrichten-IDs zusammen mit dem vollständigen Text.
+Schlägt ein Teil fehl, endet die Zustellung an dieser Stelle, statt die Antwort
+fälschlich als vollständig zu melden.
+
 Zuverlässiger King-Start
 -----------------------
 Bei einer ausdrücklich als wiederholbar gekennzeichneten Serverüberlastung

package/README.md

@@ -82,6 +82,14 @@ Bereinigung und Mikrokompaktierung verwenden dafür dieselbe semantische Grenze.
 Erst nach der nachweislichen Auswertung darf ein Ergebnis archiviert oder
 gekürzt werden.
 
+Ab BLUN King 9.1.417 schneiden automatische Telegram-Rückfallantworten Texte
+nicht mehr bei 4.096 Zeichen ab. Längere Antworten werden in
+aufeinanderfolgenden Nachrichten vollständig zugestellt; dabei bleiben jedes
+Zeichen und jedes Unicode-Surrogatpaar erhalten. Im Ausgangsprotokoll stehen
+sämtliche zurückgegebenen Nachrichten-IDs zusammen mit dem vollständigen Text.
+Schlägt ein Teil fehl, endet die Zustellung an dieser Stelle, statt die Antwort
+fälschlich als vollständig zu melden.
+
 `Strg+C` und `Esc` brechen einen aktiven Zug zuverlässig ab, ohne den bereits
 geschriebenen Entwurf zu löschen. Das gilt auch bei Autovervollständigung,
 Geistervorschlägen, Bash-Eingabe und einer noch offenen Mehrzeileneingabe.

package/bin/telegram-text-chunk-policy.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const TELEGRAM_TEXT_LIMIT = 4096;
+
+function preferredCut(text, start, hardEnd) {
+  const minimum = start + Math.floor((hardEnd - start) / 2);
+  const boundaries = [
+    ['\n\n', 2],
+    ['\n', 1],
+    [' ', 1],
+  ];
+  for (const [boundary, width] of boundaries) {
+    const index = text.lastIndexOf(boundary, hardEnd - 1);
+    if (index >= minimum) return index + width;
+  }
+  return hardEnd;
+}
+
+function preserveSurrogatePair(text, start, end) {
+  if (end <= start || end >= text.length) return end;
+  const before = text.charCodeAt(end - 1);
+  const after = text.charCodeAt(end);
+  const splitsPair = before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
+  return splitsPair && end - 1 > start ? end - 1 : end;
+}
+
+function splitTelegramText(value, limit = TELEGRAM_TEXT_LIMIT) {
+  const text = typeof value === 'string' ? value : String(value ?? '');
+  if (text.length === 0) return [];
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new TypeError('Telegram text chunk limit must be a positive safe integer');
+  }
+
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const hardEnd = Math.min(text.length, start + limit);
+    let end = hardEnd < text.length ? preferredCut(text, start, hardEnd) : hardEnd;
+    end = preserveSurrogatePair(text, start, end);
+    if (end <= start) end = hardEnd;
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+
+async function sendTelegramTextChunks(value, sendChunk, limit = TELEGRAM_TEXT_LIMIT) {
+  if (typeof sendChunk !== 'function') {
+    throw new TypeError('Telegram chunk sender must be a function');
+  }
+  const chunks = splitTelegramText(value, limit);
+  const results = [];
+  for (let index = 0; index < chunks.length; index += 1) {
+    results.push(await sendChunk(chunks[index], index, chunks.length));
+  }
+  return { chunks, results };
+}
+
+module.exports = {
+  TELEGRAM_TEXT_LIMIT,
+  sendTelegramTextChunks,
+  splitTelegramText,
+};

package/blun.mjs

@@ -514830,6 +514830,7 @@ var createMediaAutoRetrievalController, parseAcceptedMediaJob, validateCompleted
 ({ createMediaAutoRetrievalController, parseAcceptedMediaJob } = createRequire(import.meta.url)("./bin/media-auto-retrieval-policy.cjs"));
 ({ validateCompletedMedia } = createRequire(import.meta.url)("./bin/media-result-policy.cjs"));
 var { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = createRequire(import.meta.url)("./bin/telegram-private-conversation-policy.cjs");
+var { sendTelegramTextChunks } = createRequire(import.meta.url)("./bin/telegram-text-chunk-policy.cjs");
 const TELEGRAM_TEXT_LIMIT = 4096;
 const TELEGRAM_ATTACHMENT_LIMIT = 50 * 1024 * 1024;
 function mediaTelegramTarget(filePath) {
@@ -514970,25 +514971,29 @@ async function sendReplyFallback(chatId, text, contextOnly = false) {
 	}
 	const token = botToken();
 	if (token === void 0) return false;
-	const body = privateSafeText.length > TELEGRAM_TEXT_LIMIT ? `${privateSafeText.slice(0, TELEGRAM_TEXT_LIMIT - 1)}…` : privateSafeText;
+	const messageIds = [];
 	try {
-		const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				chat_id: chatId,
-				text: body
-			})
-		})).json();
-		if (payload.ok !== true) return false;
+		await sendTelegramTextChunks(privateSafeText, async (body) => {
+			const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					chat_id: chatId,
+					text: body
+				})
+			})).json();
+			if (payload.ok !== true) throw new Error("Telegram fallback chunk delivery failed");
+			if (payload.result?.message_id !== void 0) messageIds.push(payload.result.message_id);
+			return payload;
+		}, TELEGRAM_TEXT_LIMIT);
 		try {
 			appendFileSync(outboxPath(), `${JSON.stringify({
 				ts: (/* @__PURE__ */ new Date()).toISOString(),
 				direction: "out",
 				kind: "reply-fallback",
 				chat_id: String(chatId),
-				message_ids: payload.result?.message_id !== void 0 ? [payload.result.message_id] : [],
-				text: body
+				message_ids: messageIds,
+				text: privateSafeText
 			})}\n`);
 		} catch {}
 		return true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.416",
+  "version": "9.1.417",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {

package/telegram-plugin/bin/telegram-text-chunk-policy.cjs

@@ -0,0 +1,63 @@
+'use strict';
+
+const TELEGRAM_TEXT_LIMIT = 4096;
+
+function preferredCut(text, start, hardEnd) {
+  const minimum = start + Math.floor((hardEnd - start) / 2);
+  const boundaries = [
+    ['\n\n', 2],
+    ['\n', 1],
+    [' ', 1],
+  ];
+  for (const [boundary, width] of boundaries) {
+    const index = text.lastIndexOf(boundary, hardEnd - 1);
+    if (index >= minimum) return index + width;
+  }
+  return hardEnd;
+}
+
+function preserveSurrogatePair(text, start, end) {
+  if (end <= start || end >= text.length) return end;
+  const before = text.charCodeAt(end - 1);
+  const after = text.charCodeAt(end);
+  const splitsPair = before >= 0xD800 && before <= 0xDBFF && after >= 0xDC00 && after <= 0xDFFF;
+  return splitsPair && end - 1 > start ? end - 1 : end;
+}
+
+function splitTelegramText(value, limit = TELEGRAM_TEXT_LIMIT) {
+  const text = typeof value === 'string' ? value : String(value ?? '');
+  if (text.length === 0) return [];
+  if (!Number.isSafeInteger(limit) || limit <= 0) {
+    throw new TypeError('Telegram text chunk limit must be a positive safe integer');
+  }
+
+  const chunks = [];
+  let start = 0;
+  while (start < text.length) {
+    const hardEnd = Math.min(text.length, start + limit);
+    let end = hardEnd < text.length ? preferredCut(text, start, hardEnd) : hardEnd;
+    end = preserveSurrogatePair(text, start, end);
+    if (end <= start) end = hardEnd;
+    chunks.push(text.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
+
+async function sendTelegramTextChunks(value, sendChunk, limit = TELEGRAM_TEXT_LIMIT) {
+  if (typeof sendChunk !== 'function') {
+    throw new TypeError('Telegram chunk sender must be a function');
+  }
+  const chunks = splitTelegramText(value, limit);
+  const results = [];
+  for (let index = 0; index < chunks.length; index += 1) {
+    results.push(await sendChunk(chunks[index], index, chunks.length));
+  }
+  return { chunks, results };
+}
+
+module.exports = {
+  TELEGRAM_TEXT_LIMIT,
+  sendTelegramTextChunks,
+  splitTelegramText,
+};

package/telegram-plugin/dist/bridge.mjs

@@ -10,10 +10,12 @@ import remoteStatusPolicy from "../../bin/telegram-remote-status-policy.cjs";
 import consoleStatusPolicy from "../../bin/telegram-console-status-policy.cjs";
 import telegramApprovalRelay from "../../bin/telegram-approval-relay.cjs";
 import privateConversationPolicy from "../bin/telegram-private-conversation-policy.cjs";
+import telegramTextChunkPolicy from "../bin/telegram-text-chunk-policy.cjs";
 const { buildTelegramRemoteStatus, resolveTelegramQueueSnapshot, resolveTelegramRemoteVersion } = remoteStatusPolicy;
 const { parseTelegramConsoleStatus } = consoleStatusPolicy;
 const { buildTelegramApprovalCard, isAuthorizedTelegramApprovalCallback, listPendingTelegramApprovals, markTelegramApprovalSent, parseTelegramApprovalCallback, resolveTelegramApprovalTarget, wasTelegramApprovalSent, writeTelegramApprovalResponse } = telegramApprovalRelay;
 const { findDuplicateReplyWithoutNewInbound, isPrivateInternalStatusReply, sanitizePrivateConversationReply } = privateConversationPolicy;
+const { sendTelegramTextChunks } = telegramTextChunkPolicy;
 //#region ../../node_modules/pathe/dist/shared/pathe.M-eThtNZ.mjs
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
@@ -4223,25 +4225,29 @@ async function sendReplyFallback(chatId, rawText) {
 		return true;
 	}
 	const text = scrubSecrets(privateSafeText);
-	const body = text.length > TELEGRAM_TEXT_LIMIT ? `${text.slice(0, TELEGRAM_TEXT_LIMIT - 1)}…` : text;
+	const messageIds = [];
 	try {
-		const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
-			method: "POST",
-			headers: { "Content-Type": "application/json" },
-			body: JSON.stringify({
-				chat_id: chatId,
-				text: body
-			})
-		})).json();
-		if (payload.ok !== true) return false;
+		await sendTelegramTextChunks(text, async (body) => {
+			const payload = await (await fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					chat_id: chatId,
+					text: body
+				})
+			})).json();
+			if (payload.ok !== true) throw new Error("Telegram fallback chunk delivery failed");
+			if (payload.result?.message_id !== void 0) messageIds.push(payload.result.message_id);
+			return payload;
+		}, TELEGRAM_TEXT_LIMIT);
 		try {
 			appendFileSync(outboxLog(), `${JSON.stringify({
 				ts: (/* @__PURE__ */ new Date()).toISOString(),
 				direction: "out",
 				kind: "reply-fallback",
 				chat_id: String(chatId),
-				message_ids: payload.result?.message_id !== void 0 ? [payload.result.message_id] : [],
-				text: body
+				message_ids: messageIds,
+				text
 			})}\n`);
 		} catch {}
 		return true;