cord-bot 1.0.4 → 1.0.5

package/.github/workflows/publish.yml

@@ -20,15 +20,13 @@ jobs:
       - name: Install dependencies
         run: bun install
 
-      - name: Build
-        run: bun run build
-
       - uses: actions/setup-node@v4
         with:
-          node-version: '20'
+          node-version: '22'
           registry-url: 'https://registry.npmjs.org'
 
-      - name: Publish to npm
+      - name: Update npm for OIDC support
+        run: npm install -g npm@latest
+
+      - name: Publish to npm with provenance
         run: npm publish --provenance --access public
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/README.md

@@ -1,37 +1,42 @@
 # Cord
 
-A simple bridge that connects Discord to Claude Code CLI.
+A Discord bot that connects to Claude Code CLI, plus a Claude Code skill that lets your assistant control the bot.
 
 > **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
+## What You Get
 
-```bash
-npm install cord-bot
-# or
-bunx cord-bot
-```
+**Discord Bot** — @mention the bot in Discord, it spawns Claude Code to respond. Conversations happen in threads with full context preserved across messages.
 
-When someone @mentions your bot, it:
-1. Creates a thread for the conversation
-2. Queues the message for Claude processing
-3. Posts Claude's response back to the thread
-4. Remembers context for follow-up messages
+**Claude Code Skill** — Teaches your assistant to use the bot to send messages, embeds, files, and interactive buttons. Installed automatically during setup. No MCP server needed.
 
-## Architecture
+## Quick Start
 
-```
-Discord Bot  →  BullMQ Queue  →  Claude Spawner
- (Node.js)       (Redis)          (Bun)
+```bash
+# Create a new Cord project
+bunx create-cord my-bot
+cd my-bot
+
+# Start Redis (if not already running)
+redis-server &
+
+# Start Cord
+cord start
 ```
 
-- **Bot** (`src/bot.ts`): Catches @mentions, creates threads, sends to queue
-- **Queue** (`src/queue.ts`): BullMQ job queue for reliable processing
-- **Worker** (`src/worker.ts`): Pulls jobs, spawns Claude, posts responses
-- **Spawner** (`src/spawner.ts`): The Claude CLI integration (the core)
-- **DB** (`src/db.ts`): SQLite for thread→session mapping
+<details>
+<summary>Alternative: Clone from GitHub</summary>
+
+```bash
+git clone https://github.com/alexknowshtml/cord.git my-bot
+cd my-bot
+bun install
+cord setup
+cord start
+```
+</details>
 
 ## Prerequisites
 
@@ -55,24 +60,19 @@ Discord Bot  →  BullMQ Queue  →  Claude Spawner
 
 **Note:** This runs 100% locally. The bot connects *outbound* to Discord's gateway - no need to expose ports or use ngrok.
 
-## Quick Start
-
-```bash
-# Clone and install
-git clone https://github.com/alexknowshtml/cord.git
-cd cord
-bun install
-
-# Run setup wizard (configures .env, checks dependencies, installs skill)
-cord setup
-
-# Start Redis (if not already running)
-redis-server &
+## Architecture
 
-# Start Cord
-cord start
+```
+Discord Bot  →  BullMQ Queue  →  Claude Spawner
+ (Node.js)       (Redis)          (Bun)
 ```
 
+- **Bot** (`src/bot.ts`): Catches @mentions, creates threads, sends to queue
+- **Queue** (`src/queue.ts`): BullMQ job queue for reliable processing
+- **Worker** (`src/worker.ts`): Pulls jobs, spawns Claude, posts responses
+- **Spawner** (`src/spawner.ts`): The Claude CLI integration (the core)
+- **DB** (`src/db.ts`): SQLite for thread→session mapping
+
 ## Environment Variables
 
 | Variable | Required | Default | Description |
@@ -83,67 +83,31 @@ cord start
 | `CLAUDE_WORKING_DIR` | No | `cwd` | Working directory for Claude |
 | `DB_PATH` | No | `./data/threads.db` | SQLite database path |
 
