@morlay/session-rdb 0.0.21-alpha.2 → 0.0.21-alpha.4

package/dist/{sqlite-fpvm5Dzs.mjs → sqlite-C3LHLzYW.mjs}

@@ -1,4 +1,4 @@
-import { g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, v as usageRowOf } from "./log-CnYct2Dv.mjs";
+import { g as titleOfEventData, m as sessionInsertRow, p as sessionConflictRow, v as usageRowOf } from "./log-C-rbdFwK.mjs";
 import { randomUUID } from "node:crypto";
 import { SESSION_FORMAT_VERSION, SessionId, SessionLogOffset, SessionSeq } from "@deepseek-ai/dsh-session";
 import { and, desc, eq, gte, inArray, isNotNull, lt, notInArray, sql } from "drizzle-orm";
@@ -461,7 +461,7 @@ const eventUsage = {
 			}
 		},
 		f_created_at: {
-			type: "integer",
+			type: "bigint",
 			notNull: true
 		},
 		f_provider: { type: "text" },
@@ -691,6 +691,152 @@ function eventDimensions(event) {
 	}
 }
 //#endregion
+//#region src/usage.ts
+const SESSION_USAGE_PATH = "/api/session.usage";
+const DAY_MS = 864e5;
+const ROLLING_DAYS = {
+	"7d": 7,
+	"30d": 30,
+	"90d": 90
+};
+function localDayStart(now) {
+	const start = new Date(now);
+	start.setHours(0, 0, 0, 0);
+	return start;
+}
+/**
+* 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
+* @param range - 语义键。
+* @param now - 当前时刻。
+* @returns 起点毫秒时间戳，或 undefined。
+*/
+function resolveUsageSince(range, now) {
+	switch (range) {
+		case "all": return;
+		case "day": return localDayStart(now).getTime();
+		case "week": {
+			const start = localDayStart(now);
+			start.setDate(start.getDate() - (start.getDay() + 6) % 7);
+			return start.getTime();
+		}
+		default: return now - ROLLING_DAYS[range] * DAY_MS;
+	}
+}
+function parseUsageRange(value) {
+	return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d" ? value : "all";
+}
+/** 计入活动计数的事件类型（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+const COUNTED_EVENT_TYPES = [
+	"turn/start",
+	"step/start",
+	"user/message",
+	"tool/call"
+];
+/** 按事件类型把计数累加到活动指标上（表里按类型存，读的时候折成四项）。 */
+function addActivityCount(target, type, count) {
+	switch (type) {
+		case "turn/start":
+			target.turns += count;
+			return target;
+		case "step/start":
+			target.steps += count;
+			return target;
+		case "user/message":
+			target.userInputs += count;
+			return target;
+		case "tool/call":
+			target.toolCalls += count;
+			return target;
+		default: return target;
+	}
+}
+/** 毫秒时间戳 → host 本地日（`YYYY-MM-DD`，与 SQL 的 localtime 口径一致）。 */
+function localDayKey(ms) {
+	const date = new Date(ms);
+	const pad = (value) => String(value).padStart(2, "0");
+	return `${String(date.getFullYear())}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
+}
+function emptyTotals() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0,
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		reasoningTokens: 0,
+		totalTokens: 0
+	};
+}
+function addTokenTotals(target, row) {
+	target.inputTokens += row.inputTokens;
+	target.outputTokens += row.outputTokens;
+	target.cacheReadTokens += row.cacheReadTokens;
+	target.reasoningTokens += row.reasoningTokens;
+	target.totalTokens += row.totalTokens;
+	return target;
+}
+function addActivityTotals(target, row) {
+	target.turns += row.turns;
+	target.steps += row.steps;
+	target.userInputs += row.userInputs;
+	target.toolCalls += row.toolCalls;
+	return target;
+}
+/** 把一行的整套指标累加进目标（后端合并「是否子代理」两组时用）。 */
+function addTotals(target, row) {
+	addActivityTotals(target, row);
+	addTokenTotals(target, row);
+	return target;
+}
+/**
+* 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+* 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+*/
+function registerSessionUsage(ctx, persistence) {
+	ctx.inject(["webServer", "connection"], (webCtx) => {
+		const webServer = webCtx.webServer;
+		const connection = webCtx.get("connection");
+		return webCtx.effect(() => webServer.register({
+			kind: "exact",
+			path: SESSION_USAGE_PATH,
+			handler: async (req, res) => {
+				const rejection = connection.requestRejection(req);
+				if (rejection !== void 0) {
+					res.writeHead(rejection);
+					res.end(rejection === 401 ? "unauthorized" : "forbidden");
+					return;
+				}
+				if (req.method !== "POST") {
+					res.writeHead(405, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "method not allowed" }));
+					return;
+				}
+				const chunks = [];
+				for await (const chunk of req) chunks.push(chunk);
+				const raw = Buffer.concat(chunks).toString("utf8");
+				let envelope = {};
+				if (raw !== "") try {
+					envelope = JSON.parse(raw);
+				} catch {
+					res.writeHead(400, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: "request body is not JSON" }));
+					return;
+				}
+				try {
+					const report = await persistence.usageReport(resolveUsageSince(parseUsageRange(envelope.range), Date.now()));
+					res.writeHead(200, { "content-type": "application/json" });
+					res.end(JSON.stringify(report));
+				} catch (error) {
+					res.writeHead(500, { "content-type": "application/json" });
+					res.end(JSON.stringify({ error: error instanceof Error ? error.message : "usage report failed" }));
+				}
+			}
+		}), `session-rdb: ${SESSION_USAGE_PATH} route`);
+	});
+}
+//#endregion
 //#region src/storage-takeover/repository.ts
 async function allRows(query) {
 	const q = query;
@@ -941,6 +1087,32 @@ function createStorageRepository(host) {
 }
 //#endregion
 //#region src/sqlite.ts
+/** 活动计数的派生表：可销毁重建（不在 drizzle schema / 迁移里，建表幂等）。 */
+function ensureEventCountsTable(db) {
+	db.exec(`CREATE TABLE IF NOT EXISTS t_event_counts (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_session_id TEXT NOT NULL,
+      f_day TEXT NOT NULL,
+      f_type TEXT NOT NULL,
+      f_count INTEGER NOT NULL DEFAULT 0
+    );
+    CREATE UNIQUE INDEX IF NOT EXISTS uq_event_counts_session_day_type
+      ON t_event_counts(f_session_id, f_day, f_type);
+    CREATE INDEX IF NOT EXISTS idx_event_counts_day ON t_event_counts(f_day);`);
+}
+/** 一次性回填活动计数（表为空时从事件表重算；幂等）。 */
+function backfillEventCounts(db) {
+	if (db.prepare("SELECT count(*) AS n FROM t_event_counts").get().n > 0) return;
+	db.exec(`INSERT OR IGNORE INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+    SELECT b.f_session_id,
+           date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+           e.f_type,
+           count(*)
+      FROM t_session_events b
+      JOIN t_events e ON e.f_event_id = b.f_event_id
+     WHERE e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
+     GROUP BY 1, 2, 3`);
+}
 /**
 * 一次性回填：旧库的用量从未写过 `t_event_usage`，建表后按事件行补一次（幂等：表非空即跳过）。
 */
@@ -970,9 +1142,8 @@ function backfillEventUsage(db) {
             OR json_extract(e.f_data, '$.usage') IS NOT NULL)`);
 }
 /** SQL 的缺失求和是 NULL：没有 usage 字段的行使该字段计 0。 */
