afk-code 0.1.1 → 0.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin Harman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,129 +1,128 @@
 # AFK Code
 
-Monitor your Claude Code sessions from Slack or Discord. Get notified when Claude needs input, and respond without leaving your chat app.
+Monitor and interact with Claude Code sessions from Slack, Discord, or Telegram. Respond from your phone while AFK.
 
-## How it works
+![square-image](https://github.com/user-attachments/assets/83083b63-9ca2-4ef0-b83d-fcc51bd2fff9)
 
-1. Run `afk-code slack` or `afk-code discord` to start the bot
-2. Run `afk-code run -- claude` to start a monitored Claude Code session
-3. A new thread (Slack) or channel (Discord) is created for the session
-4. All messages are relayed bidirectionally - respond from your phone while AFK
-
-## Installation
+## Quick Start (Slack)
 
 ```bash
-# Install globally via npm
-npm install -g afk-code
-
-# Or run directly with npx
-npx afk-code help
-```
-
-Requires Node.js 18+.
+# 1. Create a Slack app at https://api.slack.com/apps
+#    Click "Create New App" → "From manifest" → paste slack-manifest.json
 
-## Slack Setup
+# 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
 
-### 1. Create a Slack App
+# 3. Configure and run
+npx afk-code slack setup   # Enter your credentials
+npx afk-code slack         # Start the bot
 
-Go to [api.slack.com/apps](https://api.slack.com/apps) and click **Create New App** → **From manifest**.
-
-Paste the contents of `slack-manifest.json` from this repo, then click **Create**.
-
-### 2. Install to Workspace
-
-Click **Install to Workspace** and authorize the app.
-
-### 3. Get Your Credentials
+# 4. In another terminal, start a monitored Claude session
+npx afk-code run -- claude
+```
 
-- **Bot Token**: OAuth & Permissions → Bot User OAuth Token (`xoxb-...`)
-- **App Token**: Basic Information → App-Level Tokens → Generate Token with `connections:write` scope (`xapp-...`)
-- **Signing Secret**: Basic Information → Signing Secret
-- **Your User ID**: In Slack, click your profile → three dots → Copy member ID
+A new channel is created for each session. Messages relay bidirectionally.
 
-### 4. Configure AFK Code
+## Quick Start (Discord)
 
 ```bash
-afk-code slack setup
-```
-
-Follow the prompts to enter your credentials. Config is saved to `~/.afk-code/slack.env`.
+# 1. Create a Discord app at https://discord.com/developers/applications
+#    - Go to Bot → Reset Token → copy it
+#    - Enable "Message Content Intent"
+#    - Go to OAuth2 → URL Generator → select "bot" scope
+#    - Select permissions: Send Messages, Manage Channels, Read Message History
+#    - Open the generated URL to invite the bot
 
-### 5. Run
+# 2. Get your User ID (enable Developer Mode, right-click your name → Copy User ID)
 
-```bash
-# Terminal 1: Start the Slack bot
-afk-code slack
+# 3. Configure and run
+npx afk-code discord setup   # Enter your credentials
+npx afk-code discord         # Start the bot
 
-# Terminal 2: Start a Claude Code session
-afk-code run -- claude
+# 4. In another terminal, start a monitored Claude session
+npx afk-code run -- claude
 ```
 
-A new thread will appear in your Slack channel for each session.
+## Quick Start (Telegram)
 
-## Discord Setup
-
-### 1. Create a Discord Application
+```bash
+# 1. Create a bot with @BotFather on Telegram
+#    - Send /newbot and follow the prompts
+#    - Copy the bot token
 
-Go to [discord.com/developers/applications](https://discord.com/developers/applications) and click **New Application**.
+# 2. Get your Chat ID
+#    - Message your bot, then visit:
+#    - https://api.telegram.org/bot<TOKEN>/getUpdates
+#    - Find "chat":{"id":YOUR_CHAT_ID}
 
-### 2. Create a Bot
+# 3. Configure and run
+npx afk-code telegram setup   # Enter your credentials
+npx afk-code telegram         # Start the bot
 
-- Go to **Bot** in the sidebar
-- Click **Reset Token** and copy it
-- Enable **Message Content Intent** under Privileged Gateway Intents
+# 4. In another terminal, start a monitored Claude session
+npx afk-code run -- claude
+```
 
-### 3. Invite the Bot
+## Commands
 
-- Go to **OAuth2** → **URL Generator**
-- Select scopes: `bot`
-- Select permissions: `Send Messages`, `Manage Channels`, `Read Message History`
-- Open the generated URL to invite the bot to your server
+```
+afk-code slack setup        Configure Slack credentials
+afk-code slack              Run the Slack bot
+afk-code discord setup      Configure Discord credentials
+afk-code discord            Run the Discord bot
+afk-code telegram setup     Configure Telegram credentials
+afk-code telegram           Run the Telegram bot
+afk-code run -- <command>   Start a monitored session
+afk-code help               Show help
+```
 
-### 4. Get Your User ID
+### Slash Commands
 
-Enable Developer Mode in Discord settings, then right-click your name → **Copy User ID**.
+| 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) |
 
-### 5. Configure AFK Code
+## Installation Options
 
 ```bash
-afk-code discord setup
-```
-
-Enter your bot token and user ID. Config is saved to `~/.afk-code/discord.env`.
+# Global install
+npm install -g afk-code
 
-### 6. Run
+# Or use npx (no install)
+npx afk-code <command>
 
-```bash
-# Terminal 1: Start the Discord bot
-afk-code discord
-
-# Terminal 2: Start a Claude Code session
-afk-code run -- claude
+# Or run from source
+git clone https://github.com/clharman/afk-code.git
+cd afk-code && npm install
+npm run dev -- slack
+npm run dev -- run -- claude
 ```
 
-An "AFK Code Sessions" category will be created with a channel for each session.
+Requires Node.js 18+.
 
-## Commands
+## How It Works
 
-```
-afk-code run -- <command>   Start a monitored session (e.g., afk-code run -- claude)
-afk-code slack              Run the Slack bot
-afk-code slack setup        Configure Slack credentials
-afk-code discord            Run the Discord bot
-afk-code discord setup      Configure Discord credentials
-afk-code help               Show help
-```
+1. `afk-code slack`, `afk-code discord`, or `afk-code telegram` 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
+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
 
-## How It Works
+## Limitations
 
-AFK Code watches Claude Code's JSONL output files to capture messages in real-time. When you start a session with `afk-code run`, it:
+- Does not support plan mode or responding to Claude Code's form-based questions (AskUserQuestion)
+- Does not send tool calls or results
 
-1. Spawns the command in a PTY (pseudo-terminal)
-2. Connects to the running Slack/Discord bot via Unix socket
-3. Watches the Claude Code JSONL file for new messages
-4. Relays messages bidirectionally between terminal and chat
+## Disclaimer
 
-Messages you send in Slack/Discord threads are forwarded to the terminal as if you typed them.
+This project is not affiliated with Anthropic. Use at your own risk.
 
 ## License
 

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,345 @@ 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") {
+    messageQueue.push(async () => {
+      try {
+        await bot.api.sendMessage(config.chatId, text, { parse_mode: parseMode });
+      } catch (err) {
+        if (parseMode && err.message?.includes("parse")) {
+          await bot.api.sendMessage(config.chatId, text);
+        } else {
+          throw err;
+        }
+      }
+    });
+    processQueue();
+  }
+  async function sendChunkedMessage(text, prefix) {
+    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);
+    }
+  }
+  const sessionManager = new SessionManager({
+    onSessionStart: async (session) => {
+      activeSessions.set(session.id, {
+        sessionId: session.id,
+        sessionName: session.name,
+        lastActivity: /* @__PURE__ */ new Date()
+      });
+      await sendMessage(
+        `*[${session.name}]* ${formatSessionStatus(session.status)}
+Session started
+\`${session.cwd}\``
+      );
+    },
+    onSessionEnd: async (sessionId) => {
+      const tracking = activeSessions.get(sessionId);
+      const name = tracking?.sessionName || sessionId;
+      activeSessions.delete(sessionId);
+      await sendMessage(`*[${name}]* Session ended`);
+    },
+    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, `*[${tracking.sessionName}]* *User:*`);
+      } else {
+        await sendChunkedMessage(content, `*[${tracking.sessionName}]* *Claude:*`);
+      }
+    },
+    onTodos: async (sessionId, todos) => {
+      const tracking = activeSessions.get(sessionId);
+      if (!tracking || todos.length === 0) return;
+      const todosText = formatTodos(todos);
+      await sendMessage(`*[${tracking.sessionName}]* *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(`*[${tracking.sessionName}]* ${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";
@@ -1573,7 +1996,9 @@ async function run(command2) {
       if (process.stdin.isTTY) {
         process.stdin.setRawMode(false);
       }
-      process.stdin.unref();
+      if (typeof process.stdin.unref === "function") {
+        process.stdin.unref();
+      }
       daemon?.close();
       resolve2();
     });
@@ -1897,6 +2322,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];
@@ -1933,27 +2488,39 @@ 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
   discord            Run the Discord bot
   discord setup      Configure Discord integration
+  telegram           Run the Telegram bot
+  telegram setup     Configure Telegram integration
   run -- <command>   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 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 telegram setup   # First-time Telegram configuration
+  afk-code telegram         # Start the Telegram bot
+  afk-code run -- claude    # Start a Claude Code session
 `);
       break;
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "afk-code",
-  "version": "0.1.1",
-  "description": "Monitor and interact with Claude Code sessions from Slack/Discord",
+  "version": "0.1.4",
+  "description": "Monitor and interact with Claude Code sessions from Slack/Discord/Telegram",
   "author": "Colin Harman",
   "repository": {
     "type": "git",
@@ -14,7 +14,8 @@
   "scripts": {
     "build": "tsup",
     "dev": "tsx src/cli/index.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "postinstall": "node -e \"const fs = require('fs'); const path = require('path'); const dir = path.dirname(path.dirname(require.resolve('node-pty'))); const prebuilds = path.join(dir, 'prebuilds'); if (fs.existsSync(prebuilds)) { fs.readdirSync(prebuilds).forEach(p => { const helper = path.join(prebuilds, p, 'spawn-helper'); if (fs.existsSync(helper)) fs.chmodSync(helper, 0o755); }); }\""
   },
   "files": [
     "dist",
@@ -29,6 +30,7 @@
     "claude-code",
     "slack",
     "discord",
+    "telegram",
     "bot",
     "ai",
     "cli"
@@ -37,6 +39,7 @@
   "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
       }
     ]
   },