@cordbot/agent 1.0.0

package/dist/discord/events.js

@@ -0,0 +1,283 @@
+import { TextChannel } from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+import { streamToDiscord } from '../agent/stream.js';
+import { getChannelMapping, syncNewChannel, updateChannelClaudeMdTopic } from './sync.js';
+import { DiscordPermissionManager } from '../permissions/discord.js';
+// Global permission manager instance
+export const permissionManager = new DiscordPermissionManager();
+// Queue to prevent concurrent processing of messages in the same thread
+const threadLocks = new Map();
+export function setupEventHandlers(client, sessionManager, channelMappings, basePath, guildId, cronRunner) {
+    // Handle new messages
+    client.on('messageCreate', async (message) => {
+        await handleMessageWithLock(message, sessionManager, channelMappings);
+    });
+    // Handle new channels being created
+    client.on('channelCreate', async (channel) => {
+        // Only handle text channels in the configured guild
+        if (!(channel instanceof TextChannel))
+            return;
+        if (channel.guildId !== guildId)
+            return;
+        try {
+            console.log(`\n🆕 New channel detected: #${channel.name}`);
+            // Sync the new channel
+            const mapping = await syncNewChannel(channel, basePath);
+            // Add to mappings array so it's immediately available
+            channelMappings.push(mapping);
+            // Start watching the cron file for this channel
+            cronRunner.addChannel(mapping);
+            console.log(`✅ Channel #${channel.name} synced and ready\n`);
+        }
+        catch (error) {
+            console.error(`❌ Error syncing new channel #${channel.name}:`, error);
+        }
+    });
+    // Handle channels being deleted
+    client.on('channelDelete', async (channel) => {
+        // Only handle text channels in the configured guild
+        if (!(channel instanceof TextChannel))
+            return;
+        if (channel.guildId !== guildId)
+            return;
+        try {
+            console.log(`\n🗑️  Channel deleted: #${channel.name}`);
+            // Find the mapping for this channel
+            const mappingIndex = channelMappings.findIndex(m => m.channelId === channel.id);
+            if (mappingIndex === -1) {
+                console.log(`Channel #${channel.name} was not synced, skipping cleanup`);
+                return;
+            }
+            const mapping = channelMappings[mappingIndex];
+            // Stop watching the cron file
+            cronRunner.removeChannel(channel.id);
+            // Remove from mappings array
+            channelMappings.splice(mappingIndex, 1);
+            // Delete the folder if it exists
+            if (fs.existsSync(mapping.folderPath)) {
+                fs.rmSync(mapping.folderPath, { recursive: true, force: true });
+                console.log(`📁 Deleted folder: ${mapping.folderPath}`);
+            }
+            console.log(`✅ Channel #${channel.name} cleanup complete\n`);
+        }
+        catch (error) {
+            console.error(`❌ Error cleaning up channel #${channel.name}:`, error);
+        }
+    });
+    // Handle channel updates (e.g., topic changes)
+    client.on('channelUpdate', async (oldChannel, newChannel) => {
+        // Only handle text channels in the configured guild
+        if (!(newChannel instanceof TextChannel))
+            return;
+        if (newChannel.guildId !== guildId)
+            return;
+        // Check if topic changed
+        const oldTopic = oldChannel.topic || '';
+        const newTopic = newChannel.topic || '';
+        if (oldTopic !== newTopic) {
+            const mapping = getChannelMapping(newChannel.id, channelMappings);
+            if (mapping) {
+                try {
+                    console.log(`\n📝 Topic updated for #${newChannel.name}`);
+                    await updateChannelClaudeMdTopic(mapping.claudeMdPath, newTopic);
+                    console.log(`✅ Synced topic to CLAUDE.md\n`);
+                }
+                catch (error) {
+                    console.error(`❌ Error syncing topic for #${newChannel.name}:`, error);
+                }
+            }
+        }
+    });
+    // Handle errors
+    client.on('error', (error) => {
+        console.error('Discord client error:', error);
+    });
+    // Handle warnings
+    client.on('warn', (warning) => {
+        console.warn('Discord client warning:', warning);
+    });
+    // Handle button interactions for permissions
+    client.on('interactionCreate', async (interaction) => {
+        if (!interaction.isButton())
+            return;
+        const customId = interaction.customId;
+        if (customId.startsWith('permission_')) {
+            // Parse customId - handle underscores in requestId
+            const parts = customId.split('_');
+            const [, action, ...requestIdParts] = parts;
+            const requestId = requestIdParts.join('_'); // Rejoin in case requestId has underscores
+            const approved = action === 'approve';
+            // Try to handle the permission response
+            const handled = permissionManager.handlePermissionResponse(requestId, approved);
+            if (handled) {
+                // Successfully handled - update the message
+                await interaction.update({
+                    content: `${interaction.message.content}\n\n${approved ? '✅ Approved' : '❌ Denied'}`,
+                    components: [], // Remove buttons
+                });
+            }
+            else {
+                // Not found or already handled - respond ephemerally
+                await interaction.reply({
+                    content: '⚠️ This permission request has already been handled or expired.',
+                    ephemeral: true,
+                });
+            }
+        }
+    });
+}
+async function handleMessageWithLock(message, sessionManager, channelMappings) {
+    // Determine thread ID for locking
+    const threadId = message.channel.isThread()
+        ? message.channel.id
+        : message.id; // For new threads, use message ID temporarily
+    // Wait for any existing processing on this thread to complete
+    const existingLock = threadLocks.get(threadId);
+    if (existingLock) {
+        await existingLock;
+    }
+    // Create new lock for this message
+    const newLock = handleMessage(message, sessionManager, channelMappings)
+        .finally(() => {
+        // Remove lock when done
+        if (threadLocks.get(threadId) === newLock) {
+            threadLocks.delete(threadId);
+        }
+    });
+    threadLocks.set(threadId, newLock);
+    await newLock;
+}
+async function handleMessage(message, sessionManager, channelMappings) {
+    // Ignore bot messages
+    if (message.author.bot)
+        return;
+    // Determine the parent channel ID
+    let parentChannelId;
+    if (message.channel.isThread()) {
+        parentChannelId = message.channel.parentId || message.channel.id;
+    }
+    else {
+        parentChannelId = message.channelId;
+    }
+    // Get channel mapping
+    const mapping = getChannelMapping(parentChannelId, channelMappings);
+    if (!mapping) {
+        // Not a synced channel - ignore
+        return;
+    }
+    try {
+        // Check if there's a pending cron session for this channel
+        let pendingCronSession = null;
+        if (!message.channel.isThread()) {
+            pendingCronSession = sessionManager.getPendingCronSession(parentChannelId);
+        }
+        // Determine thread context
+        let threadId;
+        let threadChannel;
+        if (message.channel.isThread()) {
+            // User is replying in an existing thread
+            threadId = message.channel.id;
+            threadChannel = message.channel;
+        }
+        else {
+            // User is writing in the channel - create a new thread
+            const textChannel = message.channel;
+            // Create thread name from message content
+            const threadName = `${message.author.username}: ${message.content.slice(0, 50)}${message.content.length > 50 ? '...' : ''}`;
+            const thread = await textChannel.threads.create({
+                name: threadName,
+                autoArchiveDuration: 1440, // 24 hours
+                reason: 'Claude conversation',
+                startMessage: message,
+            });
+            threadId = thread.id;
+            threadChannel = thread;
+        }
+        // Determine session ID and working directory
+        let sessionId;
+        let isNew;
+        let workingDir;
+        if (pendingCronSession) {
+            // Continue the cron session in this new thread
+            sessionId = pendingCronSession.sessionId;
+            workingDir = pendingCronSession.workingDir;
+            isNew = false;
+            // Map the thread to the existing cron session
+            sessionManager.createMappingWithSessionId(threadId, parentChannelId, message.id, sessionId, workingDir);
+            console.log(`🔗 Continuing cron session ${sessionId} in thread ${threadId}`);
+        }
+        else {
+            // Normal flow: get or create agent session tied to this thread
+            const result = await sessionManager.getOrCreateSession(threadId, parentChannelId, message.id, mapping.folderPath);
+            sessionId = result.sessionId;
+            isNew = result.isNew;
+            workingDir = mapping.folderPath;
+            if (!isNew) {
+                console.log(`📖 Resuming session ${sessionId} for thread ${threadId}`);
+            }
+            else {
+                console.log(`✨ Created new session ${sessionId} for thread ${threadId}`);
+            }
+        }
+        // Set channel context for permission requests
+        sessionManager.setChannelContext(sessionId, threadChannel);
+        // Set working directory context for built-in tools (cron, etc.)
+        sessionManager.setWorkingDirContext(sessionId, workingDir);
+        try {
+            // Handle attachments if present
+            let userMessage = message.content;
+            if (message.attachments.size > 0) {
+                const attachmentInfo = await downloadAttachments(message, workingDir);
+                if (attachmentInfo.length > 0) {
+                    userMessage = `${message.content}\n\n[Files attached and saved to working directory: ${attachmentInfo.join(', ')}]`;
+                }
+            }
+            // Create query for Claude
+            // For new sessions, pass null to let SDK create a fresh session
+            // For existing sessions, pass the real SDK session ID to resume
+            const queryResult = sessionManager.createQuery(userMessage, isNew ? null : sessionId, workingDir);
+            // Stream response from Claude agent to Discord
+            await streamToDiscord(queryResult, threadChannel, sessionManager, sessionId, workingDir);
+        }
+        finally {
+            // Clear contexts after execution
+            sessionManager.clearChannelContext(sessionId);
+            sessionManager.clearWorkingDirContext(sessionId);
+        }
+    }
+    catch (error) {
+        console.error('Error handling message:', error);
+        // Try to send error message to user
+        try {
+            await message.reply(`❌ Sorry, I encountered an error processing your message: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        catch (replyError) {
+            console.error('Failed to send error message to user:', replyError);
+        }
+    }
+}
+async function downloadAttachments(message, workingDir) {
+    const attachmentNames = [];
+    for (const attachment of message.attachments.values()) {
+        try {
+            // Fetch the attachment
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                console.error(`Failed to download attachment ${attachment.name}: ${response.statusText}`);
+                continue;
+            }
+            // Get the file content
+            const buffer = Buffer.from(await response.arrayBuffer());
+            // Save to channel folder (overwrite if exists)
+            const filePath = path.join(workingDir, attachment.name);
+            fs.writeFileSync(filePath, buffer);
+            attachmentNames.push(attachment.name);
+            console.log(`📎 Downloaded attachment: ${attachment.name} (${buffer.length} bytes)`);
+        }
+        catch (error) {
+            console.error(`Failed to download attachment ${attachment.name}:`, error);
+        }
+    }
+    return attachmentNames;
+}

package/dist/discord/sync.js

@@ -0,0 +1,148 @@
+import { TextChannel } from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function syncChannelsOnStartup(client, guildId, basePath) {
+    const guild = client.guilds.cache.get(guildId);
+    if (!guild) {
+        throw new Error(`Guild ${guildId} not found. Make sure the bot is added to the server.`);
+    }
+    console.log(`🔄 Syncing channels for guild: ${guild.name}`);
+    const mappings = [];
+    // Fetch all text channels
+    const channels = guild.channels.cache.filter(channel => channel.isTextBased() && !channel.isThread());
+    for (const [, channel] of channels) {
+        if (!(channel instanceof TextChannel))
+            continue;
+        const channelName = channel.name;
+        const folderPath = path.join(basePath, channelName);
+        const claudeMdPath = path.join(folderPath, 'CLAUDE.md');
+        const cronPath = path.join(folderPath, '.claude-cron');
+        const claudeFolderPath = path.join(folderPath, '.claude');
+        const skillsPath = path.join(claudeFolderPath, 'skills');
+        // Create folder structure if it doesn't exist
+        if (!fs.existsSync(folderPath)) {
+            fs.mkdirSync(folderPath, { recursive: true });
+            console.log(`📁 Created folder for #${channelName}`);
+        }
+        if (!fs.existsSync(skillsPath)) {
+            fs.mkdirSync(skillsPath, { recursive: true });
+            console.log(`📁 Created .claude/skills for #${channelName}`);
+        }
+        // Create CLAUDE.md if missing and sync Discord topic to it (one-way sync)
+        if (!fs.existsSync(claudeMdPath)) {
+            await createChannelClaudeMd(claudeMdPath, channelName, channel.topic || '');
+            console.log(`📄 Created CLAUDE.md for #${channelName}`);
+        }
+        else {
+            // Update existing CLAUDE.md with Discord topic
+            await updateChannelClaudeMdTopic(claudeMdPath, channel.topic || '');
+        }
+        // Create empty .claude-cron if missing (Claude will manage via skill)
+        if (!fs.existsSync(cronPath)) {
+            fs.writeFileSync(cronPath, 'jobs: []\n', 'utf-8');
+            console.log(`⏰ Created .claude-cron for #${channelName}`);
+        }
+        // Copy cron management skill to .claude/skills
+        const skillTemplatePath = path.join(__dirname, '..', '..', 'templates', 'cron-skill.md');
+        const skillDestPath = path.join(skillsPath, 'cron.md');
+        if (!fs.existsSync(skillDestPath)) {
+            fs.copyFileSync(skillTemplatePath, skillDestPath);
+            console.log(`🔧 Added cron management skill for #${channelName}`);
+        }
+        mappings.push({
+            channelId: channel.id,
+            channelName,
+            folderPath,
+            claudeMdPath,
+            cronPath,
+        });
+    }
+    console.log(`✅ Synced ${mappings.length} channels`);
+    return mappings;
+}
+async function createChannelClaudeMd(claudeMdPath, channelName, discordTopic) {
+    // Create a minimal CLAUDE.md with Discord topic synced
+    const content = discordTopic
+        ? `# ${channelName}\n\n> ${discordTopic}\n\n`
+        : `# ${channelName}\n\n`;
+    fs.writeFileSync(claudeMdPath, content, 'utf-8');
+}
+export async function updateChannelClaudeMdTopic(claudeMdPath, discordTopic) {
+    const content = fs.readFileSync(claudeMdPath, 'utf-8');
+    const lines = content.split('\n');
+    // Find or update the topic line (should be after the heading)
+    let updatedLines = [];
+    let foundHeading = false;
+    let foundTopic = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!foundHeading && line.trim().startsWith('#')) {
+            updatedLines.push(line);
+            updatedLines.push('');
+            if (discordTopic) {
+                updatedLines.push(`> ${discordTopic}`);
+                updatedLines.push('');
+            }
+            foundHeading = true;
+            foundTopic = true;
+            continue;
+        }
+        // Skip old topic line
+        if (foundHeading && !foundTopic && line.trim().startsWith('>')) {
+            foundTopic = true;
+            if (discordTopic) {
+                updatedLines.push(`> ${discordTopic}`);
+            }
+            continue;
+        }
+        updatedLines.push(line);
+    }
+    fs.writeFileSync(claudeMdPath, updatedLines.join('\n'), 'utf-8');
+}
+export function getChannelMapping(channelId, mappings) {
+    return mappings.find(m => m.channelId === channelId);
+}
+export async function syncNewChannel(channel, basePath) {
+    const channelName = channel.name;
+    const folderPath = path.join(basePath, channelName);
+    const claudeMdPath = path.join(folderPath, 'CLAUDE.md');
+    const cronPath = path.join(folderPath, '.claude-cron');
+    const claudeFolderPath = path.join(folderPath, '.claude');
+    const skillsPath = path.join(claudeFolderPath, 'skills');
+    // Create folder structure
+    if (!fs.existsSync(folderPath)) {
+        fs.mkdirSync(folderPath, { recursive: true });
+        console.log(`📁 Created folder for #${channelName}`);
+    }
+    if (!fs.existsSync(skillsPath)) {
+        fs.mkdirSync(skillsPath, { recursive: true });
+        console.log(`📁 Created .claude/skills for #${channelName}`);
+    }
+    // Create CLAUDE.md
+    if (!fs.existsSync(claudeMdPath)) {
+        await createChannelClaudeMd(claudeMdPath, channelName, channel.topic || '');
+        console.log(`📄 Created CLAUDE.md for #${channelName}`);
+    }
+    // Create empty .claude-cron
+    if (!fs.existsSync(cronPath)) {
+        fs.writeFileSync(cronPath, 'jobs: []\n', 'utf-8');
+        console.log(`⏰ Created .claude-cron for #${channelName}`);
+    }
+    // Copy cron management skill
+    const skillTemplatePath = path.join(__dirname, '..', '..', 'templates', 'cron-skill.md');
+    const skillDestPath = path.join(skillsPath, 'cron.md');
+    if (!fs.existsSync(skillDestPath)) {
+        fs.copyFileSync(skillTemplatePath, skillDestPath);
+        console.log(`🔧 Added cron management skill for #${channelName}`);
+    }
+    return {
+        channelId: channel.id,
+        channelName,
+        folderPath,
+        claudeMdPath,
+        cronPath,
+    };
+}

