Initial implementation of Bluetooth toy control app

Next.js app with a browser-side buttplug/buttplug-wasm control layer (server never touches real-time device commands), SQLite storage via Drizzle, single-secret auth, recordings/replay with device remapping, a usage stats dashboard, Docker deployment, and Gitea CI. Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01W8WkFF5ppURBAB918593Eb
2026-08-25 07:51:38 +02:00
commit 1119c8eea0
112 changed files with 15522 additions and 0 deletions
@@ -0,0 +1,52 @@
+import { eq } from "drizzle-orm";
+import { db } from "@/lib/db/client";
+import { devices, type DeviceCapabilities } from "@/lib/db/schema";
+
+export async function listDevices() {
+  return db.select().from(devices).orderBy(devices.lastConnectedAt);
+}
+
+export async function getDevice(id: number) {
+  const [row] = await db.select().from(devices).where(eq(devices.id, id));
+  return row;
+}
+
+/** Upserts by advertised BLE name - the only stable-ish identity Web Bluetooth exposes. */
+export async function upsertDeviceByBleName(input: {
+  bleName: string;
+  deviceClass?: string | null;
+  capabilities?: DeviceCapabilities;
+}): Promise<typeof devices.$inferSelect> {
+  const now = Date.now();
+  const [existing] = await db.select().from(devices).where(eq(devices.bleName, input.bleName));
+
+  if (existing) {
+    const [updated] = await db
+      .update(devices)
+      .set({
+        lastConnectedAt: now,
+        deviceClass: input.deviceClass ?? existing.deviceClass,
+        capabilities: input.capabilities ?? existing.capabilities,
+      })
+      .where(eq(devices.id, existing.id))
+      .returning();
+    return updated;
+  }
+
+  const [created] = await db
+    .insert(devices)
+    .values({
+      bleName: input.bleName,
+      deviceClass: input.deviceClass,
+      capabilities: input.capabilities,
+      createdAt: now,
+      lastConnectedAt: now,
+    })
+    .returning();
+  return created;
+}
+
+export async function renameDevice(id: number, displayName: string) {
+  const [updated] = await db.update(devices).set({ displayName }).where(eq(devices.id, id)).returning();
+  return updated;
+}
@@ -0,0 +1,112 @@
+import { eq } from "drizzle-orm";
+import { db } from "@/lib/db/client";
+import { playSessions, sessionDevices, devices } from "@/lib/db/schema";
+import { upsertDeviceByBleName } from "./devices";
+import { incrementPlayCount } from "./recordings";
+import type { DeviceCapabilities } from "@/lib/db/schema";
+
+export interface StartSessionDeviceInput {
+  slotLabel: string;
+  bleName: string;
+  deviceClass?: string | null;
+  capabilities?: DeviceCapabilities;
+}
+
+export interface StartSessionInput {
+  kind: "live" | "replay";
+  replayedRecordingId?: number;
+  name?: string;
+  devices: StartSessionDeviceInput[];
+}
+
+export async function startPlaySession(input: StartSessionInput) {
+  const now = Date.now();
+
+  const [session] = await db
+    .insert(playSessions)
+    .values({
+      kind: input.kind,
+      replayedRecordingId: input.replayedRecordingId,
+      name: input.name,
+      status: "active",
+      startedAt: now,
+    })
+    .returning();
+
+  const sessionDeviceRows = [];
+  for (const d of input.devices) {
+    const device = await upsertDeviceByBleName({
+      bleName: d.bleName,
+      deviceClass: d.deviceClass,
+      capabilities: d.capabilities,
+    });
+    const [sessionDevice] = await db
+      .insert(sessionDevices)
+      .values({
+        playSessionId: session.id,
+        deviceId: device.id,
+        slotLabel: d.slotLabel,
+        connectedAt: now,
+      })
+      .returning();
+    sessionDeviceRows.push(sessionDevice);
+  }
+
+  if (input.kind === "replay" && input.replayedRecordingId) {
+    await incrementPlayCount(input.replayedRecordingId, now);
+  }
+
+  return { session, sessionDevices: sessionDeviceRows };
+}
+
+export async function endPlaySession(
+  id: number,
+  input: { status: "completed" | "aborted" },
+) {
+  const [existing] = await db.select().from(playSessions).where(eq(playSessions.id, id));
+  if (!existing) return undefined;
+
+  const endedAt = Date.now();
+  const durationMs = endedAt - existing.startedAt;
+
+  await db
+    .update(sessionDevices)
+    .set({ disconnectedAt: endedAt })
+    .where(eq(sessionDevices.playSessionId, id));
+
+  const [updated] = await db
+    .update(playSessions)
+    .set({ endedAt, durationMs, status: input.status })
+    .where(eq(playSessions.id, id))
+    .returning();
+  return updated;
+}
+
+export async function listPlaySessions() {
+  return db.select().from(playSessions).orderBy(playSessions.startedAt);
+}
+
+export async function getPlaySessionDetail(id: number) {
+  const [session] = await db.select().from(playSessions).where(eq(playSessions.id, id));
+  if (!session) return undefined;
+
+  const sessionDeviceRows = await db
+    .select({
+      id: sessionDevices.id,
+      slotLabel: sessionDevices.slotLabel,
+      connectedAt: sessionDevices.connectedAt,
+      disconnectedAt: sessionDevices.disconnectedAt,
+      deviceId: devices.id,
+      deviceDisplayName: devices.displayName,
+      deviceBleName: devices.bleName,
+    })
+    .from(sessionDevices)
+    .innerJoin(devices, eq(sessionDevices.deviceId, devices.id))
+    .where(eq(sessionDevices.playSessionId, id));
+
+  return { session, devices: sessionDeviceRows };
+}
+
+export async function deletePlaySession(id: number) {
+  await db.delete(playSessions).where(eq(playSessions.id, id));
+}
@@ -0,0 +1,86 @@
+import { desc, eq } from "drizzle-orm";
+import { db } from "@/lib/db/client";
+import { recordings, sessionDevices, devices, playSessions, type RecordingDeviceSlot } from "@/lib/db/schema";
+import { getEventsForSession } from "./session-events";
+
+/**
+ * A recording is a thin pointer over an already-captured play_session, not a
+ * duplicated event pipeline: every live command is always persisted to
+ * session_events (stats need it regardless of whether the user saves a
+ * recording), so "saving a recording" just snapshots the session's device
+ * slots and points a new row at it. This keeps the replay-loader query and
+ * the stats-timeline query reading the exact same rows, with zero risk of
+ * live/recorded data drifting apart.
+ */
+export async function createRecording(input: {
+  sourcePlaySessionId: number;
+  name: string;
+  description?: string;
+}) {
+  const [session] = await db.select().from(playSessions).where(eq(playSessions.id, input.sourcePlaySessionId));
+  if (!session) throw new Error("source play session not found");
+
+  const sessionDeviceRows = await db
+    .select({
+      sessionDeviceId: sessionDevices.id,
+      slotLabel: sessionDevices.slotLabel,
+      bleName: devices.bleName,
+      deviceClass: devices.deviceClass,
+      capabilities: devices.capabilities,
+    })
+    .from(sessionDevices)
+    .innerJoin(devices, eq(sessionDevices.deviceId, devices.id))
+    .where(eq(sessionDevices.playSessionId, input.sourcePlaySessionId));
+
+  const deviceSlots: RecordingDeviceSlot[] = sessionDeviceRows.map((row) => ({
+    slotLabel: row.slotLabel,
+    recordedBleName: row.bleName,
+    deviceClass: row.deviceClass,
+    capabilities: row.capabilities,
+    sourceSessionDeviceId: row.sessionDeviceId,
+  }));
+
+  const [recording] = await db
+    .insert(recordings)
+    .values({
+      sourcePlaySessionId: input.sourcePlaySessionId,
+      name: input.name,
+      description: input.description,
+      createdAt: Date.now(),
+      durationMs: session.durationMs ?? 0,
+      deviceSlots,
+      playCount: 0,
+    })
+    .returning();
+
+  return recording;
+}
+
+export async function listRecordings() {
+  return db.select().from(recordings).orderBy(desc(recordings.createdAt));
+}
+
+export async function getRecording(id: number) {
+  const [recording] = await db.select().from(recordings).where(eq(recordings.id, id));
+  if (!recording) return undefined;
+  const events = await getEventsForSession(recording.sourcePlaySessionId);
+  return { recording, events };
+}
+
+export async function renameRecording(id: number, input: { name?: string; description?: string }) {
+  const [updated] = await db.update(recordings).set(input).where(eq(recordings.id, id)).returning();
+  return updated;
+}
+
+export async function deleteRecording(id: number) {
+  await db.delete(recordings).where(eq(recordings.id, id));
+}
+
+export async function incrementPlayCount(id: number, playedAt: number): Promise<void> {
+  const [existing] = await db.select().from(recordings).where(eq(recordings.id, id));
+  if (!existing) return;
+  await db
+    .update(recordings)
+    .set({ playCount: existing.playCount + 1, lastPlayedAt: playedAt })
+    .where(eq(recordings.id, id));
+}
@@ -0,0 +1,42 @@
+import { asc, eq } from "drizzle-orm";
+import { db, sqlite } from "@/lib/db/client";
+import { sessionEvents } from "@/lib/db/schema";
+
+export interface IncomingEvent {
+  sessionDeviceId: number;
+  tsMs: number;
+  commandType: "vibrate" | "rotate" | "linear" | "stop";
+  featureIndex: number;
+  value: number;
+  durationMs?: number;
+}
+
+export async function insertEvents(playSessionId: number, events: IncomingEvent[]): Promise<void> {
+  if (events.length === 0) return;
+
+  const insertMany = sqlite.transaction((rows: IncomingEvent[]) => {
+    for (const row of rows) {
+      db.insert(sessionEvents)
+        .values({
+          playSessionId,
+          sessionDeviceId: row.sessionDeviceId,
+          tsMs: row.tsMs,
+          commandType: row.commandType,
+          featureIndex: row.featureIndex,
+          value: row.value,
+          durationMs: row.durationMs,
+        })
+        .run();
+    }
+  });
+
+  insertMany(events);
+}
+
+export async function getEventsForSession(playSessionId: number) {
+  return db
+    .select()
+    .from(sessionEvents)
+    .where(eq(sessionEvents.playSessionId, playSessionId))
+    .orderBy(asc(sessionEvents.tsMs));
+}
@@ -0,0 +1,103 @@
+import { sql, eq, and, ne } from "drizzle-orm";
+import { db } from "@/lib/db/client";
+import { playSessions, sessionDevices, sessionEvents, devices, recordings } from "@/lib/db/schema";
+
+export async function getSessionsSummary() {
+  const [totals] = await db
+    .select({
+      count: sql<number>`count(*)`,
+      totalDurationMs: sql<number>`coalesce(sum(${playSessions.durationMs}), 0)`,
+      avgDurationMs: sql<number>`coalesce(avg(${playSessions.durationMs}), 0)`,
+    })
+    .from(playSessions)
+    .where(eq(playSessions.status, "completed"));
+
+  const byKind = await db
+    .select({
+      kind: playSessions.kind,
+      count: sql<number>`count(*)`,
+      totalDurationMs: sql<number>`coalesce(sum(${playSessions.durationMs}), 0)`,
+    })
+    .from(playSessions)
+    .where(eq(playSessions.status, "completed"))
+    .groupBy(playSessions.kind);
+
+  const durationPerDevice = await db
+    .select({
+      deviceId: devices.id,
+      displayName: devices.displayName,
+      bleName: devices.bleName,
+      totalActiveMs: sql<number>`coalesce(sum(coalesce(${sessionDevices.disconnectedAt}, ${sessionDevices.connectedAt}) - ${sessionDevices.connectedAt}), 0)`,
+    })
+    .from(sessionDevices)
+    .innerJoin(devices, eq(sessionDevices.deviceId, devices.id))
+    .groupBy(devices.id);
+
+  return { ...totals, byKind, durationPerDevice };
+}
+
+export async function getSessionTimeline(playSessionId: number, bucketMs = 1000) {
+  return db
+    .select({
+      bucket: sql<number>`(${sessionEvents.tsMs} / ${bucketMs}) * ${bucketMs}`,
+      sessionDeviceId: sessionEvents.sessionDeviceId,
+      slotLabel: sessionDevices.slotLabel,
+      avgValue: sql<number>`avg(${sessionEvents.value})`,
+      maxValue: sql<number>`max(${sessionEvents.value})`,
+    })
+    .from(sessionEvents)
+    .innerJoin(sessionDevices, eq(sessionEvents.sessionDeviceId, sessionDevices.id))
+    .where(and(eq(sessionEvents.playSessionId, playSessionId), ne(sessionEvents.commandType, "stop")))
+    .groupBy(sql`bucket`, sessionEvents.sessionDeviceId)
+    .orderBy(sql`bucket`);
+}
+
+export async function getDeviceUsageStats() {
+  return db
+    .select({
+      deviceId: devices.id,
+      displayName: devices.displayName,
+      bleName: devices.bleName,
+      sessionCount: sql<number>`count(distinct ${sessionDevices.playSessionId})`,
+      totalActiveMs: sql<number>`coalesce(sum(coalesce(${sessionDevices.disconnectedAt}, ${sessionDevices.connectedAt}) - ${sessionDevices.connectedAt}), 0)`,
+      lastUsedAt: sql<number | null>`max(${sessionDevices.connectedAt})`,
+    })
+    .from(devices)
+    .leftJoin(sessionDevices, eq(sessionDevices.deviceId, devices.id))
+    .groupBy(devices.id);
+}
+
+export async function getDeviceCommandCounts() {
+  return db
+    .select({
+      deviceId: devices.id,
+      commandCount: sql<number>`count(${sessionEvents.id})`,
+    })
+    .from(devices)
+    .leftJoin(sessionDevices, eq(sessionDevices.deviceId, devices.id))
+    .leftJoin(sessionEvents, eq(sessionEvents.sessionDeviceId, sessionDevices.id))
+    .groupBy(devices.id);
+}
+
+export async function getRecordingLibraryStats() {
+  const [totals] = await db
+    .select({
+      count: sql<number>`count(*)`,
+      avgDurationMs: sql<number>`coalesce(avg(${recordings.durationMs}), 0)`,
+      totalPlayCount: sql<number>`coalesce(sum(${recordings.playCount}), 0)`,
+    })
+    .from(recordings);
+
+  const list = await db
+    .select({
+      id: recordings.id,
+      name: recordings.name,
+      durationMs: recordings.durationMs,
+      playCount: recordings.playCount,
+      lastPlayedAt: recordings.lastPlayedAt,
+    })
+    .from(recordings)
+    .orderBy(sql`${recordings.playCount} desc`);
+
+  return { ...totals, list };
+}