@cc-monitoring/proxy-core 0.3.1 → 0.4.1

package/dist/utils/sse-protocol.js

@@ -0,0 +1,121 @@
+/**
+ * SSE 帧协议：字节流 ↔ SSE 帧 的唯一知识收敛点。
+ *
+ * - SSE 帧（frame）：字节流按 SSE 规范切分出的单位，由若干字段行
+ *   （event: / data: / id: / 注释 / 空行分发）组成。
+ * - SSE 事件（event）：SSE 帧的 data 字段解析出的 JSON 消息。
+ *
+ * 解析遵循 HTML spec 的 event stream 语义：残帧缓冲、LF/CRLF/CR 行尾、
+ * 空行分发、字段行去掉恰好一个可选空格。
+ */
+/** 创建 SSE 帧解码器：每分发一个完整 SSE 帧回调一次 */
+export function createSSEDecoder(onFrame) {
+    // 残帧缓冲：跨 chunk 的不完整行
+    let leftover = '';
+    let event;
+    let data = [];
+    let id;
+    /** 分发当前帧：至少含一个 data 行才回调；分发后重置字段状态 */
+    function dispatch() {
+        if (data.length > 0) {
+            onFrame({ event, data, id });
+        }
+        event = undefined;
+        id = undefined;
+        data = [];
+    }
+    /** 处理一个完整行 */
+    function handleLine(line) {
+        // 空行 = 一帧分发
+        if (line === '') {
+            dispatch();
+            return;
+        }
+        // 以冒号开头的行是注释，忽略
+        if (line.startsWith(':'))
+            return;
+        let field;
+        let value;
+        const colon = line.indexOf(':');
+        if (colon === -1) {
+            field = line;
+            value = '';
+        }
+        else {
+            field = line.slice(0, colon);
+            value = line.slice(colon + 1);
+            // 去掉字段值行首恰好一个可选空格
+            if (value.startsWith(' '))
+                value = value.slice(1);
+        }
+        if (field === 'event') {
+            event = value;
+        }
+        else if (field === 'data') {
+            // 多行 data 逐行保留，消费时用 \n join
+            data.push(value);
+        }
+        else if (field === 'id') {
+            id = value;
+        }
+    }
+    /** 消费文本中所有完整行，末段保留为残帧 */
+    function feed(text) {
+        // CRLF 与单独 CR 统一为 LF
+        const normalized = text.replace(/\r\n?/g, '\n');
+        const lines = normalized.split('\n');
+        leftover = lines.pop() || '';
+        for (const line of lines)
+            handleLine(line);
+    }
+    return {
+        write(chunk) {
+            const chunkText = typeof chunk === 'string' ? chunk : chunk.toString('utf-8');
+            feed(leftover + chunkText);
+        },
+        end() {
+            // 先按残帧缓冲补一次切行
+            if (leftover !== '') {
+                const normalized = leftover.replace(/\r\n?/g, '\n');
+                leftover = '';
+                for (const line of normalized.split('\n'))
+                    handleLine(line);
+            }
+            // 再对缓冲中尚未分发的非空帧做一次分发（末尾无空行也能输出最后一帧）
+            if (data.length > 0)
+                dispatch();
+            // 清空状态
+            leftover = '';
+            event = undefined;
+            id = undefined;
+            data = [];
+        }
+    };
+}
+/**
+ * 编码单个 SSE 帧。data 为已序列化好的字符串（调用方负责 JSON.stringify）。
+ * 有 event：`event: <event>\ndata: <data>\n\n`；无 event：`data: <data>\n\n`。
+ */
+export function encodeSSEFrame(args) {
+    const prefix = args.event !== undefined ? `event: ${args.event}\n` : '';
+    return `${prefix}data: ${args.data}\n\n`;
+}
+/**
+ * 创建 SSE 事件解码器：帧 data 用 \n join 后，[DONE] 触发 onDone，
+ * 其余尝试 JSON.parse 成功后触发 onEvent，解析失败静默跳过。
+ */
+export function createEventDecoder(onEvent, onDone) {
+    return createSSEDecoder((frame) => {
+        const text = frame.data.join('\n');
+        if (text.trim() === '[DONE]') {
+            onDone?.();
+            return;
+        }
+        try {
+            onEvent(JSON.parse(text));
+        }
+        catch {
+            // 非 JSON data 静默跳过
+        }
+    });
+}