-## How It Works
-
-### New Mentions
-
-1. User @mentions the bot with a question
-2. Bot creates a thread from the message
-3. Bot generates a UUID session ID
-4. Bot stores thread_id → session_id in SQLite
-5. Bot queues a job with the prompt and session ID
-6. Worker picks up the job
-7. Worker spawns Claude with `--session-id UUID`
-8. Worker posts Claude's response to the thread
+## CLI Commands
 
-### Follow-up Messages
+Once running, Cord provides CLI commands for interacting with Discord:
 
-1. User sends another message in the thread
-2. Bot looks up the session ID from SQLite
-3. Bot queues a job with `resume: true`
-4. Worker spawns Claude with `--resume UUID`
-5. Claude has full context from previous messages
-
-## Key CLI Flags
-
-The magic is in `src/spawner.ts`:
-
-```typescript
-// For new sessions:
-claude --print --session-id UUID -p "prompt"
-
-// For follow-ups:
-claude --print --resume UUID -p "prompt"
-
-// Inject context that survives compaction:
-claude --append-system-prompt "Current time: ..."
+```bash
+cord send <channel> "message"           # Send a message
+cord embed <channel> "text" --title "T" # Send formatted embed
+cord file <channel> ./report.md         # Send file attachment
+cord buttons <channel> "Pick:" --button label="Yes" id="yes" style="success"
+cord typing <channel>                   # Show typing indicator
+cord edit <channel> <msgId> "new text"  # Edit message
+cord delete <channel> <msgId>           # Delete message
+cord reply <channel> <msgId> "reply"    # Reply to message
+cord react <channel> <msgId> "emoji"    # Add reaction
+cord thread <channel> <msgId> "name"    # Create thread
+cord rename <threadId> "new name"       # Rename thread
 ```
 
-## HTTP API
-
-Cord exposes an HTTP API on port 2643 for external tools to interact with Discord:
+See [skills/cord/SKILL.md](./skills/cord/SKILL.md) for full CLI documentation.
 
-- **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
+## HTTP API
 
-# Or copy manually
-cp -r skills/cord ~/.claude/skills/
-```
+Cord also exposes an HTTP API on port 2643 for external scripts and webhooks.
 
-See [skills/cord/SKILL.md](./skills/cord/SKILL.md) for skill documentation.
+See [skills/cord/HTTP-API.md](./skills/cord/HTTP-API.md) for API documentation.
 
 ## License
 

package/bin/cord.ts

@@ -2,12 +2,24 @@
 /**
  * Cord CLI - Manage your Discord-Claude bridge
  *
- * Commands:
+ * Management Commands:
  *   cord start   - Start bot and worker
  *   cord stop    - Stop all processes
  *   cord status  - Show running status
- *   cord logs    - Show combined logs
  *   cord setup   - Interactive setup wizard
+ *
+ * Discord Commands:
+ *   cord send <channel> "message"
+ *   cord embed <channel> "description" [--title, --color, --field, etc.]
+ *   cord file <channel> <filepath> "message"
+ *   cord buttons <channel> "prompt" --button label="..." id="..." [style, reply, webhook]
+ *   cord typing <channel>
+ *   cord edit <channel> <messageId> "content"
+ *   cord delete <channel> <messageId>
+ *   cord rename <threadId> "name"
+ *   cord reply <channel> <messageId> "message"
+ *   cord thread <channel> <messageId> "name"
+ *   cord react <channel> <messageId> "emoji"
  */
 
 import { spawn, spawnSync } from 'bun';
@@ -17,8 +29,30 @@ import * as readline from 'readline';
 import { homedir } from 'os';
 
 const PID_FILE = join(process.cwd(), '.cord.pid');
+const API_BASE = process.env.CORD_API_URL || 'http://localhost:2643';
 
 const command = process.argv[2];
