@morlay/session-rdb 0.1.10-alpha.0 → 0.1.10-alpha.3

package/src/log/usage-row.ts

@@ -0,0 +1,64 @@
+import { localDayKey } from "../usage.ts";
+
+export interface EventUsageRow {
+  fEventId: string;
+  fCreatedAt: number;
+  fDay: string;
+  fProvider: string | null;
+  fModel: string | null;
+  fReferenced: number;
+  fSubagent: number;
+  fInputTokens: number;
+  fOutputTokens: number;
+  fCacheReadTokens: number;
+  fReasoningTokens: number;
+  fTotalTokens: number;
+}
+
+function numericField(value: unknown): number {
+  return typeof value === "number" && Number.isFinite(value) ? Math.max(0, Math.trunc(value)) : 0;
+}
+
+function textField(value: unknown): string | null {
+  return typeof value === "string" && value !== "" ? value : null;
+}
+
+// 一条事件行的用量（只有带 `usage` 的 `assistant/message` 才有；没有用量时为 undefined）：写路径据此记录
+// `t_event_usage`，统计因此不必逐行解析 JSON，两种 `f_data` 结构（带信封 / 老格式）都认。读侧维度一起物化：
+// 本地日由事件时间算，`f_referenced` 直接 1（这一批事件行与桥接行同事务），`f_subagent` 取写入它的会话是否子代理。
+export function usageRowOf(
+  event: {
+    fEventId: string;
+    fCreatedAt: number;
+    fType: string;
+    fData: string;
+  },
+  subagent: boolean,
+): EventUsageRow | undefined {
+  if (event.fType !== "assistant/message") return undefined;
+  let parsed: Record<string, unknown>;
+  try {
+    parsed = JSON.parse(event.fData) as Record<string, unknown>;
+  } catch {
+    return undefined;
+  }
+  const envelope = (parsed["data"] ?? parsed) as Record<string, unknown>;
+  const usage = envelope["usage"];
+  if (typeof usage !== "object" || usage === null) return undefined;
+  const source = (envelope["message"] as { source?: Record<string, unknown> } | undefined)?.source;
+  const row: EventUsageRow = {
+    fEventId: event.fEventId,
+    fCreatedAt: event.fCreatedAt,
+    fDay: localDayKey(event.fCreatedAt),
+    fProvider: textField(source?.["provider"]),
+    fModel: textField(source?.["model"]),
+    fReferenced: 1,
+    fSubagent: subagent ? 1 : 0,
+    fInputTokens: numericField((usage as Record<string, unknown>)["inputTokens"]),
+    fOutputTokens: numericField((usage as Record<string, unknown>)["outputTokens"]),
+    fCacheReadTokens: numericField((usage as Record<string, unknown>)["cacheReadTokens"]),
+    fReasoningTokens: numericField((usage as Record<string, unknown>)["reasoningTokens"]),
+    fTotalTokens: numericField((usage as Record<string, unknown>)["totalTokens"]),
+  };
+  return row;
+}

package/src/migrations.ts

