afk-code 0.1.3 → 0.2.0

package/README.md

@@ -1,28 +1,39 @@
 # AFK Code
 
-Monitor and interact with Claude Code sessions from Slack or Discord. Respond from your phone while AFK.
+Monitor and interact with Claude Code sessions from Slack, Discord, or Telegram. Respond from your phone while AFK.
 
-## Quick Start (Slack)
+<img src="https://github.com/user-attachments/assets/83083b63-9ca2-4ef0-b83d-fcc51bd2fff9" alt="AFK Code iPhone Slack screenshot" width="400">
+
+## Client Comparison
+
+Telegram and Discord are recommended.
+
+| | Telegram | Discord | Slack |
+|---|---|---|---|
+| Siri integration | Receive & Send | Receive only | Receive only |
+| Multi-session support | One at a time (switchable) | Yes | Yes |
+| Permissions required | Personal | Personal | Admin |
+
+## Quick Start (Telegram)
 
 ```bash
-# 1. Create a Slack app at https://api.slack.com/apps
-#    Click "Create New App" → "From manifest" → paste slack-manifest.json
+# 1. Create a bot with @BotFather on Telegram
+#    - Send /newbot and follow the prompts
+#    - Copy the bot token
 
-# 2. Install to your workspace and get credentials:
-#    - Bot Token (xoxb-...) from OAuth & Permissions
-#    - App Token (xapp-...) from Basic Information → App-Level Tokens (needs connections:write)
-#    - Your User ID from your Slack profile → "..." → Copy member ID
+# 2. Get your Chat ID
+#    - Message your bot, then visit:
+#    - https://api.telegram.org/bot<TOKEN>/getUpdates
+#    - Find "chat":{"id":YOUR_CHAT_ID}
 
 # 3. Configure and run
-npx afk-code slack setup   # Enter your credentials
-npx afk-code slack         # Start the bot
+npx afk-code telegram setup   # Enter your credentials
+npx afk-code telegram         # Start the bot
 
 # 4. In another terminal, start a monitored Claude session
-npx afk-code run -- claude
+npx afk-code claude
 ```
 
-A new channel is created for each session. Messages relay bidirectionally.
-
 ## Quick Start (Discord)
 
 ```bash
@@ -40,27 +51,54 @@ npx afk-code discord setup   # Enter your credentials
 npx afk-code discord         # Start the bot
 
 # 4. In another terminal, start a monitored Claude session
-npx afk-code run -- claude
+npx afk-code claude
 ```
 
+## Quick Start (Slack)
+
+```bash
+# 1. Create a Slack app at https://api.slack.com/apps
+#    Click "Create New App" → "From manifest" → paste slack-manifest.json
+
+# 2. Install to your workspace and get credentials:
+#    - Bot Token (xoxb-...) from OAuth & Permissions
+#    - App Token (xapp-...) from Basic Information → App-Level Tokens (needs connections:write)
+#    - Your User ID from your Slack profile → "..." → Copy member ID
+
+# 3. Configure and run
+npx afk-code slack setup   # Enter your credentials
+npx afk-code slack         # Start the bot
+
+# 4. In another terminal, start a monitored Claude session
+npx afk-code claude
+```
+
+A new channel is created for each session. Messages relay bidirectionally.
+
 ## Commands
 
 ```
-afk-code slack setup        Configure Slack credentials
-afk-code slack              Run the Slack bot
+afk-code telegram setup     Configure Telegram credentials
+afk-code telegram           Run the Telegram bot
 afk-code discord setup      Configure Discord credentials
 afk-code discord            Run the Discord bot
-afk-code run -- <command>   Start a monitored session
+afk-code slack setup        Configure Slack credentials
+afk-code slack              Run the Slack bot
+afk-code <command> [args]   Start a monitored session
 afk-code help               Show help
 ```
 
-### Slack Slash Commands
+### Slash Commands
 
