cord-bot 1.0.2 → 1.0.4

package/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Publish to npm
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: oven-sh/setup-bun@v2
+        with:
+          bun-version: latest
+
+      - name: Install dependencies
+        run: bun install
+
+      - name: Build
+        run: bun run build
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -4,6 +4,16 @@ A simple bridge that connects Discord to Claude Code CLI.
 
 > **cord** /kôrd/ — a connection between two things.
 
+[![npm version](https://badge.fury.io/js/cord-bot.svg)](https://www.npmjs.com/package/cord-bot)
+
+## Install
+
+```bash
+npm install cord-bot
+# or
+bunx cord-bot
+```
+
 When someone @mentions your bot, it:
 1. Creates a thread for the conversation
 2. Queues the message for Claude processing
@@ -48,18 +58,19 @@ Discord Bot  →  BullMQ Queue  →  Claude Spawner
 ## Quick Start
 
 ```bash
-# Install dependencies
+# Clone and install
+git clone https://github.com/alexknowshtml/cord.git
+cd cord
 bun install
 
-# Set environment variables
-export DISCORD_BOT_TOKEN="your-bot-token"
+# Run setup wizard (configures .env, checks dependencies, installs skill)
+cord setup
 
 # Start Redis (if not already running)
 redis-server &
 
-# Start the bot and worker
-bun run src/bot.ts &
-bun run src/worker.ts
+# Start Cord
+cord start
 ```
 
 ## Environment Variables
@@ -108,6 +119,32 @@ claude --print --resume UUID -p "prompt"
 claude --append-system-prompt "Current time: ..."
 ```
 
+## HTTP API
+
+Cord exposes an HTTP API on port 2643 for external tools to interact with Discord:
+
+- **Send messages** - Text, embeds, file attachments
+- **Interactive buttons** - With inline or webhook handlers
+- **Typing indicators** - Show typing before slow operations
+- **Edit/delete messages** - Modify existing messages
+- **Rename threads** - Update thread names
+
+See [skills/cord/PRIMITIVES.md](./skills/cord/PRIMITIVES.md) for full API documentation.
+
+## Claude Code Skill
+
+Cord includes a Claude Code skill that teaches your assistant how to send Discord messages, embeds, files, and interactive buttons.
+
+```bash
+# Installed automatically during setup
+cord setup
+
+# Or copy manually
+cp -r skills/cord ~/.claude/skills/
+```
+
+See [skills/cord/SKILL.md](./skills/cord/SKILL.md) for skill documentation.
+
 ## License
 
 MIT

package/bin/cord.ts

@@ -11,9 +11,10 @@
  */
 
 import { spawn, spawnSync } from 'bun';
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { join } from 'path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, cpSync } from 'fs';
+import { join, dirname } from 'path';
 import * as readline from 'readline';
+import { homedir } from 'os';
 
 const PID_FILE = join(process.cwd(), '.cord.pid');
 
@@ -76,6 +77,23 @@ async function setup() {
         console.log('⚠ Claude CLI not found. Install from: https://claude.ai/code');
     }
 
+    // Install Claude Code skill
+    const skillsDir = join(homedir(), '.claude', 'skills', 'cord');
+    const cordRoot = join(dirname(import.meta.dir));
+    const sourceSkillsDir = join(cordRoot, 'skills', 'cord');
+
+    if (existsSync(sourceSkillsDir)) {
+        console.log('\n📚 Claude Code Skill');
+        console.log('   Teaches your assistant how to send Discord messages, embeds,');
+        console.log('   files, and interactive buttons.');
+        const installSkill = await prompt('Install skill? (Y/n): ');
+        if (installSkill.toLowerCase() !== 'n') {
+            mkdirSync(skillsDir, { recursive: true });
+            cpSync(sourceSkillsDir, skillsDir, { recursive: true });
+            console.log(`✓ Skill installed to ${skillsDir}`);
+        }
+    }
+
     console.log('\n✨ Setup complete! Run: cord start\n');
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cord-bot",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "module": "index.ts",
   "type": "module",
   "bin": {

package/skills/cord/PRIMITIVES.md

@@ -0,0 +1,222 @@
+# Discord Primitives
+
+HTTP API for interacting with Discord from scripts and Claude skills.
+
+**Port:** `2643` (configurable via `API_PORT` env var)
+
+## Health Check
+
+```bash
+curl http://localhost:2643/health
+# {"status":"ok","connected":true,"user":"MyBot#1234"}
+```
+
+## send-message
+
+Send a text message to a channel or thread.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "CHANNEL_OR_THREAD_ID",
+      "message": "Hello from Cord!"
+    }
+  }'
+```
+
+## send-embed
+
+Send a formatted embed card with optional fields.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "CHANNEL_OR_THREAD_ID",
+      "embeds": [{
+        "title": "Status Report",
+        "description": "Daily summary",
+        "color": 3447003,
+        "fields": [
+          {"name": "Tasks", "value": "5 completed", "inline": true},
+          {"name": "Emails", "value": "12 processed", "inline": true}
+        ],
+        "footer": {"text": "Generated by Cord"}
+      }]
+    }
+  }'
+```
+
+**Color reference:**
+- Success/Green: `3066993` (0x2ECC71)
+- Info/Blue: `3447003` (0x3498DB)
+- Warning/Yellow: `16776960` (0xFFFF00)
+- Error/Red: `15158332` (0xE74C3C)
+- Purple: `10181046` (0x9B59B6)
+
+## send-file
+
+Attach content as a file (good for long reports).
+
+```bash
+curl -X POST http://localhost:2643/send-with-file \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "fileName": "report.md",
+    "fileContent": "# Report\n\nContent here...",
+    "content": "Here is the detailed report"
+  }'
+```
+
+## send-buttons
+
+Send a message with interactive button choices.
+
+```bash
+curl -X POST http://localhost:2643/send-with-buttons \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "content": "Choose an option:",
+    "buttons": [
+      {"label": "Approve", "customId": "approve-123", "style": "success"},
+      {"label": "Reject", "customId": "reject-123", "style": "danger"}
+    ]
+  }'
+```
+
+**Button styles:** `primary`, `secondary`, `success`, `danger`
+
+### Buttons with inline handler
+
+Register a handler that fires when the button is clicked.
+
+```bash
+curl -X POST http://localhost:2643/send-with-buttons \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "content": "Click for details",
+    "buttons": [{
+      "label": "Show Details",
+      "customId": "details-123",
+      "style": "secondary",
+      "handler": {
+        "type": "inline",
+        "content": "Here are the details...",
+        "ephemeral": true
+      }
+    }]
+  }'
+```
+
+### Buttons with webhook handler
+
+Call an external URL when clicked.
+
+```bash
+curl -X POST http://localhost:2643/send-with-buttons \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "content": "Approve deployment?",
+    "buttons": [{
+      "label": "Deploy",
+      "customId": "deploy-prod",
+      "style": "success",
+      "handler": {
+        "type": "webhook",
+        "url": "http://localhost:8080/deploy",
+        "data": {"env": "production"}
+      }
+    }]
+  }'
+```
+
+## typing
+
+Show typing indicator (useful before slow operations).
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "start-typing",
+    "args": {"channel": "CHANNEL_OR_THREAD_ID"}
+  }'
+```
+
+## edit-message
+
+Edit an existing message.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "edit-message",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID",
+      "content": "Updated content"
+    }
+  }'
+```
+
+## delete-message
+
+Delete a message.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "delete-message",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID"
+    }
+  }'
+```
+
+## rename-thread
+
+Rename a thread.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "rename-thread",
+    "args": {
+      "thread": "THREAD_ID",
+      "name": "New Thread Name"
+    }
+  }'
+```
+
+## Response Format
+
+All endpoints return JSON:
+
+```json
+{"success": true, "messageId": "1234567890"}
+```
+
+On error:
+
+```json
+{"error": "Description of what went wrong"}
+```
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `API_PORT` | `2643` | HTTP API server port |

package/skills/cord/SKILL.md

@@ -0,0 +1,279 @@
+---
+name: cord
+description: Send messages, files, embeds, and buttons to Discord via Cord's HTTP API. Use for notifications, reports, interactive choices, and dynamic Discord interactions.
+triggers:
+  - "send to discord"
+  - "post to discord"
+  - "discord message"
+  - "notify discord"
+---
+
+# Cord - Discord Bridge Skill
+
+## Overview
+
+Interact with Discord through Cord's HTTP API (default port 2643). This skill teaches Claude Code how to use the local Cord bot for Discord messaging, embeds, file attachments, and interactive buttons.
+
+**GitHub:** https://github.com/alexknowshtml/cord
+
+**API Reference:** [PRIMITIVES.md](./PRIMITIVES.md) - Full HTTP API documentation
+
+## Setup
+
+Ensure Cord is running:
+```bash
+cord start
+# or: bun run src/bot.ts
+```
+
+## Primitives
+
+### send-message
+
+Send a simple text message to a channel or thread.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "CHANNEL_OR_THREAD_ID",
+      "message": "Hello from Cord!"
+    }
+  }'
+```
+
+**Response:** `{"success":true,"messageId":"1234567890"}`
+
+### send-embed
+
+Send a formatted embed card with optional fields.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "CHANNEL_OR_THREAD_ID",
+      "embeds": [{
+        "title": "Status Report",
+        "description": "Daily summary",
+        "color": 3447003,
+        "fields": [
+          {"name": "Tasks", "value": "5 completed", "inline": true},
+          {"name": "Emails", "value": "12 processed", "inline": true}
+        ],
+        "footer": {"text": "Generated by Cord"}
+      }]
+    }
+  }'
+```
+
+**Color reference:**
+- Success/Green: `3066993` (0x2ECC71)
+- Info/Blue: `3447003` (0x3498DB)
+- Warning/Yellow: `16776960` (0xFFFF00)
+- Error/Red: `15158332` (0xE74C3C)
+- Purple: `10181046` (0x9B59B6)
+
+### send-file
+
+Attach content as a file (good for long reports).
+
+```bash
+curl -s -X POST http://localhost:2643/send-with-file \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "fileName": "report.md",
+    "fileContent": "# Report\n\nContent here...",
+    "content": "Here is the detailed report"
+  }'
+```
+
+### send-buttons
+
+Send a message with interactive button choices.
+
+```bash
+curl -s -X POST http://localhost:2643/send-with-buttons \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "CHANNEL_OR_THREAD_ID",
+    "content": "Choose an option:",
+    "buttons": [
+      {"label": "Approve", "customId": "approve-123", "style": "success"},
+      {"label": "Reject", "customId": "reject-123", "style": "danger"}
+    ]
+  }'
+```
+
+**Button styles:** `primary`, `secondary`, `success`, `danger`
+
+### send-buttons with inline handler
+
+Register a handler that fires when the button is clicked.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "CHANNEL_OR_THREAD_ID",
+      "message": "Click for details",
+      "buttons": [{
+        "label": "Show Details",
+        "customId": "details-123",
+        "style": "secondary",
+        "handler": {
+          "type": "inline",
+          "content": "Here are the details...",
+          "ephemeral": true
+        }
+      }]
+    }
+  }'
+```
+
+### typing
+
+Show typing indicator (useful before slow operations).
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "start-typing",
+    "args": {"channel": "CHANNEL_OR_THREAD_ID"}
+  }'
+```
+
+### edit-message
+
+Edit an existing message.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "edit-message",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID",
+      "content": "Updated content"
+    }
+  }'
+```
+
+### delete-message
+
+Delete a message.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "delete-message",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID"
+    }
+  }'
+```
+
+### rename-thread
+
+Rename a thread.
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "rename-thread",
+    "args": {
+      "thread": "THREAD_ID",
+      "name": "New Thread Name"
+    }
+  }'
+```
+
+## Usage Examples
+
+### Post a notification
+
+```bash
+curl -s -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "send-to-thread",
+    "args": {
+      "thread": "YOUR_CHANNEL_ID",
+      "embeds": [{
+        "title": "Deploy Complete",
+        "description": "Production deployment finished successfully",
+        "color": 3066993
+      }]
+    }
+  }'
+```
+
+### Send a file attachment
+
+```bash
+curl -s -X POST http://localhost:2643/send-with-file \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "YOUR_CHANNEL_ID",
+    "fileName": "weekly-report.md",
+    "fileContent": "# Weekly Report\n\nContent here...",
+    "content": "Weekly report attached"
+  }'
+```
+
+### Ask for confirmation with buttons
+
+```bash
+curl -s -X POST http://localhost:2643/send-with-buttons \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "channelId": "YOUR_CHANNEL_ID",
+    "content": "Ready to proceed?",
+    "buttons": [
+      {"label": "Yes", "customId": "confirm-action", "style": "success"},
+      {"label": "No", "customId": "cancel-action", "style": "secondary"}
+    ]
+  }'
+```
+
+## Health Check
+
+Verify Cord is running:
+
+```bash
+curl -s http://localhost:2643/health
+# {"status":"ok","connected":true,"user":"YourBot#1234"}
+```
+
+## Troubleshooting
+
+**"Connection refused"** - Cord bot not running
+```bash
+cord status
+cord start
+```
+
+**"Thread not found"** - Invalid channel/thread ID or bot doesn't have access
+
+**Button shows "expired"** - Handler was never registered or bot restarted since registration
+
+## Installation
+
+To use this skill with Claude Code:
+
+1. Copy this file to your `.claude/skills/cord/SKILL.md`
+2. Or reference it directly from the Cord repo
+
+Claude Code will automatically detect the skill and use it when you ask to send Discord messages.

