cc2im 0.2.0

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

@@ -0,0 +1,129 @@
+import { Cron } from 'croner';
+import { getEnabledJobs, updateJob, recordRun, cleanupRuns } from './db.js';
+const TICK_INTERVAL_MS = 10_000; // check every 10s
+const CLEANUP_INTERVAL_MS = 60 * 60_000; // cleanup old runs every hour
+export class CronScheduler {
+    ctx;
+    tickTimer = null;
+    cleanupTimer = null;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    start() {
+        this.recalcAll();
+        this.tickTimer = setInterval(() => this.tick(), TICK_INTERVAL_MS);
+        this.cleanupTimer = setInterval(() => {
+            const deleted = cleanupRuns();
+            if (deleted > 0) {
+                console.log(`[cron] cleaned up ${deleted} old run records`);
+            }
+        }, CLEANUP_INTERVAL_MS);
+        console.log('[cron] scheduler started');
+    }
+    stop() {
+        if (this.tickTimer) {
+            clearInterval(this.tickTimer);
+            this.tickTimer = null;
+        }
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+        console.log('[cron] scheduler stopped');
+    }
+    /**
+     * Calculate next run time for a given schedule.
+     * Public so hub management handler can use it when creating/updating jobs.
+     */
+    calcNextRun(type, value, timezone) {
+        switch (type) {
+            case 'cron': {
+                try {
+                    const job = new Cron(value, { timezone });
+                    const next = job.nextRun();
+                    return next ? next.toISOString() : null;
+                }
+                catch {
+                    return null;
+                }
+            }
+            case 'once': {
+                const d = new Date(value);
+                return d.getTime() > Date.now() ? d.toISOString() : null;
+            }
+            case 'interval': {
+                const ms = parseInt(value, 10);
+                if (isNaN(ms) || ms <= 0)
+                    return null;
+                return new Date(Date.now() + ms).toISOString();
+            }
+            default:
+                return null;
+        }
+    }
+    /**
+     * Recalculate nextRun for all enabled jobs. Called on startup.
+     */
+    recalcAll() {
+        const jobs = getEnabledJobs();
+        let updated = 0;
+        const now = new Date().toISOString();
+        for (const job of jobs) {
+            // Interval jobs: keep existing nextRun if still in the future
+            if (job.scheduleType === 'interval' && job.nextRun && job.nextRun > now)
+                continue;
+            const nextRun = this.calcNextRun(job.scheduleType, job.scheduleValue, job.timezone);
+            if (nextRun !== job.nextRun) {
+                updateJob(job.id, { nextRun });
+                updated++;
+            }
+        }
+        if (updated > 0) {
+            console.log(`[cron] recalculated nextRun for ${updated} jobs`);
+        }
+    }
+    // --- private ---
+    tick() {
+        const now = new Date().toISOString();
+        const jobs = getEnabledJobs();
+        for (const job of jobs) {
+            if (!job.nextRun)
+                continue;
+            if (job.nextRun > now)
+                continue; // ISO string comparison works for future dates
+            this.fire(job);
+        }
+    }
+    fire(job) {
+        const msg = {
+            type: 'message',
+            userId: `cron:${job.name}`,
+            text: job.message,
+            msgType: 'text',
+            timestamp: new Date().toISOString(),
+        };
+        const delivered = this.ctx.deliverToAgent(job.agentId, msg);
+        const status = delivered ? 'delivered' : 'queued';
+        recordRun(job.id, status, delivered ? undefined : 'agent offline, queued for replay');
+        console.log(`[cron] fired job "${job.name}" → ${job.agentId} (${status})`);
+        // Recalculate next run
+        let nextRun;
+        if (job.scheduleType === 'once') {
+            // One-shot job: disable after firing
+            nextRun = null;
+            updateJob(job.id, { nextRun, enabled: false });
+        }
+        else {
+            nextRun = this.calcNextRun(job.scheduleType, job.scheduleValue, job.timezone);
+            updateJob(job.id, { nextRun });
+        }
+        // Broadcast monitor event
+        this.ctx.broadcastMonitor({
+            kind: 'cron_fired',
+            agentId: job.agentId,
+            timestamp: new Date().toISOString(),
+            userId: `cron:${job.name}`,
+            text: job.message,
+        });
+    }
+}

