@gonzih/cc-discord 0.2.17 → 0.2.19

package/dist/bot.d.ts

@@ -36,6 +36,7 @@ export declare class CcDiscordBot {
     private namespace;
     private lastActiveChannelId?;
     private cron;
+    private cronEngine?;
     private metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     private mcpSession?;
@@ -90,6 +91,11 @@ export declare class CcDiscordBot {
     private registerSlashCommands;
     private handleSlashCommand;
     private handleCronsCommand;
+    /**
+     * Handle the /cron command group — backed by CronEngine (Redis-persisted, node-cron scheduled).
+     * Namespace is derived from the channel's registered namespace (same pattern as /clear and /compact).
+     */
+    private handleCronEngineCommand;
     /**
      * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
      * Returns the tool result as a string, or null on failure.
@@ -140,6 +146,11 @@ export declare class CcDiscordBot {
      * Passes a live getter for the set of registered namespaces.
      */
     startMetaAgentPolling(): void;
+    /**
+     * Start the CronEngine — loads all enabled crons from Redis and schedules them.
+     * Called from index.ts after startup migrations complete (alongside startMetaAgentPolling).
+     */
+    startCronEngine(): void;
     /**
      * Resolve the namespace for a given channelId.
      * Routed channels use their registered namespace; everything else uses the bot's primary namespace.

package/dist/bot.js

@@ -16,6 +16,7 @@ import { getCurrentToken } from "./tokens.js";
 import { writeChatLog } from "./notifier.js";
 import { LoopManager, isGoalMessage } from "./loop-manager.js";
 import { CronManager } from "./cron.js";
+import { CronEngine } from "./cron-engine.js";
 import { parseChannelCreateIntent, routeToMetaAgent } from "./router.js";
 import { createMetaAgentManager } from "./meta-agent-manager.js";
 /** Convert a Discord snowflake string to a safe 53-bit integer for CronManager compatibility. */
@@ -121,6 +122,7 @@ export class CcDiscordBot {
     namespace;
     lastActiveChannelId;
     cron;
+    cronEngine;
     metaAgentManager;
     /** ClaudeProcess running the MCP tool bridge (for callCcAgentTool) */
     mcpSession;
@@ -132,6 +134,7 @@ export class CcDiscordBot {
         if (opts.redis) {
             this.wire = createCcWire(opts.redis);
             this.loopManager = new LoopManager(opts.redis);
+            this.cronEngine = new CronEngine(opts.redis);
         }
         this.metaAgentManager = createMetaAgentManager();
         this.client = new Client({
@@ -826,6 +829,28 @@ export class CcDiscordBot {
             new SlashCommandBuilder()
                 .setName("compact")
                 .setDescription("Compact the Claude session context for this channel's namespace"),
+            new SlashCommandBuilder()
+                .setName("cron")
+                .setDescription("Manage Redis-persisted cron jobs for this channel's namespace")
+                .addSubcommand((sub) => sub
+                .setName("add")
+                .setDescription("Add a cron job (standard 5-field cron expression)")
+                .addStringOption((opt) => opt.setName("schedule").setDescription("Cron expression e.g. '0 * * * *'").setRequired(true))
+                .addStringOption((opt) => opt.setName("message").setDescription("Message to push to the meta-agent input queue").setRequired(true))
+                .addIntegerOption((opt) => opt.setName("compact_every").setDescription("Push /compact every N fires (default: 10, 0 = never)").setRequired(false)))
+                .addSubcommand((sub) => sub.setName("list").setDescription("List all cron jobs"))
+                .addSubcommand((sub) => sub
+                .setName("pause")
+                .setDescription("Pause a cron job")
+                .addStringOption((opt) => opt.setName("id").setDescription("Cron ID").setRequired(true)))
+                .addSubcommand((sub) => sub
+                .setName("resume")
+                .setDescription("Resume a paused cron job")
+                .addStringOption((opt) => opt.setName("id").setDescription("Cron ID").setRequired(true)))
+                .addSubcommand((sub) => sub
+                .setName("delete")
+                .setDescription("Delete a cron job permanently")
+                .addStringOption((opt) => opt.setName("id").setDescription("Cron ID").setRequired(true))),
         ].map((cmd) => cmd.toJSON());
         const rest = new REST().setToken(this.opts.discordToken);
         if (this.opts.guildIds?.length) {
@@ -972,6 +997,10 @@ export class CcDiscordBot {
                 });
                 break;
             }
+            case "cron": {
+                await this.handleCronEngineCommand(interaction, channelId);
+                break;
+            }
         }
     }
     async handleCronsCommand(interaction, channelId) {
@@ -1020,6 +1049,79 @@ export class CcDiscordBot {
                 await interaction.reply("Unknown subcommand.");
         }
     }
+    /**
+     * Handle the /cron command group — backed by CronEngine (Redis-persisted, node-cron scheduled).
+     * Namespace is derived from the channel's registered namespace (same pattern as /clear and /compact).
+     */
+    async handleCronEngineCommand(interaction, channelId) {
+        if (!this.cronEngine) {
+            await interaction.reply({ content: "Cron engine unavailable (no Redis connection).", ephemeral: true });
+            return;
+        }
+        const ns = this.resolveNamespaceForChannel(channelId);
+        const sub = interaction.options.getSubcommand();
+        switch (sub) {
+            case "add": {
+                const cronSchedule = interaction.options.getString("schedule", true);
+                const message = interaction.options.getString("message", true);
+                const compactEvery = interaction.options.getInteger("compact_every") ?? 10;
+                await interaction.deferReply();
+                const rec = await this.cronEngine.add(ns, cronSchedule, message, compactEvery);
+                if (!rec) {
+                    await interaction.editReply(`Invalid cron expression: \`${cronSchedule}\`\nUse standard 5-field format, e.g. \`0 * * * *\` (hourly) or \`*/30 * * * *\` (every 30 min).`);
+                }
+                else {
+                    await interaction.editReply(`Cron added for namespace **${ns}**\nID: \`${rec.id}\`\nSchedule: \`${rec.schedule}\`\nCompact every: ${rec.compact_every} fires`);
+                }
+                break;
+            }
+            case "list": {
+                await interaction.deferReply();
+                const allCrons = await this.cronEngine.list();
+                const nsCrons = allCrons.filter((r) => r.namespace === ns);
+                if (nsCrons.length === 0) {
+                    await interaction.editReply(`No cron jobs for namespace **${ns}**.`);
+                }
+                else {
+                    const embed = new EmbedBuilder()
+                        .setTitle(`Cron jobs — ${ns}`)
+                        .setColor(0x5865F2)
+                        .setDescription(nsCrons
+                        .map((r) => {
+                        const status = r.enabled ? "enabled" : "paused";
+                        const last = r.last_fired_at ? `last fired ${r.last_fired_at}` : "never fired";
+                        return `**\`${r.id}\`** [${status}]\nSchedule: \`${r.schedule}\` | Fires: ${r.fire_count} | ${last}\nMessage: \`${r.message.slice(0, 80)}${r.message.length > 80 ? "…" : ""}\``;
+                    })
+                        .join("\n\n"));
+                    await interaction.editReply({ embeds: [embed] });
+                }
+                break;
+            }
+            case "pause": {
+                const id = interaction.options.getString("id", true);
+                await interaction.deferReply();
+                const ok = await this.cronEngine.pause(id);
+                await interaction.editReply(ok ? `Cron \`${id}\` paused.` : `Cron \`${id}\` not found.`);
+                break;
+            }
+            case "resume": {
+                const id = interaction.options.getString("id", true);
+                await interaction.deferReply();
+                const ok = await this.cronEngine.resume(id);
+                await interaction.editReply(ok ? `Cron \`${id}\` resumed.` : `Cron \`${id}\` not found.`);
+                break;
+            }
+            case "delete": {
+                const id = interaction.options.getString("id", true);
+                await interaction.deferReply();
+                const ok = await this.cronEngine.delete(id);
+                await interaction.editReply(ok ? `Cron \`${id}\` deleted.` : `Cron \`${id}\` not found.`);
+                break;
+            }
+            default:
+                await interaction.reply("Unknown /cron subcommand.");
+        }
+    }
     /**
      * Call a cc-agent MCP tool via a dedicated ClaudeProcess.
      * Returns the tool result as a string, or null on failure.
@@ -1326,6 +1428,17 @@ export class CcDiscordBot {
             return;
         this.metaAgentManager.startPolling(this.wire, () => Array.from(this.channelNamespaceMap.values()), this.opts.instanceId);
     }
+    /**
+     * Start the CronEngine — loads all enabled crons from Redis and schedules them.
+     * Called from index.ts after startup migrations complete (alongside startMetaAgentPolling).
+     */
+    startCronEngine() {
+        if (!this.cronEngine)
+            return;
+        this.cronEngine.start().catch((err) => {
+            console.warn("[bot] cronEngine.start() failed:", err.message);
+        });
+    }
     /**
      * Resolve the namespace for a given channelId.
      * Routed channels use their registered namespace; everything else uses the bot's primary namespace.

package/dist/cron-engine.d.ts

@@ -0,0 +1,81 @@
+/**
+ * CronEngine — Redis-persisted, node-cron–scheduled meta-agent messaging.
+ *
+ * Redis key schema:
+ *   cca:discord:cron:list          — SET of cron IDs
+ *   cca:discord:cron:{id}          — HASH with fields:
+ *                                      namespace, schedule, message, enabled,
+ *                                      fire_count, compact_every,
+ *                                      created_at, last_fired_at
+ *
+ * On each fire:
+ *   1. Increment fire_count
+ *   2. Duplicate check: LRANGE cca:discord:meta:{ns}:input 0 -1
+ *      — skip if the exact message is already queued
+ *   3. If fire_count % compact_every === 0: RPUSH /compact first
+ *   4. RPUSH JSON entry to cca:discord:meta:{ns}:input
+ *   5. Update last_fired_at
+ */
+import type { Redis } from "ioredis";
+export interface CronRecord {
+    id: string;
+    namespace: string;
+    schedule: string;
+    message: string;
+    enabled: boolean;
+    fire_count: number;
+    compact_every: number;
+    created_at: string;
+    last_fired_at: string;
+}
+export declare class CronEngine {
+    private redis;
+    /** Map of cron ID → active node-cron ScheduledTask */
+    private tasks;
+    constructor(redis: Redis);
+    /**
+     * Add a new cron.
+     * @param namespace  The meta-agent namespace to push messages to.
+     * @param cronSchedule  A standard 5-field cron expression (e.g. "0 * * * *").
+     * @param message  Text content to push into the meta-agent input queue.
+     * @param compact_every  Push /compact every N fires. Defaults to 10.
+     * @returns The created CronRecord, or null if the schedule is invalid.
+     */
+    add(namespace: string, cronSchedule: string, message: string, compact_every?: number): Promise<CronRecord | null>;
+    /**
+     * List all crons stored in Redis.
+     */
+    list(): Promise<CronRecord[]>;
+    /**
+     * Pause a cron (sets enabled=false and stops the node-cron task).
+     */
+    pause(id: string): Promise<boolean>;
+    /**
+     * Resume a paused cron (sets enabled=true and re-schedules the task).
+     */
+    resume(id: string): Promise<boolean>;
+    /**
+     * Delete a cron (stops the task and removes from Redis).
+     */
+    delete(id: string): Promise<boolean>;
+    /**
+     * Load all enabled crons from Redis and schedule them.
+     * Call once after the bot connects and Redis is ready.
+     */
+    start(): Promise<void>;
+    private scheduleTask;
+    /**
+     * Execute one cron tick:
+     *  1. Reload record (picks up any pause between schedule and fire)
+     *  2. Increment fire_count
+     *  3. Duplicate check against the input queue
+     *  4. Optionally push /compact
+     *  5. Push the message
+     *  6. Update last_fired_at
+     */
+    private fire;
+    /** Write a CronRecord to Redis as a HASH. */
+    private saveRecord;
+    /** Load a CronRecord from Redis. Returns null if the key doesn't exist. */
+    private loadRecord;
+}

package/dist/cron-engine.js

@@ -0,0 +1,271 @@
+/**
+ * CronEngine — Redis-persisted, node-cron–scheduled meta-agent messaging.
+ *
+ * Redis key schema:
+ *   cca:discord:cron:list          — SET of cron IDs
+ *   cca:discord:cron:{id}          — HASH with fields:
+ *                                      namespace, schedule, message, enabled,
+ *                                      fire_count, compact_every,
+ *                                      created_at, last_fired_at
+ *
+ * On each fire:
+ *   1. Increment fire_count
+ *   2. Duplicate check: LRANGE cca:discord:meta:{ns}:input 0 -1
+ *      — skip if the exact message is already queued
+ *   3. If fire_count % compact_every === 0: RPUSH /compact first
+ *   4. RPUSH JSON entry to cca:discord:meta:{ns}:input
+ *   5. Update last_fired_at
+ */
+import { randomUUID } from "crypto";
+import { schedule, validate } from "node-cron";
+// ─── Redis key helpers ────────────────────────────────────────────────────────
+const CRON_LIST_KEY = "cca:discord:cron:list";
+const cronHashKey = (id) => `cca:discord:cron:${id}`;
+const metaInputKey = (ns) => `cca:discord:meta:${ns}:input`;
+// ─── CronEngine ──────────────────────────────────────────────────────────────
+export class CronEngine {
+    redis;
+    /** Map of cron ID → active node-cron ScheduledTask */
+    tasks = new Map();
+    constructor(redis) {
+        this.redis = redis;
+    }
+    /**
+     * Add a new cron.
+     * @param namespace  The meta-agent namespace to push messages to.
+     * @param cronSchedule  A standard 5-field cron expression (e.g. "0 * * * *").
+     * @param message  Text content to push into the meta-agent input queue.
+     * @param compact_every  Push /compact every N fires. Defaults to 10.
+     * @returns The created CronRecord, or null if the schedule is invalid.
+     */
+    async add(namespace, cronSchedule, message, compact_every = 10) {
+        if (!validate(cronSchedule))
+            return null;
+        const id = randomUUID();
+        const now = new Date().toISOString();
+        const record = {
+            id,
+            namespace,
+            schedule: cronSchedule,
+            message,
+            enabled: true,
+            fire_count: 0,
+            compact_every,
+            created_at: now,
+            last_fired_at: "",
+        };
+        await this.saveRecord(record);
+        await this.redis.sadd(CRON_LIST_KEY, id);
+        this.scheduleTask(record);
+        console.log(`[cron-engine] added cron id=${id} ns=${namespace} schedule="${cronSchedule}"`);
+        return record;
+    }
+    /**
+     * List all crons stored in Redis.
+     */
+    async list() {
+        const ids = await this.redis.smembers(CRON_LIST_KEY);
+        const records = [];
+        for (const id of ids) {
+            const rec = await this.loadRecord(id);
+            if (rec)
+                records.push(rec);
+        }
+        return records;
+    }
+    /**
+     * Pause a cron (sets enabled=false and stops the node-cron task).
+     */
+    async pause(id) {
+        const rec = await this.loadRecord(id);
+        if (!rec)
+            return false;
+        rec.enabled = false;
+        await this.saveRecord(rec);
+        const task = this.tasks.get(id);
+        if (task) {
+            await task.stop();
+        }
+        console.log(`[cron-engine] paused cron id=${id}`);
+        return true;
+    }
+    /**
+     * Resume a paused cron (sets enabled=true and re-schedules the task).
+     */
+    async resume(id) {
+        const rec = await this.loadRecord(id);
+        if (!rec)
+            return false;
+        rec.enabled = true;
+        await this.saveRecord(rec);
+        // Re-schedule if not already running
+        if (!this.tasks.has(id)) {
+            this.scheduleTask(rec);
+        }
+        else {
+            const task = this.tasks.get(id);
+            await task.start();
+        }
+        console.log(`[cron-engine] resumed cron id=${id}`);
+        return true;
+    }
+    /**
+     * Delete a cron (stops the task and removes from Redis).
+     */
+    async delete(id) {
+        const rec = await this.loadRecord(id);
+        if (!rec)
+            return false;
+        const task = this.tasks.get(id);
+        if (task) {
+            await task.stop();
+            await task.destroy();
+            this.tasks.delete(id);
+        }
+        await this.redis.srem(CRON_LIST_KEY, id);
+        await this.redis.del(cronHashKey(id));
+        console.log(`[cron-engine] deleted cron id=${id}`);
+        return true;
+    }
+    /**
+     * Load all enabled crons from Redis and schedule them.
+     * Call once after the bot connects and Redis is ready.
+     */
+    async start() {
+        const ids = await this.redis.smembers(CRON_LIST_KEY);
+        let scheduled = 0;
+        for (const id of ids) {
+            const rec = await this.loadRecord(id);
+            if (!rec)
+                continue;
+            if (rec.enabled) {
+                this.scheduleTask(rec);
+                scheduled++;
+            }
+        }
+        console.log(`[cron-engine] started — loaded ${ids.length} crons, scheduled ${scheduled}`);
+    }
+    // ─── Private helpers ────────────────────────────────────────────────────────
+    scheduleTask(rec) {
+        // Destroy any existing task for this ID
+        const existing = this.tasks.get(rec.id);
+        if (existing) {
+            void existing.stop();
+            void existing.destroy();
+            this.tasks.delete(rec.id);
+        }
+        const task = schedule(rec.schedule, async () => {
+            await this.fire(rec.id);
+        }, { noOverlap: true });
+        this.tasks.set(rec.id, task);
+    }
+    /**
+     * Execute one cron tick:
+     *  1. Reload record (picks up any pause between schedule and fire)
+     *  2. Increment fire_count
+     *  3. Duplicate check against the input queue
+     *  4. Optionally push /compact
+     *  5. Push the message
+     *  6. Update last_fired_at
+     */
+    async fire(id) {
+        const rec = await this.loadRecord(id);
+        if (!rec) {
+            console.warn(`[cron-engine] fire: record not found for id=${id}`);
+            return;
+        }
+        if (!rec.enabled) {
+            console.log(`[cron-engine] fire: cron id=${id} is disabled — skipping`);
+            return;
+        }
+        const ns = rec.namespace;
+        const inputKey = metaInputKey(ns);
+        // Increment fire_count
+        rec.fire_count += 1;
+        // Duplicate check: skip if the message is already queued
+        try {
+            const queued = await this.redis.lrange(inputKey, 0, -1);
+            const alreadyQueued = queued.some((entry) => {
+                try {
+                    const parsed = JSON.parse(entry);
+                    return parsed.content === rec.message;
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (alreadyQueued) {
+                console.log(`[cron-engine] fire: duplicate detected, skipping push (id=${id} ns=${ns})`);
+                await this.saveRecord(rec);
+                return;
+            }
+        }
+        catch (err) {
+            console.warn(`[cron-engine] fire: duplicate check failed (id=${id}):`, err.message);
+        }
+        // Auto-compact every N fires
+        if (rec.compact_every > 0 && rec.fire_count % rec.compact_every === 0) {
+            const compactEntry = JSON.stringify({
+                id: randomUUID(),
+                content: "/compact",
+                timestamp: new Date().toISOString(),
+                source: "cron",
+            });
+            try {
+                await this.redis.rpush(inputKey, compactEntry);
+                console.log(`[cron-engine] fire: pushed /compact (id=${id} ns=${ns} fire_count=${rec.fire_count})`);
+            }
+            catch (err) {
+                console.warn(`[cron-engine] fire: /compact push failed (id=${id}):`, err.message);
+            }
+        }
+        // Push the scheduled message
+        const entry = JSON.stringify({
+            id: randomUUID(),
+            content: rec.message,
+            timestamp: new Date().toISOString(),
+            source: "cron",
+        });
+        try {
+            await this.redis.rpush(inputKey, entry);
+            rec.last_fired_at = new Date().toISOString();
+            console.log(`[cron-engine] fire: pushed message (id=${id} ns=${ns} fire_count=${rec.fire_count})`);
+        }
+        catch (err) {
+            console.warn(`[cron-engine] fire: push failed (id=${id}):`, err.message);
+        }
+        await this.saveRecord(rec);
+    }
+    /** Write a CronRecord to Redis as a HASH. */
+    async saveRecord(rec) {
+        const key = cronHashKey(rec.id);
+        await this.redis.hset(key, {
+            id: rec.id,
+            namespace: rec.namespace,
+            schedule: rec.schedule,
+            message: rec.message,
+            enabled: rec.enabled ? "1" : "0",
+            fire_count: String(rec.fire_count),
+            compact_every: String(rec.compact_every),
+            created_at: rec.created_at,
+            last_fired_at: rec.last_fired_at,
+        });
+    }
+    /** Load a CronRecord from Redis. Returns null if the key doesn't exist. */
+    async loadRecord(id) {
+        const data = await this.redis.hgetall(cronHashKey(id));
+        if (!data || !data.id)
+            return null;
+        return {
+            id: data.id,
+            namespace: data.namespace,
+            schedule: data.schedule,
+            message: data.message,
+            enabled: data.enabled === "1",
+            fire_count: parseInt(data.fire_count ?? "0", 10),
+            compact_every: parseInt(data.compact_every ?? "10", 10),
+            created_at: data.created_at ?? "",
+            last_fired_at: data.last_fired_at ?? "",
+        };
+    }
+}

package/dist/index.js

@@ -144,6 +144,8 @@ async function runStartupMigrations() {
     console.log("[cc-discord] startup migrations complete");
     // 3. Start meta-agent polling now that data is migrated
     bot.startMetaAgentPolling();
+    // 4. Start cron engine — loads and schedules all Redis-persisted crons
+    bot.startCronEngine();
 }
 // Mutable placeholder closures — filled in once `bot` is created below
 let getLastActiveChannelIdFn = () => undefined;

package/dist/notifier.js

@@ -97,6 +97,8 @@ export function parseNotification(raw) {
         }
         if (parsed.is_cron === true)
             return null;
+        if (parsed.text?.startsWith("⏰"))
+            return null;
         if (parsed.text)
             text = parsed.text;
         driver = parsed.driver;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gonzih/cc-discord",
-  "version": "0.2.17",
+  "version": "0.2.19",
   "description": "Claude Code Discord bot — chat with Claude Code via Discord",
   "type": "module",
   "bin": {
@@ -19,8 +19,10 @@
   ],
   "dependencies": {
     "@gonzih/cc-wire": "^0.3.0",
+    "@types/node-cron": "^3.0.11",
     "discord.js": "^14.0.0",
-    "ioredis": "^5.0.0"
+    "ioredis": "^5.0.0",
+    "node-cron": "^4.4.1"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",