@hoverlover/cc-discord 0.3.0 → 0.3.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Chad Boyd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -5,6 +5,7 @@
 - One autonomous Claude Code agent per Discord channel
 - Messages stored in SQLite, delivered to agents via hooks
 - Replies sent back to Discord via `send-discord` tool
+- Automatic catch-up of missed messages on startup — no messages lost during restarts
 - Typing indicators, busy notifications, live trace threads, memory context, attachment support, and more
 
 ## Quick start
@@ -198,6 +199,10 @@ Security note: the worker process intentionally does not receive `DISCORD_BOT_TO
 
 ## Features
 
+### Message catch-up
+
+When the relay starts, it fetches recent message history from each allowed channel and persists any messages that arrived while it was offline. Duplicates are silently ignored. This ensures no messages are lost during restarts or outages. Controlled by `CATCHUP_MESSAGE_LIMIT` (default 100, set to `0` to disable).
+
 ### Typing indicators
 
 When a user sends a message, the relay starts a typing indicator that repeats every `TYPING_INTERVAL_MS` (default 8s). It stops automatically when Claude replies. After `TYPING_MAX_MS` (default 120s), a configurable fallback patience message is sent.
@@ -266,6 +271,8 @@ In interactive mode, the orchestrator runs as a Claude Code session with a visib
 
 To keep cc-discord running across reboots and terminal closures, install it as a system service.
 
+> **Dedicated Mac server?** If you're setting up a Mac mini (or similar) as a headless, always-on server, see the [macOS Headless Server Setup Guide](docs/mac-setup-guide.md). It covers disabling SIP, configuring TCC permissions, FileVault tradeoffs, auto-login, and LaunchDaemon setup for fully unattended operation.
+
 ### macOS (launchd)
 
 1. Find the full paths to `bunx` and `claude`:
@@ -463,3 +470,9 @@ Monitor all logs:
 ```bash
 tail -f /tmp/cc-discord/logs/*.log
 ```
+
+---
+
+## License
+
+[MIT](LICENSE)

package/package.json

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

package/server/trace-thread.ts

@@ -36,6 +36,15 @@ let flushTimer: ReturnType<typeof setInterval> | null = null;
 
 // ── Thread lifecycle ────────────────────────────────────────────────
 
+/** Unarchive a thread if it's been auto-archived by Discord. */
+async function ensureUnarchived(thread: ThreadChannel): Promise<void> {
+  try {
+    if (thread.archived) await thread.setArchived(false);
+  } catch {
+    // best-effort — bot may lack MANAGE_THREADS
+  }
+}
+
 /** Lock a thread if not already locked (idempotent). */
 async function ensureLocked(thread: ThreadChannel): Promise<void> {
   try {
@@ -60,7 +69,8 @@ async function ensureTraceThread(client: Client, channelId: string): Promise<Thr
     try {
       const thread = await client.channels.fetch(cachedThreadId);
       if (thread && thread.isThread()) {
-        // Ensure thread is locked (idempotent — handles pre-existing unlocked threads)
+        // Unarchive if Discord auto-archived it, then ensure locked
+        await ensureUnarchived(thread as ThreadChannel);
         await ensureLocked(thread as ThreadChannel);
         return thread as ThreadChannel;
       }
@@ -76,7 +86,8 @@ async function ensureTraceThread(client: Client, channelId: string): Promise<Thr
     try {
       const thread = await client.channels.fetch(dbThreadId);
       if (thread && thread.isThread()) {
-        // Ensure thread is locked
+        // Unarchive if Discord auto-archived it, then ensure locked
+        await ensureUnarchived(thread as ThreadChannel);
         await ensureLocked(thread as ThreadChannel);
         threadCache.set(channelId, dbThreadId);
         return thread as ThreadChannel;
@@ -86,6 +97,37 @@ async function ensureTraceThread(client: Client, channelId: string): Promise<Thr
     }
   }
 
+  // Search existing threads by name before creating a new one (fallback for
+  // cases where the DB record was lost but the thread still exists in Discord)
+  try {
+    const channel = await client.channels.fetch(channelId);
+    if (channel && channel.type === ChannelType.GuildText) {
+      const textChannel = channel as TextChannel;
+      // Check active threads
+      const activeThreads = await textChannel.threads.fetchActive();
+      const existing = activeThreads.threads.find((t) => t.name === TRACE_THREAD_NAME);
+      if (existing) {
+        await ensureUnarchived(existing);
+        await ensureLocked(existing);
+        setTraceThreadId(channelId, existing.id);
+        threadCache.set(channelId, existing.id);
+        return existing;
+      }
+      // Check archived threads
+      const archivedThreads = await textChannel.threads.fetchArchived({ limit: 10 });
+      const existingArchived = archivedThreads.threads.find((t) => t.name === TRACE_THREAD_NAME);
+      if (existingArchived) {
+        await ensureUnarchived(existingArchived);
+        await ensureLocked(existingArchived);
+        setTraceThreadId(channelId, existingArchived.id);
+        threadCache.set(channelId, existingArchived.id);
+        return existingArchived;
+      }
+    }
+  } catch {
+    // best effort — fall through to create
+  }
+
   // Create new thread
   try {
     const channel = await client.channels.fetch(channelId);