slackhive 0.1.37 → 0.1.39

package/apps/runner/src/__tests__/thread-context.test.ts

@@ -0,0 +1,215 @@
+/**
+ * @fileoverview Unit tests for thread context building in slack-handler.ts.
+ *
+ * Covers:
+ * - Real usernames and IDs resolved via users.info
+ * - Bot messages labeled with agent name
+ * - Forwarded message attachments (text, pretext, image_url, source)
+ * - Files shared in thread history (images, other files)
+ * - Username resolution cached across messages (single API call per user)
+ * - users.info failure falls back to user ID
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { buildPrompt } from '../slack-handler';
+import type { Logger } from 'winston';
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+const nopLog = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+} as unknown as Logger;
+
+const fakeAgent = {
+  id: 'agent-1',
+  name: 'Gilfoyle',
+  slackBotUserId: 'UBOT001',
+} as any;
+
+function makeClient(messages: any[], userMap: Record<string, { display_name?: string; real_name?: string }> = {}) {
+  return {
+    conversations: {
+      replies: vi.fn().mockResolvedValue({ messages }),
+    },
+    users: {
+      info: vi.fn().mockImplementation(({ user }: { user: string }) => {
+        const u = userMap[user];
+        if (!u) return Promise.reject(new Error('user not found'));
+        return Promise.resolve({ user: u });
+      }),
+    },
+  };
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────────
+
+describe('buildPrompt — thread context', () => {
+  it('resolves display names and user IDs for human messages', async () => {
+    const messages = [
+      { user: 'U001', text: 'hello there', ts: '1.0' },
+      { user: 'U002', text: 'hey @Gilfoyle', ts: '2.0' },
+      { user: 'U002', text: 'current message', ts: '3.0' }, // last message excluded
+    ];
+    const client = makeClient(messages, {
+      U001: { display_name: 'Aman' },
+      U002: { display_name: 'Kush' },
+    });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current message', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('Aman (U001): hello there');
+    expect(text).toContain('Kush (U002): hey');
+  });
+
+  it('labels bot messages with agent name', async () => {
+    const messages = [
+      { bot_id: 'B001', text: 'I am a bot response', ts: '1.0' },
+      { user: 'U001', text: 'follow up', ts: '2.0' }, // last excluded
+    ];
+    const client = makeClient(messages, {});
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'follow up', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('Gilfoyle: I am a bot response');
+    expect(text).not.toContain('User:');
+  });
+
+  it('falls back to user ID when users.info fails', async () => {
+    const messages = [
+      { user: 'U999', text: 'mystery message', ts: '1.0' },
+      { user: 'U001', text: 'next', ts: '2.0' }, // last excluded
+    ];
+    const client = makeClient(messages, {}); // U999 not in map → throws
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'next', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('U999: mystery message');
+  });
+
+  it('only calls users.info for unique users across the thread', async () => {
+    const messages = [
+      { user: 'U001', text: 'first message', ts: '1.0' },
+      { user: 'U002', text: 'second message', ts: '2.0' },
+      { user: 'U001', text: 'current', ts: '3.0' }, // last excluded
+    ];
+    const client = makeClient(messages, {
+      U001: { display_name: 'Aman' },
+      U002: { display_name: 'Kush' },
+    });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    // Both users resolved correctly
+    expect(text).toContain('Aman (U001): first message');
+    expect(text).toContain('Kush (U002): second message');
+    // Only 2 unique users → max 2 API calls
+    expect(client.users.info).toHaveBeenCalledTimes(2);
+  });
+
+  it('includes forwarded message attachment text and source', async () => {
+    const messages = [
+      {
+        user: 'U001', text: 'check this out', ts: '1.0',
+        attachments: [{
+          author_name: 'Kush',
+          text: 'why you need to be hi/hello?',
+          pretext: 'Forwarded message:',
+        }],
+      },
+      { user: 'U001', text: 'current', ts: '2.0' }, // last excluded
+    ];
+    const client = makeClient(messages, { U001: { display_name: 'Aman' } });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('check this out');
+    expect(text).toContain('[Forwarded from Kush]');
+    expect(text).toContain('Forwarded message:');
+    expect(text).toContain('why you need to be hi/hello?');
+  });
+
+  it('includes image_url from forwarded attachments', async () => {
+    const messages = [
+      {
+        user: 'U001', text: 'see screenshot', ts: '1.0',
+        attachments: [{
+          text: 'look at this',
+          image_url: 'https://files.slack.com/screenshot.png',
+        }],
+      },
+      { user: 'U001', text: 'current', ts: '2.0' },
+    ];
+    const client = makeClient(messages, { U001: { display_name: 'Aman' } });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('[Attached image: https://files.slack.com/screenshot.png]');
+  });
+
+  it('uses fallback text when attachment has no text', async () => {
+    const messages = [
+      {
+        user: 'U001', text: 'fwd', ts: '1.0',
+        attachments: [{ fallback: 'fallback content here' }],
+      },
+      { user: 'U001', text: 'current', ts: '2.0' },
+    ];
+    const client = makeClient(messages, { U001: { display_name: 'Aman' } });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('fallback content here');
+  });
+
+  it('notes images shared in thread history', async () => {
+    const messages = [
+      {
+        user: 'U001', text: '', ts: '1.0',
+        files: [{ id: 'F001', name: 'screenshot.png', mimetype: 'image/png' }],
+      },
+      { user: 'U001', text: 'current', ts: '2.0' },
+    ];
+    const client = makeClient(messages, { U001: { display_name: 'Aman' } });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('[Shared image: screenshot.png]');
+  });
+
+  it('notes non-image files shared in thread history', async () => {
+    const messages = [
+      {
+        user: 'U001', text: '', ts: '1.0',
+        files: [{ id: 'F002', name: 'report.csv', mimetype: 'text/csv' }],
+      },
+      { user: 'U001', text: 'current', ts: '2.0' },
+    ];
+    const client = makeClient(messages, { U001: { display_name: 'Aman' } });
+
+    const result = await buildPrompt(client, 'C001', '1.0', 'current', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).toContain('[Shared file: report.csv]');
+  });
+
+  it('returns no thread context when threadTs is undefined', async () => {
+    const client = makeClient([]);
+
+    const result = await buildPrompt(client, 'C001', undefined, 'hello', fakeAgent, nopLog);
+    const text = typeof result === 'string' ? result : '';
+
+    expect(text).not.toContain('[Thread context]');
+    expect(client.conversations.replies).not.toHaveBeenCalled();
+  });
+});

package/apps/runner/src/agent-runner.ts

@@ -0,0 +1,397 @@
+/**
+ * @fileoverview Agent runner — manages the lifecycle of all Slack bot instances.
+ *
+ * The AgentRunner is the top-level orchestrator for the runner service.
+ * On startup it loads all active agents from the database, starts a Slack
+ * Bolt App for each one, and listens on Redis for reload signals from the
+ * web UI.
+ *
+ * Each agent gets:
+ * - Its own Bolt App instance (separate Slack socket connection)
+ * - Its own ClaudeHandler (session manager, MCP wiring, tool permissions)
+ * - Its own MemoryWatcher (syncs learned memories to the database)
+ * - A compiled CLAUDE.md in /tmp/agents/{slug}/ (skills + memories)
+ *
+ * Hot reload flow:
+ * 1. User edits skills/MCPs/permissions in the web UI
+ * 2. Web API publishes `{ type: 'reload', agentId }` to Redis channel
+ * 3. AgentRunner receives the event, stops the agent, recompiles, restarts
+ *
+ * @module runner/agent-runner
+ */
+
+import { App, LogLevel } from '@slack/bolt';
+import { createClient, type RedisClientType } from 'redis';
+import type { Agent } from '@slackhive/shared';
+import { AGENT_EVENTS_CHANNEL, type AgentEvent } from '@slackhive/shared';
+import { JobScheduler } from './job-scheduler';
+import {
+  getAllAgents,
+  getAgentById,
+  getAgentMcpServers,
+  getAgentPermissions,
+  getAgentRestrictions,
+  getAgentMemories,
+  getAllEnvVarValues,
+  updateAgentStatus,
+} from './db';
+import { compileClaudeMd, materializeMemoryFiles } from './compile-claude-md';
+import { ClaudeHandler } from './claude-handler';
+import { MemoryWatcher } from './memory-watcher';
+import { registerSlackHandlers } from './slack-handler';
+import { logger } from './logger';
+
+/**
+ * Represents a fully initialized running agent.
+ * All resources owned by a running agent are held here for cleanup.
+ */
+interface RunningAgent {
+  agent: Agent;
+  app: App;
+  claudeHandler: ClaudeHandler;
+  memoryWatcher: MemoryWatcher;
+}
+
+/**
+ * Manages the lifecycle of all Claude Code Slack bot instances.
+ *
+ * @example
+ * const runner = new AgentRunner();
+ * await runner.start();
+ * // Ctrl+C triggers graceful shutdown
+ */
+export class AgentRunner {
+  /** Map of agent ID → running agent resources. */
+  private runningAgents: Map<string, RunningAgent> = new Map();
+
+  /** Scheduled job executor. */
+  private jobScheduler: JobScheduler;
+
+  /** Redis subscriber client for hot-reload events. */
+  private redisSubscriber: RedisClientType | null = null;
+
+  constructor() {
+    this.jobScheduler = new JobScheduler((agentId: string) => this.getRunningAgent(agentId));
+  }
+
+  /**
+   * Returns any running agent by ID, or undefined if not running.
+   */
+  getRunningAgent(agentId: string): { app: App; claudeHandler: import('./claude-handler').ClaudeHandler } | undefined {
+    const ra = this.runningAgents.get(agentId);
+    return ra ? { app: ra.app, claudeHandler: ra.claudeHandler } : undefined;
+  }
+
+  /**
+   * Starts the runner:
+   * 1. Connects to Redis for hot-reload events
+   * 2. Loads and starts all active agents from the database
+   * 3. Registers graceful shutdown handlers
+   *
+   * @returns {Promise<void>}
+   * @throws {Error} If Redis connection fails.
+   */
+  async start(): Promise<void> {
+    logger.info('AgentRunner starting...');
+
+    await this.connectRedis();
+    await this.loadAllAgents();
+    await this.jobScheduler.start();
+    this.registerShutdownHandlers();
+
+    logger.info('AgentRunner started', { agents: this.runningAgents.size });
+  }
+
+  /**
+   * Gracefully stops all running agents and disconnects from Redis.
+   *
+   * @returns {Promise<void>}
+   */
+  async stop(): Promise<void> {
+    logger.info('AgentRunner stopping...');
+
+    // Stop job scheduler
+    await this.jobScheduler.stop();
+
+    // Stop all agents concurrently
+    const stopPromises = Array.from(this.runningAgents.keys()).map((id) =>
+      this.stopAgent(id).catch((err) =>
+        logger.warn('Error stopping agent during shutdown', { agentId: id, error: err.message })
+      )
+    );
+    await Promise.all(stopPromises);
+
+    if (this.redisSubscriber) {
+      await this.redisSubscriber.unsubscribe();
+      await this.redisSubscriber.disconnect();
+      this.redisSubscriber = null;
+    }
+
+    logger.info('AgentRunner stopped');
+  }
+
+  // ===========================================================================
+  // Agent lifecycle
+  // ===========================================================================
+
+  /**
+   * Loads all agents from the database and starts each one.
+   *
+   * @returns {Promise<void>}
+   */
+  private async loadAllAgents(): Promise<void> {
+    const agents = await getAllAgents();
+    logger.info('Loading agents from database', { count: agents.length });
+
+    // Start agents sequentially to avoid overwhelming Slack's rate limits.
+    // Skip agents that are stopped or have placeholder/missing tokens.
+    for (const agent of agents) {
+      if (agent.enabled === false) {
+        logger.info('Skipping disabled agent', { agent: agent.slug });
+        continue;
+      }
+      if (
+        !agent.slackBotToken.startsWith('xoxb-') ||
+        !agent.slackAppToken.startsWith('xapp-') ||
+        agent.slackBotToken.includes('placeholder') ||
+        agent.slackAppToken.includes('placeholder')
+      ) {
+        logger.warn('Skipping agent with invalid/placeholder tokens', { agent: agent.slug });
+        await updateAgentStatus(agent.id, 'stopped');
+        continue;
+      }
+      try {
+        await this.startAgent(agent);
+      } catch (err) {
+        logger.error('Failed to start agent', { agent: agent.slug, error: (err as Error).message });
+        await updateAgentStatus(agent.id, 'error');
+      }
+    }
+  }
+
+  /**
+   * Starts a single agent:
+   * 1. Loads its MCP servers and permissions from the database
+   * 2. Compiles CLAUDE.md from skills + memories
+   * 3. Materializes memory files to disk
+   * 4. Creates Bolt App + ClaudeHandler + MemoryWatcher
+   * 5. Registers Slack event handlers
+   * 6. Starts the Bolt App (opens Socket Mode connection)
+   *
+   * @param {Agent} agent - The agent to start.
+   * @returns {Promise<void>}
+   * @throws {Error} If Slack App fails to start.
+   */
+  private async startAgent(agent: Agent): Promise<void> {
+    if (this.runningAgents.has(agent.id)) {
+      logger.warn('Agent already running, skipping start', { agent: agent.slug });
+      return;
+    }
+
+    logger.info('Starting agent', { agent: agent.slug });
+
+    // Load configuration from DB
+    const [mcpServers, permissions, restrictions, memories, envVarValues] = await Promise.all([
+      getAgentMcpServers(agent.id),
+      getAgentPermissions(agent.id),
+      getAgentRestrictions(agent.id),
+      getAgentMemories(agent.id),
+      getAllEnvVarValues(),
+    ]);
+
+    // Compile CLAUDE.md (identity + skills → temp workspace)
+    const workDir = await compileClaudeMd(agent);
+
+    // Materialize memory files so the /recall skill can read them
+    materializeMemoryFiles(agent, memories);
+
+    // Create Claude Code SDK handler
+    const claudeHandler = new ClaudeHandler(agent, mcpServers, permissions, workDir, envVarValues);
+    claudeHandler.initialize();
+
+    // Create memory watcher (persists SDK memory writes back to DB)
+    const memoryWatcher = new MemoryWatcher(agent);
+    memoryWatcher.start();
+
+    // Create Slack Bolt App in Socket Mode
+    const app = new App({
+      token: agent.slackBotToken,
+      appToken: agent.slackAppToken,
+      signingSecret: agent.slackSigningSecret,
+      socketMode: true,
+      logLevel: process.env.LOG_LEVEL === 'debug' ? LogLevel.DEBUG : LogLevel.WARN,
+    });
+
+    // Register all Slack event listeners
+    registerSlackHandlers(app, agent, claudeHandler, restrictions);
+
+    // Start the Bolt App
+    await app.start();
+
+    // Fetch and store the bot's Slack user ID for @mention construction
+    try {
+      const authResult = await app.client.auth.test({ token: agent.slackBotToken });
+      if (authResult.user_id && authResult.user_id !== agent.slackBotUserId) {
+        await updateAgentStatus(agent.id, 'running'); // Will also trigger updateAgentSlackUserId below
+        const { updateAgentSlackUserId } = await import('./db');
+        await updateAgentSlackUserId(agent.id, authResult.user_id as string);
+        agent.slackBotUserId = authResult.user_id as string;
+      }
+    } catch (err) {
+      logger.warn('Failed to fetch bot user ID', { agent: agent.slug, error: err });
+    }
+
+    this.runningAgents.set(agent.id, { agent, app, claudeHandler, memoryWatcher });
+    await updateAgentStatus(agent.id, 'running');
+
+    logger.info('Agent started', {
+      agent: agent.slug,
+      mcpServers: mcpServers.map((m) => m.name),
+    });
+  }
+
+  /**
+   * Stops a running agent and cleans up all its resources.
+   *
+   * @param {string} agentId - UUID of the agent to stop.
+   * @returns {Promise<void>}
+   */
+  private async stopAgent(agentId: string): Promise<void> {
+    const running = this.runningAgents.get(agentId);
+    if (!running) return;
+
+    const { agent, app, claudeHandler, memoryWatcher } = running;
+    logger.info('Stopping agent', { agent: agent.slug });
+
+    memoryWatcher.stop();
+    claudeHandler.destroy();
+
+    try {
+      await app.stop();
+    } catch (err) {
+      logger.warn('Error stopping Bolt App', { agent: agent.slug, error: err });
+    }
+
+    this.runningAgents.delete(agentId);
+    await updateAgentStatus(agentId, 'stopped');
+
+    logger.info('Agent stopped', { agent: agent.slug });
+  }
+
+  /**
+   * Reloads an agent: stops it, re-fetches its config, recompiles, and restarts.
+   * Called when the web UI publishes a reload event.
+   *
+   * @param {string} agentId - UUID of the agent to reload.
+   * @returns {Promise<void>}
+   */
+  private async reloadAgent(agentId: string): Promise<void> {
+    logger.info('Reloading agent', { agentId });
+
+    await this.stopAgent(agentId);
+
+    const agent = await getAgentById(agentId);
+    if (!agent) {
+      logger.warn('Agent not found after reload event', { agentId });
+      return;
+    }
+
+    await this.startAgent(agent);
+  }
+
+  // ===========================================================================
+  // Redis pub/sub
+  // ===========================================================================
+
+  /**
+   * Connects to Redis and subscribes to agent lifecycle events.
+   *
+   * @returns {Promise<void>}
+   * @throws {Error} If REDIS_URL is not set or connection fails.
+   */
+  private async connectRedis(): Promise<void> {
+    const redisUrl = process.env.REDIS_URL;
+    if (!redisUrl) {
+      logger.warn('REDIS_URL not set — hot reload disabled');
+      return;
+    }
+
+    this.redisSubscriber = createClient({ url: redisUrl }) as RedisClientType;
+
+    this.redisSubscriber.on('error', (err) => {
+      logger.warn('Redis subscriber error', { error: err.message });
+    });
+
+    await this.redisSubscriber.connect();
+
+    await this.redisSubscriber.subscribe(AGENT_EVENTS_CHANNEL, (message) => {
+      this.handleAgentEvent(message);
+    });
+
+    logger.info('Redis subscriber connected', { channel: AGENT_EVENTS_CHANNEL });
+  }
+
+  /**
+   * Handles an agent lifecycle event received from Redis.
+   *
+   * @param {string} rawMessage - JSON-encoded AgentEvent.
+   * @returns {void}
+   */
+  private handleAgentEvent(rawMessage: string): void {
+    let event: AgentEvent;
+    try {
+      event = JSON.parse(rawMessage) as AgentEvent;
+    } catch {
+      logger.warn('Received malformed agent event', { rawMessage });
+      return;
+    }
+
+    logger.info('Received agent event', { event });
+
+    switch (event.type) {
+      case 'reload':
+        this.reloadAgent(event.agentId).catch((err) =>
+          logger.error('Failed to reload agent', { agentId: event.agentId, error: err.message })
+        );
+        break;
+      case 'start':
+        getAgentById(event.agentId)
+          .then((agent) => agent && this.startAgent(agent))
+          .catch((err) =>
+            logger.error('Failed to start agent', { agentId: event.agentId, error: err.message })
+          );
+        break;
+      case 'stop':
+        this.stopAgent(event.agentId).catch((err) =>
+          logger.error('Failed to stop agent', { agentId: event.agentId, error: err.message })
+        );
+        break;
+      case 'reload-jobs':
+        this.jobScheduler.reload().catch((err) =>
+          logger.error('Failed to reload jobs', { error: (err as Error).message })
+        );
+        break;
+    }
+  }
+
+  // ===========================================================================
+  // Graceful shutdown
+  // ===========================================================================
+
+  /**
+   * Registers SIGTERM and SIGINT handlers for graceful shutdown.
+   * Ensures all agents are cleanly stopped before the process exits.
+   *
+   * @returns {void}
+   */
+  private registerShutdownHandlers(): void {
+    const shutdown = async (signal: string) => {
+      logger.info(`Received ${signal}, shutting down gracefully...`);
+      await this.stop();
+      process.exit(0);
+    };
+
+    process.on('SIGTERM', () => shutdown('SIGTERM'));
+    process.on('SIGINT', () => shutdown('SIGINT'));
+  }
+}