@@ -0,0 +1,196 @@
+import { E, defineTable, type Migration } from "@morlay/rdbkit";
+import { sessions } from "./entities/index.ts";
+import {
+  migrateLegacyDomainStorage,
+  type LegacyLinkRow,
+  type LegacyScheduleRow,
+  type LegacyWorkspaceRow,
+  type LegacyWorkspaceStateRow,
+} from "./storage-takeover/legacy-domain-migration.ts";
+import { createStorageRepository } from "./storage-takeover/repository.ts";
+
+// 旧语义表的定义：只用于读（旧表保留可回退，这里不改它们）。列名与当年的 DDL 一致。
+const legacyWorkspaces = defineTable({
+  name: "t_workspaces",
+  columns: {
+    f_workspace_id: { type: "text", primaryKey: true },
+    f_path: { type: "text" },
+    f_title: { type: "text" },
+    f_created_at: { type: "text" },
+    f_updated_at: { type: "text" },
+    f_position: { type: "integer" },
+  },
+});
+
+const legacyLinks = defineTable({
+  name: "t_workspace_sessions",
+  columns: {
+    f_workspace_id: { type: "text" },
+    f_session_id: { type: "text" },
+    f_position: { type: "integer" },
+  },
+});
+
+const legacyWorkspaceState = defineTable({
+  name: "t_workspace_state",
+  columns: {
+    f_singleton: { type: "integer", primaryKey: true },
+    f_initialized: { type: "integer" },
+    f_pending_operation: { type: "text" },
+    f_pending_workspace_id: { type: "text" },
+  },
+});
+
+const legacyScheduleTasks = defineTable({
+  name: "t_schedule_tasks",
+  columns: {
+    f_id: { type: "text", primaryKey: true },
+    f_session_id: { type: "text" },
+    f_status: { type: "text" },
+    f_record: { type: "text" },
+    f_last_delivery: { type: "text" },
+    f_delivery_history: { type: "text" },
+  },
+});
+
+const legacyGlobals = defineTable({
+  name: "t_storage_globals",
+  columns: {
+    f_domain: { type: "text", primaryKey: true },
+    f_value: { type: "text" },
+  },
+});
+
+/**
+ * 旧语义表（workspace / schedule / cua 授权域）→ 通用域存储的一次性搬运。
+ *
+ * 旧表保留可回退；是否搬过由 `t_schema_migrations` 账本决定（只跑一次），不再需要 `t_schema_meta` 标记。
+ */
+export function sessionMigrations(): readonly Migration[] {
+  return [
+    {
+      id: "20261028-legacy-domain-storage",
+      up: async (tx) => {
+        // 旧表不存在（新库 / 还没升到这一版）：这次不搬、也不记账，以后真出现旧表还会再试。
+        const objects = new Set(await tx.objectNames());
+        if (!objects.has(legacyWorkspaces.name)) return false;
+
+        const workspaces: LegacyWorkspaceRow[] = [];
+        if (objects.has(legacyWorkspaces.name)) {
+          const table = tx.table(legacyWorkspaces);
+          for await (const row of table.select({
+            id: table.f_workspace_id,
+            path: table.f_path,
+            title: table.f_title,
+            createdAt: table.f_created_at,
+            updatedAt: table.f_updated_at,
+            position: table.f_position,
+          })) {
+            workspaces.push({
+              id: String(row.id),
+              path: String(row.path ?? ""),
+              title: String(row.title ?? ""),
+              createdAt: String(row.createdAt ?? ""),
+              updatedAt: String(row.updatedAt ?? ""),
+              position: Number(row.position ?? 0),
+            });
+          }
+        }
+
+        const links: LegacyLinkRow[] = [];
+        if (objects.has(legacyLinks.name)) {
+          const table = tx.table(legacyLinks);
+          for await (const row of table.select({
+            workspaceId: table.f_workspace_id,
+            sessionId: table.f_session_id,
+            position: table.f_position,
+          })) {
+            links.push({
+              workspaceId: String(row.workspaceId),
+              sessionId: String(row.sessionId),
+              position: Number(row.position ?? 0),
+            });
+          }
+        }
+
+        let state: LegacyWorkspaceStateRow | undefined;
+        if (objects.has(legacyWorkspaceState.name)) {
+          const table = tx.table(legacyWorkspaceState);
+          for await (const row of table
+            .select({
+              initialized: table.f_initialized,
+              pendingOperation: table.f_pending_operation,
+              pendingWorkspaceId: table.f_pending_workspace_id,
+            })
+            .where(E.eq(table.f_singleton, 1))
+            .limit(1)) {
+            state = {
+              initialized: Number(row.initialized ?? 0),
+              pendingOperation: row.pendingOperation,
+              pendingWorkspaceId: row.pendingWorkspaceId,
+            };
+          }
+        }
+
+        const tasks: LegacyScheduleRow[] = [];
+        if (objects.has(legacyScheduleTasks.name)) {
+          const table = tx.table(legacyScheduleTasks);
+          for await (const row of table.select({
+            id: table.f_id,
+            sessionId: table.f_session_id,
+            status: table.f_status,
+            record: table.f_record,
+            lastDelivery: table.f_last_delivery,
+            deliveryHistory: table.f_delivery_history,
+          })) {
+            tasks.push({
+              id: String(row.id),
+              sessionId: String(row.sessionId ?? ""),
+              status: String(row.status ?? ""),
+              record: String(row.record ?? ""),
+              lastDelivery: row.lastDelivery,
+              deliveryHistory: row.deliveryHistory,
+            });
+          }
+        }
+
+        const globals: Array<{ domain: string; value: unknown }> = [];
+        if (objects.has(legacyGlobals.name)) {
+          const table = tx.table(legacyGlobals);
+          for await (const row of table.select({
+            domain: table.f_domain,
+            value: table.f_value,
+          })) {
+            globals.push({ domain: String(row.domain), value: JSON.parse(String(row.value)) });
+          }
+        }
+
+        const sessionRows = sessions.table(tx);
+        const archived: string[] = [];
+        for await (const row of sessionRows
+          .select({ id: sessionRows.f_session_id })
+          .where(E.isNotNull(sessionRows.f_archived_at))
+          .orderBy(sessionRows.f_archived_at)) {
+          archived.push(String(row.id));
+        }
+        const pinned: Array<{ id: string; seq: number }> = [];
+        for await (const row of sessionRows
+          .select({ id: sessionRows.f_session_id, seq: sessionRows.f_pinned_seq })
+          .where(E.isNotNull(sessionRows.f_pinned_seq))
+          .orderBy(sessionRows.f_pinned_seq)) {
+          pinned.push({ id: String(row.id), seq: Number(row.seq) });
+        }
+
+        // 迁移已经在一个事务里：仓储的写用直通（不再 BEGIN），否则会变成嵌套事务。
+        const storage = createStorageRepository({
+          database: tx,
+          writeAtomically: async (fn) => await fn(tx),
+        });
+        await migrateLegacyDomainStorage(
+          { workspaces, links, state, archived, pinned, tasks, globals },
+          storage,
+        );
+      },
+    },
+  ];
+}

