telecodex 0.1.3 → 0.1.4

package/dist/telegram/formatted.js

@@ -0,0 +1,183 @@
+import { FormattedString } from "@grammyjs/parse-mode";
+import { retryTelegramCall } from "./delivery.js";
+import { TELEGRAM_SAFE_TEXT_LIMIT } from "./splitMessage.js";
+export function textField(label, value) {
+    return {
+        label,
+        value,
+        style: "plain",
+    };
+}
+export function codeField(label, value) {
+    return {
+        label,
+        value,
+        style: "code",
+    };
+}
+export function renderReplyDocument(document) {
+    const lines = [formatTitle(document.title)];
+    if (document.fields?.length) {
+        lines.push(...document.fields.map(formatField));
+    }
+    for (const section of document.sections ?? []) {
+        appendBlankLine(lines);
+        if (section.title) {
+            lines.push(formatTitle(section.title));
+        }
+        if (section.fields?.length) {
+            lines.push(...section.fields.map(formatField));
+        }
+        if (section.lines?.length) {
+            lines.push(...section.lines);
+        }
+    }
+    if (document.footer != null) {
+        appendBlankLine(lines);
+        lines.push(...normalizeLines(document.footer));
+    }
+    return joinLines(trimBlankLines(lines));
+}
+export async function replyDocument(ctx, document) {
+    await replyFormatted(ctx, renderReplyDocument(document));
+}
+export async function sendReplyDocument(bot, target, document, logger) {
+    await sendFormatted(bot, target, renderReplyDocument(document), logger);
+}
+export async function replyNotice(ctx, content) {
+    await replyFormatted(ctx, renderNotice(content));
+}
+export async function sendReplyNotice(bot, target, content, logger) {
+    await sendFormatted(bot, target, renderNotice(content), logger);
+}
+export async function replyError(ctx, message, detail) {
+    await replyNotice(ctx, detail == null ? message : [message, ...normalizeLines(detail)]);
+}
+export async function sendReplyError(bot, target, message, detail, logger) {
+    await sendReplyNotice(bot, target, detail == null ? message : [message, ...normalizeLines(detail)], logger);
+}
+export async function replyUsage(ctx, usage) {
+    await replyNotice(ctx, Array.isArray(usage) ? ["Usage:", ...usage] : `Usage: ${usage}`);
+}
+export async function sendReplyUsage(bot, target, usage, logger) {
+    await sendReplyNotice(bot, target, Array.isArray(usage) ? ["Usage:", ...usage] : `Usage: ${usage}`, logger);
+}
+export async function replyFormatted(ctx, message) {
+    const target = targetFromContext(ctx);
+    if (target && typeof ctx.api?.sendMessage === "function") {
+        await sendFormattedViaApi(ctx.api, ctx.api, target, message);
+        return;
+    }
+    await ctx.reply(message.text, {
+        ...toMessageOptions(message),
+    });
+}
+export async function sendFormatted(bot, target, message, logger) {
+    await sendFormattedViaApi(bot.api, bot.api, target, message, logger);
+}
+function renderNotice(content) {
+    return joinLines(trimBlankLines(normalizeLines(content)));
+}
+function toMessageOptions(message) {
+    return {
+        ...(message.entities && message.entities.length > 0 ? { entities: message.entities } : {}),
+        link_preview_options: { is_disabled: true },
+    };
+}
+async function sendFormattedViaApi(api, cooldownKey, target, message, logger) {
+    for (const chunk of splitTextWithEntities(message)) {
+        await retryTelegramCall(cooldownKey, () => api.sendMessage(target.chatId, chunk.text, {
+            ...(target.messageThreadId == null ? {} : { message_thread_id: target.messageThreadId }),
+            ...toMessageOptions(chunk),
+        }), logger, "telegram send rate limited", {
+            chatId: target.chatId,
+            messageThreadId: target.messageThreadId,
+        });
+    }
+}
+function splitTextWithEntities(message, limit = TELEGRAM_SAFE_TEXT_LIMIT) {
+    if (message.text.length <= limit) {
+        return [message];
+    }
+    const chunks = [];
+    let start = 0;
+    while (start < message.text.length) {
+        const remaining = message.text.length - start;
+        const end = remaining <= limit
+            ? message.text.length
+            : start + chooseSplitPoint(message.text.slice(start, start + limit), limit);
+        chunks.push(sliceTextWithEntities(message, start, Math.max(start + 1, end)));
+        start = Math.max(start + 1, end);
+    }
+    return chunks;
+}
+function sliceTextWithEntities(message, start, end) {
+    const text = message.text.slice(start, end);
+    const entities = message.entities?.flatMap((entity) => {
+        const overlapStart = Math.max(entity.offset, start);
+        const overlapEnd = Math.min(entity.offset + entity.length, end);
+        if (overlapStart >= overlapEnd)
+            return [];
+        return [
+            {
+                ...entity,
+                offset: overlapStart - start,
+                length: overlapEnd - overlapStart,
+            },
+        ];
+    });
+    return entities && entities.length > 0
+        ? { text, entities }
+        : { text };
+}
+function chooseSplitPoint(text, limit) {
+    if (text.length <= limit)
+        return text.length;
+    const slice = text.slice(0, limit);
+    const splitAt = Math.max(slice.lastIndexOf("\n\n"), slice.lastIndexOf("\n"), slice.lastIndexOf(" "));
+    return splitAt > limit * 0.55 ? splitAt : limit;
+}
+function targetFromContext(ctx) {
+    const chatId = ctx.chat?.id;
+    if (chatId == null)
+        return null;
+    return {
+        chatId,
+        messageThreadId: ctx.message?.message_thread_id ?? ctx.callbackQuery?.message?.message_thread_id ?? null,
+    };
+}
+function formatTitle(value) {
+    return FormattedString.bold(value);
+}
+function formatField(field) {
+    const value = formatValue(field.value);
+    if (field.style === "code") {
+        return FormattedString.join([`${field.label}: `, FormattedString.code(value)]);
+    }
+    return `${field.label}: ${value}`;
+}
+function joinLines(lines) {
+    return FormattedString.join(lines, "\n");
+}
+function appendBlankLine(lines) {
+    if (lines.length === 0 || lines.at(-1) === "")
+        return;
+    lines.push("");
+}
+function trimBlankLines(lines) {
+    let start = 0;
+    let end = lines.length;
+    while (lines[start] === "")
+        start += 1;
+    while (lines[end - 1] === "")
+        end -= 1;
+    return lines.slice(start, end);
+}
+function normalizeLines(lines) {
+    return Array.isArray(lines) ? lines : [lines];
+}
+function formatValue(value) {
+    if (value == null)
+        return "none";
+    return String(value);
+}