package/src/api.ts

@@ -0,0 +1,294 @@
+/**
+ * HTTP API Server - Discord primitives for external tools
+ *
+ * Provides HTTP endpoints for sending messages, embeds, files, buttons,
+ * and managing threads. Useful for scripts, automation, and Claude skills.
+ */
+
+import { Client, TextChannel, EmbedBuilder, ActionRowBuilder, ButtonBuilder, ButtonStyle } from 'discord.js';
+
+const log = (msg: string) => process.stdout.write(`[api] ${msg}\n`);
+
+// Button handler registry for dynamic button responses
+type ButtonHandler = {
+    type: 'inline';
+    content: string;
+    ephemeral?: boolean;
+} | {
+    type: 'webhook';
+    url: string;
+    data?: Record<string, unknown>;
+};
+
+export const buttonHandlers = new Map<string, ButtonHandler>();
+
+/**
+ * Start the HTTP API server
+ */
+export function startApiServer(client: Client, port: number = 2643) {
+    const server = Bun.serve({
+        port,
+        async fetch(req) {
+            const url = new URL(req.url);
+            const headers = { 'Content-Type': 'application/json' };
+
+            // Health check
+            if (url.pathname === '/health' && req.method === 'GET') {
+                return new Response(JSON.stringify({
+                    status: 'ok',
+                    connected: client.isReady(),
+                    user: client.user?.tag || null,
+                }), { headers });
+            }
+
+            // Send message to thread/channel
+            if (url.pathname === '/command' && req.method === 'POST') {
+                try {
+                    const body = await req.json() as {
+                        command: string;
+                        args: Record<string, unknown>;
+                    };
+
+                    const result = await handleCommand(client, body.command, body.args);
+                    return new Response(JSON.stringify(result), { headers });
+                } catch (error) {
+                    log(`Command error: ${error}`);
+                    return new Response(JSON.stringify({ error: String(error) }), {
+                        status: 500,
+                        headers,
+                    });
+                }
+            }
+
+            // Send file attachment
+            if (url.pathname === '/send-with-file' && req.method === 'POST') {
+                try {
+                    const body = await req.json() as {
+                        channelId: string;
+                        fileName: string;
+                        fileContent: string;
+                        content?: string;
+                    };
+
+                    const channel = await client.channels.fetch(body.channelId);
+                    if (!channel?.isTextBased()) {
+                        return new Response(JSON.stringify({ error: 'Invalid channel' }), {
+                            status: 400,
+                            headers,
+                        });
+                    }
+
+                    const buffer = Buffer.from(body.fileContent, 'utf-8');
+                    const message = await (channel as TextChannel).send({
+                        content: body.content || undefined,
+                        files: [{
+                            attachment: buffer,
+                            name: body.fileName,
+                        }],
+                    });
+
+                    return new Response(JSON.stringify({
+                        success: true,
+                        messageId: message.id,
+                    }), { headers });
+                } catch (error) {
+                    log(`Send file error: ${error}`);
+                    return new Response(JSON.stringify({ error: String(error) }), {
+                        status: 500,
+                        headers,
+                    });
+                }
+            }
+
+            // Send message with buttons
+            if (url.pathname === '/send-with-buttons' && req.method === 'POST') {
+                try {
+                    const body = await req.json() as {
+                        channelId: string;
+                        content?: string;
+                        embeds?: Array<{
+                            title?: string;
+                            description?: string;
+                            color?: number;
+                            fields?: Array<{ name: string; value: string; inline?: boolean }>;
+                            footer?: { text: string };
+                        }>;
+                        buttons: Array<{
+                            label: string;
+                            customId: string;
+                            style: 'primary' | 'secondary' | 'success' | 'danger';
+                            handler?: ButtonHandler;
+                        }>;
+                    };
+
+                    const channel = await client.channels.fetch(body.channelId);
+                    if (!channel?.isTextBased()) {
+                        return new Response(JSON.stringify({ error: 'Invalid channel' }), {
+                            status: 400,
+                            headers,
+                        });
+                    }
+
+                    // Build embed if provided
+                    const embeds = body.embeds?.map(e => {
+                        const embed = new EmbedBuilder();
+                        if (e.title) embed.setTitle(e.title);
+                        if (e.description) embed.setDescription(e.description);
+                        if (e.color) embed.setColor(e.color);
+                        if (e.fields) embed.addFields(e.fields);
+                        if (e.footer) embed.setFooter(e.footer);
+                        return embed;
+                    });
+
+                    // Build button row
+                    const styleMap: Record<string, ButtonStyle> = {
+                        primary: ButtonStyle.Primary,
+                        secondary: ButtonStyle.Secondary,
+                        success: ButtonStyle.Success,
+                        danger: ButtonStyle.Danger,
+                    };
+
+                    const buttons = body.buttons.map(b => {
+                        // Register handler if provided
+                        if (b.handler) {
+                            buttonHandlers.set(b.customId, b.handler);
+                        }
+                        return new ButtonBuilder()
+                            .setCustomId(b.customId)
+                            .setLabel(b.label)
+                            .setStyle(styleMap[b.style] || ButtonStyle.Primary);
+                    });
+
+                    const row = new ActionRowBuilder<ButtonBuilder>().addComponents(buttons);
+
+                    const message = await (channel as TextChannel).send({
+                        content: body.content || undefined,
+                        embeds: embeds || undefined,
+                        components: [row],
+                    });
+
+                    return new Response(JSON.stringify({
+                        success: true,
+                        messageId: message.id,
+                    }), { headers });
+                } catch (error) {
+                    log(`Send buttons error: ${error}`);
+                    return new Response(JSON.stringify({ error: String(error) }), {
+                        status: 500,
+                        headers,
+                    });
+                }
+            }
+
+            // 404 for unknown routes
+            return new Response(JSON.stringify({ error: 'Not found' }), {
+                status: 404,
+                headers,
+            });
+        },
+    });
+
+    log(`HTTP API server listening on port ${port}`);
+    return server;
+}
+
+/**
+ * Handle a command from the /command endpoint
+ */
+async function handleCommand(
+    client: Client,
+    command: string,
+    args: Record<string, unknown>
+): Promise<Record<string, unknown>> {
+    switch (command) {
+        case 'send-to-thread': {
+            const threadId = args.thread as string;
+            const message = args.message as string | undefined;
+            const embeds = args.embeds as Array<{
+                title?: string;
+                description?: string;
+                color?: number;
+                fields?: Array<{ name: string; value: string; inline?: boolean }>;
+                footer?: { text: string };
+            }> | undefined;
+
+            const channel = await client.channels.fetch(threadId);
+            if (!channel?.isTextBased()) {
+                throw new Error('Invalid thread/channel');
+            }
+
+            // Build embeds if provided
+            const discordEmbeds = embeds?.map(e => {
+                const embed = new EmbedBuilder();
+                if (e.title) embed.setTitle(e.title);
+                if (e.description) embed.setDescription(e.description);
+                if (e.color) embed.setColor(e.color);
+                if (e.fields) embed.addFields(e.fields);
+                if (e.footer) embed.setFooter(e.footer);
+                return embed;
+            });
+
+            const sent = await (channel as TextChannel).send({
+                content: message || undefined,
+                embeds: discordEmbeds || undefined,
+            });
+
+            return { success: true, messageId: sent.id };
+        }
+
+        case 'start-typing': {
+            const channelId = args.channel as string;
+            const channel = await client.channels.fetch(channelId);
+            if (!channel?.isTextBased()) {
+                throw new Error('Invalid channel');
+            }
+            await (channel as TextChannel).sendTyping();
+            return { success: true };
+        }
+
+        case 'edit-message': {
+            const channelId = args.channel as string;
+            const messageId = args.message as string;
+            const content = args.content as string;
+
+            const channel = await client.channels.fetch(channelId);
+            if (!channel?.isTextBased()) {
+                throw new Error('Invalid channel');
+            }
+
+            const message = await (channel as TextChannel).messages.fetch(messageId);
+            await message.edit(content);
+            return { success: true };
+        }
+
+        case 'delete-message': {
+            const channelId = args.channel as string;
+            const messageId = args.message as string;
+
+            const channel = await client.channels.fetch(channelId);
+            if (!channel?.isTextBased()) {
+                throw new Error('Invalid channel');
+            }
+
+            const message = await (channel as TextChannel).messages.fetch(messageId);
+            await message.delete();
+            return { success: true };
+        }
+
+        case 'rename-thread': {
+            const threadId = args.thread as string;
+            const name = args.name as string;
+
+            const channel = await client.channels.fetch(threadId);
+            if (!channel?.isThread()) {
+                throw new Error('Invalid thread');
+            }
+
+            await channel.setName(name);
+            return { success: true };
+        }
+
+        default:
+            throw new Error(`Unknown command: ${command}`);
+    }
+}