package/src/organize.ts

@@ -0,0 +1,38 @@
+import type { Context } from "@deepseek-ai/cordis";
+import { SESSION_ORGANIZE_PATH } from "./routes.ts";
+import { mountJsonRoute } from "./http/route.ts";
+import type { SessionPersistenceRdb } from "./session-store.ts";
+
+export { SESSION_ORGANIZE_PATH };
+
+interface OrganizeAgentLike {
+  cancel?(cause: { kind: "user" }, options?: { keepInbox?: boolean }): void;
+  whenIdle(): Promise<void>;
+}
+
+// 让所有运行中的 agent 先退场：整理数据要重写事件与统计表，运行中的写路径必须停下来。
+async function stopRunningAgents(ctx: Context): Promise<number> {
+  const agents = ctx.get("agents") as { list(): OrganizeAgentLike[] } | undefined;
+  const running = agents?.list() ?? [];
+  for (const agent of running) agent.cancel?.({ kind: "user" }, { keepInbox: true });
+  await Promise.all(running.map((agent) => agent.whenIdle()));
+  return running.length;
+}
+
+/**
+ * 整理数据通道：停 agent → 回收孤儿（会话 / 事件行）→ 重算派生统计 → VACUUM。
+ *
+ * 不只是清理孤儿：三张派生统计表是可销毁重建的，整理时一并整表重算，修掉旁路累加漏记或旧数据漂移。
+ */
+export function registerSessionOrganize(ctx: Context, persistence: SessionPersistenceRdb): void {
+  mountJsonRoute(ctx, {
+    path: SESSION_ORGANIZE_PATH,
+    handle: async () => {
+      const stoppedAgents = await stopRunningAgents(ctx);
+      const { orphanSessions, orphanEvents, rebuiltSessions } = await persistence.organize();
+      return {
+        body: { stoppedAgents, orphanSessions, orphanEvents, rebuiltSessions, vacuumed: true },
+      };
+    },
+  });
+}

