@mariozechner/pi-mom 0.18.2 → 0.18.4

package/dist/slack.js

@@ -1,412 +1,289 @@
 import { SocketModeClient } from "@slack/socket-mode";
 import { WebClient } from "@slack/web-api";
-import { readFileSync } from "fs";
-import { basename } from "path";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "fs";
+import { basename, join } from "path";
 import * as log from "./log.js";
-import { ChannelStore } from "./store.js";
-export class MomBot {
+class ChannelQueue {
+    queue = [];
+    processing = false;
+    enqueue(work) {
+        this.queue.push(work);
+        this.processNext();
+    }
+    async processNext() {
+        if (this.processing || this.queue.length === 0)
+            return;
+        this.processing = true;
+        const work = this.queue.shift();
+        try {
+            await work();
+        }
+        catch (err) {
+            log.logWarning("Queue error", err instanceof Error ? err.message : String(err));
+        }
+        this.processing = false;
+        this.processNext();
+    }
+}
+// ============================================================================
+// SlackBot
+// ============================================================================
+export class SlackBot {
     socketClient;
     webClient;
     handler;
-    botUserId = null;
+    workingDir;
     store;
-    userCache = new Map();
-    channelCache = new Map(); // id -> name
+    botUserId = null;
+    startupTs = null; // Messages older than this are just logged, not processed
+    users = new Map();
+    channels = new Map();
+    queues = new Map();
     constructor(handler, config) {
         this.handler = handler;
+        this.workingDir = config.workingDir;
+        this.store = config.store;
         this.socketClient = new SocketModeClient({ appToken: config.appToken });
         this.webClient = new WebClient(config.botToken);
-        this.store = new ChannelStore({
-            workingDir: config.workingDir,
-            botToken: config.botToken,
-        });
+    }
+    // ==========================================================================
+    // Public API
+    // ==========================================================================
+    async start() {
+        const auth = await this.webClient.auth.test();
+        this.botUserId = auth.user_id;
+        await Promise.all([this.fetchUsers(), this.fetchChannels()]);
+        log.logInfo(`Loaded ${this.channels.size} channels, ${this.users.size} users`);
+        await this.backfillAllChannels();
         this.setupEventHandlers();
+        await this.socketClient.start();
+        // Record startup time - messages older than this are just logged, not processed
+        this.startupTs = (Date.now() / 1000).toFixed(6);
+        log.logConnected();
     }
-    /**
-     * Fetch all channels the bot is a member of
-     */
-    async fetchChannels() {
-        try {
-            let cursor;
-            do {
-                const result = await this.webClient.conversations.list({
-                    types: "public_channel,private_channel",
-                    exclude_archived: true,
-                    limit: 200,
-                    cursor,
-                });
-                const channels = result.channels;
-                if (channels) {
-                    for (const channel of channels) {
-                        if (channel.id && channel.name && channel.is_member) {
-                            this.channelCache.set(channel.id, channel.name);
-                        }
-                    }
-                }
-                cursor = result.response_metadata?.next_cursor;
-            } while (cursor);
-        }
-        catch (error) {
-            log.logWarning("Failed to fetch channels", String(error));
-        }
+    getUser(userId) {
+        return this.users.get(userId);
     }
-    /**
-     * Fetch all workspace users
-     */
-    async fetchUsers() {
-        try {
-            let cursor;
-            do {
-                const result = await this.webClient.users.list({
-                    limit: 200,
-                    cursor,
-                });
-                const members = result.members;
-                if (members) {
-                    for (const user of members) {
-                        if (user.id && user.name && !user.deleted) {
-                            this.userCache.set(user.id, {
-                                userName: user.name,
-                                displayName: user.real_name || user.name,
-                            });
-                        }
-                    }
-                }
-                cursor = result.response_metadata?.next_cursor;
-            } while (cursor);
-        }
-        catch (error) {
-            log.logWarning("Failed to fetch users", String(error));
-        }
+    getChannel(channelId) {
+        return this.channels.get(channelId);
     }
-    /**
-     * Get all known channels (id -> name)
-     */
-    getChannels() {
-        return Array.from(this.channelCache.entries()).map(([id, name]) => ({ id, name }));
+    getAllUsers() {
+        return Array.from(this.users.values());
+    }
+    getAllChannels() {
+        return Array.from(this.channels.values());
+    }
+    async postMessage(channel, text) {
+        const result = await this.webClient.chat.postMessage({ channel, text });
+        return result.ts;
+    }
+    async updateMessage(channel, ts, text) {
+        await this.webClient.chat.update({ channel, ts, text });
+    }
+    async postInThread(channel, threadTs, text) {
+        await this.webClient.chat.postMessage({ channel, thread_ts: threadTs, text });
+    }
+    async uploadFile(channel, filePath, title) {
+        const fileName = title || basename(filePath);
+        const fileContent = readFileSync(filePath);
+        await this.webClient.files.uploadV2({
+            channel_id: channel,
+            file: fileContent,
+            filename: fileName,
+            title: fileName,
+        });
     }
     /**
-     * Get all known users
+     * Log a message to log.jsonl (SYNC)
+     * This is the ONLY place messages are written to log.jsonl
      */
-    getUsers() {
-        return Array.from(this.userCache.entries()).map(([id, { userName, displayName }]) => ({
-            id,
-            userName,
-            displayName,
-        }));
+    logToFile(channel, entry) {
+        const dir = join(this.workingDir, channel);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        appendFileSync(join(dir, "log.jsonl"), JSON.stringify(entry) + "\n");
     }
     /**
-     * Obfuscate usernames and user IDs in text to prevent pinging people
-     * e.g., "nate" -> "n_a_t_e", "@mario" -> "@m_a_r_i_o", "<@U123>" -> "<@U_1_2_3>"
+     * Log a bot response to log.jsonl
      */
-    obfuscateUsernames(text) {
-        let result = text;
-        // Obfuscate user IDs like <@U16LAL8LS>
-        result = result.replace(/<@([A-Z0-9]+)>/gi, (_match, id) => {
-            return `<@${id.split("").join("_")}>`;
+    logBotResponse(channel, text, ts) {
+        this.logToFile(channel, {
+            date: new Date().toISOString(),
+            ts,
+            user: "bot",
+            text,
+            attachments: [],
+            isBot: true,
         });
-        // Obfuscate usernames
-        for (const { userName } of this.userCache.values()) {
-            // Escape special regex characters in username
-            const escaped = userName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-            // Match @username, <@username>, or bare username (case insensitive, word boundary)
-            const pattern = new RegExp(`(<@|@)?(\\b${escaped}\\b)`, "gi");
-            result = result.replace(pattern, (_match, prefix, name) => {
-                const obfuscated = name.split("").join("_");
-                return (prefix || "") + obfuscated;
-            });
-        }
-        return result;
     }
-    async getUserInfo(userId) {
-        if (this.userCache.has(userId)) {
-            return this.userCache.get(userId);
-        }
-        try {
-            const result = await this.webClient.users.info({ user: userId });
-            const user = result.user;
-            const info = {
-                userName: user?.name || userId,
-                displayName: user?.real_name || user?.name || userId,
-            };
-            this.userCache.set(userId, info);
-            return info;
-        }
-        catch {
-            return { userName: userId, displayName: userId };
+    // ==========================================================================
+    // Private - Event Handlers
+    // ==========================================================================
+    getQueue(channelId) {
+        let queue = this.queues.get(channelId);
+        if (!queue) {
+            queue = new ChannelQueue();
+            this.queues.set(channelId, queue);
         }
+        return queue;
     }
     setupEventHandlers() {
-        // Handle @mentions in channels
-        this.socketClient.on("app_mention", async ({ event, ack }) => {
-            await ack();
-            const slackEvent = event;
-            // Log the mention message (message event may not fire for all channel types)
-            await this.logMessage({
-                text: slackEvent.text,
-                channel: slackEvent.channel,
-                user: slackEvent.user,
-                ts: slackEvent.ts,
-                files: slackEvent.files,
-            });
-            const ctx = await this.createContext(slackEvent);
-            await this.handler.onChannelMention(ctx);
+        // Channel @mentions
+        this.socketClient.on("app_mention", ({ event, ack }) => {
+            const e = event;
+            // Skip DMs (handled by message event)
+            if (e.channel.startsWith("D")) {
+                ack();
+                return;
+            }
+            const slackEvent = {
+                type: "mention",
+                channel: e.channel,
+                ts: e.ts,
+                user: e.user,
+                text: e.text.replace(/<@[A-Z0-9]+>/gi, "").trim(),
+                files: e.files,
+            };
+            // SYNC: Log to log.jsonl (ALWAYS, even for old messages)
+            // Also downloads attachments in background and stores local paths
+            slackEvent.attachments = this.logUserMessage(slackEvent);
+            // Only trigger processing for messages AFTER startup (not replayed old messages)
+            if (this.startupTs && e.ts < this.startupTs) {
+                log.logInfo(`[${e.channel}] Logged old message (pre-startup), not triggering: ${slackEvent.text.substring(0, 30)}`);
+                ack();
+                return;
+            }
+            // Check for stop command - execute immediately, don't queue!
+            if (slackEvent.text.toLowerCase().trim() === "stop") {
+                if (this.handler.isRunning(e.channel)) {
+                    this.handler.handleStop(e.channel, this); // Don't await, don't queue
+                }
+                else {
+                    this.postMessage(e.channel, "_Nothing running_");
+                }
+                ack();
+                return;
+            }
+            // SYNC: Check if busy
+            if (this.handler.isRunning(e.channel)) {
+                this.postMessage(e.channel, "_Already working. Say `@mom stop` to cancel._");
+            }
+            else {
+                this.getQueue(e.channel).enqueue(() => this.handler.handleEvent(slackEvent, this));
+            }
+            ack();
         });
-        // Handle all messages (for logging) and DMs (for triggering handler)
-        this.socketClient.on("message", async ({ event, ack }) => {
-            await ack();
-            const slackEvent = event;
-            // Ignore bot messages
-            if (slackEvent.bot_id)
+        // All messages (for logging) + DMs (for triggering)
+        this.socketClient.on("message", ({ event, ack }) => {
+            const e = event;
+            // Skip bot messages, edits, etc.
+            if (e.bot_id || !e.user || e.user === this.botUserId) {
+                ack();
                 return;
-            // Ignore message edits, etc. (but allow file_share)
-            if (slackEvent.subtype !== undefined && slackEvent.subtype !== "file_share")
+            }
+            if (e.subtype !== undefined && e.subtype !== "file_share") {
+                ack();
                 return;
-            // Ignore if no user
-            if (!slackEvent.user)
+            }
+            if (!e.text && (!e.files || e.files.length === 0)) {
+                ack();
                 return;
-            // Ignore messages from the bot itself
-            if (slackEvent.user === this.botUserId)
+            }
+            const isDM = e.channel_type === "im";
+            const isBotMention = e.text?.includes(`<@${this.botUserId}>`);
+            // Skip channel @mentions - already handled by app_mention event
+            if (!isDM && isBotMention) {
+                ack();
                 return;
-            // Ignore if no text AND no files
-            if (!slackEvent.text && (!slackEvent.files || slackEvent.files.length === 0))
+            }
+            const slackEvent = {
+                type: isDM ? "dm" : "mention",
+                channel: e.channel,
+                ts: e.ts,
+                user: e.user,
+                text: (e.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim(),
+                files: e.files,
+            };
+            // SYNC: Log to log.jsonl (ALL messages - channel chatter and DMs)
+            // Also downloads attachments in background and stores local paths
+            slackEvent.attachments = this.logUserMessage(slackEvent);
+            // Only trigger processing for messages AFTER startup (not replayed old messages)
+            if (this.startupTs && e.ts < this.startupTs) {
+                log.logInfo(`[${e.channel}] Skipping old message (pre-startup): ${slackEvent.text.substring(0, 30)}`);
+                ack();
                 return;
-            // Log ALL messages (channel and DM)
-            await this.logMessage({
-                text: slackEvent.text || "",
-                channel: slackEvent.channel,
-                user: slackEvent.user,
-                ts: slackEvent.ts,
-                files: slackEvent.files,
-            });
-            // Only trigger handler for DMs (channel mentions are handled by app_mention event)
-            if (slackEvent.channel_type === "im") {
-                const ctx = await this.createContext({
-                    text: slackEvent.text || "",
-                    channel: slackEvent.channel,
-                    user: slackEvent.user,
-                    ts: slackEvent.ts,
-                    files: slackEvent.files,
-                });
-                await this.handler.onDirectMessage(ctx);
             }
+            // Only trigger handler for DMs
+            if (isDM) {
+                // Check for stop command - execute immediately, don't queue!
+                if (slackEvent.text.toLowerCase().trim() === "stop") {
+                    if (this.handler.isRunning(e.channel)) {
+                        this.handler.handleStop(e.channel, this); // Don't await, don't queue
+                    }
+                    else {
+                        this.postMessage(e.channel, "_Nothing running_");
+                    }
+                    ack();
+                    return;
+                }
+                if (this.handler.isRunning(e.channel)) {
+                    this.postMessage(e.channel, "_Already working. Say `stop` to cancel._");
+                }
+                else {
+                    this.getQueue(e.channel).enqueue(() => this.handler.handleEvent(slackEvent, this));
+                }
+            }
+            ack();
         });
     }
-    async logMessage(event) {
+    /**
+     * Log a user message to log.jsonl (SYNC)
+     * Downloads attachments in background via store
+     */
+    logUserMessage(event) {
+        const user = this.users.get(event.user);
+        // Process attachments - queues downloads in background
         const attachments = event.files ? this.store.processAttachments(event.channel, event.files, event.ts) : [];
-        const { userName, displayName } = await this.getUserInfo(event.user);
-        await this.store.logMessage(event.channel, {
+        this.logToFile(event.channel, {
             date: new Date(parseFloat(event.ts) * 1000).toISOString(),
             ts: event.ts,
             user: event.user,
-            userName,
-            displayName,
+            userName: user?.userName,
+            displayName: user?.displayName,
             text: event.text,
             attachments,
             isBot: false,
         });
+        return attachments;
     }
-    async createContext(event) {
-        const rawText = event.text;
-        const text = rawText.replace(/<@[A-Z0-9]+>/gi, "").trim();
-        // Get user info for logging
-        const { userName } = await this.getUserInfo(event.user);
-        // Get channel name for logging (best effort)
-        let channelName;
-        try {
-            if (event.channel.startsWith("C")) {
-                const result = await this.webClient.conversations.info({ channel: event.channel });
-                channelName = result.channel?.name ? `#${result.channel.name}` : undefined;
+    // ==========================================================================
+    // Private - Backfill
+    // ==========================================================================
+    getExistingTimestamps(channelId) {
+        const logPath = join(this.workingDir, channelId, "log.jsonl");
+        const timestamps = new Set();
+        if (!existsSync(logPath))
+            return timestamps;
+        const content = readFileSync(logPath, "utf-8");
+        const lines = content.trim().split("\n").filter(Boolean);
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.ts)
+                    timestamps.add(entry.ts);
             }
+            catch { }
         }
-        catch {
-            // Ignore errors - we'll just use the channel ID
-        }
-        // Process attachments (for context, already logged by message handler)
-        const attachments = event.files ? this.store.processAttachments(event.channel, event.files, event.ts) : [];
-        // Track the single message for this run
-        let messageTs = null;
-        let accumulatedText = "";
-        let isThinking = true; // Track if we're still in "thinking" state
-        let isWorking = true; // Track if still processing
-        const workingIndicator = " ...";
-        let updatePromise = Promise.resolve();
-        return {
-            message: {
-                text,
-                rawText,
-                user: event.user,
-                userName,
-                channel: event.channel,
-                ts: event.ts,
-                attachments,
-            },
-            channelName,
-            store: this.store,
-            channels: this.getChannels(),
-            users: this.getUsers(),
-            respond: async (responseText, shouldLog = true) => {
-                // Queue updates to avoid race conditions
-                updatePromise = updatePromise.then(async () => {
-                    try {
-                        if (isThinking) {
-                            // First real response replaces "Thinking..."
-                            accumulatedText = responseText;
-                            isThinking = false;
-                        }
-                        else {
-                            // Subsequent responses get appended
-                            accumulatedText += "\n" + responseText;
-                        }
-                        // Truncate accumulated text if too long (Slack limit is 40K, we use 35K for safety)
-                        const MAX_MAIN_LENGTH = 35000;
-                        const truncationNote = "\n\n_(message truncated, ask me to elaborate on specific parts)_";
-                        if (accumulatedText.length > MAX_MAIN_LENGTH) {
-                            accumulatedText =
-                                accumulatedText.substring(0, MAX_MAIN_LENGTH - truncationNote.length) + truncationNote;
-                        }
-                        // Add working indicator if still working
-                        const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
-                        if (messageTs) {
-                            // Update existing message
-                            await this.webClient.chat.update({
-                                channel: event.channel,
-                                ts: messageTs,
-                                text: displayText,
-                            });
-                        }
-                        else {
-                            // Post initial message
-                            const result = await this.webClient.chat.postMessage({
-                                channel: event.channel,
-                                text: displayText,
-                            });
-                            messageTs = result.ts;
-                        }
-                        // Log the response if requested
-                        if (shouldLog) {
-                            await this.store.logBotResponse(event.channel, responseText, messageTs);
-                        }
-                    }
-                    catch (err) {
-                        log.logWarning("Slack respond error", err instanceof Error ? err.message : String(err));
-                    }
-                });
-                await updatePromise;
-            },
-            respondInThread: async (threadText) => {
-                // Queue thread posts to maintain order
-                updatePromise = updatePromise.then(async () => {
-                    try {
-                        if (!messageTs) {
-                            // No main message yet, just skip
-                            return;
-                        }
-                        // Obfuscate usernames to avoid pinging people in thread details
-                        let obfuscatedText = this.obfuscateUsernames(threadText);
-                        // Truncate thread messages if too long (20K limit for safety)
-                        const MAX_THREAD_LENGTH = 20000;
-                        if (obfuscatedText.length > MAX_THREAD_LENGTH) {
-                            obfuscatedText = obfuscatedText.substring(0, MAX_THREAD_LENGTH - 50) + "\n\n_(truncated)_";
-                        }
-                        // Post in thread under the main message
-                        await this.webClient.chat.postMessage({
-                            channel: event.channel,
-                            thread_ts: messageTs,
-                            text: obfuscatedText,
-                        });
-                    }
-                    catch (err) {
-                        log.logWarning("Slack respondInThread error", err instanceof Error ? err.message : String(err));
-                    }
-                });
-                await updatePromise;
-            },
-            setTyping: async (isTyping) => {
-                if (isTyping && !messageTs) {
-                    // Post initial "thinking" message (... auto-appended by working indicator)
-                    accumulatedText = "_Thinking_";
-                    const result = await this.webClient.chat.postMessage({
-                        channel: event.channel,
-                        text: accumulatedText,
-                    });
-                    messageTs = result.ts;
-                }
-                // We don't delete/clear anymore - message persists and gets updated
-            },
-            uploadFile: async (filePath, title) => {
-                const fileName = title || basename(filePath);
-                const fileContent = readFileSync(filePath);
-                await this.webClient.files.uploadV2({
-                    channel_id: event.channel,
-                    file: fileContent,
-                    filename: fileName,
-                    title: fileName,
-                });
-            },
-            replaceMessage: async (text) => {
-                updatePromise = updatePromise.then(async () => {
-                    try {
-                        // Replace the accumulated text entirely, with truncation
-                        const MAX_MAIN_LENGTH = 35000;
-                        const truncationNote = "\n\n_(message truncated, ask me to elaborate on specific parts)_";
-                        if (text.length > MAX_MAIN_LENGTH) {
-                            accumulatedText = text.substring(0, MAX_MAIN_LENGTH - truncationNote.length) + truncationNote;
-                        }
-                        else {
-                            accumulatedText = text;
-                        }
-                        const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
-                        if (messageTs) {
-                            await this.webClient.chat.update({
-                                channel: event.channel,
-                                ts: messageTs,
-                                text: displayText,
-                            });
-                        }
-                        else {
-                            // Post initial message
-                            const result = await this.webClient.chat.postMessage({
-                                channel: event.channel,
-                                text: displayText,
-                            });
-                            messageTs = result.ts;
-                        }
-                    }
-                    catch (err) {
-                        log.logWarning("Slack replaceMessage error", err instanceof Error ? err.message : String(err));
-                    }
-                });
-                await updatePromise;
-            },
-            setWorking: async (working) => {
-                updatePromise = updatePromise.then(async () => {
-                    try {
-                        isWorking = working;
-                        // If we have a message, update it to add/remove indicator
-                        if (messageTs) {
-                            const displayText = isWorking ? accumulatedText + workingIndicator : accumulatedText;
-                            await this.webClient.chat.update({
-                                channel: event.channel,
-                                ts: messageTs,
-                                text: displayText,
-                            });
-                        }
-                    }
-                    catch (err) {
-                        log.logWarning("Slack setWorking error", err instanceof Error ? err.message : String(err));
-                    }
-                });
-                await updatePromise;
-            },
-        };
+        return timestamps;
     }
-    /**
-     * Backfill missed messages for a single channel
-     * Returns the number of messages backfilled
-     */
     async backfillChannel(channelId) {
-        const lastTs = this.store.getLastTimestamp(channelId);
+        const existingTs = this.getExistingTimestamps(channelId);
+        // Find the biggest ts in log.jsonl
+        let latestTs;
+        for (const ts of existingTs) {
+            if (!latestTs || parseFloat(ts) > parseFloat(latestTs))
+                latestTs = ts;
+        }
         const allMessages = [];
         let cursor;
         let pageCount = 0;
@@ -414,7 +291,7 @@ export class MomBot {
         do {
             const result = await this.webClient.conversations.history({
                 channel: channelId,
-                oldest: lastTs ?? undefined,
+                oldest: latestTs, // Only fetch messages newer than what we have
                 inclusive: false,
                 limit: 1000,
                 cursor,
@@ -425,15 +302,14 @@ export class MomBot {
             cursor = result.response_metadata?.next_cursor;
             pageCount++;
         } while (cursor && pageCount < maxPages);
-        // Filter messages: include mom's messages, exclude other bots
+        // Filter: include mom's messages, exclude other bots, skip already logged
         const relevantMessages = allMessages.filter((msg) => {
-            // Always include mom's own messages
+            if (!msg.ts || existingTs.has(msg.ts))
+                return false; // Skip duplicates
             if (msg.user === this.botUserId)
                 return true;
-            // Exclude other bot messages
             if (msg.bot_id)
                 return false;
-            // Standard filters for user messages
             if (msg.subtype !== undefined && msg.subtype !== "file_share")
                 return false;
             if (!msg.user)
@@ -442,76 +318,114 @@ export class MomBot {
                 return false;
             return true;
         });
-        // Reverse to chronological order (API returns newest first)
+        // Reverse to chronological order
         relevantMessages.reverse();
-        // Log each message
+        // Log each message to log.jsonl
         for (const msg of relevantMessages) {
             const isMomMessage = msg.user === this.botUserId;
+            const user = this.users.get(msg.user);
+            // Strip @mentions from text (same as live messages)
+            const text = (msg.text || "").replace(/<@[A-Z0-9]+>/gi, "").trim();
+            // Process attachments - queues downloads in background
             const attachments = msg.files ? this.store.processAttachments(channelId, msg.files, msg.ts) : [];
-            if (isMomMessage) {
-                // Log mom's message as bot response
-                await this.store.logMessage(channelId, {
-                    date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
-                    ts: msg.ts,
-                    user: "bot",
-                    text: msg.text || "",
-                    attachments,
-                    isBot: true,
-                });
-            }
-            else {
-                // Log user message
-                const { userName, displayName } = await this.getUserInfo(msg.user);
-                await this.store.logMessage(channelId, {
-                    date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
-                    ts: msg.ts,
-                    user: msg.user,
-                    userName,
-                    displayName,
-                    text: msg.text || "",
-                    attachments,
-                    isBot: false,
-                });
-            }
+            this.logToFile(channelId, {
+                date: new Date(parseFloat(msg.ts) * 1000).toISOString(),
+                ts: msg.ts,
+                user: isMomMessage ? "bot" : msg.user,
+                userName: isMomMessage ? undefined : user?.userName,
+                displayName: isMomMessage ? undefined : user?.displayName,
+                text,
+                attachments,
+                isBot: isMomMessage,
+            });
         }
         return relevantMessages.length;
     }
-    /**
-     * Backfill missed messages for all channels
-     */
     async backfillAllChannels() {
         const startTime = Date.now();
-        log.logBackfillStart(this.channelCache.size);
+        // Only backfill channels that already have a log.jsonl (mom has interacted with them before)
+        const channelsToBackfill = [];
+        for (const [channelId, channel] of this.channels) {
+            const logPath = join(this.workingDir, channelId, "log.jsonl");
+            if (existsSync(logPath)) {
+                channelsToBackfill.push([channelId, channel]);
+            }
+        }
+        log.logBackfillStart(channelsToBackfill.length);
         let totalMessages = 0;
-        for (const [channelId, channelName] of this.channelCache) {
+        for (const [channelId, channel] of channelsToBackfill) {
             try {
                 const count = await this.backfillChannel(channelId);
-                if (count > 0) {
-                    log.logBackfillChannel(channelName, count);
-                }
+                if (count > 0)
+                    log.logBackfillChannel(channel.name, count);
                 totalMessages += count;
             }
             catch (error) {
-                log.logWarning(`Failed to backfill channel #${channelName}`, String(error));
+                log.logWarning(`Failed to backfill #${channel.name}`, String(error));
             }
         }
         const durationMs = Date.now() - startTime;
         log.logBackfillComplete(totalMessages, durationMs);
     }
-    async start() {
-        const auth = await this.webClient.auth.test();
-        this.botUserId = auth.user_id;
-        // Fetch channels and users in parallel
-        await Promise.all([this.fetchChannels(), this.fetchUsers()]);
-        log.logInfo(`Loaded ${this.channelCache.size} channels, ${this.userCache.size} users`);
-        // Backfill any messages missed while offline
-        await this.backfillAllChannels();
-        await this.socketClient.start();
-        log.logConnected();
+    // ==========================================================================
+    // Private - Fetch Users/Channels
+    // ==========================================================================
+    async fetchUsers() {
+        let cursor;
+        do {
+            const result = await this.webClient.users.list({ limit: 200, cursor });
+            const members = result.members;
+            if (members) {
+                for (const u of members) {
+                    if (u.id && u.name && !u.deleted) {
+                        this.users.set(u.id, { id: u.id, userName: u.name, displayName: u.real_name || u.name });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
     }
-    async stop() {
-        await this.socketClient.disconnect();
-        log.logDisconnected();
+    async fetchChannels() {
+        // Fetch public/private channels
+        let cursor;
+        do {
+            const result = await this.webClient.conversations.list({
+                types: "public_channel,private_channel",
+                exclude_archived: true,
+                limit: 200,
+                cursor,
+            });
+            const channels = result.channels;
+            if (channels) {
+                for (const c of channels) {
+                    if (c.id && c.name && c.is_member) {
+                        this.channels.set(c.id, { id: c.id, name: c.name });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
+        // Also fetch DM channels (IMs)
+        cursor = undefined;
+        do {
+            const result = await this.webClient.conversations.list({
+                types: "im",
+                limit: 200,
+                cursor,
+            });
+            const ims = result.channels;
+            if (ims) {
+                for (const im of ims) {
+                    if (im.id) {
+                        // Use user's name as channel name for DMs
+                        const user = im.user ? this.users.get(im.user) : undefined;
+                        const name = user ? `DM:${user.userName}` : `DM:${im.id}`;
+                        this.channels.set(im.id, { id: im.id, name });
+                    }
+                }
+            }
+            cursor = result.response_metadata?.next_cursor;
+        } while (cursor);
     }
 }
 //# sourceMappingURL=slack.js.map