@cordbot/agent 1.0.0

package/dist/agent/stream.js

@@ -0,0 +1,359 @@
+import { AttachmentBuilder } from 'discord.js';
+export async function streamToDiscord(queryResult, threadChannel, sessionManager, sessionId, workingDir, messagePrefix) {
+    const state = {
+        currentToolUse: null,
+        toolMessages: [],
+        progressMessages: [],
+        planContent: null,
+        messagePrefix: messagePrefix || null,
+        workingDir,
+    };
+    try {
+        // Iterate through SDK messages
+        for await (const message of queryResult) {
+            await handleSDKMessage(message, threadChannel, state, sessionManager, sessionId);
+        }
+        // Save session ID for resumption
+        await sessionManager.updateSession(sessionId, threadChannel.id);
+        // Attach any files queued for sharing
+        await attachSharedFiles(threadChannel, sessionManager, sessionId);
+    }
+    catch (error) {
+        console.error('Stream error:', error);
+        await threadChannel.send(`❌ Failed to process: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}
+async function handleSDKMessage(message, channel, state, sessionManager, sessionId) {
+    switch (message.type) {
+        case 'assistant':
+            // Final assistant message with complete response
+            const content = extractTextFromMessage(message.message);
+            if (content) {
+                await sendCompleteMessage(channel, content, state.planContent, state.messagePrefix);
+                state.planContent = null; // Clear plan after sending
+                state.messagePrefix = null; // Clear prefix after using
+            }
+            break;
+        case 'stream_event':
+            // Partial message during streaming
+            await handleStreamEvent(message, channel, state);
+            break;
+        case 'user':
+            // User message (echo or replay) - ignore for Discord
+            break;
+        case 'system':
+            // System initialization message
+            if (message.subtype === 'init') {
+                console.log(`Session ${message.session_id} initialized with model ${message.model}`);
+                // Update database with real SDK session ID
+                await sessionManager.updateSessionId(sessionId, message.session_id, channel.id);
+            }
+            else if (message.subtype === 'compact_boundary') {
+                console.log(`Conversation compacted: ${message.compact_metadata.trigger}`);
+                await channel.send(`🗜️ Conversation history compacted (${message.compact_metadata.pre_tokens} tokens)`);
+            }
+            break;
+        case 'result':
+            // Final result message
+            if (message.subtype === 'success') {
+                console.log(`✅ Session completed: ${message.num_turns} turns, $${message.total_cost_usd.toFixed(4)}`);
+            }
+            else {
+                // Error result
+                const errors = 'errors' in message ? message.errors : [];
+                await channel.send(`❌ **Error**: ${errors.join(', ')}`);
+            }
+            break;
+    }
+}
+async function handleStreamEvent(message, channel, state) {
+    const event = message.event;
+    switch (event.type) {
+        case 'message_start':
+            // New message starting
+            break;
+        case 'content_block_start':
+            // New content block starting
+            if (event.content_block.type === 'tool_use') {
+                // Tool use starting
+                state.currentToolUse = {
+                    name: event.content_block.name,
+                    input: '',
+                    id: event.content_block.id,
+                };
+            }
+            break;
+        case 'content_block_delta':
+            // Content streaming - accumulate tool inputs for display
+            if (event.delta.type === 'input_json_delta') {
+                // Accumulate tool input JSON
+                if (state.currentToolUse) {
+                    state.currentToolUse.input += event.delta.partial_json;
+                }
+            }
+            // Text deltas are ignored - we'll get the complete text in the 'assistant' message
+            break;
+        case 'content_block_stop':
+            // Content block finished - NOW send complete block to Discord
+            if (state.currentToolUse) {
+                // Special handling for ExitPlanMode - extract plan for attachment
+                if (state.currentToolUse.name === 'ExitPlanMode') {
+                    try {
+                        const input = JSON.parse(state.currentToolUse.input);
+                        if (input.plan) {
+                            state.planContent = input.plan;
+                            // Send notification that plan is ready
+                            const msg = await channel.send('📋 **Plan Generated** - see attachment below');
+                            state.progressMessages.push(msg);
+                        }
+                    }
+                    catch (e) {
+                        console.error('Failed to parse ExitPlanMode input:', e);
+                    }
+                }
+                else {
+                    // Send complete tool use message for other tools
+                    const shouldShow = shouldShowToolMessage(state.currentToolUse.name, state.currentToolUse.input);
+                    if (shouldShow) {
+                        const emoji = getToolEmoji(state.currentToolUse.name);
+                        const description = getToolDescription(state.currentToolUse.name, state.currentToolUse.input, state.workingDir);
+                        // Strip MCP server prefix from tool name for cleaner display
+                        const displayName = stripMcpPrefix(state.currentToolUse.name);
+                        const msg = await channel.send(`\`\`\`\n${emoji} ${displayName}: ${description}\n\`\`\``);
+                        state.toolMessages.push(msg);
+                    }
+                }
+                state.currentToolUse = null;
+            }
+            break;
+        case 'message_delta':
+            // Message metadata update (stop_reason, usage, etc.)
+            if (event.delta.stop_reason === 'max_tokens') {
+                await channel.send('⚠️ Response truncated due to token limit');
+            }
+            break;
+        case 'message_stop':
+            // Message complete - nothing to do, we'll get the complete text in 'assistant' message
+            break;
+    }
+}
+function extractTextFromMessage(message) {
+    let text = '';
+    if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+            if (block.type === 'text') {
+                text += block.text;
+            }
+        }
+    }
+    else if (typeof message.content === 'string') {
+        text = message.content;
+    }
+    return text.trim();
+}
+async function sendCompleteMessage(channel, content, planContent, messagePrefix) {
+    console.log(`📤 Sending message to Discord (${content.length} chars)`);
+    // Prepend prefix if provided
+    let fullContent = content;
+    if (messagePrefix) {
+        fullContent = `${messagePrefix}\n\n${content}`;
+    }
+    // Split message if it exceeds Discord's 2000 character limit
+    const chunks = splitMessage(fullContent, 2000);
+    for (let i = 0; i < chunks.length; i++) {
+        const chunk = chunks[i];
+        // Attach plan file only on the last chunk
+        if (i === chunks.length - 1 && planContent) {
+            const attachment = new AttachmentBuilder(Buffer.from(planContent, 'utf-8'), {
+                name: `plan-${Date.now()}.md`,
+                description: 'Claude Code Plan',
+            });
+            await channel.send({
+                content: chunk,
+                files: [attachment],
+            });
+        }
+        else {
+            await channel.send(chunk);
+        }
+    }
+}
+function splitMessage(text, maxLength) {
+    if (text.length <= maxLength) {
+        return [text];
+    }
+    const chunks = [];
+    let currentChunk = '';
+    const lines = text.split('\n');
+    for (const line of lines) {
+        if (currentChunk.length + line.length + 1 > maxLength) {
+            // Current line would exceed limit
+            if (currentChunk) {
+                chunks.push(currentChunk);
+                currentChunk = '';
+            }
+            // If single line is too long, split it by words
+            if (line.length > maxLength) {
+                const words = line.split(' ');
+                for (const word of words) {
+                    if (currentChunk.length + word.length + 1 > maxLength) {
+                        chunks.push(currentChunk);
+                        currentChunk = word;
+                    }
+                    else {
+                        currentChunk += (currentChunk ? ' ' : '') + word;
+                    }
+                }
+            }
+            else {
+                currentChunk = line;
+            }
+        }
+        else {
+            currentChunk += (currentChunk ? '\n' : '') + line;
+        }
+    }
+    if (currentChunk) {
+        chunks.push(currentChunk);
+    }
+    return chunks;
+}
+function shouldShowToolMessage(toolName, input) {
+    try {
+        const params = JSON.parse(input);
+        // Filter out internal file operations
+        if (toolName === 'Read' || toolName === 'Write' || toolName === 'Edit') {
+            const filePath = params.file_path || '';
+            // Hide operations on internal files
+            if (filePath.includes('.claude-cron') ||
+                filePath.includes('.claude/') ||
+                filePath.includes('CLAUDE.md')) {
+                return false;
+            }
+        }
+        // Filter out cron tool usage messages - keep them silent/internal
+        if (toolName.startsWith('cron_')) {
+            return false;
+        }
+        return true;
+    }
+    catch (e) {
+        // If we can't parse, show the message
+        return true;
+    }
+}
+function stripMcpPrefix(toolName) {
+    // Remove MCP server prefix like "mcp__cordbot-dynamic-tools__"
+    const mcpPrefixRegex = /^mcp__[^_]+__/;
+    return toolName.replace(mcpPrefixRegex, '');
+}
+function stripWorkingDirPrefix(filePath, workingDir) {
+    // If the file path starts with the working directory, strip it to show relative path
+    if (filePath.startsWith(workingDir)) {
+        const relative = filePath.slice(workingDir.length);
+        // Remove leading slash if present
+        return relative.startsWith('/') ? relative.slice(1) : relative;
+    }
+    return filePath;
+}
+function getToolEmoji(toolName) {
+    // Strip MCP prefix for emoji lookup
+    const cleanName = stripMcpPrefix(toolName);
+    const emojiMap = {
+        Bash: '⚙️',
+        Read: '📄',
+        Write: '✏️',
+        Edit: '✏️',
+        Glob: '🔍',
+        Grep: '🔎',
+        WebFetch: '🌐',
+        WebSearch: '🔎',
+        Task: '🤖',
+        shareFile: '📎',
+        cron_list_jobs: '⏰',
+        cron_add_job: '➕',
+        cron_remove_job: '🗑️',
+        cron_update_job: '✏️',
+        gmail_send_email: '📧',
+        gmail_list_messages: '📬',
+    };
+    return emojiMap[cleanName] || '🔧';
+}
+function getToolDescription(toolName, input, workingDir) {
+    try {
+        const params = JSON.parse(input);
+        switch (toolName) {
+            case 'Bash':
+                return params.description || params.command || 'Running command';
+            case 'Read':
+                return stripWorkingDirPrefix(params.file_path || 'Reading file', workingDir);
+            case 'Write':
+                return stripWorkingDirPrefix(params.file_path || 'Writing file', workingDir);
+            case 'Edit':
+                return stripWorkingDirPrefix(params.file_path || 'Editing file', workingDir);
+            case 'Glob':
+                return params.pattern || 'Searching files';
+            case 'Grep':
+                return `Searching for "${params.pattern}"`;
+            case 'WebFetch':
+                return params.url || 'Fetching URL';
+            case 'WebSearch':
+                return `Searching: ${params.query}`;
+            case 'Task':
+                return params.description || params.prompt?.slice(0, 100) || 'Running task';
+            case 'AskUserQuestion':
+                return 'Asking question';
+            case 'TaskCreate':
+                return params.subject || 'Creating task';
+            case 'TaskUpdate':
+                return `Updating task ${params.taskId}`;
+            case 'TaskList':
+                return 'Listing tasks';
+            case 'EnterPlanMode':
+                return 'Entering plan mode';
+            case 'shareFile':
+                return `Sharing file: ${params.filePath}`;
+            case 'cron_list_jobs':
+                return 'Listing scheduled jobs';
+            case 'cron_add_job':
+                return `Adding job: ${params.name}`;
+            case 'cron_remove_job':
+                return `Removing job: ${params.name}`;
+            case 'cron_update_job':
+                return `Updating job: ${params.name}`;
+            case 'gmail_send_email':
+                return `Sending email to ${params.to}`;
+            case 'gmail_list_messages':
+                return params.query ? `Listing emails: ${params.query}` : 'Listing recent emails';
+            default:
+                // For unknown tools, try to extract first parameter value
+                const firstValue = Object.values(params)[0];
+                if (typeof firstValue === 'string') {
+                    return firstValue.slice(0, 100);
+                }
+                return 'Running tool';
+        }
+    }
+    catch (e) {
+        // If JSON parsing fails, return truncated raw input
+        return input.slice(0, 100);
+    }
+}
+async function attachSharedFiles(channel, sessionManager, sessionId) {
+    const filesToShare = sessionManager.getFilesToShare(sessionId);
+    if (filesToShare.length === 0) {
+        return;
+    }
+    try {
+        const attachments = filesToShare.map(filePath => new AttachmentBuilder(filePath));
+        await channel.send({
+            content: '📎 Shared files:',
+            files: attachments
+        });
+        console.log(`📎 Attached ${filesToShare.length} shared file(s)`);
+    }
+    catch (error) {
+        console.error('Failed to attach shared files:', error);
+        await channel.send(`❌ Failed to attach shared files: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+}

package/dist/auth.js

@@ -0,0 +1,161 @@
+import express from 'express';
+import open from 'open';
+import chalk from 'chalk';
+import ora from 'ora';
+const WEB_SERVICE_URL = process.env.WEB_SERVICE_URL || 'https://cordbot.io';
+export async function authenticateWithWebService() {
+    // Find available port
+    const port = await findAvailablePort(3456);
+    const callbackUrl = `http://localhost:${port}/callback`;
+    console.log(chalk.cyan('\n🔐 Cordbot Authentication\n'));
+    console.log(chalk.gray('To use Cordbot, you need to authenticate with the web service.\n'));
+    console.log(chalk.yellow('Press ENTER to open your browser and sign in...'));
+    // Set stdin to raw mode temporarily
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    // Wait for user to press ENTER
+    await waitForEnter();
+    // Restore stdin
+    if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+    }
+    // Start local server
+    const result = await startCallbackServer(port, callbackUrl);
+    return result;
+}
+async function waitForEnter() {
+    return new Promise((resolve) => {
+        const onData = (key) => {
+            // Check for Enter key (carriage return or newline)
+            if (key[0] === 13 || key[0] === 10) {
+                process.stdin.removeListener('data', onData);
+                resolve();
+            }
+        };
+        process.stdin.on('data', onData);
+    });
+}
+async function findAvailablePort(startPort) {
+    let port = startPort;
+    while (port < startPort + 100) {
+        try {
+            await new Promise((resolve, reject) => {
+                const server = express().listen(port)
+                    .on('listening', () => {
+                    server.close();
+                    resolve();
+                })
+                    .on('error', reject);
+            });
+            return port;
+        }
+        catch {
+            port++;
+        }
+    }
+    throw new Error('Could not find available port');
+}
+async function startCallbackServer(port, callbackUrl) {
+    return new Promise((resolve) => {
+        const app = express();
+        let server;
+        const spinner = ora('Waiting for authentication...').start();
+        // Timeout after 5 minutes
+        const timeout = setTimeout(() => {
+            spinner.fail(chalk.red('Authentication timed out'));
+            server?.close();
+            resolve(null);
+        }, 5 * 60 * 1000);
+        app.get('/callback', (req, res) => {
+            const { token, guildId, error } = req.query;
+            if (error) {
+                spinner.fail(chalk.red('Authentication failed'));
+                if (error === 'no_bot') {
+                    console.log(chalk.yellow('\n⚠️  No bot configured'));
+                    console.log(chalk.gray(`\nPlease visit ${WEB_SERVICE_URL} to:`));
+                    console.log(chalk.gray('  1. Sign in with Discord'));
+                    console.log(chalk.gray('  2. Set up your Discord bot'));
+                    console.log(chalk.gray('  3. Configure your bot token'));
+                    console.log(chalk.gray('\nThen run "npx cordbot" again.\n'));
+                }
+                else if (error === 'not_authenticated') {
+                    console.log(chalk.yellow('\n⚠️  Not authenticated'));
+                    console.log(chalk.gray(`\nPlease visit ${WEB_SERVICE_URL} to sign in first.\n`));
+                }
+                else {
+                    console.log(chalk.red(`\n❌ Error: ${error}\n`));
+                }
+                res.send(`
+          <!DOCTYPE html>
+          <html>
+            <head>
+              <title>Cordbot - Authentication Failed</title>
+              <style>
+                body { font-family: system-ui, -apple-system, sans-serif; max-width: 600px; margin: 100px auto; padding: 20px; text-align: center; }
+                .error { color: #dc2626; margin: 20px 0; }
+                .message { color: #6b7280; line-height: 1.6; }
+              </style>
+            </head>
+            <body>
+              <h1>❌ Authentication Failed</h1>
+              <p class="error">${error === 'no_bot' ? 'No bot configured' : error === 'not_authenticated' ? 'Not authenticated' : String(error)}</p>
+              <p class="message">Please check the CLI for instructions.</p>
+              <p class="message">You can close this window.</p>
+            </body>
+          </html>
+        `);
+                clearTimeout(timeout);
+                setTimeout(() => {
+                    server?.close();
+                    resolve(null);
+                }, 2000);
+                return;
+            }
+            if (!token || !guildId) {
+                spinner.fail(chalk.red('Invalid response from server'));
+                res.send('Invalid response');
+                clearTimeout(timeout);
+                server?.close();
+                resolve(null);
+                return;
+            }
+            spinner.succeed(chalk.green('Successfully authenticated!'));
+            res.send(`
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Cordbot - Authentication Successful</title>
+            <style>
+              body { font-family: system-ui, -apple-system, sans-serif; max-width: 600px; margin: 100px auto; padding: 20px; text-align: center; }
+              .success { color: #16a34a; margin: 20px 0; }
+              .message { color: #6b7280; line-height: 1.6; }
+            </style>
+          </head>
+          <body>
+            <h1>✅ Authentication Successful!</h1>
+            <p class="success">Your bot is now authenticated</p>
+            <p class="message">You can close this window and return to the CLI.</p>
+          </body>
+        </html>
+      `);
+            clearTimeout(timeout);
+            setTimeout(() => {
+                server?.close();
+                resolve({
+                    botToken: token,
+                    guildId: guildId,
+                });
+            }, 2000);
+        });
+        server = app.listen(port, () => {
+            // Open browser to web service auth page
+            const authUrl = `${WEB_SERVICE_URL}/auth/cli?callback=${encodeURIComponent(callbackUrl)}`;
+            open(authUrl).catch(err => {
+                spinner.warn(chalk.yellow('Could not open browser automatically'));
+                console.log(chalk.gray(`\nPlease open this URL in your browser:\n${authUrl}\n`));
+            });
+        });
+    });
+}

package/dist/cli.js

@@ -0,0 +1,128 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs';
+import path from 'path';
+import dotenv from 'dotenv';
+import { startBot } from './index.js';
+import { authenticateWithWebService } from './auth.js';
+export async function run() {
+    console.log(chalk.cyan.bold('\n🤖 Cordbot - Discord Bot powered by Claude Code SDK\n'));
+    const cwd = process.cwd();
+    const envPath = path.join(cwd, '.env');
+    // Check if .env exists in current directory
+    if (!fs.existsSync(envPath)) {
+        console.log(chalk.yellow('No .env file found in current directory.'));
+        console.log(chalk.gray(`Current directory: ${cwd}\n`));
+        // Use web service authentication flow
+        const authResult = await authenticateWithWebService();
+        if (!authResult) {
+            console.log(chalk.red('\n❌ Authentication failed. Exiting.\n'));
+            process.exit(1);
+        }
+        // Prompt for Claude API key and other config
+        const config = await promptForConfiguration(authResult.botToken, authResult.guildId);
+        // Write .env file
+        const spinner = ora('Creating .env file...').start();
+        writeEnvFile(envPath, config);
+        spinner.succeed(chalk.green('.env file created successfully!'));
+        console.log(chalk.gray(`\n📄 Configuration saved to: ${envPath}\n`));
+    }
+    // Load environment variables
+    dotenv.config({ path: envPath });
+    // Validate configuration
+    const spinner = ora('Validating configuration...').start();
+    const validation = validateConfig();
+    if (!validation.valid) {
+        spinner.fail(chalk.red('Configuration validation failed'));
+        console.log(chalk.red('\n❌ Missing required environment variables:'));
+        validation.missing.forEach(key => {
+            console.log(chalk.red(`   - ${key}`));
+        });
+        console.log(chalk.yellow(`\nPlease update ${envPath} with the missing values.\n`));
+        process.exit(1);
+    }
+    spinner.succeed(chalk.green('Configuration valid'));
+    // Start the bot
+    console.log(chalk.cyan('\n🚀 Starting Cordbot...\n'));
+    await startBot(cwd);
+}
+async function promptForConfiguration(botToken, guildId) {
+    console.log(chalk.cyan('\n📝 Please provide your Claude API key:\n'));
+    const answers = await inquirer.prompt([
+        {
+            type: 'password',
+            name: 'ANTHROPIC_API_KEY',
+            message: 'Anthropic API Key:',
+            mask: '*',
+            validate: (input) => {
+                if (!input || input.trim().length === 0) {
+                    return 'Anthropic API Key is required';
+                }
+                if (!input.startsWith('sk-ant-')) {
+                    return 'Anthropic API Key should start with "sk-ant-"';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'list',
+            name: 'LOG_LEVEL',
+            message: 'Log Level:',
+            choices: ['info', 'debug', 'warn', 'error'],
+            default: 'info',
+        },
+        {
+            type: 'input',
+            name: 'ARCHIVE_AFTER_DAYS',
+            message: 'Archive inactive sessions after (days):',
+            default: '30',
+            validate: (input) => {
+                const num = parseInt(input);
+                if (isNaN(num) || num < 1) {
+                    return 'Must be a positive number';
+                }
+                return true;
+            },
+        },
+    ]);
+    return {
+        DISCORD_BOT_TOKEN: botToken,
+        DISCORD_GUILD_ID: guildId,
+        ...answers,
+    };
+}
+function writeEnvFile(envPath, config) {
+    const lines = [
+        '# Cordbot Configuration',
+        '# Generated by cordbot agent',
+        '',
+        '# Discord Configuration',
+        `DISCORD_BOT_TOKEN=${config.DISCORD_BOT_TOKEN}`,
+        `DISCORD_GUILD_ID=${config.DISCORD_GUILD_ID}`,
+        '',
+        '# Anthropic Configuration',
+        `ANTHROPIC_API_KEY=${config.ANTHROPIC_API_KEY}`,
+        '',
+        '# Optional Settings',
+        `LOG_LEVEL=${config.LOG_LEVEL || 'info'}`,
+        `ARCHIVE_AFTER_DAYS=${config.ARCHIVE_AFTER_DAYS || '30'}`,
+        '',
+        '# Security Note:',
+        '# This file contains sensitive credentials. Never commit it to git!',
+        '# It should be in your .gitignore file.',
+    ];
+    fs.writeFileSync(envPath, lines.join('\n'), 'utf-8');
+}
+function validateConfig() {
+    const required = [
+        'DISCORD_BOT_TOKEN',
+        'DISCORD_GUILD_ID',
+        'ANTHROPIC_API_KEY',
+    ];
+    const missing = required.filter(key => !process.env[key]);
+    return {
+        valid: missing.length === 0,
+        missing,
+    };
+}

package/dist/discord/client.js

@@ -0,0 +1,24 @@
+import { Client, GatewayIntentBits } from 'discord.js';
+export async function createDiscordClient(config) {
+    const client = new Client({
+        intents: [
+            GatewayIntentBits.Guilds,
+            GatewayIntentBits.GuildMessages,
+            GatewayIntentBits.MessageContent,
+        ],
+    });
+    // Wait for client to be ready
+    await new Promise((resolve, reject) => {
+        client.once('clientReady', () => {
+            console.log(`✅ Discord bot logged in as ${client.user?.tag}`);
+            resolve();
+        });
+        client.once('error', (error) => {
+            console.error('❌ Discord client error:', error);
+            reject(error);
+        });
+        // Connect to Discord
+        client.login(config.token).catch(reject);
+    });
+    return client;
+}