@hexis-ai/engram-server 0.2.0 → 0.4.0

package/dist/adapters/memory-key-store.js

@@ -1,4 +1,4 @@
-import { generateRawKey, hashKey, isValidWorkspaceId, keyPrefix, } from "../key-store";
+import { deriveKey, hashKey, mintKey, resolveWorkspaceId, } from "../key-store";
 /**
  * In-process KeyStore for tests and single-node dev. Volatile.
  */
@@ -7,9 +7,7 @@ export class InMemoryKeyStore {
     keys = new Map();
     byHash = new Map();
     async createWorkspace(input) {
-        const id = input.id ?? crypto.randomUUID();
-        if (!isValidWorkspaceId(id))
-            throw new Error("invalid_workspace_id");
+        const id = resolveWorkspaceId(input);
         const existing = this.workspaces.get(id);
         if (existing)
             return existing;
@@ -40,12 +38,12 @@ export class InMemoryKeyStore {
     async issueKey(workspaceId, opts = {}) {
         if (!this.workspaces.has(workspaceId))
             throw new Error("workspace_not_found");
-        const raw = generateRawKey();
+        const { id, hash, prefix, raw } = mintKey();
         const row = {
-            id: crypto.randomUUID(),
+            id,
             workspaceId,
-            keyHash: hashKey(raw),
-            prefix: keyPrefix(raw),
+            keyHash: hash,
+            prefix,
             ...(opts.name !== undefined ? { name: opts.name } : {}),
             createdAt: new Date().toISOString(),
         };
@@ -80,14 +78,14 @@ export class InMemoryKeyStore {
     async registerKey(workspaceId, rawKey, name) {
         if (!this.workspaces.has(workspaceId))
             throw new Error("workspace_not_found");
-        const hash = hashKey(rawKey);
+        const { id, hash, prefix } = deriveKey(rawKey);
         if (this.byHash.has(hash))
             return;
         const row = {
-            id: crypto.randomUUID(),
+            id,
             workspaceId,
             keyHash: hash,
-            prefix: keyPrefix(rawKey),
+            prefix,
             ...(name !== undefined ? { name } : {}),
             createdAt: new Date().toISOString(),
         };

package/dist/adapters/memory.d.ts

@@ -20,6 +20,7 @@ export declare class InMemoryAdapter implements StorageAdapter {
     }): Promise<void>;
     appendEvents(sessionId: string, events: SessionEvent[]): Promise<void>;
     getSession(sessionId: string): Promise<Session | null>;
+    getSessionEvents(sessionId: string): Promise<SessionEvent[] | null>;
     listSessions(opts: {
         limit: number;
         channel?: string;

package/dist/adapters/memory.js

@@ -62,6 +62,12 @@ export class InMemoryAdapter {
             return null;
         return foldEvents(s.row, [...s.events.values()], new Date());
     }
+    async getSessionEvents(sessionId) {
+        const s = this.sessions.get(sessionId);
+        if (!s)
+            return null;
+        return [...s.events.values()].sort((a, b) => a.seq - b.seq);
+    }
     async listSessions(opts) {
         const now = new Date();
         const all = [];
@@ -104,7 +110,11 @@ export class InMemoryAdapter {
         const existing = this.persons.get(id);
         const next = {
             id,
-            display_name: input.display_name !== undefined
+            // `PersonCreate` has no notion of "clear the name" — that is
+            // `updatePerson`'s job. A missing value (and, defensively, an
+            // explicit null that bypasses the schema) means "keep what's
+            // there", matching the Postgres adapter's `COALESCE(EXCLUDED.…)`.
+            display_name: input.display_name != null
                 ? input.display_name
                 : existing?.display_name ?? null,
             created_at: existing?.created_at ?? now,

package/dist/adapters/postgres-key-store.js

@@ -1,4 +1,4 @@
-import { generateRawKey, hashKey, isValidWorkspaceId, keyPrefix, } from "../key-store";
+import { deriveKey, hashKey, mintKey, resolveWorkspaceId, } from "../key-store";
 import { runMigrations } from "../migrator";
 export class PostgresKeyStore {
     sql;
@@ -13,9 +13,7 @@ export class PostgresKeyStore {
         await runMigrations(this.sql);
     }
     async createWorkspace(input) {
-        const id = input.id ?? crypto.randomUUID();
-        if (!isValidWorkspaceId(id))
-            throw new Error("invalid_workspace_id");
+        const id = resolveWorkspaceId(input);
         await this.sql `
       INSERT INTO engram_workspaces (id, name, metadata)
       VALUES (${id}, ${input.name ?? null}, ${(input.metadata ?? {})})
@@ -49,10 +47,7 @@ export class PostgresKeyStore {
         const ws = await this.getWorkspace(workspaceId);
         if (!ws)
             throw new Error("workspace_not_found");
-        const raw = generateRawKey();
-        const id = crypto.randomUUID();
-        const hash = hashKey(raw);
-        const prefix = keyPrefix(raw);
+        const { id, hash, prefix, raw } = mintKey();
         const rows = await this.sql `
       INSERT INTO engram_api_keys (id, workspace_id, key_hash, prefix, name)
       VALUES (${id}, ${workspaceId}, ${hash}, ${prefix}, ${opts.name ?? null})
@@ -110,11 +105,10 @@ export class PostgresKeyStore {
         const ws = await this.getWorkspace(workspaceId);
         if (!ws)
             throw new Error("workspace_not_found");
-        const hash = hashKey(rawKey);
-        const id = crypto.randomUUID();
+        const { id, hash, prefix } = deriveKey(rawKey);
         await this.sql `
       INSERT INTO engram_api_keys (id, workspace_id, key_hash, prefix, name)
-      VALUES (${id}, ${workspaceId}, ${hash}, ${keyPrefix(rawKey)}, ${name ?? null})
+      VALUES (${id}, ${workspaceId}, ${hash}, ${prefix}, ${name ?? null})
       ON CONFLICT (key_hash) DO NOTHING
     `;
     }

package/dist/adapters/postgres.d.ts

@@ -37,6 +37,7 @@ export declare class PostgresAdapter implements StorageAdapter {
     }): Promise<void>;
     appendEvents(sessionId: string, events: SessionEvent[]): Promise<void>;
     getSession(sessionId: string): Promise<Session | null>;
+    getSessionEvents(sessionId: string): Promise<SessionEvent[] | null>;
     listSessions(opts: {
         limit: number;
         channel?: string;

package/dist/adapters/postgres.js

@@ -110,6 +110,21 @@ export class PostgresAdapter {
         };
         return foldEvents(row, events.map((e) => e.payload), new Date());
     }
+    async getSessionEvents(sessionId) {
+        const rows = await this.sql `
+      SELECT id FROM engram_sessions
+      WHERE workspace_id = ${this.workspaceId} AND id = ${sessionId}
+      LIMIT 1
+    `;
+        if (rows.length === 0)
+            return null;
+        const events = await this.sql `
+      SELECT payload FROM engram_events
+      WHERE workspace_id = ${this.workspaceId} AND session_id = ${sessionId}
+      ORDER BY seq
+    `;
+        return events.map((e) => e.payload);
+    }
     async listSessions(opts) {
         const channelFilter = opts.channel ?? null;
         const rows = await this.sql `

package/dist/index.d.ts

@@ -7,3 +7,4 @@ export { type KeyStore, type Workspace, type ApiKeyInfo, type IssuedKey, type Ke
 export { InMemoryKeyStore } from "./adapters/memory-key-store";
 export { PostgresKeyStore } from "./adapters/postgres-key-store";
 export { createAdminRouter, type AdminOptions } from "./admin";
+export { buildOpenApiDocument } from "./openapi";

package/dist/index.js

@@ -7,3 +7,4 @@ export { generateRawKey, hashKey, keyPrefix, isValidWorkspaceId, } from "./key-s
 export { InMemoryKeyStore } from "./adapters/memory-key-store";
 export { PostgresKeyStore } from "./adapters/postgres-key-store";
 export { createAdminRouter } from "./admin";
+export { buildOpenApiDocument } from "./openapi";

package/dist/key-store.d.ts

@@ -61,3 +61,32 @@ export declare function generateRawKey(): string;
 export declare function hashKey(raw: string): string;
 export declare function keyPrefix(raw: string): string;
 export declare function isValidWorkspaceId(id: string): boolean;
+/**
+ * Resolve the workspace id for a `createWorkspace` call: fall back to a random
+ * UUID when none is supplied, then validate. Shared by every KeyStore so the
+ * id policy can't drift between the in-memory and Postgres adapters.
+ */
+export declare function resolveWorkspaceId(input: {
+    id?: string;
+}): string;
+/** Derived material for a single API key row. */
+export interface KeyMaterial {
+    /** Row id (primary key). */
+    id: string;
+    /** SHA-256 hash of the raw key — the only form that gets persisted. */
+    hash: string;
+    /** Human-readable prefix shown in listings. */
+    prefix: string;
+}
+/**
+ * Mint a brand-new random key. Returns the persistable material plus the
+ * plaintext `raw` key, which the caller must return to the user exactly once.
+ */
+export declare function mintKey(): KeyMaterial & {
+    raw: string;
+};
+/**
+ * Derive persistable material for a caller-supplied raw key (`registerKey`).
+ * Unlike `mintKey`, the raw key already exists and is not returned.
+ */
+export declare function deriveKey(raw: string): KeyMaterial;

package/dist/key-store.js

@@ -15,3 +15,29 @@ export function keyPrefix(raw) {
 export function isValidWorkspaceId(id) {
     return WORKSPACE_ID_RE.test(id);
 }
+/**
+ * Resolve the workspace id for a `createWorkspace` call: fall back to a random
+ * UUID when none is supplied, then validate. Shared by every KeyStore so the
+ * id policy can't drift between the in-memory and Postgres adapters.
+ */
+export function resolveWorkspaceId(input) {
+    const id = input.id ?? crypto.randomUUID();
+    if (!isValidWorkspaceId(id))
+        throw new Error("invalid_workspace_id");
+    return id;
+}
+/**
+ * Mint a brand-new random key. Returns the persistable material plus the
+ * plaintext `raw` key, which the caller must return to the user exactly once.
+ */
+export function mintKey() {
+    const raw = generateRawKey();
+    return { id: crypto.randomUUID(), hash: hashKey(raw), prefix: keyPrefix(raw), raw };
+}
+/**
+ * Derive persistable material for a caller-supplied raw key (`registerKey`).
+ * Unlike `mintKey`, the raw key already exists and is not returned.
+ */
+export function deriveKey(raw) {
+    return { id: crypto.randomUUID(), hash: hashKey(raw), prefix: keyPrefix(raw) };
+}

package/dist/openapi.d.ts

@@ -0,0 +1,8 @@
+type Json = Record<string, unknown>;
+/**
+ * Build the OpenAPI 3.1 document. Pure and deterministic — `gen-openapi.ts`
+ * writes its output to `openapi.json`, and `openapi.test.ts` asserts the
+ * committed file still matches.
+ */
+export declare function buildOpenApiDocument(): Json;
+export {};

package/dist/openapi.js

@@ -0,0 +1,368 @@
+/**
+ * OpenAPI 3.1 document for the engram HTTP API, assembled from the same Zod
+ * schemas the server validates with (`src/schemas.ts`). The request-body
+ * contract therefore cannot drift from what the server actually accepts —
+ * a sync test (`test/openapi.test.ts`) fails the build if it does.
+ *
+ * This is the language-neutral contract artifact. Non-TypeScript engram SDK
+ * ports generate their wire types from `packages/server/openapi.json`
+ * (produced by `bun run gen:openapi`) instead of hand-mirroring the
+ * TypeScript interfaces in `@hexis-ai/engram-sdk`.
+ *
+ * `info.version` is the API version (the `/v1` surface), not the npm package
+ * version — it changes only when the wire contract changes.
+ *
+ * The human-readable strings (`summary`, `description`, response and
+ * parameter descriptions) are written in Japanese — the API reference is
+ * read by the Hexis team. Identifiers, paths, schema names and status
+ * codes stay as-is.
+ */
+import { z } from "zod";
+import { createWorkspaceSchema, eventBatchSchema, issueKeySchema, personCreateSchema, personUpdateSchema, searchRequestSchema, sessionInitSchema, } from "./schemas";
+/** Convert a Zod schema to a JSON Schema object for an OpenAPI component. */
+function toComponent(schema) {
+    const js = z.toJSONSchema(schema);
+    delete js.$schema;
+    return js;
+}
+const ref = (name) => ({ $ref: `#/components/schemas/${name}` });
+const jsonBody = (schemaName, required = true) => ({
+    required,
+    content: { "application/json": { schema: ref(schemaName) } },
+});
+const pathParam = (name, description) => ({
+    name,
+    in: "path",
+    required: true,
+    schema: { type: "string" },
+    description,
+});
+const queryParam = (name, description, schema = { type: "string" }) => ({ name, in: "query", required: false, schema, description });
+const res = (description) => ({ description });
+/** Default security: a workspace API key. `/admin/v1` paths override this. */
+const workspaceAuth = [{ workspaceKey: [] }];
+const adminAuth = [{ adminToken: [] }];
+// ---------------------------------------------------------------------
+// Tags — group the rendered reference (Scalar, on monet-web /docs/engram)
+// into a per-domain sidebar instead of one flat list of 19 operations.
+//
+//   The tag *definitions* (sidebar order + Japanese descriptions) live
+//   in TAG_DEFS; `tagged()` stamps a tag onto every operation in a
+//   path-item, so each path in buildPaths() declares its tag once,
+//   inline. test/openapi.test.ts guards that no operation slips through
+//   untagged and no operation references an undefined tag.
+// ---------------------------------------------------------------------
+/** Every tag, in sidebar order, with a Japanese description. */
+const TAG_DEFS = [
+    { name: "Me", description: "識別プローブ" },
+    { name: "Sessions", description: "セッションの作成・取得・イベント追加" },
+    { name: "Search", description: "ワークスペースコーパスへのスコアリング検索" },
+    { name: "Persons", description: "person の作成・更新・検索" },
+    {
+        name: "Workspaces (admin)",
+        description: "ワークスペースの管理（管理者トークン必須）",
+    },
+    {
+        name: "API Keys (admin)",
+        description: "ワークスペース API キーの発行・無効化（管理者トークン必須）",
+    },
+];
+/**
+ * Stamp `tag` onto every operation in a path-item. The path declares its
+ * tag once — `tagged("Sessions", { post: {…}, get: {…} })` — rather than
+ * repeating `tags` on each method.
+ */
+function tagged(tag, pathItem) {
+    const out = {};
+    for (const [method, op] of Object.entries(pathItem)) {
+        out[method] = { ...op, tags: [tag] };
+    }
+    return out;
+}
+const limitParam = queryParam("limit", "ページサイズ。サーバー側で上限が適用される。", {
+    type: "integer",
+    minimum: 1,
+});
+const channelParam = queryParam("channel", "セッションのチャンネルで絞り込む。");
+function buildPaths() {
+    return {
+        "/v1/me": tagged("Me", {
+            get: {
+                summary: "識別プローブ — 呼び出し元のキーが解決するワークスペースを返す。",
+                responses: {
+                    "200": res("ワークスペース id"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/sessions": tagged("Sessions", {
+            post: {
+                summary: "セッションを作成する。",
+                requestBody: jsonBody("SessionInit"),
+                responses: {
+                    "200": res("作成されたセッション id"),
+                    "400": res("リクエストボディが不正"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "最近のセッション一覧と、それに紐づく persons マップを取得する。",
+                parameters: [limitParam, channelParam],
+                responses: {
+                    "200": res("セッション一覧のエンベロープ"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/sessions/{id}": tagged("Sessions", {
+            get: {
+                summary: "単一セッションと、それに紐づく persons マップを取得する。",
+                parameters: [pathParam("id", "セッション id。")],
+                responses: {
+                    "200": res("セッションのエンベロープ"),
+                    "404": res("セッションが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/sessions/{id}/events": tagged("Sessions", {
+            post: {
+                summary: "セッションにイベントを追加する。",
+                parameters: [pathParam("id", "セッション id。")],
+                requestBody: jsonBody("EventBatch"),
+                responses: {
+                    "204": res("追加完了"),
+                    "400": res("リクエストボディが不正"),
+                    "404": res("セッションが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "セッションの生イベントログを seq 順で取得する（fold せず、各イベントの時刻つき）。",
+                parameters: [pathParam("id", "セッション id。")],
+                responses: {
+                    "200": res("イベントログ"),
+                    "404": res("セッションが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/search": tagged("Search", {
+            post: {
+                summary: "クエリセッションに対してワークスペースのコーパスをスコアリングする。",
+                requestBody: jsonBody("SearchRequest"),
+                responses: {
+                    "200": res("スコアリング結果と persons マップ"),
+                    "400": res("リクエストボディが不正"),
+                    "404": res("クエリセッションが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/persons": tagged("Persons", {
+            post: {
+                summary: "person を作成する（id はサーバーが採番する）。",
+                requestBody: jsonBody("PersonCreate"),
+                responses: {
+                    "201": res("作成された person"),
+                    "400": res("リクエストボディが不正"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "person の一覧取得、またはフリーテキスト検索を行う。",
+                parameters: [
+                    limitParam,
+                    queryParam("q", "id と display_name に対するフリーテキストクエリ。"),
+                ],
+                responses: {
+                    "200": res("person 一覧"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/persons/{id}": tagged("Persons", {
+            put: {
+                summary: "呼び出し元が指定した id で person を upsert する。",
+                parameters: [pathParam("id", "person id。")],
+                requestBody: jsonBody("PersonCreate"),
+                responses: {
+                    "200": res("upsert された person"),
+                    "400": res("リクエストボディが不正"),
+                    "401": res("認証エラー"),
+                },
+            },
+            patch: {
+                summary: "person のプロフィール項目を部分更新する。",
+                parameters: [pathParam("id", "person id。")],
+                requestBody: jsonBody("PersonUpdate"),
+                responses: {
+                    "200": res("更新された person"),
+                    "400": res("リクエストボディが不正"),
+                    "404": res("person が見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "単一の person を取得する。",
+                parameters: [pathParam("id", "person id。")],
+                responses: {
+                    "200": res("person"),
+                    "404": res("person が見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/v1/persons/{id}/sessions": tagged("Persons", {
+            get: {
+                summary: "この person が参加している（または閲覧可能な）セッション一覧。",
+                parameters: [
+                    pathParam("id", "person id。"),
+                    limitParam,
+                    channelParam,
+                    queryParam("scope", "`participant`（デフォルト）または `viewable`。", {
+                        type: "string",
+                        enum: ["participant", "viewable"],
+                    }),
+                ],
+                responses: {
+                    "200": res("セッション一覧のエンベロープ"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/admin/v1/workspaces": tagged("Workspaces (admin)", {
+            post: {
+                summary: "ワークスペースを作成する（デフォルトで初期キーも発行する）。",
+                security: adminAuth,
+                requestBody: jsonBody("CreateWorkspace"),
+                responses: {
+                    "200": res("ワークスペース（issueKey=false でない限りキーも含む）"),
+                    "400": res("リクエストボディまたはワークスペース id が不正"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "全ワークスペースを一覧取得する。",
+                security: adminAuth,
+                responses: {
+                    "200": res("ワークスペース一覧"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/admin/v1/workspaces/{id}": tagged("Workspaces (admin)", {
+            get: {
+                summary: "単一のワークスペースを取得する。",
+                security: adminAuth,
+                parameters: [pathParam("id", "ワークスペース id。")],
+                responses: {
+                    "200": res("ワークスペース"),
+                    "404": res("ワークスペースが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+            delete: {
+                summary: "ワークスペースを削除する（キー・セッション・イベントにカスケードする）。",
+                security: adminAuth,
+                parameters: [pathParam("id", "ワークスペース id。")],
+                responses: {
+                    "204": res("削除完了"),
+                    "404": res("ワークスペースが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/admin/v1/workspaces/{id}/keys": tagged("API Keys (admin)", {
+            post: {
+                summary: "ワークスペースに新しい API キーを発行する。",
+                security: adminAuth,
+                parameters: [pathParam("id", "ワークスペース id。")],
+                requestBody: jsonBody("IssueKey", false),
+                responses: {
+                    "200": res("発行されたキー（生のキーは一度のみ返却）"),
+                    "400": res("リクエストボディが不正"),
+                    "404": res("ワークスペースが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+            get: {
+                summary: "ワークスペースの API キー一覧を取得する（ハッシュのみ）。",
+                security: adminAuth,
+                parameters: [pathParam("id", "ワークスペース id。")],
+                responses: {
+                    "200": res("キー一覧"),
+                    "404": res("ワークスペースが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+        "/admin/v1/workspaces/{id}/keys/{keyId}": tagged("API Keys (admin)", {
+            delete: {
+                summary: "API キーを無効化する。",
+                security: adminAuth,
+                parameters: [
+                    pathParam("id", "ワークスペース id。"),
+                    pathParam("keyId", "キー id。"),
+                ],
+                responses: {
+                    "204": res("無効化完了（冪等）"),
+                    "404": res("キーが見つからない"),
+                    "401": res("認証エラー"),
+                },
+            },
+        }),
+    };
+}
+/**
+ * Build the OpenAPI 3.1 document. Pure and deterministic — `gen-openapi.ts`
+ * writes its output to `openapi.json`, and `openapi.test.ts` asserts the
+ * committed file still matches.
+ */
+export function buildOpenApiDocument() {
+    return {
+        openapi: "3.1.0",
+        info: {
+            title: "engram-server",
+            version: "1.0",
+            description: "AI エージェント向けのクロスセッション検索。リクエストボディは" +
+                "サーバーの Zod スキーマ（src/schemas.ts）から導出される。" +
+                "レスポンススキーマは現状ステータスコードのみの記述で、" +
+                "本格的な記述は今後対応予定。",
+        },
+        tags: TAG_DEFS.map((t) => ({ ...t })),
+        servers: [
+            { url: "/", description: "デプロイされた engram-server からの相対パス" },
+        ],
+        security: workspaceAuth,
+        components: {
+            securitySchemes: {
+                workspaceKey: {
+                    type: "http",
+                    scheme: "bearer",
+                    description: "ワークスペース API キー（`eng_…`）。`X-Api-Key` ヘッダーでも受け付ける。",
+                },
+                adminToken: {
+                    type: "apiKey",
+                    in: "header",
+                    name: "X-Admin-Token",
+                    description: "`/admin/v1/*` 用のプラットフォーム管理者トークン。" +
+                        "`Authorization: Bearer` でも受け付ける。",
+                },
+            },
+            schemas: {
+                SessionInit: toComponent(sessionInitSchema),
+                // `EventBatch` inlines the per-event shape. A standalone `SessionEvent`
+                // component (cross-`$ref`'d) is a planned follow-up alongside response
+                // schemas — zod's `toJSONSchema` inlines by default.
+                EventBatch: toComponent(eventBatchSchema),
+                PersonCreate: toComponent(personCreateSchema),
+                PersonUpdate: toComponent(personUpdateSchema),
+                SearchRequest: toComponent(searchRequestSchema),
+                CreateWorkspace: toComponent(createWorkspaceSchema),
+                IssueKey: toComponent(issueKeySchema),
+            },
+        },
+        paths: buildPaths(),
+    };
+}

package/dist/routes/sessions.d.ts

@@ -3,9 +3,10 @@ import type { Env } from "../context";
 import { type RouteConfig } from "./helpers";
 /**
  * Session routes. Mount under `/v1`:
- *   POST /v1/sessions            create a session
- *   POST /v1/sessions/:id/events append events
- *   GET  /v1/sessions/:id        fetch one session + its persons map
- *   GET  /v1/sessions            list recent sessions + persons map
+ *   POST /v1/sessions             create a session
+ *   POST /v1/sessions/:id/events  append events
+ *   GET  /v1/sessions/:id         fetch one session + its persons map
+ *   GET  /v1/sessions/:id/events  fetch the raw, ordered event log
+ *   GET  /v1/sessions             list recent sessions + persons map
  */
 export declare function sessionsRoutes(cfg: RouteConfig): Hono<Env>;

package/dist/routes/sessions.js

@@ -3,10 +3,11 @@ import { eventBatchSchema, parseJsonBody, sessionInitSchema } from "../schemas";
 import { clampLimit, resolvePersonMap } from "./helpers";
 /**
  * Session routes. Mount under `/v1`:
- *   POST /v1/sessions            create a session
- *   POST /v1/sessions/:id/events append events
- *   GET  /v1/sessions/:id        fetch one session + its persons map
- *   GET  /v1/sessions            list recent sessions + persons map
+ *   POST /v1/sessions             create a session
+ *   POST /v1/sessions/:id/events  append events
+ *   GET  /v1/sessions/:id         fetch one session + its persons map
+ *   GET  /v1/sessions/:id/events  fetch the raw, ordered event log
+ *   GET  /v1/sessions             list recent sessions + persons map
  */
 export function sessionsRoutes(cfg) {
     const app = new Hono();
@@ -40,6 +41,13 @@ export function sessionsRoutes(cfg) {
         const persons = await resolvePersonMap(c.var.ctx.storage, [s]);
         return c.json({ session: s, persons });
     });
+    app.get("/sessions/:id/events", async (c) => {
+        const id = c.req.param("id");
+        const events = await c.var.ctx.storage.getSessionEvents(id);
+        if (events === null)
+            return c.json({ error: "session_not_found" }, 404);
+        return c.json({ events });
+    });
     app.get("/sessions", async (c) => {
         const limit = clampLimit(c, cfg.defaultListLimit, cfg.maxListLimit);
         const channel = c.req.query("channel") || undefined;