@tormentalabs/opencode-telegram-plugin 0.2.0

package/src/state/mapping.ts

@@ -0,0 +1,112 @@
+import { writeFileSync, readFileSync, existsSync, mkdirSync, renameSync, unlinkSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { randomBytes } from "node:crypto";
+
+export interface ChatMapping {
+  chatId: number;
+  lastSessionId: string | null;
+  username: string | null;
+  firstSeen: number;
+  lastActive: number;
+}
+
+const mappings = new Map<number, ChatMapping>();
+let filePath: string | null = null;
+
+export function initMapping(dataDir: string): void {
+  mkdirSync(dataDir, { recursive: true });
+  filePath = join(dataDir, "chat-mappings.json");
+
+  if (!existsSync(filePath)) return;
+
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return;
+
+    for (const item of parsed) {
+      if (item != null && typeof item === "object" && typeof (item as Record<string, unknown>).chatId === "number") {
+        const m = item as Record<string, unknown>;
+        const chatId = m.chatId as number;
+        mappings.set(chatId, {
+          chatId,
+          lastSessionId: typeof m.lastSessionId === "string" ? m.lastSessionId : null,
+          username: typeof m.username === "string" ? m.username : null,
+          firstSeen: typeof m.firstSeen === "number" ? m.firstSeen : Date.now(),
+          lastActive: typeof m.lastActive === "number" ? m.lastActive : Date.now(),
+        });
+      }
+    }
+  } catch {
+    // Corrupt or unreadable file — start fresh
+  }
+}
+
+export function getMapping(chatId: number): ChatMapping | null {
+  return mappings.get(chatId) ?? null;
+}
+
+export function setMapping(chatId: number, data: Partial<ChatMapping>): void {
+  const now = Date.now();
+  const existing = mappings.get(chatId);
+
+  if (existing) {
+    mappings.set(chatId, {
+      ...existing,
+      ...data,
+      chatId,
+      lastActive: now,
+    });
+  } else {
+    mappings.set(chatId, {
+      lastSessionId: null,
+      username: null,
+      firstSeen: now,
+      ...data,
+      chatId,
+      lastActive: now,
+    });
+  }
+
+  scheduleSave();
+}
+
+export function getAllMappings(): ChatMapping[] {
+  return Array.from(mappings.values());
+}
+
+function saveMappingsSync(): void {
+  if (!filePath) return;
+
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+
+  const json = JSON.stringify(Array.from(mappings.values()), null, 2);
+  const tmpPath = filePath + "." + randomBytes(4).toString("hex") + ".tmp";
+  try {
+    writeFileSync(tmpPath, json, "utf-8");
+    renameSync(tmpPath, filePath);
+  } catch (err) {
+    // Clean up temp file on failure
+    try { if (existsSync(tmpPath)) unlinkSync(tmpPath); } catch { /* ignore */ }
+    throw err;
+  }
+}
+
+let saveTimer: ReturnType<typeof setTimeout> | null = null;
+
+function scheduleSave(): void {
+  if (saveTimer !== null) return;
+  saveTimer = setTimeout(() => {
+    saveTimer = null;
+    try {
+      saveMappingsSync();
+    } catch {
+      // Non-fatal — data will be retried on next write
+    }
+  }, 500);
+}
+
+export function saveMappings(): void {
+  scheduleSave();
+}

package/src/state/mode.ts

