@hoverlover/cc-discord 0.4.0 → 0.5.1

package/.claude/skills/release/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: Release
+description: Analyze commits since last release and publish with intelligent semantic version bumping.
+---
+
+# Release
+
+Analyze all commits since the last version tag, determine the appropriate semantic version bump (major/minor/patch), and publish to npm.
+
+## Version Bump Rules
+
+Semantic versioning: `MAJOR.MINOR.PATCH`
+
+| Change Type | Bump | Indicators |
+|-------------|------|------------|
+| **Breaking** | MAJOR | `BREAKING CHANGE:`, `!:` suffix, API removals, incompatible changes |
+| **Feature** | MINOR | `feat:`, `feature:`, `add:`, new functionality, enhancements |
+| **Bugfix** | PATCH | `fix:`, `bugfix:`, `patch:`, corrections, typos, small improvements |
+
+The highest-impact change determines the bump (MAJOR > MINOR > PATCH).
+
+## Instructions
+
+### Step 1: Gather Release Context
+
+Run these commands in parallel:
+
+1. Get the last version tag:
+   ```bash
+   git describe --tags --abbrev=0
+   ```
+
+2. Get commits since last tag:
+   ```bash
+   git log $(git describe --tags --abbrev=0)..HEAD --oneline
+   ```
+
+3. Check npm login status:
+   ```bash
+   npm whoami 2>/dev/null || echo "NOT_LOGGED_IN"
+   ```
+
+### Step 2: Verify npm Authentication
+
+Check the result of `npm whoami`:
+
+**If logged in** (returns a username): Proceed to Step 3.
+
+**If not logged in** (returns "NOT_LOGGED_IN" or error): Use browser-based authentication:
+
+1. Connect to Chrome (with retry logic):
+   - Call `mcp__claude-in-chrome__tabs_context_mcp` with `createIfEmpty: true`
+   - If connection fails, wait 2 seconds and retry (up to 3 times)
+   - If connected, create a new tab using `mcp__claude-in-chrome__tabs_create_mcp`
+   - Note whether Chrome is available for later steps
+
+2. Start `npm login` in the terminal with a pseudo-terminal to get the login URL:
+   ```bash
+   script -q /dev/null npm login --auth-type=web 2>&1
+   ```
+
+3. The command will output a URL like `https://www.npmjs.com/login?next=/login/cli/...`
+
+4. Open the URL:
+   - **If Chrome connected:** Navigate the browser tab to that URL using `mcp__claude-in-chrome__navigate`
+   - **If Chrome unavailable:** Display the URL and ask user to open it manually
+
+5. Inform the user: "Please complete the npm login in the browser window."
+
+6. Wait for the login command to complete (it polls for authentication)
+
+7. Verify login succeeded:
+   ```bash
+   npm whoami
+   ```
+
+8. If still not logged in, ask user if they want to retry or abort
+
+### Step 3: Analyze Commits
+
+For each commit since the last tag, classify it:
+
+**Conventional Commit Patterns (primary):**
+- `fix:`, `fix(scope):` → PATCH
+- `feat:`, `feat(scope):` → MINOR
+- `BREAKING CHANGE:` in body or `!:` → MAJOR
+- `docs:`, `chore:`, `style:`, `refactor:`, `test:` → PATCH (maintenance)
+
+**Content Analysis (for non-conventional commits):**
+- Look at the commit message semantics
+- "Add", "Implement", "Introduce" → likely MINOR
+- "Fix", "Correct", "Repair", "Resolve" → likely PATCH
+- "Remove", "Delete API", "Breaking" → likely MAJOR
+- "Update", "Bump", "Improve" → likely PATCH
+- Release commits ("Bump installer to...") → skip (don't count)
+
+**When uncertain:** Default to PATCH unless the change clearly adds new functionality.
+
+### Step 4: Present Analysis
+
+Show the user:
+
+```
+Analyzing commits since vX.Y.Z...
+
+Commit Analysis:
+  [hash] [message] → [classification] ([bump type])
+  [hash] [message] → [classification] ([bump type])
+  ...
+
+Summary:
+  Breaking changes: N
+  New features: N
+  Bugfixes/maintenance: N
+
+Highest impact: [MAJOR|MINOR|PATCH]
+Proposed version: vX.Y.Z → vA.B.C
+
+Proceed with release?
+```
+
+Wait for user confirmation before proceeding.
+
+### Step 5: Execute Release
+
+#### 5a. Connect to Chrome Browser
+
+Before starting the release, establish a Chrome connection for browser-based npm authentication:
+
+1. Call `mcp__claude-in-chrome__tabs_context_mcp` with `createIfEmpty: true`
+2. If the connection fails (extension not connected error):
+   - Wait 2 seconds and retry
+   - Retry up to 3 times total
+   - If all retries fail, inform the user: "Chrome browser extension is not available. You'll need to open the npm auth URL manually when prompted."
+3. If connected, create a new tab using `mcp__claude-in-chrome__tabs_create_mcp`
+4. Store the tab ID for later use
+
+#### 5b. Run Release Script
+
+Run the release script in background mode to capture the auth URL:
+
+```bash
+script -q /dev/null ./scripts/release.sh [patch|minor|major] 2>&1
+```
+
+The script will:
+1. Validate agent configurations
+2. Bump version in package.json files
+3. Commit and tag the release
+4. Push to git
+5. Publish to npm with browser-based 2FA
+
+#### 5c. Handle npm Authentication
+
+Monitor the script output for the auth URL. When you see:
+```
+Authenticate your account at:
+https://www.npmjs.com/auth/cli/[unique-id]
+```
+
+**If Chrome is connected:**
+1. Navigate the browser tab to that URL using `mcp__claude-in-chrome__navigate`
+2. Inform the user: "Please complete the npm authentication in the browser."
+
+**If Chrome is not available:**
+1. Display the full URL to the user
+2. Inform them: "Please open this URL in your browser to authenticate."
+
+Wait for the script to complete (npm polls for authentication).
+
+### Step 6: Report Results
+
+After successful release, show:
+- New version number
+- npm package URL
+- Git tag created
+
+## Edge Cases
+
+**No commits since last tag:**
+- Inform user there's nothing to release
+- Ask if they want to force a patch bump anyway
+
+**All commits are release/chore commits:**
+- Default to PATCH bump
+- Note that only maintenance commits were found
+
+**Mixed signals in a commit:**
+- If a commit adds a feature but also fixes a bug, classify by primary intent
+- When truly ambiguous, ask the user
+
+## Safety Rules
+
+- Always show analysis and get confirmation before releasing
+- Verify npm login before attempting to publish (use browser auth if needed)
+- If any step fails, stop and report the error
+- Don't push or publish without explicit user approval

package/package.json

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

package/server/catchup.ts

@@ -4,7 +4,8 @@
  */
 
 import type { Client } from "discord.js";
-import { CATCHUP_MESSAGE_LIMIT, IGNORED_CHANNEL_IDS, ALLOWED_CHANNEL_IDS, isAllowedUser } from "./config.ts";
+import { CATCHUP_MESSAGE_LIMIT, IGNORED_CHANNEL_IDS, ALLOWED_CHANNEL_IDS, TRACE_THREAD_NAME, isAllowedUser } from "./config.ts";
+import { isTraceThread } from "./db.ts";
 import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
 import { startTypingIndicator } from "./typing.ts";
 
@@ -15,6 +16,7 @@ export async function catchUpMissedMessages(client: Client) {
   }
 
   let channelsScanned = 0;
+  let threadsCaughtUp = 0;
   let messagesCaughtUp = 0;
 
   for (const [, guild] of client.guilds.cache) {
@@ -47,8 +49,40 @@ export async function catchUpMissedMessages(client: Client) {
       } catch (err: unknown) {
         console.error(`[Catchup] Failed to fetch messages for #${channel.name} (${channel.id}):`, (err as Error).message);
       }
+
+      // Catch up active threads in this channel
+      if ("threads" in channel && channel.threads) {
+        try {
+          const activeThreads = await (channel as any).threads.fetchActive();
+          for (const [, thread] of activeThreads.threads) {
+            if (thread.name === TRACE_THREAD_NAME || isTraceThread(thread.id)) continue;
+            try {
+              const threadMessages = await thread.messages.fetch({ limit: CATCHUP_MESSAGE_LIMIT });
+              threadsCaughtUp++;
+              const sorted = [...threadMessages.values()]
+                .filter((m: any) => !m.author.bot && isAllowedUser(m.author.id))
+                .sort((a: any, b: any) => a.createdTimestamp - b.createdTimestamp);
+              let threadHasNew = false;
+              for (const msg of sorted) {
+                const isNew = await persistInboundDiscordMessage(msg);
+                if (isNew) {
+                  messagesCaughtUp++;
+                  threadHasNew = true;
+                }
+              }
+              if (threadHasNew) {
+                startTypingIndicator(client, thread.id, persistOutboundDiscordMessage);
+              }
+            } catch (err: unknown) {
+              console.error(`[Catchup] Failed for thread "${thread.name}" (${thread.id}):`, (err as Error).message);
+            }
+          }
+        } catch (err: unknown) {
+          console.error(`[Catchup] Failed to fetch threads for #${(channel as any).name}:`, (err as Error).message);
+        }
+      }
     }
   }
 
