afk-code 0.1.0

package/src/cli/slack.ts

@@ -0,0 +1,193 @@
+import { homedir } from 'os';
+import { mkdir } from 'fs/promises';
+import * as readline from 'readline';
+
+const CONFIG_DIR = `${homedir()}/.afk-code`;
+const SLACK_CONFIG_FILE = `${CONFIG_DIR}/slack.env`;
+const MANIFEST_URL = 'https://github.com/clharman/afk-code/blob/main/slack-manifest.json';
+
+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 slackSetup(): Promise<void> {
+  console.log(`
+┌─────────────────────────────────────────────────────────────┐
+│                  AFK Code Slack Setup                       │
+└─────────────────────────────────────────────────────────────┘
+
+This will guide you through setting up the Slack bot for
+monitoring Claude Code sessions.
+
+Step 1: Create a Slack App
+──────────────────────────
+1. Go to: https://api.slack.com/apps
+2. Click "Create New App" → "From manifest"
+3. Select your workspace
+4. Paste the manifest from: ${MANIFEST_URL}
+   (Or copy from slack-manifest.json in this repo)
+5. Click "Create"
+
+Step 2: Install the App
+───────────────────────
+1. Go to "Install App" in the sidebar
+2. Click "Install to Workspace"
+3. Authorize the app
+
+Step 3: Get Your Tokens
+───────────────────────
+`);
+
+  await prompt('Press Enter when you have created and installed the app...');
+
+  console.log(`
+Now let's collect your tokens:
+
+• Bot Token: "OAuth & Permissions" → "Bot User OAuth Token" (starts with xoxb-)
+• App Token: "Basic Information" → "App-Level Tokens" → Generate one with
+  "connections:write" scope (starts with xapp-)
+• User ID: Click your profile in Slack → "..." → "Copy member ID"
+`);
+
+  const botToken = await prompt('Bot Token (xoxb-...): ');
+  if (!botToken.startsWith('xoxb-')) {
+    console.error('Invalid bot token. Should start with xoxb-');
+    process.exit(1);
+  }
+
+  const appToken = await prompt('App Token (xapp-...): ');
+  if (!appToken.startsWith('xapp-')) {
+    console.error('Invalid app token. Should start with xapp-');
+    process.exit(1);
+  }
+
+  const userId = await prompt('Your Slack User ID (U...): ');
+  if (!userId.startsWith('U')) {
+    console.error('Invalid user ID. Should start with U');
+    process.exit(1);
+  }
+
+  // Save configuration
+  await mkdir(CONFIG_DIR, { recursive: true });
+
+  const envContent = `# AFK Code Slack Configuration
+SLACK_BOT_TOKEN=${botToken}
+SLACK_APP_TOKEN=${appToken}
+SLACK_USER_ID=${userId}
+`;
+
+  await Bun.write(SLACK_CONFIG_FILE, envContent);
+  console.log(`
+✓ Configuration saved to ${SLACK_CONFIG_FILE}
+
+To start the Slack bot, run:
+  afk-code slack
+
+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 slackRun(): Promise<void> {
+  // Load config from multiple sources (in order of precedence):
+  // 1. Environment variables (highest priority)
+  // 2. Local .env file
+  // 3. ~/.afk-code/slack.env (lowest priority)
+
+  const globalConfig = await loadEnvFile(SLACK_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.SLACK_BOT_TOKEN) config.SLACK_BOT_TOKEN = process.env.SLACK_BOT_TOKEN;
+  if (process.env.SLACK_APP_TOKEN) config.SLACK_APP_TOKEN = process.env.SLACK_APP_TOKEN;
+  if (process.env.SLACK_USER_ID) config.SLACK_USER_ID = process.env.SLACK_USER_ID;
+
+  // Validate required config
+  const required = ['SLACK_BOT_TOKEN', 'SLACK_APP_TOKEN', 'SLACK_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 (SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_USER_ID)');
+    console.error('  - Local .env file');
+    console.error('  - Run "afk-code slack setup" for guided configuration');
+    process.exit(1);
+  }
+
+  // Set environment variables and start the bot
+  process.env.SLACK_BOT_TOKEN = config.SLACK_BOT_TOKEN;
+  process.env.SLACK_APP_TOKEN = config.SLACK_APP_TOKEN;
+  process.env.SLACK_USER_ID = config.SLACK_USER_ID;
+
+  // Import and run the slack bot
+  const { createSlackApp } = await import('../slack/slack-app');
+
+  // Show where config was loaded from
+  const localEnvExists = await Bun.file(`${process.cwd()}/.env`).exists();
+  const globalEnvExists = await Bun.file(SLACK_CONFIG_FILE).exists();
+  const source = localEnvExists ? '.env' : globalEnvExists ? SLACK_CONFIG_FILE : 'environment';
+  console.log(`[AFK Code] Loaded config from ${source}`);
+  console.log('[AFK Code] Starting Slack bot...');
+
+  const slackConfig = {
+    botToken: config.SLACK_BOT_TOKEN,
+    appToken: config.SLACK_APP_TOKEN,
+    signingSecret: '',
+    userId: config.SLACK_USER_ID,
+  };
+
+  const { app, sessionManager } = createSlackApp(slackConfig);
+
+  // 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 Slack app
+  try {
+    await app.start();
+    console.log('[AFK Code] 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('[AFK Code] Failed to start Slack app:', err);
+    process.exit(1);
+  }
+}

package/src/discord/channel-manager.ts

@@ -0,0 +1,191 @@
+import type { Client, TextChannel, CategoryChannel, Guild } from 'discord.js';
+import { ChannelType, PermissionFlagsBits } from 'discord.js';
+
+export interface ChannelMapping {
+  sessionId: string;
+  channelId: string;
+  channelName: string;
+  sessionName: string;
+  status: 'running' | 'idle' | 'ended';
+  createdAt: Date;
+}
+
+/**
+ * Sanitize a string for use as a Discord channel name.
+ * Rules: lowercase, no spaces, max 100 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, 90); // 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: Client;
+  private userId: string;
+  private guild: Guild | null = null;
+  private category: CategoryChannel | null = null;
+
+  constructor(client: Client, userId: string) {
+    this.client = client;
+    this.userId = userId;
+  }
+
+  async initialize(): Promise<void> {
+    // Find the first guild the bot is in
+    const guilds = await this.client.guilds.fetch();
+    if (guilds.size === 0) {
+      throw new Error('Bot is not in any servers. Please invite the bot first.');
+    }
+
+    const guildId = guilds.first()!.id;
+    this.guild = await this.client.guilds.fetch(guildId);
+
+    // Find or create AFK Code category
+    const existingCategory = this.guild.channels.cache.find(
+      (ch) => ch.type === ChannelType.GuildCategory && ch.name.toLowerCase() === 'afk code sessions'
+    ) as CategoryChannel | undefined;
+
+    if (existingCategory) {
+      this.category = existingCategory;
+    } else {
+      this.category = await this.guild.channels.create({
+        name: 'AFK Code Sessions',
+        type: ChannelType.GuildCategory,
+      });
+    }
+
+    console.log(`[ChannelManager] Using guild: ${this.guild.name}`);
+    console.log(`[ChannelManager] Using category: ${this.category.name}`);
+  }
+
+  async createChannel(
+    sessionId: string,
+    sessionName: string,
+    cwd: string
+  ): Promise<ChannelMapping | null> {
+    if (!this.guild || !this.category) {
+      console.error('[ChannelManager] Not initialized');
+      return 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 channel: TextChannel | null = null;
+
+    while (true) {
+      const nameToTry = channelName.length > 100 ? channelName.slice(0, 100) : channelName;
+
+      // Check if name exists
+      const existing = this.guild.channels.cache.find(
+        (ch) => ch.name === nameToTry && ch.parentId === this.category!.id
+      );
+
+      if (!existing) {
+        try {
+          channel = await this.guild.channels.create({
+            name: nameToTry,
+            type: ChannelType.GuildText,
+            parent: this.category,
+            topic: `Claude Code session: ${sessionName}`,
+          });
+          channelName = nameToTry;
+          break;
+        } catch (err: any) {
+          console.error('[ChannelManager] Failed to create channel:', err.message);
+          return null;
+        }
+      } else {
+        suffix++;
+        channelName = `${baseName}-${suffix}`;
+      }
+    }
+
+    if (!channel) {
+      return null;
+    }
+
+    const mapping: ChannelMapping = {
+      sessionId,
+      channelId: channel.id,
+      channelName,
+      sessionName,
+      status: 'running',
+      createdAt: new Date(),
+    };
+
+    this.channels.set(sessionId, mapping);
+    this.channelToSession.set(channel.id, sessionId);
+
+    console.log(`[ChannelManager] Created channel #${channelName} for session ${sessionId}`);
+    return mapping;
+  }
+
+  async archiveChannel(sessionId: string): Promise<boolean> {
+    if (!this.guild) return false;
+
+    const mapping = this.channels.get(sessionId);
+    if (!mapping) return false;
+
+    try {
+      const channel = await this.guild.channels.fetch(mapping.channelId);
+      if (channel && channel.type === ChannelType.GuildText) {
+        // Rename with archived suffix
+        const timestamp = Date.now().toString(36);
+        const archivedName = `${mapping.channelName}-archived-${timestamp}`.slice(0, 100);
+
+        await channel.setName(archivedName);
+
+        // Move out of category or delete (Discord doesn't have archive)
+        // For now, just rename to indicate it's archived
+        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');
+  }
+}