opencode-telegram-mirror 0.3.0

package/src/permission-handler.ts

@@ -0,0 +1,242 @@
+/**
+ * Permission handler for OpenCode permission.asked events
+ * Shows Telegram inline keyboard buttons for Accept/Accept Always/Deny
+ */
+
+import { TelegramClient, type CallbackQuery } from "./telegram"
+import type { LogFn } from "./log"
+
+// Permission request from OpenCode event
+export type PermissionRequest = {
+  id: string
+  sessionID: string
+  permission: string // e.g., "bash", "edit", "webfetch"
+  patterns: string[] // e.g., file paths or command patterns
+}
+
+type PendingPermissionContext = {
+  sessionId: string
+  requestId: string
+  chatId: number
+  threadId: number | null
+  permission: string
+  patterns: string[]
+  messageId: number
+  directory: string // Directory for looking up the correct OpenCode server
+}
+
+// Store pending permissions by a unique key (chatId:threadId)
+const pendingPermissions = new Map<string, PendingPermissionContext>()
+
+function getThreadKey(chatId: number, threadId: number | null): string {
+  return `${chatId}:${threadId ?? "main"}`
+}
+
+/**
+ * Show permission buttons in Telegram
+ */
+export async function showPermissionButtons({
+  telegram,
+  chatId,
+  threadId,
+  sessionId,
+  request,
+  directory,
+  log,
+}: {
+  telegram: TelegramClient
+  chatId: number
+  threadId: number | null
+  sessionId: string
+  request: PermissionRequest
+  directory: string
+  log: LogFn
+}): Promise<void> {
+  const threadKey = getThreadKey(chatId, threadId)
+
+  // Cancel any existing pending permission for this thread
+  const existing = pendingPermissions.get(threadKey)
+  if (existing) {
+    log("info", "Replacing existing pending permission", { threadKey })
+  }
+
+  const patternStr = request.patterns.length > 0 
+    ? request.patterns.join(", ") 
+    : ""
+
+  // Build message text
+  let messageText = "*Permission Required*\n\n"
+  messageText += `*Type:* \`${request.permission}\`\n`
+  if (patternStr) {
+    messageText += `*Pattern:* \`${patternStr}\``
+  }
+
+  // Build inline keyboard
+  const options = [
+    { label: "Accept", callbackData: `p:${threadKey}:once` },
+    { label: "Accept Always", callbackData: `p:${threadKey}:always` },
+    { label: "Deny", callbackData: `p:${threadKey}:reject` },
+  ]
+
+  const keyboard = TelegramClient.buildInlineKeyboard(options, { columns: 3 })
+
+  const messageResult = await telegram.sendMessage(messageText, { replyMarkup: keyboard })
+
+  if (messageResult.status === "error") {
+    log("error", "Failed to show permission buttons", {
+      threadKey,
+      error: messageResult.error.message,
+    })
+    return
+  }
+
+  if (messageResult.value) {
+    const context: PendingPermissionContext = {
+      sessionId,
+      requestId: request.id,
+      chatId,
+      threadId,
+      permission: request.permission,
+      patterns: request.patterns,
+      messageId: messageResult.value.message_id,
+      directory,
+    }
+    pendingPermissions.set(threadKey, context)
+
+    log("info", "Showed permission buttons", {
+      threadKey,
+      permission: request.permission,
+      patterns: request.patterns,
+    })
+  }
+
+}
+
+/**
+ * Handle callback query from permission button press
+ * Returns the reply data to send to OpenCode, including directory for server lookup
+ */
+export async function handlePermissionCallback({
+  telegram,
+  callback,
+  log,
+}: {
+  telegram: TelegramClient
+  callback: CallbackQuery
+  log: LogFn
+}): Promise<{ requestId: string; reply: "once" | "always" | "reject"; directory: string } | null> {
+  const data = callback.data
+  if (!data?.startsWith("p:")) {
+    return null
+  }
+
+  // Parse callback data: p:chatId:threadId:reply
+  const parts = data.split(":")
+  if (parts.length < 4) {
+    log("warn", "Invalid permission callback data", { data })
+    return null
+  }
+
+  const threadKey = `${parts[1]}:${parts[2]}`
+  const reply = parts[3] as "once" | "always" | "reject"
+
+  const context = pendingPermissions.get(threadKey)
+  if (!context) {
+    const answerResult = await telegram.answerCallbackQuery(callback.id, {
+      text: "This permission request has expired",
+      showAlert: true,
+    })
+    if (answerResult.status === "error") {
+      log("error", "Failed to answer permission callback", {
+        error: answerResult.error.message,
+      })
+    }
+    return null
+  }
+
+  // Acknowledge the button press
+  const ackResult = await telegram.answerCallbackQuery(callback.id)
+  if (ackResult.status === "error") {
+    log("error", "Failed to acknowledge permission callback", {
+      error: ackResult.error.message,
+    })
+  }
+
+  // Format result text
+  const resultText = (() => {
+    switch (reply) {
+      case "once":
+        return "Permission *accepted*"
+      case "always":
+        return "Permission *accepted* (auto-approve similar requests)"
+      case "reject":
+        return "Permission *rejected*"
+    }
+  })()
+
+  // Update the message to show the result and remove keyboard
+  const patternStr = context.patterns.length > 0 
+    ? context.patterns.join(", ") 
+    : ""
+
+  let updatedText = "*Permission Required*\n\n"
+  updatedText += `*Type:* \`${context.permission}\`\n`
+  if (patternStr) {
+    updatedText += `*Pattern:* \`${patternStr}\`\n\n`
+  } else {
+    updatedText += "\n"
+  }
+  updatedText += resultText
+
+  const editResult = await telegram.editMessage(context.messageId, updatedText)
+  if (editResult.status === "error") {
+    log("error", "Failed to update permission message", {
+      error: editResult.error.message,
+    })
+  }
+
+  pendingPermissions.delete(threadKey)
+
+  log("info", "Permission responded", {
+    threadKey,
+    requestId: context.requestId,
+    reply,
+    directory: context.directory,
+  })
+
+  return {
+    requestId: context.requestId,
+    reply,
+    directory: context.directory,
+  }
+}
+
+/**
+ * Auto-reject pending permission for a thread (e.g., when user sends a new message)
+ */
+export function cancelPendingPermission(
+  chatId: number,
+  threadId: number | null
+): { requestId: string; reply: "reject"; directory: string } | null {
+  const threadKey = getThreadKey(chatId, threadId)
+  const context = pendingPermissions.get(threadKey)
+
+  if (!context) {
+    return null
+  }
+
+  pendingPermissions.delete(threadKey)
+
+  return {
+    requestId: context.requestId,
+    reply: "reject",
+    directory: context.directory,
+  }
+}
+
+/**
+ * Check if there's a pending permission for a thread
+ */
+export function hasPendingPermission(chatId: number, threadId: number | null): boolean {
+  return pendingPermissions.has(getThreadKey(chatId, threadId))
+}