package/dist/plugins/persistence/db.d.ts

@@ -0,0 +1,24 @@
+import Database from 'better-sqlite3';
+export declare function openDb(): Database.Database;
+export declare function closeDb(): void;
+export declare function storeInbound(agentId: string, userId: string, text: string, msgType: string, mediaPath?: string, channelId?: string): string;
+export declare function storeOutbound(agentId: string, userId: string, text: string, channelId?: string): string;
+export declare function markDelivered(messageId: string): void;
+export declare function getPending(agentId: string): Array<{
+    id: string;
+    userId: string;
+    text: string;
+    msgType: string;
+    mediaPath: string | null;
+    createdAt: string;
+}>;
+export declare function cleanup(): {
+    expired: number;
+    deleted: number;
+};
+export declare function getNicknames(): Array<{
+    channelId: string;
+    userId: string;
+    nickname: string;
+}>;
+export declare function setNickname(channelId: string, userId: string, nickname: string): void;

package/dist/plugins/persistence/db.js

@@ -0,0 +1,121 @@
+import Database from 'better-sqlite3';
+import { join } from 'node:path';
+import { SOCKET_DIR } from '../../shared/socket.js';
+import { randomUUID } from 'node:crypto';
+const DB_PATH = join(SOCKET_DIR, 'cc2im.db');
+const DELIVERY_TTL_MS = 24 * 60 * 60 * 1000;
+const HISTORY_TTL_DAYS = 30;
+const MAX_ROWS = 100_000;
+let db = null;
+export function openDb() {
+    if (db)
+        return db;
+    db = new Database(DB_PATH);
+    db.pragma('journal_mode = WAL');
+    db.pragma('wal_autocheckpoint = 1000');
+    db.pragma('busy_timeout = 5000');
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS messages (
+      id TEXT PRIMARY KEY,
+      direction TEXT NOT NULL CHECK(direction IN ('inbound', 'outbound')),
+      agent_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      text TEXT NOT NULL,
+      msg_type TEXT DEFAULT 'text',
+      media_path TEXT,
+      created_at TEXT NOT NULL,
+      delivered_at TEXT,
+      expired INTEGER DEFAULT 0
+    );
+    CREATE INDEX IF NOT EXISTS idx_pending
+      ON messages(agent_id, delivered_at) WHERE delivered_at IS NULL AND expired = 0;
+    CREATE INDEX IF NOT EXISTS idx_created
+      ON messages(created_at);
+  `);
+    // Idempotent column add (SQLite doesn't support IF NOT EXISTS for columns)
+    try {
+        db.exec(`ALTER TABLE messages ADD COLUMN channel_id TEXT`);
+    }
+    catch {
+        // column already exists, ignore
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS nicknames (
+      channel_id TEXT NOT NULL,
+      user_id TEXT NOT NULL,
+      nickname TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (channel_id, user_id)
+    );
+  `);
+    return db;
+}
+export function closeDb() {
+    db?.close();
+    db = null;
+}
+export function storeInbound(agentId, userId, text, msgType, mediaPath, channelId) {
+    const id = randomUUID();
+    openDb().prepare(`
+    INSERT INTO messages (id, direction, agent_id, user_id, text, msg_type, media_path, channel_id, created_at)
+    VALUES (?, 'inbound', ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, agentId, userId, text, msgType, mediaPath ?? null, channelId ?? null, new Date().toISOString());
+    return id;
+}
+export function storeOutbound(agentId, userId, text, channelId) {
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    openDb().prepare(`
+    INSERT INTO messages (id, direction, agent_id, user_id, text, channel_id, created_at, delivered_at)
+    VALUES (?, 'outbound', ?, ?, ?, ?, ?, ?)
+  `).run(id, agentId, userId, text, channelId ?? null, now, now);
+    return id;
+}
+export function markDelivered(messageId) {
+    openDb().prepare(`UPDATE messages SET delivered_at = ? WHERE id = ?`)
+        .run(new Date().toISOString(), messageId);
+}
+export function getPending(agentId) {
+    return openDb().prepare(`
+    SELECT id, user_id as userId, text, msg_type as msgType, media_path as mediaPath, created_at as createdAt
+    FROM messages
+    WHERE agent_id = ? AND direction = 'inbound' AND delivered_at IS NULL AND expired = 0
+    ORDER BY created_at ASC
+  `).all(agentId);
+}
+export function cleanup() {
+    const d = openDb();
+    const cutoff = new Date(Date.now() - DELIVERY_TTL_MS).toISOString();
+    const expired = d.prepare(`
+    UPDATE messages SET expired = 1
+    WHERE delivered_at IS NULL AND expired = 0 AND created_at < ?
+  `).run(cutoff).changes;
+    const histCutoff = new Date();
+    histCutoff.setDate(histCutoff.getDate() - HISTORY_TTL_DAYS);
+    const deleted = d.prepare(`DELETE FROM messages WHERE created_at < ?`)
+        .run(histCutoff.toISOString()).changes;
+    const count = d.prepare('SELECT COUNT(*) as c FROM messages').get().c;
+    let extraDeleted = 0;
+    if (count > MAX_ROWS) {
+        extraDeleted = d.prepare(`
+      DELETE FROM messages WHERE id IN (
+        SELECT id FROM messages ORDER BY created_at ASC LIMIT ?
+      )
+    `).run(count - MAX_ROWS).changes;
+    }
+    if (expired > 0 || deleted > 0 || extraDeleted > 0) {
+        d.exec('VACUUM');
+    }
+    return { expired, deleted: deleted + extraDeleted };
+}
+export function getNicknames() {
+    return openDb().prepare(`SELECT channel_id AS channelId, user_id AS userId, nickname FROM nicknames`).all();
+}
+export function setNickname(channelId, userId, nickname) {
+    const now = new Date().toISOString();
+    openDb().prepare(`
+    INSERT INTO nicknames (channel_id, user_id, nickname, updated_at)
+    VALUES (?, ?, ?, ?)
+    ON CONFLICT(channel_id, user_id) DO UPDATE SET nickname = excluded.nickname, updated_at = excluded.updated_at
+  `).run(channelId, userId, nickname, now);
+}

package/dist/plugins/persistence/index.d.ts

@@ -0,0 +1,2 @@
+import type { Cc2imPlugin } from '../../shared/plugin.js';
+export declare function createPersistencePlugin(): Cc2imPlugin;

package/dist/plugins/persistence/index.js

@@ -0,0 +1,93 @@
+import { openDb, closeDb, storeInbound, storeOutbound, markDelivered, getPending, cleanup } from './db.js';
+const REPLAY_DELAY_MS = 500;
+const CLEANUP_INTERVAL = 60 * 60 * 1000;
+/**
+ * Replay pending messages for an agent. Safe to call multiple times —
+ * only replays messages not yet marked as delivered.
+ */
+async function doReplay(ctx, agentId) {
+    const pending = getPending(agentId);
+    if (pending.length === 0)
+        return 0;
+    console.log(`[persistence] Replaying ${pending.length} queued message(s) to "${agentId}"`);
+    ctx.deliverToAgent(agentId, {
+        type: 'message',
+        userId: 'system',
+        text: `[系统] 你离线期间收到 ${pending.length} 条消息，正在回放：`,
+        msgType: 'text',
+        timestamp: new Date().toISOString(),
+    });
+    for (const msg of pending) {
+        await new Promise(r => setTimeout(r, REPLAY_DELAY_MS));
+        const ok = ctx.deliverToAgent(agentId, {
+            type: 'message',
+            userId: msg.userId,
+            text: msg.text,
+            msgType: msg.msgType,
+            mediaPath: msg.mediaPath ?? undefined,
+            timestamp: msg.createdAt,
+        });
+        if (ok)
+            markDelivered(msg.id);
+    }
+    console.log(`[persistence] Replay complete for "${agentId}"`);
+    return pending.length;
+}
+export function createPersistencePlugin() {
+    let cleanupTimer;
+    const pendingDeliveries = new Map();
+    return {
+        name: 'persistence',
+        init(ctx) {
+            openDb();
+            console.log('[persistence] SQLite opened');
+            // Store inbound messages before delivery (skip system messages)
+            ctx.on('deliver:before', (agentId, msg, deliveryId) => {
+                if (msg.type !== 'message')
+                    return;
+                if (msg.userId === 'system')
+                    return;
+                const m = msg;
+                const dbId = storeInbound(agentId, m.userId, m.text, m.msgType, m.mediaPath, m.channelId);
+                pendingDeliveries.set(deliveryId, { agentId, messageId: dbId });
+            });
+            // Mark delivered after successful socket send
+            ctx.on('deliver:after', (deliveryId, delivered) => {
+                const entry = pendingDeliveries.get(deliveryId);
+                if (!entry)
+                    return;
+                pendingDeliveries.delete(deliveryId);
+                if (delivered) {
+                    markDelivered(entry.messageId);
+                }
+            });
+            // Store outbound replies for history
+            ctx.on('spoke:message', (_agentId, msg) => {
+                if (msg.type === 'reply') {
+                    storeOutbound(msg.agentId, msg.userId, msg.text);
+                }
+            });
+            // Primary replay: when agent comes online
+            // Works when WeChat context tokens are restored from cache
+            ctx.on('agent:online', (agentId) => {
+                doReplay(ctx, agentId).catch((err) => {
+                    console.error(`[persistence] Replay failed for "${agentId}":`, err instanceof Error ? err.message : String(err));
+                });
+            });
+            // Periodic cleanup
+            cleanupTimer = setInterval(() => {
+                const { expired, deleted } = cleanup();
+                if (expired > 0 || deleted > 0) {
+                    console.log(`[persistence] Cleanup: ${expired} expired, ${deleted} deleted`);
+                }
+            }, CLEANUP_INTERVAL);
+            cleanup();
+        },
+        destroy() {
+            if (cleanupTimer)
+                clearInterval(cleanupTimer);
+            closeDb();
+            console.log('[persistence] SQLite closed');
+        },
+    };
+}

package/dist/plugins/web-monitor/api-routes.d.ts

@@ -0,0 +1,33 @@
+/**
+ * cc2im Web — REST API route handler
+ *
+ * All /api/* routes for the dashboard. Extracted from server.ts
+ * so each concern lives in its own file.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { HubEventData } from '../../shared/types.js';
+import type { HubContext } from '../../shared/plugin.js';
+export interface ApiHandlerDeps {
+    agentsJsonPath: string;
+    mediaDir: string;
+    messageHistory: Array<{
+        event: HubEventData;
+        receivedAt: string;
+    }>;
+    monitor: {
+        isConnected(): boolean;
+    };
+    wsClients: {
+        size: number;
+    };
+    ctx?: HubContext;
+    activeQrPolls: Map<string, ReturnType<typeof setInterval>>;
+    broadcastWs: (msg: any) => void;
+    frontendDir?: string;
+}
+/**
+ * Create the HTTP request handler used by the web dashboard.
+ * Extracted so integration tests can exercise the real routing logic
+ * with mock dependencies (no SQLite, no hub socket, no filesystem).
+ */
+export declare function createApiHandler(deps: ApiHandlerDeps): (req: IncomingMessage, res: ServerResponse) => void;