afk-code 0.1.0

package/src/discord/discord-app.ts

@@ -0,0 +1,359 @@
+import { Client, GatewayIntentBits, Events, ChannelType, AttachmentBuilder, REST, Routes, SlashCommandBuilder } from 'discord.js';
+import type { DiscordConfig } from './types';
+import { SessionManager, type SessionInfo, type ToolCallInfo, type ToolResultInfo } from '../slack/session-manager';
+import { ChannelManager } from './channel-manager';
+import { markdownToSlack, chunkMessage, formatSessionStatus, formatTodos } from '../slack/message-formatter';
+import { extractImagePaths } from '../utils/image-extractor';
+
+export function createDiscordApp(config: DiscordConfig) {
+  const client = new Client({
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+    ],
+  });
+
+  const channelManager = new ChannelManager(client, config.userId);
+
+  // Track messages sent from Discord to avoid re-posting
+  const discordSentMessages = new Set<string>();
+
+  // Track tool call messages for threading results
+  const toolCallMessages = new Map<string, string>(); // toolUseId -> message id
+
+  // Create session manager with event handlers that post to Discord
+  const sessionManager = new SessionManager({
+    onSessionStart: async (session) => {
+      const channel = await channelManager.createChannel(session.id, session.name, session.cwd);
+      if (channel) {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType.GuildText) {
+          await discordChannel.send(
+            `${formatSessionStatus(session.status)} **Session started**\n\`${session.cwd}\``
+          );
+        }
+      }
+    },
+
+    onSessionEnd: async (sessionId) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, 'ended');
+
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType.GuildText) {
+          await discordChannel.send('🛑 **Session ended** - this channel will be archived');
+        }
+
+        await channelManager.archiveChannel(sessionId);
+      }
+    },
+
+    onSessionUpdate: async (sessionId, name) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateName(sessionId, name);
+        // Update channel topic
+        try {
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType.GuildText) {
+            await discordChannel.setTopic(`Claude Code session: ${name}`);
+          }
+        } catch (err) {
+          console.error('[Discord] Failed to update channel topic:', err);
+        }
+      }
+    },
+
+    onSessionStatus: async (sessionId, status) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        channelManager.updateStatus(sessionId, status);
+      }
+    },
+
+    onMessage: async (sessionId, role, content) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel) {
+        // Discord markdown is similar to Slack's mrkdwn but uses standard markdown
+        const formatted = content; // Discord uses standard markdown
+
+        if (role === 'user') {
+          // Skip messages that originated from Discord
+          const contentKey = content.trim();
+          if (discordSentMessages.has(contentKey)) {
+            discordSentMessages.delete(contentKey);
+            return;
+          }
+
+          // User message from terminal
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType.GuildText) {
+            const chunks = chunkMessage(formatted);
+            for (const chunk of chunks) {
+              await discordChannel.send(`**User:** ${chunk}`);
+            }
+          }
+        } else {
+          // Claude's response
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType.GuildText) {
+            const chunks = chunkMessage(formatted);
+            for (const chunk of chunks) {
+              await discordChannel.send(chunk);
+            }
+
+            // Extract and upload any images mentioned in the response
+            const session = sessionManager.getSession(sessionId);
+            const images = extractImagePaths(content, session?.cwd);
+            for (const image of images) {
+              try {
+                console.log(`[Discord] Uploading image: ${image.resolvedPath}`);
+                const attachment = new AttachmentBuilder(image.resolvedPath);
+                await discordChannel.send({
+                  content: `📎 ${image.originalPath}`,
+                  files: [attachment],
+                });
+              } catch (err) {
+                console.error('[Discord] Failed to upload image:', err);
+              }
+            }
+          }
+        }
+      }
+    },
+
+    onTodos: async (sessionId, todos) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (channel && todos.length > 0) {
+        const todosText = formatTodos(todos);
+        try {
+          const discordChannel = await client.channels.fetch(channel.channelId);
+          if (discordChannel?.type === ChannelType.GuildText) {
+            await discordChannel.send(`**Tasks:**\n${todosText}`);
+          }
+        } catch (err) {
+          console.error('[Discord] Failed to post todos:', err);
+        }
+      }
+    },
+
+    onToolCall: async (sessionId, tool) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+
+      // Format tool call summary
+      let inputSummary = '';
+      if (tool.name === 'Bash' && tool.input.command) {
+        inputSummary = `\`${tool.input.command.slice(0, 100)}${tool.input.command.length > 100 ? '...' : ''}\``;
+      } else if (tool.name === 'Read' && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === 'Edit' && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === 'Write' && tool.input.file_path) {
+        inputSummary = `\`${tool.input.file_path}\``;
+      } else if (tool.name === 'Grep' && tool.input.pattern) {
+        inputSummary = `\`${tool.input.pattern}\``;
+      } else if (tool.name === 'Glob' && tool.input.pattern) {
+        inputSummary = `\`${tool.input.pattern}\``;
+      } else if (tool.name === 'Task' && tool.input.description) {
+        inputSummary = tool.input.description;
+      }
+
+      const text = inputSummary
+        ? `🔧 **${tool.name}**: ${inputSummary}`
+        : `🔧 **${tool.name}**`;
+
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType.GuildText) {
+          const message = await discordChannel.send(text);
+          // Store the message id for threading results
+          toolCallMessages.set(tool.id, message.id);
+        }
+      } catch (err) {
+        console.error('[Discord] Failed to post tool call:', err);
+      }
+    },
+
+    onToolResult: async (sessionId, result) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+
+      const parentMessageId = toolCallMessages.get(result.toolUseId);
+      if (!parentMessageId) return; // No parent message to reply to
+
+      // Truncate long results
+      const maxLen = 1800; // Discord has 2000 char limit
+      let content = result.content;
+      if (content.length > maxLen) {
+        content = content.slice(0, maxLen) + '\n... (truncated)';
+      }
+
+      const prefix = result.isError ? '❌ Error:' : '✅ Result:';
+      const text = `${prefix}\n\`\`\`\n${content}\n\`\`\``;
+
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType.GuildText) {
+          // Fetch the parent message and create a thread
+          const parentMessage = await discordChannel.messages.fetch(parentMessageId);
+          if (parentMessage) {
+            // Create a thread if one doesn't exist, or use existing
+            let thread = parentMessage.thread;
+            if (!thread) {
+              thread = await parentMessage.startThread({
+                name: 'Result',
+                autoArchiveDuration: 60,
+              });
+            }
+            await thread.send(text);
+          }
+
+          // Clean up the mapping
+          toolCallMessages.delete(result.toolUseId);
+        }
+      } catch (err) {
+        console.error('[Discord] Failed to post tool result:', err);
+      }
+    },
+
+    onPlanModeChange: async (sessionId, inPlanMode) => {
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel) return;
+
+      const emoji = inPlanMode ? '📋' : '🔨';
+      const status = inPlanMode ? 'Planning mode - Claude is designing a solution' : 'Execution mode - Claude is implementing';
+
+      try {
+        const discordChannel = await client.channels.fetch(channel.channelId);
+        if (discordChannel?.type === ChannelType.GuildText) {
+          await discordChannel.send(`${emoji} ${status}`);
+        }
+      } catch (err) {
+        console.error('[Discord] Failed to post plan mode change:', err);
+      }
+    },
+  });
+
+  // Handle messages in session channels (user sending input to Claude)
+  client.on(Events.MessageCreate, async (message) => {
+    // Ignore bot's own messages
+    if (message.author.bot) return;
+
+    // Ignore DMs
+    if (!message.guild) return;
+
+    const sessionId = channelManager.getSessionByChannel(message.channelId);
+    if (!sessionId) return; // Not a session channel
+
+    const channel = channelManager.getChannel(sessionId);
+    if (!channel || channel.status === 'ended') {
+      await message.reply('⚠️ This session has ended.');
+      return;
+    }
+
+    console.log(`[Discord] Sending input to session ${sessionId}: ${message.content.slice(0, 50)}...`);
+
+    // Track this message so we don't re-post it
+    discordSentMessages.add(message.content.trim());
+
+    const sent = sessionManager.sendInput(sessionId, message.content);
+    if (!sent) {
+      discordSentMessages.delete(message.content.trim());
+      await message.reply('⚠️ Failed to send input - session not connected.');
+    }
+  });
+
+  // When bot is ready
+  client.once(Events.ClientReady, async (c) => {
+    console.log(`[Discord] Logged in as ${c.user.tag}`);
+    await channelManager.initialize();
+
+    // Register slash commands
+    const commands = [
+      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'),
+    ];
+
+    try {
+      const rest = new REST({ version: '10' }).setToken(config.botToken);
+      await rest.put(Routes.applicationCommands(c.user.id), {
+        body: commands.map((cmd) => cmd.toJSON()),
+      });
+      console.log('[Discord] Slash commands registered');
+    } catch (err) {
+      console.error('[Discord] Failed to register slash commands:', err);
+    }
+  });
+
+  // Handle slash commands
+  client.on(Events.InteractionCreate, async (interaction) => {
+    if (!interaction.isChatInputCommand()) return;
+
+    const { commandName, channelId } = interaction;
+
+    if (commandName === 'afk') {
+      const active = channelManager.getAllActive();
+      if (active.length === 0) {
+        await interaction.reply('No active sessions. Start a session with `afk-code run -- claude`');
+        return;
+      }
+
+      const text = active
+        .map((c) => `<#${c.channelId}> - ${formatSessionStatus(c.status)}`)
+        .join('\n');
+
+      await interaction.reply(`**Active Sessions:**\n${text}`);
+      return;
+    }
+
+    if (commandName === 'background' || commandName === 'interrupt' || commandName === 'mode') {
+      const sessionId = channelManager.getSessionByChannel(channelId);
+      if (!sessionId) {
+        await interaction.reply('⚠️ This channel is not associated with an active session.');
+        return;
+      }
+
+      const channel = channelManager.getChannel(sessionId);
+      if (!channel || channel.status === 'ended') {
+        await interaction.reply('⚠️ This session has ended.');
+        return;
+      }
+
+      // Send the appropriate escape sequence
+      let key: string;
+      let message: string;
+      if (commandName === 'background') {
+        key = '\x02'; // Ctrl+B
+        message = '⬇️ Sent background command (Ctrl+B)';
+      } else if (commandName === 'interrupt') {
+        key = '\x1b'; // Escape
+        message = '🛑 Sent interrupt (Escape)';
+      } else {
+        key = '\x1b[Z'; // Shift+Tab
+        message = '🔄 Sent mode toggle (Shift+Tab)';
+      }
+
+      const sent = sessionManager.sendInput(sessionId, key);
+      if (sent) {
+        await interaction.reply(message);
+      } else {
+        await interaction.reply('⚠️ Failed to send command - session not connected.');
+      }
+    }
+  });
+
+  return { client, sessionManager, channelManager };
+}

