slackhive 0.1.40 → 0.1.42

package/apps/runner/src/job-scheduler.ts

@@ -1,165 +0,0 @@
-/**
- * @fileoverview Job scheduler — executes scheduled jobs via node-cron.
- *
- * On each cron trigger:
- * 1. Finds the boss agent from the runningAgents map
- * 2. Sends the job's prompt to the boss via claudeHandler.streamQuery()
- * 3. Posts the result to the target Slack channel or DM
- * 4. Records the run in the job_runs table
- *
- * @module runner/job-scheduler
- */
-
-import cron from 'node-cron';
-import type { App } from '@slack/bolt';
-import type { ScheduledJob } from '@slackhive/shared';
-import { getAllEnabledJobs, insertJobRun, updateJobRun } from './db';
-import type { ClaudeHandler } from './claude-handler';
-import { logger } from './logger';
-
-/** The shape of a running agent as exposed by AgentRunner. */
-interface RunningAgent {
-  app: App;
-  claudeHandler: ClaudeHandler;
-}
-
-/**
- * Manages cron-scheduled jobs that are executed by any running agent.
- *
- * @example
- * ```ts
- * const scheduler = new JobScheduler((id) => agentRunner.getRunningAgent(id));
- * await scheduler.start();
- * ```
- */
-export class JobScheduler {
-  private tasks: Map<string, cron.ScheduledTask> = new Map();
-  private running: Set<string> = new Set();
-
-  /**
-   * @param {(agentId: string) => RunningAgent | undefined} getAgent - Returns a running agent by ID.
-   */
-  constructor(private getAgent: (agentId: string) => RunningAgent | undefined) {}
-
-  /**
-   * Loads all enabled jobs from DB and schedules them.
-   */
-  async start(): Promise<void> {
-    await this.reload();
-    logger.info('Job scheduler started');
-  }
-
-  /**
-   * Destroys all cron tasks.
-   */
-  async stop(): Promise<void> {
-    for (const [id, task] of this.tasks) {
-      task.stop();
-      logger.info('Job unscheduled', { jobId: id });
-    }
-    this.tasks.clear();
-    logger.info('Job scheduler stopped');
-  }
-
-  /**
-   * Reloads all jobs from DB — destroys old tasks, creates new ones.
-   */
-  async reload(): Promise<void> {
-    // Stop all existing tasks
-    for (const task of this.tasks.values()) {
-      task.stop();
-    }
-    this.tasks.clear();
-
-    // Load enabled jobs
-    const jobs = await getAllEnabledJobs();
-    for (const job of jobs) {
-      if (!cron.validate(job.cronSchedule)) {
-        logger.warn('Invalid cron expression, skipping', { jobId: job.id, cron: job.cronSchedule });
-        continue;
-      }
-      this.scheduleJob(job);
-    }
-
-    logger.info('Jobs reloaded', { count: jobs.length, scheduled: this.tasks.size });
-  }
-
-  /**
-   * Schedules a single job.
-   */
-  private scheduleJob(job: ScheduledJob): void {
-    const task = cron.schedule(job.cronSchedule, () => {
-      this.executeJob(job).catch(err =>
-        logger.error('Job execution failed', { jobId: job.id, error: (err as Error).message })
-      );
-    });
-    this.tasks.set(job.id, task);
-    logger.info('Job scheduled', { jobId: job.id, name: job.name, cron: job.cronSchedule });
-  }
-
-  /**
-   * Executes a single job — sends prompt to boss, posts result.
-   */
-  private async executeJob(job: ScheduledJob): Promise<void> {
-    // Prevent overlapping runs of the same job
-    if (this.running.has(job.id)) {
-      logger.warn('Skipping overlapping job run', { jobId: job.id });
-      return;
-    }
-    this.running.add(job.id);
-
-    // Skip silently if agent is not running — avoids noisy error runs
-    const agent = this.getAgent(job.agentId);
-    if (!agent) {
-      logger.warn('Skipping job — agent not running', { jobId: job.id, agentId: job.agentId });
-      return;
-    }
-
-    const runId = await insertJobRun(job.id);
-    logger.info('Job run started', { jobId: job.id, runId, name: job.name });
-
-    try {
-
-      // Fresh session key per run (no resume)
-      const sessionKey = `job-${job.id}-${Date.now()}`;
-
-      // Stream query to agent
-      let output = '';
-      for await (const msg of agent.claudeHandler.streamQuery(job.prompt, sessionKey)) {
-        const m = msg as Record<string, unknown>;
-        if (m.type === 'result' && m.subtype === 'success') {
-          output = (m.result as string) ?? '';
-        }
-      }
-
-      if (!output) {
-        output = '_Job completed with no output._';
-      }
-
-      // Post to target
-      if (job.targetType === 'dm') {
-        const dm = await agent.app.client.conversations.open({ users: job.targetId });
-        if (dm.channel?.id) {
-          await agent.app.client.chat.postMessage({
-            channel: dm.channel.id,
-            text: output,
-          });
-        }
-      } else {
-        await agent.app.client.chat.postMessage({
-          channel: job.targetId,
-          text: output,
-        });
-      }
-
-      await updateJobRun(runId, 'success', output.slice(0, 2000));
-      logger.info('Job run succeeded', { jobId: job.id, runId });
-    } catch (err) {
-      const errMsg = (err as Error).message;
-      await updateJobRun(runId, 'error', null, errMsg);
-      logger.error('Job run failed', { jobId: job.id, runId, error: errMsg });
-    } finally {
-      this.running.delete(job.id);
-    }
-  }
-}

