@gonzih/cc-discord 0.1.0

package/dist/claude.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Claude Code subprocess wrapper.
+ * Mirrors ce_ce's mechanism: spawn `claude` CLI with stream-json I/O,
+ * pipe prompts in, parse streaming JSON messages out.
+ */
+import { EventEmitter } from "events";
+export type MessageType = "system" | "assistant" | "user" | "result";
+export interface ClaudeMessage {
+    type: MessageType;
+    session_id?: string;
+    uuid?: string;
+    payload: Record<string, unknown>;
+    raw: Record<string, unknown>;
+}
+export interface ClaudeOptions {
+    cwd?: string;
+    systemPrompt?: string;
+    /** OAuth token (sk-ant-oat01-...) or API key (sk-ant-api03-...) */
+    token?: string;
+}
+export interface UsageEvent {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
+}
+export declare interface ClaudeProcess {
+    on(event: "message", listener: (msg: ClaudeMessage) => void): this;
+    on(event: "usage", listener: (usage: UsageEvent) => void): this;
+    on(event: "error", listener: (err: Error) => void): this;
+    on(event: "exit", listener: (code: number | null) => void): this;
+    on(event: "stderr", listener: (data: string) => void): this;
+}
+export declare class ClaudeProcess extends EventEmitter {
+    private proc;
+    private buffer;
+    private _exited;
+    constructor(opts?: ClaudeOptions);
+    sendPrompt(text: string): void;
+    /**
+     * Send an image (with optional text caption) to Claude via stream-json content blocks.
+     * mediaType: image/jpeg | image/png | image/gif | image/webp
+     */
+    sendImage(base64Data: string, mediaType: string, caption?: string): void;
+    kill(): void;
+    get exited(): boolean;
+    private drainBuffer;
+    private parseMessage;
+}
+/**
+ * Extract the text content from an assistant message payload.
+ * Handles both simple string content and content-block arrays.
+ */
+export declare function extractText(msg: ClaudeMessage): string;

package/dist/claude.js

