cc2im 0.2.0

package/dist/plugins/channel-manager/index.js

@@ -0,0 +1,387 @@
+/**
+ * ChannelManager plugin — unified channel lifecycle, routing, and permissions.
+ *
+ * Replaces the weixin plugin's "glue" logic with a channel-agnostic implementation.
+ * Owns: channel lifecycle, message routing (channel<->agent), typing indicators,
+ * pending-ack timers, permission management, and user-tracking per agent.
+ */
+import { basename, join } from 'node:path';
+import { copyFileSync, mkdirSync } from 'node:fs';
+import { SOCKET_DIR } from '../../shared/socket.js';
+import { PermissionManager } from '../weixin/permission.js';
+const TYPING_ACK_DELAY_MS = 10_000; // 10s before "processing..." ack
+export function createChannelManagerPlugin(channels) {
+    let permissionMgr;
+    let cleanupInterval;
+    const lastUserByAgent = new Map();
+    const lastChannelByUser = new Map(); // userId -> channelId
+    let lastGlobalUser = null;
+    // Per-agent pending ack timer: agentId -> { ref, timer }
+    const pendingAck = new Map();
+    // Channel lookup by id
+    const channelMap = new Map();
+    for (const ch of channels) {
+        channelMap.set(ch.id, ch);
+    }
+    return {
+        name: 'channel-manager',
+        async init(ctx) {
+            // Register channels into HubContext so other plugins can access them
+            for (const ch of channels) {
+                ctx.registerChannel(ch);
+            }
+            // Helper: find channel by id
+            function getChannel(channelId) {
+                return channelMap.get(channelId);
+            }
+            // Helper: send text via channel, with fallback log
+            async function channelSendText(ref, text) {
+                const ch = getChannel(ref.channelId);
+                if (!ch) {
+                    console.error(`[channel-manager] Channel "${ref.channelId}" not found, cannot send to ${ref.userId}`);
+                    return;
+                }
+                await ch.sendText(ref.userId, text);
+            }
+            // --- Permission manager ---
+            // PermissionManager needs a send function for permission prompts.
+            // We provide a callback that resolves channel from lastUserByAgent.
+            permissionMgr = new PermissionManager();
+            // --- Pending ack management ---
+            function clearPendingAck(agentId) {
+                const pending = pendingAck.get(agentId);
+                if (pending) {
+                    clearTimeout(pending.timer);
+                    pendingAck.delete(agentId);
+                    const ch = getChannel(pending.ref.channelId);
+                    ch?.stopTyping(pending.ref.userId).catch(() => { });
+                }
+            }
+            function startPendingAck(agentId, ref) {
+                clearPendingAck(agentId); // clear any previous
+                const ch = getChannel(ref.channelId);
+                ch?.startTyping(ref.userId).catch(() => { });
+                const timer = setTimeout(async () => {
+                    pendingAck.delete(agentId);
+                    await channelSendText(ref, `\u23F3 \u6536\u5230\uFF0C\u6B63\u5728\u5904\u7406...`).catch(() => { });
+                }, TYPING_ACK_DELAY_MS);
+                pendingAck.set(agentId, { ref, timer });
+            }
+            // --- Spoke -> Channel: handle spoke messages ---
+            ctx.on('spoke:message', async (agentId, msg) => {
+                switch (msg.type) {
+                    case 'reply': {
+                        clearPendingAck(agentId);
+                        // Resolve which channel to reply on
+                        const ref = resolveUserRef(agentId, msg.userId);
+                        if (!ref) {
+                            console.error(`[channel-manager] Cannot resolve channel for reply from ${agentId} to ${msg.userId}`);
+                            return;
+                        }
+                        console.log(`[hub] Reply from ${agentId} to ${msg.userId}: ${msg.text.slice(0, 100)}`);
+                        ctx.broadcastMonitor({ kind: 'message_out', agentId, userId: msg.userId, text: msg.text, timestamp: new Date().toISOString(), channelId: ref.channelId });
+                        await channelSendText(ref, msg.text);
+                        break;
+                    }
+                    case 'permission_request': {
+                        console.log(`[hub] Permission request from ${agentId}: ${msg.toolName}`);
+                        // sendFn resolves channel from the agent's tracked UserRef
+                        const sendFn = async (userId, text) => {
+                            const ref = resolveUserRef(agentId, userId);
+                            if (ref) {
+                                await channelSendText(ref, text);
+                            }
+                            else {
+                                console.error(`[channel-manager] Cannot resolve channel for permission prompt to ${userId}`);
+                            }
+                        };
+                        await permissionMgr.handleRequest(agentId, msg, ctx, sendFn, lastUserByAgent, lastGlobalUser);
+                        break;
+                    }
+                    case 'status': {
+                        console.log(`[hub] Agent ${agentId} status: ${msg.status}`);
+                        break;
+                    }
+                    case 'permission_timeout': {
+                        permissionMgr.handleTimeout(msg.requestId);
+                        break;
+                    }
+                    case 'send_file': {
+                        clearPendingAck(agentId);
+                        const ref = resolveUserRef(agentId, msg.userId);
+                        if (!ref) {
+                            console.error(`[channel-manager] Cannot resolve channel for send_file from ${agentId} to ${msg.userId}`);
+                            return;
+                        }
+                        const IMAGE_EXTS = new Set(['jpg', 'jpeg', 'png', 'gif', 'webp', 'bmp']);
+                        const VIDEO_EXTS = new Set(['mp4', 'mov', 'avi', 'webm']);
+                        const ext = msg.filePath.split('.').pop()?.toLowerCase() || '';
+                        const isImage = IMAGE_EXTS.has(ext);
+                        const isVideo = VIDEO_EXTS.has(ext);
+                        const msgType = isImage ? 'image' : isVideo ? 'video' : 'file';
+                        try {
+                            const ch = getChannel(ref.channelId);
+                            if (!ch)
+                                throw new Error(`Channel "${ref.channelId}" not found`);
+                            await ch.sendFile(ref.userId, msg.filePath);
+                            // Copy to media dir so dashboard can preview
+                            const mediaDir = join(SOCKET_DIR, 'media');
+                            const mediaName = `${Date.now()}-${basename(msg.filePath)}`;
+                            try {
+                                mkdirSync(mediaDir, { recursive: true });
+                                copyFileSync(msg.filePath, join(mediaDir, mediaName));
+                            }
+                            catch { }
+                            console.log(`[hub] File sent from ${agentId} to ${msg.userId}: ${msg.filePath}`);
+                            ctx.broadcastMonitor({
+                                kind: 'message_out', agentId, userId: msg.userId,
+                                text: isImage ? '[\u56FE\u7247]' : `[${msgType}] ${basename(msg.filePath)}`,
+                                timestamp: new Date().toISOString(),
+                                msgType,
+                                mediaUrl: `/media/${mediaName}`,
+                                channelId: ref.channelId,
+                            });
+                        }
+                        catch (err) {
+                            console.error(`[hub] Failed to send file from ${agentId}: ${err.message}`);
+                        }
+                        break;
+                    }
+                    // NOTE: 'management' type is handled by hub core, not by this plugin
+                }
+            });
+            // --- Channel -> Agent: wire up message + status handlers ---
+            function wireChannel(ch) {
+                ch.onMessage(async (incomingMsg) => {
+                    const userId = incomingMsg.userId;
+                    const channelId = incomingMsg.channelId;
+                    const ref = { userId, channelId };
+                    lastGlobalUser = ref;
+                    lastChannelByUser.set(userId, channelId);
+                    // Permission verdict detection
+                    if (permissionMgr.tryHandleVerdict({ type: incomingMsg.type, text: incomingMsg.text, userId, channelId }, ctx))
+                        return;
+                    // Route message
+                    const router = ctx.getRouter();
+                    const routed = router.route(incomingMsg.text || '', channelId);
+                    lastUserByAgent.set(routed.agentId, ref);
+                    // Unknown agent
+                    if (routed.unknownAgent) {
+                        const available = router.getAgentNames();
+                        await channelSendText(ref, `\u26A0 Agent "${routed.agentId}" \u4E0D\u5B58\u5728\uFF0C\u53EF\u7528\u7684 agent: ${available.join(', ') || '\u65E0'}`);
+                        return;
+                    }
+                    // Intercepted commands (restart, effort)
+                    if (routed.intercepted) {
+                        const agentManager = ctx.getAgentManager();
+                        switch (routed.intercepted.command) {
+                            case 'restart': {
+                                await channelSendText(ref, `\u6B63\u5728\u91CD\u542F ${routed.agentId}...`);
+                                const result = await agentManager.restart(routed.agentId);
+                                await channelSendText(ref, result.success ? `\u2713 ${routed.agentId} \u5DF2\u91CD\u542F` : `\u2717 \u91CD\u542F\u5931\u8D25: ${result.error}`);
+                                return;
+                            }
+                            case 'effort': {
+                                const effort = routed.intercepted.args[0];
+                                agentManager.updateEffort(routed.agentId, effort);
+                                await channelSendText(ref, `\u6B63\u5728\u4EE5 --effort ${effort} \u91CD\u542F ${routed.agentId}...`);
+                                const result = await agentManager.restart(routed.agentId);
+                                await channelSendText(ref, result.success ? `\u2713 ${routed.agentId} \u5DF2\u91CD\u542F (effort: ${effort})` : `\u2717 \u91CD\u542F\u5931\u8D25: ${result.error}`);
+                                return;
+                            }
+                        }
+                    }
+                    // Forward to spoke — persistence plugin will queue if offline
+                    const text = buildMessageContent(incomingMsg, routed.text);
+                    console.log(`[hub] Forwarding to ${routed.agentId}: ${text.substring(0, 80)}`);
+                    const mediaUrl = incomingMsg.mediaPath ? `/media/${basename(incomingMsg.mediaPath)}` : undefined;
+                    ctx.broadcastMonitor({ kind: 'message_in', agentId: routed.agentId, userId, text: routed.text, timestamp: new Date().toISOString(), msgType: incomingMsg.type, mediaUrl, channelId: incomingMsg.channelId, channelType: incomingMsg.channelType });
+                    const sent = ctx.deliverToAgent(routed.agentId, {
+                        type: 'message',
+                        userId,
+                        text,
+                        msgType: incomingMsg.type,
+                        mediaPath: incomingMsg.mediaPath ?? undefined,
+                        timestamp: incomingMsg.timestamp?.toISOString() ?? new Date().toISOString(),
+                        channelId: incomingMsg.channelId,
+                    });
+                    if (sent) {
+                        startPendingAck(routed.agentId, ref);
+                    }
+                    else {
+                        console.log(`[hub] Message queued for offline agent "${routed.agentId}"`);
+                        await channelSendText(ref, `\uD83D\uDCEC ${routed.agentId} \u6682\u65F6\u79BB\u7EBF\uFF0C\u6D88\u606F\u5DF2\u6392\u961F\uFF0C\u4E0A\u7EBF\u540E\u81EA\u52A8\u6295\u9012\u3002`);
+                    }
+                });
+                // Channel status change -> monitor broadcast
+                ch.onStatusChange((status, detail) => {
+                    console.log(`[channel-manager] ${ch.label} status: ${status}${detail ? ` (${detail})` : ''}`);
+                    ctx.broadcastMonitor({
+                        kind: 'channel_status',
+                        agentId: ch.id, // reuse agentId field for channelId
+                        timestamp: new Date().toISOString(),
+                        text: `${ch.label}: ${status}${detail ? ` — ${detail}` : ''}`,
+                    });
+                });
+            }
+            for (const ch of channels) {
+                wireChannel(ch);
+            }
+            // --- Runtime channel add/remove ---
+            ctx.on('channel:add', async (type, channelId, accountName) => {
+                if (channelMap.has(channelId))
+                    return; // already exists
+                if (type === 'weixin') {
+                    const { WeixinChannel } = await import('../weixin/weixin-channel.js');
+                    const ch = new WeixinChannel(channelId, accountName);
+                    channelMap.set(channelId, ch);
+                    ctx.registerChannel(ch);
+                    wireChannel(ch);
+                    // Persist
+                    const { loadChannelConfigs, saveChannelConfigs } = await import('../../shared/channel-config.js');
+                    const configs = loadChannelConfigs();
+                    if (!configs.find(c => c.id === channelId)) {
+                        configs.push({ id: channelId, type: 'weixin', accountName });
+                        saveChannelConfigs(configs);
+                    }
+                    // Don't auto-connect — wait for QR login to provide credentials
+                    // Connection will be triggered by reconnectChannel after QR confirmed
+                    console.log(`[channel-manager] Channel "${channelId}" created (awaiting login)`);
+                }
+                else {
+                    console.warn(`[channel-manager] Unknown channel type: ${type}`);
+                }
+            });
+            ctx.on('channel:remove', async (channelId) => {
+                const ch = channelMap.get(channelId);
+                if (ch) {
+                    try {
+                        await ch.disconnect();
+                    }
+                    catch { }
+                    channelMap.delete(channelId);
+                }
+                // Clean up user refs pointing to deleted channel
+                for (const [agentId, ref] of lastUserByAgent) {
+                    if (ref.channelId === channelId)
+                        lastUserByAgent.delete(agentId);
+                }
+                for (const [uid, chId] of lastChannelByUser) {
+                    if (chId === channelId)
+                        lastChannelByUser.delete(uid);
+                }
+                if (lastGlobalUser?.channelId === channelId)
+                    lastGlobalUser = null;
+                // Persist
+                const { loadChannelConfigs, saveChannelConfigs } = await import('../../shared/channel-config.js');
+                const configs = loadChannelConfigs().filter(c => c.id !== channelId);
+                saveChannelConfigs(configs);
+                console.log(`[channel-manager] Channel "${channelId}" removed`);
+            });
+            ctx.on('channel:reconnect', async (channelId) => {
+                const ch = channelMap.get(channelId);
+                if (!ch) {
+                    console.warn(`[channel-manager] reconnect: channel "${channelId}" not found`);
+                    return;
+                }
+                console.log(`[channel-manager] Reconnecting "${channelId}"...`);
+                try {
+                    await ch.disconnect();
+                }
+                catch (err) {
+                    console.warn(`[channel-manager] disconnect before reconnect failed: ${err.message}`);
+                }
+                try {
+                    await ch.connect();
+                    console.log(`[channel-manager] "${channelId}" reconnected`);
+                }
+                catch (err) {
+                    console.error(`[channel-manager] "${channelId}" reconnect failed: ${err.message}`);
+                }
+            });
+            // --- Helper: resolve UserRef for outbound messages ---
+            function resolveUserRef(agentId, userId) {
+                // If we have a tracked ref for this agent, use it
+                const tracked = lastUserByAgent.get(agentId);
+                if (tracked) {
+                    if (!userId || tracked.userId === userId)
+                        return tracked;
+                    // userId specified but differs — look up channel by userId
+                    const channelId = lastChannelByUser.get(userId);
+                    if (channelId)
+                        return { userId, channelId };
+                    // Fall back to tracked channel (best effort)
+                    return { userId, channelId: tracked.channelId };
+                }
+                // Fall back to global last user
+                if (lastGlobalUser) {
+                    if (!userId || lastGlobalUser.userId === userId)
+                        return lastGlobalUser;
+                    const channelId = lastChannelByUser.get(userId);
+                    if (channelId)
+                        return { userId, channelId };
+                    return { userId, channelId: lastGlobalUser.channelId };
+                }
+                // No ref available
+                if (userId) {
+                    const channelId = lastChannelByUser.get(userId);
+                    if (channelId)
+                        return { userId, channelId };
+                    const firstChannel = channels[0];
+                    if (firstChannel)
+                        return { userId, channelId: firstChannel.id };
+                }
+                return null;
+            }
+            // Alert user when an agent dies after max restart attempts
+            ctx.on('agent:dead', (agentId) => {
+                const ref = lastGlobalUser;
+                if (ref) {
+                    channelSendText(ref, `⚠ Agent "${agentId}" 多次崩溃已停止自动重启，请检查日志。`).catch(() => { });
+                }
+            });
+            // Permission cleanup interval
+            cleanupInterval = setInterval(() => permissionMgr.cleanup(), 60_000);
+            // --- Connect all channels ---
+            for (const ch of channels) {
+                try {
+                    await ch.connect();
+                    console.log(`[channel-manager] ${ch.label} connected`);
+                }
+                catch (err) {
+                    console.error(`[channel-manager] ${ch.label} connect failed: ${err.message}`);
+                }
+            }
+        },
+        async destroy() {
+            if (cleanupInterval)
+                clearInterval(cleanupInterval);
+            // Disconnect all channels
+            for (const ch of channels) {
+                try {
+                    await ch.disconnect();
+                    console.log(`[channel-manager] ${ch.label} disconnected`);
+                }
+                catch (err) {
+                    console.error(`[channel-manager] ${ch.label} disconnect failed: ${err.message}`);
+                }
+            }
+        },
+    };
+}
+/**
+ * Build the message content string sent to the spoke agent.
+ * Includes channel info and handles media/voice messages.
+ */
+function buildMessageContent(msg, routedText) {
+    const tag = `[${msg.channelType} ${msg.userId}]`;
+    if (msg.type === 'voice' && msg.voiceText)
+        return `${tag} (\u8BED\u97F3\u8F6C\u6587\u5B57) ${msg.voiceText}`;
+    if (msg.type === 'voice')
+        return `${tag} (\u8BED\u97F3\u6D88\u606F\uFF0C\u65E0\u6CD5\u8BC6\u522B)`;
+    if (msg.mediaPath)
+        return `${tag} (${msg.type} \u5DF2\u4E0B\u8F7D\u5230 ${msg.mediaPath})`;
+    if (msg.type !== 'text')
+        return `${tag} (${msg.type} \u6D88\u606F\uFF0C\u4E0B\u8F7D\u5931\u8D25)`;
+    return `${tag} ${routedText}`;
+}