+const args = process.argv.slice(3);
+
+// Color name to Discord color int mapping
+const COLORS: Record<string, number> = {
+    red: 15158332,      // 0xE74C3C
+    green: 3066993,     // 0x2ECC71
+    blue: 3447003,      // 0x3498DB
+    yellow: 16776960,   // 0xFFFF00
+    purple: 10181046,   // 0x9B59B6
+    orange: 15105570,   // 0xE67E22
+    gray: 9807270,      // 0x95A5A6
+    grey: 9807270,      // 0x95A5A6
+};
+
+// Button style name to Discord style int mapping
+const BUTTON_STYLES: Record<string, number> = {
+    primary: 1,
+    secondary: 2,
+    success: 3,
+    danger: 4,
+};
 
 async function prompt(question: string): Promise<string> {
     const rl = readline.createInterface({
@@ -33,6 +67,316 @@ async function prompt(question: string): Promise<string> {
     });
 }
 
+// ============ API Helper ============
+
+async function apiCall(endpoint: string, body: any): Promise<any> {
+    try {
+        const response = await fetch(`${API_BASE}${endpoint}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+        const data = await response.json();
+        if (!response.ok || data.error) {
+            console.error('Error:', data.error || 'Request failed');
+            process.exit(1);
+        }
+        return data;
+    } catch (error: any) {
+        if (error.code === 'ECONNREFUSED') {
+            console.error('Error: Cannot connect to Cord API. Is the bot running? (cord start)');
+        } else {
+            console.error('Error:', error.message);
+        }
+        process.exit(1);
+    }
+}
+
+// ============ Discord Commands ============
+
+async function sendMessage() {
+    const channel = args[0];
+    const message = args[1];
+    if (!channel || !message) {
+        console.error('Usage: cord send <channel> "message"');
+        process.exit(1);
+    }
+    const result = await apiCall('/command', {
+        command: 'send-to-thread',
+        args: { thread: channel, message },
+    });
+    console.log(`Sent message: ${result.messageId}`);
+}
+
+async function sendEmbed() {
+    const channel = args[0];
+    if (!channel) {
+        console.error('Usage: cord embed <channel> "description" [--title "..." --color green ...]');
+        process.exit(1);
+    }
+
+    // Parse flags and find positional description
+    const embed: any = {};
+    const fields: any[] = [];
+    let description = '';
+    let i = 1;
+
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '--title' && args[i + 1]) {
+            embed.title = args[++i];
+        } else if (arg === '--url' && args[i + 1]) {
+            embed.url = args[++i];
+        } else if (arg === '--color' && args[i + 1]) {
+            const colorArg = args[++i].toLowerCase();
+            embed.color = COLORS[colorArg] || parseInt(colorArg.replace('0x', ''), 16) || 0;
+        } else if (arg === '--author' && args[i + 1]) {
+            embed.author = embed.author || {};
+            embed.author.name = args[++i];
+        } else if (arg === '--author-url' && args[i + 1]) {
+            embed.author = embed.author || {};
+            embed.author.url = args[++i];
+        } else if (arg === '--author-icon' && args[i + 1]) {
+            embed.author = embed.author || {};
+            embed.author.icon_url = args[++i];
+        } else if (arg === '--thumbnail' && args[i + 1]) {
+            embed.thumbnail = { url: args[++i] };
+        } else if (arg === '--image' && args[i + 1]) {
+            embed.image = { url: args[++i] };
+        } else if (arg === '--footer' && args[i + 1]) {
+            embed.footer = embed.footer || {};
+            embed.footer.text = args[++i];
+        } else if (arg === '--footer-icon' && args[i + 1]) {
+            embed.footer = embed.footer || {};
+            embed.footer.icon_url = args[++i];
+        } else if (arg === '--timestamp') {
+            embed.timestamp = new Date().toISOString();
+        } else if (arg === '--field' && args[i + 1]) {
+            const fieldStr = args[++i];
+            const parts = fieldStr.split(':');
+            if (parts.length >= 2) {
+                fields.push({
+                    name: parts[0],
+                    value: parts[1],
+                    inline: parts[2]?.toLowerCase() === 'inline',
+                });
+            }
+        } else if (!arg.startsWith('--')) {
+            description = arg;
+        }
+        i++;
+    }
+
+    if (description) embed.description = description;
+    if (fields.length > 0) embed.fields = fields;
+
+    const result = await apiCall('/command', {
+        command: 'send-to-thread',
+        args: { thread: channel, embeds: [embed] },
+    });
+    console.log(`Sent embed: ${result.messageId}`);
+}
+
+async function sendFile() {
+    const channel = args[0];
+    const filepath = args[1];
+    const message = args[2] || '';
+
+    if (!channel || !filepath) {
+        console.error('Usage: cord file <channel> <filepath> ["message"]');
+        process.exit(1);
+    }
+
+    if (!existsSync(filepath)) {
+        console.error(`Error: File not found: ${filepath}`);
+        process.exit(1);
+    }
+
+    const fileContent = readFileSync(filepath, 'utf-8');
+    const fileName = filepath.split('/').pop() || 'file.txt';
+
+    const result = await apiCall('/send-with-file', {
+        channelId: channel,
+        fileName,
+        fileContent,
+        content: message,
+    });
+    console.log(`Sent file: ${result.messageId}`);
+}
+
+async function sendButtons() {
+    const channel = args[0];
+    if (!channel) {
+        console.error('Usage: cord buttons <channel> "prompt" --button label="..." id="..." [style="success"] [reply="..."] [webhook="..."]');
+        process.exit(1);
+    }
+
+    let promptText = '';
+    const buttons: any[] = [];
+    let i = 1;
+
+    while (i < args.length) {
+        const arg = args[i];
+        if (arg === '--button') {
+            // Collect all following key=value pairs until next flag or end
+            const button: any = {};
+            i++;
+            while (i < args.length && !args[i].startsWith('--')) {
+                const kvMatch = args[i].match(/^(\w+)=(.*)$/);
+                if (kvMatch) {
+                    const [, key, value] = kvMatch;
+                    if (key === 'style') {
+                        button.style = BUTTON_STYLES[value.toLowerCase()] || 1;
+                    } else {
+                        button[key] = value;
+                    }
+                }
+                i++;
+            }
+            if (button.label && button.id) {
+                // Convert to API format
+                const apiButton: any = {
+                    label: button.label,
+                    customId: button.id,
+                    style: button.style || 1,
+                };
+                if (button.reply || button.webhook) {
+                    apiButton.handler = {};
+                    if (button.reply) {
+                        apiButton.handler.type = 'inline';
+                        apiButton.handler.content = button.reply;
+                        apiButton.handler.ephemeral = true;
+                    }
+                    if (button.webhook) {
+                        apiButton.handler.type = button.reply ? 'inline' : 'webhook';
+                        apiButton.handler.webhookUrl = button.webhook;
+                    }
+                }
+                buttons.push(apiButton);
+            }
+            continue; // Don't increment i again
+        } else if (!arg.startsWith('--')) {
+            promptText = arg;
+        }
+        i++;
+    }
+
+    if (buttons.length === 0) {
+        console.error('Error: At least one --button is required');
+        process.exit(1);
+    }
+
+    const result = await apiCall('/send-with-buttons', {
+        channelId: channel,
+        content: promptText,
+        buttons,
+    });
+    console.log(`Sent buttons: ${result.messageId}`);
+}
+
+async function startTyping() {
+    const channel = args[0];
+    if (!channel) {
+        console.error('Usage: cord typing <channel>');
+        process.exit(1);
+    }
+    await apiCall('/command', {
+        command: 'start-typing',
+        args: { channel },
+    });
+    console.log('Typing indicator sent');
+}
+
+async function editMessage() {
+    const channel = args[0];
+    const messageId = args[1];
+    const content = args[2];
+    if (!channel || !messageId || !content) {
+        console.error('Usage: cord edit <channel> <messageId> "new content"');
+        process.exit(1);
+    }
+    await apiCall('/command', {
+        command: 'edit-message',
+        args: { channel, message: messageId, content },
+    });
+    console.log(`Edited message: ${messageId}`);
+}
+
+async function deleteMessage() {
+    const channel = args[0];
+    const messageId = args[1];
+    if (!channel || !messageId) {
+        console.error('Usage: cord delete <channel> <messageId>');
+        process.exit(1);
+    }
+    await apiCall('/command', {
+        command: 'delete-message',
+        args: { channel, message: messageId },
+    });
+    console.log(`Deleted message: ${messageId}`);
+}
+
+async function renameThread() {
+    const threadId = args[0];
+    const name = args[1];
+    if (!threadId || !name) {
+        console.error('Usage: cord rename <threadId> "new name"');
+        process.exit(1);
+    }
+    await apiCall('/command', {
+        command: 'rename-thread',
+        args: { thread: threadId, name },
+    });
+    console.log(`Renamed thread: ${threadId}`);
+}
+
+async function replyToMessage() {
+    const channel = args[0];
+    const messageId = args[1];
+    const message = args[2];
+    if (!channel || !messageId || !message) {
+        console.error('Usage: cord reply <channel> <messageId> "message"');
+        process.exit(1);
+    }
+    const result = await apiCall('/command', {
+        command: 'reply-to-message',
+        args: { channel, message: messageId, content: message },
+    });
+    console.log(`Replied to message: ${result.messageId}`);
+}
+
+async function createThread() {
+    const channel = args[0];
+    const messageId = args[1];
+    const name = args[2];
+    if (!channel || !messageId || !name) {
+        console.error('Usage: cord thread <channel> <messageId> "thread name"');
+        process.exit(1);
+    }
+    const result = await apiCall('/command', {
+        command: 'create-thread',
+        args: { channel, message: messageId, name },
+    });
+    console.log(`Created thread: ${result.threadId}`);
+}
+
+async function addReaction() {
+    const channel = args[0];
+    const messageId = args[1];
+    const emoji = args[2];
+    if (!channel || !messageId || !emoji) {
+        console.error('Usage: cord react <channel> <messageId> "emoji"');
+        process.exit(1);
+    }
+    await apiCall('/command', {
+        command: 'add-reaction',
+        args: { channel, message: messageId, emoji },
+    });
+    console.log(`Added reaction: ${emoji}`);
+}
+
+// ============ Management Commands ============
+
 async function setup() {
     console.log('\n🔌 Cord Setup\n');
 
@@ -198,25 +542,79 @@ function showHelp() {
     console.log(`
 Cord - Discord to Claude Code bridge
 
-Usage: cord <command>
-
-Commands:
-  start   Start bot and worker
-  stop    Stop all processes
-  status  Show running status
-  setup   Interactive setup wizard
-  help    Show this help
+Usage: cord <command> [options]
+
+Management Commands:
+  start              Start bot and worker
+  stop               Stop all processes
+  status             Show running status
+  setup              Interactive setup wizard
+  help               Show this help
+
+Discord Commands:
+  send <channel> "message"
+      Send a text message
+
+  embed <channel> "description" [options]
+      Send an embed with optional formatting
+      --title "..."          Embed title
+      --url "..."            Title link URL
+      --color <name|hex>     red, green, blue, yellow, purple, orange, or 0xHEX
+      --author "..."         Author name
+      --author-url "..."     Author link
+      --author-icon "..."    Author icon URL
+      --thumbnail "..."      Small image (top right)
+      --image "..."          Large image (bottom)
+      --footer "..."         Footer text
+      --footer-icon "..."    Footer icon URL
+      --timestamp            Add current timestamp
+      --field "Name:Value"   Add field (use :inline for inline)
+
+  file <channel> <filepath> ["message"]
+      Send a file attachment
+
+  buttons <channel> "prompt" --button label="..." id="..." [options]
+      Send interactive buttons
+      Button options:
+        label="..."          Button text (required)
+        id="..."             Custom ID (required)
+        style="..."          primary, secondary, success, danger
+        reply="..."          Ephemeral reply when clicked
+        webhook="..."        URL to POST click data to
+
+  typing <channel>
+      Show typing indicator
+
+  edit <channel> <messageId> "content"
+      Edit an existing message
+
+  delete <channel> <messageId>
+      Delete a message
+
+  rename <threadId> "name"
+      Rename a thread
+
+  reply <channel> <messageId> "message"
+      Reply to a specific message
+
+  thread <channel> <messageId> "name"
+      Create a thread from a message
+
+  react <channel> <messageId> "emoji"
+      Add a reaction to a message
 
 Examples:
-  cord setup    # First-time configuration
-  cord start    # Start the bot
-  cord status   # Check if running
-  cord stop     # Stop everything
+  cord send 123456789 "Hello world!"
+  cord embed 123456789 "Status update" --title "Daily Report" --color green --field "Tasks:5 done:inline"
+  cord buttons 123456789 "Approve?" --button label="Yes" id="approve" style="success" reply="Approved!"
+  cord file 123456789 ./report.md "Here's the report"
 `);
 }
 
-// Main
+// ============ Main ============
+
 switch (command) {
+    // Management
     case 'start':
         start();
         break;
@@ -235,6 +633,42 @@ switch (command) {
     case undefined:
         showHelp();
         break;
+
+    // Discord commands
+    case 'send':
+        sendMessage();
+        break;
+    case 'embed':
+        sendEmbed();
+        break;
+    case 'file':
+        sendFile();
+        break;
+    case 'buttons':
+        sendButtons();
+        break;
+    case 'typing':
+        startTyping();
+        break;
+    case 'edit':
+        editMessage();
+        break;
+    case 'delete':
+        deleteMessage();
+        break;
+    case 'rename':
+        renameThread();
+        break;
+    case 'reply':
+        replyToMessage();
+        break;
+    case 'thread':
+        createThread();
+        break;
+    case 'react':
+        addReaction();
+        break;
+
     default:
         console.log(`Unknown command: ${command}`);
         showHelp();

package/package.json

@@ -1,6 +1,11 @@
 {
   "name": "cord-bot",
-  "version": "1.0.4",
+  "version": "1.0.5",
+  "description": "Discord bot that bridges messages to Claude Code sessions",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alexknowshtml/cord"
+  },
   "module": "index.ts",
   "type": "module",
   "bin": {

package/skills/cord/{PRIMITIVES.md → HTTP-API.md}

@@ -1,6 +1,6 @@
-# Discord Primitives
+# HTTP API Reference
 
-HTTP API for interacting with Discord from scripts and Claude skills.
+Low-level HTTP API for interacting with Discord. For Claude Code, use the CLI commands in [SKILL.md](./SKILL.md) instead.
 
 **Port:** `2643` (configurable via `API_PORT` env var)
 
@@ -201,6 +201,57 @@ curl -X POST http://localhost:2643/command \
   }'
 ```
 
+## reply-to-message
+
+Reply to a specific message (shows reply preview).
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "reply-to-message",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID",
+      "content": "This is a reply"
+    }
+  }'
+```
+
+## create-thread
+
+Create a thread from a message.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "create-thread",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID",
+      "name": "Thread Name"
+    }
+  }'
+```
+
+## add-reaction
+
+Add a reaction to a message.
+
+```bash
+curl -X POST http://localhost:2643/command \
+  -H 'Content-Type: application/json' \
+  -d '{
+    "command": "add-reaction",
+    "args": {
+      "channel": "CHANNEL_ID",
+      "message": "MESSAGE_ID",
+      "emoji": "👍"
+    }
+  }'
+```
+
 ## Response Format
 
 All endpoints return JSON:

package/skills/cord/SKILL.md

@@ -1,6 +1,6 @@
 ---
 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.
+description: Send messages, embeds, files, and interactive buttons to Discord via the Cord CLI. Use for notifications, reports, interactive choices, and dynamic Discord interactions.
 triggers:
   - "send to discord"
   - "post to discord"
@@ -10,270 +10,295 @@ triggers:
 
 # 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.
+Interact with Discord through Cord's CLI commands. This skill teaches Claude Code how to send messages, embeds, files, 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
+Verify it's connected:
+```bash
+curl -s http://localhost:2643/health
+# {"status":"ok","connected":true,"user":"MyBot#1234"}
+```
 
-### send-message
+---
+
+## CLI Commands
 
-Send a simple text message to a channel or thread.
+### send
+
+Send a 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!"
-    }
-  }'
+cord send <channel> "message"
 ```
 
-**Response:** `{"success":true,"messageId":"1234567890"}`
+**Example:**
+```bash
+cord send 123456789 "Hello world!"
+```
+
+---
 
-### send-embed
+### embed
 
-Send a formatted embed card with optional fields.
+Send a formatted embed card with optional styling.
 
 ```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"}
