slackhive 0.1.37 → 0.1.39

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

@@ -0,0 +1,165 @@
+/**
+ * @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

@@ -0,0 +1,49 @@
+/**
+ * @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

@@ -0,0 +1,195 @@
+/**
+ * @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

@@ -0,0 +1,85 @@
+/**
+ * @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);
+`;