@hoverlover/cc-discord 0.1.0

package/memory/providers/sqlite/index.ts

@@ -0,0 +1 @@
+export { SqliteMemoryStore } from "./SqliteMemoryStore.ts";

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@hoverlover/cc-discord",
+  "version": "0.1.0",
+  "description": "Discord <-> Claude Code relay: use your Claude subscription to power per-channel AI bots",
+  "type": "module",
+  "bin": {
+    "cc-discord": "./scripts/start.sh"
+  },
+  "files": [
+    "scripts/",
+    "server/",
+    "hooks/",
+    "tools/",
+    "prompts/",
+    "memory/",
+    ".claude/settings.template.json",
+    ".env.example",
+    ".env.relay.example",
+    ".env.worker.example"
+  ],
+  "scripts": {
+    "start": "bash scripts/start.sh",
+    "start:relay": "bash scripts/start-relay.sh",
+    "start:orchestrator": "bash scripts/orchestrator.sh",
+    "start:orchestrator-interactive": "bash scripts/start-orchestrator.sh",
+    "dev": "bash scripts/start-relay.sh",
+    "generate-settings": "bash scripts/generate-settings.sh",
+    "memory:smoke": "bun tools/memory-smoke.ts",
+    "memory:inspect": "bun tools/memory-inspect.ts",
+    "memory:migrate": "bun scripts/migrate-memory-to-channel-keys.ts",
+    "lint": "bunx biome check .",
+    "lint:fix": "bunx biome check --write .",
+    "format": "bunx biome format --write .",
+    "typecheck": "bunx tsc --noEmit"
+  },
+  "dependencies": {
+    "discord.js": "^14.23.2",
+    "express": "^4.21.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.4.4",
+    "@types/bun": "^1.3.9",
+    "@types/express": "^5.0.6"
+  }
+}

package/prompts/autoreply-system.md

@@ -0,0 +1,32 @@
+You are running in autonomous Discord reply mode for a local relay.
+
+## Goal
+Automatically read incoming Discord messages and send a useful reply back to Discord without asking for terminal input.
+
+## Infinite loop behavior
+Repeat forever:
+
+1. Run:
+   wait-for-discord-messages --deliver --timeout 600
+
+2. If output contains:
+   NEW DISCORD MESSAGE(S): ...
+   then read the message content and decide on a reply.
+
+   If output is empty (no messages / timeout), immediately continue the loop.
+
+3. Send exactly one reply message with:
+   send-discord "<your reply>"
+
+4. Immediately go back to step 1.
+
+## Rules
+- Do not ask the terminal user for confirmation.
+- Do not narrate internal status (no "waiting...", "checking...", etc.).
+- Keep replies concise and useful.
+- Keep each reply under 1800 characters.
+- If multiple inbound messages are delivered together, prioritize the newest question/request.
+- If polling times out with no messages, continue the loop.
+- If the wait command is interrupted by the terminal user (e.g., Esc), treat it as a manual override: handle the user’s requested command/task, then return to step 1.
+- Never use shell background operators (`&`) in commands. Use `run_in_background: true` Bash parameter instead when needed.
+- Never stop unless explicitly told by the terminal user.

package/prompts/channel-system.md

@@ -0,0 +1,22 @@
+You are a Discord bot responsible for the #__CHANNEL_NAME__ channel.
+
+## Loop
+Repeat forever:
+1. Run: `AGENT_ID=__CHANNEL_ID__ wait-for-discord-messages --deliver --timeout 600`
+2. If output contains NEW DISCORD MESSAGE(S), read the content and craft a reply.
+3. Send reply: `send-discord --channel __CHANNEL_ID__ "your reply"`
+4. Go back to step 1.
+
+IMPORTANT: Always set AGENT_ID=__CHANNEL_ID__ as an env var prefix on every wait-for-discord-messages call. This is how messages are routed to you.
+
+## Steering
+- If your send-discord call is blocked with new messages, read them carefully, revise your reply to address them, and send the updated reply.
+- Do not resend the same text that was blocked.
+
+## Rules
+- Keep replies under 1800 characters.
+- If polling times out with no messages, continue the loop.
+- Never stop unless explicitly told.
+- Do not ask the terminal user for confirmation.
+- Do not narrate internal status.
+- Never use shell background operators (&). Use `run_in_background: true` Bash parameter instead when needed.