-- `/afk` - List active sessions
-- `/background` - Send Ctrl+B (background signal)
-- `/interrupt` - Send Escape (interrupt signal)
-- `/mode` - Send Shift+Tab (toggle mode)
-    - Not recommended since you don't get feedback on what mode you're in
+| Command | Slack | Discord | Telegram | Description |
+|---------|:-----:|:-------:|:--------:|-------------|
+| `/sessions` | ✓ | ✓ | ✓ | List active sessions |
+| `/switch <name>` | - | - | ✓ | Switch session (Telegram only) |
+| `/model <name>` | ✓ | ✓ | ✓ | Switch model (opus, sonnet, haiku) |
+| `/compact` | ✓ | ✓ | ✓ | Compact the conversation |
+| `/background` | ✓ | ✓ | ✓ | Send Ctrl+B (background mode) |
+| `/interrupt` | ✓ | ✓ | ✓ | Send Escape (interrupt) |
+| `/mode` | ✓ | ✓ | ✓ | Toggle mode (Shift+Tab) |
 
 ## Installation Options
 
@@ -75,15 +113,15 @@ npx afk-code <command>
 git clone https://github.com/clharman/afk-code.git
 cd afk-code && npm install
 npm run dev -- slack
-npm run dev -- run -- claude
+npm run dev -- claude
 ```
 
 Requires Node.js 18+.
 
 ## How It Works
 
-1. `afk-code slack` or `afk-code discord` starts a bot that listens for sessions
-2. `afk-code run -- claude` spawns Claude in a PTY and connects to the bot via Unix socket
+1. `afk-code slack`, `afk-code discord`, or `afk-code telegram` starts a bot that listens for sessions
+2. `afk-code claude` spawns Claude in a PTY and connects to the bot via Unix socket
 3. The bot watches Claude's JSONL files for messages and relays them to chat
 4. Messages you send in chat are forwarded to the terminal
 

package/dist/cli/index.js

@@ -889,7 +889,7 @@ ${todosText}`,
       await say(":warning: Failed to send input - session not connected.");
     }
   });
