@lightupai/polaris 0.0.1

package/tests/client.test.ts

@@ -0,0 +1,187 @@
+import { describe, expect, test, beforeAll, afterAll, beforeEach } from "bun:test";
+import { startServer } from "../src/service/server";
+import { startDaemon } from "../src/daemon/daemon";
+import type { Sql } from "../src/service/db";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris";
+
+let serviceUrl: string;
+let daemonUrl: string;
+let sql: Sql;
+let stopService: () => Promise<void>;
+let stopDaemon: () => void;
+
+beforeAll(async () => {
+  const s = await startServer({ port: 0, databaseUrl: DATABASE_URL });
+  sql = s.sql;
+  stopService = s.stop;
+  serviceUrl = `http://localhost:${s.server.port}`;
+
+  process.env.POLARIS_SERVICE_URL = serviceUrl;
+  const d = startDaemon(0);
+  stopDaemon = d.stop;
+  daemonUrl = `http://127.0.0.1:${d.server.port}`;
+});
+
+afterAll(async () => {
+  stopDaemon();
+  await stopService();
+});
+
+beforeEach(async () => {
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql`CREATE TABLE IF NOT EXISTS orgs (id TEXT PRIMARY KEY, name TEXT NOT NULL, domain TEXT, slack_team_id TEXT, slack_bot_token TEXT, slack_system_channel_id TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`;
+  await sql`CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY, email TEXT NOT NULL UNIQUE, name TEXT NOT NULL, org_id TEXT NOT NULL REFERENCES orgs(id), participant_id TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`;
+  await sql`CREATE TABLE IF NOT EXISTS projects (name TEXT NOT NULL, org_id TEXT NOT NULL REFERENCES orgs(id), created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (org_id, name))`;
+  await sql`CREATE TABLE IF NOT EXISTS sessions (name TEXT NOT NULL, project TEXT NOT NULL, org_id TEXT NOT NULL, driver TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (org_id, project, name), FOREIGN KEY (org_id, project) REFERENCES projects(org_id, name))`;
+  await sql`CREATE TABLE IF NOT EXISTS events (id UUID PRIMARY KEY, org_id TEXT NOT NULL, project TEXT NOT NULL, session TEXT NOT NULL, timestamp TIMESTAMPTZ NOT NULL, source TEXT NOT NULL, sender TEXT NOT NULL, payload JSONB NOT NULL)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_events_project ON events(org_id, project, timestamp)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_events_session ON events(org_id, project, session, timestamp)`;
+  await sql`INSERT INTO orgs (id, name) VALUES ('default', 'Default') ON CONFLICT DO NOTHING`;
+});
+
+async function post(base: string, path: string, body: unknown) {
+  return fetch(`${base}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function get(base: string, path: string) {
+  return fetch(`${base}${path}`);
+}
+
+describe("end-to-end: daemon + cloud service", () => {
+  test("connect → hook event → appears in cloud", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "e2e-1",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    await post(daemonUrl, "/events", {
+      session_id: "e2e-1",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "build auth",
+    });
+
+    const res = await get(serviceUrl, "/projects/pj/sessions/fxm/messages");
+    const body = await res.json();
+    expect(body).toHaveLength(1);
+    expect(body[0].payload.prompt).toBe("build auth");
+    expect(body[0].sender).toBe("user:manu");
+  });
+
+  test("inject event reaches session WS via daemon", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "e2e-2",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const wsUrl = serviceUrl.replace("http", "ws");
+    const ws = new WebSocket(`${wsUrl}/projects/pj/sessions/fxm/ws`);
+    const received: unknown[] = [];
+    await new Promise<void>((resolve) => { ws.onopen = () => resolve(); });
+    ws.onmessage = (e) => received.push(JSON.parse(e.data as string));
+
+    await post(serviceUrl, "/projects/pj/sessions/fxm/inject", {
+      content: "Use RS256",
+      sender: "user:krishna",
+    });
+
+    await new Promise((r) => setTimeout(r, 100));
+    expect(received).toHaveLength(1);
+    expect((received[0] as { source: string }).source).toBe("inject");
+    ws.close();
+  });
+
+  test("multiple sessions on same machine route independently", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "multi-1",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "multi-2",
+      project: "pj",
+      session: "fxk",
+      user: "user:krishna",
+    });
+
+    await post(daemonUrl, "/events", {
+      session_id: "multi-1",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "from fxm",
+    });
+    await post(daemonUrl, "/events", {
+      session_id: "multi-2",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "from fxk",
+    });
+
+    const fxmRes = await get(serviceUrl, "/projects/pj/sessions/fxm/messages");
+    const fxmBody = await fxmRes.json();
+    expect(fxmBody).toHaveLength(1);
+    expect(fxmBody[0].payload.prompt).toBe("from fxm");
+    expect(fxmBody[0].sender).toBe("user:manu");
+
+    const fxkRes = await get(serviceUrl, "/projects/pj/sessions/fxk/messages");
+    const fxkBody = await fxkRes.json();
+    expect(fxkBody).toHaveLength(1);
+    expect(fxkBody[0].payload.prompt).toBe("from fxk");
+    expect(fxkBody[0].sender).toBe("user:krishna");
+  });
+});
+
+describe("capture.sh with daemon", () => {
+  test("script relays stdin to daemon", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "capture-1",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const hookPayload = JSON.stringify({
+      session_id: "capture-1",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "test from capture.sh",
+    });
+
+    const proc = Bun.spawn(["sh", "hooks/capture.sh"], {
+      stdin: "pipe",
+      env: { ...process.env, POLARIS_PORT: String(new URL(daemonUrl).port) },
+    });
+    proc.stdin.write(hookPayload);
+    proc.stdin.end();
+    const exitCode = await proc.exited;
+    expect(exitCode).toBe(0);
+
+    await new Promise((r) => setTimeout(r, 200));
+
+    const res = await get(serviceUrl, "/projects/pj/sessions/fxm/messages");
+    const body = await res.json();
+    expect(body).toHaveLength(1);
+    expect(body[0].payload.prompt).toBe("test from capture.sh");
+  });
+
+  test("script exits 0 when daemon is down", async () => {
+    const proc = Bun.spawn(["sh", "hooks/capture.sh"], {
+      stdin: "pipe",
+      env: { ...process.env, POLARIS_PORT: "59999" },
+    });
+    proc.stdin.write('{"session_id":"x","test":true}');
+    proc.stdin.end();
+    const exitCode = await proc.exited;
+    expect(exitCode).toBe(0);
+  });
+});

package/tests/daemon.test.ts

@@ -0,0 +1,220 @@
+import { describe, expect, test, beforeAll, afterAll, beforeEach } from "bun:test";
+import { startDaemon } from "../src/daemon/daemon";
+import { startServer } from "../src/service/server";
+import type { Sql } from "../src/service/db";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris";
+
+let daemonUrl: string;
+let serviceUrl: string;
+let sql: Sql;
+let stopDaemon: () => void;
+let stopService: () => Promise<void>;
+
+beforeAll(async () => {
+  // Start cloud service
+  const s = await startServer({ port: 0, databaseUrl: DATABASE_URL });
+  sql = s.sql;
+  stopService = s.stop;
+  serviceUrl = `http://localhost:${s.server.port}`;
+
+  // Start daemon pointed at the cloud service
+  process.env.POLARIS_SERVICE_URL = serviceUrl;
+  const d = startDaemon(0);
+  stopDaemon = d.stop;
+  daemonUrl = `http://127.0.0.1:${d.server.port}`;
+});
+
+afterAll(async () => {
+  stopDaemon();
+  await stopService();
+});
+
+beforeEach(async () => {
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql`CREATE TABLE IF NOT EXISTS orgs (id TEXT PRIMARY KEY, name TEXT NOT NULL, domain TEXT, slack_team_id TEXT, slack_bot_token TEXT, slack_system_channel_id TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`;
+  await sql`CREATE TABLE IF NOT EXISTS users (id TEXT PRIMARY KEY, email TEXT NOT NULL UNIQUE, name TEXT NOT NULL, org_id TEXT NOT NULL REFERENCES orgs(id), participant_id TEXT NOT NULL, created_at TIMESTAMPTZ NOT NULL DEFAULT now())`;
+  await sql`CREATE TABLE IF NOT EXISTS projects (name TEXT NOT NULL, org_id TEXT NOT NULL REFERENCES orgs(id), created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (org_id, name))`;
+  await sql`CREATE TABLE IF NOT EXISTS sessions (name TEXT NOT NULL, project TEXT NOT NULL, org_id TEXT NOT NULL, driver TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY (org_id, project, name), FOREIGN KEY (org_id, project) REFERENCES projects(org_id, name))`;
+  await sql`CREATE TABLE IF NOT EXISTS events (id UUID PRIMARY KEY, org_id TEXT NOT NULL, project TEXT NOT NULL, session TEXT NOT NULL, timestamp TIMESTAMPTZ NOT NULL, source TEXT NOT NULL, sender TEXT NOT NULL, payload JSONB NOT NULL)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_events_project ON events(org_id, project, timestamp)`;
+  await sql`CREATE INDEX IF NOT EXISTS idx_events_session ON events(org_id, project, session, timestamp)`;
+  await sql`INSERT INTO orgs (id, name) VALUES ('default', 'Default') ON CONFLICT DO NOTHING`;
+});
+
+async function post(base: string, path: string, body: unknown) {
+  return fetch(`${base}${path}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function get(base: string, path: string) {
+  return fetch(`${base}${path}`);
+}
+
+describe("daemon /register", () => {
+  test("registers a CC session", async () => {
+    const res = await post(daemonUrl, "/register", { ccSessionId: "cc-1" });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.status).toBe("registered");
+  });
+
+  test("rejects missing ccSessionId", async () => {
+    const res = await post(daemonUrl, "/register", {});
+    expect(res.status).toBe(400);
+  });
+});
+
+describe("daemon /connect", () => {
+  test("connects a CC session to a polaris project/session", async () => {
+    const res = await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-2",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.status).toBe("connected");
+    expect(body.project).toBe("pj");
+
+    // Verify project and session were created on cloud
+    const projRes = await get(serviceUrl, "/projects/pj");
+    expect(projRes.status).toBe(200);
+
+    const sessRes = await get(serviceUrl, "/projects/pj/sessions/fxm");
+    expect(sessRes.status).toBe(200);
+    const sess = await sessRes.json();
+    expect(sess.driver).toBe("user:manu");
+  });
+
+  test("rejects missing fields", async () => {
+    const res = await post(daemonUrl, "/connect", { ccSessionId: "cc-3" });
+    expect(res.status).toBe(400);
+  });
+
+  test("connecting twice switches sessions", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-4",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const res = await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-4",
+      project: "pj",
+      session: "fxk",
+      user: "user:manu",
+    });
+    expect(res.status).toBe(200);
+
+    const status = await get(daemonUrl, "/status/cc-4");
+    const body = await status.json();
+    expect(body.session).toBe("fxk");
+  });
+});
+
+describe("daemon /disconnect", () => {
+  test("disconnects a CC session", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-5",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const res = await post(daemonUrl, "/disconnect", { ccSessionId: "cc-5" });
+    expect(res.status).toBe(200);
+
+    const status = await get(daemonUrl, "/status/cc-5");
+    const body = await status.json();
+    expect(body.connected).toBe(false);
+  });
+});
+
+describe("daemon /events (hook relay)", () => {
+  test("relays hook events to cloud service", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-6",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const res = await post(daemonUrl, "/events", {
+      session_id: "cc-6",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "build auth middleware",
+    });
+    expect(res.status).toBe(200);
+
+    // Verify event reached cloud
+    const messages = await get(serviceUrl, "/projects/pj/sessions/fxm/messages");
+    const body = await messages.json();
+    expect(body).toHaveLength(1);
+    expect(body[0].payload.prompt).toBe("build auth middleware");
+  });
+
+  test("discards events for unconnected sessions", async () => {
+    const res = await post(daemonUrl, "/events", {
+      session_id: "cc-unknown",
+      hook_event_name: "UserPromptSubmit",
+      prompt: "hello",
+    });
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body.status).toBe("not_connected");
+  });
+});
+
+describe("daemon /status", () => {
+  test("returns session-specific status", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-7",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+
+    const res = await get(daemonUrl, "/status/cc-7");
+    const body = await res.json();
+    expect(body.connected).toBe(true);
+    expect(body.project).toBe("pj");
+    expect(body.session).toBe("fxm");
+    expect(body.user).toBe("user:manu");
+  });
+
+  test("returns not connected for unknown session", async () => {
+    const res = await get(daemonUrl, "/status/cc-nonexistent");
+    const body = await res.json();
+    expect(body.connected).toBe(false);
+  });
+
+  test("returns daemon health with all active sessions", async () => {
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-8a",
+      project: "pj",
+      session: "fxm",
+      user: "user:manu",
+    });
+    await post(daemonUrl, "/connect", {
+      ccSessionId: "cc-8b",
+      project: "pj",
+      session: "fxk",
+      user: "user:krishna",
+    });
+
+    const res = await get(daemonUrl, "/status");
+    const body = await res.json();
+    expect(body.ok).toBe(true);
+    expect(body.sessions.length).toBeGreaterThanOrEqual(2);
+  });
+});

package/tests/db.test.ts

@@ -0,0 +1,282 @@
+import { describe, expect, test, beforeEach, afterAll } from "bun:test";
+import {
+  createDb,
+  createOrg,
+  getOrg,
+  getOrgByDomain,
+  setOrgSlack,
+  createUser,
+  getUser,
+  getUserByEmail,
+  upsertUser,
+  createProject,
+  getProject,
+  createSession,
+  getSession,
+  setDriver,
+  clearDriver,
+  pushEvent,
+  getProjectEvents,
+  getSessionEvents,
+  getEventsSince,
+  type Sql,
+} from "../src/service/db";
+import type { PolarisEvent } from "../src/types";
+
+const DATABASE_URL = process.env.DATABASE_URL ?? "postgres://polaris:polaris@localhost:5432/polaris";
+
+let sql: Sql;
+
+beforeEach(async () => {
+  sql = await createDb(DATABASE_URL);
+  await sql`DROP TABLE IF EXISTS events`;
+  await sql`DROP TABLE IF EXISTS sessions`;
+  await sql`DROP TABLE IF EXISTS projects`;
+  await sql`DROP TABLE IF EXISTS users`;
+  await sql`DROP TABLE IF EXISTS orgs`;
+  await sql.end();
+  sql = await createDb(DATABASE_URL);
+  await createOrg(sql, "test-org", "Test Org");
+});
+
+afterAll(async () => {
+  await sql.end();
+});
+
+function makeEvent(overrides: Partial<PolarisEvent> = {}): PolarisEvent {
+  return {
+    id: crypto.randomUUID(),
+    project: "pj",
+    session: "fxm",
+    timestamp: new Date().toISOString(),
+    source: "hook",
+    sender: "user:manu",
+    payload: {
+      hook_event_name: "UserPromptSubmit",
+      session_id: "s1",
+      prompt: "hello",
+    },
+    ...overrides,
+  };
+}
+
+describe("orgs", () => {
+  test("create and retrieve an org", async () => {
+    const org = await getOrg(sql, "test-org");
+    expect(org).not.toBeNull();
+    expect(org!.name).toBe("Test Org");
+    expect(org!.created_at).toBeDefined();
+  });
+
+  test("duplicate org id throws", async () => {
+    expect(createOrg(sql, "test-org", "Duplicate")).rejects.toThrow();
+  });
+
+  test("get nonexistent org returns null", async () => {
+    expect(await getOrg(sql, "nope")).toBeNull();
+  });
+
+  test("get org by domain", async () => {
+    await createOrg(sql, "domain-org", "Domain Org", "example.com");
+    const org = await getOrgByDomain(sql, "example.com");
+    expect(org).not.toBeNull();
+    expect(org!.id).toBe("domain-org");
+  });
+
+  test("get org by domain returns null for unknown domain", async () => {
+    expect(await getOrgByDomain(sql, "unknown.com")).toBeNull();
+  });
+
+  test("set org slack credentials", async () => {
+    await setOrgSlack(sql, "test-org", "T123", "xoxb-token");
+    const org = await getOrg(sql, "test-org");
+    expect(org!.slack_team_id).toBe("T123");
+    expect(org!.slack_bot_token).toBe("xoxb-token");
+  });
+});
+
+describe("users", () => {
+  test("create and retrieve a user", async () => {
+    const user = await createUser(sql, "u1", "manu@test.com", "Manu", "test-org", "user:manu");
+    expect(user.email).toBe("manu@test.com");
+    expect(user.org_id).toBe("test-org");
+    expect(user.participant_id).toBe("user:manu");
+
+    const retrieved = await getUser(sql, "u1");
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.name).toBe("Manu");
+  });
+
+  test("get user by email", async () => {
+    await createUser(sql, "u2", "krishna@test.com", "Krishna", "test-org", "user:krishna");
+    const user = await getUserByEmail(sql, "krishna@test.com");
+    expect(user).not.toBeNull();
+    expect(user!.id).toBe("u2");
+  });
+
+  test("get nonexistent user returns null", async () => {
+    expect(await getUser(sql, "nope")).toBeNull();
+    expect(await getUserByEmail(sql, "nope@test.com")).toBeNull();
+  });
+
+  test("duplicate email throws", async () => {
+    await createUser(sql, "u3", "dupe@test.com", "User A", "test-org", "user:a");
+    expect(createUser(sql, "u4", "dupe@test.com", "User B", "test-org", "user:b")).rejects.toThrow();
+  });
+
+  test("upsert user updates existing", async () => {
+    await createUser(sql, "u5", "upsert@test.com", "Old Name", "test-org", "user:old");
+    const updated = await upsertUser(sql, "u5-new", "upsert@test.com", "New Name", "test-org", "user:new");
+    expect(updated.name).toBe("New Name");
+    expect(updated.participant_id).toBe("user:new");
+
+    const fetched = await getUserByEmail(sql, "upsert@test.com");
+    expect(fetched!.name).toBe("New Name");
+  });
+});
+
+describe("projects", () => {
+  test("create and retrieve a project", async () => {
+    const project = await createProject(sql, "test-org", "pj");
+    expect(project.name).toBe("pj");
+    expect(project.created_at).toBeDefined();
+
+    const retrieved = await getProject(sql, "test-org", "pj");
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.name).toBe("pj");
+  });
+
+  test("duplicate project name throws", async () => {
+    await createProject(sql, "test-org", "pj");
+    expect(createProject(sql, "test-org", "pj")).rejects.toThrow();
+  });
+
+  test("get nonexistent project returns null", async () => {
+    expect(await getProject(sql, "test-org", "nope")).toBeNull();
+  });
+});
+
+describe("sessions", () => {
+  beforeEach(async () => {
+    await createProject(sql, "test-org", "pj");
+  });
+
+  test("create and retrieve a session", async () => {
+    const session = await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    expect(session.name).toBe("fxm");
+    expect(session.project).toBe("pj");
+    expect(session.driver).toBe("user:manu");
+
+    const retrieved = await getSession(sql, "test-org", "pj", "fxm");
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.driver).toBe("user:manu");
+  });
+
+  test("create session with null driver", async () => {
+    const session = await createSession(sql, "test-org", "pj", "open-session", null);
+    expect(session.driver).toBeNull();
+  });
+
+  test("duplicate session name in same project throws", async () => {
+    await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    expect(createSession(sql, "test-org", "pj", "fxm", "user:krishna")).rejects.toThrow();
+  });
+
+  test("same session name in different projects is fine", async () => {
+    await createProject(sql, "test-org", "pj2");
+    await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    const s2 = await createSession(sql, "test-org", "pj2", "fxm", "user:krishna");
+    expect(s2.driver).toBe("user:krishna");
+  });
+
+  test("get nonexistent session returns null", async () => {
+    expect(await getSession(sql, "test-org", "pj", "nope")).toBeNull();
+  });
+
+  test("set driver", async () => {
+    await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    await setDriver(sql, "test-org", "pj", "fxm", "user:krishna");
+    const session = await getSession(sql, "test-org", "pj", "fxm");
+    expect(session!.driver).toBe("user:krishna");
+  });
+
+  test("clear driver", async () => {
+    await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    await clearDriver(sql, "test-org", "pj", "fxm");
+    const session = await getSession(sql, "test-org", "pj", "fxm");
+    expect(session!.driver).toBeNull();
+  });
+});
+
+describe("events", () => {
+  beforeEach(async () => {
+    await createProject(sql, "test-org", "pj");
+    await createSession(sql, "test-org", "pj", "fxm", "user:manu");
+    await createSession(sql, "test-org", "pj", "fxk", "user:krishna");
+  });
+
+  test("push and retrieve events by project", async () => {
+    const e1 = makeEvent({ session: "fxm", timestamp: "2026-06-05T10:00:00.000Z" });
+    const e2 = makeEvent({ session: "fxk", sender: "user:krishna", timestamp: "2026-06-05T10:01:00.000Z" });
+    await pushEvent(sql, "test-org", e1);
+    await pushEvent(sql, "test-org", e2);
+
+    const events = await getProjectEvents(sql, "test-org", "pj");
+    expect(events).toHaveLength(2);
+    expect(events[0].session).toBe("fxm");
+    expect(events[1].session).toBe("fxk");
+  });
+
+  test("retrieve events by session", async () => {
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxm" }));
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxk", sender: "user:krishna" }));
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxm" }));
+
+    const fxmEvents = await getSessionEvents(sql, "test-org", "pj", "fxm");
+    expect(fxmEvents).toHaveLength(2);
+
+    const fxkEvents = await getSessionEvents(sql, "test-org", "pj", "fxk");
+    expect(fxkEvents).toHaveLength(1);
+  });
+
+  test("events are ordered by timestamp", async () => {
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxm", timestamp: "2026-06-05T10:02:00.000Z" }));
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxm", timestamp: "2026-06-05T10:00:00.000Z" }));
+    await pushEvent(sql, "test-org", makeEvent({ session: "fxm", timestamp: "2026-06-05T10:01:00.000Z" }));
+
+    const events = await getSessionEvents(sql, "test-org", "pj", "fxm");
+    expect(events[0].timestamp).toBe("2026-06-05T10:00:00.000Z");
+    expect(events[1].timestamp).toBe("2026-06-05T10:01:00.000Z");
+    expect(events[2].timestamp).toBe("2026-06-05T10:02:00.000Z");
+  });
+
+  test("getEventsSince filters by timestamp", async () => {
+    await pushEvent(sql, "test-org", makeEvent({ timestamp: "2026-06-05T10:00:00.000Z" }));
+    await pushEvent(sql, "test-org", makeEvent({ timestamp: "2026-06-05T10:01:00.000Z" }));
+    await pushEvent(sql, "test-org", makeEvent({ timestamp: "2026-06-05T10:02:00.000Z" }));
+
+    const events = await getEventsSince(sql, "test-org", "pj", "2026-06-05T10:00:30.000Z");
+    expect(events).toHaveLength(2);
+    expect(events[0].timestamp).toBe("2026-06-05T10:01:00.000Z");
+  });
+
+  test("payload round-trips through JSONB", async () => {
+    const event = makeEvent({
+      source: "inject",
+      payload: {
+        type: "inject" as const,
+        content: "Use RS256",
+        sender: "user:krishna" as const,
+        target: "fxm",
+      },
+    });
+    await pushEvent(sql, "test-org", event);
+
+    const events = await getSessionEvents(sql, "test-org", "pj", "fxm");
+    expect(events[0].payload).toEqual(event.payload);
+  });
+
+  test("empty project returns empty array", async () => {
+    expect(await getProjectEvents(sql, "test-org", "pj")).toEqual([]);
+  });
+});