-      }]
-    }
-  }'
+cord embed <channel> "description" [options]
 ```
 
-**Color reference:**
-- Success/Green: `3066993` (0x2ECC71)
-- Info/Blue: `3447003` (0x3498DB)
-- Warning/Yellow: `16776960` (0xFFFF00)
-- Error/Red: `15158332` (0xE74C3C)
-- Purple: `10181046` (0x9B59B6)
+**Options:**
+| Flag | Description |
+|------|-------------|
+| `--title "..."` | Embed title |
+| `--url "..."` | Title link URL |
+| `--color <name\|hex>` | red, green, blue, yellow, purple, orange, or 0xHEX |
+| `--author "..."` | Author name |
+| `--author-url "..."` | Author link |
+| `--author-icon "..."` | Author icon URL |
+| `--thumbnail "..."` | Small image (top right) |
+| `--image "..."` | Large image (bottom) |
+| `--footer "..."` | Footer text |
+| `--footer-icon "..."` | Footer icon URL |
+| `--timestamp` | Add current timestamp |
+| `--field "Name:Value"` | Add field (append `:inline` for inline) |
+
+**Examples:**
+
+Simple embed:
+```bash
+cord embed 123456789 "Daily status update" --title "Status Report" --color green
+```
 
-### send-file
+Embed with fields:
+```bash
+cord embed 123456789 "Build completed successfully" \
+  --title "CI/CD Pipeline" \
+  --color green \
+  --field "Branch:main:inline" \
+  --field "Duration:2m 34s:inline" \
+  --field "Tests:142 passed" \
+  --footer "Deployed by Cord" \
+  --timestamp
+```
 
-Attach content as a file (good for long reports).
+---
 
+### file
+
+Send a file attachment.
+
+```bash
+cord file <channel> <filepath> ["message"]
+```
+
+**Examples:**
 ```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"
