@ironcode-ai/telegram 1.16.1

package/README.md

@@ -0,0 +1,97 @@
+# @ironcode-ai/telegram
+
+Telegram bot integration for ironcode. Send messages from Telegram to run an AI coding agent on your machine — tool calls, file edits, and responses stream back in real-time.
+
+## Requirements
+
+- [Bun](https://bun.sh) >= 1.0
+- [`ironcode-ai`](https://www.npmjs.com/package/ironcode-ai) CLI installed and authenticated
+
+## Installation
+
+### 1. Install ironcode-ai CLI
+
+```bash
+bun install -g ironcode-ai
+```
+
+### 2. Authenticate a provider
+
+```bash
+ironcode auth login            # GitHub Copilot (recommended)
+ironcode auth login anthropic  # Anthropic
+ironcode auth login openai     # OpenAI
+```
+
+List available models:
+```bash
+ironcode models
+```
+
+### 3. Create a Telegram Bot
+
+1. Open Telegram → search for [@BotFather](https://t.me/BotFather)
+2. Send `/newbot` → follow prompts → copy the **Bot Token**
+
+### 4. Install ironcode-telegram
+
+```bash
+bun install -g @ironcode-ai/telegram
+```
+
+### 5. Configure
+
+```bash
+ironcode-telegram setup
+# Bot Token (from @BotFather): ****
+# Model [github-copilot/claude-sonnet-4.6]:
+# ✅ Config saved to ~/.config/ironcode/telegram.json
+```
+
+Config is stored at `~/.config/ironcode/telegram.json`:
+```json
+{
+  "token": "your-bot-token",
+  "model": "github-copilot/claude-sonnet-4.6"
+}
+```
+
+### 6. Run
+
+```bash
+# cd into the repo you want the agent to work on
+cd /path/to/your/project
+
+ironcode-telegram
+```
+
+The agent runs with the current directory as its working directory, so it can read and edit files in your project.
+
+## Bot Commands
+
+| Command | Description |
+|---|---|
+| `/sessions` | List recent sessions — tap to switch |
+| `/new` | Start a new session |
+| `/info` | Show current session details (title, ID, file changes) |
+| `/start` | Show help |
+
+## How It Works
+
+```
+You send a message
+  → Bot creates/resumes an ironcode session on your machine
+  → Agent reads/writes files, runs bash, calls LLM
+  → Each completed tool call is sent as a separate message
+  → Text response is streamed live by editing a ⏳ placeholder
+  → Final response replaces the placeholder when done
+```
+
+Each chat (DM, group, or group thread) gets its own independent session. Use `/sessions` to switch between them.
+
+## Session Management
+
+- **Automatic**: Each chat automatically gets its own session on first message.
+- **Switch**: `/sessions` shows the 10 most recent sessions with an inline keyboard. Tap any to resume it.
+- **New**: `/new` clears the current slot — your next message starts a fresh session.
+- **Persistent**: Sessions and their file change history are preserved across bot restarts.

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@ironcode-ai/telegram",
+  "version": "1.16.1",
+  "type": "module",
+  "license": "MIT",
+  "bin": {
+    "ironcode-telegram": "./src/index.ts"
+  },
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "typecheck": "tsgo --noEmit"
+  },
+  "dependencies": {
+    "@ironcode-ai/sdk": "^1.15.4",
+    "grammy": "^1.36.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.9",
+    "typescript": "^5.9.3"
+  }
+}

package/src/index.ts

@@ -0,0 +1,344 @@
+#!/usr/bin/env bun
+import { Bot, InlineKeyboard } from "grammy"
+import { createIroncode } from "@ironcode-ai/sdk"
+import type { Session } from "@ironcode-ai/sdk"
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import * as readline from "readline"
+
+// ── Config ────────────────────────────────────────────────────────────────────
+
+type Config = {
+  token: string
+  model?: string
+}
+
+function configPath() {
+  const xdg = process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config")
+  return join(xdg, "ironcode", "telegram.json")
+}
+
+function loadConfig(): Config | null {
+  const p = configPath()
+  if (!existsSync(p)) return null
+  try {
+    return JSON.parse(readFileSync(p, "utf8")) as Config
+  } catch {
+    return null
+  }
+}
+
+function saveConfig(cfg: Config) {
+  const p = configPath()
+  mkdirSync(join(p, ".."), { recursive: true })
+  writeFileSync(p, JSON.stringify(cfg, null, 2))
+}
+
+async function ask(prompt: string): Promise<string> {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+  return new Promise((resolve) => {
+    rl.question(prompt, (ans) => {
+      rl.close()
+      resolve(ans.trim())
+    })
+  })
+}
+
+// ── Setup command ─────────────────────────────────────────────────────────────
+
+if (process.argv[2] === "setup") {
+  console.log("⚙️  ironcode-telegram setup\n")
+
+  const existing = loadConfig()
+  const token = await ask(`Bot Token (from @BotFather)${existing?.token ? " [keep current: Enter]" : ""}: `)
+  const model = await ask(`Model [${existing?.model ?? "github-copilot/claude-sonnet-4.6"}]: `)
+
+  const cfg: Config = {
+    token: token || existing?.token || "",
+    model: model || existing?.model || "github-copilot/claude-sonnet-4.6",
+  }
+
+  if (!cfg.token) {
+    console.error("❌ Bot Token is required.")
+    process.exit(1)
+  }
+
+  saveConfig(cfg)
+  console.log(`\n✅ Config saved to ${configPath()}`)
+  console.log("   Run: ironcode-telegram\n")
+  process.exit(0)
+}
+
+// ── Load config ───────────────────────────────────────────────────────────────
+
+const cfg = loadConfig()
+if (!cfg) {
+  console.error(`❌ No config found. Run:\n\n   ironcode-telegram setup\n`)
+  process.exit(1)
+}
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+function parseModel(model: string) {
+  const [providerID, ...rest] = model.split("/")
+  return { providerID, modelID: rest.join("/") }
+}
+
+function relativeTime(ms: number) {
+  const diff = Date.now() - ms
+  const m = Math.floor(diff / 60000)
+  const h = Math.floor(diff / 3600000)
+  const d = Math.floor(diff / 86400000)
+  if (m < 1) return "just now"
+  if (m < 60) return `${m}m ago`
+  if (h < 24) return `${h}h ago`
+  return `${d}d ago`
+}
+
+function sessionLabel(s: Session, isCurrent: boolean) {
+  const changes = s.summary ? ` (+${s.summary.additions}/-${s.summary.deletions})` : ""
+  const cur = isCurrent ? " ✓" : ""
+  return `${s.title}${changes} · ${relativeTime(s.time.updated)}${cur}`
+}
+
+// ── Bot ───────────────────────────────────────────────────────────────────────
+
+const bot = new Bot(cfg.token)
+
+console.log("🚀 Starting ironcode server...")
+const ironcode = await createIroncode({ port: 0 })
+console.log("✅ Ironcode server ready at", ironcode.server.url)
+
+type SessionState = {
+  sessionId: string
+  chatId: number
+  threadId?: number
+  liveMessageId?: number
+  liveText: string
+  lastEditMs: number
+}
+
+const EDIT_INTERVAL_MS = 1200
+
+const sessions = new Map<string, SessionState>()
+
+function getChatKey(chatId: number, threadId?: number) {
+  return threadId ? `${chatId}-${threadId}` : `${chatId}`
+}
+
+async function editLive(state: SessionState, text: string) {
+  if (!state.liveMessageId) return
+  await bot.api
+    .editMessageText(state.chatId, state.liveMessageId, text || "…")
+    .catch(() => {})
+}
+
+// Event loop
+;(async () => {
+  const events = await ironcode.client.event.subscribe()
+  for await (const event of events.stream) {
+    const getState = (sessionID: string) =>
+      [...sessions.values()].find((s) => s.sessionId === sessionID)
+
+    if (event.type === "message.part.updated") {
+      const part = event.properties.part as any
+      const state = getState(part.sessionID)
+      if (!state) continue
+
+      if (part.type === "text") {
+        state.liveText = part.text
+        const now = Date.now()
+        if (state.liveMessageId && now - state.lastEditMs > EDIT_INTERVAL_MS) {
+          await editLive(state, state.liveText)
+          state.lastEditMs = now
+        }
+      } else if (part.type === "tool" && part.state?.status === "completed") {
+        await bot.api
+          .sendMessage(state.chatId, `*${part.tool}* — ${part.state.title}`, {
+            parse_mode: "Markdown",
+            ...(state.threadId ? { message_thread_id: state.threadId } : {}),
+          })
+          .catch(() => {})
+      }
+    } else if (event.type === "message.updated") {
+      const info = event.properties.info as any
+      if (info.role !== "assistant") continue
+      const state = getState(info.sessionID)
+      if (!state) continue
+
+      if (info.error) {
+        const msg = info.error.data?.message ?? info.error.name ?? "Unknown error"
+        await editLive(state, `❌ ${msg}`)
+        state.liveMessageId = undefined
+        state.liveText = ""
+        continue
+      }
+
+      if (info.finish && info.finish !== "tool-calls" && info.finish !== "unknown") {
+        const finalText = state.liveText.trim()
+        if (finalText) {
+          await editLive(state, finalText)
+        } else if (state.liveMessageId) {
+          await bot.api.deleteMessage(state.chatId, state.liveMessageId).catch(() => {})
+        }
+        state.liveMessageId = undefined
+        state.liveText = ""
+      }
+    }
+  }
+})()
+
+bot.catch((err) => {
+  console.error("❌ Unhandled bot error:", err.message)
+  err.ctx.reply(`❌ ${err.message}`).catch(() => {})
+})
+
+// ── Commands ──────────────────────────────────────────────────────────────────
+
+bot.command("start", async (ctx) => {
+  await ctx.reply(
+    "👋 *IronCode Bot*\n\n" +
+      "Send a message to start coding with the AI agent.\n\n" +
+      "Commands:\n" +
+      "/sessions — list sessions\n" +
+      "/new — start a new session\n" +
+      "/info — current session details",
+    { parse_mode: "Markdown" },
+  )
+})
+
+bot.command("new", async (ctx) => {
+  const key = getChatKey(ctx.chat.id, ctx.message?.message_thread_id)
+  sessions.delete(key)
+  await ctx.reply("✨ New session will be created on your next message.")
+})
+
+bot.command("info", async (ctx) => {
+  const key = getChatKey(ctx.chat.id, ctx.message?.message_thread_id)
+  const state = sessions.get(key)
+
+  if (!state) {
+    await ctx.reply("No active session. Send a message to create one.")
+    return
+  }
+
+  const res = await ironcode.client.session.get({ path: { id: state.sessionId } })
+  if (res.error) {
+    await ctx.reply(`❌ ${JSON.stringify(res.error)}`)
+    return
+  }
+
+  const s = res.data
+  const changes = s.summary
+    ? `📊 ${s.summary.files} files · +${s.summary.additions}/-${s.summary.deletions}`
+    : "📊 No changes yet"
+
+  await ctx.reply(
+    `*${s.title}*\n` +
+      `ID: \`${s.id}\`\n` +
+      `Created: ${relativeTime(s.time.created)}\n` +
+      `Updated: ${relativeTime(s.time.updated)}\n` +
+      changes,
+    { parse_mode: "Markdown" },
+  )
+})
+
+bot.command("sessions", async (ctx) => {
+  const key = getChatKey(ctx.chat.id, ctx.message?.message_thread_id)
+  const currentState = sessions.get(key)
+
+  const res = await ironcode.client.session.list()
+  if (res.error) {
+    await ctx.reply(`❌ ${JSON.stringify(res.error)}`)
+    return
+  }
+
+  const list = res.data!
+    .filter((s) => !(s as any).time?.archived)
+    .sort((a, b) => b.time.updated - a.time.updated)
+    .slice(0, 10)
+
+  if (list.length === 0) {
+    await ctx.reply("No sessions yet.")
+    return
+  }
+
+  const kb = new InlineKeyboard()
+  for (const s of list) {
+    kb.text(sessionLabel(s, s.id === currentState?.sessionId), `switch:${s.id}`).row()
+  }
+
+  await ctx.reply("Select a session to continue:", { reply_markup: kb })
+})
+
+bot.callbackQuery(/^switch:(.+)$/, async (ctx) => {
+  const sessionId = ctx.match[1]
+  const chatId = ctx.chat!.id
+  const threadId = (ctx.callbackQuery.message as any)?.message_thread_id
+  const key = getChatKey(chatId, threadId)
+
+  const res = await ironcode.client.session.get({ path: { id: sessionId } })
+  if (res.error) {
+    await ctx.answerCallbackQuery({ text: "❌ Session not found" })
+    return
+  }
+
+  const existing = sessions.get(key)
+  sessions.set(key, { sessionId, chatId, threadId, liveText: "", lastEditMs: 0, liveMessageId: existing?.liveMessageId })
+
+  await ctx.answerCallbackQuery({ text: "✓ Session switched" })
+  await ctx.editMessageText(`✅ Now using: *${res.data!.title}*`, { parse_mode: "Markdown" })
+})
+
+// ── Main message handler ──────────────────────────────────────────────────────
+
+bot.on("message:text", async (ctx) => {
+  const chatId = ctx.chat.id
+  const threadId = ctx.message.message_thread_id
+  const key = getChatKey(chatId, threadId)
+  const text = ctx.message.text
+
+  if (text.startsWith("/")) return
+
+  let state = sessions.get(key)
+
+  if (!state) {
+    const res = await ironcode.client.session.create({
+      body: { title: `Telegram ${ctx.chat.type} ${key}` },
+    })
+    if (res.error) {
+      await ctx.reply(`❌ Failed to create session: ${JSON.stringify(res.error)}`)
+      return
+    }
+    state = { sessionId: res.data.id, chatId, threadId, liveText: "", lastEditMs: 0 }
+    sessions.set(key, state)
+
+    const share = await ironcode.client.session.share({ path: { id: res.data.id } })
+    if (!share.error && share.data?.share?.url) {
+      await ctx.reply(`🔗 Session: ${share.data.share.url}`)
+    }
+  }
+
+  const placeholder = await ctx.reply("⏳", {
+    ...(threadId ? { message_thread_id: threadId } : {}),
+  })
+  state.liveMessageId = placeholder.message_id
+  state.liveText = ""
+  state.lastEditMs = 0
+
+  const model = cfg.model ? parseModel(cfg.model) : undefined
+
+  const result = await ironcode.client.session.promptAsync({
+    path: { id: state.sessionId },
+    body: { parts: [{ type: "text", text }], model },
+  })
+
+  if (result.error) {
+    await ctx.api.editMessageText(chatId, placeholder.message_id, `❌ ${JSON.stringify(result.error)}`)
+    state.liveMessageId = undefined
+  }
+})
+
+await bot.start()
+console.log("⚡️ Telegram bot is running!")