opencode-telegram-mirror 0.3.0

package/src/message-formatting.ts

@@ -0,0 +1,202 @@
+/**
+ * Message formatting for OpenCode parts
+ * Matches kimaki's Discord formatting style
+ */
+
+import type { Part } from "@opencode-ai/sdk/v2"
+
+/**
+ * Escapes Telegram markdown special characters
+ */
+function escapeMarkdown(text: string): string {
+  return text.replace(/([*_`\[\]])/g, "\\$1")
+}
+
+/**
+ * Get tool summary text (file names, patterns, etc.)
+ */
+function getToolSummaryText(part: Part): string {
+  if (part.type !== "tool") return ""
+
+  const input = part.state.input ?? {}
+
+  if (part.tool === "edit") {
+    const filePath = (input.filePath as string) || ""
+    const newString = (input.newString as string) || ""
+    const oldString = (input.oldString as string) || ""
+    const added = newString.split("\n").length
+    const removed = oldString.split("\n").length
+    const fileName = filePath.split("/").pop() || ""
+    return fileName ? `*${escapeMarkdown(fileName)}* (+${added}-${removed})` : `(+${added}-${removed})`
+  }
+
+  if (part.tool === "write") {
+    const filePath = (input.filePath as string) || ""
+    const content = (input.content as string) || ""
+    const lines = content.split("\n").length
+    const fileName = filePath.split("/").pop() || ""
+    return fileName ? `*${escapeMarkdown(fileName)}* (${lines} line${lines === 1 ? "" : "s"})` : `(${lines} line${lines === 1 ? "" : "s"})`
+  }
+
+  if (part.tool === "webfetch") {
+    const url = (input.url as string) || ""
+    const urlWithoutProtocol = url.replace(/^https?:\/\//, "")
+    return urlWithoutProtocol ? `*${escapeMarkdown(urlWithoutProtocol)}*` : ""
+  }
+
+  if (part.tool === "read") {
+    const filePath = (input.filePath as string) || ""
+    const fileName = filePath.split("/").pop() || ""
+    return fileName ? `*${escapeMarkdown(fileName)}*` : ""
+  }
+
+  if (part.tool === "glob") {
+    const pattern = (input.pattern as string) || ""
+    return pattern ? `*${escapeMarkdown(pattern)}*` : ""
+  }
+
+  if (part.tool === "grep") {
+    const pattern = (input.pattern as string) || ""
+    return pattern ? `*${escapeMarkdown(pattern)}*` : ""
+  }
+
+  if (part.tool === "bash" || part.tool === "todoread" || part.tool === "todowrite") {
+    return ""
+  }
+
+  if (part.tool === "task") {
+    const description = (input.description as string) || ""
+    return description ? `_${escapeMarkdown(description)}_` : ""
+  }
+
+  return ""
+}
+
+/**
+ * Status indicators for todo items
+ */
+const TODO_STATUS_ICONS: Record<string, string> = {
+  pending: "○",
+  in_progress: "◉",
+  completed: "✓",
+  cancelled: "✗",
+}
+
+/**
+ * Format todo list from todowrite tool
+ * Shows all todos with status indicators
+ */
+function formatTodoList(part: Part): string {
+  if (part.type !== "tool" || part.tool !== "todowrite") return ""
+  
+  const todos = (part.state.input?.todos as Array<{
+    content: string
+    status: "pending" | "in_progress" | "completed" | "cancelled"
+    priority?: "high" | "medium" | "low"
+  }>) ?? []
+  
+  if (todos.length === 0) return ""
+  
+  const lines: string[] = []
+  
+  for (const todo of todos) {
+    const icon = TODO_STATUS_ICONS[todo.status] || "○"
+    const content = todo.content
+    
+    // Format based on status
+    let formatted: string
+    if (todo.status === "in_progress") {
+      // Active item: bold
+      formatted = `${icon} *${escapeMarkdown(content)}*`
+    } else if (todo.status === "completed") {
+      // Completed: strikethrough
+      formatted = `${icon} ~${escapeMarkdown(content)}~`
+    } else if (todo.status === "cancelled") {
+      // Cancelled: strikethrough + italic
+      formatted = `${icon} ~_${escapeMarkdown(content)}_~`
+    } else {
+      // Pending: plain
+      formatted = `${icon} ${escapeMarkdown(content)}`
+    }
+    
+    lines.push(formatted)
+  }
+  
+  return lines.join("\n")
+}
+
+/**
+ * Format a single part for Telegram display
+ * Matches kimaki's formatting style
+ */
+export function formatPart(part: Part): string {
+  if (part.type === "text") {
+    if (!part.text?.trim()) return ""
+    return part.text
+  }
+
+  if (part.type === "reasoning") {
+    if (!part.text?.trim()) return ""
+    return "> thinking"
+  }
+
+  if (part.type === "file") {
+    return `[file] ${part.filename || "File"}`
+  }
+
+  if (part.type === "step-start" || part.type === "step-finish" || part.type === "patch") {
+    return ""
+  }
+
+  if (part.type === "agent") {
+    return `> agent ${part.id}`
+  }
+
+  if (part.type === "tool") {
+    if (part.tool === "todowrite") {
+      return formatTodoList(part)
+    }
+
+    // Question tool is handled via buttons, not text
+    if (part.tool === "question") {
+      return ""
+    }
+
+    if (part.state.status === "pending") {
+      return ""
+    }
+
+    const summaryText = getToolSummaryText(part)
+    const stateTitle = "title" in part.state ? part.state.title : undefined
+
+    let toolTitle = ""
+    if (part.state.status === "error") {
+      toolTitle = part.state.error || "error"
+    } else if (part.tool === "bash") {
+      const command = (part.state.input?.command as string) || ""
+      const description = (part.state.input?.description as string) || ""
+      const isSingleLine = !command.includes("\n")
+      if (isSingleLine && command.length <= 50) {
+        toolTitle = `_${escapeMarkdown(command)}_`
+      } else if (description) {
+        toolTitle = `_${escapeMarkdown(description)}_`
+      } else if (stateTitle) {
+        toolTitle = `_${escapeMarkdown(stateTitle as string)}_`
+      }
+    } else if (stateTitle) {
+      toolTitle = `_${escapeMarkdown(stateTitle as string)}_`
+    }
+
+    const icon = (() => {
+      if (part.state.status === "error") return "X"
+      if (part.tool === "edit" || part.tool === "write") return ">"
+      return ">"
+    })()
+    
+    return `${icon} ${part.tool} ${toolTitle} ${summaryText}`.trim()
+  }
+
+  return ""
+}
+
+export type { Part }

package/src/opencode.ts

@@ -0,0 +1,306 @@
+/**
+ * OpenCode server process manager.
+ * Spawns and maintains a single OpenCode API server.
+ */
+
+import { spawn, type ChildProcess } from "node:child_process"
+import fs from "node:fs"
+import net from "node:net"
+import {
+  createOpencodeClient,
+  type OpencodeClient,
+  type Config,
+} from "@opencode-ai/sdk"
+import {
+  createOpencodeClient as createOpencodeClientV2,
+  type OpencodeClient as OpencodeClientV2,
+} from "@opencode-ai/sdk/v2"
+import { Result, TaggedError } from "better-result"
+import { createLogger } from "./log"
+
+const log = createLogger()
+
+export interface OpenCodeServer {
+  process: ChildProcess | null  // null when connecting to external server
+  client: OpencodeClient
+  clientV2: OpencodeClientV2
+  port: number
+  directory: string
+  baseUrl: string
+}
+
+export class PortLookupError extends TaggedError("PortLookupError")<{
+  message: string
+  cause: unknown
+}>() {
+  constructor(args: { cause: unknown }) {
+    const causeMessage = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Failed to get open port: ${causeMessage}` })
+  }
+}
+
+export class ServerStartError extends TaggedError("ServerStartError")<{
+  message: string
+  cause: unknown
+}>() {
+  constructor(args: { cause: unknown }) {
+    const causeMessage = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Server failed to start: ${causeMessage}` })
+  }
+}
+
+export class DirectoryAccessError extends TaggedError("DirectoryAccessError")<{
+  message: string
+  directory: string
+  cause: unknown
+}>() {
+  constructor(args: { directory: string; cause: unknown }) {
+    const causeMessage = args.cause instanceof Error ? args.cause.message : String(args.cause)
+    super({ ...args, message: `Directory not accessible: ${args.directory} (${causeMessage})` })
+  }
+}
+
+let server: OpenCodeServer | null = null
+
+async function getOpenPort(): Promise<Result<number, PortLookupError>> {
+  return Result.tryPromise({
+    try: () =>
+      new Promise<number>((resolve, reject) => {
+        const srv = net.createServer()
+        srv.listen(0, () => {
+          const address = srv.address()
+          if (address && typeof address === "object") {
+            const port = address.port
+            srv.close(() => resolve(port))
+          } else {
+            reject(new Error("Failed to get port"))
+          }
+        })
+        srv.on("error", reject)
+      }),
+    catch: (error) => new PortLookupError({ cause: error }),
+  })
+}
+
+async function waitForServer(
+  port: number,
+  maxAttempts = 30,
+  baseUrl?: string
+): Promise<Result<boolean, ServerStartError>> {
+  const url = baseUrl || `http://127.0.0.1:${port}`
+
+  for (let i = 0; i < maxAttempts; i++) {
+    const responseResult = await Result.tryPromise({
+      try: () =>
+        fetch(`${url}/session`, {
+          signal: AbortSignal.timeout(2000),
+        }),
+      catch: (error) => new ServerStartError({ cause: error }),
+    })
+
+    if (responseResult.status === "ok") {
+      if (responseResult.value.status < 500) {
+        return Result.ok(true)
+      }
+    }
+
+    await new Promise((r) => setTimeout(r, 1000))
+  }
+
+  return Result.err(
+    new ServerStartError({
+      cause: new Error(`Server did not start at ${url} after ${maxAttempts} seconds`),
+    })
+  )
+}
+
+/**
+ * Connect to an already-running OpenCode server
+ */
+export async function connectToServer(
+  baseUrl: string,
+  directory: string
+): Promise<Result<OpenCodeServer, ServerStartError>> {
+  // Reuse existing server if connected to same URL
+  if (server && server.baseUrl === baseUrl) {
+    log("info", "Reusing existing connection", { baseUrl })
+    return Result.ok(server)
+  }
+
+  log("info", "Connecting to external OpenCode server", { baseUrl })
+
+  // Extract port from URL
+  const url = new URL(baseUrl)
+  const port = Number(url.port) || (url.protocol === "https:" ? 443 : 80)
+
+  // Wait for server to be ready
+  const readyResult = await waitForServer(port, 30, baseUrl)
+  if (readyResult.status === "error") {
+    return Result.err(readyResult.error)
+  }
+
+  log("info", "External server ready", { baseUrl })
+
+  const fetchWithTimeout = (request: Request) =>
+    fetch(request, {
+      // @ts-ignore - bun supports timeout
+      timeout: false,
+    })
+
+  const client = createOpencodeClient({
+    baseUrl,
+    fetch: fetchWithTimeout,
+  })
+
+  const clientV2 = createOpencodeClientV2({
+    baseUrl,
+    fetch: fetchWithTimeout as typeof fetch,
+  })
+
+  server = {
+    process: null,  // No process - external server
+    client,
+    clientV2,
+    port,
+    directory,
+    baseUrl,
+  }
+
+  return Result.ok(server)
+}
+
+export async function startServer(
+  directory: string
+): Promise<Result<OpenCodeServer, DirectoryAccessError | PortLookupError | ServerStartError>> {
+  // Reuse existing server if running
+  if (server?.process && !server.process.killed) {
+    log("info", "Reusing existing server", { directory, port: server.port })
+    return Result.ok(server)
+  }
+
+  // Verify directory exists
+  const accessResult = Result.try({
+    try: () => fs.accessSync(directory, fs.constants.R_OK | fs.constants.X_OK),
+    catch: (error) => new DirectoryAccessError({ directory, cause: error }),
+  })
+
+  if (accessResult.status === "error") {
+    return Result.err(accessResult.error)
+  }
+
+  const envPort = process.env.OPENCODE_PORT
+  const parsedPort = envPort ? Number(envPort) : null
+  const portResult = parsedPort && !Number.isNaN(parsedPort) ? Result.ok(parsedPort) : await getOpenPort()
+
+  if (portResult.status === "error") {
+    return Result.err(portResult.error)
+  }
+
+  const port = portResult.value
+  const opencodePath = process.env.OPENCODE_PATH || `${process.env.HOME}/.opencode/bin/opencode`
+
+  log("info", "Starting opencode serve", { directory, port })
+
+  const serverProcess = spawn(opencodePath, ["serve", "--port", port.toString()], {
+    stdio: "pipe",
+    detached: false,
+    cwd: directory,
+    env: {
+      ...process.env,
+      OPENCODE_CONFIG_CONTENT: JSON.stringify({
+        $schema: "https://opencode.ai/config.json",
+        lsp: false,
+        formatter: false,
+        permission: {
+          edit: "allow",
+          bash: "allow",
+          webfetch: "allow",
+        },
+      } satisfies Config),
+    },
+  })
+
+  serverProcess.stdout?.on("data", (data) => {
+    log("debug", "opencode stdout", { data: data.toString().trim().slice(0, 200) })
+  })
+
+  serverProcess.stderr?.on("data", (data) => {
+    log("debug", "opencode stderr", { data: data.toString().trim().slice(0, 200) })
+  })
+
+  serverProcess.on("error", (error) => {
+    log("error", "Server process error", { directory, error: String(error) })
+  })
+
+  serverProcess.on("exit", (code) => {
+    log("info", "Server exited", { directory, code })
+    server = null
+
+    if (code !== 0) {
+      log("info", "Restarting server", { directory })
+      startServer(directory).then((result) => {
+        if (result.status === "error") {
+          log("error", "Failed to restart server", { error: result.error.message })
+        }
+      })
+    }
+  })
+
+  const readyResult = await waitForServer(port)
+  if (readyResult.status === "error") {
+    return Result.err(readyResult.error)
+  }
+
+  log("info", "Server ready", { directory, port })
+
+  const baseUrl = `http://127.0.0.1:${port}`
+  const fetchWithTimeout = (request: Request) =>
+    fetch(request, {
+      // @ts-ignore - bun supports timeout
+      timeout: false,
+    })
+
+  const client = createOpencodeClient({
+    baseUrl,
+    fetch: fetchWithTimeout,
+  })
+
+  const clientV2 = createOpencodeClientV2({
+    baseUrl,
+    fetch: fetchWithTimeout as typeof fetch,
+  })
+
+  server = {
+    process: serverProcess,
+    client,
+    clientV2,
+    port,
+    directory,
+    baseUrl,
+  }
+
+  return Result.ok(server)
+}
+
+export function getServer(): OpenCodeServer | null {
+  return server
+}
+
+export async function stopServer(): Promise<Result<void, ServerStartError>> {
+  if (!server) {
+    return Result.ok(undefined)
+  }
+
+  const serverToStop = server
+
+  const stopResult = Result.try({
+    try: () => {
+      serverToStop.process?.kill()
+      log("info", "Server stopped", { directory: serverToStop.directory })
+      server = null
+    },
+    catch: (error) => new ServerStartError({ cause: error }),
+  })
+
+  return stopResult.map(() => undefined)
+}