package/dist/plugins/cron-scheduler/db.d.ts

@@ -0,0 +1,12 @@
+import Database from 'better-sqlite3';
+import type { CronJob, CronRun } from '../../shared/types.js';
+export declare function openCronDb(): Database.Database;
+export declare function closeCronDb(): void;
+export declare function createJob(job: Omit<CronJob, 'id' | 'createdAt'>): CronJob;
+export declare function deleteJob(id: string): boolean;
+export declare function updateJob(id: string, updates: Partial<Pick<CronJob, 'enabled' | 'nextRun' | 'name' | 'message' | 'scheduleValue' | 'scheduleType' | 'timezone'>>): boolean;
+export declare function listJobs(agentId?: string): CronJob[];
+export declare function getEnabledJobs(): CronJob[];
+export declare function recordRun(jobId: string, status: CronRun['status'], detail?: string): string;
+export declare function getRecentRuns(jobId: string, limit?: number): CronRun[];
+export declare function cleanupRuns(): number;

package/dist/plugins/cron-scheduler/db.js

@@ -0,0 +1,160 @@
+import Database from 'better-sqlite3';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { SOCKET_DIR } from '../../shared/socket.js';
+const DB_PATH = join(SOCKET_DIR, 'cc2im.db');
+const RUNS_TTL_DAYS = 30;
+let db = null;
+export function openCronDb() {
+    if (db)
+        return db;
+    db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('busy_timeout = 5000');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS cron_jobs (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      agent_id TEXT NOT NULL,
+      schedule_type TEXT NOT NULL CHECK(schedule_type IN ('cron', 'once', 'interval')),
+      schedule_value TEXT NOT NULL,
+      timezone TEXT NOT NULL DEFAULT 'Asia/Shanghai',
+      message TEXT NOT NULL,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      next_run TEXT,
+      created_at TEXT NOT NULL,
+      created_by TEXT NOT NULL DEFAULT 'dashboard'
+    );
+    CREATE INDEX IF NOT EXISTS idx_cron_next ON cron_jobs(next_run) WHERE enabled = 1;
+
+    CREATE TABLE IF NOT EXISTS cron_runs (
+      id TEXT PRIMARY KEY,
+      job_id TEXT NOT NULL,
+      fired_at TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('delivered', 'queued', 'failed')),
+      detail TEXT
+    );
+    CREATE INDEX IF NOT EXISTS idx_runs_job ON cron_runs(job_id, fired_at);
+  `);
+    return db;
+}
+export function closeCronDb() {
+    db?.close();
+    db = null;
+}
+// --- helpers ---
+function rowToJob(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        agentId: row.agent_id,
+        scheduleType: row.schedule_type,
+        scheduleValue: row.schedule_value,
+        timezone: row.timezone,
+        message: row.message,
+        enabled: row.enabled === 1,
+        nextRun: row.next_run ?? null,
+        createdAt: row.created_at,
+        createdBy: row.created_by,
+    };
+}
+function rowToRun(row) {
+    return {
+        id: row.id,
+        jobId: row.job_id,
+        firedAt: row.fired_at,
+        status: row.status,
+        detail: row.detail ?? undefined,
+    };
+}
+// --- CRUD ---
+export function createJob(job) {
+    const id = randomUUID();
+    const createdAt = new Date().toISOString();
+    openCronDb().prepare(`
+    INSERT INTO cron_jobs (id, name, agent_id, schedule_type, schedule_value, timezone, message, enabled, next_run, created_at, created_by)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, job.name, job.agentId, job.scheduleType, job.scheduleValue, job.timezone, job.message, job.enabled ? 1 : 0, job.nextRun ?? null, createdAt, job.createdBy);
+    return { ...job, id, createdAt };
+}
+export function deleteJob(id) {
+    const d = openCronDb();
+    d.prepare('DELETE FROM cron_runs WHERE job_id = ?').run(id);
+    const result = d.prepare('DELETE FROM cron_jobs WHERE id = ?').run(id);
+    return result.changes > 0;
+}
+export function updateJob(id, updates) {
+    const setClauses = [];
+    const values = [];
+    if (updates.enabled !== undefined) {
+        setClauses.push('enabled = ?');
+        values.push(updates.enabled ? 1 : 0);
+    }
+    if (updates.nextRun !== undefined) {
+        setClauses.push('next_run = ?');
+        values.push(updates.nextRun);
+    }
+    if (updates.name !== undefined) {
+        setClauses.push('name = ?');
+        values.push(updates.name);
+    }
+    if (updates.message !== undefined) {
+        setClauses.push('message = ?');
+        values.push(updates.message);
+    }
+    if (updates.scheduleValue !== undefined) {
+        setClauses.push('schedule_value = ?');
+        values.push(updates.scheduleValue);
+    }
+    if (updates.scheduleType !== undefined) {
+        setClauses.push('schedule_type = ?');
+        values.push(updates.scheduleType);
+    }
+    if (updates.timezone !== undefined) {
+        setClauses.push('timezone = ?');
+        values.push(updates.timezone);
+    }
+    if (setClauses.length === 0)
+        return false;
+    values.push(id);
+    const result = openCronDb()
+        .prepare(`UPDATE cron_jobs SET ${setClauses.join(', ')} WHERE id = ?`)
+        .run(...values);
+    return result.changes > 0;
+}
+export function listJobs(agentId) {
+    const d = openCronDb();
+    const rows = agentId
+        ? d.prepare('SELECT * FROM cron_jobs WHERE agent_id = ? ORDER BY created_at DESC').all(agentId)
+        : d.prepare('SELECT * FROM cron_jobs ORDER BY created_at DESC').all();
+    return rows.map(rowToJob);
+}
+export function getEnabledJobs() {
+    const rows = openCronDb()
+        .prepare('SELECT * FROM cron_jobs WHERE enabled = 1 ORDER BY next_run ASC')
+        .all();
+    return rows.map(rowToJob);
+}
+export function recordRun(jobId, status, detail) {
+    const id = randomUUID();
+    const firedAt = new Date().toISOString();
+    openCronDb().prepare(`
+    INSERT INTO cron_runs (id, job_id, fired_at, status, detail)
+    VALUES (?, ?, ?, ?, ?)
+  `).run(id, jobId, firedAt, status, detail ?? null);
+    return id;
+}
+export function getRecentRuns(jobId, limit = 20) {
+    const rows = openCronDb()
+        .prepare('SELECT * FROM cron_runs WHERE job_id = ? ORDER BY fired_at DESC LIMIT ?')
+        .all(jobId, limit);
+    return rows.map(rowToRun);
+}
+export function cleanupRuns() {
+    const cutoff = new Date();
+    cutoff.setDate(cutoff.getDate() - RUNS_TTL_DAYS);
+    const result = openCronDb()
+        .prepare('DELETE FROM cron_runs WHERE fired_at < ?')
+        .run(cutoff.toISOString());
+    return result.changes;
+}