package/src/discord/types.ts

@@ -0,0 +1,4 @@
+export interface DiscordConfig {
+  botToken: string;
+  userId: string; // User to notify
+}

package/src/slack/channel-manager.ts

@@ -0,0 +1,175 @@
+import type { WebClient } from '@slack/web-api';
+
+export interface ChannelMapping {
+  sessionId: string;
+  channelId: string;
+  channelName: string;
+  sessionName: string;
+  status: 'running' | 'idle' | 'ended';
+  createdAt: Date;
+}
+
+/**
+ * Sanitize a string for use as a Slack channel name.
+ * Rules: lowercase, no spaces, max 80 chars, only letters/numbers/hyphens/underscores
+ */
+function sanitizeChannelName(name: string): string {
+  return name
+    .toLowerCase()
+    .replace(/[^a-z0-9-_\s]/g, '') // Remove invalid chars
+    .replace(/\s+/g, '-') // Spaces to hyphens
+    .replace(/-+/g, '-') // Collapse multiple hyphens
+    .replace(/^-|-$/g, '') // Trim hyphens from ends
+    .slice(0, 70); // Leave room for "afk-" prefix and uniqueness suffix
+}
+
+export class ChannelManager {
+  private channels = new Map<string, ChannelMapping>();
+  private channelToSession = new Map<string, string>();
+  private client: WebClient;
+  private userId: string;
+
+  constructor(client: WebClient, userId: string) {
+    this.client = client;
+    this.userId = userId;
+  }
+
+  async createChannel(
+    sessionId: string,
+    sessionName: string,
+    cwd: string
+  ): Promise<ChannelMapping | null> {
+    // Check if channel already exists for this session
+    if (this.channels.has(sessionId)) {
+      return this.channels.get(sessionId)!;
+    }
+
+    // Extract just the folder name from the path
+    const folderName = cwd.split('/').filter(Boolean).pop() || 'session';
+    const baseName = `afk-${sanitizeChannelName(folderName)}`;
+
+    // Try to create channel, incrementing suffix if name is taken
+    let channelName = baseName;
+    let suffix = 1;
+    let result;
+
+    while (true) {
+      // Ensure max 80 chars
+      const nameToTry = channelName.length > 80 ? channelName.slice(0, 80) : channelName;
+
+      try {
+        result = await this.client.conversations.create({
+          name: nameToTry,
+          is_private: true,
+        });
+        channelName = nameToTry;
+        break; // Success!
+      } catch (err: any) {
+        if (err.data?.error === 'name_taken') {
+          // Try next number
+          suffix++;
+          channelName = `${baseName}-${suffix}`;
+        } else {
+          throw err; // Different error, rethrow
+        }
+      }
+    }
+
+    if (!result?.channel?.id) {
+      console.error('[ChannelManager] Failed to create channel - no ID returned');
+      return null;
+    }
+
+    const mapping: ChannelMapping = {
+      sessionId,
+      channelId: result.channel.id,
+      channelName,
+      sessionName,
+      status: 'running',
+      createdAt: new Date(),
+    };
+
+    this.channels.set(sessionId, mapping);
+    this.channelToSession.set(result.channel.id, sessionId);
+
+    // Set channel topic
+    try {
+      await this.client.conversations.setTopic({
+        channel: result.channel.id,
+        topic: `Claude Code session: ${sessionName}`,
+      });
+    } catch (err: any) {
+      console.error('[ChannelManager] Failed to set topic:', err.message);
+    }
+
+    // Invite user to channel
+    if (this.userId) {
+      try {
+        await this.client.conversations.invite({
+          channel: result.channel.id,
+          users: this.userId,
+        });
+        console.log(`[ChannelManager] Invited user to channel`);
+      } catch (err: any) {
+        // Ignore "already_in_channel" error
+        if (err.data?.error !== 'already_in_channel') {
+          console.error('[ChannelManager] Failed to invite user:', err.message);
+        }
+      }
+    }
+
+    console.log(`[ChannelManager] Created channel #${channelName} for session ${sessionId}`);
+    return mapping;
+  }
+
+  async archiveChannel(sessionId: string): Promise<boolean> {
+    const mapping = this.channels.get(sessionId);
+    if (!mapping) return false;
+
+    try {
+      // Rename channel before archiving to free up the name for reuse
+      const timestamp = Date.now().toString(36);
+      const archivedName = `${mapping.channelName}-archived-${timestamp}`.slice(0, 80);
+
+      await this.client.conversations.rename({
+        channel: mapping.channelId,
+        name: archivedName,
+      });
+
+      await this.client.conversations.archive({
+        channel: mapping.channelId,
+      });
+      console.log(`[ChannelManager] Archived channel #${mapping.channelName}`);
+      return true;
+    } catch (err: any) {
+      console.error('[ChannelManager] Failed to archive channel:', err.message);
+      return false;
+    }
+  }
+
+  getChannel(sessionId: string): ChannelMapping | undefined {
+    return this.channels.get(sessionId);
+  }
+
+  getSessionByChannel(channelId: string): string | undefined {
+    return this.channelToSession.get(channelId);
+  }
+
+  updateStatus(sessionId: string, status: 'running' | 'idle' | 'ended'): void {
+    const mapping = this.channels.get(sessionId);
+    if (mapping) {
+      mapping.status = status;
+    }
+  }
+
+  updateName(sessionId: string, name: string): void {
+    const mapping = this.channels.get(sessionId);
+    if (mapping) {
+      mapping.sessionName = name;
+    }
+  }
+
+  getAllActive(): ChannelMapping[] {
+    return Array.from(this.channels.values()).filter((c) => c.status !== 'ended');
+  }
+}

