@gonzih/cc-discord 0.1.0 → 0.1.2

package/dist/router.js

@@ -1,193 +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 { execSync } from "child_process";
-import { metaAgentStatusKey, metaKey, metaInputKey } from "@gonzih/cc-wire";
-/**
- * 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 function parseRoutingTag(text) {
-    const defaultOrg = process.env.DEFAULT_GITHUB_ORG;
-    // Match #word or #org/repo — each segment: starts with alphanumeric, allows ._- inside
-    const match = text.match(/#([a-zA-Z0-9][a-zA-Z0-9._-]*)(?:\/([a-zA-Z0-9][a-zA-Z0-9._-]*))?/);
-    if (!match)
-        return null;
-    const fullMatch = match[0]; // e.g. "#gonzih/of-stack"
-    const part1 = match[1]; // org-or-repo
-    const part2 = match[2]; // repo (only present in #org/repo format)
-    let namespace;
-    let repoUrl;
-    if (part2) {
-        // #org/repo format
-        namespace = part2;
-        repoUrl = `https://github.com/${part1}/${part2}`;
-    }
-    else {
-        // #repo format — requires DEFAULT_GITHUB_ORG; return null if unset
-        if (!defaultOrg)
-            return null;
-        namespace = part1;
-        repoUrl = `https://github.com/${defaultOrg}/${part1}`;
-    }
-    // Strip the matched tag token and collapse whitespace
-    const strippedMessage = text.replace(fullMatch, "").replace(/\s+/g, " ").trim();
-    return { namespace, repoUrl, strippedMessage };
-}
-/**
- * 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 async function ensureMetaAgent(namespace, repoUrl, callTool, redis) {
-    const timeoutMs = parseInt(process.env.META_AGENT_TIMEOUT_MS ?? "10000", 10);
-    const statusKey = metaAgentStatusKey(namespace);
-    // State key written by startMetaAgent() directly — the source of truth for workspace existence.
-    const stateKey = metaKey(namespace);
-    console.log(`[router] ensureMetaAgent namespace=${namespace}`);
-    // Fast path: check live-status key (written by messageMetaAgent after first message)
-    const statusRaw = await redis.get(statusKey);
-    if (statusRaw) {
-        try {
-            const status = JSON.parse(statusRaw);
-            if (status.status === "running" || status.status === "idle") {
-                console.log(`[router] meta-agent ${namespace} is already ready (status=${status.status})`);
-                return;
-            }
-        }
-        catch {
-            // Corrupt status value — fall through
-        }
-    }
-    // Fast path: also check state key (written by startMetaAgent, persists 30 days).
-    // Presence of this key means the workspace was already created — no need to re-run start_meta_agent.
-    const stateRaw = await redis.get(stateKey);
-    if (stateRaw) {
-        try {
-            const state = JSON.parse(stateRaw);
-            if (state.status === "idle" || state.status === "running") {
-                console.log(`[router] meta-agent ${namespace} workspace exists (state.status=${state.status})`);
-                return;
-            }
-        }
-        catch {
-            // Corrupt state — fall through and re-initialize
-        }
-    }
-    // Derive "org/repo" from the full URL for gh CLI calls
-    const orgRepo = repoUrl.replace(/^https:\/\/github\.com\//, "");
-    // Verify / create the GitHub repo
-    try {
-        execSync(`gh repo view ${orgRepo}`, { stdio: "ignore" });
-    }
-    catch {
-        // Repo not found — create it
-        try {
-            execSync(`gh repo create ${orgRepo} --public --description "Meta-agent workspace for ${namespace}"`, { stdio: "pipe" });
-            console.log(`[router] created repo ${orgRepo} for namespace=${namespace}`);
-        }
-        catch (createErr) {
-            throw new Error(`Failed to create repo ${orgRepo}: ${createErr.message}`);
-        }
-    }
-    // Start the meta-agent via MCP (clones workspace if needed, writes cca:meta:{namespace})
-    const result = await callTool("start_meta_agent", { namespace, repo_url: repoUrl });
-    if (result === null) {
-        throw new Error(`start_meta_agent returned null — tool may not be available in cc-agent`);
-    }
-    // Check for explicit failure payload (e.g. git clone error)
-    try {
-        const parsed = JSON.parse(result);
-        if (parsed.ok === false) {
-            throw new Error(`start_meta_agent failed: ${parsed.error ?? "unknown error"}`);
-        }
-    }
-    catch (jsonErr) {
-        if (!(jsonErr instanceof SyntaxError))
-            throw jsonErr;
-        // Non-JSON result (e.g. plain "ok") — not an error, continue to poll
-    }
-    // Poll until ready. Check both keys:
-    //   - statusKey: written by writeLiveStatus() during messageMetaAgent (may not exist yet on cold start)
-    //   - stateKey:  written by startMetaAgent() above — will appear within 1s of the tool call returning
-    const deadline = Date.now() + timeoutMs;
-    while (Date.now() < deadline) {
-        await new Promise((resolve) => setTimeout(resolve, 1000));
-        const raw = await redis.get(statusKey);
-        if (raw) {
-            try {
-                const s = JSON.parse(raw);
-                console.log(`[router] waiting for meta-agent ${namespace} — status key: ${s.status}`);
-                if (s.status === "running" || s.status === "idle")
-                    return;
-            }
-            catch {
-                // ignore parse errors, keep polling
-            }
-        }
-        // Also check state key — startMetaAgent writes this synchronously before responding
-        const state = await redis.get(stateKey);
-        if (state) {
-            try {
-                const s = JSON.parse(state);
-                console.log(`[router] waiting for meta-agent ${namespace} — state key: ${s.status}`);
-                if (s.status === "idle" || s.status === "running")
-                    return;
-            }
-            catch {
-                // ignore parse errors, keep polling
-            }
-        }
-        else {
-            console.log(`[router] waiting for meta-agent ${namespace} — neither key present yet`);
-        }
-    }
-    throw new Error(`Meta-agent for ${namespace} did not become ready within ${timeoutMs}ms`);
-}
-/**
- * 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 async function routeToMetaAgent(namespace, strippedMessage, redis) {
-    if (!strippedMessage)
-        return;
-    const entry = JSON.stringify({
-        id: crypto.randomUUID(),
-        content: strippedMessage,
-        timestamp: new Date().toISOString(),
-    });
-    // FIFO — cc-agent reads via LPOP
-    await redis.rpush(metaInputKey(namespace), entry);
-    console.log(`[router] routed message to meta-agent namespace=${namespace}`);
-}

package/dist/tokens.d.ts

@@ -1,24 +0,0 @@
-/**
- * OAuth token pool management.
- *
- * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
- * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
- *
- * cc-tg token pool rotates independently from cc-agent's pool. No coordination between them.
- */
-/**
- * Load tokens from env vars. Called on startup; also re-callable in tests.
- * Priority: CLAUDE_CODE_OAUTH_TOKENS > CLAUDE_CODE_OAUTH_TOKEN > (empty)
- */
-export declare function loadTokens(): string[];
-/** Returns the current active token, or empty string if none configured. */
-export declare function getCurrentToken(): string;
-/**
- * Advance to the next token (wraps around).
- * Returns the new current token.
- */
-export declare function rotateToken(): string;
-/** Zero-based index of the current token. */
-export declare function getTokenIndex(): number;
-/** Total number of tokens in the pool. */
-export declare function getTokenCount(): number;

package/dist/tokens.js

@@ -1,58 +0,0 @@
-/**
- * OAuth token pool management.
- *
- * Supports CLAUDE_CODE_OAUTH_TOKENS (comma-separated list of tokens).
- * Falls back to CLAUDE_CODE_OAUTH_TOKEN for single-token / backwards compat.
- *
- * cc-tg token pool rotates independently from cc-agent's pool. No coordination between them.
- */
-let tokens = [];
-let currentIndex = 0;
-let initialized = false;
-/**
- * Load tokens from env vars. Called on startup; also re-callable in tests.
- * Priority: CLAUDE_CODE_OAUTH_TOKENS > CLAUDE_CODE_OAUTH_TOKEN > (empty)
- */
-export function loadTokens() {
-    const multi = process.env.CLAUDE_CODE_OAUTH_TOKENS;
-    if (multi) {
-        tokens = multi.split(",").map((t) => t.trim()).filter(Boolean);
-    }
-    else {
-        const single = process.env.CLAUDE_CODE_OAUTH_TOKEN;
-        tokens = single ? [single] : [];
-    }
-    currentIndex = 0;
-    initialized = true;
-    return tokens;
-}
-function ensureInitialized() {
-    if (!initialized)
-        loadTokens();
-}
-/** Returns the current active token, or empty string if none configured. */
-export function getCurrentToken() {
-    ensureInitialized();
-    return tokens[currentIndex] ?? "";
-}
-/**
- * Advance to the next token (wraps around).
- * Returns the new current token.
- */
-export function rotateToken() {
-    ensureInitialized();
-    if (tokens.length === 0)
-        return "";
-    currentIndex = (currentIndex + 1) % tokens.length;
-    return tokens[currentIndex];
-}
-/** Zero-based index of the current token. */
-export function getTokenIndex() {
-    ensureInitialized();
-    return currentIndex;
-}
-/** Total number of tokens in the pool. */
-export function getTokenCount() {
-    ensureInitialized();
-    return tokens.length;
-}

package/dist/voice.d.ts

@@ -1,13 +0,0 @@
-/**
- * Voice message transcription via whisper.cpp.
- * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
- */
-/**
- * Transcribe a voice message from a Telegram file URL.
- * Returns the transcribed text, or throws if whisper/ffmpeg not available.
- */
-export declare function transcribeVoice(fileUrl: string): Promise<string>;
-/**
- * Check if voice transcription is available on this system.
- */
-export declare function isVoiceAvailable(): boolean;

package/dist/voice.js