@@ -0,0 +1,40 @@
+import { getChatState } from "./store.js";
+
+export type SessionMode = "attached" | "independent" | "detached";
+
+export function getActiveSessionId(chatId: number): string | null {
+  const state = getChatState(chatId);
+  switch (state.mode) {
+    case "attached":
+      return state.attachedSessionId;
+    case "independent":
+      return state.independentSessionId;
+    case "detached":
+      return null;
+  }
+}
+
+export function attachSession(chatId: number, sessionId: string): void {
+  const state = getChatState(chatId);
+  state.mode = "attached";
+  state.attachedSessionId = sessionId;
+  state.independentSessionId = null;
+}
+
+export function detachSession(chatId: number): void {
+  const state = getChatState(chatId);
+  state.mode = "detached";
+  state.attachedSessionId = null;
+  state.independentSessionId = null;
+}
+
+export function startIndependentSession(chatId: number, sessionId: string): void {
+  const state = getChatState(chatId);
+  state.mode = "independent";
+  state.independentSessionId = sessionId;
+  state.attachedSessionId = null;
+}
+
+export function getMode(chatId: number): SessionMode {
+  return getChatState(chatId).mode;
+}

package/src/state/store.ts

@@ -0,0 +1,167 @@
+export type StreamState = "IDLE" | "PENDING_SEND" | "SENT" | "EDITING" | "FINAL";
+
+export interface StreamTracker {
+  state: StreamState;
+  messageId: number | null;
+  lastSentText: string;
+  sessionId: string | null;
+  messageIdOC: string | null;
+  chunks: number[];
+  streamGeneration: number;
+}
+
+export interface PendingPermission {
+  permissionId: string;
+  sessionId: string;
+  tool: string;
+  description: string;
+  telegramMessageId: number | null;
+  timestamp: number;
+}
+
+export interface SelectedModel {
+  providerID: string;
+  modelID: string;
+  displayName: string;
+}
+
+export type EffortLevel = "low" | "medium" | "high";
+
+export interface ChatState {
+  chatId: number;
+  mode: "attached" | "independent" | "detached";
+  attachedSessionId: string | null;
+  independentSessionId: string | null;
+  selectedModel: SelectedModel | null;
+  effort: EffortLevel;
+  stream: StreamTracker;
+  pendingPermissions: Map<string, PendingPermission>;
+  typingStop: (() => void) | null;
+}
+
+export interface CallbackEntry {
+  action: string;
+  data: Record<string, string>;
+  expiresAt: number;
+}
+
+const DEFAULT_CALLBACK_TTL_MS = 600_000; // 10 minutes
+const CALLBACK_KEY_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+const CALLBACK_KEY_LENGTH = 6;
+
+const chatStates = new Map<number, ChatState>();
+const callbackRegistry = new Map<string, CallbackEntry>();
+
+function makeDefaultStream(): StreamTracker {
+  return {
+    state: "IDLE",
+    messageId: null,
+    lastSentText: "",
+    sessionId: null,
+    messageIdOC: null,
+    chunks: [],
+    streamGeneration: 0,
+  };
+}
+
+function makeDefaultChatState(chatId: number): ChatState {
+  return {
+    chatId,
+    mode: "detached",
+    attachedSessionId: null,
+    independentSessionId: null,
+    selectedModel: null,
+    effort: "high",
+    stream: makeDefaultStream(),
+    pendingPermissions: new Map(),
+    typingStop: null,
+  };
+}
+
+export function getChatState(chatId: number): ChatState {
+  let state = chatStates.get(chatId);
+  if (!state) {
+    state = makeDefaultChatState(chatId);
+    chatStates.set(chatId, state);
+  }
+  return state;
+}
+
+export function deleteChatState(chatId: number): void {
+  chatStates.delete(chatId);
+}
+
+export function getAllChatIds(): number[] {
+  return Array.from(chatStates.keys());
+}
+
+export function resetStream(chatId: number): void {
+  const state = getChatState(chatId);
+  const nextGen = state.stream.streamGeneration + 1;
+  state.stream = makeDefaultStream();
+  state.stream.streamGeneration = nextGen;
+}
+
+export function cleanupChatStream(chatId: number): void {
+  const state = getChatState(chatId);
+  state.typingStop?.();
+  state.typingStop = null;
+  resetStream(chatId);
+}
+
+function generateKey(): string {
+  let key = "";
+  for (let i = 0; i < CALLBACK_KEY_LENGTH; i++) {
+    key += CALLBACK_KEY_CHARS[Math.floor(Math.random() * CALLBACK_KEY_CHARS.length)];
+  }
+  return key;
+}
+
+export function registerCallback(
+  action: string,
+  data: Record<string, string>,
+  ttlMs: number = DEFAULT_CALLBACK_TTL_MS,
+): string {
+  let key: string;
+  do {
+    key = generateKey();
+  } while (callbackRegistry.has(key));
+
+  callbackRegistry.set(key, {
+    action,
+    data,
+    expiresAt: Date.now() + ttlMs,
+  });
+
+  return key;
+}
+
+export function resolveCallback(key: string): CallbackEntry | null {
+  const entry = callbackRegistry.get(key);
+  if (!entry) return null;
+
+  callbackRegistry.delete(key);
+
+  if (Date.now() > entry.expiresAt) return null;
+
+  return entry;
+}
+
+export function cleanExpiredCallbacks(): void {
+  const now = Date.now();
+  for (const [key, entry] of callbackRegistry) {
+    if (now > entry.expiresAt) {
+      callbackRegistry.delete(key);
+    }
+  }
+
+  // Also sweep expired pending permissions across all chats.
+  // Permissions share the same TTL as callbacks (10 minutes).
+  for (const state of chatStates.values()) {
+    for (const [permId, perm] of state.pendingPermissions) {
+      if (now - perm.timestamp > DEFAULT_CALLBACK_TTL_MS) {
+        state.pendingPermissions.delete(permId);
+      }
+    }
+  }
+}