package/src/read-path.ts

@@ -0,0 +1,190 @@
+import { SESSION_FORMAT_VERSION } from "@deepseek-ai/dsh-session";
+import type { SessionEvent, SessionHeader, SessionId } from "@deepseek-ai/dsh-session";
+import { sessionFormatLogFilename } from "@deepseek-ai/dsh-session-format";
+import { balanceRewindPrefix } from "@morlay/session-branch";
+import { adoptLegacyRows, convertLegacyRows, isLegacyVersion } from "./legacy.ts";
+import { scanRows, toJsonlArtifact } from "./log/export.ts";
+import { needsShapeAdoption, repairReadView } from "./log/repair.ts";
+import { rowToMeta } from "./log/rows.ts";
+import type {
+  SessionPersistenceRevision,
+  SessionPersistenceSnapshot,
+} from "@deepseek-ai/dsh-session-persistence";
+import type { Backend, SessionRow } from "./backend.ts";
+import type { RdbBackendTracker } from "./handles.ts";
+
+export interface ReadPathDeps {
+  readonly ready: Promise<void>;
+  backend(): Backend;
+  readonly tracker: RdbBackendTracker;
+  readonly logger: { warn(message: string): void };
+  /** materialization 身份的 revision 串（`storeIdentity:incarnation:…`）。 */
+  revisionOf(row: SessionRow): SessionPersistenceRevision;
+}
+
+/**
+ * 读侧：会话日志、原始导出、快照列表与已存储 revision。
+ *
+ * 这些只读 `backend.reads`，不碰写事务；`session-store.ts` 的契约方法（`load` / `open` / `readFrom`）把调用转到这里。
+ */
+export function createReadPath(deps: ReadPathDeps) {
+  return {
+    async readLog(
+    id: SessionId,
+    options: { fromSeq?: number } = {},
+    signal?: AbortSignal,
+  ): Promise<
+    | {
+        meta: SessionHeader;
+
+        inheritedEventCount: number;
+        events: SessionEvent[];
+        tornFrom?: number;
+
+        incarnation: string;
+
+        revision: number;
+
+        storedCount: number;
+
+        migrated: boolean;
+      }
+    | undefined
+  > {
+    signal?.throwIfAborted();
+    await deps.ready;
+    signal?.throwIfAborted();
+    const row = await deps.backend().reads.getSession(id);
+    if (row === undefined) return undefined;
+    const meta = rowToMeta(row);
+    const eventRows =
+      options.fromSeq === undefined
+        ? await deps.backend().reads.getEventRows(id)
+        : await deps.backend().reads.getEventRows(id, options.fromSeq);
+    signal?.throwIfAborted();
+
+    if (isLegacyVersion(row.fVersion)) {
+      try {
+        const converted = convertLegacyRows(row, eventRows);
+        return {
+          meta: converted.meta,
+          inheritedEventCount: converted.inheritedEventCount,
+          events: converted.events,
+          incarnation: row.fIncarnation,
+          revision: row.fRevision,
+          storedCount: eventRows.length,
+          migrated: true,
+        };
+      } catch (error: unknown) {
+        deps.logger.warn(
+          `session-rdb: session "${id}" is not a single released format; adopting its stored rows as current-format data (${error instanceof Error ? error.message : String(error)})`,
+        );
+        const adopted = adoptLegacyRows(row, eventRows);
+        return {
+          meta: adopted.meta,
+          inheritedEventCount: adopted.inheritedEventCount,
+          events: adopted.events,
+          incarnation: row.fIncarnation,
+          revision: row.fRevision,
+          storedCount: eventRows.length,
+          migrated: false,
+          ...(adopted.tornFrom !== undefined ? { tornFrom: adopted.tornFrom } : {}),
+        };
+      }
+    }
+    const { preserved, tornFrom } = scanRows(eventRows, options.fromSeq ?? 0);
+    // 版本号不完全可信：写路径曾把回退视图的结果以当前版本号落库，于是库里存在「v4 标记 + 旧代形状」
+    // 的行——在扫干净的边界之内再按内容判一次（撕裂尾部与坏行已经被 `scanRows` 丢掉了）。
+    if (needsShapeAdoption(preserved)) {
+      const adopted = adoptLegacyRows(row, eventRows);
+      return {
+        meta: adopted.meta,
+        inheritedEventCount: adopted.inheritedEventCount,
+        events: adopted.events,
+        incarnation: row.fIncarnation,
+        revision: row.fRevision,
+        storedCount: eventRows.length,
+        migrated: false,
+        ...(adopted.tornFrom !== undefined ? { tornFrom: adopted.tornFrom } : {}),
+      };
+    }
+    return {
+      meta,
+      inheritedEventCount: row.fSeedLength ?? 0,
+      events: preserved,
+      incarnation: row.fIncarnation,
+      revision: row.fRevision,
+      storedCount: eventRows.length,
+      migrated: false,
+      ...(tornFrom !== undefined ? { tornFrom } : {}),
+    };
+  },
+
+    async readRaw(
+    id: SessionId,
+    signal?: AbortSignal,
+  ): Promise<
+    | { meta: SessionHeader; inheritedEventCount: number; filename: string; content: string }
+    | undefined
+  > {
+    signal?.throwIfAborted();
+    await deps.ready;
+    signal?.throwIfAborted();
+    const log = await this.readLog(id, {}, signal);
+    if (log === undefined) return undefined;
+    repairReadView(log.events);
+    // 整段日志导出：只丢弃「已不平衡」之后的尾部（尾部未闭合的 step 是中断运行的正常形状，由上游 resume 补 closers）
+    const events = balanceRewindPrefix(log.events, { keepOpenTail: true });
+    const inheritedEventCount = Math.min(log.inheritedEventCount, events.length);
+    return {
+      meta: log.meta,
+      inheritedEventCount,
+
+      filename: sessionFormatLogFilename(SESSION_FORMAT_VERSION),
+      content: toJsonlArtifact(log.meta, inheritedEventCount, events),
+    };
+  },
+
+    async listSnapshots(
+    signal?: AbortSignal,
+  ): Promise<Array<SessionPersistenceSnapshot & { inheritedEventCount: number }>> {
+    signal?.throwIfAborted();
+    await deps.ready;
+    signal?.throwIfAborted();
+    const snapshots: Array<SessionPersistenceSnapshot & { inheritedEventCount: number }> = [];
+    const listed = new Set<SessionId>();
+    for (const [id, pending] of deps.tracker.pendingEntries()) {
+      snapshots.push({
+        header: pending.header,
+        revision: pending.revision,
+        inheritedEventCount: pending.inheritedEventCount,
+      });
+      listed.add(id);
+    }
+    const rows = await deps.backend().reads.listSessions();
+    signal?.throwIfAborted();
+    for (const row of rows) {
+      if (listed.has(row.fSessionId as SessionId)) continue;
+      snapshots.push({
+        header: rowToMeta(row),
+        revision: deps.revisionOf(row),
+        inheritedEventCount: row.fSeedLength ?? 0,
+      });
+    }
+    return snapshots;
+  },
+
+    async readStoredRevision(
+    id: SessionId,
+    signal?: AbortSignal,
+  ): Promise<SessionPersistenceRevision | undefined> {
+    signal?.throwIfAborted();
+    await deps.ready;
+    signal?.throwIfAborted();
+    const row = await deps.backend().reads.getSession(id);
+    if (row === undefined) return undefined;
+    return deps.revisionOf(row);
+  }
+
+  };
+}

