@gonzih/cc-discord 0.2.15 → 0.2.17

package/dist/bot.d.ts

@@ -18,6 +18,8 @@ export interface DiscordBotOptions {
     redis?: Redis;
     namespace?: string;
     guildIds?: string[];
+    /** Instance ID for singleton overlap detection */
+    instanceId?: string;
     /** Called when a message is routed to a non-default namespace so the notifier
      *  can forward the response back to the originating Discord channel. */
     registerRoutedChannelId?: (namespace: string, channelId: string) => void;
@@ -138,5 +140,22 @@ export declare class CcDiscordBot {
      * Passes a live getter for the set of registered namespaces.
      */
     startMetaAgentPolling(): void;
+    /**
+     * Resolve the namespace for a given channelId.
+     * Routed channels use their registered namespace; everything else uses the bot's primary namespace.
+     */
+    private resolveNamespaceForChannel;
+    /**
+     * Delete all Claude session JSONL files for the given namespace's workspace.
+     * Claude stores sessions in ~/.claude/projects/{encoded-workspace-path}/*.jsonl
+     * The path encoding replaces / with - and prepends a leading -.
+     * Returns the number of files deleted.
+     */
+    private clearClaudeSession;
+    /**
+     * Send /compact as a prompt to a one-shot claude --continue session in the namespace workspace.
+     * This triggers Claude's built-in context compaction.
+     */
+    private compactClaudeSession;
     stop(): void;
 }

package/dist/bot.js

@@ -3,8 +3,9 @@
  * One ClaudeProcess per channel (or channel:thread) — sessions are isolated per channel.
  */
 import { Client, GatewayIntentBits, REST, Routes, SlashCommandBuilder, EmbedBuilder, AttachmentBuilder, Events, ChannelType, } from "discord.js";
-import { existsSync, createWriteStream, mkdirSync, statSync } from "fs";
+import { existsSync, createWriteStream, mkdirSync, statSync, readdirSync, rmSync } from "fs";
 import { resolve, basename, join } from "path";
+import { homedir } from "os";
 import https from "https";
 import http from "http";
 import { createCcWire } from "@gonzih/cc-wire";
@@ -816,6 +817,15 @@ export class CcDiscordBot {
                 .setName("channel")
                 .setDescription("Create a Discord channel for a GitHub repo meta-agent")
                 .addStringOption((opt) => opt.setName("repo").setDescription("GitHub repo URL (e.g. https://github.com/org/repo)").setRequired(true)),
+            new SlashCommandBuilder()
+                .setName("restart")
+                .setDescription("Graceful restart — exits this process (launchd will respawn clean)"),
+            new SlashCommandBuilder()
+                .setName("clear")
+                .setDescription("Clear the Claude session context for this channel's namespace"),
+            new SlashCommandBuilder()
+                .setName("compact")
+                .setDescription("Compact the Claude session context for this channel's namespace"),
         ].map((cmd) => cmd.toJSON());
         const rest = new REST().setToken(this.opts.discordToken);
         if (this.opts.guildIds?.length) {
@@ -941,6 +951,27 @@ export class CcDiscordBot {
                 }
                 break;
             }
+            case "restart": {
+                await interaction.reply("Restarting...");
+                setTimeout(() => { process.exit(0); }, 500);
+                break;
+            }
+            case "clear": {
+                const ns = this.resolveNamespaceForChannel(channelId);
+                const deleted = this.clearClaudeSession(ns);
+                await interaction.reply(deleted > 0
+                    ? `Context cleared for ${ns} (${deleted} session file${deleted === 1 ? "" : "s"} removed). Next message starts fresh.`
+                    : `No active session files found for ${ns}.`);
+                break;
+            }
+            case "compact": {
+                const ns = this.resolveNamespaceForChannel(channelId);
+                await interaction.reply(`Compacting context for ${ns}...`);
+                this.compactClaudeSession(ns).catch((err) => {
+                    console.warn(`[bot] /compact failed (ns=${ns}):`, err.message);
+                });
+                break;
+            }
         }
     }
     async handleCronsCommand(interaction, channelId) {
@@ -1293,7 +1324,90 @@ export class CcDiscordBot {
     startMetaAgentPolling() {
         if (!this.wire)
             return;
-        this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()));
+        this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()), this.opts.instanceId);
+    }
+    /**
+     * Resolve the namespace for a given channelId.
+     * Routed channels use their registered namespace; everything else uses the bot's primary namespace.
+     */
+    resolveNamespaceForChannel(channelId) {
+        return this.channelNamespaceMap.get(channelId)?.namespace ?? this.namespace;
+    }
+    /**
+     * Delete all Claude session JSONL files for the given namespace's workspace.
+     * Claude stores sessions in ~/.claude/projects/{encoded-workspace-path}/*.jsonl
+     * The path encoding replaces / with - and prepends a leading -.
+     * Returns the number of files deleted.
+     */
+    clearClaudeSession(ns) {
+        const wsPath = join(homedir(), "cc-discord-workspace", ns);
+        // Claude encodes workspace path: strip leading /, replace / with -, then prepend -
+        const encoded = "-" + wsPath.slice(1).replace(/\//g, "-");
+        const projectsDir = join(homedir(), ".claude", "projects", encoded);
+        if (!existsSync(projectsDir))
+            return 0;
+        let count = 0;
+        try {
+            const entries = readdirSync(projectsDir);
+            for (const entry of entries) {
+                if (entry.endsWith(".jsonl")) {
+                    rmSync(join(projectsDir, entry), { force: true });
+                    count++;
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`[bot] clearClaudeSession(${ns}) failed:`, err.message);
+        }
+        console.log(`[bot] clearClaudeSession(${ns}): deleted ${count} files from ${projectsDir}`);
+        return count;
+    }
+    /**
+     * Send /compact as a prompt to a one-shot claude --continue session in the namespace workspace.
+     * This triggers Claude's built-in context compaction.
+     */
+    async compactClaudeSession(ns) {
+        const wsPath = join(homedir(), "cc-discord-workspace", ns);
+        if (!existsSync(wsPath)) {
+            console.warn(`[bot] compactClaudeSession(${ns}): workspace not found at ${wsPath}`);
+            return;
+        }
+        const token = await this.resolveToken();
+        const { spawn } = await import("child_process");
+        const { existsSync: fsExists } = await import("fs");
+        const resolveBin = () => {
+            const dirs = (process.env.PATH ?? "").split(":");
+            for (const dir of dirs) {
+                const c = `${dir}/claude`;
+                if (fsExists(c))
+                    return c;
+            }
+            for (const p of [`${homedir()}/.npm-global/bin/claude`, "/opt/homebrew/bin/claude", "/usr/local/bin/claude"]) {
+                if (fsExists(p))
+                    return p;
+            }
+            return "claude";
+        };
+        const env = { ...process.env };
+        if (token.startsWith("sk-ant-api")) {
+            env.ANTHROPIC_API_KEY = token;
+            delete env.CLAUDE_CODE_OAUTH_TOKEN;
+        }
+        else {
+            env.CLAUDE_CODE_OAUTH_TOKEN = token;
+            delete env.ANTHROPIC_API_KEY;
+        }
+        return new Promise((resolve) => {
+            const proc = spawn(resolveBin(), ["--continue", "-p", "/compact", "--output-format", "text", "--dangerously-skip-permissions"], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
+            proc.on("exit", (code) => {
+                console.log(`[bot] compactClaudeSession(${ns}) exited code=${code}`);
+                resolve();
+            });
+            proc.on("error", (err) => {
+                console.warn(`[bot] compactClaudeSession(${ns}) spawn error:`, err.message);
+                resolve();
+            });
+        });
     }
     stop() {
         for (const [key, session] of this.sessions) {

package/dist/index.js

@@ -20,6 +20,7 @@
  *   CC_DISCORD_MCP_JSON        — JSON template for .mcp.json injection into workspaces
  */
 import { createRequire } from "node:module";
+import { randomUUID } from "crypto";
 import { Redis } from "ioredis";
 import { createCcWire } from "@gonzih/cc-wire";
 import { CcDiscordBot } from "./bot.js";
@@ -77,12 +78,28 @@ sharedRedis.on("error", (err) => {
 });
 // cc-wire factory
 const wire = createCcWire(sharedRedis);
+// Singleton instance ID — used to detect stale processes after a restart
+const instanceId = randomUUID();
+const INSTANCE_KEY = "cca:discord:instance";
+const INSTANCE_TTL_MS = 30_000;
+const INSTANCE_REFRESH_MS = 10_000;
 sharedRedis.once("ready", () => {
     // Announce version
     sharedRedis.set(`cca:meta:cc-discord:version`, version).catch((err) => {
         console.warn("[redis] failed to write version:", err.message);
     });
     console.log(`[cc-discord] version:reported ${version}`);
+    // Write singleton instance ID with 30s TTL
+    sharedRedis.set(INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
+        console.warn("[cc-discord] failed to write instance ID:", err.message);
+    });
+    console.log(`[cc-discord] instance:${instanceId}`);
+    // Refresh TTL every 10s so launchd-respawned processes displace old ones
+    setInterval(() => {
+        sharedRedis.set(INSTANCE_KEY, instanceId, "PX", INSTANCE_TTL_MS).catch((err) => {
+            console.warn("[cc-discord] instance refresh failed:", err.message);
+        });
+    }, INSTANCE_REFRESH_MS);
     // Store master token so MetaAgentManager can retrieve it
     wire.token.setMaster(claudeToken).catch((err) => {
         console.warn("[cc-discord] failed to set master token:", err.message);
@@ -140,6 +157,7 @@ const bot = new CcDiscordBot({
     guildIds,
     redis: sharedRedis,
     namespace,
+    instanceId,
     registerRoutedChannelId: (ns, channelId) => notifier.registerRoutedChannelId(ns, channelId),
 });
 const notifier = startNotifier(bot, notifyChannelId, namespace, sharedRedis, (channelId, text) => handleUserMessageFn?.(channelId, text), (channelId, text) => forwardNotificationFn?.(channelId, text), () => getLastActiveChannelIdFn(), (n) => bot.reverseSnowflakeLookup(n), (ns) => bot.getChannelIdForNamespace(ns));

package/dist/meta-agent-manager.d.ts

@@ -30,9 +30,17 @@ export declare function ensureWorkspace(ns: string, repoUrl: string): Promise<vo
  * {npmCache}, {trustedOwners}, {path}.
  */
 export declare function injectMcp(ns: string, wsPath: string, token: string): void;
+/**
+ * Redis keys for meta-agent stdout streaming.
+ * cca:meta:{ns}:stream — pub/sub channel (live streaming)
+ * cca:meta:{ns}:log    — list (history, capped at 2000)
+ */
+export declare function metaStreamChannel(ns: string): string;
+export declare function metaLogKey(ns: string): string;
 /**
  * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
  */
 export declare function spawnSession(ns: string, message: string, token: string, wire: Wire): Promise<void>;
@@ -42,7 +50,7 @@ export interface MetaAgentManager {
     startPolling: (wire: Wire, getNamespaces: () => Array<{
         namespace: string;
         repoUrl: string;
-    }>) => void;
+    }>, instanceId?: string) => void;
     stop: () => void;
 }
 /**

package/dist/meta-agent-manager.js

@@ -64,7 +64,7 @@ export function injectMcp(ns, wsPath, token) {
         return;
     }
     const npmCache = process.env.npm_config_cache ?? `${homedir()}/.npm`;
-    const trustedOwners = process.env.CC_AGENT_TRUSTED_OWNERS ?? "";
+    const trustedOwners = process.env.CC_AGENT_TRUSTED_OWNERS ?? "gonzih,ecoclaw,simorgh-app";
     const systemPath = process.env.PATH ?? "/usr/local/bin:/usr/bin:/bin";
     const config = {
         mcpServers: {
@@ -112,9 +112,21 @@ function resolveClaude() {
     }
     return "claude";
 }
+/**
+ * Redis keys for meta-agent stdout streaming.
+ * cca:meta:{ns}:stream — pub/sub channel (live streaming)
+ * cca:meta:{ns}:log    — list (history, capped at 2000)
+ */
+export function metaStreamChannel(ns) {
+    return `cca:meta:${ns}:stream`;
+}
+export function metaLogKey(ns) {
+    return `cca:meta:${ns}:log`;
+}
 /**
  * Spawn `claude --continue -p "{message}" --dangerously-skip-permissions` in the
  * namespace workspace. Pipes stdout line-by-line → wire.discord.publishOutgoing.
+ * Also streams each chunk to Redis: PUBLISH cca:meta:{ns}:stream and LPUSH cca:meta:{ns}:log.
  * Returns a Promise that resolves when the process exits.
  */
 export function spawnSession(ns, message, token, wire) {
@@ -134,6 +146,7 @@ export function spawnSession(ns, message, token, wire) {
             "--continue",
             "-p", message,
             "--output-format", "text",
+            "--verbose",
             "--dangerously-skip-permissions",
         ], { cwd: wsPath, env, stdio: ["ignore", "pipe", "pipe"] });
         let lineBuffer = "";
@@ -153,8 +166,27 @@ export function spawnSession(ns, message, token, wire) {
                 console.warn(`[meta-agent-manager] publishOutgoing failed (ns=${ns}):`, err.message);
             });
         };
+        const rawRedis = wire._redis;
+        const streamToRedis = (chunk) => {
+            const entry = JSON.stringify({ ts: Date.now(), ns, text: chunk });
+            const streamCh = metaStreamChannel(ns);
+            const logKey = metaLogKey(ns);
+            // Publish for live consumers (fire-and-forget)
+            rawRedis.publish(streamCh, entry).catch((err) => {
+                console.warn(`[meta-agent-manager] stream publish failed (ns=${ns}):`, err.message);
+            });
+            // Persist to log list, cap at 2000
+            rawRedis.lpush(logKey, entry).then(() => {
+                rawRedis.ltrim(logKey, 0, 1999).catch(() => { });
+            }).catch((err) => {
+                console.warn(`[meta-agent-manager] log lpush failed (ns=${ns}):`, err.message);
+            });
+        };
         proc.stdout.on("data", (chunk) => {
-            lineBuffer += chunk.toString();
+            const chunkStr = chunk.toString();
+            // Stream raw chunk to Redis (before line-splitting)
+            streamToRedis(chunkStr);
+            lineBuffer += chunkStr;
             const lines = lineBuffer.split("\n");
             lineBuffer = lines.pop() ?? "";
             for (const line of lines) {
@@ -194,9 +226,10 @@ export function createMetaAgentManager() {
             const wsPath = workspacePath(ns);
             injectMcp(ns, wsPath, token);
         },
-        startPolling(wire, getNamespaces) {
+        startPolling(wire, getNamespaces, instanceId) {
             if (pollInterval)
                 return; // already running
+            const INSTANCE_KEY = "cca:discord:instance";
             pollInterval = setInterval(() => {
                 const namespaces = getNamespaces();
                 if (namespaces.length === 0)
@@ -208,6 +241,19 @@ export function createMetaAgentManager() {
                         .then(async (msg) => {
                         if (!msg)
                             return;
+                        // Staleness check: if a newer instance has registered, this process is stale — exit.
+                        if (instanceId) {
+                            try {
+                                const current = await wire._redis.get(INSTANCE_KEY);
+                                if (current && current !== instanceId) {
+                                    console.log(`[meta-agent-manager] stale instance detected (current=${current}, ours=${instanceId}) — exiting`);
+                                    process.exit(0);
+                                }
+                            }
+                            catch {
+                                // Redis error — proceed anyway
+                            }
+                        }
                         const content = typeof msg === "string" ? msg : msg.content ?? String(msg);
                         activeNamespaces.add(ns);
                         await wire.discord.setStatus(ns, {

package/dist/notifier.js

@@ -10,9 +10,53 @@
  *   cca:discord:chat:log:{ns}           — LPUSH + LTRIM 0 499 (last 500 messages)
  *   cca:discord:chat:outgoing:{ns}      — PUBLISH for web UI to consume
  */
+import { createHash } from "crypto";
 import { discordChatLog, discordChatOutgoing, discordNotify, notifyChannel, chatIncomingChannel, createCcWire, TIMING, } from "@gonzih/cc-wire";
 import { splitLongMessage, stripAnsi } from "./formatter.js";
 import { parseEvalReport } from "./loop-manager.js";
+/** Redis key for per-namespace notification dedup set */
+function dedupKey(ns) {
+    return `cca:discord:sent:${ns}`;
+}
+/** Compute a short stable dedup fingerprint for a raw notification string */
+function notifFingerprint(raw) {
+    return createHash("sha256").update(raw.slice(0, 500)).digest("hex").slice(0, 16);
+}
+/**
+ * Check whether this notification has already been forwarded for `ns` (Redis-backed dedup).
+ * If not, records it (SADD + EXPIRE 120s) and returns false (not a dup).
+ * Returns true if it's a duplicate and should be skipped.
+ */
+async function checkAndMarkSent(redis, ns, raw) {
+    const key = dedupKey(ns);
+    const fp = notifFingerprint(raw);
+    // SADD returns 1 if the element was added (new), 0 if already existed (dup)
+    const added = await redis.sadd(key, fp);
+    if (added === 0)
+        return true; // duplicate
+    // Set/refresh the TTL on the set key
+    await redis.expire(key, 120);
+    return false;
+}
+/**
+ * In-memory dedup cache for pub/sub notifications (avoids async overhead on hot path).
+ * Maps fingerprint → expiry timestamp. Entries expire after 120 seconds.
+ */
+const inMemoryDedupCache = new Map();
+const IN_MEMORY_DEDUP_TTL_MS = 120_000;
+function checkAndMarkSentSync(ns, raw) {
+    const fp = `${ns}:${notifFingerprint(raw)}`;
+    const now = Date.now();
+    // Evict expired entries (keep cache small)
+    for (const [k, exp] of inMemoryDedupCache) {
+        if (now > exp)
+            inMemoryDedupCache.delete(k);
+    }
+    if (inMemoryDedupCache.has(fp))
+        return true; // duplicate
+    inMemoryDedupCache.set(fp, now + IN_MEMORY_DEDUP_TTL_MS);
+    return false;
+}
 function log(level, ...args) {
     const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
     fn("[notifier]", ...args);
@@ -292,6 +336,25 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             const notification = parseNotification(raw);
             if (notification === null)
                 continue; // routing excludes discord
+            // Dedup: skip if this notification was already forwarded recently
+            // Uses Redis when available; falls back to in-memory dedup on Redis errors.
+            let isDup = false;
+            try {
+                if (typeof redis.sadd === "function") {
+                    isDup = await checkAndMarkSent(redis, ns, raw);
+                }
+                else {
+                    isDup = checkAndMarkSentSync(ns, raw);
+                }
+            }
+            catch (err) {
+                log("warn", `dedup check failed (ns=${ns}), falling back to in-memory:`, err.message);
+                isDup = checkAndMarkSentSync(ns, raw);
+            }
+            if (isDup) {
+                log("info", `dedup: skipping already-sent notification (ns=${ns})`);
+                continue;
+            }
             // Primary namespace: honour chatId-based per-channel routing via reverseSnowflakeLookup,
             // then namespace → channelId lookup, then notifyChannelId / active channel.
             // Routed namespaces: always deliver to the registered Discord channelId — no leakage.
@@ -348,6 +411,11 @@ export function startNotifier(bot, notifyChannelId, namespace, redis, handleUser
             const notification = parseNotification(message);
             if (notification === null)
                 return; // routing excludes discord
+            // Synchronous in-memory dedup — keeps pub/sub handler synchronous
+            if (checkAndMarkSentSync(ns, message)) {
+                log("info", `dedup: skipping already-sent pub/sub notification (ns=${ns})`);
+                return;
+            }
             let mainChannelId;
             if (isPrimary) {
                 mainChannelId = resolveNotifyChannel(notification.chatId, notifyChannelId, getActiveChannelId, reverseSnowflakeLookup, ns, getChannelIdForNamespace);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.15",
+  "version": "0.2.17",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {