@gonzih/cc-discord 0.1.2 → 0.1.3

package/dist/index.js

@@ -0,0 +1,107 @@
+#!/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

@@ -0,0 +1,53 @@
+/**
+ * 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

@@ -0,0 +1,315 @@
+/**
+ * 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

@@ -0,0 +1,47 @@
+/**
+ * Routing helpers: channel-creation intent detection and meta-agent routing.
+ */
+import { Redis } from "ioredis";
+/** Callback type matching CcDiscordBot.callCcAgentTool */
+export type CallToolFn = (toolName: string, args?: Record<string, unknown>) => Promise<string | 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>;
+/**
+ * Detect a natural-language channel-creation request.
+ * Matches:
+ *   "channel for https://github.com/org/repo"
+ *   "create channel for https://github.com/org/repo"
+ *   "add channel for https://github.com/org/repo"
+ *
+ * Returns { namespace, repoUrl } or null.
+ */
+export declare function parseChannelCreateIntent(text: string): {
+    namespace: string;
+    repoUrl: string;
+} | null;
+/**
+ * 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>;

package/dist/router.js

@@ -0,0 +1,165 @@
+/**
+ * Routing helpers: channel-creation intent detection and meta-agent routing.
+ */
+import { execSync } from "child_process";
+import { metaAgentStatusKey, metaKey, metaInputKey } from "@gonzih/cc-wire";
+/**
+ * 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`);
+}
+/**
+ * Detect a natural-language channel-creation request.
+ * Matches:
+ *   "channel for https://github.com/org/repo"
+ *   "create channel for https://github.com/org/repo"
+ *   "add channel for https://github.com/org/repo"
+ *
+ * Returns { namespace, repoUrl } or null.
+ */
+export function parseChannelCreateIntent(text) {
+    const match = text.match(/(?:create\s+|add\s+)?channel\s+for\s+(https?:\/\/github\.com\/([\w.-]+)\/([\w.-]+))/i);
+    if (!match)
+        return null;
+    const repoUrl = match[1];
+    const namespace = match[3];
+    return { namespace, repoUrl };
+}
+/**
+ * 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}`);
+}