@hoverlover/cc-discord 0.1.0

package/hooks/check-discord-messages.ts

@@ -0,0 +1,204 @@
+#!/usr/bin/env bun
+/**
+ * Claude Code hook: deliver unread Discord messages into Claude context.
+ *
+ * Hook input:  snake_case fields (hook_event_name, tool_name, ...)
+ * Hook output: camelCase fields (hookEventName, additionalContext)
+ */
+
+// Suppress Node.js ExperimentalWarning (SQLite) to keep hook 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 { 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 agentId = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "claude";
+const sessionId =
+  process.env.DISCORD_SESSION_ID || process.env.BROKER_SESSION_ID || process.env.SESSION_ID || "default";
+
+const dbPath = join(ROOT_DIR, "data", "messages.db");
+
+const noopLogger = {
+  log() {},
+  warn() {},
+  error() {},
+};
+
+async function syncRuntimeContext({ hookEvent, hookInput }: { hookEvent: string; hookInput: any }) {
+  const memoryDbPath = join(ROOT_DIR, "data", "memory.db");
+  const memorySessionKey = buildMemorySessionKey({ sessionId, agentId });
+  const runtimeHint = process.env.CLAUDE_RUNTIME_ID || hookInput?.session_id || hookInput?.sessionId || null;
+
+  let store: SqliteMemoryStore | undefined;
+  try {
+    store = new SqliteMemoryStore({ dbPath: memoryDbPath, logger: noopLogger });
+    const coordinator = new MemoryCoordinator({ store, logger: noopLogger });
+    await coordinator.init();
+
+    if (hookEvent === "SessionStart") {
+      return await coordinator.beginNewRuntimeContext({
+        sessionKey: memorySessionKey,
+        runtimeContextId: runtimeHint ? `${runtimeHint}_start_${Date.now().toString(36)}` : null,
+      });
+    }
+
+    return await coordinator.ensureRuntimeContext({
+      sessionKey: memorySessionKey,
+      runtimeContextId: runtimeHint,
+    });
+  } catch {
+    return null;
+  } finally {
+    if (store) {
+      try {
+        await store.close();
+      } catch {
+        /* ignore */
+      }
+    }
+  }
+}
+
+async function buildMemoryContext({ queryText, runtimeState }: { queryText: string; runtimeState: any }) {
+  const memoryDbPath = join(ROOT_DIR, "data", "memory.db");
+  const memorySessionKey = buildMemorySessionKey({ sessionId, agentId });
+
+  let store: SqliteMemoryStore | undefined;
+  try {
+    store = new SqliteMemoryStore({ dbPath: memoryDbPath, logger: noopLogger });
+    const coordinator = new MemoryCoordinator({ store, logger: noopLogger });
+    await coordinator.init();
+
+    const packet = await coordinator.assembleContext({
+      sessionKey: memorySessionKey,
+      queryText,
+      runtimeContextId: runtimeState?.runtimeContextId || null,
+      runtimeEpoch: runtimeState?.runtimeEpoch || null,
+      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 */
+      }
+    }
+  }
+}
+
+let hookInput: any;
+try {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+  const raw = Buffer.concat(chunks).toString();
+  hookInput = raw ? JSON.parse(raw) : { hook_event_name: "PostToolUse" };
+} catch {
+  process.exit(0);
+}
+
+const hookEvent = hookInput.hook_event_name || "PostToolUse";
+const runtimeState = await syncRuntimeContext({ hookEvent, hookInput });
+
+// Match direct agent IDs, generic "claude", and optionally base role
+const baseRole = agentId.replace(/-\d+$/, "");
+const targets = [...new Set([agentId, baseRole, "claude"])];
+
+let db: InstanceType<typeof DatabaseSync>;
+try {
+  db = new DatabaseSync(dbPath);
+} catch {
+  process.exit(0);
+}
+
+try {
+  db.exec("BEGIN IMMEDIATE");
+
+  const placeholders = targets.map(() => "?").join(",");
+  const rows = db
+    .prepare(`
+    SELECT id, from_agent, message_type, content
+    FROM messages
+    WHERE session_id = ?
+      AND to_agent IN (${placeholders})
+      AND read = 0
+    ORDER BY id ASC
+  `)
+    .all(sessionId, ...targets) as any[];
+
+  if (rows.length > 0) {
+    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, " ");
+      return `[MESSAGE from ${r.from_agent}] [${r.message_type}]: ${oneLine}`;
+    });
+    const inboxText = `NEW DISCORD MESSAGE(S): ${formatted.join(" | ")}`;
+
+    const latestQueryText = String(rows[rows.length - 1]?.content || "");
+    const memoryText = await buildMemoryContext({
+      queryText: latestQueryText,
+      runtimeState,
+    });
+    const contextText = memoryText ? `${inboxText}\n\n${memoryText}` : inboxText;
+
+    if (hookEvent === "Stop") {
+      process.stdout.write(
+        JSON.stringify({
+          decision: "block",
+          reason: `New Discord messages received. Process these before stopping.\n\n${contextText}`,
+        }),
+      );
+      process.exit(0);
+    }
+
+    process.stdout.write(
+      JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: hookEvent,
+          additionalContext: contextText,
+        },
+      }),
+    );
+    process.exit(0);
+  }
+
+  db.exec("COMMIT");
+  process.exit(0);
+} catch {
+  try {
+    db.exec("ROLLBACK");
+  } catch {
+    /* ignore */
+  }
+  process.exit(0);
+} finally {
+  try {
+    db.close();
+  } catch {
+    /* ignore */
+  }
+}