package/src/utils/chunk.ts

@@ -0,0 +1,186 @@
+const MAX_LENGTH = 4096;
+
+/** Tags whose open/close state is tracked across chunk boundaries. */
+const TRACKED_TAGS = new Set([
+  "b",
+  "i",
+  "u",
+  "s",
+  "code",
+  "pre",
+  "blockquote",
+  "a",
+]);
+
+interface OpenTag {
+  name: string;
+  /** Attribute string, e.g. `href="https://example.com"` */
+  attrs: string;
+}
+
+function openTagStr(tag: OpenTag): string {
+  return tag.attrs ? `<${tag.name} ${tag.attrs}>` : `<${tag.name}>`;
+}
+
+function stackCloseStr(stack: readonly OpenTag[]): string {
+  return [...stack]
+    .reverse()
+    .map((t) => `</${t.name}>`)
+    .join("");
+}
+
+function stackOpenStr(stack: readonly OpenTag[]): string {
+  return stack.map(openTagStr).join("");
+}
+
+/**
+ * Split an HTML string into chunks of at most `maxLength` characters.
+ *
+ * When a chunk boundary falls inside open HTML tags, the chunk is closed
+ * with the appropriate closing tags and the next chunk is reopened with the
+ * matching opening tags, preserving attributes (e.g. href on <a>).
+ *
+ * Split preference order: newline → space → forced.
+ */
+export function chunkMessage(
+  html: string,
+  maxLength: number = MAX_LENGTH,
+): string[] {
+  const chunks: string[] = [];
+  const stack: OpenTag[] = [];
+  let current = "";
+
+  /** Close open tags, push chunk, reopen tags for next chunk. */
+  function flush(): void {
+    const close = stackCloseStr(stack);
+    const chunk = current + close;
+    if (chunk.trim().length > 0) {
+      chunks.push(chunk);
+    }
+    current = stackOpenStr(stack);
+  }
+
+  /**
+   * Returns true if adding `addition` to current, with `futureStack` as the
+   * resulting open-tag state, would still fit within maxLength.
+   */
+  function fitsInCurrent(addition: string, futureStack: OpenTag[]): boolean {
+    const close = stackCloseStr(futureStack);
+    return current.length + addition.length + close.length <= maxLength;
+  }
+
+  // Tokenise: either an HTML tag (<tag ...> or </tag>) or a run of text.
+  const TOKEN_RE = /<\/?[a-zA-Z][^>]*>|[^<]+/g;
+  const tokens = html.match(TOKEN_RE) ?? [];
+
+  for (const token of tokens) {
+    // ── Text token ──────────────────────────────────────────────────────────
+    if (!token.startsWith("<")) {
+      let remaining = token;
+
+      while (remaining.length > 0) {
+        const close = stackCloseStr(stack);
+        const available = maxLength - current.length - close.length;
+
+        if (remaining.length <= available) {
+          current += remaining;
+          break;
+        }
+
+        if (available <= 0) {
+          flush();
+          // Safety: if the tag prefix alone fills maxLength, bail out.
+          const newAvail =
+            maxLength - current.length - stackCloseStr(stack).length;
+          if (newAvail <= 0) break;
+          continue;
+        }
+
+        // Find the best split point within the available window.
+        const sub = remaining.slice(0, available);
+        let splitAt = available;
+
+        const nl = sub.lastIndexOf("\n");
+        if (nl > 0) {
+          splitAt = nl + 1; // include the newline in this chunk
+        } else {
+          const sp = sub.lastIndexOf(" ");
+          if (sp > 0) {
+            splitAt = sp + 1; // include the space in this chunk
+          }
+          // else: forced split at `available`
+        }
+
+        current += remaining.slice(0, splitAt);
+        remaining = remaining.slice(splitAt);
+        flush();
+      }
+      continue;
+    }
+
+    // ── HTML tag token ───────────────────────────────────────────────────────
+    const isClose = token.startsWith("</");
+    const nameMatch = token.match(/<\/?(\w+)/);
+    if (!nameMatch) continue;
+
+    const name = nameMatch[1].toLowerCase();
+    const tracked = TRACKED_TAGS.has(name);
+
+    if (isClose) {
+      // Locate the last matching open tag in the stack.
+      let stackIdx = -1;
+      for (let j = stack.length - 1; j >= 0; j--) {
+        if (stack[j].name === name) {
+          stackIdx = j;
+          break;
+        }
+      }
+
+      // Compute what the stack will look like after closing this tag.
+      const futureStack: OpenTag[] =
+        tracked && stackIdx !== -1
+          ? [
+              ...stack.slice(0, stackIdx),
+              ...stack.slice(stackIdx + 1),
+            ]
+          : [...stack];
+
+      if (!fitsInCurrent(token, futureStack)) {
+        flush();
+      }
+
+      current += token;
+
+      if (tracked && stackIdx !== -1) {
+        stack.splice(stackIdx, 1);
+      }
+    } else {
+      // Opening tag — extract attribute string for tracked tags.
+      const attrsMatch = token.match(/^<\w+((?:\s+[^>]*)?)>/);
+      const attrs = attrsMatch ? attrsMatch[1].trim() : "";
+
+      const futureStack: OpenTag[] = tracked
+        ? [...stack, { name, attrs }]
+        : [...stack];
+
+      if (!fitsInCurrent(token, futureStack)) {
+        flush();
+      }
+
+      current += token;
+
+      if (tracked) {
+        stack.push({ name, attrs });
+      }
+    }
+  }
+
+  // Flush any remaining content.
+  const close = stackCloseStr(stack);
+  const final = current + close;
+  if (final.trim().length > 0) {
+    chunks.push(final);
+  }
+
+  return chunks.filter((c) => c.trim().length > 0);
+}

