@hoverlover/cc-discord 0.1.0

package/server/db.ts

@@ -0,0 +1,249 @@
+/**
+ * Database initialization and query helpers for the relay server.
+ */
+
+import { Database as DatabaseSync } from "bun:sqlite";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { DATA_DIR } from "./config.ts";
+
+mkdirSync(DATA_DIR, { recursive: true });
+
+export const db = new DatabaseSync(join(DATA_DIR, "messages.db"));
+
+db.exec(`
+  CREATE TABLE IF NOT EXISTS messages (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    session_id TEXT NOT NULL,
+    from_agent TEXT NOT NULL,
+    to_agent TEXT NOT NULL,
+    message_type TEXT NOT NULL,
+    content TEXT NOT NULL,
+    source TEXT NOT NULL DEFAULT 'discord',
+    external_id TEXT,
+    channel_id TEXT,
+    read INTEGER DEFAULT 0
+  );
+
+  CREATE TABLE IF NOT EXISTS agent_activity (
+    session_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'idle',
+    activity_type TEXT,
+    activity_summary TEXT,
+    started_at TEXT,
+    updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (session_id, agent_id)
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_messages_session ON messages(session_id);
+  CREATE INDEX IF NOT EXISTS idx_messages_to_agent ON messages(to_agent);
+  CREATE INDEX IF NOT EXISTS idx_messages_read ON messages(read);
+  CREATE UNIQUE INDEX IF NOT EXISTS idx_messages_source_external
+    ON messages(source, external_id);
+  CREATE INDEX IF NOT EXISTS idx_agent_activity_status
+    ON agent_activity(status);
+
+  CREATE TABLE IF NOT EXISTS channel_models (
+    channel_id TEXT PRIMARY KEY,
+    model TEXT NOT NULL,
+    updated_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    updated_by TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS trace_threads (
+    channel_id TEXT PRIMARY KEY,
+    thread_id TEXT NOT NULL,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP
+  );
+
+  CREATE TABLE IF NOT EXISTS trace_events (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    created_at TEXT DEFAULT CURRENT_TIMESTAMP,
+    session_id TEXT NOT NULL,
+    agent_id TEXT NOT NULL,
+    channel_id TEXT,
+    event_type TEXT NOT NULL,
+    tool_name TEXT,
+    summary TEXT,
+    posted INTEGER DEFAULT 0
+  );
+
+  CREATE INDEX IF NOT EXISTS idx_trace_events_pending
+    ON trace_events(posted, created_at);
+`);
+
+export const insertStmt = db.prepare(`
+  INSERT INTO messages (
+    session_id,
+    from_agent,
+    to_agent,
+    message_type,
+    content,
+    source,
+    external_id,
+    channel_id,
+    read
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+`);
+
+export function getChannelModel(channelId: string) {
+  try {
+    const row = db.prepare("SELECT model FROM channel_models WHERE channel_id = ?").get(channelId) as any;
+    return row?.model || null;
+  } catch {
+    return null;
+  }
+}
+
+export function setChannelModel(channelId: string, model: string, updatedBy: string | null) {
+  db.prepare(`
+    INSERT INTO channel_models (channel_id, model, updated_at, updated_by)
+    VALUES (?, ?, CURRENT_TIMESTAMP, ?)
+    ON CONFLICT(channel_id) DO UPDATE SET
+      model = excluded.model,
+      updated_at = excluded.updated_at,
+      updated_by = excluded.updated_by
+  `).run(channelId, model, updatedBy || null);
+}
+
+export function clearChannelModel(channelId: string) {
+  db.prepare("DELETE FROM channel_models WHERE channel_id = ?").run(channelId);
+}
+
+export function getCurrentAgentActivity(sessionId: string, defaultAgentId: string, agentIdOverride?: string | null) {
+  const targetAgent = agentIdOverride || defaultAgentId;
+  try {
+    return db
+      .prepare(`
+      SELECT status, activity_type, activity_summary, started_at, updated_at
+      FROM agent_activity
+      WHERE session_id = ? AND agent_id = ?
+      LIMIT 1
+    `)
+      .get(sessionId, targetAgent);
+  } catch {
+    return null;
+  }
+}
+
+// ── Trace thread helpers ────────────────────────────────────────────
+
+export function getTraceThreadId(channelId: string): string | null {
+  try {
+    const row = db.prepare("SELECT thread_id FROM trace_threads WHERE channel_id = ?").get(channelId) as any;
+    return row?.thread_id || null;
+  } catch {
+    return null;
+  }
+}
+
+export function setTraceThreadId(channelId: string, threadId: string) {
+  db.prepare(`
+    INSERT INTO trace_threads (channel_id, thread_id, created_at)
+    VALUES (?, ?, CURRENT_TIMESTAMP)
+    ON CONFLICT(channel_id) DO UPDATE SET
+      thread_id = excluded.thread_id,
+      created_at = excluded.created_at
+  `).run(channelId, threadId);
+}
+
+export interface TraceEvent {
+  id: number;
+  created_at: string;
+  session_id: string;
+  agent_id: string;
+  channel_id: string | null;
+  event_type: string;
+  tool_name: string | null;
+  summary: string | null;
+}
+
+export function getPendingTraceEvents(limit: number = 50): TraceEvent[] {
+  try {
+    return db
+      .prepare("SELECT * FROM trace_events WHERE posted = 0 ORDER BY created_at, id LIMIT ?")
+      .all(limit) as TraceEvent[];
+  } catch {
+    return [];
+  }
+}
+
+export function markTraceEventsPosted(ids: number[]) {
+  if (!ids.length) return;
+  try {
+    const placeholders = ids.map(() => "?").join(",");
+    db.prepare(`UPDATE trace_events SET posted = 1 WHERE id IN (${placeholders})`).run(...ids);
+  } catch {
+    // fail-open
+  }
+}
+
+export function insertTraceEvent(
+  sessionId: string,
+  agentId: string,
+  channelId: string | null,
+  eventType: string,
+  toolName: string | null,
+  summary: string | null,
+) {
+  try {
+    db.prepare(`
+      INSERT INTO trace_events (session_id, agent_id, channel_id, event_type, tool_name, summary)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run(sessionId, agentId, channelId, eventType, toolName, summary);
+  } catch {
+    // fail-open
+  }
+}
+
+/**
+ * Get health status for all agents in a session.
+ * Returns each agent's last heartbeat time, status, and whether it
+ * has unread messages waiting (a sign it might be stuck).
+ */
+export function getAgentHealthAll(sessionId: string, staleThresholdSeconds: number = 900) {
+  try {
+    const agents = db
+      .prepare(`
+      SELECT
+        a.agent_id,
+        a.status,
+        a.activity_type,
+        a.activity_summary,
+        a.updated_at,
+        CAST((julianday('now') - julianday(a.updated_at)) * 86400 AS INTEGER) as seconds_since_heartbeat,
+        COALESCE(m.unread_count, 0) as unread_count,
+        m.oldest_unread_at
+      FROM agent_activity a
+      LEFT JOIN (
+        SELECT
+          to_agent,
+          COUNT(*) as unread_count,
+          MIN(created_at) as oldest_unread_at
+        FROM messages
+        WHERE session_id = ? AND read = 0
+        GROUP BY to_agent
+      ) m ON m.to_agent = a.agent_id
+      WHERE a.session_id = ?
+      ORDER BY a.agent_id
+    `)
+      .all(sessionId, sessionId);
+
+    return agents.map((a: any) => ({
+      agentId: a.agent_id,
+      status: a.status,
+      activityType: a.activity_type,
+      activitySummary: a.activity_summary,
+      lastHeartbeat: a.updated_at,
+      secondsSinceHeartbeat: a.seconds_since_heartbeat,
+      unreadCount: a.unread_count,
+      oldestUnreadAt: a.oldest_unread_at,
+      healthy: a.seconds_since_heartbeat < staleThresholdSeconds,
+      stuck: a.seconds_since_heartbeat >= staleThresholdSeconds && a.unread_count > 0,
+    }));
+  } catch {
+    return [];
+  }
+}

package/server/index.ts

@@ -0,0 +1,311 @@
+#!/usr/bin/env bun
+
+import { Client, GatewayIntentBits, REST, Routes, SlashCommandBuilder } from "discord.js";
+import express, { type NextFunction, type Request, type Response } from "express";
+import { cleanupOldAttachments } from "./attachment.ts";
+import { maybeNotifyBusyQueued } from "./busy-notify.ts";
+import {
+  ALLOWED_CHANNEL_IDS,
+  ALLOWED_DISCORD_USER_IDS,
+  BUSY_NOTIFY_COOLDOWN_MS,
+  BUSY_NOTIFY_ON_QUEUE,
+  DEFAULT_CHANNEL_ID,
+  DISCORD_BOT_TOKEN,
+  DISCORD_SESSION_ID,
+  IGNORED_CHANNEL_IDS,
+  MESSAGE_ROUTING_MODE,
+  RELAY_ALLOW_NO_AUTH,
+  RELAY_API_TOKEN,
+  RELAY_HOST,
+  RELAY_PORT,
+  THINKING_FALLBACK_ENABLED,
+  TYPING_INTERVAL_MS,
+  TYPING_MAX_MS,
+  validateConfig,
+} from "./config.ts";
+import { clearChannelModel, db, getAgentHealthAll, getChannelModel, setChannelModel } from "./db.ts";
+import { memoryStore } from "./memory.ts";
+import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
+import { startTraceFlushLoop, stopTraceFlushLoop } from "./trace-thread.ts";
+import { startTypingIndicator, stopAllTypingSessions, stopTypingIndicator } from "./typing.ts";
+
+validateConfig();
+
+// Run attachment cleanup every 10 minutes; also once at startup
+setInterval(cleanupOldAttachments, 10 * 60 * 1000);
+cleanupOldAttachments();
+
+const client = new Client({
+  intents: [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent],
+});
+
+function isAllowedChannel(channelId: string): boolean {
+  if (!channelId) return false;
+  if (IGNORED_CHANNEL_IDS.has(channelId)) return false;
+  if (ALLOWED_CHANNEL_IDS.length > 0) return ALLOWED_CHANNEL_IDS.includes(channelId);
+  return true;
+}
+
+function isAllowedUser(userId: string | undefined): boolean {
+  if (!userId) return false;
+  if (ALLOWED_DISCORD_USER_IDS.length === 0) return true;
+  return ALLOWED_DISCORD_USER_IDS.includes(userId);
+}
+
+function requireAuth(req: Request, res: Response): boolean {
+  if (RELAY_ALLOW_NO_AUTH) return true;
+  const token = req.header("x-api-token") || req.header("authorization")?.replace(/^Bearer\s+/i, "");
+  if (!token || token !== RELAY_API_TOKEN) {
+    res.status(401).json({ success: false, error: "Unauthorized" });
+    return false;
+  }
+  return true;
+}
+
+// ── Discord client events ──────────────────────────────────────────────────────
+
+client.once("clientReady", async () => {
+  console.log(`[Relay] Discord bot ready as ${client.user?.tag}`);
+  console.log(
+    `[Relay] Listening on channel(s): ${ALLOWED_CHANNEL_IDS.length > 0 ? ALLOWED_CHANNEL_IDS.join(", ") : DEFAULT_CHANNEL_ID}`,
+  );
+  console.log(
+    `[Relay] User allowlist: ${ALLOWED_DISCORD_USER_IDS.length > 0 ? ALLOWED_DISCORD_USER_IDS.join(", ") : "disabled (all users in allowed channels)"}`,
+  );
+  console.log(`[Relay] API auth: ${RELAY_ALLOW_NO_AUTH ? "disabled (RELAY_ALLOW_NO_AUTH=true)" : "required"}`);
+  console.log(`[Relay] Message routing: ${MESSAGE_ROUTING_MODE} mode`);
+  console.log(
+    `[Relay] Busy queue notify: ${BUSY_NOTIFY_ON_QUEUE ? `on (cooldown=${BUSY_NOTIFY_COOLDOWN_MS}ms)` : "off"}`,
+  );
+  console.log(
+    `[Relay] Typing: interval=${TYPING_INTERVAL_MS}ms, max=${TYPING_MAX_MS}ms, fallback=${THINKING_FALLBACK_ENABLED ? "on" : "off"}`,
+  );
+
+  // Register /model slash command
+  try {
+    const modelCommand = new SlashCommandBuilder()
+      .setName("model")
+      .setDescription("Get or set the Claude model for this channel")
+      .addStringOption((option) =>
+        option
+          .setName("name")
+          .setDescription(
+            "Model name or alias (e.g. claude-opus-4-6, claude-sonnet-4-6, claude-haiku-4-5, or full model ID)",
+          )
+          .setRequired(false),
+      );
+
+    const rest = new REST({ version: "10" }).setToken(DISCORD_BOT_TOKEN!);
+    await rest.put(Routes.applicationCommands(client.user!.id), { body: [modelCommand.toJSON()] });
+    console.log("[Relay] Registered /model slash command");
+  } catch (err: unknown) {
+    console.error("[Relay] Failed to register slash commands:", (err as Error).message);
+  }
+
+  // Start live trace thread flush loop
+  startTraceFlushLoop(client);
+});
+
+client.on("messageCreate", async (message) => {
+  if (!message) return;
+  if (message.author?.bot) return;
+  if (!isAllowedChannel(message.channelId)) return;
+  if (!isAllowedUser(message.author?.id)) {
+    console.log(`[Relay] Ignoring message from unauthorized user ${message.author?.id}`);
+    return;
+  }
+  startTypingIndicator(client, message.channelId, persistOutboundDiscordMessage);
+  maybeNotifyBusyQueued(message, client, persistOutboundDiscordMessage);
+  await persistInboundDiscordMessage(message);
+});
+
+client.on("interactionCreate", async (interaction) => {
+  if (!interaction.isChatInputCommand()) return;
+  if (interaction.commandName !== "model") return;
+
+  const modelArg = interaction.options.getString("name");
+
+  if (!modelArg) {
+    const current = getChannelModel(interaction.channelId);
+    await interaction.reply(
+      current ? `Current model for this channel: \`${current}\`` : "No model set for this channel (using default).",
+    );
+    return;
+  }
+
+  if (modelArg === "clear" || modelArg === "reset" || modelArg === "default") {
+    clearChannelModel(interaction.channelId);
+    await interaction.reply("Model override cleared for this channel. Using default model.");
+    console.log(`[Relay] Model cleared for channel ${interaction.channelId} by ${interaction.user?.tag}`);
+    return;
+  }
+
+  setChannelModel(interaction.channelId, modelArg, interaction.user?.tag || interaction.user?.id || null);
+  await interaction.reply(`Model for this channel set to: \`${modelArg}\``);
+  console.log(`[Relay] Model set for channel ${interaction.channelId}: ${modelArg} by ${interaction.user?.tag}`);
+});
+
+client.on("error", (err) => {
+  console.error("[Relay] Discord client error:", err.message);
+});
+
+// ── Express HTTP API ───────────────────────────────────────────────────────────
+
+const app = express();
+app.use(express.json({ limit: "1mb" }));
+
+// Handle malformed JSON bodies cleanly
+app.use((err: any, _req: Request, res: Response, next: NextFunction) => {
+  if (
+    err?.type === "entity.parse.failed" ||
+    (err instanceof SyntaxError && (err as any)?.status === 400 && "body" in err)
+  ) {
+    res.status(400).json({ success: false, error: "Invalid JSON body" });
+    return;
+  }
+  next(err);
+});
+
+app.get("/health", (_req: Request, res: Response) => {
+  res.json({
+    ok: true,
+    discordReady: Boolean(client.user),
+    defaultChannelId: DEFAULT_CHANNEL_ID,
+    sessionId: DISCORD_SESSION_ID,
+  });
+});
+
+app.get("/api/channels", async (req: Request, res: Response) => {
+  try {
+    if (!requireAuth(req, res)) return;
+    if (!client.user) {
+      res.status(503).json({ success: false, error: "Discord client not ready yet" });
+      return;
+    }
+
+    const channels: any[] = [];
+    for (const [, guild] of client.guilds.cache) {
+      const guildChannels = await guild.channels.fetch();
+      for (const [, channel] of guildChannels) {
+        if (!channel || !channel.isTextBased() || channel.isThread() || channel.isVoiceBased()) continue;
+        if (IGNORED_CHANNEL_IDS.has(channel.id)) continue;
+        if (ALLOWED_CHANNEL_IDS.length > 0 && !ALLOWED_CHANNEL_IDS.includes(channel.id)) continue;
+        channels.push({
+          id: channel.id,
+          name: channel.name,
+          guildId: guild.id,
+          guildName: guild.name,
+          type: channel.type,
+          model: getChannelModel(channel.id),
+        });
+      }
+    }
+
+    res.json({ success: true, channels });
+  } catch (err: unknown) {
+    console.error("[Relay] /api/channels failed:", err);
+    res.status(500).json({ success: false, error: (err as Error).message });
+  }
+});
+
+app.get("/api/agent-health", (req: Request, res: Response) => {
+  try {
+    if (!requireAuth(req, res)) return;
+    const staleThreshold = Number(req.query.stale_threshold) || 900; // default 15 min
+    const agents = getAgentHealthAll(DISCORD_SESSION_ID, staleThreshold);
+    const stuckAgents = agents.filter((a: any) => a.stuck);
+    res.json({
+      success: true,
+      sessionId: DISCORD_SESSION_ID,
+      staleThresholdSeconds: staleThreshold,
+      agents,
+      stuckAgents: stuckAgents.map((a: any) => a.agentId),
+      anyStuck: stuckAgents.length > 0,
+    });
+  } catch (err: unknown) {
+    console.error("[Relay] /api/agent-health failed:", err);
+    res.status(500).json({ success: false, error: (err as Error).message });
+  }
+});
+
+app.post("/api/send", async (req: Request, res: Response) => {
+  try {
+    if (!requireAuth(req, res)) return;
+    if (!client.user) {
+      res.status(503).json({ success: false, error: "Discord client not ready yet" });
+      return;
+    }
+
+    const { content, channelId, replyTo, fromAgent } = req.body || {};
+    const text = String(content || "").trim();
+    const targetChannelId = channelId || DEFAULT_CHANNEL_ID;
+
+    if (!text) {
+      res.status(400).json({ success: false, error: "Missing content" });
+      return;
+    }
+
+    const channel = await client.channels.fetch(targetChannelId);
+    if (!channel || !channel.isTextBased()) {
+      res.status(400).json({ success: false, error: `Channel ${targetChannelId} not found or not text-based` });
+      return;
+    }
+
+    let sent: any;
+    if (replyTo && channel.messages?.fetch) {
+      const original = await channel.messages.fetch(replyTo);
+      sent = await original.reply(text);
+    } else {
+      if (!("send" in channel) || typeof channel.send !== "function") {
+        res.status(400).json({ success: false, error: `Channel ${targetChannelId} does not support sending messages` });
+        return;
+      }
+      sent = await channel.send(text);
+    }
+
+    persistOutboundDiscordMessage({ content: text, channelId: targetChannelId, externalId: sent.id, fromAgent });
+    stopTypingIndicator(client, targetChannelId, persistOutboundDiscordMessage, "reply-sent");
+
+    res.json({ success: true, messageId: sent.id, channelId: targetChannelId });
+  } catch (err: unknown) {
+    console.error("[Relay] /api/send failed:", err);
+    res.status(500).json({ success: false, error: (err as Error).message });
+  }
+});
+
+// ── Server startup ─────────────────────────────────────────────────────────────
+
+const server = app.listen(RELAY_PORT, RELAY_HOST, () => {
+  console.log(`[Relay] HTTP API running at http://${RELAY_HOST}:${RELAY_PORT}`);
+});
+
+client.login(DISCORD_BOT_TOKEN).catch((err: Error) => {
+  console.error("[Relay] Failed to login to Discord:", err.message);
+  process.exit(1);
+});
+
+function shutdown(signal: string) {
+  console.log(`\n[Relay] Received ${signal}. Shutting down...`);
+  stopTraceFlushLoop();
+  stopAllTypingSessions(client, persistOutboundDiscordMessage);
+  try {
+    server.close();
+  } catch {
+    /* ignore */
+  }
+  try {
+    client.destroy();
+  } catch {
+    /* ignore */
+  }
+  try {
+    db.close();
+  } catch {
+    /* ignore */
+  }
+  void memoryStore.close().catch(() => {});
+  process.exit(0);
+}
+
+process.on("SIGINT", () => shutdown("SIGINT"));
+process.on("SIGTERM", () => shutdown("SIGTERM"));

