@hoverlover/cc-discord 0.1.0

package/tools/memory-smoke.ts

@@ -0,0 +1,173 @@
+#!/usr/bin/env bun
+
+// Keep smoke output clean on Node builds where sqlite is marked experimental.
+const _origEmit = process.emit;
+process.emit = function (event: string, ...args: any[]) {
+  if (event === "warning" && args[0]?.name === "ExperimentalWarning") return false;
+  return _origEmit.call(this, event, ...args) as any;
+};
+
+import assert from "node:assert/strict";
+import { randomUUID } from "node:crypto";
+import { rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { MemoryCoordinator } from "../memory/core/MemoryCoordinator.ts";
+import { SqliteMemoryStore } from "../memory/providers/sqlite/SqliteMemoryStore.ts";
+
+const dbPath = join(tmpdir(), `cc-discord-memory-smoke-${process.pid}-${Date.now()}.db`);
+const store = new SqliteMemoryStore({ dbPath });
+const coordinator = new MemoryCoordinator({ store, logger: console });
+
+try {
+  await coordinator.init();
+
+  const health = await store.health();
+  assert.equal(health.ok, true);
+
+  const sessionKey = `smoke-${randomUUID()}`;
+  const batchId = `batch-${randomUUID()}`;
+
+  const write1 = await store.writeBatch({
+    batchId,
+    sessionKey,
+    agentId: "claude-test",
+    turns: [
+      { role: "user", content: "Hello memory store" },
+      { role: "assistant", content: "Hi, I remember that." },
+    ],
+    snapshot: {
+      summaryText: "User greeted the assistant",
+      openTasks: ["Keep tracking context"],
+      decisions: ["Use sqlite primary memory store"],
+    },
+    cardsUpsert: [
+      {
+        cardType: "decision",
+        title: "Storage choice",
+        body: "Use sqlite as primary memory store",
+        pinned: true,
+      },
+    ],
+  });
+
+  assert.equal(write1.idempotent, false);
+  assert.equal(write1.counts.turns, 2);
+  assert.equal(write1.counts.snapshots, 1);
+  assert.equal(write1.counts.cardsUpserted, 1);
+
+  const write2 = await store.writeBatch({
+    batchId,
+    sessionKey,
+    turns: [{ role: "user", content: "This should not be written twice" }],
+  });
+
+  assert.equal(write2.idempotent, true);
+
+  const snapshot = await store.readSessionSnapshot(sessionKey);
+  assert.ok(snapshot);
+  assert.equal(snapshot.summaryText, "User greeted the assistant");
+
+  const turns = await store.listTurns({ sessionKey, limit: 10 });
+  assert.equal(turns.length, 2);
+  assert.equal(turns[0].turnIndex, 0);
+  assert.equal(turns[1].turnIndex, 1);
+
+  const recentTurns = await store.listRecentTurns({ sessionKey, limit: 1 });
+  assert.equal(recentTurns.length, 1);
+  assert.equal(recentTurns[0].turnIndex, 1);
+
+  const cards = await store.queryCards({ sessionKey, limit: 10 });
+  assert.equal(cards.length, 1);
+  assert.equal(cards[0].cardType, "decision");
+
+  const runtimeState = await coordinator.ensureRuntimeContext({
+    sessionKey,
+    runtimeContextId: "runtime-current",
+    runtimeEpoch: 1,
+  });
+
+  await coordinator.appendTurn({
+    sessionKey,
+    role: "user",
+    content: "Legacy runtime detail: we chose sqlite for memory",
+    metadata: { runtimeContextId: "runtime-legacy", runtimeEpoch: 0 },
+  });
+
+  await coordinator.appendTurn({
+    sessionKey,
+    role: "user",
+    content: "Current runtime only detail: temporary debug flag is on",
+    metadata: {
+      runtimeContextId: runtimeState.runtimeContextId,
+      runtimeEpoch: runtimeState.runtimeEpoch,
+    },
+  });
+
+  const currentRuntimeTurn = (await store.listRecentTurns({ sessionKey, limit: 5 })).find((t: any) =>
+    /Current runtime only detail/.test(t.content),
+  );
+  assert.ok(currentRuntimeTurn);
+
+  const legacyContext = await coordinator.assembleContext({
+    sessionKey,
+    queryText: "what did we choose for memory backend?",
+    runtimeContextId: runtimeState.runtimeContextId,
+    runtimeEpoch: runtimeState.runtimeEpoch,
+    maxCards: 3,
+    maxRecallTurns: 4,
+  });
+  assert.ok(legacyContext);
+  assert.ok(Array.isArray(legacyContext.cards));
+  assert.equal(
+    legacyContext.recalledTurns.some((t: any) => /Legacy runtime detail/.test(t.content)),
+    true,
+  );
+
+  const filteredContext = await coordinator.assembleContext({
+    sessionKey,
+    queryText: "is temporary debug flag on?",
+    runtimeContextId: runtimeState.runtimeContextId,
+    runtimeEpoch: runtimeState.runtimeEpoch,
+    maxCards: 2,
+    maxRecallTurns: 6,
+  });
+
+  assert.equal(
+    filteredContext.recalledTurns.some((t: any) => /Current runtime only detail/.test(t.content)),
+    false,
+  );
+
+  // Compaction caveat: once current-runtime turn is compacted, it becomes eligible again.
+  await store.writeBatch({
+    batchId: `compact-${randomUUID()}`,
+    sessionKey,
+    compactedToTurnId: currentRuntimeTurn.id,
+  });
+
+  const postCompactionContext = await coordinator.assembleContext({
+    sessionKey,
+    queryText: "is temporary debug flag on?",
+    runtimeContextId: runtimeState.runtimeContextId,
+    runtimeEpoch: runtimeState.runtimeEpoch,
+    maxCards: 2,
+    maxRecallTurns: 6,
+  });
+
+  assert.equal(
+    postCompactionContext.recalledTurns.some((t: any) => /Current runtime only detail/.test(t.content)),
+    true,
+  );
+
+  const contextText = coordinator.formatContextPacket(postCompactionContext);
+  assert.equal(typeof contextText, "string");
+
+  console.log(`Memory smoke test passed (db=${dbPath})`);
+} finally {
+  await store.close().catch(() => {});
+  try {
+    rmSync(dbPath, { force: true });
+  } catch {
+    /* ignore */
+  }
+}

package/tools/send-discord

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec bun "$(dirname "$0")/send-discord.ts" "$@"

package/tools/send-discord.ts

@@ -0,0 +1,82 @@
+#!/usr/bin/env bun
+
+/**
+ * Send a message to Discord via local relay.
+ *
+ * Usage:
+ *   send-discord "hello world"
+ *   send-discord --channel 1234567890 "hello"
+ *   send-discord --reply 1234567890 "reply text"
+ */
+
+const args = process.argv.slice(2);
+let channelId: string | null = null;
+let replyTo: string | null = null;
+const textParts: string[] = [];
+
+for (let i = 0; i < args.length; i++) {
+  const arg = args[i];
+  if (arg === "--channel" && args[i + 1]) {
+    channelId = args[++i];
+    continue;
+  }
+  if (arg === "--reply" && args[i + 1]) {
+    replyTo = args[++i];
+    continue;
+  }
+  textParts.push(arg);
+}
+
+const content = textParts.join(" ").trim();
+if (!content) {
+  console.error(`
+Usage: send-discord [--channel <id>] [--reply <messageId>] "message"
+
+Examples:
+  send-discord "Build started"
+  send-discord --channel 123456789012345678 "Hello from Claude"
+  send-discord --reply 123456789012345678 "Thanks, on it"
+`);
+  process.exit(1);
+}
+
+const relayHost = process.env.RELAY_HOST || "127.0.0.1";
+const relayPort = process.env.RELAY_PORT || "3199";
+const relayUrl = process.env.RELAY_URL || `http://${relayHost}:${relayPort}`;
+const apiToken = process.env.RELAY_API_TOKEN || "";
+const fromAgent = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "claude";
+
+const headers: Record<string, string> = {
+  "Content-Type": "application/json",
+};
+if (apiToken) {
+  headers["x-api-token"] = apiToken;
+}
+
+try {
+  const response = await fetch(`${relayUrl}/api/send`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      content,
+      channelId,
+      replyTo,
+      fromAgent,
+    }),
+  });
+
+  const body: any = await response.json().catch(() => ({}));
+
+  if (!response.ok || !body.success) {
+    console.error(`Failed to send Discord message: ${body.error || response.statusText}`);
+    process.exit(1);
+  }
+
+  console.log(`Discord message sent (channel=${body.channelId}, messageId=${body.messageId})`);
+  process.exit(0);
+} catch (err: unknown) {
+  console.error(`Failed to call relay at ${relayUrl}: ${(err as Error).message}`);
+  process.exit(1);
+}
+
+export {};