-  app.command("/afk", async ({ command: command2, ack, respond }) => {
+  app.command("/sessions", async ({ command: command2, ack, respond }) => {
     await ack();
     const subcommand = command2.text.trim().split(" ")[0];
     if (subcommand === "sessions" || !subcommand) {
@@ -905,7 +905,7 @@ ${text}`,
         mrkdwn: true
       });
     } else {
-      await respond("Unknown command. Available: `/afk sessions`");
+      await respond("Unknown command. Try `/sessions`");
     }
   });
   app.command("/background", async ({ command: command2, ack, respond }) => {
@@ -965,6 +965,50 @@ ${text}`,
       await respond(":warning: Failed to send command - session not connected.");
     }
   });
+  app.command("/compact", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const sessionId = channelManager.getSessionByChannel(command2.channel_id);
+    if (!sessionId) {
+      await respond(":warning: This channel is not associated with an active session.");
+      return;
+    }
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await respond(":warning: This session has ended.");
+      return;
+    }
+    const sent = sessionManager.sendInput(sessionId, "/compact\n");
+    if (sent) {
+      await respond(":compression: Sent /compact");
+    } else {
+      await respond(":warning: Failed to send command - session not connected.");
+    }
+  });
+  app.command("/model", async ({ command: command2, ack, respond }) => {
+    await ack();
+    const sessionId = channelManager.getSessionByChannel(command2.channel_id);
+    if (!sessionId) {
+      await respond(":warning: This channel is not associated with an active session.");
+      return;
+    }
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === "ended") {
+      await respond(":warning: This session has ended.");
+      return;
+    }
+    const modelArg = command2.text.trim();
+    if (!modelArg) {
+      await respond("Usage: `/model <opus|sonnet|haiku>`");
+      return;
+    }
+    const sent = sessionManager.sendInput(sessionId, `/model ${modelArg}
+`);
+    if (sent) {
+      await respond(`:brain: Sent /model ${modelArg}`);
+    } else {
+      await respond(":warning: Failed to send command - session not connected.");
+    }
+  });
   app.event("app_home_opened", async ({ event, client }) => {
     const active = channelManager.getAllActive();
     const blocks = [
@@ -1413,7 +1457,9 @@ ${content}
       new SlashCommandBuilder().setName("background").setDescription("Send Claude to background mode (Ctrl+B)"),
       new SlashCommandBuilder().setName("interrupt").setDescription("Interrupt Claude (Escape)"),
       new SlashCommandBuilder().setName("mode").setDescription("Toggle Claude mode (Shift+Tab)"),
-      new SlashCommandBuilder().setName("afk").setDescription("List active Claude Code sessions")
+      new SlashCommandBuilder().setName("sessions").setDescription("List active Claude Code sessions"),
+      new SlashCommandBuilder().setName("compact").setDescription("Compact the conversation (/compact)"),
+      new SlashCommandBuilder().setName("model").setDescription("Switch Claude model").addStringOption((option) => option.setName("name").setDescription("Model name (opus, sonnet, haiku)").setRequired(true))
     ];
     try {
       const rest = new REST({ version: "10" }).setToken(config.botToken);
@@ -1428,7 +1474,7 @@ ${content}
   client.on(Events.InteractionCreate, async (interaction) => {
     if (!interaction.isChatInputCommand()) return;
     const { commandName, channelId } = interaction;
-    if (commandName === "afk") {
+    if (commandName === "sessions") {
       const active = channelManager.getAllActive();
       if (active.length === 0) {
         await interaction.reply("No active sessions. Start a session with `afk-code run -- claude`");
@@ -1469,6 +1515,44 @@ ${text}`);
         await interaction.reply("\u26A0\uFE0F Failed to send command - session not connected.");
       }
     }
+    if (commandName === "compact") {
+      const sessionId = channelManager.getSessionByChannel(channelId);
+      if (!sessionId) {
+        await interaction.reply("\u26A0\uFE0F This channel is not associated with an active session.");
+        return;
+      }
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel || channel.status === "ended") {
+        await interaction.reply("\u26A0\uFE0F This session has ended.");
+        return;
+      }
+      const sent = sessionManager.sendInput(sessionId, "/compact\n");
+      if (sent) {
+        await interaction.reply("\u{1F5DC}\uFE0F Sent /compact");
+      } else {
+        await interaction.reply("\u26A0\uFE0F Failed to send command - session not connected.");
+      }
+    }
+    if (commandName === "model") {
+      const sessionId = channelManager.getSessionByChannel(channelId);
+      if (!sessionId) {
+        await interaction.reply("\u26A0\uFE0F This channel is not associated with an active session.");
+        return;
+      }
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel || channel.status === "ended") {
+        await interaction.reply("\u26A0\uFE0F This session has ended.");
+        return;
+      }
+      const modelArg = interaction.options.getString("name", true);
+      const sent = sessionManager.sendInput(sessionId, `/model ${modelArg}
+`);
+      if (sent) {
+        await interaction.reply(`\u{1F9E0} Sent /model ${modelArg}`);
+      } else {
+        await interaction.reply("\u26A0\uFE0F Failed to send command - session not connected.");
+      }
+    }
   });
   return { client, sessionManager, channelManager };
 }
@@ -1482,6 +1566,351 @@ var init_discord_app = __esm({
   }
 });
 
+// src/telegram/telegram-app.ts
+var telegram_app_exports = {};
+__export(telegram_app_exports, {
+  createTelegramApp: () => createTelegramApp
+});
+import { Bot } from "grammy";
+function createTelegramApp(config) {
+  const bot = new Bot(config.botToken);
+  const activeSessions = /* @__PURE__ */ new Map();
+  const telegramSentMessages = /* @__PURE__ */ new Set();
+  let currentSessionId = null;
+  const messageQueue = [];
+  let processingQueue = false;
+  async function processQueue() {
+    if (processingQueue) return;
+    processingQueue = true;
+    while (messageQueue.length > 0) {
+      const fn = messageQueue.shift();
+      if (fn) {
+        try {
+          await fn();
+        } catch (err) {
+          console.error("[Telegram] Error sending message:", err);
+        }
+        if (messageQueue.length > 0) {
+          await new Promise((r) => setTimeout(r, 100));
+        }
+      }
+    }
+    processingQueue = false;
+  }
+  async function sendMessage(text, parseMode = "Markdown", options) {
+    messageQueue.push(async () => {
+      try {
+        await bot.api.sendMessage(config.chatId, text, {
+          parse_mode: parseMode,
+          disable_notification: options?.disable_notification
+        });
+      } catch (err) {
+        if (parseMode && err.message?.includes("parse")) {
+          await bot.api.sendMessage(config.chatId, text, {
+            disable_notification: options?.disable_notification
+          });
+        } else {
+          throw err;
+        }
+      }
+    });
+    processQueue();
+  }
+  async function sendChunkedMessage(text, prefix, options) {
+    const chunks = chunkMessage(text, MAX_MESSAGE_LENGTH);
+    for (let i = 0; i < chunks.length; i++) {
+      const chunk = prefix && i === 0 ? `${prefix} ${chunks[i]}` : chunks[i];
+      await sendMessage(chunk, "Markdown", options);
+    }
+  }
+  const sessionManager = new SessionManager({
+    onSessionStart: async (session) => {
+      activeSessions.set(session.id, {
+        sessionId: session.id,
+        sessionName: session.name,
+        lastActivity: /* @__PURE__ */ new Date()
+      });
+      const parts = session.name.split(" ");
+      const cmd = parts[0];
+      const args2 = parts.slice(1).map((a) => a.replace(/^-+/, ""));
+      const sessionLabel = args2.length > 0 ? `${cmd} (${args2.join(", ")})` : cmd;
+      await sendMessage(
+        `Session started: ${sessionLabel}
+Directory: \`${session.cwd}\``
+      );
+    },
+    onSessionEnd: async (sessionId) => {
+      const tracking = activeSessions.get(sessionId);
+      const name = tracking?.sessionName || sessionId;
+      activeSessions.delete(sessionId);
+      await sendMessage(`Session ended: ${name}`);
+    },
+    onSessionUpdate: async (sessionId, name) => {
+      const tracking = activeSessions.get(sessionId);
+      if (tracking) {
+        tracking.sessionName = name;
+        tracking.lastActivity = /* @__PURE__ */ new Date();
+      }
+    },
+    onSessionStatus: async (sessionId, _status) => {
+      const tracking = activeSessions.get(sessionId);
+      if (tracking) {
+        tracking.lastActivity = /* @__PURE__ */ new Date();
+      }
+    },
+    onMessage: async (sessionId, role, content) => {
+      const tracking = activeSessions.get(sessionId);
+      if (!tracking) return;
+      tracking.lastActivity = /* @__PURE__ */ new Date();
+      if (role === "user") {
+        const contentKey = content.trim();
+        if (telegramSentMessages.has(contentKey)) {
+          telegramSentMessages.delete(contentKey);
+          return;
+        }
+        await sendChunkedMessage(content, `_User (terminal):_`, { disable_notification: true });
+      } else {
+        await sendChunkedMessage(content, `_Claude Code:_`);
+      }
+    },
+    onTodos: async (sessionId, todos) => {
+      const tracking = activeSessions.get(sessionId);
+      if (!tracking || todos.length === 0) return;
+      const todosText = formatTodos(todos);
+      await sendMessage(`_Claude Code:_ *Tasks:*
+${todosText}`);
+    },
+    onToolCall: async (_sessionId, _tool) => {
+    },
+    onToolResult: async (_sessionId, _result) => {
+    },
+    onPlanModeChange: async (sessionId, inPlanMode) => {
+      const tracking = activeSessions.get(sessionId);
+      if (!tracking) return;
+      const status = inPlanMode ? "Planning mode - Claude is designing a solution" : "Execution mode - Claude is implementing";
+      await sendMessage(`_Claude Code:_ ${status}`);
+    }
+  });
+  function getCurrentSession() {
+    if (currentSessionId) {
+      const session = activeSessions.get(currentSessionId);
+      if (session) return session;
+      currentSessionId = null;
+    }
+    if (activeSessions.size === 1) {
+      return activeSessions.values().next().value;
+    }
+    return null;
+  }
+  function getSessionByName(name) {
+    const nameLower = name.toLowerCase();
+    for (const tracking of activeSessions.values()) {
+      if (tracking.sessionName.toLowerCase().startsWith(nameLower)) {
+        return tracking;
+      }
+    }
+    return null;
+  }
+  function getMostRecentSession() {
+    let mostRecent = null;
+    for (const tracking of activeSessions.values()) {
+      if (!mostRecent || tracking.lastActivity > mostRecent.lastActivity) {
+        mostRecent = tracking;
+      }
+    }
+    return mostRecent;
+  }
+  bot.on("message:text", async (ctx) => {
+    if (ctx.chat.id.toString() !== config.chatId) return;
+    const text = ctx.message.text;
+    if (text.startsWith("/")) {
+      await handleCommand(ctx, text.trim());
+      return;
+    }
+    const current = getCurrentSession();
+    if (!current) {
+      if (activeSessions.size === 0) {
+        await ctx.reply("No active sessions. Start one with:\n`afk-code run -- claude`", { parse_mode: "Markdown" });
+      } else {
+        const list = Array.from(activeSessions.values()).map((s) => `\u2022 \`${s.sessionName}\``).join("\n");
+        await ctx.reply(
+          `Multiple sessions active. Select one first:
+
+${list}
+
+Use: \`/switch <name>\``,
+          { parse_mode: "Markdown" }
+        );
+      }
+      return;
+    }
+    telegramSentMessages.add(text.trim());
+    const sent = sessionManager.sendInput(current.sessionId, text);
+    if (!sent) {
+      telegramSentMessages.delete(text.trim());
+      await ctx.reply("Failed to send input - session not connected.");
+    }
+  });
+  async function handleCommand(ctx, text) {
+    const [command2, ...args2] = text.split(" ");
+    const sessionArg = args2[0];
+    let targetSession = null;
+    if (sessionArg && !sessionArg.startsWith("/")) {
+      for (const tracking of activeSessions.values()) {
+        if (tracking.sessionName.toLowerCase().startsWith(sessionArg.toLowerCase())) {
+          targetSession = tracking;
+          break;
+        }
+      }
+    }
+    if (!targetSession) {
+      targetSession = getMostRecentSession();
+    }
+    switch (command2.toLowerCase()) {
+      case "/start": {
+        await ctx.reply(
+          `*AFK Code Telegram Bot*
+
+This bot lets you monitor and interact with Claude Code sessions.
+
+Start a session with:
+\`afk-code run -- claude\`
+
+Type /help for available commands.`,
+          { parse_mode: "Markdown" }
+        );
+        break;
+      }
+      case "/sessions": {
+        if (activeSessions.size === 0) {
+          await ctx.reply("No active sessions. Start one with `afk-code run -- claude`");
+          return;
+        }
+        const current = getCurrentSession();
+        const list = Array.from(activeSessions.values()).map((s) => {
+          const isCurrent = current && s.sessionId === current.sessionId;
+          return isCurrent ? `\u2022 *${s.sessionName}* \u2190 current` : `\u2022 ${s.sessionName}`;
+        }).join("\n");
+        await ctx.reply(`*Active Sessions:*
+${list}
+
+Use \`/switch <name>\` to change`, { parse_mode: "Markdown" });
+        break;
+      }
+      case "/switch":
+      case "/select": {
+        if (!sessionArg) {
+          if (activeSessions.size === 0) {
+            await ctx.reply("No active sessions.");
+            return;
+          }
+          const current = getCurrentSession();
+          const list = Array.from(activeSessions.values()).map((s) => {
+            const isCurrent = current && s.sessionId === current.sessionId;
+            return isCurrent ? `\u2022 *${s.sessionName}* \u2190 current` : `\u2022 ${s.sessionName}`;
+          }).join("\n");
+          await ctx.reply(`*Sessions:*
+${list}
+
+Use: \`/switch <name>\``, { parse_mode: "Markdown" });
+          return;
+        }
+        const session = getSessionByName(sessionArg);
+        if (session) {
+          currentSessionId = session.sessionId;
+          await ctx.reply(`Switched to: *${session.sessionName}*`, { parse_mode: "Markdown" });
+        } else {
+          await ctx.reply(`Session not found: ${sessionArg}`);
+        }
+        break;
+      }
+      case "/background":
+      case "/bg": {
+        if (!targetSession) {
+          await ctx.reply("No active session.");
+          return;
+        }
+        const sent = sessionManager.sendInput(targetSession.sessionId, "");
+        await ctx.reply(sent ? "Sent background command (Ctrl+B)" : "Failed - session not connected.");
+        break;
+      }
+      case "/interrupt":
+      case "/stop": {
+        if (!targetSession) {
+          await ctx.reply("No active session.");
+          return;
+        }
+        const sent = sessionManager.sendInput(targetSession.sessionId, "\x1B");
+        await ctx.reply(sent ? "Sent interrupt (Escape)" : "Failed - session not connected.");
+        break;
+      }
+      case "/mode": {
+        if (!targetSession) {
+          await ctx.reply("No active session.");
+          return;
+        }
+        const sent = sessionManager.sendInput(targetSession.sessionId, "\x1B[Z");
+        await ctx.reply(sent ? "Sent mode toggle (Shift+Tab)" : "Failed - session not connected.");
+        break;
+      }
+      case "/compact": {
+        if (!targetSession) {
+          await ctx.reply("No active session.");
+          return;
+        }
+        const sent = sessionManager.sendInput(targetSession.sessionId, "/compact\n");
+        await ctx.reply(sent ? "Sent /compact" : "Failed - session not connected.");
+        break;
+      }
+      case "/model": {
+        if (!targetSession) {
+          await ctx.reply("No active session.");
+          return;
+        }
+        const modelArg = args2.slice(targetSession === getSessionByName(args2[0] || "") ? 1 : 0).join(" ");
+        if (!modelArg) {
+          await ctx.reply("Usage: `/model <opus|sonnet|haiku>`", { parse_mode: "Markdown" });
+          return;
+        }
+        const sent = sessionManager.sendInput(targetSession.sessionId, `/model ${modelArg}
+`);
+        await ctx.reply(sent ? `Sent /model ${modelArg}` : "Failed - session not connected.");
+        break;
+      }
+      case "/help": {
+        await ctx.reply(
+          `*AFK Code Commands:*
+
+/sessions - List active sessions
+/switch <name> - Switch to a session
+/model <name> - Switch model
+/compact - Compact conversation
+/background - Send Ctrl+B
+/interrupt - Send Escape
+/mode - Toggle mode (Shift+Tab)
+/help - Show this message
+
+_Messages go to the current session (auto-selected if only one)._`,
+          { parse_mode: "Markdown" }
+        );
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return { bot, sessionManager };
+}
+var MAX_MESSAGE_LENGTH;
+var init_telegram_app = __esm({
+  "src/telegram/telegram-app.ts"() {
+    "use strict";
+    init_session_manager();
+    init_message_formatter();
+    MAX_MESSAGE_LENGTH = 4e3;
+  }
+});
+
 // src/cli/run.ts
 import { randomUUID } from "crypto";
 import { homedir } from "os";
@@ -1899,6 +2328,136 @@ async function discordRun() {
   }
 }
 
+// src/cli/telegram.ts
+import { homedir as homedir5 } from "os";
+import { mkdir as mkdir3, writeFile as writeFile3, readFile as readFile4, access as access3 } from "fs/promises";
+import * as readline3 from "readline";
+var CONFIG_DIR3 = `${homedir5()}/.afk-code`;
+var TELEGRAM_CONFIG_FILE = `${CONFIG_DIR3}/telegram.env`;
+function prompt3(question) {
+  const rl = readline3.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+async function fileExists3(path) {
+  try {
+    await access3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function telegramSetup() {
+  console.log(`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502                AFK Code Telegram Setup                       \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+
+This will configure a Telegram bot for monitoring Claude Code sessions.
+
+Step 1: Create a Telegram Bot
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Open Telegram and search for @BotFather
+2. Send /newbot and follow the prompts
+3. Choose a name (e.g., "AFK Code")
+4. Choose a username (e.g., "my_afk_code_bot")
+5. Copy the bot token BotFather gives you
+`);
+  const botToken = await prompt3("Bot Token: ");
+  if (!botToken || !botToken.includes(":")) {
+    console.error("Invalid bot token. It should look like: 123456789:ABCdefGHIjklMNOpqrsTUVwxyz");
+    process.exit(1);
+  }
+  console.log(`
+Step 2: Get Your Chat ID
+\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+1. Start a chat with your new bot in Telegram
+2. Send it any message (e.g., "hello")
+3. Visit this URL in your browser:
+   https://api.telegram.org/bot${botToken}/getUpdates
+4. Find "chat":{"id":YOUR_CHAT_ID} in the response
+5. Copy the numeric chat ID
+`);
+  const chatId = await prompt3("Chat ID: ");
+  if (!chatId || !/^-?\d+$/.test(chatId)) {
+    console.error("Invalid chat ID. It should be a number (can be negative for groups).");
+    process.exit(1);
+  }
+  await mkdir3(CONFIG_DIR3, { recursive: true });
+  const envContent = `# AFK Code Telegram Configuration
+TELEGRAM_BOT_TOKEN=${botToken}
+TELEGRAM_CHAT_ID=${chatId}
+`;
+  await writeFile3(TELEGRAM_CONFIG_FILE, envContent);
+  console.log(`
+Configuration saved to ${TELEGRAM_CONFIG_FILE}
+
+To start the Telegram bot, run:
+  afk-code telegram
+
+Then start a Claude Code session with:
+  afk-code run -- claude
+
+Your bot will send session updates to your Telegram chat!
+`);
+}
+async function loadEnvFile3(path) {
+  if (!await fileExists3(path)) return {};
+  const content = await readFile4(path, "utf-8");
+  const config = {};
+  for (const line of content.split("\n")) {
+    if (line.startsWith("#") || !line.includes("=")) continue;
+    const [key, ...valueParts] = line.split("=");
+    config[key.trim()] = valueParts.join("=").trim();
+  }
+  return config;
+}
+async function telegramRun() {
+  const globalConfig = await loadEnvFile3(TELEGRAM_CONFIG_FILE);
+  const localConfig = await loadEnvFile3(`${process.cwd()}/.env`);
+  const config = {
+    ...globalConfig,
+    ...localConfig
+  };
+  if (process.env.TELEGRAM_BOT_TOKEN) config.TELEGRAM_BOT_TOKEN = process.env.TELEGRAM_BOT_TOKEN;
+  if (process.env.TELEGRAM_CHAT_ID) config.TELEGRAM_CHAT_ID = process.env.TELEGRAM_CHAT_ID;
+  const required = ["TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID"];
+  const missing = required.filter((key) => !config[key]);
+  if (missing.length > 0) {
+    console.error(`Missing config: ${missing.join(", ")}`);
+    console.error("");
+    console.error('Run "afk-code telegram setup" for guided configuration.');
+    process.exit(1);
+  }
+  console.log("[AFK Code] Starting Telegram bot...");
+  const { createTelegramApp: createTelegramApp2 } = await Promise.resolve().then(() => (init_telegram_app(), telegram_app_exports));
+  const telegramConfig = {
+    botToken: config.TELEGRAM_BOT_TOKEN,
+    chatId: config.TELEGRAM_CHAT_ID
+  };
+  const { bot, sessionManager } = createTelegramApp2(telegramConfig);
+  try {
+    await sessionManager.start();
+  } catch (err) {
+    console.error("[AFK Code] Failed to start session manager:", err);
+    process.exit(1);
+  }
+  bot.start({
+    onStart: (botInfo) => {
+      console.log(`[AFK Code] Telegram bot @${botInfo.username} is running!`);
+      console.log("");
+      console.log("Start a Claude Code session with: afk-code run -- claude");
+    }
+  });
+}
+
 // src/cli/index.ts
 var args = process.argv.slice(2);
 var command = args[0];
@@ -1935,34 +2494,45 @@ async function main() {
       }
       break;
     }
+    case "telegram": {
+      if (args[1] === "setup") {
+        await telegramSetup();
+      } else {
+        await telegramRun();
+      }
+      break;
+    }
     case "help":
     case "--help":
     case "-h":
     case void 0: {
       console.log(`
-AFK Code - Monitor Claude Code sessions from Slack/Discord
+AFK Code - Monitor Claude Code sessions from Slack/Discord/Telegram
 
 Commands:
-  slack              Run the Slack bot
-  slack setup        Configure Slack integration
+  telegram           Run the Telegram bot
+  telegram setup     Configure Telegram integration
   discord            Run the Discord bot
   discord setup      Configure Discord integration
-  run -- <command>   Start a monitored session
+  slack              Run the Slack bot
+  slack setup        Configure Slack integration
+  <command> [args]   Start a monitored session
   help               Show this help message
 
 Examples:
-  afk-code slack setup    # First-time Slack configuration
-  afk-code slack          # Start the Slack bot
-  afk-code discord setup  # First-time Discord configuration
-  afk-code discord        # Start the Discord bot
-  afk-code run -- claude  # Start a Claude Code session
+  afk-code telegram setup   # First-time Telegram configuration
+  afk-code telegram         # Start the Telegram bot
+  afk-code discord setup    # First-time Discord configuration
+  afk-code discord          # Start the Discord bot
+  afk-code slack setup      # First-time Slack configuration
+  afk-code slack            # Start the Slack bot
+  afk-code claude           # Start a Claude Code session
 `);
       break;
     }
     default: {
-      console.error(`Unknown command: ${command}`);
-      console.error('Run "afk-code help" for usage');
-      process.exit(1);
+      await run(args);
+      break;
     }
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "afk-code",
-  "version": "0.1.3",
-  "description": "Monitor and interact with Claude Code sessions from Slack/Discord",
+  "version": "0.2.0",
+  "description": "Monitor and interact with Claude Code sessions from Slack/Discord/Telegram",
   "author": "Colin Harman",
   "repository": {
     "type": "git",
@@ -30,14 +30,16 @@
     "claude-code",
     "slack",
     "discord",
+    "telegram",
     "bot",
     "ai",
     "cli"
   ],
   "license": "MIT",
-  "dependencies": {
+"dependencies": {
     "@slack/bolt": "^4.6.0",
     "discord.js": "^14.25.1",
+    "grammy": "^1.35.0",
     "node-pty": "^1.0.0"
   },
   "devDependencies": {

package/slack-manifest.json

@@ -16,9 +16,8 @@
     },
     "slash_commands": [
       {
-        "command": "/afk",
+        "command": "/sessions",
         "description": "List active Claude Code sessions",
-        "usage_hint": "[sessions]",
         "should_escape": false
       },
       {
@@ -35,6 +34,17 @@
         "command": "/mode",
         "description": "Toggle Claude Code mode (Shift+Tab)",
         "should_escape": false
+      },
+      {
+        "command": "/compact",
+        "description": "Compact the Claude Code conversation",
+        "should_escape": false
+      },
+      {
+        "command": "/model",
+        "description": "Switch Claude model (opus, sonnet, haiku)",
+        "usage_hint": "<model>",
+        "should_escape": false
       }
     ]
   },