package/dist/index.js

@@ -0,0 +1,72 @@
+import { initializeClaudeFolder } from "./init.js";
+import { createDiscordClient } from "./discord/client.js";
+import { syncChannelsOnStartup } from "./discord/sync.js";
+import { setupEventHandlers } from "./discord/events.js";
+import { SessionDatabase } from "./storage/database.js";
+import { SessionManager } from "./agent/manager.js";
+import { CronRunner } from "./scheduler/runner.js";
+export async function startBot(cwd) {
+    console.log("🚀 Initializing Cordbot...\n");
+    // Initialize .claude folder and database
+    const { dbPath, sessionsDir, claudeDir, isFirstRun } = initializeClaudeFolder(cwd);
+    if (isFirstRun) {
+        console.log("\n✨ First run detected - initialized project structure\n");
+    }
+    // Validate environment variables
+    const token = process.env.DISCORD_BOT_TOKEN;
+    const guildId = process.env.DISCORD_GUILD_ID;
+    const apiKey = process.env.ANTHROPIC_API_KEY;
+    if (!token || !guildId || !apiKey) {
+        throw new Error("Missing required environment variables");
+    }
+    // Initialize database
+    const db = new SessionDatabase(dbPath);
+    console.log(`📊 Active sessions: ${db.getActiveCount()}\n`);
+    // Initialize session manager
+    const sessionManager = new SessionManager(db, sessionsDir);
+    await sessionManager.initialize(token);
+    console.log("");
+    // Connect to Discord
+    console.log("🔌 Connecting to Discord...\n");
+    const client = await createDiscordClient({ token, guildId });
+    // Sync channels with folders
+    const channelMappings = await syncChannelsOnStartup(client, guildId, cwd);
+    console.log("");
+    // Start cron scheduler
+    const cronRunner = new CronRunner(client, sessionManager);
+    cronRunner.start(channelMappings);
+    console.log("");
+    // Setup event handlers (after cron runner is initialized)
+    setupEventHandlers(client, sessionManager, channelMappings, cwd, guildId, cronRunner);
+    console.log("✅ Event handlers registered\n");
+    // Setup graceful shutdown
+    const shutdown = async () => {
+        console.log("\n⏸️  Shutting down Cordbot...");
+        // Stop cron scheduler
+        cronRunner.stop();
+        // Stop token refresh
+        sessionManager.shutdown();
+        // Close database
+        db.close();
+        console.log("🗄️  Database closed");
+        // Destroy Discord client
+        client.destroy();
+        console.log("🔌 Discord client disconnected");
+        console.log("\n👋 Cordbot stopped");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    // Archive old sessions periodically (every 24 hours)
+    const archiveDays = parseInt(process.env.ARCHIVE_AFTER_DAYS || "30");
+    setInterval(async () => {
+        const archived = await sessionManager.archiveOldSessions(archiveDays);
+        if (archived > 0) {
+            console.log(`🗄️  Archived ${archived} inactive sessions`);
+        }
+    }, 24 * 60 * 60 * 1000);
+    console.log("✅ Cordbot is now running!\n");
+    console.log(`📊 Watching ${channelMappings.length} channels`);
+    console.log(`💬 Bot is ready to receive messages\n`);
+    console.log("Press Ctrl+C to stop\n");
+}

package/dist/init.js

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import Database from 'better-sqlite3';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function initializeClaudeFolder(cwd) {
+    const claudeDir = path.join(cwd, '.claude');
+    const configPath = path.join(claudeDir, 'config.json');
+    const dbPath = path.join(claudeDir, 'mappings.db');
+    const sessionsDir = path.join(claudeDir, 'sessions');
+    const isFirstRun = !fs.existsSync(claudeDir);
+    // Create .claude directory if it doesn't exist
+    if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+        console.log('📁 Created .claude directory');
+    }
+    // Create sessions directory
+    if (!fs.existsSync(sessionsDir)) {
+        fs.mkdirSync(sessionsDir, { recursive: true });
+        console.log('📁 Created sessions directory');
+    }
+    // Initialize config.json if it doesn't exist
+    if (!fs.existsSync(configPath)) {
+        const defaultConfig = {
+            version: '1.0.0',
+            created: new Date().toISOString(),
+            lastStarted: new Date().toISOString(),
+        };
+        fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2), 'utf-8');
+        console.log('⚙️  Created config.json');
+    }
+    else {
+        // Update lastStarted
+        const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        config.lastStarted = new Date().toISOString();
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+    }
+    // Initialize SQLite database
+    initializeDatabase(dbPath);
+    // Create root CLAUDE.md if it doesn't exist
+    ensureRootClaudeMd(cwd);
+    return {
+        claudeDir,
+        configPath,
+        dbPath,
+        sessionsDir,
+        isFirstRun,
+    };
+}
+function initializeDatabase(dbPath) {
+    const db = new Database(dbPath);
+    // Create session_mappings table
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS session_mappings (
+      discord_thread_id TEXT PRIMARY KEY,
+      discord_channel_id TEXT NOT NULL,
+      discord_message_id TEXT NOT NULL,
+      session_id TEXT NOT NULL,
+      working_directory TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      last_active_at TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('active', 'archived'))
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_session_id ON session_mappings(session_id);
+    CREATE INDEX IF NOT EXISTS idx_channel_id ON session_mappings(discord_channel_id);
+  `);
+    db.close();
+    console.log('🗄️  Initialized database');
+}
+function ensureRootClaudeMd(cwd) {
+    const claudeMdPath = path.join(cwd, 'CLAUDE.md');
+    if (!fs.existsSync(claudeMdPath)) {
+        const templatePath = path.join(__dirname, '..', 'templates', 'root-CLAUDE.md.template');
+        let template = fs.readFileSync(templatePath, 'utf-8');
+        // Replace placeholders
+        template = template.replace(/{{WORKING_DIRECTORY}}/g, cwd);
+        fs.writeFileSync(claudeMdPath, template, 'utf-8');
+        console.log('📄 Created root CLAUDE.md with Discord bot instructions');
+    }
+}

package/dist/permissions/discord.js

@@ -0,0 +1,66 @@
+import { ButtonBuilder, ActionRowBuilder, ButtonStyle } from 'discord.js';
+export class DiscordPermissionManager {
+    pendingRequests = new Map();
+    /**
+     * Request permission from user via Discord buttons
+     * Returns a promise that resolves if approved, rejects if denied
+     */
+    async requestPermission(channel, message, requestId) {
+        // Create Approve/Deny buttons
+        const approveButton = new ButtonBuilder()
+            .setCustomId(`permission_approve_${requestId}`)
+            .setLabel('Approve')
+            .setStyle(ButtonStyle.Success);
+        const denyButton = new ButtonBuilder()
+            .setCustomId(`permission_deny_${requestId}`)
+            .setLabel('Deny')
+            .setStyle(ButtonStyle.Danger);
+        const row = new ActionRowBuilder().addComponents(approveButton, denyButton);
+        // Send permission request message
+        const permissionMsg = await channel.send({
+            content: `🔐 **Permission Required**\n${message}`,
+            components: [row],
+        });
+        // Wait for user response
+        return new Promise((resolve, reject) => {
+            this.pendingRequests.set(requestId, {
+                resolve,
+                reject,
+                messageId: permissionMsg.id
+            });
+            // Timeout after 5 minutes
+            setTimeout(() => {
+                if (this.pendingRequests.has(requestId)) {
+                    this.pendingRequests.delete(requestId);
+                    permissionMsg.delete().catch(() => { });
+                    reject(new Error('Permission request timed out'));
+                }
+            }, 5 * 60 * 1000);
+        });
+    }
+    /**
+     * Handle permission response from button interaction
+     * Returns true if handled successfully, false if not found
+     */
+    handlePermissionResponse(requestId, approved) {
+        const request = this.pendingRequests.get(requestId);
+        if (!request) {
+            return false;
+        }
+        // Remove from map and resolve/reject
+        this.pendingRequests.delete(requestId);
+        if (approved) {
+            request.resolve();
+        }
+        else {
+            request.reject(new Error('Permission denied by user'));
+        }
+        return true;
+    }
+    /**
+     * Check if a request ID is pending
+     */
+    hasPendingRequest(requestId) {
+        return this.pendingRequests.has(requestId);
+    }
+}