package/src/question-handler.ts

@@ -0,0 +1,391 @@
+/**
+ * Question handler for OpenCode question.asked events
+ * Shows Telegram inline keyboard buttons for questions and collects responses
+ */
+
+import { TelegramClient, type CallbackQuery } from "./telegram"
+import type { LogFn } from "./log"
+
+// Question input schema matching OpenCode's question tool
+export type QuestionInput = {
+  questions: Array<{
+    question: string
+    header: string // max 12 chars
+    options: Array<{
+      label: string
+      description: string
+    }>
+    multiple?: boolean
+  }>
+}
+
+// Question request from OpenCode event
+export type QuestionRequest = {
+  id: string
+  sessionID: string
+  questions: QuestionInput["questions"]
+}
+
+type PendingQuestionContext = {
+  sessionId: string
+  requestId: string
+  chatId: number
+  threadId: number | null
+  questions: QuestionInput["questions"]
+  answers: Record<number, string[]> // questionIndex -> selected labels
+  totalQuestions: number
+  answeredCount: number
+  messageIds: number[] // Track sent message IDs for cleanup
+  awaitingFreetext: number | null // questionIndex awaiting freetext input, or null
+  directory: string // Directory for looking up the correct OpenCode server
+}
+
+// Store pending questions by a unique key (chatId:threadId)
+const pendingQuestions = new Map<string, PendingQuestionContext>()
+
+function getThreadKey(chatId: number, threadId: number | null): string {
+  return `${chatId}:${threadId ?? "main"}`
+}
+
+/**
+ * Show question buttons in Telegram
+ */
+export async function showQuestionButtons({
+  telegram,
+  chatId,
+  threadId,
+  sessionId,
+  request,
+  directory,
+  log,
+}: {
+  telegram: TelegramClient
+  chatId: number
+  threadId: number | null
+  sessionId: string
+  request: QuestionRequest
+  directory: string
+  log: LogFn
+}): Promise<void> {
+  const threadKey = getThreadKey(chatId, threadId)
+
+  // Cancel any existing pending question for this thread
+  const existing = pendingQuestions.get(threadKey)
+  if (existing) {
+    log("info", "Cancelling existing pending question", { threadKey })
+  }
+
+  const context: PendingQuestionContext = {
+    sessionId,
+    requestId: request.id,
+    chatId,
+    threadId,
+    questions: request.questions,
+    answers: {},
+    totalQuestions: request.questions.length,
+    answeredCount: 0,
+    messageIds: [],
+    awaitingFreetext: null,
+    directory,
+  }
+
+  pendingQuestions.set(threadKey, context)
+
+  // Send one message per question with inline keyboard
+  for (let i = 0; i < request.questions.length; i++) {
+    const q = request.questions[i]
+    if (!q) continue
+
+    // Build inline keyboard - max 8 buttons per row, max 100 buttons total
+    const options = [
+      ...q.options.slice(0, 7).map((opt, optIdx) => ({
+        label: opt.label.slice(0, 64), // Telegram button text limit
+        callbackData: `q:${threadKey}:${i}:${optIdx}`,
+      })),
+      {
+        label: "Other",
+        callbackData: `q:${threadKey}:${i}:other`,
+      },
+    ]
+
+    const keyboard = TelegramClient.buildInlineKeyboard(options, { columns: 2 })
+
+  const messageResult = await telegram.sendMessage(
+    `*${q.header}*\n${q.question}`,
+    { replyMarkup: keyboard }
+  )
+
+  if (messageResult.status === "error") {
+    log("error", "Failed to send question message", {
+      threadKey,
+      error: messageResult.error.message,
+    })
+    continue
+  }
+
+  if (messageResult.value) {
+    context.messageIds.push(messageResult.value.message_id)
+  }
+
+  }
+
+  log("info", "Showed question buttons", {
+    threadKey,
+    questionCount: request.questions.length,
+  })
+}
+
+/**
+ * Handle callback query from question button press
+ * Returns the answer data if all questions are answered, null otherwise
+ * Returns { awaitingFreetext: true } if waiting for user to type custom answer
+ */
+export async function handleQuestionCallback({
+  telegram,
+  callback,
+  log,
+}: {
+  telegram: TelegramClient
+  callback: CallbackQuery
+  log: LogFn
+}): Promise<{ requestId: string; answers: string[][]; directory: string } | { awaitingFreetext: true } | null> {
+  const data = callback.data
+  if (!data?.startsWith("q:")) {
+    return null
+  }
+
+  // Parse callback data: q:chatId:threadId:questionIndex:optionIndex
+  const parts = data.split(":")
+  log("debug", "Parsing question callback", { parts, partsLength: parts.length })
+  
+  if (parts.length < 5) {
+    log("warn", "Invalid question callback data", { data })
+    return null
+  }
+
+  const threadKey = `${parts[1]}:${parts[2]}`
+  const questionIndex = Number.parseInt(parts[3] ?? "0", 10)
+  const optionValue = parts[4] ?? "0"
+
+  log("debug", "Looking up pending question", { 
+    threadKey, 
+    questionIndex, 
+    optionValue,
+    pendingKeys: Array.from(pendingQuestions.keys())
+  })
+
+  const context = pendingQuestions.get(threadKey)
+  if (!context) {
+    log("warn", "No pending question for threadKey", { threadKey })
+    const answerResult = await telegram.answerCallbackQuery(callback.id, {
+      text: "This question has expired",
+      showAlert: true,
+    })
+    if (answerResult.status === "error") {
+      log("error", "Failed to answer expired question", {
+        error: answerResult.error.message,
+      })
+    }
+    return null
+  }
+
+  const question = context.questions[questionIndex]
+  if (!question) {
+    log("error", "Question index not found", { questionIndex, threadKey })
+    const answerResult = await telegram.answerCallbackQuery(callback.id)
+    if (answerResult.status === "error") {
+      log("error", "Failed to answer invalid question", {
+        error: answerResult.error.message,
+      })
+    }
+    return null
+  }
+
+  // Acknowledge the button press
+  const ackResult = await telegram.answerCallbackQuery(callback.id)
+  if (ackResult.status === "error") {
+    log("error", "Failed to acknowledge question", {
+      error: ackResult.error.message,
+    })
+  }
+
+  // Handle "Other" - wait for freetext input
+  if (optionValue === "other") {
+    context.awaitingFreetext = questionIndex
+    
+    // Update the message to prompt for freetext input
+    const messageId = context.messageIds[questionIndex]
+    if (messageId) {
+      const editResult = await telegram.editMessage(
+        messageId,
+        `*${question.header}*\n${question.question}\n\n_Please type your answer:_`
+      )
+      if (editResult.status === "error") {
+        log("error", "Failed to prompt freetext answer", {
+          error: editResult.error.message,
+        })
+      }
+    }
+    
+    log("info", "Awaiting freetext input for question", { threadKey, questionIndex })
+    return { awaitingFreetext: true }
+  }
+
+  // Record the selected option answer
+  const optIdx = Number.parseInt(optionValue, 10)
+  const selectedLabel = question.options[optIdx]?.label ?? `Option ${optIdx + 1}`
+  context.answers[questionIndex] = [selectedLabel]
+  context.answeredCount++
+
+  // Update the message to show the selection and remove keyboard
+  const messageId = context.messageIds[questionIndex]
+  if (messageId) {
+    const answeredText = context.answers[questionIndex]?.join(", ") ?? ""
+    const editResult = await telegram.editMessage(
+      messageId,
+      `*${question.header}*\n${question.question}\n\n_${answeredText}_`
+    )
+    if (editResult.status === "error") {
+      log("error", "Failed to update answered question", {
+        error: editResult.error.message,
+      })
+    }
+  }
+
+  // Check if all questions are answered
+  if (context.answeredCount >= context.totalQuestions) {
+    // Build answers array
+    const answers = context.questions.map((_, i) => context.answers[i] ?? [])
+
+    pendingQuestions.delete(threadKey)
+
+    log("info", "All questions answered", {
+      threadKey,
+      requestId: context.requestId,
+      directory: context.directory,
+    })
+
+    return {
+      requestId: context.requestId,
+      answers,
+      directory: context.directory,
+    }
+  }
+
+  return null
+}
+
+/**
+ * Check if there's a pending freetext question for a thread
+ */
+export function isAwaitingFreetext(chatId: number, threadId: number | null): boolean {
+  const threadKey = getThreadKey(chatId, threadId)
+  const context = pendingQuestions.get(threadKey)
+  return context?.awaitingFreetext !== null && context?.awaitingFreetext !== undefined
+}
+
+/**
+ * Handle freetext answer for "Other" option
+ * Returns the answer data if all questions are answered, null otherwise
+ */
+export async function handleFreetextAnswer({
+  telegram,
+  chatId,
+  threadId,
+  text,
+  log,
+}: {
+  telegram: TelegramClient
+  chatId: number
+  threadId: number | null
+  text: string
+  log: LogFn
+}): Promise<{ requestId: string; answers: string[][]; directory: string } | null> {
+  const threadKey = getThreadKey(chatId, threadId)
+  const context = pendingQuestions.get(threadKey)
+
+  if (!context || context.awaitingFreetext === null) {
+    return null
+  }
+
+  const questionIndex = context.awaitingFreetext
+  const question = context.questions[questionIndex]
+
+  // Record the freetext answer
+  context.answers[questionIndex] = [text]
+  context.answeredCount++
+  context.awaitingFreetext = null
+
+  // Update the message to show the answer
+  const messageId = context.messageIds[questionIndex]
+  if (messageId && question) {
+    const editResult = await telegram.editMessage(
+      messageId,
+      `*${question.header}*\n${question.question}\n\n_${text}_`
+    )
+    if (editResult.status === "error") {
+      log("error", "Failed to update freetext answer", {
+        error: editResult.error.message,
+      })
+    }
+  }
+
+  log("info", "Freetext answer recorded", { threadKey, questionIndex, text: text.slice(0, 50) })
+
+  // Check if all questions are answered
+  if (context.answeredCount >= context.totalQuestions) {
+    // Build answers array
+    const answers = context.questions.map((_, i) => context.answers[i] ?? [])
+
+    pendingQuestions.delete(threadKey)
+
+    log("info", "All questions answered (after freetext)", {
+      threadKey,
+      requestId: context.requestId,
+      directory: context.directory,
+    })
+
+    return {
+      requestId: context.requestId,
+      answers,
+      directory: context.directory,
+    }
+  }
+
+  return null
+}
+
+/**
+ * Cancel pending question for a thread (e.g., when user sends a new message that's not a freetext answer)
+ */
+export function cancelPendingQuestion(
+  chatId: number,
+  threadId: number | null
+): { requestId: string; answers: string[][]; directory: string } | null {
+  const threadKey = getThreadKey(chatId, threadId)
+  const context = pendingQuestions.get(threadKey)
+
+  if (!context) {
+    return null
+  }
+
+  // Build answers with cancellation markers for unanswered questions
+  const answers = context.questions.map((_, i) => {
+    return context.answers[i] ?? ["(cancelled - user sent new message)"]
+  })
+
+  pendingQuestions.delete(threadKey)
+
+  return {
+    requestId: context.requestId,
+    answers,
+    directory: context.directory,
+  }
+}
+
+/**
+ * Check if there's a pending question for a thread
+ */
+export function hasPendingQuestion(chatId: number, threadId: number | null): boolean {
+  return pendingQuestions.has(getThreadKey(chatId, threadId))
+}