-  }'
+cord file 123456789 ./report.md "Here's the weekly report"
+cord file 123456789 ./logs.txt
 ```
 
-### send-buttons
+---
+
+### buttons
 
-Send a message with interactive button choices.
+Send interactive buttons with optional handlers.
 
 ```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"}
-    ]
-  }'
+cord buttons <channel> "prompt" --button label="..." id="..." [options]
 ```
 
-**Button styles:** `primary`, `secondary`, `success`, `danger`
+**Button options:**
+| Option | Description |
+|--------|-------------|
+| `label="..."` | Button text (required) |
+| `id="..."` | Custom ID for tracking (required) |
+| `style="..."` | primary, secondary, success, danger |
+| `reply="..."` | Ephemeral reply when clicked |
+| `webhook="..."` | URL to POST click data to |
+
+**Examples:**
 
-### send-buttons with inline handler
+Simple confirmation:
+```bash
+cord buttons 123456789 "Deploy to production?" \
+  --button label="Deploy" id="deploy-prod" style="success" \
+  --button label="Cancel" id="cancel-deploy" style="secondary"
+```
 
-Register a handler that fires when the button is clicked.
+With inline responses:
+```bash
+cord buttons 123456789 "Approve this PR?" \
+  --button label="Approve" id="approve" style="success" reply="Approved! Merging now." \
+  --button label="Reject" id="reject" style="danger" reply="Rejected. Please revise."
+```
 
+With webhook callback:
 ```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