package/apps/runner/src/logger.ts

@@ -1,49 +0,0 @@
-/**
- * @fileoverview Structured logger for the runner service.
- *
- * Wraps Winston to provide consistent JSON-structured logs with
- * support for an optional agent context field. All log entries
- * include a timestamp and log level.
- *
- * @module runner/logger
- */
-
-import winston from 'winston';
-
-const { combine, timestamp, json, colorize, simple } = winston.format;
-
-const isDev = process.env.NODE_ENV !== 'production';
-
-/**
- * The shared logger instance for the runner service.
- * Use this for all logging throughout the runner.
- *
- * @example
- * logger.info('Agent started', { agent: 'gilfoyle' });
- * logger.error('Failed to compile CLAUDE.md', { agent: 'boss', error: err.message });
- */
-export const logger = winston.createLogger({
-  level: process.env.LOG_LEVEL ?? (isDev ? 'debug' : 'info'),
-  format: isDev
-    ? combine(timestamp(), colorize(), simple())
-    : combine(timestamp(), json()),
-  transports: [
-    new winston.transports.Console(),
-  ],
-});
-
-/**
- * Creates a child logger with a fixed `agent` context field.
- * All log entries from the child will include `{ agent: slug }`.
- *
- * @param {string} slug - Agent slug to attach to all log entries.
- * @returns {winston.Logger} Child logger with agent context.
- *
- * @example
- * const log = agentLogger('gilfoyle');
- * log.info('Session started', { sessionKey: 'U123-C456-...' });
- * // → { level: 'info', message: 'Session started', agent: 'gilfoyle', sessionKey: '...' }
- */
-export function agentLogger(slug: string): winston.Logger {
-  return logger.child({ agent: slug });
-}

package/apps/runner/src/mcp-process-manager.ts