package/dist/telegram/messageBuffer.js

@@ -98,6 +98,16 @@ export class MessageBuffer {
         this.states.delete(from);
         this.states.set(to, state);
     }
+    dispose() {
+        for (const state of this.states.values()) {
+            if (state.timer) {
+                clearTimeout(state.timer);
+                state.timer = null;
+            }
+            this.stopActivityPulse(state);
+        }
+        this.states.clear();
+    }
     async complete(key, finalMarkdown) {
         const state = this.states.get(key);
         if (!state)

package/dist/telegram/splitMessage.js

@@ -1,4 +1,4 @@
-const TELEGRAM_SAFE_TEXT_LIMIT = 3900;
+export const TELEGRAM_SAFE_TEXT_LIMIT = 3900;
 export function splitTelegramText(text, limit = TELEGRAM_SAFE_TEXT_LIMIT) {
     if (text.length <= limit)
         return [text];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "telecodex",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Telegram bridge for local Codex.",
   "license": "MIT",
   "type": "module",
@@ -49,13 +49,15 @@
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
+    "@grammyjs/parse-mode": "^2.3.0",
     "@grammyjs/runner": "^2.0.3",
     "@napi-rs/keyring": "^1.2.0",
     "@openai/codex-sdk": "^0.120.0",
     "clipboardy": "^4.0.0",
-    "grammy": "^1.36.3",
+    "grammy": "^1.42.0",
     "markdown-it": "^14.1.0",
-    "pino": "^10.3.1"
+    "pino": "^10.3.1",
+    "write-file-atomic": "^7.0.1"
   },
   "devDependencies": {
     "@types/markdown-it": "^14.1.2",