-  console.log(`[Catchup] Done — scanned ${channelsScanned} channel(s), caught up ${messagesCaughtUp} message(s)`);
+  console.log(`[Catchup] Done — scanned ${channelsScanned} channel(s), ${threadsCaughtUp} thread(s), caught up ${messagesCaughtUp} message(s)`);
 }

package/server/config.ts

@@ -94,6 +94,24 @@ export function isAllowedChannel(channelId: string): boolean {
   return true;
 }
 
+/**
+ * Thread-aware channel check for incoming messages.
+ * Allows threads whose parent channel is in the allowlist.
+ */
+export function isAllowedChannelForMessage(message: { channelId: string; channel?: any }): boolean {
+  if (!message.channelId) return false;
+  if (IGNORED_CHANNEL_IDS.has(message.channelId)) return false;
+  if (ALLOWED_CHANNEL_IDS.length === 0) return true;
+  if (ALLOWED_CHANNEL_IDS.includes(message.channelId)) return true;
+  // Thread: check parent channel
+  const ch = message.channel;
+  if (ch?.isThread?.() && ch.parentId) {
+    if (IGNORED_CHANNEL_IDS.has(ch.parentId)) return false;
+    return ALLOWED_CHANNEL_IDS.includes(ch.parentId);
+  }
+  return false;
+}
+
 export function isAllowedUser(userId: string | undefined): boolean {
   if (!userId) return false;
   if (ALLOWED_DISCORD_USER_IDS.length === 0) return true;

package/server/db.ts

@@ -133,6 +133,15 @@ export function getCurrentAgentActivity(sessionId: string, defaultAgentId: strin
   }
 }
 
