@morlay/session-rdb 0.0.20 → 0.0.21-alpha.0

package/src/usage.ts

@@ -0,0 +1,191 @@
+import type { Context } from "@deepseek-ai/cordis";
+import type { SessionPersistenceRdb } from "./index.ts";
+
+export const SESSION_USAGE_PATH = "/api/session.usage";
+
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * 时间范围的语义键：`all` 不限；`day` / `week` 是**本地自然日 / 自然周**（周一起算）；
+ * `7d` / `30d` / `90d` 是最近 N 天（滚动窗口）。
+ */
+export type UsageRangeKey = "all" | "day" | "week" | "7d" | "30d" | "90d";
+
+const ROLLING_DAYS: Record<"7d" | "30d" | "90d", number> = { "7d": 7, "30d": 30, "90d": 90 };
+
+function localDayStart(now: number): Date {
+  const start = new Date(now);
+  start.setHours(0, 0, 0, 0);
+  return start;
+}
+
+/**
+ * 范围起点（含），不限时为 undefined。自然日 / 自然周按 host 的本地时区算，周边界是周一 00:00。
+ * @param range - 语义键。
+ * @param now - 当前时刻。
+ * @returns 起点毫秒时间戳，或 undefined。
+ */
+export function resolveUsageSince(range: UsageRangeKey, now: number): number | undefined {
+  switch (range) {
+    case "all":
+      return undefined;
+    case "day":
+      return localDayStart(now).getTime();
+    case "week": {
+      const start = localDayStart(now);
+      // getDay(): 0 = 周日；换算成「距离本周一几天」。
+      start.setDate(start.getDate() - ((start.getDay() + 6) % 7));
+      return start.getTime();
+    }
+    default:
+      return now - ROLLING_DAYS[range] * DAY_MS;
+  }
+}
+
+function parseUsageRange(value: unknown): UsageRangeKey {
+  return value === "day" || value === "week" || value === "7d" || value === "30d" || value === "90d"
+    ? value
+    : "all";
+}
+
+/** 一段用量合计（token 字段直接取事件里模型报的 usage）。 */
+export interface UsageTotals {
+  events: number;
+  inputTokens: number;
+  outputTokens: number;
+  cacheReadTokens: number;
+  reasoningTokens: number;
+  totalTokens: number;
+}
+
+/** 一天 × 一个模型 × 是否子代理 的用量桶：总览、按天、按模型都由它折叠。 */
+export interface UsageBucket extends UsageTotals {
+  day: string;
+  provider: string | null;
+  model: string | null;
+  subagent: boolean;
+}
+
+/** 一条会话的用量行。 */
+export interface UsageSessionRow extends UsageTotals {
+  sessionId: string;
+  title: string | null;
+  subagent: boolean;
+  archived: boolean;
+}
+
+/** 后端的原始聚合结果。 */
+export interface UsageAggregate {
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+
+/** 一次统计请求的完整回报。 */
+export interface SessionUsageReport {
+  totals: UsageTotals;
+  subagent: UsageTotals;
+  /** 只被人类会话引用的部分（`totals − subagent`）。 */
+  human: UsageTotals;
+  buckets: UsageBucket[];
+  sessions: UsageSessionRow[];
+}
+
+function emptyTotals(): UsageTotals {
+  return {
+    events: 0,
+    inputTokens: 0,
+    outputTokens: 0,
+    cacheReadTokens: 0,
+    reasoningTokens: 0,
+    totalTokens: 0,
+  };
+}
+
+/** 折叠一组行（桶或会话行）的用量。 */
+export function sumUsage(rows: readonly UsageTotals[]): UsageTotals {
+  const totals = emptyTotals();
+  for (const row of rows) {
+    totals.events += row.events;
+    totals.inputTokens += row.inputTokens;
+    totals.outputTokens += row.outputTokens;
+    totals.cacheReadTokens += row.cacheReadTokens;
+    totals.reasoningTokens += row.reasoningTokens;
+    totals.totalTokens += row.totalTokens;
+  }
+  return totals;
+}
+
+/**
+ * 用量统计通道：一次请求回报总览（含 subagent 拆分）、按天 × 模型的桶与按会话的行。
+ * 聚合只算被会话引用的事件行——fork 共享行因此只计一次，已删会话留下的孤儿行不计。
+ */
+export function registerSessionUsage(ctx: Context, persistence: SessionPersistenceRdb): void {
+  ctx.inject(["webServer", "connection"] as const, (webCtx) => {
+    const webServer = webCtx.webServer as unknown as {
+      register(route: {
+        kind: "exact";
+        path: string;
+        handler: (
+          req: import("node:http").IncomingMessage,
+          res: import("node:http").ServerResponse,
+        ) => void | Promise<void>;
+      }): () => void;
+    };
+    const connection = webCtx.get("connection") as unknown as {
+      requestRejection(request: {
+        headers: import("node:http").IncomingHttpHeaders;
+      }): number | undefined;
+    };
+    return webCtx.effect(
+      () =>
+        webServer.register({
+          kind: "exact",
+          path: SESSION_USAGE_PATH,
+          handler: async (req, res) => {
+            const rejection = connection.requestRejection(req);
+            if (rejection !== undefined) {
+              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: Buffer[] = [];
+            for await (const chunk of req) chunks.push(chunk as Buffer);
+            const raw = Buffer.concat(chunks).toString("utf8");
+            let envelope: { range?: unknown } = {};
+            if (raw !== "") {
+              try {
+                envelope = JSON.parse(raw) as { range?: unknown };
+              } catch {
+                res.writeHead(400, { "content-type": "application/json" });
+                res.end(JSON.stringify({ error: "request body is not JSON" }));
+                return;
+              }
+            }
+            try {
+              const aggregate = await persistence.usageReport(
+                resolveUsageSince(parseUsageRange(envelope.range), Date.now()),
+              );
+              const totals = sumUsage(aggregate.buckets);
+              const subagent = sumUsage(aggregate.buckets.filter((bucket) => bucket.subagent));
+              const human = sumUsage(aggregate.buckets.filter((bucket) => !bucket.subagent));
+              res.writeHead(200, { "content-type": "application/json" });
+              res.end(JSON.stringify({ totals, subagent, human, ...aggregate }));
+            } catch (error: unknown) {
+              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`,
+    );
+  });
+}

package/dist/index-D55G9n4k.d.mts

@@ -1,271 +0,0 @@
-import { a as JournalMode, b as WriteGuard, x as Backend } from "./schema-BkQN5GyT.mjs";
-import z from "@deepseek-ai/schemastery";
-import { SessionAccess, SessionHandle, SessionHandleAppendOptions, SessionHandleFlushOptions, SessionHandleReadOptions, SessionHandleReadResult, SessionPersistence, SessionPersistenceCreateOptions, SessionPersistenceListOptions, SessionPersistenceOpenOptions, SessionPersistenceRevision, SessionPersistenceSnapshot, SessionPersistenceStatOptions } from "@deepseek-ai/dsh-session-persistence";
-import { Session, SessionEvent, SessionHeader, SessionId, SessionLogOffset } from "@deepseek-ai/dsh-session";
-import { BranchAnchorMode, BranchBoundary, ForkFromOptions, SessionBranch, SessionBranchProvider } from "@morlay/session-branch";
-import { Context } from "@deepseek-ai/cordis";
-//#region src/branch.d.ts
-declare function locateTurnEnd(events: readonly SessionEvent[], atSeq?: number, mode?: BranchAnchorMode): number;
-interface LiveSessionHooks {
-  getSession(id: SessionId): Session | undefined;
-  getAgent(id: SessionId): LiveAgentLike | undefined;
-  flush(session: Session): Promise<boolean>;
-  resetProjections?(session: Session): void;
-  refreshProjectionCache?(session: ProjectionCacheSession): Promise<void>;
-}
-/**
- * 投影检查点刷新所需的最小会话面：cold rewind 没有 live Session 可复用，
- * 而截断后的前缀未必是合法的独立会话（surface 引用可能悬空），不能走
- * `Session.create` 的校验；缓存服务只读 id / header / inheritedEventCount
- * 与事件前缀，用普通对象承载即可。
- */
-interface ProjectionCacheSession {
-  readonly id: SessionId;
-  readonly header: SessionHeader;
-  readonly inheritedEventCount: SessionLogOffset;
-  snapshotEvents(): readonly SessionEvent[];
-}
-interface LiveAgentLike {
-  session: Session;
-  requestHeaderLogged?: boolean;
-  inbox?: {
-    clear(): void;
-  };
-}
-declare function truncateLiveSession(session: Session, newLength: number): void;
-declare class SessionBranchRdbProvider implements SessionBranchProvider {
-  private readonly persistence;
-  private readonly live;
-  readonly name = "session-rdb";
-  constructor(persistence: SessionPersistenceRdb, live?: LiveSessionHooks);
-  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
-  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    events: readonly SessionEvent[];
-  }>;
-  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
-  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
-  /**
-   * 让持久化投影检查点跟随截断后的 log（见 {@link LiveSessionHooks.refreshProjectionCache}）。
-   * 缓存是派生数据：刷新失败只让缓存多滞后一轮，不能让 rewind 失败。
-   */
-  private refreshProjectionCache;
-}
-declare class SessionBranchRdb extends SessionBranch {
-  static inject: string[];
-  constructor(ctx: import("@deepseek-ai/cordis").Context);
-  private readonly provider;
-  readBranchPrefix(id: SessionId, atSeq?: number, mode?: BranchAnchorMode, signal?: AbortSignal): Promise<BranchBoundary>;
-  readRawEvents(id: SessionId, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    events: readonly SessionEvent[];
-  }>;
-  forkFrom(sourceId: SessionId, options?: ForkFromOptions, signal?: AbortSignal): Promise<SessionId>;
-  rewind(id: SessionId, toBoundary: number, signal?: AbortSignal): Promise<SessionPersistenceSnapshot>;
-  timeline(sessionId: SessionId, signal?: AbortSignal): Promise<import("@morlay/session-branch").BranchTimeline>;
-}
-//#endregion
-//#region src/index.d.ts
-interface SessionPersistenceRdbInternals {
-  readonly backend: Backend;
-  readonly writeGuard: WriteGuard;
-  create(meta: SessionHeader, inheritedEventCount?: number): Promise<SessionHandle>;
-  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
-  load(id: SessionId): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
-  inspect(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
-  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    inheritedEventCount: number;
-    events: readonly SessionEvent[];
-  }>;
-  listSnapshots(signal?: AbortSignal): Promise<SessionPersistenceSnapshot[]>;
-  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionPersistenceRevision | undefined>;
-  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
-}
-/** 投影 checkpoint 写节流（替换上游 `session-projection-cache` 的 Config）。 */
-interface ProjectionCacheOptions {
-  /** 两次强制点之间累积多少已提交事件强制落盘（默认 200）。 */
-  writeEveryEvents?: number;
-  /** 脏 checkpoint 在强制点之间允许滞留的最长毫秒数（默认 5000）。 */
-  writeIntervalMs?: number;
-}
-type Config = {
-  type: "sqlite";
-  path: string;
-  journalMode?: JournalMode;
-  busyTimeout?: number;
-  projectionCache?: ProjectionCacheOptions;
-} | {
-  type: "postgres";
-  connectionString: string;
-  schema?: string;
-  projectionCache?: ProjectionCacheOptions;
-};
-/** 一个已创建但未 materialize 的会话（本进程可见，其他进程不可见）。 */
-interface PendingSession {
-  readonly header: SessionHeader;
-  readonly revision: SessionPersistenceRevision;
-  readonly inheritedEventCount: SessionLogOffset;
-  /** 输入空间 cursor（全 delta 批次也推进）。 */
-  readonly cursor: number;
-  /** 是否调用过 append（close 时保留 pending）。 */
-  readonly everAppended: boolean;
-}
-/** 会话级写所有权与 live 路由簿记。 */
-declare class RdbBackendTracker {
-  private readonly name;
-  /** 每个 id 的活跃 write handle；`null` 表示 claim 构造中。 */
-  private readonly writers;
-  private readonly pending;
-  private readonly openHandles;
-  private counter;
-  constructor(name: string);
-  registerCreated(header: SessionHeader, inheritedEventCount: SessionLogOffset): void;
-  /** 更新 pending 的 cursor / everAppended（handle append 后同步）。 */
-  updatePending(id: SessionId, cursor: number, everAppended: boolean): void;
-  claimWrite(id: SessionId): void;
-  releaseClaim(id: SessionId): void;
-  pendingOf(id: SessionId): PendingSession | undefined;
-  hasPending(id: SessionId): boolean;
-  pendingEntries(): IterableIterator<[SessionId, PendingSession]>;
-  materialized(id: SessionId): void;
-  adopt(handle: RdbSessionHandle): RdbSessionHandle;
-  release(handle: RdbSessionHandle, materialized: boolean): void;
-  writerOf(id: SessionId): RdbSessionHandle | undefined;
-  flushAll(): Promise<void>;
-  closeAll(): Promise<void>;
-}
-/** 一个打开会话的存储句柄：read / append / flush / close。 */
-declare class RdbSessionHandle implements SessionHandle {
-  private readonly persistence;
-  readonly id: SessionId;
-  readonly header: SessionHeader;
-  readonly access: SessionAccess;
-  private readonly state;
-  private chain;
-  private closing;
-  /** 稠密 next-seq（输入空间计数，与旧版 coordinator cursor 同语义）。 */
-  private cursor;
-  private materialized;
-  /** live 路由缓冲（上游 seq 事件，drain 时过滤 delta 后重编号稠密）。 */
-  private buffered;
-  private batchTimer;
-  private drainPaused;
-  private draining;
-  /** write open 时发现的 torn tail 起点（append 前先截断）。 */
-  private tornTruncateTo;
-  /** 是否调用过 append（即使全 delta 未落库）——close 时保留 pending。 */
-  private everAppended;
-  constructor(persistence: SessionPersistenceRdb, id: SessionId, header: SessionHeader, access: SessionAccess, state: {
-    cursor: number;
-    materialized: boolean;
-    inheritedEventCount: SessionLogOffset;
-    tornTruncateTo?: number;
-  });
-  get inheritedEventCount(): SessionLogOffset;
-  /** 输入空间 cursor（下一个待落库的上游 seq）。 */
-  get cursorValue(): number;
-  read(offset?: number, length?: number, options?: SessionHandleReadOptions): Promise<SessionHandleReadResult>;
-  append(events: readonly SessionEvent[], options?: SessionHandleAppendOptions): Promise<void>;
-  flush(options?: SessionHandleFlushOptions): Promise<void>;
-  close(): Promise<void>;
-  [Symbol.asyncDispose](): Promise<void>;
-  /** live 路由：缓冲一个已发布事件（持久化自有副本），并启动批量窗口。 */
-  enqueueLive(event: SessionEvent, reportBackgroundFailure: (error: unknown) => void): void;
-  /** rewind 截断后对齐 handle 的稠密 cursor 与继承前缀（DB 已截断）。 */
-  resetAfterRewind(cursor: number, inheritedEventCount?: number): void;
-  /** 排空 live 缓冲（过滤 delta + 重编号稠密 + append）。 */
-  drainLive(): Promise<void>;
-  private drainBuffered;
-  private enqueueChain;
-  private run;
-  private assertOpen;
-  static readonly LIVE_WRITE_BATCH_MAX_DELAY_MS = 200;
-}
-declare class SessionPersistenceRdb extends SessionPersistence {
-  config: Config;
-  static inject: string[];
-  static Config: z<Config>;
-  static readonly settingsNs = "session-rdb";
-  readonly name = "session-rdb";
-  readonly tracker: RdbBackendTracker;
-  private readonly backend;
-  private storeIdentity;
-  private readonly ready;
-  private readonly writeGuard;
-  private readonly reuseEventIds;
-  /** live 路由：session/created 后 handle 就绪前的缓冲。 */
-  private readonly liveBuffers;
-  private readonly liveReady;
-  constructor(ctx: Context, config: Config, injectedBackend?: Backend);
-  private init;
-  create(header: SessionHeader, options?: SessionPersistenceCreateOptions): Promise<SessionHandle>;
-  open(id: SessionId, access: SessionAccess, options?: SessionPersistenceOpenOptions): Promise<SessionHandle>;
-  flush(): Promise<void>;
-  stat(id: SessionId, options?: SessionPersistenceStatOptions): Promise<SessionPersistenceSnapshot | undefined>;
-  list(options?: SessionPersistenceListOptions): Promise<readonly SessionPersistenceSnapshot[]>;
-  /** 导出当前世代的 jsonl artifact，视图只读不落库。 */
-  readRaw(id: SessionId, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    inheritedEventCount: number;
-    filename: string;
-    content: string;
-  } | undefined>;
-  /** 空会话 materialize（flush 的持久化屏障）。 */
-  materializeEmpty(meta: SessionHeader, inheritedEventCount: SessionLogOffset): Promise<void>;
-  /** 原样 append 落库（handle 已校验 contiguity；torn tail 先截断）。
-   *  与上游 JSONL 一致：ignorable 事件原样存储，不做过滤。写路径校验当前
-   *  格式形状（fail-closed）：未知类型（非 ignorable）与非法消息形状拒绝入库；
-   *  非当前格式（v0/v1/v2）数据只在读取时经 legacy 转换链动态转换，不落新库。 */
-  appendBatch(meta: SessionHeader, inheritedEventCount: SessionLogOffset, events: readonly SessionEvent[], tornTruncateTo?: number): Promise<boolean>;
-  /** 读取一个会话的稠密 log（含 torn tail 检测，不含修复改写）。 */
-  readLog(id: SessionId, options?: {
-    fromSeq?: number;
-  }, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    inheritedEventCount: number;
-    events: SessionEvent[];
-    tornFrom?: number;
-    incarnation: string;
-    revision: number;
-    /** 存储桥接行数（迁移链可能生成/合并事件，与 `events.length` 不同）。 */
-    storedCount: number;
-    /** 是否经上游迁移链转换（非当前格式 → 当前格式）。 */
-    migrated: boolean;
-  } | undefined>;
-  /**
-   * 把迁移链读出的当前格式视图整体落库（非当前格式会话写打开时的一次性迁移）。
-   *
-   * 迁移链会生成/合并事件（end-seed / attempt / chunk 合并），事件 seq 空间
-   * 与存储桥接行数不再相等；写路径以存储 head 为锚点重编号，二者不一致会让
-   * append 撞上已有行。这里在同一事务内删光本会话桥接行、按迁移视图重建
-   * （新事件行，完整信封），并更新 head 与 revision；旧事件行保留（可能被
-   * fork 子会话引用，孤儿由惰性 GC 处理）。
-   */
-  private rewriteMigratedLog;
-  listSnapshots(signal?: AbortSignal): Promise<Array<SessionPersistenceSnapshot & {
-    inheritedEventCount: number;
-  }>>;
-  readStoredRevision(id: SessionId, signal?: AbortSignal): Promise<SessionPersistenceRevision | undefined>;
-  /** 便捷：create + append + close（测试与导入路径共用）。 */
-  createAndAppend(header: SessionHeader, events: readonly SessionEvent[], inheritedEventCount?: number): Promise<void>;
-  /** 便捷：open(read) + read 全量 + close。 */
-  load(id: SessionId, signal?: AbortSignal): Promise<import("@deepseek-ai/dsh-session-persistence").SessionInspection>;
-  /** 便捷：open(write) + append + close。 */
-  append(id: SessionId, events: readonly SessionEvent[]): Promise<void>;
-  /** 便捷：readFrom（稠密后缀）。 */
-  readFrom(id: SessionId, fromSeq: number, signal?: AbortSignal): Promise<{
-    meta: SessionHeader;
-    inheritedEventCount: number;
-    events: readonly SessionEvent[];
-  }>;
-  close(): Promise<void>;
-  registerReuseEventIds(childId: SessionId, map: ReadonlyMap<number, string>): void;
-  internals(): SessionPersistenceRdbInternals;
-  private rowRevision;
-  private installLiveRouting;
-  /** session/created 后为 live 会话建立 write handle（create 或 adopt）。 */
-  private ensureLiveHandle;
-}
-//#endregion
-export { SessionBranchRdb as a, truncateLiveSession as c, SessionPersistenceRdbInternals as i, ProjectionCacheOptions as n, SessionBranchRdbProvider as o, SessionPersistenceRdb as r, locateTurnEnd as s, Config as t };