opencode-telegram-mirror 0.3.0

package/src/database.ts

@@ -0,0 +1,120 @@
+/**
+ * Simple state persistence for Telegram bot
+ */
+
+import { Database } from "bun:sqlite"
+import type { LogFn } from "./log"
+
+const DB_PATH = process.env.TELEGRAM_DB_PATH || "/tmp/telegram-opencode.db"
+
+let db: Database | null = null
+
+export function getDb(log: LogFn): Database {
+  if (!db) {
+    log("debug", "Opening SQLite database", { path: DB_PATH })
+    db = new Database(DB_PATH, { create: true })
+
+    db.run(
+      "CREATE TABLE IF NOT EXISTS state (" +
+        "key TEXT PRIMARY KEY, " +
+        "value TEXT NOT NULL)"
+    )
+
+    log("info", "SQLite database initialized", { path: DB_PATH })
+  }
+  return db
+}
+
+/**
+ * Get the stored session ID
+ */
+export function getSessionId(log: LogFn): string | null {
+  const database = getDb(log)
+  type Row = { value: string }
+  const row = database
+    .query<Row, [string]>("SELECT value FROM state WHERE key = ?")
+    .get("session_id")
+  return row?.value ?? null
+}
+
+/**
+ * Store the session ID
+ */
+export function setSessionId(sessionId: string, log: LogFn): void {
+  const database = getDb(log)
+  database.run(
+    "INSERT OR REPLACE INTO state (key, value) VALUES (?, ?)",
+    ["session_id", sessionId]
+  )
+  log("info", "Stored session ID", { sessionId })
+}
+
+/**
+ * Get the last processed Telegram update_id
+ */
+export function getLastUpdateId(log: LogFn): number {
+  const database = getDb(log)
+  type Row = { value: string }
+  const row = database
+    .query<Row, [string]>("SELECT value FROM state WHERE key = ?")
+    .get("last_update_id")
+  return row ? Number.parseInt(row.value, 10) : 0
+}
+
+/**
+ * Store the last processed Telegram update_id
+ */
+export function setLastUpdateId(updateId: number, log: LogFn): void {
+  const database = getDb(log)
+  database.run(
+    "INSERT OR REPLACE INTO state (key, value) VALUES (?, ?)",
+    ["last_update_id", String(updateId)]
+  )
+}
+
+/**
+ * Get the stored control message ID
+ */
+export function getControlMessageId(log: LogFn): number | null {
+  const database = getDb(log)
+  type Row = { value: string }
+  const row = database
+    .query<Row, [string]>("SELECT value FROM state WHERE key = ?")
+    .get("control_message_id")
+  return row ? Number.parseInt(row.value, 10) : null
+}
+
+/**
+ * Store the control message ID
+ */
+export function setControlMessageId(messageId: number, log: LogFn): void {
+  const database = getDb(log)
+  database.run(
+    "INSERT OR REPLACE INTO state (key, value) VALUES (?, ?)",
+    ["control_message_id", String(messageId)]
+  )
+}
+
+/**
+ * Get the stored session variant
+ */
+export function getSessionVariant(log: LogFn): string | null {
+  const database = getDb(log)
+  type Row = { value: string }
+  const row = database
+    .query<Row, [string]>("SELECT value FROM state WHERE key = ?")
+    .get("session_variant")
+  return row?.value ?? null
+}
+
+/**
+ * Store the session variant
+ */
+export function setSessionVariant(variant: string, log: LogFn): void {
+  const database = getDb(log)
+  database.run(
+    "INSERT OR REPLACE INTO state (key, value) VALUES (?, ?)",
+    ["session_variant", variant]
+  )
+  log("info", "Stored session variant", { variant })
+}

package/src/diff-service.ts

