@adriangalilea/utils 0.6.0 → 0.7.0

package/README.md

@@ -262,6 +262,7 @@ pnpm add @adriangalilea/utils gramio @gramio/storage @gramio/session
 |---|---|
 | `@adriangalilea/utils/bot/kit` | `gracefulStart(bot)` — SIGINT/SIGTERM → `bot.stop()` → exit; force-kills if shutdown hangs.<br>`adminContext({ adminId? })` — reads `TELEGRAM_ADMIN_ID` from `kev` (with optional hardcoded fallback), decorates `ctx.adminId` + `ctx.isAdmin`. |
 | `@adriangalilea/utils/bot/access-control` | Personal-bot ACL — gates non-admin/non-default users; admin gets DM with `[✅ Aprobar][❌ Denegar]` on first attempt; `/access` opens a persistent menu (revoke / reapprove / list pending). Backed by `@gramio/session` per-user + a small index. |
+| `@adriangalilea/utils/bot/coalesce` | Joins client-split inbound messages back into one. When a user pastes >4096 chars, Telegram clients fragment it into separate `message` updates with no marker. Middleware detects the burst and emits one combined event. |
 | `@adriangalilea/utils/bot/llm-stream` | `ctx.startStream()` for LLM token streams. Debounced `editMessageText`, splits at 4000 chars on paragraph/line/word boundary, parses Markdown locally so malformed mid-stream markup degrades to plain text instead of failing. |
 
 Standard wiring:

package/dist/bot/coalesce.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Coalesce client-split inbound messages.
+ *
+ * Telegram clients (Desktop / iOS / web) split a single message > 4096
+ * chars into multiple `sendMessage` calls before they ever reach the
+ * server. The bot receives them as **separate** `message` updates with
+ * no marker linking them. This middleware joins them back into one
+ * event so your handlers see the full text.
+ *
+ *     user pastes 8000 chars → client splits in 2 → bot gets 2 updates
+ *                                                            │
+ *                                                            ▼
+ *                                                 coalesce middleware
+ *                                                            │
+ *                                                     hold + join
+ *                                                            │
+ *                                                            ▼
+ *                                              handler sees ONE event
+ *                                              with full ctx.text
+ *
+ * ## Detection rule (strict)
+ *
+ * We coalesce only when ALL hold. Otherwise fragments pass through
+ * as separate events — false negatives are preferred over silently
+ * merging unrelated messages.
+ *
+ *   1. Same chat.
+ *   2. Same user (override with `acrossUsers: true`).
+ *   3. Leading fragment length ≥ `minLeadingLength` (a current
+ *      guess — see the type definition for the default and the
+ *      reasoning). Short messages never start a real client split.
+ *   4. Each subsequent fragment within `windowMs` of the previous.
+ *
+ * ## Known caveats
+ *
+ *   - `ctx.entities` is cleared on coalesced messages — per-fragment
+ *     entity offsets would point at the wrong characters once joined.
+ *     Plain-text consumers don't care; formatted-input consumers
+ *     should disable this plugin.
+ *   - In-memory buffer; doesn't survive bot restart mid-burst.
+ *
+ * Peer deps: `gramio`.
+ *
+ * @example
+ * import { Bot } from 'gramio'
+ * import { coalesceLongMessages } from '@adriangalilea/utils/bot/coalesce'
+ *
+ * const bot = new Bot(process.env.BOT_TOKEN!)
+ *   .extend(coalesceLongMessages())     // ← before .on / .command handlers
+ *   .on('message', (ctx) => {
+ *     // ctx.text is the full pasted text even if Telegram split it
+ *     return ctx.send(`got ${ctx.text?.length} chars`)
+ *   })
+ *
+ * @example  Power-user escape hatch
+ *
+ * import { isCoalescent } from '@adriangalilea/utils/bot/coalesce'
+ *
+ * if (isCoalescent(prev, curr)) {
+ *   // do your own thing
+ * }
+ */
+import { Plugin } from 'gramio';
+export type CoalesceCriteria = {
+    /**
+     * Minimum length of the leading fragment to consider a possible
+     * client split. Below this → never coalesce, zero latency. Once
+     * the buffer is open, follow-up fragments of any size join.
+     */
+    minLeadingLength?: number;
+    /**
+     * Max ms between consecutive fragments to consider them part of
+     * one client-split burst.
+     */
+    windowMs?: number;
+    /**
+     * If true, fragments from different users (same chat) can coalesce.
+     * Useful for "user forwarded a multi-author conversation as one
+     * logical block."
+     */
+    acrossUsers?: boolean;
+};
+export type CoalesceLongMessagesOptions = CoalesceCriteria & {
+    /**
+     * Log each fragment + buffer transition to stderr for debugging.
+     * Off by default.
+     */
+    log?: boolean;
+};
+/**
+ * Pure check: are these two fragments part of the same client-split
+ * burst? Use this if you want to make your own decision instead of
+ * letting the middleware do it.
+ *
+ * The two fragments are passed as plain objects so this function is
+ * decoupled from gramio's context type. Adapt your context as needed.
+ */
+export type CoalesceFragment = {
+    text: string;
+    chatId: number;
+    userId: number;
+    /** Timestamp in **milliseconds** (use `Date.now()` or `msg.date * 1000`). */
+    dateMs: number;
+};
+export declare const isCoalescent: (prev: CoalesceFragment, curr: CoalesceFragment, opts?: CoalesceCriteria) => boolean;
+export declare const coalesceLongMessages: (opts?: CoalesceLongMessagesOptions) => Plugin<{}, import("gramio").DeriveDefinitions, {}>;
+//# sourceMappingURL=coalesce.d.ts.map