package/server/memory.ts

@@ -0,0 +1,88 @@
+/**
+ * Memory integration for the relay server.
+ * Persists inbound/outbound turns and assembles memory context for context injection.
+ *
+ * Session key strategy:
+ * When a channelId is provided, turns are written to a per-channel key
+ * (discord:{sessionId}:{channelId}) so that per-channel subagents can
+ * retrieve them. This matches the key that wait-for-discord-messages
+ * uses on the read side (agentId = channelId).
+ *
+ * When no channelId is available, falls back to the legacy shared key
+ * (discord:{sessionId}:{CLAUDE_AGENT_ID}).
+ */
+
+import { join } from "node:path";
+import { MemoryCoordinator } from "../memory/core/MemoryCoordinator.ts";
+import { buildMemorySessionKey } from "../memory/core/session-key.ts";
+import { SqliteMemoryStore } from "../memory/providers/sqlite/SqliteMemoryStore.ts";
+import { CLAUDE_AGENT_ID, DATA_DIR, DISCORD_SESSION_ID } from "./config.ts";
+
+/** Legacy fallback key for turns without a channel association. */
+const fallbackSessionKey = buildMemorySessionKey({
+  sessionId: DISCORD_SESSION_ID,
+  agentId: CLAUDE_AGENT_ID,
+});
+
+export const memoryStore = new SqliteMemoryStore({
+  dbPath: join(DATA_DIR, "memory.db"),
+  logger: console,
+});
+
+export const memory = new MemoryCoordinator({
+  store: memoryStore,
+  logger: console,
+});
+
+await memory.init();
+
+/**
+ * Resolve the memory session key for a turn.
+ * If channelId is available, produces a per-channel key matching what
+ * the subagent's wait-for-discord-messages will query.
+ */
+function resolveSessionKey(channelId?: string): string {
+  if (channelId) {
+    // Subagents set AGENT_ID=channelId and build their key as:
+    //   buildMemorySessionKey({ sessionId, agentId: channelId })
+    // => discord:{sessionId}:{channelId}
+    return buildMemorySessionKey({
+      sessionId: DISCORD_SESSION_ID,
+      agentId: channelId,
+    });
+  }
+  return fallbackSessionKey;
+}
+
+export async function appendMemoryTurn({
+  role,
+  content,
+  metadata = {} as any,
+}: {
+  role: string;
+  content: string;
+  metadata?: any;
+}) {
+  try {
+    const channelId = metadata?.channelId || null;
+    const sessionKey = resolveSessionKey(channelId);
+    const runtimeState = await memoryStore.readRuntimeState(sessionKey);
+
+    const result = await memory.appendTurn({
+      sessionKey,
+      agentId: channelId || CLAUDE_AGENT_ID,
+      role,
+      content,
+      metadata: {
+        ...metadata,
+        runtimeContextId: runtimeState?.runtimeContextId || null,
+        runtimeEpoch: runtimeState?.runtimeEpoch || null,
+      },
+    });
+    console.log(
+      `[Memory] persisted ${role} turn to ${sessionKey} (batch=${result?.batchId}, turns=${result?.counts?.turns})`,
+    );
+  } catch (err: unknown) {
+    console.error("[Memory] failed to persist turn:", (err as Error).message);
+  }
+}