package/prompts/orchestrator-system.md

@@ -0,0 +1,56 @@
+You are the orchestrator for a multi-channel Discord bot. Your job is to spawn one subagent per channel and keep them healthy.
+
+## Startup
+
+1. Discover channels by running:
+   ```
+   curl -s -H "x-api-token: $RELAY_API_TOKEN" http://${RELAY_HOST:-127.0.0.1}:${RELAY_PORT:-3199}/api/channels
+   ```
+   This returns JSON with `{ success: true, channels: [{ id, name, model, ... }] }`.
+
+2. For each channel, spawn a subagent using the Agent tool. Give each subagent a prompt like:
+
+   > You are a Discord bot responsible for the #CHANNEL_NAME channel.
+   >
+   > ## Loop
+   > Repeat forever:
+   > 1. Run: `AGENT_ID=CHANNEL_ID wait-for-discord-messages --deliver --timeout 600`
+   > 2. If output contains NEW DISCORD MESSAGE(S), read the content and craft a reply.
+   > 3. Send reply: `send-discord --channel CHANNEL_ID "your reply"`
+   > 4. Go back to step 1.
+   >
+   > IMPORTANT: Always set AGENT_ID=CHANNEL_ID as an env var prefix on every wait-for-discord-messages call. This is how messages are routed to you.
+   >
+   > ## Rules
+   > - Keep replies under 1800 characters.
+   > - If polling times out with no messages, continue the loop.
+   > - Never stop unless explicitly told.
+   > - Do not ask the terminal user for confirmation.
+   > - Do not narrate internal status.
+   > - Never use shell background operators (&). Use `run_in_background: true` Bash parameter instead when needed.
+
+   Replace CHANNEL_NAME with the channel's name and CHANNEL_ID with the channel's id in the prompt above.
+
+## Health check loop
+
+After all subagents are spawned, repeat forever:
+
+1. Wait for up to 300 seconds using:
+   ```
+   wait-for-discord-messages --timeout 300
+   ```
+   This returns after 300s or when any message arrives (whichever comes first).
+
+2. After waking, perform these checks:
+   - **Subagent health:** If a subagent has stopped or errored, restart it by spawning a new Agent for that channel.
+   - **New channels:** Re-fetch `/api/channels` and compare to your known channel list. If a new channel has appeared, spawn a subagent for it.
+
+3. Go back to step 1.
+
+## Rules
+- Do not ask the terminal user for confirmation.
+- Do not narrate internal status (no "waiting...", "checking...", etc.).
+- Never use shell background operators (`&`) in commands. Use `run_in_background: true` Bash parameter instead when needed.
+- Never stop unless explicitly told by the terminal user.
+- If a subagent dies, restart it promptly on the next health check cycle.
+- You do NOT consume Discord messages yourself. Only subagents do.

package/scripts/channel-agent.sh