-        }
-      }]
-    }
-  }'
+cord buttons 123456789 "Start backup?" \
+  --button label="Start Backup" id="backup-start" style="primary" webhook="http://localhost:8080/backup"
 ```
 
+---
+
 ### 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"}
-  }'
+cord typing <channel>
 ```
 
-### edit-message
+---
+
+### edit
 
 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"
-    }
-  }'
+cord edit <channel> <messageId> "new content"
 ```
 
-### delete-message
+---
+
+### delete
 
 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"
-    }
-  }'
+cord delete <channel> <messageId>
 ```
 
-### rename-thread
+---
+
+### rename
 
 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"
-    }
-  }'
+cord rename <threadId> "new name"
 ```
 
-## Usage Examples
+---
+
+### reply
 
-### Post a notification
+Reply to a specific message (shows reply preview).
 
 ```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
-      }]
-    }
-  }'
+cord reply <channel> <messageId> "message"
 ```
 
-### Send a file attachment
+---
+
+### thread
+
+Create a thread from a message.
 
 ```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"
-  }'
+cord thread <channel> <messageId> "thread name"
 ```
 
-### Ask for confirmation with buttons
+---
+
+### react
+
+Add a reaction to a message.
 
 ```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"}
-    ]
-  }'
+cord react <channel> <messageId> "emoji"
 ```
 
-## Health Check
+**Example:**
+```bash
+cord react 123456789 987654321 "👍"
+```
+
+---
+
+## Choosing the Right Command
+
+| Use Case | Command |
+|----------|---------|
+| Simple notification | `cord send` |
+| Formatted status update | `cord embed` |
+| Long content (logs, reports) | `cord file` |
+| User needs to make a choice | `cord buttons` |
+| Indicate processing | `cord typing` |
+| Update previous message | `cord edit` |
+| Start a focused discussion | `cord thread` |
+| Quick acknowledgment | `cord react` |
+
+---
+
+## Assembly Patterns
 
-Verify Cord is running:
+### Notification with follow-up options
 
 ```bash