package/src/slack/index.ts

@@ -0,0 +1,58 @@
+import { createSlackApp } from './slack-app';
+import type { SlackConfig } from './types';
+
+async function main() {
+  const config: SlackConfig = {
+    botToken: process.env.SLACK_BOT_TOKEN || '',
+    appToken: process.env.SLACK_APP_TOKEN || '',
+    signingSecret: process.env.SLACK_SIGNING_SECRET || '',
+    userId: process.env.SLACK_USER_ID || '',
+  };
+
+  // Validate required config
+  const required: (keyof SlackConfig)[] = ['botToken', 'appToken', 'userId'];
+
+  const missing = required.filter((key) => !config[key]);
+  if (missing.length > 0) {
+    console.error(`[Slack] Missing required config: ${missing.join(', ')}`);
+    console.error('');
+    console.error('Required environment variables:');
+    console.error('  SLACK_BOT_TOKEN     - Bot User OAuth Token (xoxb-...)');
+    console.error('  SLACK_APP_TOKEN     - App-Level Token for Socket Mode (xapp-...)');
+    console.error('  SLACK_USER_ID       - Your Slack user ID (U...)');
+    console.error('');
+    console.error('Optional:');
+    console.error('  SLACK_SIGNING_SECRET - Signing secret (for request verification)');
+    process.exit(1);
+  }
+
+  console.log('[Slack] Starting AFK Code bot...');
+
+  const { app, sessionManager } = createSlackApp(config);
+
+  // Start session manager (Unix socket server for CLI connections)
+  try {
+    await sessionManager.start();
+    console.log('[Slack] Session manager started');
+  } catch (err) {
+    console.error('[Slack] Failed to start session manager:', err);
+    process.exit(1);
+  }
+
+  // Start Slack app
+  try {
+    await app.start();
+    console.log('[Slack] Bot is running!');
+    console.log('');
+    console.log('Start a Claude Code session with: afk-code run -- claude');
+    console.log('Each session will create a private #afk-* channel');
+  } catch (err) {
+    console.error('[Slack] Failed to start app:', err);
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('[Slack] Fatal error:', err);
+  process.exit(1);
+});

