@hoverlover/cc-discord 0.5.4 → 0.5.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hoverlover/cc-discord",
-  "version": "0.5.4",
+  "version": "0.5.6",
   "description": "Discord <-> Claude Code relay: use your Claude subscription to power per-channel AI bots",
   "type": "module",
   "bin": {

package/scripts/orchestrator.sh

@@ -299,33 +299,84 @@ done < <(discover_channels_lines)
 
 log "Initial spawn complete (${#KNOWN_CHANNEL_IDS[@]} channels). Entering health check loop."
 
-# Health check loop
-while true; do
-  sleep "$HEALTH_CHECK_INTERVAL"
+# Check for unread messages with no active agent (e.g. new threads).
+# Spawns agents immediately so users don't wait for the next health check.
+UNSERVICED_CHECK_INTERVAL="${UNSERVICED_CHECK_INTERVAL:-5}"
 
-  # Check for dead agents and restart them
-  for i in "${!KNOWN_CHANNEL_IDS[@]}"; do
-    _pid="${KNOWN_CHANNEL_PIDS[$i]}"
-    if ! is_agent_alive "$_pid"; then
-      _name="${KNOWN_CHANNEL_NAMES[$i]}"
-      _cid="${KNOWN_CHANNEL_IDS[$i]}"
-      wait "$_pid" 2>/dev/null || true
-      log "Agent #${_name} (${_cid}) exited. Restarting in ${AGENT_RESTART_DELAY}s..."
-      sleep "$AGENT_RESTART_DELAY"
-      start_channel_agent "$_cid" "$_name"
-    fi
-  done
+check_unserviced() {
+  local response
+  response=$(curl -s --max-time 5 \
+    -H "x-api-token: ${RELAY_API_TOKEN}" \
+    "${RELAY_URL}/api/unserviced" 2>/dev/null) || return
+
+  local targets
+  targets=$(echo "$response" | bun -e "
+    const input = await Bun.stdin.text();
+    try {
+      const data = JSON.parse(input);
+      if (data.success && Array.isArray(data.targets)) {
+        for (const t of data.targets) {
+          // Only spawn for snowflake IDs (channels/threads), not agent names
+          if (/^\d{15,22}$/.test(t.toAgent)) {
+            console.log(t.toAgent);
+          }
+        }
+      }
+    } catch {}
+  " 2>/dev/null) || return
 
-  # Check for stuck agents (alive but not polling)
-  check_stuck_agents
+  [ -z "$targets" ] && return
 
-  # Check for new channels
-  while IFS=' ' read -r channel_id channel_name; do
-    [ -z "$channel_id" ] && continue
-    _idx=$(find_channel_index "$channel_id")
-    if [ "$_idx" -lt 0 ]; then
-      log "New channel discovered: #${channel_name} (${channel_id})"
-      start_channel_agent "$channel_id" "$channel_name"
+  while IFS= read -r target_id; do
+    [ -z "$target_id" ] && continue
+    _idx=$(find_channel_index "$target_id")
+    if [ "$_idx" -ge 0 ]; then
+      # Agent exists but hasn't polled yet — skip
+      continue
     fi
-  done < <(discover_channels_lines)
+    log "Unserviced messages for ${target_id} — spawning agent"
+    start_channel_agent "$target_id" "thread-${target_id}"
+  done <<< "$targets"
+}
+
+# Health check loop — runs unserviced check every UNSERVICED_CHECK_INTERVAL seconds,
+# full health check every HEALTH_CHECK_INTERVAL seconds.
+SECONDS_SINCE_HEALTH=0
+while true; do
+  sleep "$UNSERVICED_CHECK_INTERVAL"
+  SECONDS_SINCE_HEALTH=$((SECONDS_SINCE_HEALTH + UNSERVICED_CHECK_INTERVAL))
+
+  # Fast check: spawn agents for unserviced threads/channels
+  check_unserviced
+
+  # Full health check on the slower interval
+  if [ "$SECONDS_SINCE_HEALTH" -ge "$HEALTH_CHECK_INTERVAL" ]; then
+    SECONDS_SINCE_HEALTH=0
+
+    # Check for dead agents and restart them
+    for i in "${!KNOWN_CHANNEL_IDS[@]}"; do
+      _pid="${KNOWN_CHANNEL_PIDS[$i]}"
+      if ! is_agent_alive "$_pid"; then
+        _name="${KNOWN_CHANNEL_NAMES[$i]}"
+        _cid="${KNOWN_CHANNEL_IDS[$i]}"
+        wait "$_pid" 2>/dev/null || true
+        log "Agent #${_name} (${_cid}) exited. Restarting in ${AGENT_RESTART_DELAY}s..."
+        sleep "$AGENT_RESTART_DELAY"
+        start_channel_agent "$_cid" "$_name"
+      fi
+    done
+
+    # Check for stuck agents (alive but not polling)
+    check_stuck_agents
+
+    # Check for new channels/threads
+    while IFS=' ' read -r channel_id channel_name; do
+      [ -z "$channel_id" ] && continue
+      _idx=$(find_channel_index "$channel_id")
+      if [ "$_idx" -lt 0 ]; then
+        log "New channel discovered: #${channel_name} (${channel_id})"
+        start_channel_agent "$channel_id" "$channel_name"
+      fi
+    done < <(discover_channels_lines)
+  fi
 done

package/server/db.ts

@@ -227,6 +227,28 @@ export function insertTraceEvent(
   }
 }
 
+/**
+ * Find message targets (to_agent) that have unread messages but no agent
+ * has ever polled for them (no agent_activity record). These are typically
+ * new threads that need an agent spawned.
+ */
+export function getUnservicedTargets(sessionId: string): { toAgent: string; unreadCount: number; oldestAt: string }[] {
+  try {
+    const rows = db
+      .prepare(`
+      SELECT m.to_agent, COUNT(*) as unread_count, MIN(m.created_at) as oldest_at
+      FROM messages m
+      LEFT JOIN agent_activity a ON a.agent_id = m.to_agent AND a.session_id = m.session_id
+      WHERE m.session_id = ? AND m.read = 0 AND a.agent_id IS NULL
+      GROUP BY m.to_agent
+    `)
+      .all(sessionId) as any[];
+    return rows.map((r) => ({ toAgent: r.to_agent, unreadCount: r.unread_count, oldestAt: r.oldest_at }));
+  } catch {
+    return [];
+  }
+}
+
 /**
  * Get health status for all agents in a session.
  * Returns each agent's last heartbeat time, status, and whether it

package/server/index.ts

@@ -27,7 +27,7 @@ import {
   TYPING_MAX_MS,
   validateConfig,
 } from "./config.ts";
-import { clearChannelModel, db, getAgentHealthAll, getChannelModel, isTraceThread, setChannelModel } from "./db.ts";
+import { clearChannelModel, db, getAgentHealthAll, getChannelModel, getUnservicedTargets, isTraceThread, setChannelModel } from "./db.ts";
 import { memoryStore } from "./memory.ts";
 import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
 import { startTraceFlushLoop, stopTraceFlushLoop } from "./trace-thread.ts";
@@ -253,6 +253,17 @@ app.get("/api/agent-health", (req: Request, res: Response) => {
   }
 });
 
+app.get("/api/unserviced", (req: Request, res: Response) => {
+  try {
+    if (!requireAuth(req, res)) return;
+    const targets = getUnservicedTargets(DISCORD_SESSION_ID);
+    res.json({ success: true, targets });
+  } catch (err: unknown) {
+    console.error("[Relay] /api/unserviced 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;

package/server/trace-thread.ts

@@ -54,6 +54,18 @@ async function ensureTraceThread(client: Client, channelId: string): Promise<Thr
   const failedAt = failedChannels.get(channelId);
   if (failedAt && Date.now() - failedAt < FAILURE_COOLDOWN_MS) return null;
 
+  // Quick-fetch to detect threads: can't create trace threads inside threads
+  try {
+    const ch = await client.channels.fetch(channelId);
+    if (ch?.isThread()) {
+      failedChannels.set(channelId, Date.now());
+      return null;
+    }
+  } catch {
+    // Channel doesn't exist or inaccessible — fall through to cached/DB path
+    // which will also fail and trigger cooldown
+  }
+
   // Check in-memory cache first
   const cachedThreadId = threadCache.get(channelId);
   if (cachedThreadId) {
@@ -156,7 +168,13 @@ async function ensureTraceThread(client: Client, channelId: string): Promise<Thr
     threadCache.set(channelId, thread.id);
     return thread;
   } catch (err) {
-    console.error(`[Trace] Failed to create trace thread for channel ${channelId}:`, err);
+    const code = (err as any)?.code;
+    if (code === 10003 || code === 50001 || code === 50013) {
+      console.warn(`[Trace] Cannot create trace thread for channel ${channelId} (${code}) — backing off 5m`);
+      failedChannels.set(channelId, Date.now());
+    } else {
+      console.error(`[Trace] Failed to create trace thread for channel ${channelId}:`, err);
+    }
     return null;
   }
 }
@@ -313,9 +331,9 @@ async function flushTraceEvents(client: Client) {
       postedIds.push(...channelEvents.map((e) => e.id));
     } catch (err) {
       const code = (err as any)?.code;
-      if (code === 50001 || code === 50013) {
-        // Missing Access or Missing Permissions — clear cache and back off
-        console.warn(`[Trace] No access to trace thread for channel ${channelId} (${code}) — backing off 5m`);
+      if (code === 50001 || code === 50013 || code === 10003) {
+        // Missing Access, Missing Permissions, or Unknown Channel — clear cache and back off
+        console.warn(`[Trace] Cannot access trace thread for channel ${channelId} (${code}) — backing off 5m`);
         threadCache.delete(channelId);
         failedChannels.set(channelId, Date.now());
         // Mark as posted to avoid infinite retry on permanent access errors