@ironcode-ai/telegram 1.17.2 → 1.17.4

package/README.md

@@ -74,16 +74,19 @@ The agent runs with the current directory as its working directory, so it can re
 | `/sessions` | List recent sessions — tap to switch |
 | `/new` | Start a new session |
 | `/info` | Show current session details (title, ID, file changes) |
+| `/init` | Analyze the project and create an `AGENTS.md` config file |
+| `/diff` | Show all file changes made in the current session |
 | `/start` | Show help |
 
 ## How It Works
 
 ```
 You send a message
+  → Bot shows 🤔 Thinking... while the agent starts up
   → 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
+  → Text response is streamed live by editing the placeholder
   → Final response replaces the placeholder when done
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ironcode-ai/telegram",
-  "version": "1.17.2",
+  "version": "1.17.4",
   "type": "module",
   "license": "MIT",
   "bin": {

package/src/index.ts

@@ -107,8 +107,24 @@ function sessionLabel(s: Session, isCurrent: boolean) {
 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)
+let localServer: Awaited<ReturnType<typeof createIroncode>>
+try {
+  localServer = await createIroncode({ port: 0 })
+} catch (err: any) {
+  const msg = err?.message ?? String(err)
+  if (msg.includes("exited with code 0") || msg.includes("ENOENT") || msg.includes("Illegal instruction")) {
+    console.error("❌ Failed to start ironcode server.\n")
+    console.error("   Make sure the ironcode CLI is installed and authenticated:")
+    console.error("   1. npm install -g ironcode-ai")
+    console.error("   2. ironcode auth login")
+    console.error("   3. ironcode serve  ← test manually first\n")
+  } else {
+    console.error("❌ Failed to start ironcode server:", msg)
+  }
+  process.exit(1)
+}
+console.log("✅ Ironcode server ready at", localServer.server.url)
+const client = localServer.client
 
 type SessionState = {
   sessionId: string
@@ -117,6 +133,7 @@ type SessionState = {
   liveMessageId?: number
   liveText: string
   lastEditMs: number
+  currentTool?: string
 }
 
 const EDIT_INTERVAL_MS = 1200
@@ -136,7 +153,7 @@ async function editLive(state: SessionState, text: string) {
 
 // Event loop
 ;(async () => {
-  const events = await ironcode.client.event.subscribe()
+  const events = await client.event.subscribe()
   for await (const event of events.stream) {
     const getState = (sessionID: string) =>
       [...sessions.values()].find((s) => s.sessionId === sessionID)
@@ -153,13 +170,26 @@ async function editLive(state: SessionState, text: string) {
           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 (part.type === "tool") {
+        if (part.state?.status === "completed") {
+          state.currentTool = undefined
+          await bot.api
+            .sendMessage(state.chatId, `🔧 *${part.tool}* — ${part.state.title}`, {
+              parse_mode: "Markdown",
+              ...(state.threadId ? { message_thread_id: state.threadId } : {}),
+            })
+            .catch(() => {})
+        } else if (state.currentTool !== part.tool) {
+          // Tool just started — show loading indicator if no text yet
+          state.currentTool = part.tool
+          if (!state.liveText.trim() && state.liveMessageId) {
+            const now = Date.now()
+            if (now - state.lastEditMs > 500) {
+              await editLive(state, `⏳ ${part.tool}...`)
+              state.lastEditMs = now
+            }
+          }
+        }
       }
     } else if (event.type === "message.updated") {
       const info = event.properties.info as any
@@ -172,18 +202,31 @@ async function editLive(state: SessionState, text: string) {
         await editLive(state, `❌ ${msg}`)
         state.liveMessageId = undefined
         state.liveText = ""
+        state.currentTool = undefined
         continue
       }
 
       if (info.finish && info.finish !== "tool-calls" && info.finish !== "unknown") {
         const finalText = state.liveText.trim()
+        const savedMessageId = state.liveMessageId
+
         if (finalText) {
           await editLive(state, finalText)
-        } else if (state.liveMessageId) {
-          await bot.api.deleteMessage(state.chatId, state.liveMessageId).catch(() => {})
+        } else if (savedMessageId) {
+          // No text output (only tools ran) — show done in placeholder
+          await bot.api.editMessageText(state.chatId, savedMessageId, "✅ Done").catch(() => {})
+        }
+
+        // Add ✅ reaction to signal completion
+        if (savedMessageId) {
+          await bot.api
+            .setMessageReaction(state.chatId, savedMessageId, [{ type: "emoji", emoji: "👍" }])
+            .catch(() => {})
         }
+
         state.liveMessageId = undefined
         state.liveText = ""
+        state.currentTool = undefined
       }
     }
   }
@@ -203,7 +246,9 @@ bot.command("start", async (ctx) => {
       "Commands:\n" +
       "/sessions — list sessions\n" +
       "/new — start a new session\n" +
-      "/info — current session details",
+      "/info — current session details\n" +
+      "/init — create AGENTS.md for current project\n" +
+      "/diff — show code changes in this session",
     { parse_mode: "Markdown" },
   )
 })
@@ -223,7 +268,7 @@ bot.command("info", async (ctx) => {
     return
   }
 
-  const res = await ironcode.client.session.get({ path: { id: state.sessionId } })
+  const res = await client.session.get({ path: { id: state.sessionId } })
   if (res.error) {
     await ctx.reply(`❌ ${JSON.stringify(res.error)}`)
     return
@@ -244,19 +289,89 @@ bot.command("info", async (ctx) => {
   )
 })
 
+bot.command("init", async (ctx) => {
+  const key = getChatKey(ctx.chat.id, ctx.message?.message_thread_id)
+  let state = sessions.get(key)
+
+  if (!state) {
+    const res = await 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: ctx.chat.id, threadId: ctx.message?.message_thread_id, liveText: "", lastEditMs: 0 }
+    sessions.set(key, state)
+  }
+
+  const placeholder = await ctx.reply("⏳ Analyzing project and creating AGENTS.md...")
+
+  const model = cfg.model ? parseModel(cfg.model) : undefined
+  const res = await client.session.command({
+    path: { id: state.sessionId },
+    body: { command: "init", arguments: "", ...(model ? { model: `${model.providerID}/${model.modelID}` } : {}) },
+  })
+
+  if (res.error) {
+    await bot.api
+      .editMessageText(ctx.chat.id, placeholder.message_id, `❌ ${JSON.stringify(res.error)}`)
+      .catch(() => {})
+    return
+  }
+
+  await bot.api
+    .editMessageText(ctx.chat.id, placeholder.message_id, "✅ *AGENTS.md created!*\n\nThe AI agent has analyzed your project and written configuration.", {
+      parse_mode: "Markdown",
+    })
+    .catch(() => {})
+})
+
+bot.command("diff", 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 client.session.diff({ path: { id: state.sessionId } })
+  if (res.error) {
+    await ctx.reply(`❌ ${JSON.stringify(res.error)}`)
+    return
+  }
+
+  const diffs = res.data ?? []
+
+  if (diffs.length === 0) {
+    await ctx.reply("📊 No code changes in this session.")
+    return
+  }
+
+  const totalAdd = diffs.reduce((s, d) => s + d.additions, 0)
+  const totalDel = diffs.reduce((s, d) => s + d.deletions, 0)
+
+  const fileLines = diffs.map((d) => `✏️ \`${d.file}\` (+${d.additions}/-${d.deletions})`).join("\n")
+
+  const msg = `📝 *Code Changes* — ${diffs.length} files · +${totalAdd}/-${totalDel}\n\n${fileLines}`
+
+  await ctx.reply(msg.slice(0, 4096), { 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()
+  const res = await 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)
+    .filter((s: any) => !s.time?.archived)
+    .sort((a: any, b: any) => b.time.updated - a.time.updated)
     .slice(0, 10)
 
   if (list.length === 0) {
@@ -278,7 +393,7 @@ bot.callbackQuery(/^switch:(.+)$/, async (ctx) => {
   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 } })
+  const res = await client.session.get({ path: { id: sessionId } })
   if (res.error) {
     await ctx.answerCallbackQuery({ text: "❌ Session not found" })
     return
@@ -304,7 +419,7 @@ bot.on("message:text", async (ctx) => {
   let state = sessions.get(key)
 
   if (!state) {
-    const res = await ironcode.client.session.create({
+    const res = await client.session.create({
       body: { title: `Telegram ${ctx.chat.type} ${key}` },
     })
     if (res.error) {
@@ -314,26 +429,39 @@ bot.on("message:text", async (ctx) => {
     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 } })
+    const share = await 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("⏳", {
+  const placeholder = await ctx.reply("🤔 Thinking\\.\\.\\.", {
+    parse_mode: "MarkdownV2",
     ...(threadId ? { message_thread_id: threadId } : {}),
   })
   state.liveMessageId = placeholder.message_id
   state.liveText = ""
   state.lastEditMs = 0
+  state.currentTool = undefined
+
+  // Show "typing..." indicator immediately and keep it alive every 4s
+  const sendTyping = () =>
+    bot.api.sendChatAction(chatId, "typing", threadId ? { message_thread_id: threadId } : {}).catch(() => {})
+  sendTyping()
+  const typingInterval = setInterval(() => {
+    if (!state.liveMessageId) return
+    sendTyping()
+  }, 4000)
 
   const model = cfg.model ? parseModel(cfg.model) : undefined
 
-  const result = await ironcode.client.session.promptAsync({
+  const result = await client.session.promptAsync({
     path: { id: state.sessionId },
     body: { parts: [{ type: "text", text }], model },
   })
 
+  clearInterval(typingInterval)
+
   if (result.error) {
     await ctx.api.editMessageText(chatId, placeholder.message_id, `❌ ${JSON.stringify(result.error)}`)
     state.liveMessageId = undefined