@@ -0,0 +1,208 @@
+/**
+ * Claude Code subprocess wrapper.
+ * Mirrors ce_ce's mechanism: spawn `claude` CLI with stream-json I/O,
+ * pipe prompts in, parse streaming JSON messages out.
+ */
+import { spawn } from "child_process";
+import { EventEmitter } from "events";
+import { existsSync } from "fs";
+export class ClaudeProcess extends EventEmitter {
+    proc;
+    buffer = "";
+    _exited = false;
+    constructor(opts = {}) {
+        super();
+        const args = [
+            "--continue",
+            "--output-format", "stream-json",
+            "--input-format", "stream-json",
+            "--print",
+            "--verbose",
+            "--dangerously-skip-permissions",
+        ];
+        if (opts.systemPrompt) {
+            args.push("--system-prompt", opts.systemPrompt);
+        }
+        const env = { ...process.env };
+        if (opts.token) {
+            // API keys start with sk-ant-api — set ANTHROPIC_API_KEY only
+            // Everything else (OAuth sk-ant-oat, setup-token format with #, etc.)
+            // goes into CLAUDE_CODE_OAUTH_TOKEN
+            // Mixing them causes "Invalid API key" errors
+            if (opts.token.startsWith("sk-ant-api")) {
+                env.ANTHROPIC_API_KEY = opts.token;
+                delete env.CLAUDE_CODE_OAUTH_TOKEN;
+            }
+            else {
+                env.CLAUDE_CODE_OAUTH_TOKEN = opts.token;
+                delete env.ANTHROPIC_API_KEY;
+            }
+        }
+        // Resolve claude binary — check common install locations if not in PATH
+        const claudeBin = resolveClaude(env.PATH);
+        this.proc = spawn(claudeBin, args, {
+            cwd: opts.cwd ?? process.cwd(),
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        this.proc.stdout.on("data", (chunk) => {
+            this.buffer += chunk.toString();
+            this.drainBuffer();
+        });
+        this.proc.stderr.on("data", (chunk) => {
+            this.emit("stderr", chunk.toString());
+        });
+        this.proc.on("exit", (code) => {
+            this._exited = true;
+            this.emit("exit", code);
+        });
+        this.proc.on("error", (err) => {
+            this.emit("error", err);
+        });
+    }
+    sendPrompt(text) {
+        if (this._exited)
+            throw new Error("Claude process has exited");
+        const payload = JSON.stringify({
+            type: "user",
+            message: { role: "user", content: text },
+        });
+        this.proc.stdin.write(payload + "\n");
+    }
+    /**
+     * Send an image (with optional text caption) to Claude via stream-json content blocks.
+     * mediaType: image/jpeg | image/png | image/gif | image/webp
+     */
+    sendImage(base64Data, mediaType, caption) {
+        if (this._exited)
+            throw new Error("Claude process has exited");
+        const content = [];
+        if (caption) {
+            content.push({ type: "text", text: caption });
+        }
+        content.push({
+            type: "image",
+            source: {
+                type: "base64",
+                media_type: mediaType,
+                data: base64Data,
+            },
+        });
+        const payload = JSON.stringify({
+            type: "user",
+            message: { role: "user", content },
+        });
+        this.proc.stdin.write(payload + "\n");
+    }
+    kill() {
+        this.proc.kill();
+    }
+    get exited() {
+        return this._exited;
+    }
+    drainBuffer() {
+        const lines = this.buffer.split("\n");
+        // Last element may be incomplete — keep it
+        this.buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let raw;
+            try {
+                raw = JSON.parse(line);
+            }
+            catch {
+                // Non-JSON line (startup noise etc.) — ignore
+                continue;
+            }
+            // Emit usage events from Anthropic API stream events passed through by Claude CLI
+            if (raw.type === "message_start") {
+                const usage = (raw.message?.usage);
+                if (usage) {
+                    this.emit("usage", {
+                        inputTokens: usage.input_tokens ?? 0,
+                        outputTokens: 0, // output_tokens at message_start is always 0
+                        cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+                        cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+                    });
+                }
+            }
+            else if (raw.type === "message_delta") {
+                const usage = raw.usage;
+                if (usage?.output_tokens) {
+                    this.emit("usage", {
+                        inputTokens: 0,
+                        outputTokens: usage.output_tokens,
+                        cacheReadTokens: 0,
+                        cacheWriteTokens: 0,
+                    });
+                }
+            }
+            const msg = this.parseMessage(raw);
+            if (msg)
+                this.emit("message", msg);
+        }
+    }
+    parseMessage(raw) {
+        const type = raw.type;
+        if (!type)
+            return null;
+        return {
+            type,
+            session_id: raw.session_id,
+            uuid: raw.uuid,
+            payload: raw,
+            raw,
+        };
+    }
+}
+/**
+ * Extract the text content from an assistant message payload.
+ * Handles both simple string content and content-block arrays.
+ */
+export function extractText(msg) {
+    const message = msg.payload.message;
+    if (!message) {
+        // result message type
+        if (msg.type === "result") {
+            return msg.payload.result ?? "";
+        }
+        return "";
+    }
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("");
+    }
+    return "";
+}
+/**
+ * Resolve the claude CLI binary path.
+ * Checks PATH entries + common npm global install locations.
+ */
+function resolveClaude(pathEnv) {
+    // Try PATH entries first
+    const dirs = (pathEnv ?? process.env.PATH ?? "").split(":");
+    for (const dir of dirs) {
+        const candidate = `${dir}/claude`;
+        if (existsSync(candidate))
+            return candidate;
+    }
+    // Common fallback locations
+    const fallbacks = [
+        `${process.env.HOME}/.npm-global/bin/claude`,
+        "/opt/homebrew/bin/claude",
+        "/usr/local/bin/claude",
+        "/usr/bin/claude",
+    ];
+    for (const p of fallbacks) {
+        if (existsSync(p))
+            return p;
+    }
+    // Last resort — let the OS resolve it (will throw ENOENT if missing)
+    return "claude";
+}