package/dist/bot/coalesce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.d.ts","sourceRoot":"","sources":["../../src/bot/coalesce.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AACH,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAW/B,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;OAIG;IACH,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,2BAA2B,GAAG,gBAAgB,GAAG;IAC3D;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAA;CACd,CAAA;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,6EAA6E;IAC7E,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,eAAO,MAAM,YAAY,GACvB,MAAM,gBAAgB,EACtB,MAAM,gBAAgB,EACtB,OAAM,gBAAqB,KAC1B,OAUF,CAAA;AAWD,eAAO,MAAM,oBAAoB,GAAI,OAAM,2BAAgC,uDA8E1E,CAAA"}

package/dist/bot/coalesce.js

@@ -0,0 +1,155 @@
+/**
+ * Coalesce client-split inbound messages.
+ *
+ * Telegram clients (Desktop / iOS / web) split a single message > 4096
+ * chars into multiple `sendMessage` calls before they ever reach the
+ * server. The bot receives them as **separate** `message` updates with
+ * no marker linking them. This middleware joins them back into one
+ * event so your handlers see the full text.
+ *
+ *     user pastes 8000 chars → client splits in 2 → bot gets 2 updates
+ *                                                            │
+ *                                                            ▼
+ *                                                 coalesce middleware
+ *                                                            │
+ *                                                     hold + join
+ *                                                            │
+ *                                                            ▼
+ *                                              handler sees ONE event
+ *                                              with full ctx.text
+ *
+ * ## Detection rule (strict)
+ *
+ * We coalesce only when ALL hold. Otherwise fragments pass through
+ * as separate events — false negatives are preferred over silently
+ * merging unrelated messages.
+ *
+ *   1. Same chat.
+ *   2. Same user (override with `acrossUsers: true`).
+ *   3. Leading fragment length ≥ `minLeadingLength` (a current
+ *      guess — see the type definition for the default and the
+ *      reasoning). Short messages never start a real client split.
+ *   4. Each subsequent fragment within `windowMs` of the previous.
+ *
+ * ## Known caveats
+ *
+ *   - `ctx.entities` is cleared on coalesced messages — per-fragment
+ *     entity offsets would point at the wrong characters once joined.
+ *     Plain-text consumers don't care; formatted-input consumers
+ *     should disable this plugin.
+ *   - In-memory buffer; doesn't survive bot restart mid-burst.
+ *
+ * Peer deps: `gramio`.
+ *
+ * @example
+ * import { Bot } from 'gramio'
+ * import { coalesceLongMessages } from '@adriangalilea/utils/bot/coalesce'
+ *
+ * const bot = new Bot(process.env.BOT_TOKEN!)
+ *   .extend(coalesceLongMessages())     // ← before .on / .command handlers
+ *   .on('message', (ctx) => {
+ *     // ctx.text is the full pasted text even if Telegram split it
+ *     return ctx.send(`got ${ctx.text?.length} chars`)
+ *   })
+ *
+ * @example  Power-user escape hatch
+ *
+ * import { isCoalescent } from '@adriangalilea/utils/bot/coalesce'
+ *
+ * if (isCoalescent(prev, curr)) {
+ *   // do your own thing
+ * }
+ */
+import { Plugin } from 'gramio';
+// Current guess. Real Telegram clients split at natural boundaries
+// (newline / paragraph / sentence) before the 4096 cap, but we don't
+// yet have a solid dataset of where they actually land. Adjust as
+// real-world data comes in. Single source of truth — both
+// `isCoalescent` and the middleware read from here.
+const DEFAULT_MIN_LEADING_LENGTH = 3750;
+const DEFAULT_WINDOW_MS = 500;
+const DEFAULT_ACROSS_USERS = false;
+export const isCoalescent = (prev, curr, opts = {}) => {
+    const minLeadingLength = opts.minLeadingLength ?? DEFAULT_MIN_LEADING_LENGTH;
+    const windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+    const acrossUsers = opts.acrossUsers ?? DEFAULT_ACROSS_USERS;
+    if (prev.chatId !== curr.chatId)
+        return false;
+    if (!acrossUsers && prev.userId !== curr.userId)
+        return false;
+    if (prev.text.length < minLeadingLength)
+        return false;
+    if (curr.dateMs - prev.dateMs > windowMs)
+        return false;
+    return true;
+};
+export const coalesceLongMessages = (opts = {}) => {
+    const minLeadingLength = opts.minLeadingLength ?? DEFAULT_MIN_LEADING_LENGTH;
+    const windowMs = opts.windowMs ?? DEFAULT_WINDOW_MS;
+    const acrossUsers = opts.acrossUsers ?? DEFAULT_ACROSS_USERS;
+    const log = opts.log ?? false;
+    const dbg = (msg) => {
+        if (log)
+            console.error(`[coalesce] ${msg}`);
+    };
+    // Keyed per `<chatId>:<userId>` (or `<chatId>` when acrossUsers).
+    // Buffer lives only as long as fragments are still arriving — gets
+    // deleted on flush.
+    const buffers = new Map();
+    const keyFor = (chatId, userId) => acrossUsers ? `${chatId}` : `${chatId}:${userId}`;
+    return new Plugin('@adriangalilea/utils/bot/coalesce').use(async (ctx, next) => {
+        if (!ctx.is('message') || ctx.text === undefined)
+            return next();
+        const key = keyFor(ctx.chat.id, ctx.from.id);
+        const existing = buffers.get(key);
+        if (existing) {
+            // Continuation fragment — fold into the held buffer and reset
+            // the timer. No length check on continuations: once a buffer
+            // is open, anything within the window joins (the tail of a
+            // split is typically short). We don't call next(); this update
+            // is swallowed. The first fragment held by `existing.flush`
+            // will eventually fire next() with the combined text.
+            dbg(`join key=${key} len=${ctx.text.length} buffered=${existing.text.length}→${existing.text.length + ctx.text.length}`);
+            clearTimeout(existing.timer);
+            existing.text += ctx.text;
+            existing.timer = setTimeout(existing.flush, windowMs);
+            return;
+        }
+        if (ctx.text.length < minLeadingLength) {
+            // Short message → can never be the leading fragment of a real
+            // client split. Zero-latency passthrough.
+            dbg(`passthrough key=${key} len=${ctx.text.length} (<${minLeadingLength})`);
+            return next();
+        }
+        // Suspicious leading fragment: hold + start the wait window.
+        // Returns a Promise that only resolves after the buffer flushes
+        // (next() of THIS ctx is called with the combined text). This
+        // keeps gramio's middleware chain awaiting until we're done.
+        dbg(`open key=${key} len=${ctx.text.length} (≥${minLeadingLength}, wait ${windowMs}ms)`);
+        return new Promise((resolve, reject) => {
+            const buffered = {
+                text: ctx.text,
+                timer: setTimeout(() => buffered.flush(), windowMs),
+                flush: () => {
+                    // Detach from the map FIRST so any fragment arriving mid-flush
+                    // starts a fresh buffer instead of re-entering this one.
+                    dbg(`flush key=${key} total=${buffered.text.length}`);
+                    buffers.delete(key);
+                    // gramio's MessageContext exposes `text` as an accessor
+                    // with both `get` and `set` — assignment is the supported
+                    // way to override. We don't touch `entities`: fragment-1
+                    // entities reference fragment-1 text only, but plain-text
+                    // consumers (the sensible use of this plugin) ignore them.
+                    // Formatted-input consumers should disable the plugin.
+                    ctx.text = buffered.text;
+                    // Hand off to the rest of the chain. Resolve outer Promise
+                    // once the chain (and any downstream awaits) settles, so
+                    // gramio considers this middleware fully done.
+                    Promise.resolve(next()).then(() => resolve(), reject);
+                },
+            };
+            buffers.set(key, buffered);
+        });
+    });
+};
+//# sourceMappingURL=coalesce.js.map

