gibi-bot 1.0.0

package/dist/app.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const bolt_1 = require("@slack/bolt");
+const config_1 = require("./config");
+const context_1 = require("./context");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const agents_1 = require("./agents");
+const AVAILABLE_MODELS = [
+    { id: 'gemini-2.5-pro', desc: 'Complex reasoning, coding (Access required)' },
+    { id: 'gemini-2.5-flash', desc: 'Fast, lightweight (Access required)' },
+    { id: 'gemini-1.5-pro', desc: 'General purpose, good reasoning' },
+    { id: 'gemini-1.5-flash', desc: 'High speed, lower latency' },
+    { id: 'gemini-1.0-pro', desc: 'Standard model' },
+];
+let isRestarting = false;
+const start = async () => {
+    try {
+        await (0, config_1.loadConfig)();
+        let BOT_USER_ID = '';
+        let BOT_ID = '';
+        const app = new bolt_1.App({
+            token: process.env.SLACK_BOT_TOKEN || '',
+            signingSecret: process.env.SLACK_SIGNING_SECRET || '',
+            socketMode: true,
+            appToken: process.env.SLACK_APP_TOKEN || ''
+        });
+        // Fetch Bot User ID on startup
+        (async () => {
+            try {
+                const authResult = await app.client.auth.test();
+                BOT_USER_ID = authResult.user_id;
+                BOT_ID = authResult.bot_id;
+            }
+            catch (e) {
+                console.error('Failed to fetch Bot User ID:', e);
+            }
+        })();
+        const contextManager = new context_1.ContextManager();
+        // Handle bot being added to a channel
+        app.event('member_joined_channel', async ({ event, client, say }) => {
+            // Use cached ID or fetch if not ready
+            if (!BOT_USER_ID) {
+                const authResult = await client.auth.test();
+                BOT_USER_ID = authResult.user_id;
+                BOT_ID = authResult.bot_id;
+            }
+            if (event.user === BOT_USER_ID) {
+                await say(`Hello! I'm Gibi. I'm ready to help. Mention me (@Gibi) to start a new thread!`);
+            }
+        });
+        // Generic message handler for Agent Chat
+        // Helper to handle Agent turns
+        const processAgentTurn = async (contextId, channelId, threadTs, userText, say, client, existingMessageTs) => {
+            const context = contextManager.getContext(contextId);
+            // Append User Message if provided
+            if (userText) {
+                context.messages.push({ role: 'user', content: userText });
+                contextManager.setContextData(contextId, { messages: context.messages });
+            }
+            let processingMsgTs = existingMessageTs;
+            try {
+                const agentName = context.data.agent || 'gemini';
+                // Send or Update ephemeral "Thinking..." message
+                const thinkingBlocks = [
+                    {
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: `_Thinking..._ (using \`${agentName}\`)`
+                        }
+                    }
+                ];
+                if (processingMsgTs) {
+                    await client.chat.update({
+                        channel: channelId,
+                        ts: processingMsgTs,
+                        text: 'Thinking...',
+                        blocks: thinkingBlocks
+                    });
+                }
+                else {
+                    const processingMsg = await say({
+                        blocks: thinkingBlocks,
+                        text: 'Thinking...',
+                        thread_ts: threadTs
+                    });
+                    processingMsgTs = processingMsg.ts;
+                }
+                // Determine Agent
+                const agent = agents_1.agentRegistry[agentName];
+                if (!agent) {
+                    throw new Error(`Unknown agent: ${agentName}`);
+                }
+                const responseText = await agent.run(context.messages, {
+                    model: context.data.model,
+                    mode: context.data.mode
+                });
+                if (responseText) {
+                    // Append Assistant Response
+                    context.messages.push({ role: 'assistant', content: responseText });
+                    contextManager.setContextData(contextId, { messages: context.messages });
+                    const responseBlocks = [
+                        {
+                            type: 'section',
+                            text: {
+                                type: 'mrkdwn',
+                                text: responseText
+                            }
+                        },
+                        {
+                            type: 'context',
+                            elements: [
+                                {
+                                    type: 'mrkdwn',
+                                    text: `🤖 *Agent:* \`${agentName}\` | 🧠 *Model:* \`${context.data.model || 'default'}\` | 📂 *CWD:* \`${context.data.cwd || 'root'}\``
+                                }
+                            ]
+                        },
+                        {
+                            type: 'actions',
+                            elements: [
+                                {
+                                    type: 'button',
+                                    text: { type: 'plain_text', text: '🔄 Retry', emoji: true },
+                                    action_id: 'retry_turn'
+                                },
+                                {
+                                    type: 'button',
+                                    text: { type: 'plain_text', text: '↩️ Revert', emoji: true },
+                                    action_id: 'revert_turn'
+                                }
+                            ]
+                        }
+                    ];
+                    // Update the processing message with the actual response
+                    if (processingMsgTs) {
+                        await client.chat.update({
+                            channel: channelId,
+                            ts: processingMsgTs,
+                            text: responseText,
+                            blocks: responseBlocks
+                        });
+                    }
+                    else {
+                        await say({
+                            text: responseText,
+                            blocks: responseBlocks,
+                            thread_ts: threadTs
+                        });
+                    }
+                }
+                else if (processingMsgTs) {
+                    // Handle empty response case
+                    await client.chat.update({
+                        channel: channelId,
+                        ts: processingMsgTs,
+                        text: `Received empty response from ${agentName}.`
+                    });
+                }
+            }
+            catch (error) {
+                console.error('Error calling Agent:', error);
+                const errorMessage = `params: Error calling Agent: ${error.message}`;
+                if (processingMsgTs) {
+                    await client.chat.update({
+                        channel: channelId,
+                        ts: processingMsgTs,
+                        text: errorMessage
+                    });
+                }
+                else {
+                    await say({
+                        text: errorMessage,
+                        thread_ts: threadTs
+                    });
+                }
+            }
+        };
+        // Handle generic messages
+        app.message(async ({ message, say, client }) => {
+            const msg = message;
+            if (msg.bot_id || msg.subtype === 'bot_message' || !msg.text)
+                return;
+            // Skip if it looks like the cd command
+            if (/^cd\s+/.test(msg.text.trim()))
+                return;
+            // Check if this message mentions the bot
+            let isMention = false;
+            if (BOT_USER_ID && msg.text.includes(`<@${BOT_USER_ID}>`))
+                isMention = true;
+            if (BOT_ID && msg.text.includes(`<@${BOT_ID}>`))
+                isMention = true;
+            const isDm = msg.channel_type === 'im';
+            const isThread = !!msg.thread_ts;
+            const contextId = msg.thread_ts || msg.channel;
+            if (isDm) {
+                // Process
+            }
+            else if (isThread) {
+                if (!isMention && !contextManager.hasContext(contextId))
+                    return;
+            }
+            else {
+                if (!isMention)
+                    return;
+            }
+            // Clean up text (remove mention)
+            let text = msg.text;
+            if (BOT_USER_ID)
+                text = text.replace(new RegExp(`<@${BOT_USER_ID}>`, 'g'), '').trim();
+            if (BOT_ID)
+                text = text.replace(new RegExp(`<@${BOT_ID}>`, 'g'), '').trim();
+            const replyThreadTs = msg.thread_ts || msg.ts;
+            const targetContextId = msg.thread_ts || msg.ts;
+            await processAgentTurn(targetContextId, msg.channel, replyThreadTs, text, say, client);
+        });
+        // Helper for CD command (shared between Slash command and Message)
+        const executeChangeDirectory = async (contextId, targetPath) => {
+            const context = contextManager.getContext(contextId);
+            // 1. Determine current context CWD
+            const currentCwd = context.data.cwd || process.cwd();
+            // 2. Resolve new path
+            let newPath = currentCwd;
+            if (targetPath) {
+                newPath = path.resolve(currentCwd, targetPath);
+            }
+            try {
+                // 3. Validate path
+                await fs.promises.access(newPath, fs.constants.F_OK);
+                const stats = await fs.promises.stat(newPath);
+                if (!stats.isDirectory()) {
+                    return { text: `❌ Path is not a directory: \`${newPath}\`` };
+                }
+                // 4. Update Context
+                contextManager.setContextData(contextId, { cwd: newPath });
+                // 5. List files
+                const files = await fs.promises.readdir(newPath, { withFileTypes: true });
+                // Sort: Directories first, then files
+                files.sort((a, b) => {
+                    if (a.isDirectory() && !b.isDirectory())
+                        return -1;
+                    if (!a.isDirectory() && b.isDirectory())
+                        return 1;
+                    return a.name.localeCompare(b.name);
+                });
+                // Build Blocks
+                const blocks = [
+                    {
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: `📂 *Directory:* \`${newPath}\``
+                        }
+                    }
+                ];
+                // Add "Up" button if not root
+                const parentPath = path.dirname(newPath);
+                if (newPath !== parentPath) {
+                    blocks.push({
+                        type: 'actions',
+                        elements: [
+                            {
+                                type: 'button',
+                                text: {
+                                    type: 'plain_text',
+                                    text: '⬆️ Up one level',
+                                    emoji: true
+                                },
+                                value: parentPath,
+                                action_id: 'navigate_dir'
+                            }
+                        ]
+                    });
+                }
+                const dirButtons = [];
+                const fileNames = [];
+                files.forEach(file => {
+                    if (file.isDirectory()) {
+                        if (dirButtons.length < 10) { // Limit buttons to avoid clutter
+                            dirButtons.push({
+                                type: 'button',
+                                text: {
+                                    type: 'plain_text',
+                                    text: `📁 ${file.name}`,
+                                    emoji: true
+                                },
+                                value: path.join(newPath, file.name),
+                                action_id: 'navigate_dir'
+                            });
+                        }
+                        else {
+                            fileNames.push(`📁 ${file.name}`);
+                        }
+                    }
+                    else {
+                        fileNames.push(`📄 ${file.name}`);
+                    }
+                });
+                if (dirButtons.length > 0) {
+                    // Slack allows max 5 buttons per action block
+                    for (let i = 0; i < dirButtons.length; i += 5) {
+                        blocks.push({
+                            type: 'actions',
+                            elements: dirButtons.slice(i, i + 5)
+                        });
+                    }
+                }
+                if (fileNames.length > 0) {
+                    let fileListText = fileNames.join('\n');
+                    if (fileListText.length > 2500) {
+                        fileListText = fileListText.substring(0, 2500) + '\n...(truncated)';
+                    }
+                    blocks.push({
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: fileListText
+                        }
+                    });
+                }
+                return {
+                    text: `Directory: ${newPath}`,
+                    blocks: blocks
+                };
+            }
+            catch (error) {
+                return { text: `❌ Error accessing directory: ${error.message}` };
+            }
+        };
+        // Handle navigate_dir action
+        app.action('navigate_dir', async ({ ack, body, respond }) => {
+            await ack();
+            const action = body.actions[0];
+            const contextId = body.container.thread_ts || body.container.channel_id;
+            const output = await executeChangeDirectory(contextId, action.value);
+            await respond({
+                ...output,
+                replace_original: true
+            });
+        });
+        // Handle /plan command
+        app.command('/plan', async ({ command, ack, say, client }) => {
+            await ack();
+            const contextId = command.channel_id;
+            const goal = command.text.trim();
+            // Switch to Plan Mode
+            contextManager.setContextData(contextId, { mode: 'plan' });
+            // Notify initiation
+            await say({
+                text: `📝 *Entering Plan Mode*\nTarget: ${goal || "No specific goal provided. What would you like to plan?"}`,
+                channel: command.channel_id
+            });
+            // If goal provided, process it as the first message
+            if (goal) {
+                await processAgentTurn(contextId, command.channel_id, undefined, goal, say, client);
+            }
+        });
+        // Handle /cd command
+        app.command('/cd', async ({ command, ack, respond }) => {
+            await ack();
+            const output = await executeChangeDirectory(command.channel_id, command.text.trim());
+            await respond(output);
+        });
+        // Handle "cd [path]" messages (works in threads)
+        app.message(/^cd\s+(.+)/, async ({ message, context, say }) => {
+            // Need to cast message to access optional properties like thread_ts
+            const msg = message;
+            const targetPath = context.matches[1].trim();
+            // Use thread_ts if available, otherwise channel
+            const contextId = msg.thread_ts || msg.channel;
+            const output = await executeChangeDirectory(contextId, targetPath);
+            await say({
+                text: output,
+                thread_ts: msg.thread_ts // Reply in thread if it was a thread message
+            });
+        });
+        // Handle /model command
+        app.command('/model', async ({ command, ack, client, respond }) => {
+            await ack();
+            const input = command.text.trim();
+            const contextId = command.channel_id;
+            const context = contextManager.getContext(contextId);
+            // Show modal if no input
+            if (!input) {
+                await client.views.open({
+                    trigger_id: command.trigger_id,
+                    view: {
+                        type: 'modal',
+                        callback_id: 'model_select_modal',
+                        private_metadata: contextId,
+                        title: { type: 'plain_text', text: 'Select Model' },
+                        blocks: [
+                            {
+                                type: 'input',
+                                block_id: 'model_block',
+                                label: { type: 'plain_text', text: 'Choose a Gemini model' },
+                                element: {
+                                    type: 'static_select',
+                                    action_id: 'model_select',
+                                    initial_option: AVAILABLE_MODELS.find(m => m.id === (context.data.model || 'gemini-1.5-pro')) ? {
+                                        text: { type: 'plain_text', text: context.data.model || 'gemini-1.5-pro' },
+                                        value: context.data.model || 'gemini-1.5-pro'
+                                    } : undefined,
+                                    options: AVAILABLE_MODELS.map(m => ({
+                                        text: { type: 'plain_text', text: m.id },
+                                        value: m.id,
+                                        description: { type: 'plain_text', text: m.desc.substring(0, 75) }
+                                    }))
+                                }
+                            }
+                        ],
+                        submit: { type: 'plain_text', text: 'Update' }
+                    }
+                });
+                return;
+            }
+            if (input === 'list' || input === 'help') {
+                const currentModel = context.data.model || 'default';
+                const modelList = AVAILABLE_MODELS.map(m => `• \`${m.id}\`: ${m.desc}`).join('\n');
+                await respond(`Current model: \`${currentModel}\`\n\n` +
+                    `*Available Models:*\n${modelList}\n\n` +
+                    `To switch, use \`/model <model_name>\``);
+                return;
+            }
+            contextManager.setContextData(contextId, { model: input });
+            await respond(`Switched model to: \`${input}\``);
+        });
+        // Handle /agent command
+        app.command('/agent', async ({ command, ack, client, respond }) => {
+            await ack();
+            const input = command.text.trim();
+            const contextId = command.channel_id;
+            const context = contextManager.getContext(contextId);
+            if (!input) {
+                await client.views.open({
+                    trigger_id: command.trigger_id,
+                    view: {
+                        type: 'modal',
+                        callback_id: 'agent_select_modal',
+                        private_metadata: contextId,
+                        title: { type: 'plain_text', text: 'Select Agent' },
+                        blocks: [
+                            {
+                                type: 'input',
+                                block_id: 'agent_block',
+                                label: { type: 'plain_text', text: 'Choose a backing agent' },
+                                element: {
+                                    type: 'static_select',
+                                    action_id: 'agent_select',
+                                    initial_option: {
+                                        text: { type: 'plain_text', text: context.data.agent || 'gemini' },
+                                        value: context.data.agent || 'gemini'
+                                    },
+                                    options: Object.keys(agents_1.agentRegistry).map(k => ({
+                                        text: { type: 'plain_text', text: k },
+                                        value: k
+                                    }))
+                                }
+                            }
+                        ],
+                        submit: { type: 'plain_text', text: 'Update' }
+                    }
+                });
+                return;
+            }
+            if (input === 'list' || input === 'help') {
+                const currentAgent = context.data.agent || 'gemini';
+                const agentList = Object.keys(agents_1.agentRegistry).map(k => `• \`${k}\``).join('\n');
+                await respond(`Current agent: \`${currentAgent}\`\n\n` +
+                    `*Available Agents:*\n${agentList}\n\n` +
+                    `To switch, use \`/agent <agent_name>\``);
+                return;
+            }
+            const agentName = input.toLowerCase();
+            if (!agents_1.agentRegistry[agentName]) {
+                await respond(`❌ Unknown agent: \`${agentName}\`. Available agents: ${Object.keys(agents_1.agentRegistry).join(', ')}`);
+                return;
+            }
+            contextManager.setContextData(contextId, { agent: agentName });
+            await respond(`Switched agent to: \`${agentName}\``);
+        });
+        // Handle Modal Submissions
+        app.view('model_select_modal', async ({ ack, view, client }) => {
+            await ack();
+            const contextId = view.private_metadata;
+            const selectedModel = view.state.values.model_block.model_select.selected_option?.value;
+            if (selectedModel) {
+                contextManager.setContextData(contextId, { model: selectedModel });
+                await client.chat.postMessage({
+                    channel: contextId,
+                    text: `🔄 Model updated to \`${selectedModel}\``
+                });
+            }
+        });
+        app.view('agent_select_modal', async ({ ack, view, client }) => {
+            await ack();
+            const contextId = view.private_metadata;
+            const selectedAgent = view.state.values.agent_block.agent_select.selected_option?.value;
+            if (selectedAgent) {
+                contextManager.setContextData(contextId, { agent: selectedAgent });
+                await client.chat.postMessage({
+                    channel: contextId,
+                    text: `🔄 Agent updated to \`${selectedAgent}\``
+                });
+            }
+        });
+        // Handle Retry
+        app.action('retry_turn', async ({ ack, body, client }) => {
+            await ack();
+            const action = body;
+            const contextId = action.container.thread_ts || action.container.channel_id;
+            const channelId = action.container.channel_id;
+            const messageTs = action.container.message_ts;
+            const threadTs = action.container.thread_ts;
+            const context = contextManager.getContext(contextId);
+            // Remove last assistant message
+            if (context.messages.length > 0 && context.messages[context.messages.length - 1].role === 'assistant') {
+                context.messages.pop();
+            }
+            // Add a note to the last user message if not already present
+            if (context.messages.length > 0 && context.messages[context.messages.length - 1].role === 'user') {
+                const lastMsg = context.messages[context.messages.length - 1];
+                if (!lastMsg.content.includes('[System: The user requested a retry')) {
+                    lastMsg.content += '\n\n[System: The user requested a retry of this instruction.]';
+                }
+            }
+            contextManager.setContextData(contextId, { messages: context.messages });
+            // Polyfill say using client
+            const say = async (args) => {
+                const msg = typeof args === 'string' ? { text: args } : args;
+                return await client.chat.postMessage({
+                    channel: channelId,
+                    ...msg
+                });
+            };
+            // Re-run agent turn (without new user text, using existing message to update)
+            await processAgentTurn(contextId, channelId, threadTs, undefined, say, client, messageTs);
+        });
+        // Handle Revert
+        app.action('revert_turn', async ({ ack, body, client }) => {
+            await ack();
+            const action = body;
+            const contextId = action.container.thread_ts || action.container.channel_id;
+            const channelId = action.container.channel_id;
+            const threadTs = action.container.thread_ts;
+            const context = contextManager.getContext(contextId);
+            // Find the last user message to include in the revert prompt
+            let lastUserText = '';
+            for (let i = context.messages.length - 1; i >= 0; i--) {
+                if (context.messages[i].role === 'user') {
+                    lastUserText = context.messages[i].content;
+                    break;
+                }
+            }
+            // Polyfill say using client
+            const say = async (args) => {
+                const msg = typeof args === 'string' ? { text: args } : args;
+                return await client.chat.postMessage({
+                    channel: channelId,
+                    ...msg
+                });
+            };
+            const revertPrompt = `The user wants to revert the actions taken for the following request: "${lastUserText}". Please undo any file modifications or state changes made in that turn.`;
+            // Trigger a new turn with instructions to revert
+            // We do NOT pop messages here, we want the agent to see what it did and undo it.
+            await processAgentTurn(contextId, channelId, threadTs, revertPrompt, say, client);
+        });
+        // Handle /help command
+        app.command('/help', async ({ ack, respond }) => {
+            await ack();
+            const helpMessage = `
+    *Available Commands:*
+    
+    - \`/plan [goal]\`: Enter plan mode to generate and execute coding plans.
+    - \`/cd [path]\`: Change the current working directory for the conversation.
+    - \`/model [name]\`: Switch the Gemini model (e.g., \`gemini-pro\`, \`gemini-1.5-pro\`).
+    - \`/agent [name]\`: Switch the backing agent (e.g., \`gemini\`, \`claude\`, \`cursor\`).
+    - \`/help\`: Show this help message.
+          `;
+            await respond(helpMessage);
+        });
+        // Handle App Home Tab
+        app.event('app_home_opened', async ({ event, client, logger }) => {
+            try {
+                const contexts = contextManager.getAllContexts();
+                // Sort by last active
+                contexts.sort((a, b) => b.lastActiveAt.getTime() - a.lastActiveAt.getTime());
+                const contextBlocks = contexts.slice(0, 5).map(ctx => ({
+                    type: 'section',
+                    text: {
+                        type: 'mrkdwn',
+                        text: `*Context:* \`${ctx.id}\`\n*Last Active:* ${ctx.lastActiveAt.toLocaleString()}\n*Agent:* \`${ctx.data.agent || 'gemini'}\` | *Model:* \`${ctx.data.model || 'default'}\` | *CWD:* \`${ctx.data.cwd || 'root'}\``
+                    }
+                }));
+                const blocks = [
+                    {
+                        type: 'header',
+                        text: {
+                            type: 'plain_text',
+                            text: '🏠 Gibi Dashboard',
+                            emoji: true
+                        }
+                    },
+                    {
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: `Welcome, <@${event.user}>! Here is a summary of your Gibi instance status.`
+                        }
+                    },
+                    {
+                        type: 'divider'
+                    },
+                    {
+                        type: 'section',
+                        fields: [
+                            {
+                                type: 'mrkdwn',
+                                text: `*Default Agent:*\n\`gemini\``
+                            },
+                            {
+                                type: 'mrkdwn',
+                                text: `*Available Agents:*\n${Object.keys(agents_1.agentRegistry).map(k => `\`${k}\``).join(', ')}`
+                            }
+                        ]
+                    },
+                    {
+                        type: 'divider'
+                    },
+                    {
+                        type: 'header',
+                        text: {
+                            type: 'plain_text',
+                            text: '🕒 Recent Activity',
+                            emoji: true
+                        }
+                    }
+                ];
+                if (contextBlocks.length > 0) {
+                    blocks.push(...contextBlocks.flatMap(b => [b, { type: 'divider' }]));
+                }
+                else {
+                    blocks.push({
+                        type: 'section',
+                        text: {
+                            type: 'mrkdwn',
+                            text: '_No active contexts found. Send a message to Gibi in any channel to start._'
+                        }
+                    });
+                }
+                blocks.push({
+                    type: 'context',
+                    elements: [
+                        {
+                            type: 'mrkdwn',
+                            text: `Last updated: ${new Date().toLocaleString()}`
+                        }
+                    ]
+                });
+                await client.views.publish({
+                    user_id: event.user,
+                    view: {
+                        type: 'home',
+                        blocks: blocks
+                    }
+                });
+            }
+            catch (error) {
+                logger.error('Error publishing Home tab:', error);
+            }
+        });
+        // Start your app
+        await app.start(process.env.PORT || 3000);
+        console.log('🐒 Gibi is running!');
+    }
+    catch (error) {
+        await handleAuthError(error);
+    }
+};
+const handleAuthError = async (error) => {
+    if (isRestarting)
+        return;
+    if (error?.data?.error === 'invalid_auth') {
+        isRestarting = true;
+        console.error('\n❌ Authentication failed: The stored Slack tokens seem to be invalid.');
+        console.error('   Clearing stored configuration and restarting setup...');
+        await (0, config_1.clearConfig)(['SLACK_BOT_TOKEN']);
+        console.log('\n🔄 Restarting app setup...\n');
+        isRestarting = false;
+        await start(); // Recursively restart
+    }
+    else {
+        console.error('Failed to start app:', error);
+        process.exit(1);
+    }
+};
+// Start the application
+start();
+// Global error handlers to catch any unhandled promise rejections
+process.on('unhandledRejection', async (reason) => {
+    await handleAuthError(reason);
+});
+process.on('uncaughtException', async (error) => {
+    await handleAuthError(error);
+});