@gonzih/cc-discord 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,107 +0,0 @@
-#!/usr/bin/env node
-/**
- * cc-discord — Claude Code Discord bot
- *
- * Usage:
- *   npx @gonzih/cc-discord
- *
- * Required env:
- *   DISCORD_BOT_TOKEN          — from Discord Developer Portal
- *   CLAUDE_CODE_OAUTH_TOKEN    — your Claude Code OAuth token (or ANTHROPIC_API_KEY)
- *
- * Optional env:
- *   DISCORD_GUILD_IDS          — comma-separated Discord guild/server IDs (for instant slash command registration)
- *   DISCORD_ALLOWED_USER_IDS   — comma-separated Discord user IDs to whitelist (leave empty to allow all)
- *   DISCORD_NOTIFY_CHANNEL_ID  — Discord channel ID for job notifications
- *   CC_AGENT_NAMESPACE         — cc-agent namespace (default: money-brain)
- *   REDIS_URL                  — Redis connection URL (default: redis://localhost:6379)
- *   CWD                        — working directory for Claude Code (default: process.cwd())
- *   DEFAULT_GITHUB_ORG         — default GitHub org for #repo routing (default: gonzih)
- */
-import { Redis } from "ioredis";
-import { CcDiscordBot } from "./bot.js";
-import { startNotifier } from "./notifier.js";
-import { loadTokens } from "./tokens.js";
-function required(name) {
-    const val = process.env[name];
-    if (!val) {
-        console.error(`
-ERROR: ${name} is not set.
-
-cc-discord requires:
-  DISCORD_BOT_TOKEN         — create a bot at https://discord.com/developers/applications
-  CLAUDE_CODE_OAUTH_TOKEN   — your Claude Code OAuth token
-
-Set them and run again:
-  DISCORD_BOT_TOKEN=xxx CLAUDE_CODE_OAUTH_TOKEN=yyy npx @gonzih/cc-discord
-`);
-        process.exit(1);
-    }
-    return val;
-}
-const discordToken = required("DISCORD_BOT_TOKEN");
-const claudeToken = process.env.CLAUDE_CODE_TOKEN ??
-    process.env.CLAUDE_CODE_OAUTH_TOKEN ??
-    process.env.ANTHROPIC_API_KEY;
-if (!claudeToken) {
-    console.error(`
-ERROR: No Claude token set. Set one of: CLAUDE_CODE_TOKEN, CLAUDE_CODE_OAUTH_TOKEN, or ANTHROPIC_API_KEY.
-`);
-    process.exit(1);
-}
-// Load OAuth token pool
-const tokenPool = loadTokens();
-if (tokenPool.length > 1) {
-    console.log(`[cc-discord] Token pool loaded: ${tokenPool.length} tokens`);
-}
-const guildIds = process.env.DISCORD_GUILD_IDS
-    ? process.env.DISCORD_GUILD_IDS.split(",").map((s) => s.trim()).filter(Boolean)
-    : [];
-const allowedUserIds = process.env.DISCORD_ALLOWED_USER_IDS
-    ? process.env.DISCORD_ALLOWED_USER_IDS.split(",").map((s) => s.trim()).filter(Boolean)
-    : [];
-const cwd = process.env.CWD ?? process.cwd();
-const redisUrl = process.env.REDIS_URL || "redis://localhost:6379";
-const namespace = process.env.CC_AGENT_NAMESPACE || "money-brain";
-const notifyChannelId = process.env.DISCORD_NOTIFY_CHANNEL_ID ?? null;
-// Redis
-const sharedRedis = new Redis(redisUrl);
-sharedRedis.on("error", (err) => {
-    console.warn("[redis] connection error:", err.message);
-});
-sharedRedis.once("ready", () => {
-    // Announce this version on Redis so other services can discover cc-discord
-    sharedRedis.set(`cca:meta:cc-discord:version`, "0.1.0").catch((err) => {
-        console.warn("[redis] failed to write version:", err.message);
-    });
-    console.log("[cc-discord] version:reported 0.1.0");
-});
-// Mutable placeholder closures — filled in once `bot` is created below
-let getLastActiveChannelIdFn = () => undefined;
-let handleUserMessageFn;
-let forwardNotificationFn;
-const bot = new CcDiscordBot({
-    discordToken,
-    claudeToken,
-    cwd,
-    allowedUserIds,
-    guildIds,
-    redis: sharedRedis,
-    namespace,
-    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());
-console.log(`[notifier] started for namespace=${namespace} notifyChannelId=${notifyChannelId ?? "dynamic"}`);
-// Wire closures now that bot is constructed
-getLastActiveChannelIdFn = () => bot.getLastActiveChannelId();
-handleUserMessageFn = (channelId, text) => { void bot.handleUserMessage(channelId, text); };
-forwardNotificationFn = (channelId, text) => { bot.forwardNotification(channelId, text); };
-process.on("SIGINT", () => {
-    console.log("\nShutting down...");
-    bot.stop();
-    process.exit(0);
-});
-process.on("SIGTERM", () => {
-    bot.stop();
-    process.exit(0);
-});

package/dist/notifier.d.ts

@@ -1,53 +0,0 @@
-/**
- * DiscordNotifier — subscribes to Redis pub/sub channels and bridges messages to Discord.
- *
- * Channels:
- *   cca:notify:{namespace}        — job completion notifications from cc-agent → forward to DISCORD_NOTIFY_CHANNEL_ID
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Discord + feed into Claude session
- *   cca:chat:outgoing:*           — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
- *
- * All messages (Discord incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}      — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
- */
-import { Redis } from "ioredis";
-import type { CcDiscordBot } from "./bot.js";
-export interface ChatMessage {
-    id: string;
-    source: "discord" | "ui" | "claude" | "cc-tg";
-    role: "user" | "assistant" | "tool";
-    content: string;
-    timestamp: string;
-    chatId: number;
-}
-/**
- * Parse a notification payload and return the display text.
- * Appends a [driver] or [driver:model] badge whenever the driver field is present.
- * Appends " cost: $X.XXX" if a numeric cost field is present.
- */
-export declare function parseNotification(raw: string): string;
-/**
- * Write a message to the chat log in Redis.
- * Fire-and-forget — errors are logged but not thrown.
- */
-export declare function writeChatLog(redis: Redis, namespace: string, msg: ChatMessage): void;
-export interface NotifierHandle {
-    /**
-     * Register the originating Discord channel ID for a routed namespace.
-     * When the meta-agent for `namespace` publishes a response, it will be
-     * forwarded to `channelId`.
-     */
-    registerRoutedChannelId: (namespace: string, channelId: string) => void;
-}
-/**
- * Start the Discord notifier.
- *
- * @param bot               - CcDiscordBot instance (for sending messages)
- * @param notifyChannelId   - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace         - cc-agent namespace (used to build Redis channel names)
- * @param redis             - ioredis client in normal mode (will be duplicated for pub/sub)
- * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
- * @param forwardNotification - Optional callback to forward job notifications
- * @param getActiveChannelId  - Optional callback to resolve channelId dynamically
- */
-export declare function startNotifier(bot: CcDiscordBot, notifyChannelId: string | null, namespace: string, redis: Redis, handleUserMessage?: (channelId: string, text: string) => void, forwardNotification?: (channelId: string, text: string) => void, getActiveChannelId?: () => string | undefined): NotifierHandle;

package/dist/notifier.js

@@ -1,315 +0,0 @@
-/**
- * DiscordNotifier — subscribes to Redis pub/sub channels and bridges messages to Discord.
- *
- * Channels:
- *   cca:notify:{namespace}        — job completion notifications from cc-agent → forward to DISCORD_NOTIFY_CHANNEL_ID
- *   cca:chat:incoming:{namespace} — messages from the web UI → echo to Discord + feed into Claude session
- *   cca:chat:outgoing:*           — meta-agent stdout lines (source=claude) → buffer+debounce → Discord
- *
- * All messages (Discord incoming, Claude responses) are also written to:
- *   cca:chat:log:{namespace}      — LPUSH + LTRIM 0 499 (last 500 messages)
- *   cca:chat:outgoing:{namespace} — PUBLISH for web UI to consume
- */
-import { chatLogKey, chatOutgoingChannel, chatIncomingChannel, notifyChannel, metaAgentStatusKey, metaInputKey, } from "@gonzih/cc-wire";
-import { splitLongMessage, stripAnsi } from "./formatter.js";
-function log(level, ...args) {
-    const fn = level === "error" ? console.error : level === "warn" ? console.warn : console.log;
-    fn("[notifier]", ...args);
-}
-/**
- * Shorten a model name for display in a badge.
- */
-function shortenModelName(model, driver) {
-    if (!model.trim())
-        return "";
-    const pfx = driver.toLowerCase() + "-";
-    if (model.toLowerCase().startsWith(pfx))
-        return model.slice(pfx.length);
-    const slashIdx = model.indexOf("/");
-    if (slashIdx >= 0)
-        return model.slice(slashIdx + 1);
-    return model;
-}
-/**
- * Parse a notification payload and return the display text.
- * Appends a [driver] or [driver:model] badge whenever the driver field is present.
- * Appends " cost: $X.XXX" if a numeric cost field is present.
- */
-export function parseNotification(raw) {
-    let text = raw;
-    let driver;
-    let model;
-    let cost;
-    try {
-        const parsed = JSON.parse(raw);
-        if (parsed.text)
-            text = parsed.text;
-        driver = parsed.driver;
-        model = parsed.model;
-        if (typeof parsed.cost === "number")
-            cost = parsed.cost;
-    }
-    catch {
-        return text;
-    }
-    if (!driver)
-        return text;
-    const shortModel = shortenModelName(model ?? "", driver);
-    const badge = shortModel ? `${driver}:${shortModel}` : driver;
-    const costStr = cost != null ? ` cost: $${cost.toFixed(3)}` : "";
-    return `${text}\n[${badge}]${costStr}`;
-}
-/**
- * Write a message to the chat log in Redis.
- * Fire-and-forget — errors are logged but not thrown.
- */
-export function writeChatLog(redis, namespace, msg) {
-    const logKey = chatLogKey(namespace);
-    const outKey = chatOutgoingChannel(namespace);
-    const payload = JSON.stringify(msg);
-    redis.lpush(logKey, payload).catch((err) => {
-        log("warn", "writeChatLog lpush failed:", err.message);
-    });
-    redis.ltrim(logKey, 0, 499).catch((err) => {
-        log("warn", "writeChatLog ltrim failed:", err.message);
-    });
-    redis.publish(outKey, payload).catch((err) => {
-        log("warn", "writeChatLog publish failed:", err.message);
-    });
-}
-/**
- * Start the Discord notifier.
- *
- * @param bot               - CcDiscordBot instance (for sending messages)
- * @param notifyChannelId   - Discord channel ID to forward notifications to. Pass null to use getActiveChannelId.
- * @param namespace         - cc-agent namespace (used to build Redis channel names)
- * @param redis             - ioredis client in normal mode (will be duplicated for pub/sub)
- * @param handleUserMessage - Optional callback to feed UI messages into the active Claude session
- * @param forwardNotification - Optional callback to forward job notifications
- * @param getActiveChannelId  - Optional callback to resolve channelId dynamically
- */
-export function startNotifier(bot, notifyChannelId, namespace, redis, handleUserMessage, forwardNotification, getActiveChannelId) {
-    // Per-namespace channelId registry
-    const routedChannelIds = new Map();
-    const sub = redis.duplicate({
-        retryStrategy: (times) => {
-            const delay = Math.min(1000 * Math.pow(2, times - 1), 30_000);
-            log("info", `subscriber reconnecting in ${delay}ms (attempt ${times})`);
-            return delay;
-        },
-    });
-    sub.on("error", (err) => {
-        log("warn", "subscriber error:", err.message);
-    });
-    sub.on("close", () => {
-        log("info", "subscriber disconnected, will reconnect with backoff");
-    });
-    // notifyChannel(namespace) — forward job completion notifications to Discord
-    sub.subscribe(notifyChannel(namespace), (err) => {
-        if (err) {
-            log("error", `subscribe ${notifyChannel(namespace)} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to ${notifyChannel(namespace)}`);
-        }
-    });
-    // chatIncomingChannel(namespace) — messages from UI
-    sub.subscribe(chatIncomingChannel(namespace), (err) => {
-        if (err) {
-            log("error", `subscribe ${chatIncomingChannel(namespace)} failed:`, err.message);
-        }
-        else {
-            log("info", `subscribed to ${chatIncomingChannel(namespace)}`);
-        }
-    });
-    // chatOutgoingChannel("*") — meta-agent stdout lines
-    sub.psubscribe(chatOutgoingChannel("*"), (err) => {
-        if (err) {
-            log("error", `psubscribe ${chatOutgoingChannel("*")} failed:`, err.message);
-        }
-        else {
-            log("info", `psubscribed to ${chatOutgoingChannel("*")}`);
-        }
-    });
-    // 1.5s silence buffer for meta-agent streaming
-    const META_AGENT_FLUSH_DELAY_MS = 1500;
-    const metaAgentBuffers = new Map();
-    function flushMetaAgentBuffer(ns, targetChannelId) {
-        const buf = metaAgentBuffers.get(ns);
-        if (!buf || !buf.text.trim())
-            return;
-        const text = `← [${ns}] ` + stripAnsi(buf.text.trim());
-        buf.text = "";
-        buf.timer = null;
-        const chunks = splitLongMessage(text);
-        for (const chunk of chunks) {
-            bot.sendToChannelById(targetChannelId, chunk).catch((err) => {
-                log("warn", `meta-agent flush sendToChannelById failed (ns=${ns}):`, err.message);
-            });
-        }
-    }
-    sub.on("pmessage", (pattern, channel, message) => {
-        void pattern;
-        const ns = channel.slice(chatOutgoingChannel("").length);
-        let parsed = null;
-        try {
-            parsed = JSON.parse(message);
-        }
-        catch {
-            return;
-        }
-        if (parsed.source !== "claude")
-            return;
-        const content = parsed.content;
-        if (!content)
-            return;
-        const targetChannelId = routedChannelIds.get(ns) ?? notifyChannelId ?? getActiveChannelId?.();
-        if (targetChannelId == null) {
-            log("warn", `meta-agent output: no channelId for namespace=${ns}, dropping line`);
-            return;
-        }
-        let buf = metaAgentBuffers.get(ns);
-        if (!buf) {
-            buf = { text: "", timer: null };
-            metaAgentBuffers.set(ns, buf);
-        }
-        buf.text += (buf.text ? "\n" : "") + content;
-        if (buf.timer)
-            clearTimeout(buf.timer);
-        buf.timer = setTimeout(() => flushMetaAgentBuffer(ns, targetChannelId), META_AGENT_FLUSH_DELAY_MS);
-    });
-    // Poll the notifyChannel(namespace) LIST every 5 seconds
-    const notifyListKey = notifyChannel(namespace);
-    const MAX_PER_CYCLE = 20;
-    const pollNotifyList = async () => {
-        const targetId = notifyChannelId ?? getActiveChannelId?.();
-        if (targetId == null)
-            return;
-        const items = [];
-        try {
-            for (let i = 0; i < MAX_PER_CYCLE; i++) {
-                const item = await redis.rpop(notifyListKey);
-                if (item === null)
-                    break;
-                items.push(item);
-            }
-        }
-        catch (err) {
-            log("warn", "notify list rpop failed:", err.message);
-            return;
-        }
-        if (items.length === 0)
-            return;
-        let remaining = 0;
-        if (items.length === MAX_PER_CYCLE) {
-            try {
-                remaining = await redis.llen(notifyListKey);
-            }
-            catch (err) {
-                log("warn", "notify list llen failed:", err.message);
-            }
-        }
-        for (const raw of items) {
-            const text = parseNotification(raw);
-            bot.sendToChannelById(targetId, text).catch((err) => {
-                log("warn", "notify list send failed:", err.message);
-            });
-            if (forwardNotification) {
-                forwardNotification(targetId, text);
-            }
-        }
-        if (remaining > 0) {
-            bot.sendToChannelById(targetId, `...and ${remaining} more notifications`).catch((err) => {
-                log("warn", "notify list summary send failed:", err.message);
-            });
-        }
-    };
-    setInterval(() => {
-        void pollNotifyList();
-    }, 5_000);
-    sub.on("message", (channel, message) => {
-        const notifyCh = notifyChannel(namespace);
-        const incomingCh = chatIncomingChannel(namespace);
-        if (channel === notifyCh) {
-            const targetId = notifyChannelId ?? getActiveChannelId?.();
-            if (targetId != null) {
-                const text = parseNotification(message);
-                bot.sendToChannelById(targetId, text).catch((err) => {
-                    log("warn", "notify send failed:", err.message);
-                });
-                if (forwardNotification) {
-                    forwardNotification(targetId, text);
-                }
-            }
-            else {
-                log("warn", "notify: no channelId available, dropping notification");
-            }
-            return;
-        }
-        if (channel === incomingCh) {
-            let content = message;
-            let originalTimestamp;
-            try {
-                const parsed = JSON.parse(message);
-                if (parsed.content)
-                    content = parsed.content;
-                if (parsed.timestamp)
-                    originalTimestamp = parsed.timestamp;
-            }
-            catch {
-                // raw string message — use as-is
-            }
-            const targetChannelId = notifyChannelId ?? getActiveChannelId?.();
-            if (targetChannelId !== undefined) {
-                // Echo to Discord so the user sees UI messages
-                bot.sendToChannelById(targetChannelId, `[from UI]: ${content}`).catch((err) => {
-                    log("warn", "sendToChannelById (UI echo) failed:", err.message);
-                });
-                // Log the incoming message
-                const inMsg = {
-                    id: crypto.randomUUID(),
-                    source: "ui",
-                    role: "user",
-                    content,
-                    timestamp: originalTimestamp ?? new Date().toISOString(),
-                    chatId: 0, // no numeric chatId for Discord — stored by channelId string
-                };
-                writeChatLog(redis, namespace, inMsg);
-                // Check if a meta-agent is running; if so, route there instead
-                void (async () => {
-                    let routedToMetaAgent = false;
-                    try {
-                        const statusRaw = await redis.get(metaAgentStatusKey(namespace));
-                        if (statusRaw) {
-                            const status = JSON.parse(statusRaw);
-                            if (status.status === "running") {
-                                const entry = JSON.stringify({
-                                    id: crypto.randomUUID(),
-                                    content,
-                                    timestamp: new Date().toISOString(),
-                                });
-                                await redis.rpush(metaInputKey(namespace), entry);
-                                log("info", `cca:chat:incoming: routed to meta-agent for namespace ${namespace}`);
-                                routedToMetaAgent = true;
-                            }
-                        }
-                    }
-                    catch (err) {
-                        log("warn", "meta-agent status check failed:", err.message);
-                    }
-                    if (!routedToMetaAgent && handleUserMessage) {
-                        handleUserMessage(targetChannelId, content);
-                    }
-                })();
-            }
-            else {
-                log("warn", "cca:chat:incoming: no active channelId to route message to");
-            }
-        }
-    });
-    return {
-        registerRoutedChannelId: (ns, channelId) => {
-            routedChannelIds.set(ns, channelId);
-        },
-    };
-}

package/dist/router.d.ts

@@ -1,59 +0,0 @@
-/**
- * Hashtag meta-agent routing.
- *
- * Parses #tag or #org/repo tokens from Telegram messages and routes them to
- * the appropriate cc-agent meta-agent instead of the local Claude session.
- *
- * Tag formats:
- *   #repo-name    → namespace=repo-name, repo=https://github.com/{DEFAULT_GITHUB_ORG}/repo-name (null if DEFAULT_GITHUB_ORG unset)
- *   #org/repo     → namespace=repo,      repo=https://github.com/org/repo
- */
-import { Redis } from "ioredis";
-/** Callback type matching CcTgBot.callCcAgentTool */
-export type CallToolFn = (toolName: string, args?: Record<string, unknown>) => Promise<string | null>;
-export interface RoutingTag {
-    namespace: string;
-    repoUrl: string;
-    /** Original message with the tag token stripped and whitespace collapsed */
-    strippedMessage: string;
-}
-/**
- * Parse the first #tag or #org/repo token from a message.
- * Returns null when no routing tag is present, or when the short #repo format is used
- * without DEFAULT_GITHUB_ORG being set (operators must configure this explicitly).
- *
- * Examples:
- *   "#cc-agent fix the bug"           → null if DEFAULT_GITHUB_ORG unset; { namespace: "cc-agent", repoUrl: "…/{org}/cc-agent", … } if set
- *   "#gonzih/of-stack deploy it"      → { namespace: "of-stack", repoUrl: "…/gonzih/of-stack", … }
- *   "#org/repo do something"          → { namespace: "repo",     repoUrl: "…/org/repo", … }
- *   "please help #of-stack with this" → null if DEFAULT_GITHUB_ORG unset
- */
-export declare function parseRoutingTag(text: string): RoutingTag | null;
-/**
- * Ensure a meta-agent for the given namespace is running.
- *
- * Steps:
- *   1. Check Redis for readiness via two keys (see below) — return early if already ready.
- *   2. Verify the GitHub repo exists; create it (public) if not.
- *   3. Call the start_meta_agent MCP tool via callTool.
- *   4. Poll both Redis keys every 1s until ready or META_AGENT_TIMEOUT_MS expires.
- *
- * Two Redis keys are checked:
- *   cca:meta-agent:status:{namespace} — live-status key written by writeLiveStatus()
- *     (only populated after the first message is processed by messageMetaAgent)
- *   cca:meta:{namespace} — state key written by startMetaAgent() directly via saveState()
- *     (populated as soon as the workspace is created, with status:"idle")
- *
- * Bug context: start_meta_agent writes cca:meta:{namespace} but NOT cca:meta-agent:status:{namespace}.
- * Polling only the status key caused a 10s timeout on every cold start.
- *
- * Throws on failure (repo creation error, tool call failure, or timeout).
- */
-export declare function ensureMetaAgent(namespace: string, repoUrl: string, callTool: CallToolFn, redis: Redis): Promise<void>;
-/**
- * Route a message to a running meta-agent via Redis RPUSH.
- * The cc-agent polls cca:meta:{namespace}:input every 3s (up to 3s delivery latency).
- *
- * No-op when strippedMessage is empty (user sent only the tag token).
- */
-export declare function routeToMetaAgent(namespace: string, strippedMessage: string, redis: Redis): Promise<void>;