@@ -0,0 +1,159 @@
+#!/bin/bash
+# channel-agent.sh — Run a single Claude channel agent in headless (-p) mode.
+#
+# Usage: channel-agent.sh <channel_id> <channel_name>
+#
+# Designed to be spawned by orchestrator.sh. Each invocation runs one
+# claude -p session that polls for messages and replies. When claude
+# exits (e.g., max turns, cost limit, or normal stop), the orchestrator
+# restarts this script to create a persistent loop.
+
+set -euo pipefail
+
+CHANNEL_ID="${1:?Usage: channel-agent.sh <channel_id> <channel_name>}"
+CHANNEL_NAME="${2:-channel-$CHANNEL_ID}"
+
+ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+source "$ROOT_DIR/scripts/load-env.sh"
+
+# Load worker env vars (same set as start-orchestrator.sh)
+WORKER_KEYS=(
+  DISCORD_SESSION_ID
+  CLAUDE_AGENT_ID
+  RELAY_HOST
+  RELAY_PORT
+  RELAY_URL
+  RELAY_API_TOKEN
+  AUTO_REPLY_PERMISSION_MODE
+  CLAUDE_RUNTIME_ID
+  WAIT_QUIET_TIMEOUT
+  BASH_POLICY_MODE
+  ALLOW_BASH_RUN_IN_BACKGROUND
+  ALLOW_BASH_BACKGROUND_OPS
+  BASH_POLICY_NOTIFY_ON_BLOCK
+  BASH_POLICY_NOTIFY_CHANNEL_ID
+)
+load_env_keys "$ROOT_DIR/.env.worker" "${WORKER_KEYS[@]}"
+load_env_keys "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env.worker" "${WORKER_KEYS[@]}"
+load_env_keys "$ROOT_DIR/.env" "${WORKER_KEYS[@]}"
+load_env_keys "${CC_DISCORD_CONFIG_DIR:-$HOME/.config/cc-discord}/.env" "${WORKER_KEYS[@]}"
+
+# Ensure bun is on PATH for hooks/tools
+export PATH="$HOME/.bun/bin:/opt/homebrew/bin:/usr/local/bin:$ROOT_DIR/tools:$PATH"
+
+SETTINGS_PATH="$ROOT_DIR/.claude/settings.json"
+PROMPT_TEMPLATE="$ROOT_DIR/prompts/channel-system.md"
+
+if ! command -v claude >/dev/null 2>&1; then
+  echo "[channel-agent:$CHANNEL_NAME] Error: 'claude' CLI not found on PATH" >&2
+  exit 1
+fi
+
+if [ ! -f "$SETTINGS_PATH" ]; then
+  echo "[channel-agent:$CHANNEL_NAME] Generating settings..."
+  bash "$ROOT_DIR/scripts/generate-settings.sh"
+fi
+
+if [ ! -f "$PROMPT_TEMPLATE" ]; then
+  echo "[channel-agent:$CHANNEL_NAME] Missing prompt template: $PROMPT_TEMPLATE" >&2
+  exit 1
+fi
+
+# Defensive cleanup: never leak relay-only secrets to Claude
+unset DISCORD_BOT_TOKEN DISCORD_CHANNEL_ID DISCORD_ALLOWED_CHANNEL_IDS
+
+# Kill orphaned poller processes from previous runs of this channel agent.
+# These linger when Claude exits but its child wait-for-discord-messages keeps polling.
+POLLER_LOCK="/tmp/cc-discord/poller-${CHANNEL_ID}-${DISCORD_SESSION_ID:-default}.lock"
+if [ -f "$POLLER_LOCK" ]; then
+  OLD_PID=$(cat "$POLLER_LOCK" 2>/dev/null)
+  if [ -n "$OLD_PID" ] && kill -0 "$OLD_PID" 2>/dev/null; then
+    echo "[channel-agent:$CHANNEL_NAME] Killing orphaned poller (PID $OLD_PID)"
+    kill -TERM "$OLD_PID" 2>/dev/null || true
+    sleep 1
+    kill -9 "$OLD_PID" 2>/dev/null || true
+  fi
+  rm -f "$POLLER_LOCK"
+fi
+
+export ORCHESTRATOR_DIR="$ROOT_DIR"
+export DISCORD_SESSION_ID="${DISCORD_SESSION_ID:-default}"
+export AGENT_ID="$CHANNEL_ID"
+export CLAUDE_AGENT_ID="${CLAUDE_AGENT_ID:-claude-discord}"
+export CLAUDE_RUNTIME_ID="${CLAUDE_RUNTIME_ID:-rt_$(date +%s)_${RANDOM}}"
+
+# Build the channel-specific system prompt
+SYSTEM_PROMPT="$(sed \
+  -e "s|__CHANNEL_ID__|${CHANNEL_ID}|g" \
+  -e "s|__CHANNEL_NAME__|${CHANNEL_NAME}|g" \
+  "$PROMPT_TEMPLATE")"
+
+# Permission mode
+if [ "${AUTO_REPLY_PERMISSION_MODE:-skip}" = "accept-edits" ]; then
+  PERMISSION_ARGS=(--permission-mode acceptEdits)
+else
+  PERMISSION_ARGS=(--dangerously-skip-permissions)
+fi
+
+# Log directory
+LOG_DIR="${CC_DISCORD_LOG_DIR:-/tmp/cc-discord/logs}"
+mkdir -p "$LOG_DIR"
+LOG_FILE="${LOG_DIR}/channel-${CHANNEL_NAME}-${CHANNEL_ID}.log"
+
+PARSER="$ROOT_DIR/scripts/parse-claude-stream.ts"
+
+echo "[channel-agent:$CHANNEL_NAME] Starting claude -p (channel=$CHANNEL_ID, session=$DISCORD_SESSION_ID, runtime=$CLAUDE_RUNTIME_ID)"
+echo "[channel-agent:$CHANNEL_NAME] Logging to $LOG_FILE"
+
+# Write the system prompt to a temp file to avoid quoting issues in pipes.
+PROMPT_FILE=$(mktemp /tmp/cc-discord-prompt-XXXXXX)
+printf '%s' "$SYSTEM_PROMPT" > "$PROMPT_FILE"
+
+# On exit: clean up temp file, kill orphaned pollers, and kill child processes.
+cleanup_agent() {
+  rm -f "$PROMPT_FILE"
+  # Kill any poller left behind by this session
+  if [ -f "$POLLER_LOCK" ]; then
+    local lpid
+    lpid=$(cat "$POLLER_LOCK" 2>/dev/null)
+    if [ -n "$lpid" ] && kill -0 "$lpid" 2>/dev/null; then
+      kill -TERM "$lpid" 2>/dev/null || true
+    fi
+    rm -f "$POLLER_LOCK"
+  fi
+  # Kill any remaining children (claude, parser, pollers)
+  local pids
+  pids=$(jobs -p 2>/dev/null) || true
+  if [ -n "$pids" ]; then
+    kill $pids 2>/dev/null || true
+  fi
+}
+trap cleanup_agent EXIT
+
+# Run claude in headless/print mode with stream-json output.
+# The stream is piped through the parser which extracts reasoning, tool
+# calls, and errors into human-readable log lines.
+# If the parser is missing, fall back to raw output.
+if [ -f "$PARSER" ]; then
+  claude \
+    -p \
+    --output-format stream-json \
+    --verbose \
+    --settings "$SETTINGS_PATH" \
+    "${PERMISSION_ARGS[@]}" \
+    --system-prompt-file "$PROMPT_FILE" \
+    --no-session-persistence \
+    -- "Begin listening for messages in #${CHANNEL_NAME} now." 2>&1 \
+  | bun "$PARSER" >> "$LOG_FILE" 2>&1
+else
+  echo "[channel-agent:$CHANNEL_NAME] WARNING: Parser not found at $PARSER — using raw output"
+  claude \
+    -p \
+    --output-format stream-json \
+    --settings "$SETTINGS_PATH" \
+    "${PERMISSION_ARGS[@]}" \
+    --system-prompt-file "$PROMPT_FILE" \
+    --no-session-persistence \
+    -- "Begin listening for messages in #${CHANNEL_NAME} now." \
+    >> "$LOG_FILE" 2>&1
+fi

package/scripts/generate-settings.sh

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ORCHESTRATOR_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+
+TEMPLATE="$ORCHESTRATOR_DIR/.claude/settings.template.json"
+OUTPUT="$ORCHESTRATOR_DIR/.claude/settings.json"
+
+if [ ! -f "$TEMPLATE" ]; then
+  echo "Template not found: $TEMPLATE"
+  exit 1
+fi
+
+sed -e "s|__ORCHESTRATOR_DIR__|$ORCHESTRATOR_DIR|g" "$TEMPLATE" > "$OUTPUT"
+
+echo "Generated: $OUTPUT"

package/scripts/load-env.sh

@@ -0,0 +1,79 @@
+#!/bin/bash
+# Load KEY=VALUE pairs from .env into the current shell without overriding
+# variables that are already set.
+
+_parse_env_line() {
+  local line="$1"
+  # Normalize CRLF endings
+  line="${line%$'\r'}"
+
+  # Skip blanks/comments
+  [[ -z "$line" ]] && return 1
+  [[ "$line" =~ ^[[:space:]]*# ]] && return 1
+  [[ "$line" == *=* ]] || return 1
+
+  local key="${line%%=*}"
+  local value="${line#*=}"
+
+  # Trim surrounding whitespace from key/value
+  key="${key#"${key%%[![:space:]]*}"}"
+  key="${key%"${key##*[![:space:]]}"}"
+  value="${value#"${value%%[![:space:]]*}"}"
+  value="${value%"${value##*[![:space:]]}"}"
+
+  # Valid shell variable names only
+  [[ "$key" =~ ^[A-Za-z_][A-Za-z0-9_]*$ ]] || return 1
+
+  # Remove matching surrounding quotes
+  if [[ "$value" =~ ^\".*\"$ ]]; then
+    value="${value:1:${#value}-2}"
+  elif [[ "$value" =~ ^\'.*\'$ ]]; then
+    value="${value:1:${#value}-2}"
+  fi
+
+  ENV_KEY="$key"
+  ENV_VALUE="$value"
+  return 0
+}
+
+load_env_file() {
+  local env_file="${1:-.env}"
+  if [ ! -f "$env_file" ]; then
+    return 0
+  fi
+
+  while IFS= read -r line || [ -n "$line" ]; do
+    _parse_env_line "$line" || continue
+    # Keep explicit environment overrides
+    if [ -z "${!ENV_KEY+x}" ]; then
+      export "$ENV_KEY=$ENV_VALUE"
+    fi
+  done < "$env_file"
+}
+
+# Load only specified keys from an env file.
+# Usage: load_env_keys /path/to/.env KEY1 KEY2 ...
+load_env_keys() {
+  local env_file="${1:-.env}"
+  shift || true
+
+  if [ ! -f "$env_file" ]; then
+    return 0
+  fi
+
+  # Build lookup table of requested keys
+  local wanted=" "
+  local key
+  for key in "$@"; do
+    wanted+="$key "
+  done
+
+  while IFS= read -r line || [ -n "$line" ]; do
+    _parse_env_line "$line" || continue
+    [[ "$wanted" == *" $ENV_KEY "* ]] || continue
+
+    if [ -z "${!ENV_KEY+x}" ]; then
+      export "$ENV_KEY=$ENV_VALUE"
+    fi
+  done < "$env_file"
+}

package/scripts/migrate-memory-to-channel-keys.ts

@@ -0,0 +1,148 @@
+#!/usr/bin/env bun
+/**
+ * One-time migration: re-key memory_turns from the legacy shared session key
+ * (discord:default:claude-discord) into per-channel session keys
+ * (discord:default:{channelId}).
+ *
+ * Each turn's channelId is read from its metadata_json. Turns without a
+ * channelId are left in the old key.
+ *
+ * Turn indices are renumbered per-channel to be sequential, starting after
+ * any existing turns already in that channel key.
+ *
+ * Usage:
+ *   bun scripts/migrate-memory-to-channel-keys.ts [path/to/memory.db]
+ */
+
+import { Database } from "bun:sqlite";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const dbPath = process.argv[2] || join(__dirname, "..", "data", "memory.db");
+
+console.log(`[migrate] Opening ${dbPath}`);
+const db = new Database(dbPath);
+
+const OLD_SESSION_KEY = "discord:default:claude-discord";
+
+// Read all turns under the old key
+const turns = db
+  .prepare(`
+  SELECT id, session_key, turn_index, role, content, metadata_json, created_at
+  FROM memory_turns
+  WHERE session_key = ?
+  ORDER BY turn_index ASC
+`)
+  .all(OLD_SESSION_KEY) as any[];
+
+console.log(`[migrate] Found ${turns.length} turns under ${OLD_SESSION_KEY}`);
+
+if (turns.length === 0) {
+  console.log("[migrate] Nothing to migrate.");
+  db.close();
+  process.exit(0);
+}
+
+// Group by channelId from metadata
+const byChannel = new Map<string, typeof turns>();
+const noChannel: typeof turns = [];
+
+for (const turn of turns) {
+  let channelId: string | null = null;
+  try {
+    const meta = JSON.parse(String((turn as any).metadata_json || "{}"));
+    channelId = meta.channelId || null;
+  } catch {}
+
+  if (!channelId) {
+    noChannel.push(turn);
+    continue;
+  }
+
+  if (!byChannel.has(channelId)) byChannel.set(channelId, []);
+  byChannel.get(channelId)!.push(turn);
+}
+
+console.log(`[migrate] Splitting into ${byChannel.size} channels:`);
+for (const [ch, chTurns] of byChannel) {
+  console.log(`  discord:default:${ch} -> ${chTurns.length} turns`);
+}
+if (noChannel.length > 0) {
+  console.log(`  (${noChannel.length} turns have no channelId -- left in old key)`);
+}
+
+// Find the current max turn_index for each target channel key
+function getMaxTurnIndex(sessionKey: string): number {
+  const row = db
+    .prepare("SELECT MAX(turn_index) as max_idx FROM memory_turns WHERE session_key = ?")
+    .get(sessionKey) as any;
+  return row?.max_idx ?? 0;
+}
+
+// Ensure per-channel session keys exist in memory_sessions
+const upsertSession = db.prepare(`
+  INSERT OR IGNORE INTO memory_sessions (session_key, created_at)
+  VALUES (?, datetime('now'))
+`);
+
+// Update each turn's session_key and re-index
+const updateTurn = db.prepare(`
+  UPDATE memory_turns SET session_key = ?, turn_index = ? WHERE id = ?
+`);
+
+// Copy runtime state for new keys
+const readRuntimeState = db.prepare(`
+  SELECT * FROM memory_runtime_state WHERE session_key = ?
+`);
+const upsertRuntimeState = db.prepare(`
+  INSERT OR IGNORE INTO memory_runtime_state (session_key, runtime_context_id, runtime_epoch, updated_at)
+  VALUES (?, ?, ?, datetime('now'))
+`);
+
+db.exec("BEGIN TRANSACTION");
+try {
+  const oldRuntime = readRuntimeState.get(OLD_SESSION_KEY) as any;
+
+  for (const [channelId, chTurns] of byChannel) {
+    const newKey = `discord:default:${channelId}`;
+    upsertSession.run(newKey);
+
+    // Start numbering after any existing turns in the target key
+    const startIndex = getMaxTurnIndex(newKey) + 1;
+
+    for (let i = 0; i < chTurns.length; i++) {
+      updateTurn.run(newKey, startIndex + i, chTurns[i].id);
+    }
+
+    // Bootstrap runtime state for the new key if it doesn't exist
+    if (oldRuntime) {
+      upsertRuntimeState.run(newKey, `migrated_from_${OLD_SESSION_KEY}`, 1);
+    }
+
+    console.log(
+      `[migrate] Updated ${chTurns.length} turns -> ${newKey} (indices ${startIndex}..${startIndex + chTurns.length - 1})`,
+    );
+  }
+
+  db.exec("COMMIT");
+  console.log("[migrate] Migration complete.");
+} catch (err) {
+  db.exec("ROLLBACK");
+  console.error("[migrate] Migration failed, rolled back:", (err as Error).message || err);
+  process.exit(1);
+}
+
+// Summary
+for (const [channelId] of byChannel) {
+  const newKey = `discord:default:${channelId}`;
+  const count = (db.prepare("SELECT COUNT(*) as cnt FROM memory_turns WHERE session_key = ?").get(newKey) as any).cnt;
+  console.log(`  ${newKey}: ${count} turns total`);
+}
+
+const remaining = (
+  db.prepare("SELECT COUNT(*) as cnt FROM memory_turns WHERE session_key = ?").get(OLD_SESSION_KEY) as any
+).cnt;
+console.log(`  ${OLD_SESSION_KEY}: ${remaining} turns remaining`);
+
+db.close();