@@ -1,195 +0,0 @@
-/**
- * @fileoverview Persistent MCP server manager.
- *
- * Keeps stdio MCP servers alive as long-running processes for the duration of
- * an agent's lifetime, rather than spawning fresh processes per query. Each
- * stdio MCP is proxied as a local SSE endpoint so the Claude Agent SDK can
- * connect to it via HTTP instead of spawning a new process every turn.
- *
- * Architecture:
- *   stdio MCP process ←→ Client (MCP SDK) ←→ ProxyServer ←→ SSE HTTP server
- *                                                               ↑
- *                                              Claude Agent SDK connects here
- *
- * @module runner/mcp-process-manager
- */
-
-import * as fs from 'fs';
-import * as path from 'path';
-import * as http from 'http';
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
-import {
-  ListToolsRequestSchema,
-  CallToolRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
-} from '@modelcontextprotocol/sdk/types.js';
-import type { McpStdioConfig } from '@slackhive/shared';
-import { agentLogger } from './logger.js';
-import type { Logger } from 'winston';
-
-interface ManagedProxy {
-  client: Client;
-  httpServer: http.Server;
-  port: number;
-  url: string;
-}
-
-/**
- * Manages persistent MCP server processes for a single agent.
- * Call `startAll()` when the agent starts, `stopAll()` when it stops.
- */
-export class McpProcessManager {
-  private readonly proxies = new Map<string, ManagedProxy>();
-  private nextPort: number;
-  private readonly log: Logger;
-  private readonly workDir: string;
-
-  constructor(agentSlug: string, workDir: string, basePort: number) {
-    this.log = agentLogger(agentSlug);
-    this.workDir = workDir;
-    this.nextPort = basePort;
-  }
-
-  /**
-   * Starts a persistent stdio MCP process and exposes it as an SSE proxy.
-   * Returns the SSE URL to pass to the Claude Agent SDK.
-   */
-  async startServer(
-    name: string,
-    config: McpStdioConfig,
-    envVarValues: Record<string, string> = {}
-  ): Promise<string> {
-    // Stop any existing proxy for this server
-    await this.stopServer(name);
-
-    // Build resolved environment
-    const env: Record<string, string> = {
-      ...(process.env as Record<string, string>),
-      ...(config.env ?? {}),
-    };
-    for (const [subKey, storeKey] of Object.entries((config.envRefs ?? {}) as Record<string, string>)) {
-      if (envVarValues[storeKey] !== undefined) env[subKey] = envVarValues[storeKey];
-    }
-
-    // For inline TypeScript source, write to disk first
-    let command = config.command;
-    let args = config.args ?? [];
-    if (config.tsSource) {
-      const scriptDir = path.join(this.workDir, '.mcp-scripts');
-      const scriptPath = path.join(scriptDir, `${name}.ts`);
-      fs.mkdirSync(scriptDir, { recursive: true });
-      fs.writeFileSync(scriptPath, config.tsSource as string, 'utf8');
-      command = '/app/node_modules/.bin/tsx';
-      args = [scriptPath];
-      env.NODE_PATH = '/app/node_modules';
-    }
-
-    // Connect to the stdio MCP process
-    const transport = new StdioClientTransport({ command, args, env });
-    const client = new Client(
-      { name: 'slackhive-proxy', version: '1.0.0' },
-      { capabilities: {} }
-    );
-
-    try {
-      await client.connect(transport);
-    } catch (err) {
-      this.log.error('Failed to connect to MCP server', { server: name, error: (err as Error).message });
-      throw err;
-    }
-
-    this.log.info('MCP server connected', { server: name, command });
-
-    const caps = client.getServerCapabilities() ?? {};
-
-    // Build a proxy MCP Server that forwards calls to the client
-    const proxyServer = new Server(
-      { name, version: '1.0.0' },
-      { capabilities: caps }
-    );
-
-    if (caps.tools) {
-      proxyServer.setRequestHandler(ListToolsRequestSchema, () => client.listTools());
-      proxyServer.setRequestHandler(CallToolRequestSchema, (req) =>
-        client.callTool({ name: req.params.name, arguments: req.params.arguments ?? {} })
-      );
-    }
-    if (caps.resources) {
-      proxyServer.setRequestHandler(ListResourcesRequestSchema, () => client.listResources());
-      proxyServer.setRequestHandler(ReadResourceRequestSchema, (req) =>
-        client.readResource({ uri: req.params.uri })
-      );
-    }
-    if (caps.prompts) {
-      proxyServer.setRequestHandler(ListPromptsRequestSchema, () => client.listPrompts());
-      proxyServer.setRequestHandler(GetPromptRequestSchema, (req) =>
-        client.getPrompt({ name: req.params.name, arguments: req.params.arguments })
-      );
-    }
-
-    // Serve the proxy over SSE on a local port
-    const port = this.nextPort++;
-    const sseTransports = new Map<string, SSEServerTransport>();
-
-    const httpServer = http.createServer(async (req, res) => {
-      try {
-        if (req.method === 'GET' && req.url === '/sse') {
-          const sseTransport = new SSEServerTransport('/message', res);
-          sseTransports.set(sseTransport.sessionId, sseTransport);
-          res.on('close', () => sseTransports.delete(sseTransport.sessionId));
-          await proxyServer.connect(sseTransport);
-        } else if (req.method === 'POST' && req.url?.startsWith('/message')) {
-          const sessionId = new URL(req.url, `http://127.0.0.1:${port}`).searchParams.get('sessionId') ?? '';
-          const sseTransport = sseTransports.get(sessionId);
-          if (sseTransport) {
-            await sseTransport.handlePostMessage(req, res);
-          } else {
-            res.writeHead(404).end('Session not found');
-          }
-        } else {
-          res.writeHead(404).end();
-        }
-      } catch (err) {
-        this.log.error('MCP proxy HTTP error', { server: name, error: (err as Error).message });
-        if (!res.headersSent) res.writeHead(500).end();
-      }
-    });
-
-    await new Promise<void>((resolve, reject) => {
-      httpServer.once('error', reject);
-      httpServer.listen(port, '127.0.0.1', resolve);
-    });
-
-    const url = `http://127.0.0.1:${port}/sse`;
-    this.proxies.set(name, { client, httpServer, port, url });
-    this.log.info('MCP proxy listening', { server: name, url });
-
-    return url;
-  }
-
-  /** Returns the SSE URL for a running proxy, or undefined if not started. */
-  getUrl(name: string): string | undefined {
-    return this.proxies.get(name)?.url;
-  }
-
-  /** Stops and cleans up a single MCP proxy. */
-  async stopServer(name: string): Promise<void> {
-    const proxy = this.proxies.get(name);
-    if (!proxy) return;
-    this.proxies.delete(name);
-    await proxy.client.close().catch(() => {});
-    await new Promise<void>((resolve) => proxy.httpServer.close(() => resolve()));
-    this.log.info('MCP proxy stopped', { server: name });
-  }
-
-  /** Stops all running MCP proxies. */
-  async stopAll(): Promise<void> {
-    await Promise.all([...this.proxies.keys()].map((name) => this.stopServer(name)));
-  }
-}

