afk-code 0.1.0

package/README.md

@@ -0,0 +1,134 @@
+# AFK Code
+
+Monitor your Claude Code sessions from Slack or Discord. Get notified when Claude needs input, and respond without leaving your chat app.
+
+## How it works
+
+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
+
+```bash
+# Clone the repo
+git clone https://github.com/clharman/afk-code.git
+cd afk-code
+
+# Install dependencies
+bun install
+
+# Link the CLI globally (optional)
+bun link
+```
+
+Requires [Bun](https://bun.sh) runtime.
+
+## Slack Setup
+
+### 1. Create a Slack App
+
+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
+
+- **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
+
+### 4. Configure AFK Code
+
+```bash
+afk-code slack setup
+```
+
+Follow the prompts to enter your credentials. Config is saved to `~/.afk-code/slack.env`.
+
+### 5. Run
+
+```bash
+# Terminal 1: Start the Slack bot
+afk-code slack
+
+# Terminal 2: Start a Claude Code session
+afk-code run -- claude
+```
+
+A new thread will appear in your Slack channel for each session.
+
+## Discord Setup
+
+### 1. Create a Discord Application
+
+Go to [discord.com/developers/applications](https://discord.com/developers/applications) and click **New Application**.
+
+### 2. Create a Bot
+
+- Go to **Bot** in the sidebar
+- Click **Reset Token** and copy it
+- Enable **Message Content Intent** under Privileged Gateway Intents
+
+### 3. Invite the Bot
+
+- 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
+
+### 4. Get Your User ID
+
+Enable Developer Mode in Discord settings, then right-click your name → **Copy User ID**.
+
+### 5. Configure AFK Code
+
+```bash
+afk-code discord setup
+```
+
+Enter your bot token and user ID. Config is saved to `~/.afk-code/discord.env`.
+
+### 6. Run
+
+```bash
+# Terminal 1: Start the Discord bot
+afk-code discord
+
+# Terminal 2: Start a Claude Code session
+afk-code run -- claude
+```
+
+An "AFK Code Sessions" category will be created with a channel for each session.
+
+## Commands
+
+```
+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
+```
+
+## How It Works
+
+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:
+
+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
+
+Messages you send in Slack/Discord threads are forwarded to the terminal as if you typed them.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "afk-code",
+  "version": "0.1.0",
+  "description": "Monitor and interact with Claude Code sessions from Slack/Discord",
+  "author": "Colin Harman",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clharman/afk-code.git"
+  },
+  "type": "module",
+  "bin": {
+    "afk-code": "./src/cli/index.ts"
+  },
+  "scripts": {
+    "dev": "bun run src/cli/index.ts",
+    "test": "bun test"
+  },
+  "files": [
+    "src",
+    "slack-manifest.json",
+    "README.md"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "slack",
+    "discord",
+    "bot",
+    "ai",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@slack/bolt": "^4.6.0",
+    "@zenyr/bun-pty": "^0.4.4",
+    "discord.js": "^14.25.1"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.0.0"
+  }
+}

package/slack-manifest.json

@@ -0,0 +1,70 @@
+{
+  "display_information": {
+    "name": "AFK Code",
+    "description": "Monitor and interact with Claude Code sessions from Slack",
+    "background_color": "#4a154b"
+  },
+  "features": {
+    "app_home": {
+      "home_tab_enabled": true,
+      "messages_tab_enabled": false,
+      "messages_tab_read_only_enabled": false
+    },
+    "bot_user": {
+      "display_name": "AFK Code",
+      "always_online": true
+    },
+    "slash_commands": [
+      {
+        "command": "/afk",
+        "description": "List active Claude Code sessions",
+        "usage_hint": "[sessions]",
+        "should_escape": false
+      },
+      {
+        "command": "/background",
+        "description": "Send Claude to background mode (Ctrl+B)",
+        "should_escape": false
+      },
+      {
+        "command": "/interrupt",
+        "description": "Interrupt Claude (Escape)",
+        "should_escape": false
+      },
+      {
+        "command": "/mode",
+        "description": "Toggle Claude mode (Shift+Tab)",
+        "should_escape": false
+      }
+    ]
+  },
+  "oauth_config": {
+    "scopes": {
+      "bot": [
+        "channels:history",
+        "channels:read",
+        "chat:write",
+        "chat:write.customize",
+        "commands",
+        "groups:history",
+        "groups:write",
+        "users:read"
+      ]
+    }
+  },
+  "settings": {
+    "event_subscriptions": {
+      "bot_events": [
+        "app_home_opened",
+        "message.channels",
+        "message.groups"
+      ]
+    },
+    "interactivity": {
+      "is_enabled": false
+    },
+    "org_deploy_enabled": false,
+    "socket_mode_enabled": true,
+    "token_rotation_enabled": false
+  }
+}