package/dist/bot/coalesce.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"coalesce.js","sourceRoot":"","sources":["../../src/bot/coalesce.ts"],"names":[],"mappings":"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"}

package/dist/bot/index.d.ts

@@ -13,5 +13,6 @@
  */
 export * from './kit.js';
 export * from './access-control.js';
+export * from './coalesce.js';
 export * from './llm-stream.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/bot/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,UAAU,CAAA;AACxB,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,UAAU,CAAA;AACxB,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA"}

package/dist/bot/index.js

@@ -13,5 +13,6 @@
  */
 export * from './kit.js';
 export * from './access-control.js';
+export * from './coalesce.js';
 export * from './llm-stream.js';
 //# sourceMappingURL=index.js.map

package/dist/bot/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,UAAU,CAAA;AACxB,cAAc,qBAAqB,CAAA;AACnC,cAAc,iBAAiB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/bot/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,cAAc,UAAU,CAAA;AACxB,cAAc,qBAAqB,CAAA;AACnC,cAAc,eAAe,CAAA;AAC7B,cAAc,iBAAiB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adriangalilea/utils",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "TypeScript utilities - logger, currency, formatter, GramIO bot plugins, and more",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -36,6 +36,10 @@
       "types": "./dist/bot/access-control.d.ts",
       "default": "./dist/bot/access-control.js"
     },
+    "./bot/coalesce": {
+      "types": "./dist/bot/coalesce.d.ts",
+      "default": "./dist/bot/coalesce.js"
+    },
     "./bot/kit": {
       "types": "./dist/bot/kit.d.ts",
       "default": "./dist/bot/kit.js"