package/apps/runner/src/memory-mcp.ts

@@ -1,85 +0,0 @@
-/**
- * @fileoverview Built-in memory MCP server source code.
- *
- * This TypeScript source is injected as an inline stdio MCP for every agent.
- * It exposes three tools — list_memories, search_memories, get_memory — that
- * query the agent's memory rows directly from Postgres.
- *
- * The script runs via `tsx` inside the runner container and receives:
- *   DATABASE_URL  — Postgres connection string
- *   MEMORY_AGENT_ID — the agent's UUID (injected by ClaudeHandler)
- *
- * @module runner/memory-mcp
- */
-
-export const MEMORY_MCP_SOURCE = `
-import { Pool } from "pg";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-
-const pool = new Pool({ connectionString: process.env.DATABASE_URL });
-const AGENT_ID = process.env.MEMORY_AGENT_ID;
-
-const server = new Server({ name: "memory", version: "1.0.0" }, { capabilities: { tools: {} } });
-
-server.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: "list_memories",
-      description: "List all memories for this agent. Returns names and a short preview. Optionally filter by type.",
-      inputSchema: { type: "object", properties: { type: { type: "string", enum: ["user", "feedback", "project", "reference"], description: "Filter by memory type (optional)" } } },
-    },
-    {
-      name: "search_memories",
-      description: "Search memories by keyword across name and content. Use to find relevant past context.",
-      inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] },
-    },
-    {
-      name: "get_memory",
-      description: "Get the full content of a specific memory by name.",
-      inputSchema: { type: "object", properties: { name: { type: "string" } }, required: ["name"] },
-    },
-  ],
-}));
-
-function text(t) { return { content: [{ type: "text", text: t }] }; }
-function err(e) { return { content: [{ type: "text", text: String(e) }], isError: true }; }
-
-server.setRequestHandler(CallToolRequestSchema, async (req) => {
-  const { name, arguments: args } = req.params;
-  const a = args ?? {};
-  try {
-    if (name === "list_memories") {
-      const q = a.type
-        ? "SELECT type, name, LEFT(content, 300) as preview FROM memories WHERE agent_id = $1 AND type = $2 ORDER BY type, name"
-        : "SELECT type, name, LEFT(content, 300) as preview FROM memories WHERE agent_id = $1 ORDER BY type, name";
-      const params = a.type ? [AGENT_ID, a.type] : [AGENT_ID];
-      const r = await pool.query(q, params);
-      if (r.rows.length === 0) return text("No memories found.");
-      return text(r.rows.map(row => "[" + row.type + "] " + row.name + "\\n" + row.preview.split("\\n").slice(0, 3).join("\\n")).join("\\n\\n"));
-    }
-    if (name === "search_memories") {
-      const r = await pool.query(
-        "SELECT type, name, content FROM memories WHERE agent_id = $1 AND (name ILIKE $2 OR content ILIKE $2) ORDER BY type, name",
-        [AGENT_ID, "%" + a.query + "%"]
-      );
-      if (r.rows.length === 0) return text("No memories found matching \\"" + a.query + "\\".");
-      return text(r.rows.map(row => "[" + row.type + "] " + row.name + "\\n\\n" + row.content).join("\\n\\n---\\n\\n"));
-    }
-    if (name === "get_memory") {
-      const r = await pool.query("SELECT type, name, content FROM memories WHERE agent_id = $1 AND name = $2", [AGENT_ID, a.name]);
-      if (r.rows.length === 0) return text("Memory \\"" + a.name + "\\" not found.");
-      const row = r.rows[0];
-      return text("[" + row.type + "] " + row.name + "\\n\\n" + row.content);
-    }
-    return err("Unknown tool: " + name);
-  } catch (e) { return err(e); }
-});
-
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-}
-main().catch(console.error);
-`;