cc2im 0.2.0

package/dist/plugins/web-monitor/server.d.ts

@@ -0,0 +1,14 @@
+/**
+ * cc2im Web — monitoring dashboard server
+ *
+ * Independent process: connects to hub.sock as monitor,
+ * serves React frontend + WebSocket events to browser.
+ */
+import type { HubContext } from '../../shared/plugin.js';
+export { createApiHandler, type ApiHandlerDeps } from './api-routes.js';
+export declare function startWeb(options: {
+    port: number;
+    ctx?: HubContext;
+}): Promise<{
+    shutdown: () => void;
+}>;

package/dist/plugins/web-monitor/server.js

@@ -0,0 +1,205 @@
+/**
+ * cc2im Web — monitoring dashboard server
+ *
+ * Independent process: connects to hub.sock as monitor,
+ * serves React frontend + WebSocket events to browser.
+ */
+import { createServer } from 'node:http';
+import { readFileSync, writeFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { WebSocketServer, WebSocket } from 'ws';
+import { MonitorClient } from './monitor-client.js';
+import { LogTailer } from './log-tailer.js';
+import { SOCKET_DIR } from '../../shared/socket.js';
+import { getNicknames } from '../persistence/db.js';
+import { listJobs, getRecentRuns } from '../cron-scheduler/db.js';
+import { createApiHandler } from './api-routes.js';
+// Re-export for test backward compat
+export { createApiHandler } from './api-routes.js';
+const AGENTS_JSON_PATH = join(SOCKET_DIR, 'agents.json');
+export async function startWeb(options) {
+    const { port, ctx } = options;
+    const host = '127.0.0.1';
+    // --- Track agent state from monitor events ---
+    const agentState = new Map();
+    const MAX_HISTORY = 200;
+    const HISTORY_PATH = join(SOCKET_DIR, 'web-messages.json');
+    const activeQrPolls = new Map();
+    // Load persisted history on startup
+    let messageHistory = [];
+    try {
+        if (existsSync(HISTORY_PATH)) {
+            messageHistory = JSON.parse(readFileSync(HISTORY_PATH, 'utf8')).slice(-MAX_HISTORY);
+        }
+    }
+    catch { }
+    let historyDirty = false;
+    function pushHistory(event) {
+        messageHistory.push({ event, receivedAt: new Date().toISOString() });
+        if (messageHistory.length > MAX_HISTORY)
+            messageHistory.shift();
+        historyDirty = true;
+    }
+    // Persist to disk every 5s if changed
+    setInterval(() => {
+        if (!historyDirty)
+            return;
+        historyDirty = false;
+        try {
+            writeFileSync(HISTORY_PATH, JSON.stringify(messageHistory));
+        }
+        catch { }
+    }, 5000);
+    // --- Monitor Client ---
+    const monitor = new MonitorClient((hubEvent) => {
+        const ev = hubEvent.event;
+        // Update local agent state
+        if (ev.kind === 'agent_online') {
+            agentState.set(ev.agentId, { status: 'connected', onlineSince: ev.timestamp });
+        }
+        else if (ev.kind === 'agent_offline') {
+            agentState.set(ev.agentId, { status: 'stopped' });
+        }
+        // Track message history
+        if (['message_in', 'message_out', 'permission_request', 'permission_verdict'].includes(ev.kind)) {
+            pushHistory(ev);
+        }
+        // Broadcast to all browser WebSocket clients
+        broadcastWs({ type: 'hub_event', event: ev });
+    });
+    // --- Log Tailer ---
+    const MAX_LOG_LINES = 200;
+    const logBuffer = [];
+    let wsReady = false;
+    const logTailer = new LogTailer((source, line) => {
+        logBuffer.push({ source, line });
+        if (logBuffer.length > MAX_LOG_LINES)
+            logBuffer.shift();
+        if (wsReady)
+            broadcastWs({ type: 'log', source, line });
+    });
+    // Tail hub log
+    const hubLogPath = join(SOCKET_DIR, 'hub.log');
+    logTailer.tail('hub', hubLogPath);
+    // Tail spoke logs for known agents
+    function tailAgentLogs() {
+        if (!existsSync(AGENTS_JSON_PATH))
+            return;
+        try {
+            const config = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+            for (const name of Object.keys(config.agents)) {
+                const spokeLog = join(SOCKET_DIR, 'agents', name, 'spoke.log');
+                logTailer.tail(name, spokeLog);
+            }
+        }
+        catch { }
+    }
+    tailAgentLogs();
+    // --- WebSocket (declared early so handler can reference wsClients) ---
+    const wsClients = new Set();
+    function broadcastWs(msg) {
+        if (wsClients.size === 0)
+            return;
+        const data = JSON.stringify(msg);
+        for (const ws of wsClients) {
+            if (ws.readyState === WebSocket.OPEN) {
+                ws.send(data);
+            }
+        }
+    }
+    // --- HTTP Server ---
+    const frontendDir = join(import.meta.dirname, '..', '..', '..', 'dist', 'web-frontend');
+    const handler = createApiHandler({
+        agentsJsonPath: AGENTS_JSON_PATH,
+        mediaDir: join(SOCKET_DIR, 'media'),
+        messageHistory,
+        monitor,
+        wsClients,
+        ctx,
+        activeQrPolls,
+        broadcastWs,
+        frontendDir,
+    });
+    const httpServer = createServer(handler);
+    const wss = new WebSocketServer({ server: httpServer, path: '/ws' });
+    wsReady = true;
+    wss.on('connection', (ws) => {
+        wsClients.add(ws);
+        console.log(`[web] Browser connected (${wsClients.size} clients)`);
+        // Send snapshot on connect
+        const snapshot = getSnapshot();
+        ws.send(JSON.stringify({ type: 'snapshot', ...snapshot }));
+        ws.on('close', () => {
+            wsClients.delete(ws);
+            console.log(`[web] Browser disconnected (${wsClients.size} clients)`);
+        });
+    });
+    function getSnapshot() {
+        let agents = [];
+        try {
+            if (existsSync(AGENTS_JSON_PATH)) {
+                const config = JSON.parse(readFileSync(AGENTS_JSON_PATH, 'utf8'));
+                agents = Object.entries(config.agents).map(([name, agent]) => {
+                    const state = agentState.get(name);
+                    return {
+                        name,
+                        status: (state?.status || 'stopped'),
+                        cwd: agent.cwd,
+                        autoStart: agent.autoStart ?? false,
+                        isDefault: config.defaultAgent === name,
+                        onlineSince: state?.onlineSince,
+                    };
+                });
+            }
+        }
+        catch { }
+        let channelList = [];
+        if (ctx) {
+            channelList = ctx.getChannels().map(ch => ({
+                id: ch.id, type: ch.type, label: ch.label, status: ch.getStatus(),
+            }));
+        }
+        let nicknameList = [];
+        try {
+            nicknameList = getNicknames();
+        }
+        catch { }
+        let cronJobList = [];
+        try {
+            cronJobList = listJobs().map(j => ({ ...j, recentRuns: getRecentRuns(j.id, 5) }));
+        }
+        catch { }
+        return {
+            agents,
+            hubConnected: monitor.isConnected(),
+            recentMessages: messageHistory.slice(-50),
+            recentLogs: logBuffer.slice(-100),
+            channels: channelList,
+            nicknames: nicknameList,
+            cronJobs: cronJobList,
+        };
+    }
+    // --- Start ---
+    monitor.connect();
+    httpServer.on('error', (err) => {
+        console.error(`[web] HTTP server error: ${err.message}`);
+    });
+    wss.on('error', (err) => {
+        console.error(`[web] WebSocket server error: ${err.message}`);
+    });
+    httpServer.listen(port, host, () => {
+        console.log(`[web] Dashboard: http://${host}:${port}`);
+        console.log(`[web] WebSocket: ws://${host}:${port}/ws`);
+        console.log(`[web] Hub: ${monitor.isConnected() ? 'connected' : 'connecting...'}`);
+    });
+    // Return shutdown handle — caller manages when to invoke
+    return {
+        shutdown() {
+            console.log('[web] Shutting down...');
+            logTailer.stop();
+            monitor.disconnect();
+            wss.close();
+            httpServer.close();
+        },
+    };
+}

package/dist/plugins/web-monitor/stats-reader.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Stats Reader — polls ~/.claude/stats-cache.json
+ */
+export interface StatsData {
+    dailyActivity: Array<{
+        date: string;
+        messageCount: number;
+        sessionCount: number;
+        toolCallCount: number;
+    }>;
+    dailyModelTokens: Array<{
+        date: string;
+        tokensByModel: Record<string, number>;
+    }>;
+    modelUsage: Record<string, {
+        inputTokens: number;
+        outputTokens: number;
+        cacheReadInputTokens: number;
+        cacheCreationInputTokens: number;
+    }>;
+}
+export declare function readStats(): StatsData | null;

package/dist/plugins/web-monitor/stats-reader.js

@@ -0,0 +1,17 @@
+/**
+ * Stats Reader — polls ~/.claude/stats-cache.json
+ */
+import { readFileSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const STATS_PATH = join(homedir(), '.claude', 'stats-cache.json');
+export function readStats() {
+    if (!existsSync(STATS_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(STATS_PATH, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}

package/dist/plugins/web-monitor/token-stats.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Token Stats — parse transcript JSONL files for accurate token usage
+ */
+export interface DailyTokens {
+    date: string;
+    input: number;
+    output: number;
+    cacheRead: number;
+    cacheCreate: number;
+    cost?: number;
+}
+export interface TokenStats {
+    daily: DailyTokens[];
+    lastUpdated: string;
+    todayCost?: number;
+    avgDailyCost?: number;
+    pricingDate?: string;
+}
+export declare function getTokenStats(): TokenStats;

package/dist/plugins/web-monitor/token-stats.js

@@ -0,0 +1,86 @@
+/**
+ * Token Stats — parse transcript JSONL files for accurate token usage
+ */
+import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+const pricingPath = join(import.meta.dirname, 'pricing.json');
+const pricing = JSON.parse(readFileSync(pricingPath, 'utf8'));
+const PROJECTS_DIR = join(homedir(), '.claude', 'projects');
+const MAX_AGE_MS = 30 * 24 * 60 * 60 * 1000; // Only read files modified in last 30 days
+let cachedStats = null;
+let lastComputeTime = 0;
+const CACHE_TTL_MS = 30_000; // Recompute at most every 30s (parsing ~800 files takes ~1.5s)
+export function getTokenStats() {
+    const now = Date.now();
+    if (cachedStats && now - lastComputeTime < CACHE_TTL_MS) {
+        return cachedStats;
+    }
+    cachedStats = computeTokenStats();
+    lastComputeTime = now;
+    return cachedStats;
+}
+function computeTokenStats() {
+    const daily = new Map();
+    if (!existsSync(PROJECTS_DIR)) {
+        return { daily: [], lastUpdated: new Date().toISOString() };
+    }
+    const cutoff = Date.now() - MAX_AGE_MS;
+    function scanDir(dir) {
+        for (const entry of readdirSync(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                scanDir(full);
+                continue;
+            }
+            if (!entry.name.endsWith('.jsonl'))
+                continue;
+            try {
+                // Skip files not modified in the last 30 days
+                if (statSync(full).mtimeMs < cutoff)
+                    continue;
+                const content = readFileSync(full, 'utf8');
+                for (const line of content.split('\n')) {
+                    if (!line.includes('input_tokens'))
+                        continue;
+                    try {
+                        const rec = JSON.parse(line);
+                        const u = rec.message?.usage;
+                        if (!u)
+                            continue;
+                        // Use local date (not UTC) so "today" matches user's midnight
+                        const date = rec.timestamp ? new Date(rec.timestamp).toLocaleDateString('sv-SE') : null;
+                        if (!date)
+                            continue;
+                        const d = daily.get(date) || { date, input: 0, output: 0, cacheRead: 0, cacheCreate: 0 };
+                        d.input += u.input_tokens || 0;
+                        d.output += u.output_tokens || 0;
+                        d.cacheRead += u.cache_read_input_tokens || 0;
+                        d.cacheCreate += u.cache_creation_input_tokens || 0;
+                        daily.set(date, d);
+                    }
+                    catch { }
+                }
+            }
+            catch { }
+        }
+    }
+    scanDir(PROJECTS_DIR);
+    const sorted = [...daily.values()].sort((a, b) => a.date.localeCompare(b.date));
+    // Calculate cost per day using default Opus 4.6 pricing
+    const p = pricing.models['claude-opus-4-6'];
+    for (const d of sorted) {
+        d.cost = (d.input * p.input + d.output * p.output + d.cacheRead * p.cacheRead + d.cacheCreate * p.cacheCreate) / 1_000_000;
+    }
+    const today = new Date().toLocaleDateString('sv-SE');
+    const todayData = sorted.find(d => d.date === today);
+    const last30 = sorted.slice(-30);
+    const totalCost = last30.reduce((s, d) => s + (d.cost || 0), 0);
+    return {
+        daily: sorted,
+        lastUpdated: new Date().toISOString(),
+        todayCost: todayData?.cost,
+        avgDailyCost: last30.length > 0 ? totalCost / last30.length : undefined,
+        pricingDate: pricing.lastChecked,
+    };
+}

package/dist/plugins/web-monitor/usage-stats.d.ts

@@ -0,0 +1,13 @@
+export interface UsageStats {
+    fiveHour?: {
+        utilization: number;
+        resetsAt: string;
+    };
+    sevenDay?: {
+        utilization: number;
+        resetsAt: string;
+    };
+    lastUpdated: string;
+    error?: string;
+}
+export declare function getUsageStats(): UsageStats;

package/dist/plugins/web-monitor/usage-stats.js

@@ -0,0 +1,56 @@
+import { execSync } from 'node:child_process';
+let cachedUsage = null;
+let nextFetchAt = 0;
+const CACHE_TTL_MS = 5 * 60_000; // 5 min normal interval
+const BACKOFF_BASE_MS = 60_000; // 60s base on 429
+const BACKOFF_MAX_MS = 5 * 60_000; // 5 min max backoff
+let consecutiveErrors = 0;
+export function getUsageStats() {
+    const now = Date.now();
+    if (now < nextFetchAt) {
+        return cachedUsage || { lastUpdated: '' };
+    }
+    const result = fetchUsage();
+    if (result.error) {
+        consecutiveErrors++;
+        // Exponential backoff: 60s, 120s, 240s, 300s (cap)
+        const backoff = Math.min(BACKOFF_BASE_MS * Math.pow(2, consecutiveErrors - 1), BACKOFF_MAX_MS);
+        nextFetchAt = now + backoff;
+        // Keep last successful data in memory
+        if (cachedUsage?.fiveHour)
+            return cachedUsage;
+        return result;
+    }
+    consecutiveErrors = 0;
+    nextFetchAt = now + CACHE_TTL_MS;
+    cachedUsage = result;
+    return cachedUsage;
+}
+function fetchUsage() {
+    try {
+        const creds = execSync('security find-generic-password -s "Claude Code-credentials" -w', { encoding: 'utf8', timeout: 3000 }).trim();
+        const { claudeAiOauth } = JSON.parse(creds);
+        if (!claudeAiOauth?.accessToken) {
+            return { lastUpdated: new Date().toISOString(), error: 'No OAuth token' };
+        }
+        const res = execSync(`curl -s -H "Authorization: Bearer ${claudeAiOauth.accessToken}" -H "anthropic-beta: oauth-2025-04-20" -H "User-Agent: claude-code/2.1" "https://api.anthropic.com/api/oauth/usage"`, { encoding: 'utf8', timeout: 10000 });
+        const data = JSON.parse(res);
+        if (data.error) {
+            return { lastUpdated: new Date().toISOString(), error: data.error.message || 'API error' };
+        }
+        return {
+            fiveHour: data.five_hour ? {
+                utilization: data.five_hour.utilization,
+                resetsAt: data.five_hour.resets_at,
+            } : undefined,
+            sevenDay: data.seven_day ? {
+                utilization: data.seven_day.utilization,
+                resetsAt: data.seven_day.resets_at,
+            } : undefined,
+            lastUpdated: new Date().toISOString(),
+        };
+    }
+    catch (err) {
+        return { lastUpdated: new Date().toISOString(), error: err.message };
+    }
+}

package/dist/plugins/weixin/chunker.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 结构感知的消息分段
+ *
+ * 设计原则：
+ * 1. 以「块」为原子单位 — 代码围栏、表格、列表等结构不在内部切割
+ * 2. 安全长度低于 SDK 的 2000 硬切，避免双重分段
+ * 3. 对未知内容类型有兜底 — 不依赖穷举所有格式
+ */
+/**
+ * 按块累积分段。
+ * - 尽量在块边界切割
+ * - 原子块超长时退化为行级切割
+ * - 单行超长时硬切（最终兜底）
+ */
+export declare function splitIntoChunks(text: string): string[];
+export declare function formatChunks(chunks: string[]): string[];

package/dist/plugins/weixin/chunker.js

@@ -0,0 +1,142 @@
+/**
+ * 结构感知的消息分段
+ *
+ * 设计原则：
+ * 1. 以「块」为原子单位 — 代码围栏、表格、列表等结构不在内部切割
+ * 2. 安全长度低于 SDK 的 2000 硬切，避免双重分段
+ * 3. 对未知内容类型有兜底 — 不依赖穷举所有格式
+ */
+// SDK chunkText 硬切在 2000，[1/N]\n 前缀占约 10 字符，留足余量
+const MAX_CHUNK = 1800;
+/**
+ * 将文本解析为结构块。
+ * 识别：代码围栏 (```)、表格 (|--|)、空行分隔的段落。
+ * 不识别的内容按空行分段 — 兜底而非穷举。
+ */
+function parseBlocks(text) {
+    const lines = text.split('\n');
+    const blocks = [];
+    let current = [];
+    let inCodeFence = false;
+    let inTable = false;
+    function flush(atomic = false) {
+        if (current.length > 0) {
+            blocks.push({ text: current.join('\n'), atomic });
+            current = [];
+        }
+    }
+    for (const line of lines) {
+        // 代码围栏开关
+        if (/^```/.test(line.trimStart())) {
+            if (!inCodeFence) {
+                // 进入代码块：先 flush 之前的段落
+                flush();
+                inCodeFence = true;
+                current.push(line);
+            }
+            else {
+                // 代码块结束
+                current.push(line);
+                inCodeFence = false;
+                flush(true);
+            }
+            continue;
+        }
+        if (inCodeFence) {
+            current.push(line);
+            continue;
+        }
+        // 表格检测：连续的 | 开头行
+        const isTableLine = /^\|/.test(line.trimStart());
+        if (isTableLine && !inTable) {
+            flush();
+            inTable = true;
+            current.push(line);
+            continue;
+        }
+        if (inTable && isTableLine) {
+            current.push(line);
+            continue;
+        }
+        if (inTable && !isTableLine) {
+            inTable = false;
+            flush(true);
+            // fall through to handle current line
+        }
+        // 空行 → 段落分隔
+        if (line.trim() === '') {
+            if (current.length > 0) {
+                // 保留空行作为段落间距
+                current.push(line);
+                flush();
+            }
+            continue;
+        }
+        current.push(line);
+    }
+    // 未闭合的代码围栏也要 flush（兜底）
+    flush(inCodeFence);
+    return blocks;
+}
+/**
+ * 按块累积分段。
+ * - 尽量在块边界切割
+ * - 原子块超长时退化为行级切割
+ * - 单行超长时硬切（最终兜底）
+ */
+export function splitIntoChunks(text) {
+    if (text.length <= MAX_CHUNK)
+        return [text];
+    const blocks = parseBlocks(text);
+    const chunks = [];
+    let buffer = '';
+    function pushBuffer() {
+        const trimmed = buffer.replace(/\n+$/, '');
+        if (trimmed)
+            chunks.push(trimmed);
+        buffer = '';
+    }
+    for (const block of blocks) {
+        // 块能整体放入当前 buffer
+        if (buffer.length + block.text.length + 1 <= MAX_CHUNK) {
+            buffer += (buffer ? '\n' : '') + block.text;
+            continue;
+        }
+        // 放不下 — 先 flush buffer
+        pushBuffer();
+        // 块本身不超限 → 直接作为新 buffer
+        if (block.text.length <= MAX_CHUNK) {
+            buffer = block.text;
+            continue;
+        }
+        // 超长块 — 退化为行级切割
+        const lines = block.text.split('\n');
+        for (const line of lines) {
+            if (buffer.length + line.length + 1 <= MAX_CHUNK) {
+                buffer += (buffer ? '\n' : '') + line;
+            }
+            else {
+                pushBuffer();
+                // 单行超长 — 硬切兜底
+                if (line.length > MAX_CHUNK) {
+                    let remaining = line;
+                    while (remaining.length > MAX_CHUNK) {
+                        chunks.push(remaining.slice(0, MAX_CHUNK));
+                        remaining = remaining.slice(MAX_CHUNK);
+                    }
+                    buffer = remaining;
+                }
+                else {
+                    buffer = line;
+                }
+            }
+        }
+    }
+    pushBuffer();
+    return chunks;
+}
+export function formatChunks(chunks) {
+    if (chunks.length <= 1)
+        return chunks;
+    return chunks.map((chunk, i) => `[${i + 1}/${chunks.length}]\n${chunk}`);
+}

package/dist/plugins/weixin/connection.d.ts

@@ -0,0 +1,46 @@
+/**
+ * 微信连接 + 收发
+ * 从 cc2wx 搬迁，适配 hub 架构
+ */
+export type IncomingMessage = {
+    userId: string;
+    type: string;
+    text?: string;
+    raw?: any;
+    timestamp?: Date;
+};
+export type OnMessageCallback = (msg: IncomingMessage & {
+    mediaPath?: string | null;
+    voiceText?: string | null;
+}) => void;
+export declare class WeixinConnection {
+    private bot;
+    private recentMessages;
+    private onIncoming;
+    private listening;
+    private cleanupTimer;
+    setMessageHandler(handler: OnMessageCallback): void;
+    /** Persist context tokens to disk so replies work after hub restart */
+    saveContextCache(channelId?: string): void;
+    /** Restore context tokens from disk. Call after login, before startListening. */
+    restoreContextCache(channelId?: string): void;
+    login(channelId?: string): Promise<string>;
+    startListening(): void;
+    startPolling(): Promise<void>;
+    /** Stop the polling loop and clear the message handler so reconnect starts clean. */
+    stop(): void;
+    startTyping(userId: string): Promise<void>;
+    stopTyping(userId: string): Promise<void>;
+    send(userId: string, text: string): Promise<void>;
+    /** Upload a local image and send it as an image message. */
+    sendImage(userId: string, filePath: string): Promise<void>;
+    /** Upload a local file and send it as a file message. */
+    sendFile(userId: string, filePath: string): Promise<void>;
+    /** Extract baseUrl, token, and contextToken from the SDK internals. */
+    private getBotCredentials;
+    /**
+     * POST /ilink/bot/sendmessage — mirrors the SDK's sendMessage()
+     * which is not re-exported from the package's main entry.
+     */
+    private callSendMessage;
+}