package/tools/wait-for-discord-messages

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec bun "$(dirname "$0")/wait-for-discord-messages.ts" "$@"

package/tools/wait-for-discord-messages.ts

@@ -0,0 +1,369 @@
+#!/usr/bin/env bun
+
+/**
+ * Wait for unread Discord messages for this agent/session.
+ *
+ * Notes:
+ * - Uses a PID lock so only one active poller exists per agent+session.
+ * - Default timeout exits 0 quietly (to avoid noisy background failures in Claude UI).
+ * - Use --strict-timeout to return exit code 1 on timeout.
+ *
+ * Usage:
+ *   wait-for-discord-messages --agent claude --session default --timeout 600 [--deliver] [--strict-timeout]
+ */
+
+// Suppress Node.js ExperimentalWarning (SQLite) to keep output clean
+const _origEmit = process.emit;
+process.emit = function (event: string, ...args: any[]) {
+  if (event === "warning" && args[0]?.name === "ExperimentalWarning") return false;
+  return _origEmit.call(this, event, ...args) as any;
+};
+
+import { Database as DatabaseSync } from "bun:sqlite";
+import { mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { MemoryCoordinator } from "../memory/core/MemoryCoordinator.ts";
+import { buildMemorySessionKey } from "../memory/core/session-key.ts";
+import { SqliteMemoryStore } from "../memory/providers/sqlite/SqliteMemoryStore.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = process.env.ORCHESTRATOR_DIR || join(__dirname, "..");
+
+const args = process.argv.slice(2);
+let agentId = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "claude";
+let sessionId = process.env.DISCORD_SESSION_ID || process.env.BROKER_SESSION_ID || process.env.SESSION_ID || "default";
+let timeoutSeconds = 300;
+let deliverMode = false;
+let strictTimeout = false;
+let quietTimeout = String(process.env.WAIT_QUIET_TIMEOUT || "true").toLowerCase() !== "false";
+let channelFilter = process.env.DISCORD_CHANNEL_FILTER || "";
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--agent" && args[i + 1]) {
+    agentId = args[++i];
+  } else if (args[i] === "--session" && args[i + 1]) {
+    sessionId = args[++i];
+  } else if (args[i] === "--timeout" && args[i + 1]) {
+    timeoutSeconds = Number(args[++i]);
+  } else if (args[i] === "--channel" && args[i + 1]) {
+    channelFilter = args[++i];
+  } else if (args[i] === "--deliver") {
+    deliverMode = true;
+  } else if (args[i] === "--strict-timeout") {
+    strictTimeout = true;
+  } else if (args[i] === "--no-quiet-timeout") {
+    quietTimeout = false;
+  }
+}
+
+const dbPath = join(ROOT_DIR, "data", "messages.db");
+// When agent ID is a numeric channel ID (subagent mode), only match that exact ID.
+// Otherwise use the legacy multi-target matching.
+const isChannelAgent = /^\d{15,22}$/.test(agentId);
+const targets = isChannelAgent ? [agentId] : [...new Set([agentId, agentId.replace(/-\d+$/, ""), "claude"])];
+const placeholders = targets.map(() => "?").join(",");
+
+const noopLogger = {
+  log() {},
+  warn() {},
+  error() {},
+};
+
+const TEMP_DIR = "/tmp/cc-discord";
+mkdirSync(TEMP_DIR, { recursive: true });
+
+const safeAgent = sanitizeForFilename(agentId);
+const safeSession = sanitizeForFilename(sessionId);
+const safeChannel = channelFilter ? `-ch${sanitizeForFilename(channelFilter)}` : "";
+const lockFile = join(TEMP_DIR, `poller-${safeAgent}-${safeSession}${safeChannel}.lock`);
+
+function sanitizeForFilename(input: string): string {
+  return String(input || "x").replace(/[^a-zA-Z0-9_.-]/g, "_");
+}
+
+function pidAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function currentLockOwnerPid(): number | null {
+  try {
+    const raw = readFileSync(lockFile, "utf8").trim();
+    const pid = Number(raw);
+    return Number.isInteger(pid) ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function acquireLock(): boolean {
+  try {
+    writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+    return true;
+  } catch (err: any) {
+    if (err.code !== "EEXIST") return false;
+
+    const existingPid = currentLockOwnerPid();
+    if (existingPid && existingPid !== process.pid && pidAlive(existingPid)) {
+      // Another poller for this agent/session is already active.
+      return false;
+    }
+
+    // Stale lock: reclaim.
+    try {
+      unlinkSync(lockFile);
+    } catch {
+      /* ignore */
+    }
+
+    try {
+      writeFileSync(lockFile, String(process.pid), { flag: "wx" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+function cleanupLock() {
+  try {
+    const ownerPid = currentLockOwnerPid();
+    if (ownerPid === process.pid) {
+      unlinkSync(lockFile);
+    }
+  } catch {
+    // ignore
+  }
+}
+
+if (!acquireLock()) {
+  // Another poller holds the lock. Output a message so Claude knows not to tight-loop retry.
+  const existingPid = currentLockOwnerPid();
+  console.log(
+    `POLLER_ACTIVE: Another poller (PID ${existingPid ?? "?"}) is already waiting for messages for agent ${agentId}. Messages will be delivered by the active poller. Do NOT call this tool again until the active poller returns with messages.`,
+  );
+  process.exit(0);
+}
+
+process.on("SIGTERM", () => {
+  cleanupLock();
+  process.exit(0);
+});
+
+process.on("SIGINT", () => {
+  cleanupLock();
+  process.exit(0);
+});
+
+process.on("exit", () => {
+  cleanupLock();
+});
+
+async function buildMemoryContext(queryText: string): Promise<string> {
+  const memoryDbPath = join(ROOT_DIR, "data", "memory.db");
+  const memorySessionKey = buildMemorySessionKey({ sessionId, agentId, channelId: channelFilter || undefined });
+  const runtimeHint = process.env.CLAUDE_RUNTIME_ID || null;
+
+  let store: SqliteMemoryStore | undefined;
+  try {
+    store = new SqliteMemoryStore({ dbPath: memoryDbPath, logger: noopLogger });
+    const coordinator = new MemoryCoordinator({ store, logger: noopLogger });
+    await coordinator.init();
+
+    const runtimeState = await coordinator.ensureRuntimeContext({
+      sessionKey: memorySessionKey,
+      runtimeContextId: runtimeHint,
+    });
+
+    const packet = await coordinator.assembleContext({
+      sessionKey: memorySessionKey,
+      queryText,
+      runtimeContextId: runtimeState?.runtimeContextId,
+      runtimeEpoch: runtimeState?.runtimeEpoch,
+      includeSnapshot: true,
+      avoidCurrentRuntime: true,
+      activeWindowSize: 12,
+      maxCards: 6,
+      maxRecallTurns: 8,
+      maxTurnScan: 300,
+    });
+
+    return coordinator.formatContextPacket(packet);
+  } catch {
+    return "";
+  } finally {
+    if (store) {
+      try {
+        await store.close();
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+}
+
+function checkCount(db: InstanceType<typeof DatabaseSync>): number {
+  const channelClause = channelFilter ? " AND channel_id = ?" : "";
+  const params: any[] = channelFilter ? [sessionId, ...targets, channelFilter] : [sessionId, ...targets];
+  const row = db
+    .prepare(`
+    SELECT COUNT(*) as count
+    FROM messages
+    WHERE session_id = ?
+      AND to_agent IN (${placeholders})
+      AND read = 0
+      ${channelClause}
+  `)
+    .get(...params) as any;
+  return row.count;
+}
+
+async function deliverMessages(db: InstanceType<typeof DatabaseSync>): Promise<boolean> {
+  db.exec("BEGIN IMMEDIATE");
+  const channelClause = channelFilter ? " AND channel_id = ?" : "";
+  const params: any[] = channelFilter ? [sessionId, ...targets, channelFilter] : [sessionId, ...targets];
+  const rows = db
+    .prepare(`
+    SELECT id, from_agent, message_type, content, channel_id
+    FROM messages
+    WHERE session_id = ?
+      AND to_agent IN (${placeholders})
+      AND read = 0
+      ${channelClause}
+    ORDER BY id ASC
+  `)
+    .all(...params) as any[];
+
+  if (rows.length === 0) {
+    db.exec("COMMIT");
+    return false;
+  }
+
+  const ids = rows.map((r: any) => r.id);
+  const idPlaceholders = ids.map(() => "?").join(",");
+  db.prepare(`UPDATE messages SET read = 1 WHERE id IN (${idPlaceholders})`).run(...ids);
+  db.exec("COMMIT");
+
+  const formatted = rows.map((r: any) => {
+    const oneLine = String(r.content).replace(/\r/g, "").replace(/\n/g, " ");
+    const channelTag = r.channel_id ? ` [channel:${r.channel_id}]` : "";
+    return `[MESSAGE from ${r.from_agent}]${channelTag} [${r.message_type}]: ${oneLine}`;
+  });
+
+  const latestQueryText = String(rows[rows.length - 1]?.content || "");
+  const memoryText = await buildMemoryContext(latestQueryText);
+  const inboxText = `NEW DISCORD MESSAGE(S): ${formatted.join(" | ")}`;
+  const outputText = memoryText ? `${inboxText}\n\n${memoryText}` : inboxText;
+
+  console.log(outputText);
+  return true;
+}
+
+/**
+ * Write a heartbeat to agent_activity so the orchestrator/relay can detect
+ * stuck agents. Called on every poll cycle — even when no messages arrive.
+ */
+function writeHeartbeat(db: InstanceType<typeof DatabaseSync>, status: string = "polling") {
+  try {
+    db.prepare(`
+      INSERT INTO agent_activity (session_id, agent_id, status, activity_type, activity_summary, started_at, updated_at)
+      VALUES (?, ?, ?, 'heartbeat', ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
+      ON CONFLICT(session_id, agent_id) DO UPDATE SET
+        status = excluded.status,
+        activity_type = 'heartbeat',
+        activity_summary = excluded.activity_summary,
+        updated_at = CURRENT_TIMESTAMP
+    `).run(sessionId, agentId, status, `poller pid=${process.pid}`);
+  } catch {
+    // Non-fatal; keep polling even if heartbeat write fails
+  }
+}
+
+async function main() {
+  let db: InstanceType<typeof DatabaseSync>;
+  try {
+    db = new DatabaseSync(dbPath);
+  } catch (err: unknown) {
+    console.error(`Cannot open database at ${dbPath}: ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  process.on("exit", () => {
+    try {
+      db.close();
+    } catch {
+      /* ignore */
+    }
+  });
+
+  try {
+    // Initial heartbeat
+    writeHeartbeat(db, "starting");
+
+    if (checkCount(db) > 0) {
+      writeHeartbeat(db, "delivering");
+      if (deliverMode) {
+        await deliverMessages(db);
+      } else {
+        console.log(`Messages pending for ${agentId}`);
+      }
+      process.exit(0);
+    }
+
+    const pollIntervalMs = 2000;
+    const timeoutMs = timeoutSeconds * 1000;
+    const start = Date.now();
+
+    let polling = false;
+
+    const tick = async () => {
+      if (polling) return;
+      polling = true;
+      try {
+        writeHeartbeat(db, "polling");
+
+        if (checkCount(db) > 0) {
+          writeHeartbeat(db, "delivering");
+          if (deliverMode) {
+            await deliverMessages(db);
+          } else {
+            console.log(`Messages pending for ${agentId}`);
+          }
+          process.exit(0);
+        }
+
+        if (Date.now() - start > timeoutMs) {
+          if (!quietTimeout) {
+            console.log(`No messages after ${timeoutSeconds}s timeout`);
+          }
+          process.exit(strictTimeout ? 1 : 0);
+        }
+      } catch {
+        // transient DB errors; keep polling
+      } finally {
+        polling = false;
+      }
+    };
+
+    const timer = setInterval(() => {
+      void tick();
+    }, pollIntervalMs);
+
+    // Also run once right away (in case race inserted message before first interval)
+    void tick();
+
+    process.on("exit", () => {
+      clearInterval(timer);
+    });
+  } catch {
+    process.exit(1);
+  }
+}
+
+await main();