package/src/utils/format.ts

@@ -0,0 +1,120 @@
+/**
+ * Escape HTML special characters for Telegram HTML parse mode.
+ */
+export function escapeHtml(text: string): string {
+  return text
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
+/**
+ * Convert Markdown text to Telegram-safe HTML.
+ *
+ * Supported output tags: <b>, <i>, <u>, <s>, <code>, <pre>,
+ * <a href="...">, <blockquote>
+ *
+ * Strategy:
+ *  1. Extract fenced/inline code blocks into placeholders
+ *  2. Escape HTML entities in remaining text
+ *  3. Convert Markdown inline formatting
+ *  4. Convert headers
+ *  5. Collect adjacent blockquote lines
+ *  6. Restore code placeholders as <pre>/<code>
+ */
+export function markdownToTelegramHtml(md: string): string {
+  const codeBlocks: string[] = [];
+  const inlineCodes: string[] = [];
+
+  // Step 1a: Extract fenced code blocks (``` lang \n code \n ```)
+  let text = md.replace(
+    /```([^\n]*)\n([\s\S]*?)```/g,
+    (_match, _lang: string, code: string) => {
+      const idx = codeBlocks.length;
+      codeBlocks.push(code);
+      return `\x00CODEBLOCK_${idx}\x00`;
+    },
+  );
+
+  // Step 1b: Extract inline code (` code `)
+  text = text.replace(/`([^`]+)`/g, (_match, code: string) => {
+    const idx = inlineCodes.length;
+    inlineCodes.push(code);
+    return `\x00INLINE_${idx}\x00`;
+  });
+
+  // Step 2: Escape HTML entities in the remaining text
+  text = escapeHtml(text);
+
+  // Step 3: Convert Markdown inline formatting
+
+  // Bold: **text**
+  text = text.replace(/\*\*([\s\S]+?)\*\*/g, "<b>$1</b>");
+
+  // Italic: *text* (single asterisk, content must not contain * or newline)
+  text = text.replace(/\*([^*\n]+)\*/g, "<i>$1</i>");
+
+  // Strikethrough: ~~text~~
+  text = text.replace(/~~([\s\S]+?)~~/g, "<s>$1</s>");
+
+  // Links: [text](url)
+  text = text.replace(/\[([^\]]+)\]\(((?:[^()]*|\([^()]*\))*)\)/g, '<a href="$2">$1</a>');
+
+  // Step 4: Headers (# through ######) → <b>header text</b>
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, "<b>$1</b>");
+
+  // Step 5: Blockquotes
+  // After HTML escaping, ">" at the start of a line becomes "&gt;".
+  // Collect adjacent blockquote lines into a single <blockquote> element.
+  const lines = text.split("\n");
+  const result: string[] = [];
+  let i = 0;
+  while (i < lines.length) {
+    if (lines[i].startsWith("&gt; ") || lines[i] === "&gt;") {
+      const blockLines: string[] = [];
+      while (
+        i < lines.length &&
+        (lines[i].startsWith("&gt; ") || lines[i] === "&gt;")
+      ) {
+        blockLines.push(lines[i].replace(/^&gt;[ ]?/, ""));
+        i++;
+      }
+      result.push(`<blockquote>${blockLines.join("\n")}</blockquote>`);
+    } else {
+      result.push(lines[i]);
+      i++;
+    }
+  }
+  text = result.join("\n");
+
+  // Step 6: Restore code placeholders with properly escaped content
+
+  // Fenced code blocks → <pre>
+  text = text.replace(/\x00CODEBLOCK_(\d+)\x00/g, (_match, idx: string) => {
+    const raw = codeBlocks[parseInt(idx, 10)] ?? "";
+    // Trim trailing newline that the regex capture group includes
+    const normalized = raw.endsWith("\n") ? raw.slice(0, -1) : raw;
+    return `<pre>${escapeHtml(normalized)}</pre>`;
+  });
+
+  // Inline code → <code>
+  text = text.replace(/\x00INLINE_(\d+)\x00/g, (_match, idx: string) => {
+    const raw = inlineCodes[parseInt(idx, 10)] ?? "";
+    return `<code>${escapeHtml(raw)}</code>`;
+  });
+
+  return text;
+}
+
+/**
+ * Remove all HTML tags from a string and decode basic HTML entities.
+ */
+export function stripHtml(text: string): string {
+  return text
+    .replace(/<[^>]+>/g, "")
+    .replace(/&amp;/g, "&")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&quot;/g, '"');
+}