@herdctl/core 4.2.0 → 5.1.0

package/dist/fleet-manager/__tests__/slack-manager.test.js

@@ -1,983 +0,0 @@
-/**
- * Tests for SlackManager
- *
- * Tests the SlackManager class which manages Slack connectors for agents
- * with chat.slack configured (one connector per agent).
- *
- * Since @herdctl/slack is not a dependency of @herdctl/core, we mock the
- * dynamic import to test the full initialization and lifecycle paths.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { EventEmitter } from "node:events";
-// ---------------------------------------------------------------------------
-// Mock Factories
-// ---------------------------------------------------------------------------
-const mockLogger = {
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-};
-function createMockEmitter() {
-    const emitter = new EventEmitter();
-    vi.spyOn(emitter, "emit");
-    return emitter;
-}
-function createMockContext(config = null, emitter = createMockEmitter()) {
-    return {
-        getConfig: () => config,
-        getStateDir: () => "/tmp/test-state",
-        getStateDirInfo: () => null,
-        getLogger: () => mockLogger,
-        getScheduler: () => null,
-        getStatus: () => "initialized",
-        getInitializedAt: () => null,
-        getStartedAt: () => null,
-        getStoppedAt: () => null,
-        getLastError: () => null,
-        getCheckInterval: () => 1000,
-        emit: (event, ...args) => emitter.emit(event, ...args),
-        getEmitter: () => emitter,
-    };
-}
-function createSlackAgent(name, slackConfig) {
-    return {
-        name,
-        model: "sonnet",
-        runtime: "sdk",
-        schedules: {},
-        chat: { slack: slackConfig },
-        configPath: "/test/herdctl.yaml",
-    };
-}
-function createNonSlackAgent(name) {
-    return {
-        name,
-        model: "sonnet",
-        schedules: {},
-        configPath: "/test/herdctl.yaml",
-    };
-}
-const defaultSlackConfig = {
-    bot_token_env: "SLACK_BOT_TOKEN",
-    app_token_env: "SLACK_APP_TOKEN",
-    session_expiry_hours: 24,
-    log_level: "standard",
-    channels: [{ id: "C0123456789", mode: "mention", context_messages: 10 }],
-};
-function createConfigWithAgents(...agents) {
-    return {
-        fleet: { name: "test-fleet" },
-        agents,
-        configPath: "/test/herdctl.yaml",
-        configDir: "/test",
-    };
-}
-// ---------------------------------------------------------------------------
-// Mock SlackConnector and SessionManager
-// ---------------------------------------------------------------------------
-function createMockConnector(agentName, sessionManager) {
-    const connector = new EventEmitter();
-    connector.agentName = agentName;
-    connector.sessionManager = sessionManager;
-    connector.connect = vi.fn().mockResolvedValue(undefined);
-    connector.disconnect = vi.fn().mockResolvedValue(undefined);
-    connector.isConnected = vi.fn().mockReturnValue(false);
-    connector.getState = vi.fn().mockReturnValue({
-        status: "disconnected",
-        connectedAt: null,
-        disconnectedAt: null,
-        reconnectAttempts: 0,
-        lastError: null,
-        botUser: null,
-        messageStats: { received: 0, sent: 0, ignored: 0 },
-    });
-    connector.uploadFile = vi.fn().mockResolvedValue({ fileId: "file-123" });
-    return connector;
-}
-function createMockSessionManager(agentName) {
-    return {
-        agentName,
-        getOrCreateSession: vi.fn().mockResolvedValue({ sessionId: "session-1", isNew: true }),
-        getSession: vi.fn().mockResolvedValue(null),
-        setSession: vi.fn().mockResolvedValue(undefined),
-        touchSession: vi.fn().mockResolvedValue(undefined),
-        clearSession: vi.fn().mockResolvedValue(true),
-        cleanupExpiredSessions: vi.fn().mockResolvedValue(0),
-        getActiveSessionCount: vi.fn().mockResolvedValue(0),
-    };
-}
-// ---------------------------------------------------------------------------
-// Tests – No Mock (no mocked SlackConnector; tests basic init paths)
-// ---------------------------------------------------------------------------
-describe("SlackManager (no @herdctl/slack)", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-        // Mock @herdctl/slack to simulate it not being installed
-        vi.doMock("@herdctl/slack", () => {
-            throw new Error("Cannot find package '@herdctl/slack'");
-        });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    // We import fresh each time to avoid stale module state
-    async function getSlackManager() {
-        const mod = await import("../slack-manager.js");
-        return mod.SlackManager;
-    }
-    describe("constructor", () => {
-        it("creates instance with context", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext();
-            const manager = new SlackManager(ctx);
-            expect(manager).toBeDefined();
-        });
-    });
-    describe("initialize", () => {
-        it("skips initialization when no config is available", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No config available, skipping Slack initialization");
-        });
-        it("skips when @herdctl/slack is not installed (no slack agents)", async () => {
-            const SlackManager = await getSlackManager();
-            const config = createConfigWithAgents(createNonSlackAgent("agent1"), createNonSlackAgent("agent2"));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connectors");
-        });
-        it("skips when @herdctl/slack is not installed (with slack agents)", async () => {
-            const SlackManager = await getSlackManager();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("@herdctl/slack not installed, skipping Slack connectors");
-        });
-        it("allows retry when no config (initialized not set)", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.initialize();
-            const calls = mockLogger.debug.mock.calls.filter((c) => c[0] === "No config available, skipping Slack initialization");
-            expect(calls.length).toBe(2);
-        });
-    });
-    describe("start", () => {
-        it("does nothing when no connector exists", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to start");
-        });
-    });
-    describe("stop", () => {
-        it("does nothing when no connector exists", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.stop();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to stop");
-        });
-    });
-    describe("hasAgent", () => {
-        it("returns false when not initialized", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            expect(manager.hasAgent("test-agent")).toBe(false);
-        });
-    });
-    describe("getState", () => {
-        it("returns null when no connector for agent", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            expect(manager.getState("test-agent")).toBeNull();
-        });
-    });
-    describe("getConnectedCount", () => {
-        it("returns 0 when no connectors", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            expect(manager.getConnectedCount()).toBe(0);
-        });
-    });
-    describe("getConnector", () => {
-        it("returns undefined when no connector for agent", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            expect(manager.getConnector("test-agent")).toBeUndefined();
-        });
-    });
-    describe("getConnectorNames", () => {
-        it("returns empty array when not initialized", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            expect(manager.getConnectorNames()).toEqual([]);
-        });
-    });
-    describe("splitResponse", () => {
-        it("returns single chunk for short text", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            const result = manager.splitResponse("Hello, world!");
-            expect(result).toEqual(["Hello, world!"]);
-        });
-        it("splits long text at natural breaks", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            // Build a text larger than 4000 chars
-            const line = "This is a test line that is moderately long. ";
-            const longText = line.repeat(100); // ~4500 chars
-            const chunks = manager.splitResponse(longText);
-            expect(chunks.length).toBeGreaterThan(1);
-            for (const chunk of chunks) {
-                expect(chunk.length).toBeLessThanOrEqual(4000);
-            }
-            // All content preserved
-            expect(chunks.join("")).toBe(longText);
-        });
-        it("splits at double newlines when available", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            const part1 = "A".repeat(3800);
-            const part2 = "B".repeat(200);
-            const longText = part1 + "\n\n" + part2;
-            const chunks = manager.splitResponse(longText);
-            expect(chunks.length).toBe(2);
-            expect(chunks[0]).toBe(part1 + "\n\n");
-        });
-        it("splits at single newline when no double newline", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            const part1 = "A".repeat(3900);
-            const part2 = "B".repeat(200);
-            const longText = part1 + "\n" + part2;
-            const chunks = manager.splitResponse(longText);
-            expect(chunks.length).toBe(2);
-            expect(chunks[0]).toBe(part1 + "\n");
-        });
-        it("splits at space when no newline", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            const part1 = "A".repeat(3950);
-            const part2 = "B".repeat(200);
-            const longText = part1 + " " + part2;
-            const chunks = manager.splitResponse(longText);
-            expect(chunks.length).toBe(2);
-            expect(chunks[0]).toBe(part1 + " ");
-        });
-    });
-    describe("formatErrorMessage", () => {
-        it("formats an error with !reset suggestion", async () => {
-            const SlackManager = await getSlackManager();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            const result = manager.formatErrorMessage(new Error("Something broke"));
-            expect(result).toContain("Something broke");
-            expect(result).toContain("!reset");
-        });
-    });
-});
-// ---------------------------------------------------------------------------
-// Tests – With Mocked @herdctl/slack (full initialization paths)
-// ---------------------------------------------------------------------------
-describe("SlackManager (mocked @herdctl/slack)", () => {
-    let mockConnectors;
-    let mockSessionManagers;
-    let MockSlackConnector;
-    let MockSessionManager;
-    let originalEnv;
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.resetModules();
-        originalEnv = { ...process.env };
-        // Set required env vars
-        process.env.SLACK_BOT_TOKEN = "xoxb-test-bot-token";
-        process.env.SLACK_APP_TOKEN = "xapp-test-app-token";
-        // Create mock implementations - per-agent connectors
-        mockConnectors = new Map();
-        mockSessionManagers = new Map();
-        // Must use function expressions (not arrows) so they work with `new`
-        MockSessionManager = vi.fn().mockImplementation(function (opts) {
-            const sessionMgr = createMockSessionManager(opts.agentName);
-            mockSessionManagers.set(opts.agentName, sessionMgr);
-            return sessionMgr;
-        });
-        MockSlackConnector = vi.fn().mockImplementation(function (opts) {
-            const connector = createMockConnector(opts.agentName, opts.sessionManager);
-            mockConnectors.set(opts.agentName, connector);
-            return connector;
-        });
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-        process.env = originalEnv;
-    });
-    async function getSlackManagerWithMock() {
-        // Mock the dynamic import. vi.resetModules() in beforeEach ensures
-        // the import cache is cleared so our mock takes effect.
-        vi.doMock("@herdctl/slack", () => ({
-            SlackConnector: MockSlackConnector,
-            SessionManager: MockSessionManager,
-        }));
-        // Force fresh import of the slack-manager module
-        const mod = await import("../slack-manager.js");
-        return mod.SlackManager;
-    }
-    describe("initialize", () => {
-        it("creates connector when slack agents exist and tokens are set", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(MockSessionManager).toHaveBeenCalledWith(expect.objectContaining({
-                agentName: "agent1",
-                stateDir: "/tmp/test-state",
-                sessionExpiryHours: 24,
-            }));
-            expect(MockSlackConnector).toHaveBeenCalledWith(expect.objectContaining({
-                agentName: "agent1",
-                botToken: "xoxb-test-bot-token",
-                appToken: "xapp-test-app-token",
-                channels: [{ id: "C0123456789", mode: "mention" }],
-            }));
-            expect(manager.hasAgent("agent1")).toBe(true);
-            expect(manager.getConnector("agent1")).toBe(mockConnectors.get("agent1"));
-        });
-        it("creates separate connectors for multiple agents", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C001", mode: "mention", context_messages: 10 }, { id: "C002", mode: "mention", context_messages: 10 }],
-            }), createSlackAgent("agent2", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C003", mode: "mention", context_messages: 10 }],
-            }));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(manager.getConnectorNames()).toEqual(["agent1", "agent2"]);
-            expect(MockSlackConnector).toHaveBeenCalledTimes(2);
-            expect(manager.getConnector("agent1")).toBeDefined();
-            expect(manager.getConnector("agent2")).toBeDefined();
-        });
-        it("skips when no agents have Slack configured", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createNonSlackAgent("agent1"));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No agents with Slack configured");
-            expect(MockSlackConnector).not.toHaveBeenCalled();
-        });
-        it("warns and skips agent when bot token env var is missing", async () => {
-            delete process.env.SLACK_BOT_TOKEN;
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Slack bot token not found"));
-            expect(MockSlackConnector).not.toHaveBeenCalled();
-        });
-        it("warns and skips agent when app token env var is missing", async () => {
-            delete process.env.SLACK_APP_TOKEN;
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Slack app token not found"));
-            expect(MockSlackConnector).not.toHaveBeenCalled();
-        });
-        it("is idempotent after successful initialization", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.initialize();
-            // Constructor only called once
-            expect(MockSlackConnector).toHaveBeenCalledTimes(1);
-        });
-        it("is idempotent after no-agents path", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createNonSlackAgent("agent1"));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.initialize();
-            const calls = mockLogger.debug.mock.calls.filter((c) => c[0] === "No agents with Slack configured");
-            expect(calls.length).toBe(1);
-        });
-        it("logs info about successful initialization", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining("Slack manager initialized with 1 connector(s)"));
-        });
-        it("handles connector creation failure for one agent", async () => {
-            MockSlackConnector.mockImplementationOnce(() => {
-                throw new Error("Failed to create Bolt app");
-            });
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to create Slack connector for agent 'agent1'"));
-            expect(manager.getConnector("agent1")).toBeUndefined();
-        });
-        it("creates connectors for multiple agents", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C001", mode: "mention", context_messages: 10 }],
-            }), createSlackAgent("agent2", {
-                ...defaultSlackConfig,
-                channels: [{ id: "C002", mode: "mention", context_messages: 10 }],
-            }), createNonSlackAgent("agent3"));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            expect(MockSessionManager).toHaveBeenCalledTimes(2);
-            expect(MockSlackConnector).toHaveBeenCalledTimes(2);
-            expect(manager.hasAgent("agent1")).toBe(true);
-            expect(manager.hasAgent("agent2")).toBe(true);
-            expect(manager.hasAgent("agent3")).toBe(false);
-        });
-    });
-    describe("start", () => {
-        it("connects the connector and subscribes to events", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const connector = mockConnectors.get("agent1");
-            expect(connector?.connect).toHaveBeenCalledTimes(1);
-            expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining("Slack connectors started"));
-        });
-        it("handles connection failure for one agent", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            // Make the connector fail to connect
-            const connector = mockConnectors.get("agent1");
-            connector?.connect.mockRejectedValue(new Error("Connection refused"));
-            await manager.start();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to connect Slack for agent 'agent1'"));
-        });
-        it("logs debug message when no connectors to start", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const ctx = createMockContext(null);
-            const manager = new SlackManager(ctx);
-            await manager.start();
-            expect(mockLogger.debug).toHaveBeenCalledWith("No Slack connectors to start");
-        });
-    });
-    describe("stop", () => {
-        it("disconnects all connectors", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.stop();
-            const connector = mockConnectors.get("agent1");
-            expect(connector?.disconnect).toHaveBeenCalledTimes(1);
-            expect(mockLogger.debug).toHaveBeenCalledWith("All Slack connectors stopped");
-        });
-        it("handles disconnect failure for one agent", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            const connector = mockConnectors.get("agent1");
-            connector?.disconnect.mockRejectedValue(new Error("Disconnect timeout"));
-            await manager.stop();
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Error disconnecting Slack for agent 'agent1'"));
-        });
-        it("logs active session counts before stopping", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            // Update the session manager to return 3 active sessions
-            const connector = mockConnectors.get("agent1");
-            connector?.sessionManager.getActiveSessionCount.mockResolvedValue(3);
-            await manager.stop();
-            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining("Preserving 3 active Slack session(s)"));
-        });
-        it("handles session count query failure gracefully", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            // Make the session manager fail
-            const connector = mockConnectors.get("agent1");
-            connector?.sessionManager.getActiveSessionCount.mockRejectedValue(new Error("File read error"));
-            await manager.stop();
-            expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining("Failed to get Slack session count"));
-        });
-    });
-    describe("getConnectedCount", () => {
-        it("returns count of connected connectors", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            const connector = mockConnectors.get("agent1");
-            connector?.isConnected.mockReturnValue(true);
-            expect(manager.getConnectedCount()).toBe(1);
-        });
-    });
-    describe("getState", () => {
-        it("delegates to connector.getState() for specific agent", async () => {
-            const state = {
-                status: "connected",
-                connectedAt: "2026-01-01T00:00:00Z",
-                disconnectedAt: null,
-                reconnectAttempts: 0,
-                lastError: null,
-                botUser: { id: "U123", username: "testbot" },
-                messageStats: { received: 5, sent: 3, ignored: 1 },
-            };
-            const SlackManager = await getSlackManagerWithMock();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            const connector = mockConnectors.get("agent1");
-            connector?.getState.mockReturnValue(state);
-            expect(manager.getState("agent1")).toBe(state);
-        });
-    });
-    describe("message handling (via connector events)", () => {
-        it("emits slack:error event when connector error fires", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            // Simulate error from connector (with agentName)
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("error", {
-                agentName: "agent1",
-                error: new Error("Socket closed"),
-            });
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'agent1'"));
-            expect(emitter.emit).toHaveBeenCalledWith("slack:error", expect.objectContaining({
-                agentName: "agent1",
-                error: "Socket closed",
-            }));
-        });
-        it("handles message with successful trigger", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            // Add a trigger method to the emitter (FleetManager exposes this)
-            const triggerMock = vi.fn().mockResolvedValue({
-                jobId: "job-123",
-                success: true,
-                sessionId: "session-abc",
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const stopIndicator = vi.fn();
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Help me with coding",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => stopIndicator,
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            expect(triggerMock).toHaveBeenCalledWith("agent1", undefined, expect.objectContaining({
-                prompt: "Help me with coding",
-            }));
-            expect(stopIndicator).toHaveBeenCalled();
-            expect(emitter.emit).toHaveBeenCalledWith("slack:message:handled", expect.objectContaining({
-                agentName: "agent1",
-                jobId: "job-123",
-            }));
-        });
-        it("sends fallback when no messages streamed and job succeeds", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const triggerMock = vi.fn().mockResolvedValue({
-                jobId: "job-123",
-                success: true,
-                sessionId: null,
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Do something",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            // Should send fallback message
-            expect(replyFn).toHaveBeenCalledWith(expect.stringContaining("completed the task"));
-        });
-        it("sends error fallback when job fails and no messages streamed", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const triggerMock = vi.fn().mockResolvedValue({
-                jobId: "job-123",
-                success: false,
-                error: new Error("API rate limit"),
-                errorDetails: { message: "API rate limit exceeded" },
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Do something",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            expect(replyFn).toHaveBeenCalledWith(expect.stringContaining("API rate limit exceeded"));
-        });
-        it("handles trigger throw and sends error message", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const triggerMock = vi.fn().mockRejectedValue(new Error("Trigger failed"));
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Do something",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack message handling failed"));
-            expect(replyFn).toHaveBeenCalledWith(expect.stringContaining("Trigger failed"));
-            expect(emitter.emit).toHaveBeenCalledWith("slack:message:error", expect.objectContaining({
-                agentName: "agent1",
-                error: "Trigger failed",
-            }));
-        });
-        it("resumes existing session when one exists", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const triggerMock = vi.fn().mockResolvedValue({
-                jobId: "job-123",
-                success: true,
-                sessionId: "new-session-789",
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            // Set up the session manager to return an existing session
-            const connector = mockConnectors.get("agent1");
-            connector?.sessionManager.getSession.mockResolvedValue({
-                sessionId: "existing-session-456",
-                lastMessageAt: "2026-02-15T10:00:00Z",
-            });
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Continue our conversation",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: false,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            // Should pass the existing session for resume
-            expect(triggerMock).toHaveBeenCalledWith("agent1", undefined, expect.objectContaining({
-                resume: "existing-session-456",
-            }));
-            // Should store the new session
-            expect(connector?.sessionManager.setSession).toHaveBeenCalledWith("C0123456789", "new-session-789");
-        });
-        it("streams assistant messages via onMessage callback", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            let capturedOnMessage = null;
-            const triggerMock = vi.fn().mockImplementation(async (_name, _schedule, opts) => {
-                capturedOnMessage = opts?.onMessage ?? null;
-                // Simulate streaming messages
-                if (capturedOnMessage) {
-                    await capturedOnMessage({ type: "assistant", content: "Hello from agent!" });
-                }
-                return { jobId: "job-123", success: true, sessionId: "s1" };
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Say hello",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 100));
-            // Should have sent the streamed message
-            expect(replyFn).toHaveBeenCalledWith("Hello from agent!");
-        });
-        it("handles non-Error string in error handler", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            // Simulate non-Error (string) error from connector
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("error", {
-                agentName: "agent1",
-                error: "string error",
-            });
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack connector error for agent 'agent1': string error"));
-        });
-        it("handles reply failure during error handling gracefully", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            const triggerMock = vi.fn().mockRejectedValue(new Error("Boom"));
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockRejectedValue(new Error("Reply failed too"));
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Do something",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 50));
-            // Should log both the original error and the reply failure
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Slack message handling failed"));
-            expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining("Failed to send error reply"));
-        });
-        it("extracts text from message.message.content array", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            let capturedOnMessage = null;
-            const triggerMock = vi.fn().mockImplementation(async (_name, _schedule, opts) => {
-                capturedOnMessage = opts?.onMessage ?? null;
-                if (capturedOnMessage) {
-                    // Simulate content array format
-                    await capturedOnMessage({
-                        type: "assistant",
-                        message: {
-                            content: [
-                                { type: "text", text: "Part 1 " },
-                                { type: "text", text: "Part 2" },
-                            ],
-                        },
-                    });
-                }
-                return { jobId: "job-123", success: true, sessionId: null };
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Test",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 100));
-            expect(replyFn).toHaveBeenCalledWith("Part 1 Part 2");
-        });
-        it("extracts text from message.message.content string", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            let capturedOnMessage = null;
-            const triggerMock = vi.fn().mockImplementation(async (_name, _schedule, opts) => {
-                capturedOnMessage = opts?.onMessage ?? null;
-                if (capturedOnMessage) {
-                    await capturedOnMessage({
-                        type: "assistant",
-                        message: { content: "Direct string content" },
-                    });
-                }
-                return { jobId: "job-123", success: true, sessionId: null };
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Test",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 100));
-            expect(replyFn).toHaveBeenCalledWith("Direct string content");
-        });
-        it("ignores non-assistant messages in onMessage callback", async () => {
-            const SlackManager = await getSlackManagerWithMock();
-            const emitter = createMockEmitter();
-            const config = createConfigWithAgents(createSlackAgent("agent1", defaultSlackConfig));
-            let capturedOnMessage = null;
-            const triggerMock = vi.fn().mockImplementation(async (_name, _schedule, opts) => {
-                capturedOnMessage = opts?.onMessage ?? null;
-                if (capturedOnMessage) {
-                    await capturedOnMessage({ type: "system", content: "System msg" });
-                    await capturedOnMessage({ type: "assistant", content: "Real response" });
-                }
-                return { jobId: "job-123", success: true, sessionId: null };
-            });
-            emitter.trigger = triggerMock;
-            const ctx = createMockContext(config, emitter);
-            const manager = new SlackManager(ctx);
-            await manager.initialize();
-            await manager.start();
-            const replyFn = vi.fn().mockResolvedValue(undefined);
-            const connector = mockConnectors.get("agent1");
-            connector?.emit("message", {
-                agentName: "agent1",
-                prompt: "Test",
-                metadata: {
-                    channelId: "C0123456789",
-                    messageTs: "1707930001.000000",
-                    userId: "U0123456789",
-                    wasMentioned: true,
-                },
-                reply: replyFn,
-                startProcessingIndicator: () => () => { },
-            });
-            await new Promise((r) => setTimeout(r, 100));
-            // Should only send the assistant message, not the system one
-            expect(replyFn).toHaveBeenCalledWith("Real response");
-            expect(replyFn).not.toHaveBeenCalledWith("System msg");
-        });
-    });
-});
-//# sourceMappingURL=slack-manager.test.js.map