feat: add multiplayer/shared sessions for terminal and guacd

2026-08-29 18:31:33 +00:00 · 2026-07-20 22:18:54 -05:00
parent 36ab7e4872
commit f44d09eef7
50 changed files with 5089 additions and 102 deletions
@@ -0,0 +1,247 @@
+import { and, eq, gt, isNull, lt } from "drizzle-orm";
+import {
+  hosts,
+  sessionShareParticipants,
+  sessionShares,
+  users,
+} from "../db/schema.js";
+import type { DatabaseContext } from "./database-context.js";
+
+export type SessionShareRecord = typeof sessionShares.$inferSelect;
+export type SessionShareParticipantRecord =
+  typeof sessionShareParticipants.$inferSelect;
+
+export type SessionShareType = "link" | "user";
+export type SessionSharePermissionLevel = "read-only" | "read-write";
+
+export interface SessionShareCreateInput {
+  id: string;
+  hostId: number;
+  ownerUserId: string;
+  protocol: string;
+  sessionId: string;
+  tabInstanceId?: string | null;
+  shareType: SessionShareType;
+  targetUserId?: string | null;
+  linkToken?: string | null;
+  permissionLevel: SessionSharePermissionLevel;
+  expiresAt: string;
+}
+
+export interface SessionShareWithHost extends SessionShareRecord {
+  hostName: string | null;
+  ownerUsername: string | null;
+}
+
+export interface SharedWithMeRecord extends SessionShareRecord {
+  hostName: string | null;
+  ownerUsername: string | null;
+}
+
+function activeShareFilter(now: string) {
+  return and(isNull(sessionShares.revokedAt), gt(sessionShares.expiresAt, now));
+}
+
+export class SessionShareRepository {
+  constructor(
+    private readonly context: DatabaseContext,
+    private readonly onWrite?: () => void | Promise<void>,
+  ) {}
+
+  async create(input: SessionShareCreateInput): Promise<SessionShareRecord> {
+    const [created] = await this.context.drizzle
+      .insert(sessionShares)
+      .values({
+        id: input.id,
+        hostId: input.hostId,
+        ownerUserId: input.ownerUserId,
+        protocol: input.protocol,
+        sessionId: input.sessionId,
+        tabInstanceId: input.tabInstanceId ?? null,
+        shareType: input.shareType,
+        targetUserId: input.targetUserId ?? null,
+        linkToken: input.linkToken ?? null,
+        permissionLevel: input.permissionLevel,
+        expiresAt: input.expiresAt,
+      })
+      .returning();
+
+    await this.afterWrite();
+    return created;
+  }
+
+  async findById(id: string): Promise<SessionShareRecord | null> {
+    const rows = await this.context.drizzle
+      .select()
+      .from(sessionShares)
+      .where(eq(sessionShares.id, id))
+      .limit(1);
+    return rows[0] ?? null;
+  }
+
+  async findActiveById(
+    id: string,
+    now = new Date().toISOString(),
+  ): Promise<SessionShareRecord | null> {
+    const rows = await this.context.drizzle
+      .select()
+      .from(sessionShares)
+      .where(and(eq(sessionShares.id, id), activeShareFilter(now)))
+      .limit(1);
+    return rows[0] ?? null;
+  }
+
+  async findByLinkToken(
+    linkToken: string,
+    now = new Date().toISOString(),
+  ): Promise<SessionShareRecord | null> {
+    const rows = await this.context.drizzle
+      .select()
+      .from(sessionShares)
+      .where(
+        and(eq(sessionShares.linkToken, linkToken), activeShareFilter(now)),
+      )
+      .limit(1);
+    return rows[0] ?? null;
+  }
+
+  async findActiveSharesForHost(
+    hostId: number,
+    ownerUserId: string,
+    now = new Date().toISOString(),
+  ): Promise<SessionShareRecord[]> {
+    return this.context.drizzle
+      .select()
+      .from(sessionShares)
+      .where(
+        and(
+          eq(sessionShares.hostId, hostId),
+          eq(sessionShares.ownerUserId, ownerUserId),
+          activeShareFilter(now),
+        ),
+      );
+  }
+
+  async findSharesTargetingUser(
+    userId: string,
+    now = new Date().toISOString(),
+  ): Promise<SharedWithMeRecord[]> {
+    const rows = await this.context.drizzle
+      .select({
+        share: sessionShares,
+        hostName: hosts.name,
+        ownerUsername: users.username,
+      })
+      .from(sessionShares)
+      .leftJoin(hosts, eq(sessionShares.hostId, hosts.id))
+      .leftJoin(users, eq(sessionShares.ownerUserId, users.id))
+      .where(
+        and(
+          eq(sessionShares.shareType, "user"),
+          eq(sessionShares.targetUserId, userId),
+          activeShareFilter(now),
+        ),
+      );
+
+    return rows.map((row) => ({
+      ...row.share,
+      hostName: row.hostName,
+      ownerUsername: row.ownerUsername,
+    }));
+  }
+
+  async revoke(shareId: string, requestingUserId: string): Promise<boolean> {
+    const rows = await this.context.drizzle
+      .update(sessionShares)
+      .set({ revokedAt: new Date().toISOString() })
+      .where(
+        and(
+          eq(sessionShares.id, shareId),
+          eq(sessionShares.ownerUserId, requestingUserId),
+        ),
+      )
+      .returning({ id: sessionShares.id });
+
+    if (rows.length > 0) {
+      await this.afterWrite();
+    }
+    return rows.length > 0;
+  }
+
+  async revokeAsAdmin(shareId: string): Promise<boolean> {
+    const rows = await this.context.drizzle
+      .update(sessionShares)
+      .set({ revokedAt: new Date().toISOString() })
+      .where(eq(sessionShares.id, shareId))
+      .returning({ id: sessionShares.id });
+
+    if (rows.length > 0) {
+      await this.afterWrite();
+    }
+    return rows.length > 0;
+  }
+
+  async deleteExpiredShares(now = new Date().toISOString()): Promise<number> {
+    const rows = await this.context.drizzle
+      .delete(sessionShares)
+      .where(lt(sessionShares.expiresAt, now))
+      .returning({ id: sessionShares.id });
+
+    if (rows.length > 0) {
+      await this.afterWrite();
+    }
+    return rows.length;
+  }
+
+  async touchShareUsage(
+    shareId: string,
+    lastJoinedAt = new Date().toISOString(),
+  ): Promise<void> {
+    const current = await this.findById(shareId);
+    await this.context.drizzle
+      .update(sessionShares)
+      .set({
+        lastJoinedAt,
+        joinCount: (current?.joinCount ?? 0) + 1,
+      })
+      .where(eq(sessionShares.id, shareId));
+    await this.afterWrite();
+  }
+
+  async recordParticipantJoin(
+    shareId: string,
+    userId: string | null,
+    guestLabel: string | null,
+  ): Promise<SessionShareParticipantRecord> {
+    const [created] = await this.context.drizzle
+      .insert(sessionShareParticipants)
+      .values({ shareId, userId, guestLabel })
+      .returning();
+    await this.afterWrite();
+    return created;
+  }
+
+  async recordParticipantLeave(participantId: number): Promise<void> {
+    await this.context.drizzle
+      .update(sessionShareParticipants)
+      .set({ leftAt: new Date().toISOString() })
+      .where(eq(sessionShareParticipants.id, participantId));
+    await this.afterWrite();
+  }
+
+  async deleteSharesForHost(hostId: number): Promise<number> {
+    const rows = await this.context.drizzle
+      .delete(sessionShares)
+      .where(eq(sessionShares.hostId, hostId))
+      .returning({ id: sessionShares.id });
+
+    if (rows.length > 0) {
+      await this.afterWrite();
+    }
+    return rows.length;
+  }
+
+  private async afterWrite(): Promise<void> {
+    await this.onWrite?.();
+  }
+}