@@ -0,0 +1,176 @@
+/**
+ * Diff service for uploading diffs to the diff viewer
+ */
+
+import { Result, TaggedError } from "better-result"
+import type { LogFn } from "./log"
+
+// Configure via environment variable - optional, if not set diff uploads are disabled
+const DIFF_VIEWER_URL = process.env.DIFF_VIEWER_URL || null
+
+export interface DiffFile {
+  path: string
+  oldContent: string
+  newContent: string
+  additions: number
+  deletions: number
+}
+
+export interface DiffUploadResult {
+  id: string
+  url: string
+  viewerUrl: string // URL for the mini-app viewer
+}
+
+export class DiffUploadError extends TaggedError("DiffUploadError")<{
+  message: string
+  cause: unknown
+}>() {
+  constructor(args: { cause: unknown }) {
+    const causeMessage = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Diff upload failed: ${causeMessage}` })
+  }
+}
+
+export type DiffUploadResultValue = DiffUploadResult
+export type DiffUploadResultError = DiffUploadError
+export type DiffUploadResultReturn = Result<DiffUploadResultValue | null, DiffUploadResultError>
+
+/**
+ * Count additions and deletions between two strings
+ */
+function countChanges(oldContent: string, newContent: string): { additions: number; deletions: number } {
+  const oldLines = oldContent.split("\n")
+  const newLines = newContent.split("\n")
+  
+  // Simple line-based diff counting
+  const oldSet = new Set(oldLines)
+  const newSet = new Set(newLines)
+  
+  let additions = 0
+  let deletions = 0
+  
+  for (const line of newLines) {
+    if (!oldSet.has(line)) additions++
+  }
+  
+  for (const line of oldLines) {
+    if (!newSet.has(line)) deletions++
+  }
+  
+  return { additions, deletions }
+}
+
+/**
+ * Upload a diff to the diff viewer service
+ */
+export async function uploadDiff(
+  files: DiffFile[],
+  options?: { title?: string; log?: LogFn }
+): Promise<DiffUploadResultReturn> {
+  const log = options?.log ?? (() => {})
+
+  // If DIFF_VIEWER_URL is not configured, skip diff upload
+  if (!DIFF_VIEWER_URL) {
+    log("debug", "Diff upload skipped - DIFF_VIEWER_URL not configured")
+    return Result.ok(null)
+  }
+
+  const uploadResult = await Result.tryPromise({
+    try: async () => {
+      log("debug", "Uploading diff", { fileCount: files.length, url: DIFF_VIEWER_URL })
+
+      const response = await fetch(`${DIFF_VIEWER_URL}/api/diff`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          title: options?.title,
+          files,
+        }),
+      })
+
+      if (!response.ok) {
+        throw new Error(`Diff upload failed: ${response.status}`)
+      }
+
+      const data = (await response.json()) as { id: string; url: string }
+
+      log("info", "Diff uploaded", { id: data.id, url: data.url })
+
+      return {
+        id: data.id,
+        url: data.url,
+        viewerUrl: `${DIFF_VIEWER_URL}/diff/${data.id}`,
+      }
+    },
+    catch: (error) => new DiffUploadError({ cause: error }),
+  })
+
+  if (uploadResult.status === "error") {
+    log("error", "Error uploading diff", { error: uploadResult.error.message })
+  }
+
+  return uploadResult
+}
+
+/**
+ * Create a diff file from edit tool input
+ */
+export function createDiffFromEdit(input: {
+  filePath: string
+  oldString: string
+  newString: string
+}): DiffFile {
+  const { additions, deletions } = countChanges(input.oldString, input.newString)
+  
+  return {
+    path: input.filePath,
+    oldContent: input.oldString,
+    newContent: input.newString,
+    additions,
+    deletions,
+  }
+}
+
+/**
+ * Generate inline diff preview (truncated for Telegram message)
+ */
+export function generateInlineDiffPreview(
+  oldContent: string,
+  newContent: string,
+  maxLines = 10
+): string {
+  const oldLines = oldContent.split("\n")
+  const newLines = newContent.split("\n")
+  
+  const diffLines: string[] = []
+  let lineCount = 0
+  
+  // Find removed lines
+  for (const line of oldLines) {
+    if (!newLines.includes(line) && line.trim()) {
+      diffLines.push(`-${line}`)
+      lineCount++
+      if (lineCount >= maxLines) break
+    }
+  }
+  
+  // Find added lines  
+  if (lineCount < maxLines) {
+    for (const line of newLines) {
+      if (!oldLines.includes(line) && line.trim()) {
+        diffLines.push(`+${line}`)
+        lineCount++
+        if (lineCount >= maxLines) break
+      }
+    }
+  }
+  
+  if (diffLines.length === 0) {
+    return ""
+  }
+  
+  return `\`\`\`diff\n${diffLines.join("\n")}\n\`\`\``
+}
+
+export { DIFF_VIEWER_URL }

package/src/log.ts

@@ -0,0 +1,23 @@
+/**
+ * Stdout logging for the Telegram plugin
+ */
+
+export type LogFn = (
+  level: "debug" | "info" | "warn" | "error",
+  message: string,
+  extra?: Record<string, unknown>
+) => void
+
+export function createLogger(): LogFn {
+  return (level, message, extra) => {
+    const timestamp = new Date().toISOString()
+    const extraStr = extra ? ` ${JSON.stringify(extra)}` : ""
+    const line = `${timestamp} [${level}] ${message}${extraStr}`
+
+    if (level === "error" || level === "warn") {
+      console.error(line)
+    } else {
+      console.log(line)
+    }
+  }
+}