package/dist/plugins/cron-scheduler/index.d.ts

@@ -0,0 +1,4 @@
+import type { Cc2imPlugin } from '../../shared/plugin.js';
+export declare function createCronSchedulerPlugin(): Cc2imPlugin;
+export { createJob, deleteJob, updateJob, listJobs, getRecentRuns } from './db.js';
+export { CronScheduler } from './scheduler.js';

package/dist/plugins/cron-scheduler/index.js

@@ -0,0 +1,22 @@
+import { openCronDb, closeCronDb } from './db.js';
+import { CronScheduler } from './scheduler.js';
+export function createCronSchedulerPlugin() {
+    let scheduler = null;
+    return {
+        name: 'cron-scheduler',
+        init(ctx) {
+            openCronDb();
+            console.log('[cron-scheduler] SQLite tables ready');
+            scheduler = new CronScheduler(ctx);
+            scheduler.start();
+        },
+        destroy() {
+            scheduler?.stop();
+            closeCronDb();
+            console.log('[cron-scheduler] Stopped');
+        },
+    };
+}
+// Re-export for hub management handler
+export { createJob, deleteJob, updateJob, listJobs, getRecentRuns } from './db.js';
+export { CronScheduler } from './scheduler.js';

package/dist/plugins/cron-scheduler/scheduler.d.ts

@@ -0,0 +1,20 @@
+import type { HubContext } from '../../shared/plugin.js';
+export declare class CronScheduler {
+    private ctx;
+    private tickTimer;
+    private cleanupTimer;
+    constructor(ctx: HubContext);
+    start(): void;
+    stop(): void;
+    /**
+     * Calculate next run time for a given schedule.
+     * Public so hub management handler can use it when creating/updating jobs.
+     */
+    calcNextRun(type: 'cron' | 'once' | 'interval', value: string, timezone: string): string | null;
+    /**
+     * Recalculate nextRun for all enabled jobs. Called on startup.
+     */
+    recalcAll(): void;
+    private tick;
+    private fire;
+}