package/hooks/cleanup-attachment.ts

@@ -0,0 +1,47 @@
+#!/usr/bin/env bun
+/**
+ * Claude Code hook: clean up downloaded Discord attachment files after they are read.
+ *
+ * Runs on PostToolUse for the Read tool. If the file path is inside
+ * /tmp/cc-discord/attachments/, delete it to keep the filesystem clean.
+ */
+
+import { existsSync, unlinkSync } from "node:fs";
+
+const ATTACHMENT_DIR = "/tmp/cc-discord/attachments/";
+
+let hookInput: any;
+try {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+  const raw = Buffer.concat(chunks).toString();
+  hookInput = raw ? JSON.parse(raw) : {};
+} catch {
+  process.exit(0);
+}
+
+const toolName = hookInput.tool_name || hookInput.toolName || "";
+const toolInput = hookInput.tool_input || hookInput.toolInput || {};
+
+// Only act on Read tool calls
+if (toolName !== "Read") {
+  process.exit(0);
+}
+
+const filePath = toolInput.file_path || toolInput.path || "";
+
+// Only clean up files in our attachment directory
+if (!filePath.startsWith(ATTACHMENT_DIR)) {
+  process.exit(0);
+}
+
+try {
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    // No console output to keep hook silent
+  }
+} catch {
+  // fail-open: if we can't delete, the TTL cleanup in the relay will handle it
+}
+
+process.exit(0);

package/hooks/safe-bash.ts