package/src/system-message.ts

@@ -0,0 +1,73 @@
+/**
+ * System message generator for OpenCode sessions
+ * Creates the system prompt injected into sessions, including
+ * Telegram-specific formatting rules and diff commands
+ */
+
+export interface SystemMessageOptions {
+  sessionId: string
+  chatId: string
+  threadId?: number
+}
+
+/**
+ * Generate the system message to inject into OpenCode sessions
+ */
+export function getSystemMessage(options: SystemMessageOptions): string {
+  const { sessionId, chatId, threadId } = options
+
+  return `
+The user is reading your messages from inside Telegram, via a Telegram bot mirror.
+
+The user cannot see bash tool outputs. If there is important information in bash output, include it in your text response.
+
+Your current OpenCode session ID is: ${sessionId}
+Your current Telegram chat ID is: ${chatId}${threadId ? `\nYour current Telegram thread ID is: ${threadId}` : ""}
+
+## showing diffs
+
+IMPORTANT: After editing any files, you MUST execute the critique command using the Bash tool to get a diff URL, then share that URL with the user.
+
+Execute this after making changes:
+
+bunx critique web --title "Add user authentication flow"
+
+If there are other unrelated changes in the working directory, filter to only show the files you edited:
+
+bunx critique web --title "Fix database connection retry" -- path/to/file1.ts path/to/file2.ts
+
+You can also show latest commit changes using:
+
+bunx critique web --title "Refactor API endpoints" HEAD
+
+bunx critique web --title "Update dependencies" HEAD~1 to get the one before last
+
+Do this in case you committed the changes yourself (only if the user asks so, never commit otherwise).
+
+The command outputs a URL - share that URL with the user so they can see the diff.
+
+## markdown
+
+Telegram supports basic markdown features:
+- *bold* text using single asterisks
+- _italic_ text using underscores
+- \`inline code\` using backticks
+- \`\`\`code blocks\`\`\` using triple backticks (language specification optional)
+- [links](url) using standard markdown
+
+Telegram does NOT support:
+- Headers (no # syntax)
+- Tables
+- Nested formatting
+
+Keep formatting simple and readable.
+
+## spoilers
+
+Telegram supports spoiler text using ||double pipes||. This can be useful for hiding long outputs or sensitive information that the user can tap to reveal.
+
+## message limits
+
+Telegram messages are limited to 4096 characters. Very long responses will be automatically split into multiple messages.
+`.trim()
+}