@lapage/codex-telegram-bridge 0.1.0 → 0.1.1

package/dist/text.js

@@ -8,45 +8,6 @@ export function normalizeTerminalOutput(data) {
 function visibleText(data) {
     return normalizeTerminalOutput(data);
 }
-export function cleanPaneSnapshot(data) {
-    const lines = paneLines(data);
-    return collapseRepeatedLines(lines).join('\n').trim();
-}
-export function latestCompletedCodexResponse(data) {
-    const lines = paneLines(data);
-    if (isCodexWorking(data)) {
-        return null;
-    }
-    return latestCodexResponse(data);
-}
-export function latestCodexResponse(data) {
-    const lines = paneLines(data);
-    const lastResponseBullet = findLastIndex(lines, (line) => {
-        const trimmed = visibleText(line).trimStart();
-        return trimmed.startsWith('• ') && !/^•\s*Working\s*\(/i.test(trimmed);
-    });
-    if (lastResponseBullet === -1) {
-        return null;
-    }
-    const promptStart = findLastIndex(lines.slice(0, lastResponseBullet), (line) => isUserPromptLine(visibleText(line).trim()));
-    const responseStart = promptStart === -1 ? lastResponseBullet : promptStart + 1;
-    const response = [];
-    for (const line of lines.slice(responseStart)) {
-        const trimmed = visibleText(line).trim();
-        if (response.length > 0 && isPromptOrStatusLine(trimmed)) {
-            break;
-        }
-        if (isIgnorableResponseLine(trimmed)) {
-            continue;
-        }
-        response.push(line);
-    }
-    const cleaned = collapseRepeatedLines(response).join('\n').trim();
-    return cleaned || null;
-}
-export function isCodexWorking(data) {
-    return paneLines(data).some((line) => /esc to interrupt|^\s*•\s*Working\s*\(/i.test(visibleText(line)));
-}
 export function chunkText(text, maxLength) {
     const chunks = [];
     let remaining = text;
@@ -70,11 +31,56 @@ export function formatTelegramMarkdown(text) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
+export function formatTelegramMarkdownChunks(text, maxLength) {
+    const lines = formatTelegramMarkdownLines(text);
+    const chunks = [];
+    let current = '';
+    for (const line of lines) {
+        const nextLine = current ? `\n\n${line}` : line;
+        if (current && current.length + nextLine.length > maxLength) {
+            chunks.push(current);
+            current = line;
+            continue;
+        }
+        current += nextLine;
+    }
+    if (current) {
+        chunks.push(current);
+    }
+    return chunks.flatMap((chunk) => chunk.length > maxLength ? hardSplitText(chunk, maxLength) : [chunk]);
+}
 export function formatTelegramMarkdownLines(text) {
-    return normalizeWrappedLines(text)
-        .split('\n')
-        .map(formatTelegramLine)
-        .filter((line) => line.trim().length > 0);
+    const lines = normalizeTerminalOutput(text).split('\n');
+    const formatted = [];
+    let codeFenceLanguage = '';
+    let codeFenceLines = [];
+    for (const line of lines) {
+        const trimmed = visibleText(line).trim();
+        const fenceMatch = trimmed.match(/^```([a-zA-Z0-9_-]*)\s*$/);
+        if (fenceMatch && codeFenceLines.length === 0 && codeFenceLanguage === '') {
+            codeFenceLanguage = fenceMatch[1] || 'text';
+            codeFenceLines = [];
+            continue;
+        }
+        if (trimmed === '```' && codeFenceLanguage) {
+            formatted.push(formatCodeBlock(codeFenceLines.join('\n'), codeFenceLanguage));
+            codeFenceLanguage = '';
+            codeFenceLines = [];
+            continue;
+        }
+        if (codeFenceLanguage) {
+            codeFenceLines.push(line);
+            continue;
+        }
+        const formattedLine = formatTelegramLine(line);
+        if (formattedLine.trim().length > 0) {
+            formatted.push(formattedLine);
+        }
+    }
+    if (codeFenceLanguage) {
+        formatted.push(formatCodeBlock(codeFenceLines.join('\n'), codeFenceLanguage));
+    }
+    return formatted;
 }
 export function plainTelegramText(text) {
     return plainTelegramLines(text)
@@ -82,57 +88,24 @@ export function plainTelegramText(text) {
         .replace(/\n{3,}/g, '\n\n')
         .trim();
 }
+export function safePlainTelegramText(text) {
+    return plainTelegramText(text)
+        .replace(/^```[a-zA-Z0-9_-]*\s*$/gm, '')
+        .replace(/\*\*([^*]+)\*\*/g, '$1')
+        .replace(/`([^`]+)`/g, '$1')
+        .replace(/^\s*-\s+/gm, '• ')
+        .replace(/^\s{2,}•\s+/gm, '  ◦ ')
+        .trim();
+}
+export function safePlainTelegramChunks(text, maxLength) {
+    return chunkText(safePlainTelegramText(text), maxLength);
+}
 export function plainTelegramLines(text) {
     return normalizeWrappedLines(text)
         .split('\n')
         .map((line) => line.trimEnd())
         .filter((line) => line.trim().length > 0);
 }
-function isDecorativeLine(line) {
-    const trimmed = visibleText(line).trim();
-    if (/^[╭╮╰╯│─┌┐└┘├┤┬┴┼╞╡═\s]+$/.test(trimmed)) {
-        return true;
-    }
-    if (/^Tip: /.test(trimmed)) {
-        return true;
-    }
-    if (/^model:\s+/.test(trimmed) || /^directory:\s+/.test(trimmed)) {
-        return true;
-    }
-    if (/^>_ OpenAI Codex/.test(trimmed)) {
-        return true;
-    }
-    return false;
-}
-function paneLines(data) {
-    return normalizeTerminalOutput(data)
-        .split('\n')
-        .map((line) => line.trimEnd())
-        .filter((line) => visibleText(line).trim().length > 0)
-        .filter((line) => !isDecorativeLine(line))
-        .filter((line) => !isIgnorablePaneLine(visibleText(line).trim()));
-}
-function isPromptOrStatusLine(trimmed) {
-    return isUserPromptLine(trimmed)
-        || /^agentic\s+/.test(trimmed)
-        || /^•\s*Working\s*\(/i.test(trimmed)
-        || /^─\s*Worked for\b/.test(trimmed);
-}
-function isUserPromptLine(trimmed) {
-    return trimmed.startsWith('› ');
-}
-function isIgnorablePaneLine(trimmed) {
-    return /^⚠ Model metadata for `agentic` not found/.test(trimmed)
-        || /^can degrade performance and cause issues\.$/.test(trimmed)
-        || /^fallback metadata;/.test(trimmed)
-        || /^issues\.$/.test(trimmed)
-        || /^─\s*Worked for\b/.test(trimmed)
-        || /^agentic\s+/.test(trimmed)
-        || /^› (Write tests for @filename|Summarize recent commits|Implement \{feature\}|Improve documentation in @filename)/.test(trimmed);
-}
-function isIgnorableResponseLine(trimmed) {
-    return isIgnorablePaneLine(trimmed) || /^⚠ /.test(trimmed);
-}
 function normalizeWrappedLines(text) {
     const lines = text.split('\n');
     const normalized = [];
@@ -176,27 +149,16 @@ function shouldJoinSoftWrap(previous, current) {
     return !/[.!?:;)]$/.test(trimmedPrevious) && /^[a-z0-9(/]/i.test(trimmedCurrent);
 }
 function formatTelegramLine(line) {
-    const style = lineStyle(line);
     const trimmed = visibleText(line).trim();
     if (!trimmed) {
         return '';
     }
-    if (style.hasBold && /(?:^•\s+)?Ran\b/.test(trimmed)) {
-        const command = trimmed.replace(/^•\s+Ran\s+/, '').replace(/^Ran\s+/, '');
-        return blockQuote(`🔧 *Ran* ${inlineCode(command)}`);
-    }
     if (trimmed.startsWith('• Ran ')) {
         return blockQuote(`🔧 *Ran* ${inlineCode(trimmed.slice('• Ran '.length))}`);
     }
-    if (style.hasBold && /background terminal/i.test(trimmed)) {
-        return blockQuote(`🔧 _${escapeMarkdownV2(trimmed.replace(/^•\s+/, ''))}_`);
-    }
     if (trimmed.startsWith('• Waited for background terminal')) {
         return blockQuote(`🔧 _${escapeMarkdownV2(trimmed.slice(2))}_`);
     }
-    if (style.hasDim && isThinkingLine(trimmed)) {
-        return blockQuote(`🧠 _${escapeMarkdownV2(trimmed.slice(2))}_`);
-    }
     if (trimmed.startsWith('↳ Interacted with background terminal')) {
         return blockQuote(`🔧 _${escapeMarkdownV2(trimmed)}_`);
     }
@@ -210,33 +172,70 @@ function formatTelegramLine(line) {
         return `• ${escapeMarkdownV2(trimmed.slice(2))}`;
     }
     if (trimmed.startsWith('- ')) {
-        return `  ◦ ${escapeMarkdownV2(trimmed.slice(2))}`;
+        return `• ${formatInlineMarkdown(trimmed.slice(2))}`;
     }
     if (/^\s{2,}\S/.test(visibleText(line))) {
         return `   ${escapeMarkdownV2(trimmed)}`;
     }
-    return escapeMarkdownV2(trimmed);
+    return formatInlineMarkdown(trimmed);
+}
+function hardSplitText(text, maxLength) {
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > maxLength) {
+        chunks.push(remaining.slice(0, maxLength));
+        remaining = remaining.slice(maxLength);
+    }
+    if (remaining) {
+        chunks.push(remaining);
+    }
+    return chunks;
 }
 function inlineCode(text) {
     return `\`${text.replace(/[`\\]/g, '\\$&')}\``;
 }
-function lineStyle(line) {
-    const sgrMatches = line.match(/\x1b\[[0-9;]*m/g) ?? [];
-    let hasDim = false;
-    let hasBold = false;
-    for (const match of sgrMatches) {
-        const codes = match.slice(2, -1).split(';').map((code) => Number(code || 0));
-        if (codes.includes(0)) {
-            continue;
+function formatCodeBlock(text, language) {
+    return `\`\`\`${escapeCodeFenceLanguage(language)}\n${escapePreText(text)}\n\`\`\``;
+}
+function escapeCodeFenceLanguage(language) {
+    return language.replace(/[^a-zA-Z0-9_-]/g, '') || 'text';
+}
+function escapePreText(text) {
+    return text.replace(/[`\\]/g, '\\$&');
+}
+function formatInlineMarkdown(text) {
+    const segments = splitInlineMarkdown(text);
+    return segments.map((segment) => {
+        if (segment.type === 'code') {
+            return inlineCode(segment.text);
+        }
+        if (segment.type === 'bold') {
+            return `*${escapeMarkdownV2(segment.text)}*`;
+        }
+        return escapeMarkdownV2(segment.text);
+    }).join('');
+}
+function splitInlineMarkdown(text) {
+    const segments = [];
+    const pattern = /`([^`]+)`|\*\*([^*]+)\*\*/g;
+    let index = 0;
+    let match;
+    while ((match = pattern.exec(text))) {
+        if (match.index > index) {
+            segments.push({ type: 'plain', text: text.slice(index, match.index) });
         }
-        if (codes.includes(1)) {
-            hasBold = true;
+        if (match[1] !== undefined) {
+            segments.push({ type: 'code', text: match[1] });
         }
-        if (codes.includes(2)) {
-            hasDim = true;
+        else if (match[2] !== undefined) {
+            segments.push({ type: 'bold', text: match[2] });
         }
+        index = pattern.lastIndex;
     }
-    return { hasDim, hasBold };
+    if (index < text.length) {
+        segments.push({ type: 'plain', text: text.slice(index) });
+    }
+    return segments;
 }
 function blockQuote(markdown) {
     return markdown
@@ -244,29 +243,6 @@ function blockQuote(markdown) {
         .map((line) => `> ${line}`)
         .join('\n');
 }
-function isThinkingLine(trimmed) {
-    return /^•\s+I(?:’|'|`)?m\s+(thinking|considering|checking|looking|trying|wondering|deciding|figuring|reasoning|planning)\b/i.test(trimmed)
-        || /^•\s+I\s+need\s+to\s+think\b/i.test(trimmed)
-        || /^•\s+I\s+need\s+to\s+(provide|answer|decide|figure|check|inspect|verify)\b/i.test(trimmed)
-        || /^•\s+Let\s+me\s+think\b/i.test(trimmed);
-}
-function findLastIndex(items, predicate) {
-    for (let index = items.length - 1; index >= 0; index -= 1) {
-        if (predicate(items[index])) {
-            return index;
-        }
-    }
-    return -1;
-}
-function collapseRepeatedLines(lines) {
-    const collapsed = [];
-    for (const line of lines) {
-        if (collapsed[collapsed.length - 1] !== line) {
-            collapsed.push(line);
-        }
-    }
-    return collapsed;
-}
 function escapeMarkdownV2(text) {
     return text.replace(/([_*.\[\]()~`>#+\-=|{}!\\])/g, '\\$1');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lapage/codex-telegram-bridge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Private Telegram bridge for controlling Codex CLI on a home PC or server without opening inbound ports.",
   "type": "module",
   "bin": {
@@ -24,7 +24,7 @@
     "codex-cli",
     "telegram",
     "telegram-bot",
-    "tmux",
+    "app-server",
     "remote-control",
     "agent"
   ],

package/dist/tmux.js

@@ -1,25 +0,0 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-export async function runTmux(args) {
-    const { stdout } = await execFileAsync('tmux', args, { env: process.env });
-    return stdout;
-}
-export async function tmuxSessionExists(session) {
-    try {
-        await runTmux(['has-session', '-t', session]);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function capturePane(session, rows) {
-    return runTmux(['capture-pane', '-p', '-t', session, '-S', `-${rows}`]);
-}
-export function shellCommand(parts) {
-    return parts.map(shellQuote).join(' ');
-}
-function shellQuote(value) {
-    return `'${value.replace(/'/g, `'\\''`)}'`;
-}