package/src/bot.ts

@@ -14,10 +14,12 @@ import {
     Events,
     Message,
     TextChannel,
-    ThreadAutoArchiveDuration
+    ThreadAutoArchiveDuration,
+    Interaction,
 } from 'discord.js';
 import { claudeQueue } from './queue.js';
 import { db } from './db.js';
+import { startApiServer, buttonHandlers } from './api.js';
 
 // Force unbuffered logging
 const log = (msg: string) => process.stdout.write(`[bot] ${msg}\n`);
@@ -32,6 +34,49 @@ const client = new Client({
 
 client.once(Events.ClientReady, (c) => {
     log(`Logged in as ${c.user.tag}`);
+
+    // Start HTTP API server
+    const apiPort = parseInt(process.env.API_PORT || '2643');
+    startApiServer(client, apiPort);
+});
+
+// Handle button interactions
+client.on(Events.InteractionCreate, async (interaction: Interaction) => {
+    if (!interaction.isButton()) return;
+
+    const handler = buttonHandlers.get(interaction.customId);
+    if (!handler) {
+        await interaction.reply({ content: 'This button has expired.', ephemeral: true });
+        return;
+    }
+
+    try {
+        if (handler.type === 'inline') {
+            await interaction.reply({
+                content: handler.content,
+                ephemeral: handler.ephemeral ?? false,
+            });
+        } else if (handler.type === 'webhook') {
+            await interaction.deferReply({ ephemeral: true });
+            const response = await fetch(handler.url, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    customId: interaction.customId,
+                    userId: interaction.user.id,
+                    channelId: interaction.channelId,
+                    data: handler.data,
+                }),
+            });
+            const result = await response.json() as { content?: string };
+            await interaction.editReply({ content: result.content || 'Done.' });
+        }
+    } catch (error) {
+        log(`Button handler error: ${error}`);
+        if (!interaction.replied && !interaction.deferred) {
+            await interaction.reply({ content: 'An error occurred.', ephemeral: true });
+        }
+    }
 });
 
 client.on(Events.MessageCreate, async (message: Message) => {