telecodex 0.1.0

package/dist/telegram/splitMessage.js

@@ -0,0 +1,141 @@
+const TELEGRAM_SAFE_TEXT_LIMIT = 3900;
+export function splitTelegramText(text, limit = TELEGRAM_SAFE_TEXT_LIMIT) {
+    if (text.length <= limit)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > limit) {
+        const slice = remaining.slice(0, limit);
+        const splitAt = Math.max(slice.lastIndexOf("\n\n"), slice.lastIndexOf("\n"), slice.lastIndexOf(" "));
+        const cut = splitAt > limit * 0.55 ? splitAt : limit;
+        chunks.push(remaining.slice(0, cut).trimEnd());
+        remaining = remaining.slice(cut).trimStart();
+    }
+    if (remaining)
+        chunks.push(remaining);
+    return chunks;
+}
+export function splitTelegramHtml(html, limit = TELEGRAM_SAFE_TEXT_LIMIT) {
+    if (html.length <= limit)
+        return [html];
+    const tokens = html.match(/<[^>]+>|[^<]+/g) ?? [];
+    const chunks = [];
+    const stack = [];
+    let body = "";
+    let chunkHasContent = false;
+    for (const token of tokens) {
+        if (token.startsWith("<")) {
+            const parsed = parseHtmlTag(token);
+            if (!parsed) {
+                appendTextToken(token);
+                continue;
+            }
+            if (parsed.kind === "close") {
+                const matchingIndex = findMatchingStackIndex(stack, parsed.name);
+                const nextStack = matchingIndex >= 0 ? stack.slice(0, matchingIndex) : stack;
+                if (!canFit(token.length, closingSuffixLength(nextStack), body.length, limit) && chunkHasContent) {
+                    pushChunk();
+                }
+                body += token;
+                if (matchingIndex >= 0) {
+                    stack.splice(matchingIndex, 1);
+                }
+                continue;
+            }
+            const nextStack = [...stack, parsed];
+            if (!canFit(token.length, closingSuffixLength(nextStack), body.length, limit) && chunkHasContent) {
+                pushChunk();
+            }
+            body += token;
+            stack.push(parsed);
+            continue;
+        }
+        appendTextToken(token);
+    }
+    if (chunkHasContent) {
+        chunks.push(body + closingSuffix(stack));
+    }
+    else if (!chunks.length && body) {
+        chunks.push(body);
+    }
+    return chunks.filter(Boolean);
+    function appendTextToken(token) {
+        let remaining = token;
+        while (remaining) {
+            const available = limit - body.length - closingSuffixLength(stack);
+            if (available <= 0 && chunkHasContent) {
+                pushChunk();
+                continue;
+            }
+            if (available <= 0) {
+                body += remaining;
+                chunkHasContent = true;
+                remaining = "";
+                continue;
+            }
+            if (remaining.length <= available) {
+                body += remaining;
+                chunkHasContent = true;
+                remaining = "";
+                continue;
+            }
+            const cut = chooseSplitPoint(remaining, available);
+            body += remaining.slice(0, cut);
+            chunkHasContent = true;
+            remaining = remaining.slice(cut);
+            pushChunk();
+        }
+    }
+    function pushChunk() {
+        if (!chunkHasContent)
+            return;
+        chunks.push(body + closingSuffix(stack));
+        body = openingPrefix(stack);
+        chunkHasContent = false;
+    }
+}
+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 parseHtmlTag(token) {
+    const closeMatch = token.match(/^<\/([a-z]+)>$/i);
+    if (closeMatch?.[1]) {
+        return {
+            kind: "close",
+            name: closeMatch[1].toLowerCase(),
+        };
+    }
+    const openMatch = token.match(/^<([a-z]+)(?:\s[^>]*)?>$/i);
+    if (!openMatch?.[1])
+        return null;
+    const name = openMatch[1].toLowerCase();
+    return {
+        kind: "open",
+        name,
+        open: token,
+        close: `</${name}>`,
+    };
+}
+function openingPrefix(stack) {
+    return stack.map((frame) => frame.open).join("");
+}
+function closingSuffix(stack) {
+    return [...stack].reverse().map((frame) => frame.close).join("");
+}
+function closingSuffixLength(stack) {
+    return stack.reduce((total, frame) => total + frame.close.length, 0);
+}
+function canFit(tokenLength, suffixLength, currentLength, limit) {
+    return currentLength + tokenLength + suffixLength <= limit;
+}
+function findMatchingStackIndex(stack, name) {
+    for (let index = stack.length - 1; index >= 0; index -= 1) {
+        if (stack[index]?.name === name)
+            return index;
+    }
+    return -1;
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "telecodex",
+  "version": "0.1.0",
+  "description": "Telegram bridge for local Codex.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "telecodex": "dist/cli.js"
+  },
+  "files": [
+    "dist/bot/**",
+    "dist/codex/**",
+    "dist/runtime/**",
+    "dist/store/**",
+    "dist/telegram/**",
+    "dist/config.js",
+    "dist/cli.js",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "codex",
+    "telegram",
+    "bot",
+    "cli",
+    "automation"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiangege/telecodex.git"
+  },
+  "homepage": "https://github.com/jiangege/telecodex#readme",
+  "bugs": {
+    "url": "https://github.com/jiangege/telecodex/issues"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "dev": "NODE_OPTIONS=--disable-warning=ExperimentalWarning tsx src/cli.ts",
+    "build": "tsc -p tsconfig.json",
+    "prepack": "npm run build",
+    "start": "node --disable-warning=ExperimentalWarning dist/cli.js",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "node --import tsx --test src/tests/**/*.test.ts"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.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",
+    "markdown-it": "^14.1.0",
+    "pino": "^10.3.1"
+  },
+  "devDependencies": {
+    "@types/markdown-it": "^14.1.2",
+    "@types/node": "^24.0.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.9.3"
+  }
+}