package/src/cli/discord.ts

@@ -0,0 +1,183 @@
+import { homedir } from 'os';
+import { mkdir } from 'fs/promises';
+import * as readline from 'readline';
+
+const CONFIG_DIR = `${homedir()}/.afk-code`;
+const DISCORD_CONFIG_FILE = `${CONFIG_DIR}/discord.env`;
+
+function prompt(question: string): Promise<string> {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+export async function discordSetup(): Promise<void> {
+  console.log(`
+┌─────────────────────────────────────────────────────────────┐
+│                 AFK Code Discord Setup                      │
+└─────────────────────────────────────────────────────────────┘
+
+This will guide you through setting up the Discord bot for
+monitoring Claude Code sessions.
+
+Step 1: Create a Discord Application
+────────────────────────────────────
+1. Go to: https://discord.com/developers/applications
+2. Click "New Application"
+3. Give it a name (e.g., "AFK Code")
+4. Click "Create"
+
+Step 2: Create a Bot
+────────────────────
+1. Go to "Bot" in the sidebar
+2. Click "Add Bot" → "Yes, do it!"
+3. Under "Privileged Gateway Intents", enable:
+   • MESSAGE CONTENT INTENT
+4. Click "Reset Token" and copy the token
+
+Step 3: Invite the Bot
+──────────────────────
+1. Go to "OAuth2" → "URL Generator"
+2. Select scopes: "bot"
+3. Select permissions:
+   • Send Messages
+   • Manage Channels
+   • Read Message History
+4. Copy the URL and open it to invite the bot to your server
+`);
+
+  await prompt('Press Enter when you have created and invited the bot...');
+
+  console.log(`
+Now let's collect your credentials:
+
+• Bot Token: "Bot" → "Token" (click "Reset Token" if needed)
+• Your User ID: Enable Developer Mode in Discord settings,
+  then right-click your name → "Copy User ID"
+`);
+
+  const botToken = await prompt('Bot Token: ');
+  if (!botToken || botToken.length < 50) {
+    console.error('Invalid bot token.');
+    process.exit(1);
+  }
+
+  const userId = await prompt('Your Discord User ID: ');
+  if (!userId || !/^\d+$/.test(userId)) {
+    console.error('Invalid user ID. Should be a number.');
+    process.exit(1);
+  }
+
+  // Save configuration
+  await mkdir(CONFIG_DIR, { recursive: true });
+
+  const envContent = `# AFK Code Discord Configuration
+DISCORD_BOT_TOKEN=${botToken}
+DISCORD_USER_ID=${userId}
+`;
+
+  await Bun.write(DISCORD_CONFIG_FILE, envContent);
+  console.log(`
+✓ Configuration saved to ${DISCORD_CONFIG_FILE}
+
+To start the Discord bot, run:
+  afk-code discord
+
+Then start a Claude Code session with:
+  afk-code run -- claude
+`);
+}
+
+async function loadEnvFile(path: string): Promise<Record<string, string>> {
+  const file = Bun.file(path);
+  if (!(await file.exists())) return {};
+
+  const content = await file.text();
+  const config: Record<string, string> = {};
+
+  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;
+}
+
+export async function discordRun(): Promise<void> {
+  // Load config from multiple sources (in order of precedence):
+  // 1. Environment variables (highest priority)
+  // 2. Local .env file
+  // 3. ~/.afk-code/discord.env (lowest priority)
+
+  const globalConfig = await loadEnvFile(DISCORD_CONFIG_FILE);
+  const localConfig = await loadEnvFile(`${process.cwd()}/.env`);
+
+  // Merge configs (local overrides global, env vars override both)
+  const config: Record<string, string> = {
+    ...globalConfig,
+    ...localConfig,
+  };
+
+  // Environment variables take highest precedence
+  if (process.env.DISCORD_BOT_TOKEN) config.DISCORD_BOT_TOKEN = process.env.DISCORD_BOT_TOKEN;
+  if (process.env.DISCORD_USER_ID) config.DISCORD_USER_ID = process.env.DISCORD_USER_ID;
+
+  // Validate required config
+  const required = ['DISCORD_BOT_TOKEN', 'DISCORD_USER_ID'];
+  const missing = required.filter((key) => !config[key]);
+
+  if (missing.length > 0) {
+    console.error(`Missing config: ${missing.join(', ')}`);
+    console.error('');
+    console.error('Provide tokens via:');
+    console.error('  - Environment variables (DISCORD_BOT_TOKEN, DISCORD_USER_ID)');
+    console.error('  - Local .env file');
+    console.error('  - Run "afk-code discord setup" for guided configuration');
+    process.exit(1);
+  }
+
+  // Import and run the discord bot
+  const { createDiscordApp } = await import('../discord/discord-app');
+
+  // Show where config was loaded from
+  const localEnvExists = await Bun.file(`${process.cwd()}/.env`).exists();
+  const globalEnvExists = await Bun.file(DISCORD_CONFIG_FILE).exists();
+  const source = localEnvExists ? '.env' : globalEnvExists ? DISCORD_CONFIG_FILE : 'environment';
+  console.log(`[AFK Code] Loaded config from ${source}`);
+  console.log('[AFK Code] Starting Discord bot...');
+
+  const discordConfig = {
+    botToken: config.DISCORD_BOT_TOKEN,
+    userId: config.DISCORD_USER_ID,
+  };
+
+  const { client, sessionManager } = createDiscordApp(discordConfig);
+
+  // Start session manager (Unix socket server for CLI connections)
+  try {
+    await sessionManager.start();
+    console.log('[AFK Code] Session manager started');
+  } catch (err) {
+    console.error('[AFK Code] Failed to start session manager:', err);
+    process.exit(1);
+  }
+
+  // Start Discord bot
+  try {
+    await client.login(config.DISCORD_BOT_TOKEN);
+    console.log('[AFK Code] Discord bot is running!');
+    console.log('');
+    console.log('Start a Claude Code session with: afk-code run -- claude');
+    console.log('Each session will create an #afk-* channel');
+  } catch (err) {
+    console.error('[AFK Code] Failed to start Discord bot:', err);
+    process.exit(1);
+  }
+}

package/src/cli/index.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+
+import { run } from './run';
+import { slackSetup, slackRun } from './slack';
+import { discordSetup, discordRun } from './discord';
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+async function main() {
+  switch (command) {
+    case 'run': {
+      // Find -- separator and get command after it
+      const separatorIndex = args.indexOf('--');
+      if (separatorIndex === -1) {
+        console.error('Usage: afk-code run -- <command> [args...]');
+        console.error('Example: afk-code run -- claude');
+        process.exit(1);
+      }
+      const cmd = args.slice(separatorIndex + 1);
+      if (cmd.length === 0) {
+        console.error('No command specified after --');
+        process.exit(1);
+      }
+      await run(cmd);
+      break;
+    }
+
+    case 'slack': {
+      if (args[1] === 'setup') {
+        await slackSetup();
+      } else {
+        await slackRun();
+      }
+      break;
+    }
+
+    case 'discord': {
+      if (args[1] === 'setup') {
+        await discordSetup();
+      } else {
+        await discordRun();
+      }
+      break;
+    }
+
+    case 'help':
+    case '--help':
+    case '-h':
+    case undefined: {
+      console.log(`
+AFK Code - Monitor Claude Code sessions from Slack/Discord
+
+Commands:
+  slack              Run the Slack bot
+  slack setup        Configure Slack integration
+  discord            Run the Discord bot
+  discord setup      Configure Discord 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
+`);
+      break;
+    }
+
+    default: {
+      console.error(`Unknown command: ${command}`);
+      console.error('Run "afk-code help" for usage');
+      process.exit(1);
+    }
+  }
+}
+
+main().catch((err) => {
+  console.error('Error:', err.message);
+  process.exit(1);
+});

package/src/cli/run.ts

@@ -0,0 +1,126 @@
+import { randomUUID } from 'crypto';
+import { spawn } from 'bun';
+import { spawn as spawnPty } from '@zenyr/bun-pty';
+import type { Socket } from 'bun';
+import { homedir } from 'os';
+
+const DAEMON_SOCKET = '/tmp/afk-code-daemon.sock';
+
+// Get Claude's project directory for the current working directory
+function getClaudeProjectDir(cwd: string): string {
+  // Claude encodes paths by replacing / with -
+  const encodedPath = cwd.replace(/\//g, '-');
+  return `${homedir()}/.claude/projects/${encodedPath}`;
+}
+
+// Connect to daemon and maintain bidirectional communication
+async function connectToDaemon(
+  sessionId: string,
+  projectDir: string,
+  cwd: string,
+  command: string[],
+  onInput: (text: string) => void
+): Promise<{ close: () => void } | null> {
+  try {
+    let messageBuffer = '';
+
+    const socket = await Bun.connect({
+      unix: DAEMON_SOCKET,
+      socket: {
+        data(socket, data) {
+          messageBuffer += data.toString();
+
+          const lines = messageBuffer.split('\n');
+          messageBuffer = lines.pop() || '';
+
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+              const msg = JSON.parse(line);
+              if (msg.type === 'input' && msg.text) {
+                onInput(msg.text);
+              }
+            } catch {}
+          }
+        },
+        error(socket, error) {
+          console.error('[Session] Daemon connection error:', error);
+        },
+        close(socket) {},
+      },
+    });
+
+    // Tell daemon about this session
+    socket.write(JSON.stringify({
+      type: 'session_start',
+      id: sessionId,
+      projectDir,
+      cwd,
+      command,
+      name: command.join(' '),
+    }) + '\n');
+
+    return {
+      close: () => {
+        socket.write(JSON.stringify({ type: 'session_end', sessionId }) + '\n');
+        socket.end();
+      },
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function run(command: string[]): Promise<void> {
+  const sessionId = randomUUID().slice(0, 8);
+  const cwd = process.cwd();
+  const projectDir = getClaudeProjectDir(cwd);
+
+  // Use bun-pty for full terminal features + remote input
+  const cols = process.stdout.columns || 80;
+  const rows = process.stdout.rows || 24;
+
+  const pty = spawnPty(command[0], command.slice(1), {
+    name: process.env.TERM || 'xterm-256color',
+    cols,
+    rows,
+    cwd,
+    env: process.env as Record<string, string>,
+  });
+
+  const daemon = await connectToDaemon(
+    sessionId,
+    projectDir,
+    cwd,
+    command,
+    (text) => {
+      pty.write(text);
+    }
+  );
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  pty.onData((data: string) => {
+    process.stdout.write(data);
+  });
+
+  process.stdin.on('data', (data: Buffer) => {
+    pty.write(data.toString());
+  });
+
+  process.stdout.on('resize', () => {
+    pty.resize(process.stdout.columns || 80, process.stdout.rows || 24);
+  });
+
+  await new Promise<void>((resolve) => {
+    pty.onExit(() => {
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+      }
+      daemon?.close();
+      resolve();
+    });
+  });
+}