+export function isTraceThread(threadId: string): boolean {
+  try {
+    const row = db.prepare("SELECT 1 FROM trace_threads WHERE thread_id = ?").get(threadId);
+    return !!row;
+  } catch {
+    return false;
+  }
+}
+
 // ── Trace thread helpers ────────────────────────────────────────────
 
 export function getTraceThreadId(channelId: string): string | null {

package/server/index.ts

@@ -15,6 +15,7 @@ import {
   DISCORD_SESSION_ID,
   IGNORED_CHANNEL_IDS,
   isAllowedChannel,
+  isAllowedChannelForMessage,
   isAllowedUser,
   MESSAGE_ROUTING_MODE,
   RELAY_ALLOW_NO_AUTH,
@@ -26,7 +27,7 @@ import {
   TYPING_MAX_MS,
   validateConfig,
 } from "./config.ts";
-import { clearChannelModel, db, getAgentHealthAll, getChannelModel, setChannelModel } from "./db.ts";
+import { clearChannelModel, db, getAgentHealthAll, getChannelModel, isTraceThread, setChannelModel } from "./db.ts";
 import { memoryStore } from "./memory.ts";
 import { persistInboundDiscordMessage, persistOutboundDiscordMessage } from "./messages.ts";
 import { startTraceFlushLoop, stopTraceFlushLoop } from "./trace-thread.ts";
@@ -104,7 +105,8 @@ client.once("clientReady", async () => {
 client.on("messageCreate", async (message) => {
   if (!message) return;
   if (message.author?.bot) return;
-  if (!isAllowedChannel(message.channelId)) return;
+  if (!isAllowedChannelForMessage(message)) return;
+  if (message.channel?.isThread?.() && isTraceThread(message.channelId)) return;
   if (!isAllowedUser(message.author?.id)) {
     console.log(`[Relay] Ignoring message from unauthorized user ${message.author?.id}`);
     return;
@@ -196,6 +198,34 @@ app.get("/api/channels", async (req: Request, res: Response) => {
       }
     }
 
+    // Optionally include active threads in allowed channels
+    if (req.query.include_threads === "true") {
+      for (const ch of [...channels]) {
+        try {
+          const parentChannel = await client.channels.fetch(ch.id);
+          if (parentChannel && "threads" in parentChannel) {
+            const activeThreads = await (parentChannel as any).threads.fetchActive();
+            for (const [, thread] of activeThreads.threads) {
+              if (isTraceThread(thread.id)) continue;
+              channels.push({
+                id: thread.id,
+                name: thread.name,
+                guildId: ch.guildId,
+                guildName: ch.guildName,
+                type: thread.type,
+                isThread: true,
+                parentChannelId: ch.id,
+                parentChannelName: ch.name,
+                model: getChannelModel(thread.id),
+              });
+            }
+          }
+        } catch {
+          /* skip */
+        }
+      }
+    }
+
     res.json({ success: true, channels });
   } catch (err: unknown) {
     console.error("[Relay] /api/channels failed:", err);

package/server/messages.ts

@@ -23,7 +23,14 @@ export async function formatInboundMessage(message: any) {
     fullText = "[No text content]";
   }
 
-  return `${author}: ${fullText}`;
+  // Add thread context if message is from a thread
+  let prefix = author;
+  if (message.channel?.isThread?.()) {
+    const threadName = message.channel.name || "thread";
+    prefix = `${author} [thread: ${threadName}]`;
+  }
+
+  return `${prefix}: ${fullText}`;
 }
 
 export async function persistInboundDiscordMessage(message: any): Promise<boolean> {