package/dist/utils/sse-stream-processor.d.ts

@@ -4,23 +4,18 @@ import { type ParsedUpstream } from './inject-loop.js';
  * SSE 增量流式处理器：边转发原始 chunk 到客户端，边增量解析事件累积状态。
  * stream end 后提供 getParsedUpstream() 和 hasInjectedToolUse() 供注入检测。
  *
- * 跨 chunk 行边界通过 leftover 缓冲处理（参考 SSEAccumulator）。
+ * 跨 chunk 残帧由内部 sse-protocol decoder 缓冲处理。
  */
 export declare class SSEStreamProcessor {
     events: any[];
-    private contentBlocks;
-    private stopReason;
-    private usage;
-    private leftover;
+    private decoder;
     private raw;
     constructor(raw: ServerResponse);
     /** 处理一个 chunk：转发到 reply.raw + 增量解析事件 */
     processChunk(chunk: Buffer): void;
-    /** 处理 leftover 中残留的最后一行（stream end 后调用） */
+    /** 收尾残帧（stream end 后调用） */
     flushLeftover(): void;
-    /** 增量解析单个事件，更新 contentBlocks / stopReason / usage */
-    private processEvent;
-    /** 从累积状态构建 ParsedUpstream */
+    /** 从累积事件构建 ParsedUpstream */
     getParsedUpstream(): ParsedUpstream;
     /** 检测是否有注入的 MCP tool_use */
     hasInjectedToolUse(): boolean;

package/dist/utils/sse-stream-processor.js

@@ -1,9 +1,10 @@
-import { findInjectedCall } from './inject-loop.js';
+import { findInjectedCall, parseUpstreamEvents } from './inject-loop.js';
+import { createEventDecoder } from './sse-protocol.js';
 /**
  * SSE 增量流式处理器：边转发原始 chunk 到客户端，边增量解析事件累积状态。
  * stream end 后提供 getParsedUpstream() 和 hasInjectedToolUse() 供注入检测。
  *
- * 跨 chunk 行边界通过 leftover 缓冲处理（参考 SSEAccumulator）。
+ * 跨 chunk 残帧由内部 sse-protocol decoder 缓冲处理。
  */
 export class SSEStreamProcessor {
     constructor(raw) {
@@ -13,29 +14,11 @@ export class SSEStreamProcessor {
             writable: true,
             value: []
         });
-        Object.defineProperty(this, "contentBlocks", {
+        Object.defineProperty(this, "decoder", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "stopReason", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
-        });
-        Object.defineProperty(this, "usage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: undefined
-        });
-        Object.defineProperty(this, "leftover", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ''
+            value: void 0
         });
         Object.defineProperty(this, "raw", {
             enumerable: true,
@@ -44,101 +27,27 @@ export class SSEStreamProcessor {
             value: void 0
         });
         this.raw = raw;
+        this.decoder = createEventDecoder((event) => this.events.push(event));
     }
     /** 处理一个 chunk：转发到 reply.raw + 增量解析事件 */
     processChunk(chunk) {
         // 转发原始 chunk 到客户端
         this.raw.write(chunk);
-        const text = this.leftover + chunk.toString('utf-8');
-        const lines = text.split('\n');
-        // 最后一行可能不完整，保留到下次
-        this.leftover = lines.pop() || '';
-        for (const line of lines) {
-            if (line.startsWith('data:')) {
-                const d = line.slice(5).trim();
-                if (!d || d === '[DONE]')
-                    continue;
-                try {
-                    const event = JSON.parse(d);
-                    this.events.push(event);
-                    this.processEvent(event);
-                }
-                catch {
-                    // 非 JSON 行跳过
-                }
-            }
-        }
+        this.decoder.write(chunk);
     }
-    /** 处理 leftover 中残留的最后一行（stream end 后调用） */
+    /** 收尾残帧（stream end 后调用） */
     flushLeftover() {
-        if (this.leftover.startsWith('data:')) {
-            const d = this.leftover.slice(5).trim();
-            if (d && d !== '[DONE]') {
-                try {
-                    const event = JSON.parse(d);
-                    this.events.push(event);
-                    this.processEvent(event);
-                }
-                catch {
-                    // skip
-                }
-            }
-        }
-        this.leftover = '';
+        this.decoder.end();
     }
-    /** 增量解析单个事件，更新 contentBlocks / stopReason / usage */
-    processEvent(e) {
-        if (e?.type === 'content_block_start') {
-            const cb = e.content_block || {};
-            this.contentBlocks.set(e.index, {
-                type: cb.type,
-                text: cb.type === 'text' ? '' : undefined,
-                id: cb.id,
-                name: cb.name,
-                input: cb.type === 'tool_use' ? '' : undefined
-            });
-        }
-        else if (e?.type === 'content_block_delta') {
-            const b = this.contentBlocks.get(e.index);
-            if (!b)
-                return;
-            const d = e.delta || {};
-            if (d.type === 'text_delta')
-                b.text = (b.text || '') + d.text;
-            if (d.type === 'thinking_delta')
-                b.text = (b.text || '') + d.thinking;
-            if (d.type === 'input_json_delta')
-                b.input = (b.input || '') + (d.partial_json || '');
-        }
-        else if (e?.type === 'message_delta') {
-            this.stopReason = e.delta?.stop_reason || this.stopReason;
-            this.usage = e.usage;
-        }
-    }
-    /** 从累积状态构建 ParsedUpstream */
+    /** 从累积事件构建 ParsedUpstream */
     getParsedUpstream() {
-        const ordered = Array.from(this.contentBlocks.entries())
-            .sort((a, b) => a[0] - b[0])
-            .map(([, b]) => {
-            if (b.type === 'tool_use') {
-                let input = {};
-                try {
-                    input = b.input ? JSON.parse(b.input) : {};
-                }
-                catch {
-                    input = {};
-                }
-                return { ...b, input };
-            }
-            return b;
-        });
-        return { blocks: ordered, stopReason: this.stopReason, usage: this.usage };
+        return parseUpstreamEvents(this.events);
     }
     /** 检测是否有注入的 MCP tool_use */
     hasInjectedToolUse() {
-        if (this.stopReason !== 'tool_use')
-            return false;
         const parsed = this.getParsedUpstream();
+        if (parsed.stopReason !== 'tool_use')
+            return false;
         return !!findInjectedCall(parsed);
     }
 }