package/dist/cron.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Cron job manager for cc-tg.
+ * Persists jobs to <cwd>/.cc-tg/crons.json.
+ * Fires prompts into Claude sessions on schedule.
+ */
+export interface CronJob {
+    id: string;
+    chatId: number;
+    intervalMs: number;
+    prompt: string;
+    createdAt: string;
+    schedule: string;
+}
+/** Called when a job fires. `done` must be called when the task completes so
+ *  the next scheduled tick is allowed to run. Until `done` is called, concurrent
+ *  ticks for the same job are silently skipped (prevents the resume-loop explosion
+ *  where each tick spawns more agents than the last). */
+type FireCallback = (chatId: number, prompt: string, jobId: string, done: () => void) => void;
+export declare class CronManager {
+    private jobs;
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    private activeJobs;
+    private storePath;
+    private fire;
+    constructor(cwd: string, fire: FireCallback);
+    /** Parse "every 30m", "every 2h", "every 1d" → ms */
+    static parseSchedule(schedule: string): number | null;
+    add(chatId: number, schedule: string, prompt: string): CronJob | null;
+    remove(chatId: number, id: string): boolean;
+    clearAll(chatId: number): number;
+    list(chatId: number): CronJob[];
+    update(chatId: number, id: string, updates: {
+        schedule?: string;
+        prompt?: string;
+    }): CronJob | null | false;
+    private persist;
+    private load;
+}
+export {};

package/dist/cron.js

@@ -0,0 +1,148 @@
+/**
+ * Cron job manager for cc-tg.
+ * Persists jobs to <cwd>/.cc-tg/crons.json.
+ * Fires prompts into Claude sessions on schedule.
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { join } from "path";
+export class CronManager {
+    jobs = new Map();
+    /** Job IDs whose fire callback has been invoked but whose `done` hasn't fired yet. */
+    activeJobs = new Set();
+    storePath;
+    fire;
+    constructor(cwd, fire) {
+        this.storePath = join(cwd, ".cc-tg", "crons.json");
+        this.fire = fire;
+        this.load();
+    }
+    /** Parse "every 30m", "every 2h", "every 1d" → ms */
+    static parseSchedule(schedule) {
+        const m = schedule.trim().match(/^every\s+(\d+)(m|h|d)$/i);
+        if (!m)
+            return null;
+        const n = parseInt(m[1]);
+        const unit = m[2].toLowerCase();
+        if (unit === "m")
+            return n * 60_000;
+        if (unit === "h")
+            return n * 3_600_000;
+        if (unit === "d")
+            return n * 86_400_000;
+        return null;
+    }
+    add(chatId, schedule, prompt) {
+        const intervalMs = CronManager.parseSchedule(schedule);
+        if (!intervalMs)
+            return null;
+        const id = `${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const job = { id, chatId, intervalMs, prompt, schedule, createdAt: new Date().toISOString() };
+        const timer = setInterval(() => {
+            if (this.activeJobs.has(id)) {
+                console.log(`[cron:${id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(id);
+            console.log(`[cron:${id}] firing for chat=${chatId} prompt="${prompt}"`);
+            this.fire(chatId, prompt, id, () => { this.activeJobs.delete(id); });
+        }, intervalMs);
+        this.jobs.set(id, { ...job, timer });
+        this.persist();
+        return job;
+    }
+    remove(chatId, id) {
+        const job = this.jobs.get(id);
+        if (!job || job.chatId !== chatId)
+            return false;
+        clearInterval(job.timer);
+        this.activeJobs.delete(id);
+        this.jobs.delete(id);
+        this.persist();
+        return true;
+    }
+    clearAll(chatId) {
+        let count = 0;
+        for (const [id, job] of this.jobs) {
+            if (job.chatId === chatId) {
+                clearInterval(job.timer);
+                this.activeJobs.delete(id);
+                this.jobs.delete(id);
+                count++;
+            }
+        }
+        if (count)
+            this.persist();
+        return count;
+    }
+    list(chatId) {
+        return [...this.jobs.values()]
+            .filter((j) => j.chatId === chatId)
+            .map(({ timer: _t, ...j }) => j);
+    }
+    update(chatId, id, updates) {
+        const job = this.jobs.get(id);
+        if (!job || job.chatId !== chatId)
+            return false;
+        if (updates.schedule !== undefined) {
+            const intervalMs = CronManager.parseSchedule(updates.schedule);
+            if (!intervalMs)
+                return null;
+            job.intervalMs = intervalMs;
+            job.schedule = updates.schedule;
+        }
+        if (updates.prompt !== undefined) {
+            job.prompt = updates.prompt;
+        }
+        // Recreate timer so it uses updated intervalMs and always reads latest job.prompt
+        clearInterval(job.timer);
+        // Also clear any active-job lock so the updated timer can fire immediately next tick
+        this.activeJobs.delete(job.id);
+        job.timer = setInterval(() => {
+            if (this.activeJobs.has(job.id)) {
+                console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                return;
+            }
+            this.activeJobs.add(job.id);
+            console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+            this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
+        }, job.intervalMs);
+        this.persist();
+        const { timer: _t, ...cronJob } = job;
+        return cronJob;
+    }
+    persist() {
+        try {
+            const dir = join(this.storePath, "..");
+            if (!existsSync(dir))
+                mkdirSync(dir, { recursive: true });
+            const data = [...this.jobs.values()].map(({ timer: _t, ...j }) => j);
+            writeFileSync(this.storePath, JSON.stringify(data, null, 2));
+        }
+        catch (err) {
+            console.error("[cron] persist error:", err.message);
+        }
+    }
+    load() {
+        if (!existsSync(this.storePath))
+            return;
+        try {
+            const data = JSON.parse(readFileSync(this.storePath, "utf8"));
+            for (const job of data) {
+                const timer = setInterval(() => {
+                    if (this.activeJobs.has(job.id)) {
+                        console.log(`[cron:${job.id}] skipping tick — previous task still running`);
+                        return;
+                    }
+                    this.activeJobs.add(job.id);
+                    console.log(`[cron:${job.id}] firing for chat=${job.chatId} prompt="${job.prompt}"`);
+                    this.fire(job.chatId, job.prompt, job.id, () => { this.activeJobs.delete(job.id); });
+                }, job.intervalMs);
+                this.jobs.set(job.id, { ...job, timer });
+            }
+            console.log(`[cron] loaded ${data.length} jobs from disk`);
+        }
+        catch (err) {
+            console.error("[cron] load error:", err.message);
+        }
+    }
+}