@@ -0,0 +1,157 @@
+#!/usr/bin/env bun
+/**
+ * PreToolUse Bash guard.
+ *
+ * Policies:
+ * - Detects risky background execution patterns:
+ *   1) Bash tool_input.run_in_background=true
+ *   2) standalone '&' operator in command text
+ *
+ * Behavior is controlled by env vars:
+ * - BASH_POLICY_MODE=block|allow   (default: block)
+ * - ALLOW_BASH_RUN_IN_BACKGROUND=true|false (default: true)
+ * - ALLOW_BASH_BACKGROUND_OPS=true|false (default: false)
+ * - BASH_POLICY_NOTIFY_ON_BLOCK=true|false (default: true)
+ * - BASH_POLICY_NOTIFY_CHANNEL_ID=<discord-channel-id> (optional)
+ *
+ * When blocked, script exits 2 (Claude Code hook "block" behavior).
+ */
+
+function readJsonStdin(): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    process.stdin.on("data", (chunk: Buffer) => chunks.push(chunk));
+    process.stdin.on("end", () => {
+      try {
+        const raw = Buffer.concat(chunks).toString();
+        resolve(raw ? JSON.parse(raw) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    process.stdin.on("error", reject);
+  });
+}
+
+function asBool(value: unknown, defaultValue: boolean = false): boolean {
+  if (value === undefined || value === null || value === "") return defaultValue;
+  const normalized = String(value).toLowerCase().trim();
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return defaultValue;
+}
+
+function normalizeMode(value: unknown): "allow" | "block" {
+  const v = String(value || "block")
+    .toLowerCase()
+    .trim();
+  return v === "allow" ? "allow" : "block";
+}
+
+function hasStandaloneBackgroundOperator(command: string): boolean {
+  // Remove escaped ampersands and logical-and to reduce false positives.
+  const reduced = String(command || "")
+    .replace(/\\&/g, "")
+    .replace(/&&/g, "");
+
+  // Match standalone job-control '&' (e.g. "cmd &" or "; &").
+  return /(^|[\s;|])&($|[\s\n])/m.test(reduced);
+}
+
+function truncateCommand(command: string, max: number = 220): string {
+  const clean = String(command || "")
+    .replace(/[`\r\n\t]+/g, " ")
+    .trim();
+  if (clean.length <= max) return clean;
+  return `${clean.slice(0, max - 1)}…`;
+}
+
+async function notifyDiscord({ blocked, reasons, command }: { blocked: boolean; reasons: string[]; command: string }) {
+  const notifyEnabled = asBool(process.env.BASH_POLICY_NOTIFY_ON_BLOCK, true);
+  if (!notifyEnabled) return;
+
+  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 channelId = process.env.BASH_POLICY_NOTIFY_CHANNEL_ID || null;
+  const fromAgent = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "bash-guard";
+
+  const status = blocked ? "blocked" : "warning";
+  const reasonText = reasons.join("; ");
+  const commandText = truncateCommand(command);
+
+  const content = [
+    `⚠️ Bash safety policy ${status} a command.`,
+    `Agent: ${fromAgent}`,
+    `Reason: ${reasonText}`,
+    `Command: ${commandText}`,
+  ].join("\n");
+
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (apiToken) headers["x-api-token"] = apiToken;
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 1500);
+
+  try {
+    await fetch(`${relayUrl}/api/send`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        content,
+        channelId,
+        fromAgent: "bash-guard",
+      }),
+      signal: controller.signal,
+    });
+  } catch {
+    // Best-effort notification only.
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+try {
+  const input: any = await readJsonStdin();
+  const toolName = input.tool_name || input.toolName;
+  if (toolName !== "Bash") {
+    process.exit(0);
+  }
+
+  const toolInput = input.tool_input || input.toolInput || {};
+  const command = String(toolInput.command || "");
+
+  const mode = normalizeMode(process.env.BASH_POLICY_MODE);
+  const allowRunInBackground = asBool(process.env.ALLOW_BASH_RUN_IN_BACKGROUND, true);
+  const allowAmpersand = asBool(process.env.ALLOW_BASH_BACKGROUND_OPS, false);
+
+  const reasons: string[] = [];
+
+  if ((toolInput.run_in_background === true || toolInput.runInBackground === true) && !allowRunInBackground) {
+    reasons.push("run_in_background=true is disabled");
+  }
+
+  if (hasStandaloneBackgroundOperator(command) && !allowAmpersand) {
+    reasons.push("standalone & background operator is disabled");
+  }
+
+  if (reasons.length === 0) {
+    process.exit(0);
+  }
+
+  const blocked = mode !== "allow";
+  await notifyDiscord({ blocked, reasons, command });
+
+  if (blocked) {
+    console.error(`Bash safety policy blocked command: ${reasons.join("; ")}`);
+    process.exit(2);
+  }
+
+  process.exit(0);
+} catch {
+  // Fail-open to avoid blocking all Bash calls on hook parse issues.
+  process.exit(0);
+}
+
+export {};

package/hooks/steer-send.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env bun
+/**
+ * PreToolUse hook: block send-discord when unread messages exist.
+ *
+ * When a Discord user sends a follow-up while the agent is composing a reply,
+ * this hook intercepts the send-discord Bash call, delivers the new messages
+ * as the block reason, and forces the agent to revise its reply.
+ *
+ * Hook input:  snake_case fields (hook_event_name, tool_name, tool_input)
+ * Hook output: { "decision": "block", "reason": "..." } or silent exit 0
+ */
+
+import { Database as DatabaseSync } from "bun:sqlite";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const ROOT_DIR = process.env.ORCHESTRATOR_DIR || join(__dirname, "..");
+
+const agentId = process.env.AGENT_ID || process.env.CLAUDE_AGENT_ID || "claude";
+const sessionId =
+  process.env.DISCORD_SESSION_ID || process.env.BROKER_SESSION_ID || process.env.SESSION_ID || "default";
+
+const dbPath = join(ROOT_DIR, "data", "messages.db");
+
+let hookInput: any;
+try {
+  const chunks: Buffer[] = [];
+  for await (const chunk of process.stdin) chunks.push(chunk as Buffer);
+  const raw = Buffer.concat(chunks).toString();
+  hookInput = raw ? JSON.parse(raw) : {};
+} catch {
+  process.exit(0); // fail-open
+}
+
+// Only intercept Bash calls that run send-discord
+const toolName = hookInput.tool_name || hookInput.toolName;
+if (toolName !== "Bash") process.exit(0);
+
+const toolInput = hookInput.tool_input || hookInput.toolInput || {};
+const command = String(toolInput.command || "");
+if (!command.includes("send-discord")) process.exit(0);
+
+// Check for unread messages
+const baseRole = agentId.replace(/-\d+$/, "");
+const targets = [...new Set([agentId, baseRole, "claude"])];
+
+let db: InstanceType<typeof DatabaseSync>;
+try {
+  db = new DatabaseSync(dbPath);
+} catch {
+  process.exit(0); // fail-open: can't reach DB, allow send
+}
+
+try {
+  db.exec("BEGIN IMMEDIATE");
+
+  const placeholders = targets.map(() => "?").join(",");
+  const rows = db
+    .prepare(
+      `SELECT id, from_agent, message_type, content
+       FROM messages
+       WHERE session_id = ?
+         AND to_agent IN (${placeholders})
+         AND read = 0
+       ORDER BY id ASC`,
+    )
+    .all(sessionId, ...targets) as any[];
+
+  if (rows.length === 0) {
+    db.exec("COMMIT");
+    process.exit(0); // no new messages, allow send
+  }
+
+  // Mark consumed so check-discord-messages won't double-deliver
+  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, " ");
+    return `[MESSAGE from ${r.from_agent}] [${r.message_type}]: ${oneLine}`;
+  });
+
+  const reason = [
+    "SEND BLOCKED: New messages arrived while you were composing a reply.",
+    "Read them carefully, revise your reply to address ALL messages, then re-send.",
+    "",
+    ...formatted,
+  ].join("\n");
+
+  process.stdout.write(JSON.stringify({ decision: "block", reason }));
+  process.exit(0);
+} catch {
+  try {
+    db.exec("ROLLBACK");
+  } catch {
+    /* ignore */
+  }
+  process.exit(0); // fail-open
+} finally {
+  try {
+    db.close();
+  } catch {
+    /* ignore */
+  }
+}