package/src/routes.ts

@@ -11,6 +11,7 @@ export const SESSION_IMPORT_PATH = `${MORLAY_SESSION_API_PREFIX}/import`;
 
 export const SESSION_DELETE_PATH = `${MORLAY_SESSION_API_PREFIX}/delete`;
 
-export const SESSION_GC_PATH = `${MORLAY_SESSION_API_PREFIX}/gc`;
+// 「整理数据」通道：回收孤儿 + 重算派生统计 + VACUUM，一次请求完成。
+export const SESSION_ORGANIZE_PATH = `${MORLAY_SESSION_API_PREFIX}/organize`;
 
 export const SESSION_USAGE_PATH = `${MORLAY_SESSION_API_PREFIX}/usage`;

package/src/rows.ts

@@ -1,6 +1,7 @@
 import type { Context } from "@deepseek-ai/cordis";
 import type { Backend } from "./backend.ts";
 import { SESSION_ROWS_PATH } from "./routes.ts";
+import { mountJsonRoute } from "./http/route.ts";
 
 // 管理面的会话列表路由：完整语料（含归档）+ 标题 + 最后活动时间，与官方 `session/list` 分开
 // （见 ADR-会话列表两条路）。
@@ -41,82 +42,29 @@ export interface SessionRowsValue {
 const MAX_PAGE_SIZE = 200;
 const DEFAULT_PAGE_SIZE = 20;
 
-export function registerSessionRows(ctx: Context, backend: Backend): 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_ROWS_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: SessionRowsRequest = {};
-            if (raw !== "") {
-              try {
-                envelope = JSON.parse(raw) as SessionRowsRequest;
-              } catch {
-                res.writeHead(400, { "content-type": "application/json" });
-                res.end(JSON.stringify({ error: "request body is not JSON" }));
-                return;
-              }
-            }
-            const page =
-              Number.isSafeInteger(envelope.page) && (envelope.page ?? 0) > 0 ? envelope.page! : 1;
-            const requested = envelope.pageSize;
-            const pageSize =
-              Number.isSafeInteger(requested) && (requested ?? 0) > 0
-                ? Math.min(requested!, MAX_PAGE_SIZE)
-                : DEFAULT_PAGE_SIZE;
-            try {
-              const { items, total } = await backend.listSessionRows({
-                ...(envelope.query === undefined ? {} : { query: envelope.query }),
-                ...(envelope.includeSubagents === undefined
-                  ? {}
-                  : { includeSubagents: envelope.includeSubagents }),
-                limit: pageSize,
-                offset: (page - 1) * pageSize,
-              });
-              res.writeHead(200, { "content-type": "application/json" });
-              res.end(JSON.stringify({ items, total, page, pageSize } satisfies SessionRowsValue));
-            } catch (error: unknown) {
-              res.writeHead(500, { "content-type": "application/json" });
-              res.end(
-                JSON.stringify({
-                  error: error instanceof Error ? error.message : "session rows failed",
-                }),
-              );
-            }
-          },
-        }),
-      "session-rdb: session rows route",
-    );
+export function registerSessionRows(ctx: Context, getBackend: () => Promise<Backend>): void {
+  mountJsonRoute(ctx, {
+    path: SESSION_ROWS_PATH,
+    handle: async (body) => {
+      const envelope = body as SessionRowsRequest;
+      const page =
+        Number.isSafeInteger(envelope.page) && (envelope.page ?? 0) > 0 ? envelope.page! : 1;
+      const requested = envelope.pageSize;
+      const pageSize =
+        Number.isSafeInteger(requested) && (requested ?? 0) > 0
+          ? Math.min(requested!, MAX_PAGE_SIZE)
+          : DEFAULT_PAGE_SIZE;
+      const backend = await getBackend();
+      const { items, total } = await backend.listSessionRows({
+        ...(envelope.query === undefined ? {} : { query: envelope.query }),
+        ...(envelope.includeSubagents === undefined
+          ? {}
+          : { includeSubagents: envelope.includeSubagents }),
+        limit: pageSize,
+        offset: (page - 1) * pageSize,
+      });
+      return { body: { items, total, page, pageSize } satisfies SessionRowsValue };
+    },
+    statusOfError: () => undefined,
   });
 }