package/dist/formatter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Discord markdown post-processor.
+ * Discord renders standard markdown natively — no HTML escaping needed.
+ * Headings become bold, lists use bullet characters.
+ */
+/**
+ * Convert standard markdown text to Discord-friendly format.
+ *
+ * Discord renders most markdown natively (bold, italic, code blocks).
+ * We only need to:
+ * 1. Preserve fenced code blocks (``` ... ```) — Discord renders them
+ * 2. Preserve inline code (`...`) — Discord renders it
+ * 3. Convert ## headings → **Heading**
+ * 4. Convert --- → blank line
+ * 5. Leave **bold**, *italic*, _italic_ as-is (Discord handles them)
+ */
+export declare function formatForDiscord(text: string): string;
+/**
+ * Split a long message at natural boundaries (paragraph > line > word).
+ * Never splits inside code blocks. Chunks are at most maxLen characters.
+ * Discord's limit is 2000 characters.
+ */
+export declare function splitLongMessage(text: string, maxLen?: number): string[];
+/** Strip ANSI escape sequences from a string before sending to Discord. */
+export declare function stripAnsi(text: string): string;

package/dist/formatter.js

@@ -0,0 +1,100 @@
+/**
+ * Discord markdown post-processor.
+ * Discord renders standard markdown natively — no HTML escaping needed.
+ * Headings become bold, lists use bullet characters.
+ */
+/**
+ * Convert standard markdown text to Discord-friendly format.
+ *
+ * Discord renders most markdown natively (bold, italic, code blocks).
+ * We only need to:
+ * 1. Preserve fenced code blocks (``` ... ```) — Discord renders them
+ * 2. Preserve inline code (`...`) — Discord renders it
+ * 3. Convert ## headings → **Heading**
+ * 4. Convert --- → blank line
+ * 5. Leave **bold**, *italic*, _italic_ as-is (Discord handles them)
+ */
+export function formatForDiscord(text) {
+    const placeholders = [];
+    // Step 1: Extract fenced code blocks — protect from further processing
+    let out = text.replace(/```(?:\w*)\n?([\s\S]*?)```/g, (match) => {
+        placeholders.push(match);
+        return `\x00P${placeholders.length - 1}\x00`;
+    });
+    // Step 2: Extract inline code — protect from further processing
+    out = out.replace(/`([^`\n]+)`/g, (match) => {
+        placeholders.push(match);
+        return `\x00P${placeholders.length - 1}\x00`;
+    });
+    // Step 3: Convert --- → blank line
+    out = out.replace(/^-{3,}$/gm, "");
+    // Step 4: Convert ## headings → **Heading**
+    out = out.replace(/^#{1,6}\s+(.+)$/gm, "**$1**");
+    // Step 5: Reinsert code blocks/inline code
+    out = out.replace(/\x00P(\d+)\x00/g, (_, i) => placeholders[parseInt(i, 10)]);
+    return out;
+}
+function findCodeBlockRanges(text) {
+    const ranges = [];
+    const re = /```[\s\S]*?```/g;
+    let m;
+    while ((m = re.exec(text)) !== null) {
+        ranges.push([m.index, m.index + m[0].length]);
+    }
+    return ranges;
+}
+function isInsideCodeBlock(pos, ranges) {
+    return ranges.some(([start, end]) => pos > start && pos < end);
+}
+/**
+ * Split a long message at natural boundaries (paragraph > line > word).
+ * Never splits inside code blocks. Chunks are at most maxLen characters.
+ * Discord's limit is 2000 characters.
+ */
+export function splitLongMessage(text, maxLen = 2000) {
+    if (text.length <= maxLen)
+        return [text];
+    const chunks = [];
+    let remaining = text;
+    while (remaining.length > maxLen) {
+        const slice = remaining.slice(0, maxLen);
+        const codeRanges = findCodeBlockRanges(remaining);
+        // Prefer paragraph boundary (\n\n)
+        const lastPara = slice.lastIndexOf("\n\n");
+        // Then line boundary (\n)
+        const lastLine = slice.lastIndexOf("\n");
+        // Then word boundary (space)
+        const lastSpace = slice.lastIndexOf(" ");
+        let splitAt;
+        if (lastPara > 0 && !isInsideCodeBlock(lastPara, codeRanges)) {
+            splitAt = lastPara + 2;
+        }
+        else if (lastLine > 0 && !isInsideCodeBlock(lastLine, codeRanges)) {
+            splitAt = lastLine + 1;
+        }
+        else if (lastSpace > 0 && !isInsideCodeBlock(lastSpace, codeRanges)) {
+            splitAt = lastSpace + 1;
+        }
+        else {
+            // If all candidate split points are inside a code block, split after it
+            const coveringBlock = codeRanges.find(([start, end]) => start < maxLen && end > maxLen);
+            if (coveringBlock) {
+                splitAt = coveringBlock[1];
+            }
+            else {
+                splitAt = maxLen;
+            }
+        }
+        chunks.push(remaining.slice(0, splitAt).trimEnd());
+        remaining = remaining.slice(splitAt).trimStart();
+    }
+    if (remaining.length > 0) {
+        chunks.push(remaining);
+    }
+    return chunks;
+}
+/** Strip ANSI escape sequences from a string before sending to Discord. */
+export function stripAnsi(text) {
+    // eslint-disable-next-line no-control-regex
+    return text.replace(/\x1B\[[0-9;]*[mGKHF]/g, "");
+}

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+#!/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)
+ */
+export {};