-curl -s http://localhost:2643/health
-# {"status":"ok","connected":true,"user":"YourBot#1234"}
+# Send the notification
+cord embed 123456789 "Build failed on main branch" \
+  --title "CI Alert" \
+  --color red \
+  --field "Error:Test suite timeout" \
+  --field "Commit:abc1234:inline"
+
+# Offer actions
+cord buttons 123456789 "What would you like to do?" \
+  --button label="View Logs" id="view-logs" style="primary" reply="Fetching logs..." \
+  --button label="Retry Build" id="retry" style="success" webhook="http://ci/retry" \
+  --button label="Ignore" id="ignore" style="secondary" reply="Acknowledged"
 ```
 
-## Troubleshooting
+### Progress updates
 
-**"Connection refused"** - Cord bot not running
 ```bash
-cord status
-cord start
+# Start with typing indicator
+cord typing 123456789
+
+# Send initial status
+MSGID=$(cord send 123456789 "Processing... 0%" | grep -o '[0-9]*$')
+
+# Update as progress continues
+cord edit 123456789 $MSGID "Processing... 50%"
+cord edit 123456789 $MSGID "Processing... 100% Complete!"
+
+# Add completion reaction
+cord react 123456789 $MSGID "✅"
 ```
 
-**"Thread not found"** - Invalid channel/thread ID or bot doesn't have access
+### Report delivery
+
+```bash
+# Send summary embed
+cord embed 123456789 "Weekly metrics compiled" \
+  --title "Weekly Report Ready" \
+  --color blue \
+  --field "Period:Jan 15-21:inline" \
+  --field "Pages:12:inline"
+
+# Attach the full report
+cord file 123456789 ./weekly-report.pdf "Full report attached"
+```
 
-**Button shows "expired"** - Handler was never registered or bot restarted since registration
+### Confirmation flow
 
-## Installation
+```bash
+# Ask for confirmation
+cord buttons 123456789 "Delete all archived items older than 30 days?" \
+  --button label="Yes, Delete" id="confirm-delete" style="danger" reply="Deleting..." \
+  --button label="Cancel" id="cancel-delete" style="secondary" reply="Cancelled"
+```
 
-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
+## HTTP API
 
-Claude Code will automatically detect the skill and use it when you ask to send Discord messages.
+For advanced use cases (webhooks, external scripts), see [HTTP-API.md](./HTTP-API.md).

package/src/api.ts

@@ -288,6 +288,51 @@ async function handleCommand(
             return { success: true };
         }
 
+        case 'reply-to-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 targetMessage = await (channel as TextChannel).messages.fetch(messageId);
+            const sent = await targetMessage.reply(content);
+            return { success: true, messageId: sent.id };
+        }
+
+        case 'create-thread': {
+            const channelId = args.channel as string;
+            const messageId = args.message as string;
+            const name = args.name 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);
+            const thread = await message.startThread({ name });
+            return { success: true, threadId: thread.id };
+        }
+
+        case 'add-reaction': {
+            const channelId = args.channel as string;
+            const messageId = args.message as string;
+            const emoji = args.emoji 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.react(emoji);
+            return { success: true };
+        }
+
         default:
             throw new Error(`Unknown command: ${command}`);
     }