package/src/slack/message-formatter.ts

@@ -0,0 +1,91 @@
+import type { TodoItem } from '../types';
+
+/**
+ * Convert GitHub-flavored markdown to Slack mrkdwn format
+ */
+export function markdownToSlack(markdown: string): string {
+  let text = markdown;
+
+  // Bold: **text** -> *text*
+  text = text.replace(/\*\*(.+?)\*\*/g, '*$1*');
+
+  // Headers: # Header -> *Header*
+  text = text.replace(/^#{1,6}\s+(.+)$/gm, '*$1*');
+
+  // Links: [text](url) -> <url|text>
+  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<$2|$1>');
+
+  // Strikethrough: ~~text~~ -> ~text~
+  text = text.replace(/~~(.+?)~~/g, '~$1~');
+
+  return text;
+}
+
+/**
+ * Split long messages to fit within Slack's 40k char limit
+ */
+export function chunkMessage(text: string, maxLength = 39000): string[] {
+  if (text.length <= maxLength) return [text];
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // Find a good break point (newline or space)
+    let breakPoint = remaining.lastIndexOf('\n', maxLength);
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = remaining.lastIndexOf(' ', maxLength);
+    }
+    if (breakPoint === -1 || breakPoint < maxLength / 2) {
+      breakPoint = maxLength;
+    }
+
+    chunks.push(remaining.slice(0, breakPoint));
+    remaining = remaining.slice(breakPoint).trimStart();
+  }
+
+  return chunks;
+}
+
+/**
+ * Format session status with emoji
+ */
+export function formatSessionStatus(status: 'running' | 'idle' | 'ended'): string {
+  const icons: Record<string, string> = {
+    running: ':hourglass_flowing_sand:',
+    idle: ':white_check_mark:',
+    ended: ':stop_sign:',
+  };
+  const labels: Record<string, string> = {
+    running: 'Running',
+    idle: 'Idle',
+    ended: 'Ended',
+  };
+  return `${icons[status]} ${labels[status]}`;
+}
+
+/**
+ * Format todo list with status icons
+ */
+export function formatTodos(todos: TodoItem[]): string {
+  if (todos.length === 0) return '';
+
+  const icons: Record<string, string> = {
+    pending: ':white_circle:',
+    in_progress: ':large_blue_circle:',
+    completed: ':white_check_mark:',
+  };
+
+  return todos
+    .map((t) => {
+      const icon = icons[t.status] || ':white_circle:';
+      const text = t.status === 'in_progress' && t.activeForm ? t.activeForm : t.content;
+      return `${icon} ${text}`;
+    })
+    .join('\n');
+}