-function totalsOf(row) {
+function tokenTotalsOf(row) {
 	return {
-		events: row.events,
 		inputTokens: row.input_tokens ?? 0,
 		outputTokens: row.output_tokens ?? 0,
 		cacheReadTokens: row.cache_read_tokens ?? 0,
@@ -980,6 +1151,26 @@ function totalsOf(row) {
 		totalTokens: row.total_tokens ?? 0
 	};
 }
+/** 一行的整套指标：token 用量 + 活动计数（轮次 / 步骤 / 用户输入 / 工具调用）。 */
+function emptyActivity() {
+	return {
+		turns: 0,
+		steps: 0,
+		userInputs: 0,
+		toolCalls: 0
+	};
+}
+/** 有 token 用量的会话：活动计数与列表都限定在这一批会话里，口径一致。 */
+function hasUsageSession(column) {
+	return `EXISTS (SELECT 1 FROM t_session_events ub
+                    JOIN t_event_usage uu ON uu.f_event_id = ub.f_event_id
+                   WHERE ub.f_session_id = ${column})`;
+}
+const SUBAGENT_OF_EVENT = `EXISTS (SELECT 1 FROM t_session_events sb
+                                     JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
+                                    WHERE sb.f_event_id = %EVENT% AND ss.f_origin = 'subagent')`;
+/** `IN (...)` 用的类型字面量（与 `COUNTED_EVENT_TYPES` 同源）。 */
+const COUNTED_EVENT_TYPE_SQL = COUNTED_EVENT_TYPES.map((type) => `'${type}'`).join(", ");
 const sqliteMigrationsDir = fileURLToPath(new URL("../drizzle/sqlite/", import.meta.url));
 const sqliteTxQueues = /* @__PURE__ */ new Map();
 function enqueueSqliteTx(path, fn) {
@@ -1002,6 +1193,8 @@ async function openDatabase(path, journalMode, busyTimeout = DEFAULT_BUSY_TIMEOU
 		const { user_version: onDisk } = db.prepare("PRAGMA user_version").get();
 		if (onDisk === 2 && !hasMigrationsTable(db)) await baselineV2(db);
 		migrate(dbx, { migrationsFolder: sqliteMigrationsDir });
+		ensureEventCountsTable(db);
+		backfillEventCounts(db);
 		backfillEventUsage(db);
 		dbx.insert(tPersistenceState).values({
 			fSingleton: 1,
@@ -1142,10 +1335,13 @@ var SqliteBackend = class SqliteBackend {
 		return (fromSequence === void 0 ? this.eventRows().where(eq(tSessionEvents.fSessionId, id)) : this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), gte(tSessionEvents.fSequence, fromSequence)))).orderBy(tSessionEvents.fSequence).all();
 	}
 	async getEventTypeAt(id, sequence) {
-		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
+		return this.db.select({ fType: tEvents.fType }).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), eq(tSessionEvents.fSequence, sequence))).get()?.fType;
 	}
 	async getEventTypesBefore(id, beforeSequence, limit) {
-		return this.eventRows().where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
+		return this.db.select({
+			fSequence: tSessionEvents.fSequence,
+			fType: tEvents.fType
+		}).from(tSessionEvents).innerJoin(tEvents, eq(tSessionEvents.fEventId, tEvents.fEventId)).where(and(eq(tSessionEvents.fSessionId, id), lt(tSessionEvents.fSequence, beforeSequence))).orderBy(desc(tSessionEvents.fSequence)).limit(limit).all();
 	}
 	async listSessions() {
 		return this.db.select().from(tSessions).all();
@@ -1273,30 +1469,49 @@ var SqliteBackend = class SqliteBackend {
 		const info = this.db.delete(tSessions).where(inArray(tSessions.fSessionId, ids)).run();
 		return Number(info.changes);
 	}
-	/** 用量聚合：只读 `t_event_usage`；可选只算 `sinceMs` 之后的事件行。 */
+	/**
+	* 用量聚合：token 用量沿 `t_event_usage` 的用量行，活动计数（轮次 / 步骤 / 用户输入 / 工具调用）
+	* 沿 `t_events` 的事件类型数——两者限定在**有 token 用量的会话**里，时间范围各自按自己的
+	* `f_created_at`（同一时刻写入，口径一致）。
+	*/
 	async usageReport(sinceMs) {
-		const sinceClause = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
-		const sinceParams = sinceMs === void 0 ? [] : [sinceMs];
+		const usageSince = sinceMs === void 0 ? "" : " AND u.f_created_at >= ?";
+		const params = sinceMs === void 0 ? [] : [sinceMs];
+		const daySince = sinceMs === void 0 ? "" : " AND c.f_day >= ?";
+		const dayParams = sinceMs === void 0 ? [] : [localDayKey(sinceMs)];
+		const subagentOfUsage = SUBAGENT_OF_EVENT.replace("%EVENT%", "u.f_event_id");
 		const buckets = this.db.$client.prepare(`SELECT date(u.f_created_at / 1000, 'unixepoch', 'localtime') AS day,
                 u.f_provider AS provider,
                 u.f_model AS model,
-                EXISTS (SELECT 1 FROM t_session_events sb
-                          JOIN t_sessions ss ON ss.f_session_id = sb.f_session_id
-                         WHERE sb.f_event_id = u.f_event_id AND ss.f_origin = 'subagent') AS subagent,
-                count(*) AS events,
+                ${subagentOfUsage} AS subagent,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
                 sum(u.f_reasoning_tokens) AS reasoning_tokens,
                 sum(u.f_total_tokens) AS total_tokens
            FROM t_event_usage u
-          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${sinceClause}
-          GROUP BY day, provider, model, subagent`).all(...sinceParams);
-		const sessions = this.db.$client.prepare(`SELECT b.f_session_id AS session_id,
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+          GROUP BY day, provider, model, subagent`).all(...params);
+		const tokenScope = this.db.$client.prepare(`SELECT ${subagentOfUsage} AS subagent,
+                sum(u.f_input_tokens) AS input_tokens,
+                sum(u.f_output_tokens) AS output_tokens,
+                sum(u.f_cache_read_tokens) AS cache_read_tokens,
+                sum(u.f_reasoning_tokens) AS reasoning_tokens,
+                sum(u.f_total_tokens) AS total_tokens
+           FROM t_event_usage u
+          WHERE EXISTS (SELECT 1 FROM t_session_events rb WHERE rb.f_event_id = u.f_event_id)${usageSince}
+          GROUP BY subagent`).all(...params);
+		const activityScope = this.db.$client.prepare(`SELECT (s.f_origin = 'subagent') AS subagent,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+           JOIN t_sessions s ON s.f_session_id = c.f_session_id
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY subagent, c.f_type`).all(...dayParams);
+		const tokenSessions = this.db.$client.prepare(`SELECT b.f_session_id AS session_id,
                 s.f_title AS title,
                 (s.f_origin = 'subagent') AS subagent,
                 (s.f_archived_at IS NOT NULL) AS archived,
-                count(*) AS events,
                 sum(u.f_input_tokens) AS input_tokens,
                 sum(u.f_output_tokens) AS output_tokens,
                 sum(u.f_cache_read_tokens) AS cache_read_tokens,
@@ -1305,25 +1520,69 @@ var SqliteBackend = class SqliteBackend {
            FROM t_session_events b
            JOIN t_event_usage u ON u.f_event_id = b.f_event_id
            JOIN t_sessions s ON s.f_session_id = b.f_session_id
-          WHERE 1 = 1${sinceClause}
-          GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...sinceParams);
+          WHERE 1 = 1${usageSince}
+          GROUP BY b.f_session_id, s.f_title, s.f_origin, s.f_archived_at`).all(...params);
+		const activitySessions = this.db.$client.prepare(`SELECT c.f_session_id AS session_id,
+                c.f_type AS f_type,
+                sum(c.f_count) AS n
+           FROM t_event_counts c
+          WHERE ${hasUsageSession("c.f_session_id")}${daySince}
+          GROUP BY c.f_session_id, c.f_type`).all(...dayParams);
+		const human = emptyTotals();
+		const subagent = emptyTotals();
+		for (const row of tokenScope) addTokenTotals(row.subagent === 1 ? subagent : human, tokenTotalsOf(row));
+		for (const row of activityScope) addActivityCount(row.subagent === 1 ? subagent : human, row.f_type, row.n ?? 0);
+		const totals = addTotals(addTotals(emptyTotals(), human), subagent);
+		const activityBySession = /* @__PURE__ */ new Map();
+		for (const row of activitySessions) {
+			const target = activityBySession.get(row.session_id) ?? emptyActivity();
+			addActivityCount(target, row.f_type, row.n ?? 0);
+			activityBySession.set(row.session_id, target);
+		}
 		return {
+			totals,
+			subagent,
+			human,
 			buckets: buckets.map((row) => ({
 				day: row.day,
 				provider: row.provider,
 				model: row.model,
 				subagent: row.subagent === 1,
-				...totalsOf(row)
+				...tokenTotalsOf(row)
 			})),
-			sessions: sessions.map((row) => ({
+			sessions: tokenSessions.map((row) => ({
 				sessionId: row.session_id,
 				title: row.title,
 				subagent: row.subagent === 1,
 				archived: row.archived === 1,
-				...totalsOf(row)
+				...tokenTotalsOf(row),
+				...activityBySession.get(row.session_id) ?? emptyActivity()
 			}))
 		};
 	}
+	/** 活动计数旁路累加：派生表 `t_event_counts`，不在写事务里（失败可丢，表可销毁重建）。 */
+	async incrementEventCounts(id, buckets) {
+		if (buckets.length === 0) return;
+		const statement = this.db.$client.prepare(`INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count) VALUES (?, ?, ?, ?)
+       ON CONFLICT(f_session_id, f_day, f_type) DO UPDATE SET f_count = f_count + excluded.f_count`);
+		for (const bucket of buckets) statement.run(id, bucket.day, bucket.type, bucket.count);
+	}
+	/** 按会话重算活动计数（rewind / fork 之后）：先删该会话的行，再从事件表重算。 */
+	async rebuildEventCounts(id) {
+		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+		this.db.$client.prepare(`INSERT INTO t_event_counts (f_session_id, f_day, f_type, f_count)
+         SELECT b.f_session_id,
+                date(e.f_created_at / 1000, 'unixepoch', 'localtime'),
+                e.f_type,
+                count(*)
+           FROM t_session_events b
+           JOIN t_events e ON e.f_event_id = b.f_event_id
+          WHERE b.f_session_id = ? AND e.f_type IN (${COUNTED_EVENT_TYPE_SQL})
+          GROUP BY 1, 2, 3`).run(id);
+	}
+	async deleteEventCounts(id) {
+		this.db.$client.prepare("DELETE FROM t_event_counts WHERE f_session_id = ?").run(id);
+	}
 	async vacuum() {
 		await enqueueSqliteTx(this.dbPath, async () => {
 			this.db.$client.exec("VACUUM");
@@ -1345,4 +1604,4 @@ var SqliteBackend = class SqliteBackend {
 	}
 };
 //#endregion
-export { WriteGuard as C, toPostgresSchema as S, tStorageUnits as _, EVENT_ENCODING as a, tWorkspaces as b, eventDimensions as c, tEvents as d, tPersistenceState as f, tSessions as g, tSessionProjcacheRows as h, DEFAULT_BUSY_TIMEOUT_MS as i, eventKind as l, tSessionEvents as m, openDatabase as n, SCHEMA_VERSION as o, tSchemaMeta as p, createStorageRepository as r, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as s, SqliteBackend as t, tEventUsage as u, tWorkspaceSessions as v, postgresTableDefs as x, tWorkspaceState as y };
+export { WriteGuard as A, tSessions as C, tWorkspaces as D, tWorkspaceState as E, postgresTableDefs as O, tSessionProjcacheRows as S, tWorkspaceSessions as T, tEventUsage as _, addActivityCount as a, tSchemaMeta as b, emptyTotals as c, DEFAULT_BUSY_TIMEOUT_MS as d, EVENT_ENCODING as f, eventKind as g, eventDimensions as h, COUNTED_EVENT_TYPES as i, toPostgresSchema as k, localDayKey as l, SESSION_PERSISTENCE_SQLITE_APPLICATION_ID as m, openDatabase as n, addTokenTotals as o, SCHEMA_VERSION as p, createStorageRepository as r, addTotals as s, SqliteBackend as t, registerSessionUsage as u, tEvents as v, tStorageUnits as w, tSessionEvents as x, tPersistenceState as y };