package/dist/utils/sse-writer.d.ts

@@ -1,6 +1,6 @@
 import type { ServerResponse } from 'http';
 /**
- * SSE 构造器（后端）—— 与 sse-accumulator（解析器）互为逆向。
+ * SSE 构造器（后端）—— 与 sse-protocol（帧解析器）互为逆向。
  *
  * 用于 proxy 主动构造并回写合成 SSE 流，让 Claude Code 客户端
  * 将其识别为一次正常的模型文本回答。事件骨架遵循 Anthropic

package/dist/utils/sse-writer.js

@@ -1,5 +1,6 @@
+import { encodeSSEFrame } from './sse-protocol.js';
 /**
- * SSE 构造器（后端）—— 与 sse-accumulator（解析器）互为逆向。
+ * SSE 构造器（后端）—— 与 sse-protocol（帧解析器）互为逆向。
  *
  * 用于 proxy 主动构造并回写合成 SSE 流，让 Claude Code 客户端
  * 将其识别为一次正常的模型文本回答。事件骨架遵循 Anthropic
@@ -7,7 +8,7 @@
  */
 /** 写单个 SSE 事件：`event: <type>\ndata: {json}\n\n`（Anthropic 双行格式） */
 export function writeSSEEvent(raw, event) {
-    raw.write(`event: ${event.type}\ndata: ${JSON.stringify(event)}\n\n`);
+    raw.write(encodeSSEFrame({ event: event.type, data: JSON.stringify(event) }));
 }
 /**
  * 把一段文本伪装成模型的正常 text 输出，构造完整合成流写回。

package/dist/utils/stats-aggregator.d.ts

@@ -16,6 +16,6 @@ export interface TodayStats {
     request_count: number;
     models: Record<string, number>;
 }
-export declare function aggregateStats(): void;
+export declare function aggregateStats(maxDays?: number): void;
 export declare function getStatsData(since?: string): StatsData;
 export declare function getTodayStats(since: string): TodayStats;

package/dist/utils/stats-aggregator.js

@@ -1,26 +1,47 @@
 import { initDatabase } from './db.js';
+// 共用 token 聚合列：小时聚合与今日 totals 同口径，避免列漂移
+const TOKEN_AGG_COLUMNS = `
+  SUM(input_tokens) as input_tokens,
+  SUM(output_tokens) as output_tokens,
+  SUM(cache_read_tokens) as cache_read_tokens,
+  SUM(cache_creation_tokens) as cache_creation_tokens,
+  COUNT(*) as request_count
+`;
+// Build the UTC hourly key ('YYYY-MM-DD-HH') used as stats.period_key
+function toHourKey(date) {
+    return `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}-${String(date.getUTCDate()).padStart(2, '0')}-${String(date.getUTCHours()).padStart(2, '0')}`;
+}
 // Aggregate stats from requests table (called periodically)
 // Only stores hourly (UTC) entries — daily aggregation is done on the frontend
 // using the user's local timezone.
-export function aggregateStats() {
+// maxDays: hourly retention window in days. A positive integer shrinks the
+// window (capped at 30); undefined / <=0 falls back to the default 30 days.
+export function aggregateStats(maxDays) {
     const db = initDatabase();
     const now = new Date();
     const nowIso = now.toISOString();
-    // 30 days of hourly data = 720 entries
-    const hourlyCutoff = new Date(now.getTime() - 30 * 86400000).toISOString();
+    // windowDays days of hourly data (30 days = 720 entries)
+    const windowDays = Number.isInteger(maxDays) && maxDays > 0
+        ? Math.min(30, maxDays)
+        : 30;
+    const hourlyCutoff = new Date(now.getTime() - windowDays * 86400000).toISOString();
     // Aggregate hourly stats using SQLite's built-in strftime (UTC)
     const hourlyRows = db.prepare(`
     SELECT
       strftime('%Y-%m-%d-%H', timestamp) as hour,
-      SUM(input_tokens) as input_tokens,
-      SUM(output_tokens) as output_tokens,
-      SUM(cache_read_tokens) as cache_read_tokens,
-      SUM(cache_creation_tokens) as cache_creation_tokens,
-      COUNT(*) as request_count
+      ${TOKEN_AGG_COLUMNS}
     FROM requests
     WHERE timestamp >= ?
     GROUP BY hour
   `).all(hourlyCutoff);
+    // Recompute the whole window atomically: drop every hourly snapshot inside
+    // the window first (source rows may already have been deleted by cleanup, so
+    // an upsert-only pass would leave stale snapshots frozen forever), then
+    // re-insert from the requests table.
+    // Cutoff key uses UTC methods to match the UTC keys stored in the DB.
+    // The two deletes (< key / >= key) together clear every hourly row.
+    const cutoffKey = toHourKey(new Date(hourlyCutoff));
+    const deleteWindow = db.prepare(`DELETE FROM stats WHERE period = 'hourly' AND period_key >= ?`);
     // Upsert hourly stats
     const upsertHourly = db.prepare(`
     INSERT OR REPLACE INTO stats (
@@ -28,16 +49,19 @@ export function aggregateStats() {
       cache_read_tokens, cache_creation_tokens, request_count, updated_at
     ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
   `);
-    for (const row of hourlyRows) {
-        upsertHourly.run('hourly', row.hour, row.input_tokens || 0, row.output_tokens || 0, row.cache_read_tokens || 0, row.cache_creation_tokens || 0, row.request_count, nowIso);
-    }
-    // Clean old hourly entries: compute cutoff key using UTC methods
-    // to match the UTC keys stored in the DB
-    const cutoffDate = new Date(hourlyCutoff);
-    const cutoffKey = `${cutoffDate.getUTCFullYear()}-${String(cutoffDate.getUTCMonth() + 1).padStart(2, '0')}-${String(cutoffDate.getUTCDate()).padStart(2, '0')}-${String(cutoffDate.getUTCHours()).padStart(2, '0')}`;
-    db.prepare(`DELETE FROM stats WHERE period = 'hourly' AND period_key < ?`).run(cutoffKey);
+    // Clean hourly entries outside the recomputation window
+    const deleteOldKeys = db.prepare(`DELETE FROM stats WHERE period = 'hourly' AND period_key < ?`);
     // Clean ALL daily entries (legacy data from old +8h approach)
-    db.prepare(`DELETE FROM stats WHERE period = 'daily'`).run();
+    const deleteDaily = db.prepare(`DELETE FROM stats WHERE period = 'daily'`);
+    const recompute = db.transaction(() => {
+        deleteWindow.run(cutoffKey);
+        for (const row of hourlyRows) {
+            upsertHourly.run('hourly', row.hour, row.input_tokens || 0, row.output_tokens || 0, row.cache_read_tokens || 0, row.cache_creation_tokens || 0, row.request_count, nowIso);
+        }
+        deleteOldKeys.run(cutoffKey);
+        deleteDaily.run();
+    });
+    recompute();
     // WAL checkpoint to keep WAL file size bounded
     db.pragma('wal_checkpoint(TRUNCATE)');
 }
@@ -47,8 +71,7 @@ export function getStatsData(since) {
     let hourlyRows;
     if (since) {
         // Convert since (ISO UTC) to UTC hourly key format for filtering
-        const sinceDate = new Date(since);
-        const sinceKey = `${sinceDate.getUTCFullYear()}-${String(sinceDate.getUTCMonth() + 1).padStart(2, '0')}-${String(sinceDate.getUTCDate()).padStart(2, '0')}-${String(sinceDate.getUTCHours()).padStart(2, '0')}`;
+        const sinceKey = toHourKey(new Date(since));
         hourlyRows = db.prepare(`
       SELECT * FROM stats WHERE period = 'hourly' AND period_key >= ? ORDER BY period_key ASC
     `).all(sinceKey);
@@ -82,12 +105,9 @@ export function getStatsData(since) {
 export function getTodayStats(since) {
     const db = initDatabase();
     // Totals: SUM tokens + COUNT requests since local midnight
+    // 多选的 cache_creation_tokens 在返回映射时忽略
     const totalRow = db.prepare(`
-    SELECT
-      SUM(input_tokens) as input_tokens,
-      SUM(output_tokens) as output_tokens,
-      SUM(cache_read_tokens) as cache_read_tokens,
-      COUNT(*) as request_count
+    SELECT ${TOKEN_AGG_COLUMNS}
     FROM requests
     WHERE timestamp >= ?
   `).get(since);

package/dist/utils/tool-injector.js

@@ -10,6 +10,13 @@ import { mcpManager } from './mcp-manager.js';
  * 无 tools 数组时自动创建，让裸请求也能使用 MCP tool。
  */
 export function injectMcpTools(body) {
+    // 守卫：malformed body 直接返回，避免给原始值赋值抛 TypeError。
+    // 判定依据：有效 chat body 至少要有 messages 数组；null/非对象，或既无 tools 也无 messages（如 {}、{tools:'nope'}）均不注入。
+    if (body === null ||
+        typeof body !== 'object' ||
+        (!Array.isArray(body?.tools) && !Array.isArray(body?.messages))) {
+        return [];
+    }
     if (!Array.isArray(body?.tools)) {
         body.tools = [];
     }

package/dist/utils/vault.d.ts

@@ -0,0 +1,111 @@
+export declare function isValidSlug(slug: string): boolean;
+export interface TopicSummary {
+    slug: string;
+    title: string;
+    summary: string;
+    tags: string[];
+}
+export interface ChunkRef {
+    id: string;
+    title: string;
+    summary: string;
+    tags: string[];
+}
+export interface TopicIndex {
+    slug: string;
+    title: string;
+    summary: string;
+    tags: string[];
+    chunks: ChunkRef[];
+}
+interface TopicDetail {
+    title: string;
+    tags: string[];
+    sources: unknown[];
+    chunks: ChunkRef[];
+}
+interface ChunkHit {
+    topic: string;
+    chunkId: string;
+    title: string;
+}
+interface QueryHit {
+    topic: string;
+    chunkId: string;
+    title: string;
+    body: string;
+}
+export interface OutlineItem {
+    id: string;
+    title: string;
+    oneLine: string;
+}
+interface RootIndex {
+    topics: TopicSummary[];
+}
+export interface Vault {
+    /** vault 根目录（docsDir）绝对路径 */
+    readonly root: string;
+    listTopics(): Promise<TopicSummary[]>;
+    getTopic(topic: string): Promise<TopicDetail>;
+    searchChunks(query: string): Promise<ChunkHit[]>;
+    queryKnowledge(query: string, limit?: number): Promise<QueryHit[]>;
+    readChunk(topic: string, chunkId: string): Promise<string>;
+    upsertTopic(input: {
+        slug: string;
+        title: string;
+        summary: string;
+        tags: string[];
+    }): Promise<void>;
+    upsertChunkRef(input: {
+        topic: string;
+        chunkId: string;
+        title: string;
+        summary: string;
+        tags: string[];
+    }): Promise<void>;
+    readTopicIndex(slug: string): Promise<TopicIndex | null>;
+    readSidecarIndex(slug: string): Promise<TopicIndex | null>;
+    assertSlug(slug: string, field?: string): void;
+    /** 重建 topic 目录：rm -rf 后建 sources/ + chunks/ */
+    prepareTopic(slug: string): void;
+    /** 写 <slug>/sources/source-NNN.md（content 带 Source 头） */
+    writeSourceFile(slug: string, index: number, url: string, text: string): void;
+    /** 数 <slug>/sources 下 .md 文件；目录不存在按 0 */
+    countSourceFiles(slug: string): number;
+    /** 读 <slug>/sources 下全部 .md 正文（按文件名排序）；目录缺失抛底层错误 */
+    readSourceBodies(slug: string): string[];
+    /** 写 <slug>/outline.json（校验目录已 prepare、sources 存在） */
+    writeOutline(slug: string, items: OutlineItem[]): void;
+    /** 读 <slug>/outline.json 的 items；文件不存在抛「outline 未生成」 */
+    readOutlineItems(slug: string): OutlineItem[];
+    /** 旁挂：<slug> → <slug>.old */
+    parkTopic(slug: string): void;
+    /** 还原：<slug>.old → <slug> */
+    restoreTopic(slug: string): void;
+    /** 重命名 topic 目录：<slug> → <newSlug> */
+    renameTopic(slug: string, newSlug: string): void;
+    /** 读 <entry>/index.json（entry 可为 slug 或 <slug>.old）；缺失/坏抛底层错误 */
+    readEntryIndexSync(entry: string): TopicIndex;
+    /** 写 <entry>/index.json */
+    writeEntryIndexSync(entry: string, idx: TopicIndex): void;
+    readRootIndexSync(): RootIndex;
+    writeRootIndexSync(root: RootIndex): void;
+    /** 列 <entry>/<subdir> 下 .md 文件名（排序）；目录缺失视为空 */
+    listEntryMd(entry: string, subdir: 'sources' | 'chunks'): string[];
+    mkdirEntrySubdir(entry: string, subdir: 'sources' | 'chunks'): void;
+    readEntryFile(entry: string, subdir: 'sources' | 'chunks', file: string): Buffer;
+    writeEntryFile(entry: string, subdir: 'sources' | 'chunks', file: string, body: Buffer): void;
+    unlinkEntryFile(entry: string, subdir: 'sources' | 'chunks', file: string): void;
+    /** 删除整个 <entry> 目录 */
+    removeEntry(entry: string): void;
+    /** docsDir 下存在任何 .old 旁挂目录时抛错 */
+    assertNoOldSidecars(): void;
+    /** 归一化路径并断言其在 docsDir 内，越界抛错 */
+    assertInside(absPath: string): string;
+    /** 目标为受管 index.json 时抛错 */
+    assertNotManagedIndexJson(absPath: string): void;
+}
+export declare function createVault(docsDir: string): Vault;
+export declare const vault: Vault;
+export {};