@@ -1,142 +0,0 @@
-/**
- * Voice message transcription via whisper.cpp.
- * Flow: Telegram OGG → ffmpeg convert to 16kHz WAV → whisper-cpp → text
- */
-import { execFile } from "child_process";
-import { promisify } from "util";
-import { existsSync } from "fs";
-import { unlink, readFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-import https from "https";
-import http from "http";
-import { createWriteStream } from "fs";
-const execFileAsync = promisify(execFile);
-// Whisper model — small.en is fast and accurate enough for commands
-// Falls back to base.en if small not found
-const WHISPER_MODELS = [
-    "/opt/homebrew/share/whisper-cpp/ggml-small.en.bin",
-    "/opt/homebrew/share/whisper-cpp/ggml-small.bin",
-    "/opt/homebrew/share/whisper-cpp/ggml-base.en.bin",
-    "/opt/homebrew/share/whisper-cpp/ggml-base.bin",
-    // user-local
-    `${process.env.HOME}/.local/share/whisper-cpp/ggml-small.en.bin`,
-    `${process.env.HOME}/.local/share/whisper-cpp/ggml-base.en.bin`,
-];
-const WHISPER_BIN_CANDIDATES = [
-    "/opt/homebrew/bin/whisper-cli", // whisper-cpp brew formula installs as whisper-cli
-    "/opt/homebrew/bin/whisper-cpp",
-    "/usr/local/bin/whisper-cli",
-    "/usr/local/bin/whisper-cpp",
-    "/opt/homebrew/bin/whisper",
-];
-const FFMPEG_CANDIDATES = [
-    "/opt/homebrew/bin/ffmpeg",
-    "/usr/local/bin/ffmpeg",
-    "/usr/bin/ffmpeg",
-];
-function findBin(candidates) {
-    for (const p of candidates) {
-        if (existsSync(p))
-            return p;
-    }
-    return null;
-}
-function findModel() {
-    for (const p of WHISPER_MODELS) {
-        if (existsSync(p))
-            return p;
-    }
-    return null;
-}
-function downloadFile(url, dest) {
-    return new Promise((resolve, reject) => {
-        const file = createWriteStream(dest);
-        const getter = url.startsWith("https") ? https : http;
-        getter.get(url, (res) => {
-            if (res.statusCode !== 200) {
-                reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
-                return;
-            }
-            res.pipe(file);
-            file.on("finish", () => file.close(() => resolve()));
-            file.on("error", reject);
-        }).on("error", reject);
-    });
-}
-/**
- * Transcribe a voice message from a Telegram file URL.
- * Returns the transcribed text, or throws if whisper/ffmpeg not available.
- */
-export async function transcribeVoice(fileUrl) {
-    const whisperBin = findBin(WHISPER_BIN_CANDIDATES);
-    if (!whisperBin)
-        throw new Error("whisper-cpp not found — install with: brew install whisper-cpp");
-    const ffmpegBin = findBin(FFMPEG_CANDIDATES);
-    if (!ffmpegBin)
-        throw new Error("ffmpeg not found — install with: brew install ffmpeg");
-    const model = findModel();
-    if (!model)
-        throw new Error("No whisper model found — run: whisper-cpp-download-ggml-model small.en");
-    const tmp = join(tmpdir(), `cc-tg-voice-${Date.now()}`);
-    const oggPath = `${tmp}.ogg`;
-    const wavPath = `${tmp}.wav`;
-    try {
-        // 1. Download OGG from Telegram
-        await downloadFile(fileUrl, oggPath);
-        // 2. Convert OGG → 16kHz mono WAV (whisper requirement)
-        await execFileAsync(ffmpegBin, [
-            "-y", "-i", oggPath,
-            "-ar", "16000",
-            "-ac", "1",
-            "-c:a", "pcm_s16le",
-            wavPath,
-        ]);
-        // 3. Run whisper-cpp
-        // --output-txt writes to ${wavPath}.txt (NOT stdout)
-        // -l auto fails with .en models — detect and use -l en instead
-        const isEnModel = model.includes(".en.");
-        const langArgs = isEnModel ? ["-l", "en"] : ["-l", "auto"];
-        try {
-            await execFileAsync(whisperBin, [
-                "-m", model,
-                "-f", wavPath,
-                "--no-timestamps",
-                ...langArgs,
-                "--output-txt", // writes to wavPath + ".txt"
-            ]);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`whisper-cpp failed: ${msg}`);
-        }
-        // Read the output file whisper-cpp wrote
-        const txtPath = `${wavPath}.txt`;
-        let raw = "";
-        try {
-            raw = await readFile(txtPath, "utf-8");
-        }
-        catch {
-            throw new Error("whisper-cpp ran but produced no output file");
-        }
-        const text = raw
-            .replace(/\[BLANK_AUDIO\]/gi, "")
-            .replace(/\[.*?\]/g, "") // remove timestamp artifacts
-            .trim();
-        return text || "[empty transcription]";
-    }
-    finally {
-        // Cleanup temp files
-        await unlink(oggPath).catch(() => { });
-        await unlink(wavPath).catch(() => { });
-        await unlink(`${wavPath}.txt`).catch(() => { });
-    }
-}
-/**
- * Check if voice transcription is available on this system.
- */
-export function isVoiceAvailable() {
-    return (findBin(WHISPER_BIN_CANDIDATES) !== null &&
-        findBin(FFMPEG_CANDIDATES) !== null &&
-        findModel() !== null);
-}