@roster-lock/match-agent 0.1.0

package/src/handle-room/version-0/piece-selection/steps/encrypton.ts

@@ -0,0 +1,70 @@
+
+import { JSON_Unknown } from "@match-lock/shared";
+import {
+  Object as CastObject,
+  String as CastString,
+} from "runtypes";
+
+import { webcrypto as crypto } from "crypto";
+// Generate a random AES-GCM key (256-bit)
+
+export async function encryptJSON(
+  originalValue: JSON_Unknown
+): Promise<{ key: string, encrypted: { iv: string, ciphertext: string } }> {
+  const key = await crypto.subtle.generateKey(
+    {
+      name: "AES-GCM",
+      length: 256,
+    },
+    true, // extractable
+    ["encrypt", "decrypt"]
+  );
+  const text = JSON.stringify(originalValue);
+  const iv = crypto.getRandomValues(new Uint8Array(12)); // 12-byte IV is recommended for AES-GCM
+  const ciphertext = await crypto.subtle.encrypt(
+    {
+      name: "AES-GCM",
+      iv,
+    },
+    key,
+    new TextEncoder().encode(text)
+  );
+  return {
+    key: Buffer.from(await crypto.subtle.exportKey("raw", key)).toString("base64"),
+    encrypted: {
+      iv: Buffer.from(iv).toString("base64"),
+      ciphertext: Buffer.from(ciphertext).toString("base64"),
+    }
+  };
+}
+
+export const CastEncryptedMessage = (
+  CastObject({
+    iv: CastString,
+    ciphertext: CastString,
+  }).conform<{ iv: string, ciphertext: string }>()
+);
+
+export async function decryptJSON(
+  keyString: string, { iv: ivString, ciphertext: ciphertextString }: { iv: string, ciphertext: string }
+): Promise<JSON_Unknown> {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    Buffer.from(keyString, "base64").buffer,
+    "AES-GCM",
+    true,
+    ["encrypt", "decrypt"]
+  );
+  const iv = new Uint8Array(Buffer.from(ivString, "base64"));
+  const ciphertext = Buffer.from(ciphertextString, "base64").buffer;
+  const plaintextBuffer = await crypto.subtle.decrypt(
+    {
+      name: "AES-GCM",
+      iv,
+    },
+    key,
+    ciphertext
+  );
+  const text = new TextDecoder().decode(plaintextBuffer);
+  return JSON.parse(text);
+}

package/src/handle-room/version-0/piece-selection/steps/final-selection.ts

@@ -0,0 +1,72 @@
+import { CollectionId, MatchLockRestrictionConfig, PieceId, UserId } from "@match-lock/shared";
+import { PlayerSelectionWithSeed } from "./player-selection";
+import { runScriptInFork } from "../script-vm";
+
+export type FinalSelection = Record<CollectionId, Array<PieceId> | Record<UserId, Array<PieceId>>>;
+
+import {
+  Union as CastUnion,
+  Array as CastArray,
+  Record as CastRecord,
+  String as CastString,
+} from "runtypes";
+
+const CastGlobalResult = CastArray(CastString);
+const CastPlayerResult = CastRecord(CastString, CastArray(CastString));
+
+export const CastFinalSelection = (
+  CastRecord(CastString, CastUnion(
+    CastGlobalResult,
+    CastPlayerResult,
+  )).conform<FinalSelection>()
+);
+
+export async function finalizeSelection(
+  restriction: MatchLockRestrictionConfig,
+  players: Record<UserId, PlayerSelectionWithSeed>
+): Promise<FinalSelection>{
+  const seeds: Record<UserId, string> = {};
+  for(const [userId, player] of Object.entries(players)){
+    seeds[userId] = player.rngSeed;
+  }
+  const finalSelection: Record<CollectionId, Array<PieceId> | Record<UserId, Array<PieceId>>> = {};
+  await Promise.all(Object.entries(restriction.pieces).map(async ([collectionId, collection])=>{
+    if(collection.selectionConfig.type === "mandatory") return;
+    if(collection.selectionConfig.type === "on-demand") return;
+    if(collection.selectionConfig.type === "agreed") return;
+    finalSelection[collectionId] = await handleCollectionSelections(collectionId, collection, players, seeds);
+  }));
+  return finalSelection;
+}
+
+
+async function handleCollectionSelections(
+  collectionId: string,
+  collection: MatchLockRestrictionConfig["pieces"][string],
+  players: Record<UserId, PlayerSelectionWithSeed>,
+  seeds: Record<UserId, string>
+){
+  const pieces: Record<UserId, Array<PieceId>> = {};
+  for(const [userId, player] of Object.entries(players)){
+    pieces[userId] = player.selection[collectionId];
+  }
+  if(!("algorithm" in collection.selectionConfig) || !collection.selectionConfig.algorithm){
+    return pieces
+  }
+  const algorithmResult = await runScriptInFork({
+    type: collection.selectionConfig.type,
+    scriptConfig: collection.selectionConfig.algorithm,
+    args: {
+      pieceIds: collection.pieces.map(p=>p.id),
+      playerChoices: pieces,
+      playerSeeds: seeds,
+    },
+  });
+  if(collection.selectionConfig.type === "global-choices"){
+    return CastGlobalResult.check(algorithmResult);
+  }
+  if(collection.selectionConfig.type === "player-choices"){
+    return CastPlayerResult.check(algorithmResult);
+  }
+  throw new Error("Invalid Collection Type");
+}

package/src/handle-room/version-0/piece-selection/steps/player-selection.ts

@@ -0,0 +1,100 @@
+
+import { CollectionId, JSON_Unknown, RosterLockV1Config, ROSTERLOCK_V1_CASTER_JSONSCHEMA, UserInput, PieceId } from "@match-lock/shared";
+import {
+  Object as CastObject,
+  Record as CastRecord,
+  String as CastString,
+  Array as CastArray,
+} from "runtypes";
+import { runScriptInFork } from "../script-vm";
+
+export type PlayerSelection = Record<CollectionId, Array<PieceId>>;
+export const CastPlayerSelection = (
+  CastRecord(CastString, CastArray(CastString)).conform<PlayerSelection>()
+);
+
+export type PlayerSelectionWithSeed = {
+  selection: PlayerSelection;
+  rngSeed: string;
+}
+
+export const CastPlayerSelectionWithSeed = (
+  CastObject({
+    selection: CastPlayerSelection,
+    rngSeed: CastString,
+  }).conform<PlayerSelectionWithSeed>()
+);
+
+export function createRandomSeed(){
+  const array = new Uint8Array(16); // 16 bytes = 128 bits = 32 hex characters
+  crypto.getRandomValues(array);
+  const randHex = Array.from(array)
+    .map(b => b.toString(16).padStart(2, "0"))
+    .join(""); // 32-character hex string
+  return randHex;
+}
+
+export async function validatePlayerSelection(
+  restriction: RosterLockV1Config,
+  data: JSON_Unknown
+): Promise<UserInput> {
+  const casted: PlayerSelectionWithSeed = CastPlayerSelectionWithSeed.check(data);
+  if(casted.rngSeed.length !== 32){
+    throw new Error("Invalid RNG Seed");
+  }
+  await Promise.all(Object.entries(restriction.pieces).map(async ([collectionId, collection])=>{
+    return runCollectionValidation(collectionId, collection, casted);
+  }));
+  return casted;
+}
+
+function runCollectionValidation(
+  collectionId: string,
+  collection: MatchLockRestrictionConfig["pieces"][string],
+  casted: PlayerSelectionWithSeed
+){
+  if(collection.selectionConfig.type === "mandatory") return;
+  if(collection.selectionConfig.type === "on-demand") return;
+  if(collection.selectionConfig.type === "agreed") return;
+  const pieces = casted.selection[collectionId];
+  const validation = collection.selectionConfig.validation;
+  if(!pieces){
+    throw new Error(`Missing Collection ${collectionId}`);
+  }
+  if(!validation) return;
+  if(validation.unique && new Set(pieces).size !== pieces.length){
+    throw new Error(`Duplicate Piece in Collection ${collectionId}`);
+  }
+  validateCount(collectionId, pieces, validation.count);
+
+  for(const pieceId of pieces){
+    if(!collection.pieces.find(p=>p.id === pieceId)){
+      throw new Error(`Piece ${pieceId} not found in collection ${collectionId}`);
+    }
+  }
+
+  return Promise.all(validation.customValidation.map(async (script)=>(
+    await runScriptInFork({
+      type: "validation",
+      scriptConfig: script,
+      args: { pieceIds: pieces },
+    })
+  )));
+}
+
+function validateCount(collectionId: string, pieces: Array<string>, countConfig: number | [number, number]){
+  if(!Array.isArray(countConfig)){
+    if(pieces.length !== countConfig){
+      throw new Error(`Invalid Piece Count in Selection ${collectionId}`);
+    }
+    return;
+  }
+  const [min, max] = countConfig;
+  if(pieces.length < min){
+    throw new Error(`Not Enough Pieces in Selection ${collectionId}`);
+  }
+  if(pieces.length > max){
+    throw new Error(`Too Many Pieces in Selection ${collectionId}`);
+  }
+}
+

package/src/handle-room/version-1/constants.ts

@@ -0,0 +1,44 @@
+import { JSON_Unknown } from "@roster-lock/utils";
+
+export enum ROOM_EVENT {
+  roomFull = "room-full",
+  userLeft = "user-left",
+}
+
+export enum MATCHLOCK_SELECTION_STATE {
+  failure = "failure",
+
+  hello = "selection-hello",
+  lockConfig = "selection-lock",
+  selectionEncrypt = "selection-encrypt",
+  selectionDecrypt = "selection-decrypt",
+  selectionFinal = "selection-final",
+  goodbye = "selection-goodbye",
+}
+
+export enum MATCHLOCK_DOWNLOAD_STATE {
+  failure = "failure",
+
+  hello = "download-hello",
+  downloadStart = "download-start",
+  downloadProgress = "download-progress",
+  downloadValidation = "download-validation",
+  downloadFinished = "download-finished",
+  downloadFailure = "download-failure",
+
+  downloadAllComplete = "download-all-complete",
+  downloadFullFailure = "download-full-fail",
+  goodbye = "download-goodbye",
+}
+
+export class ExternalUserError extends Error {
+  constructor(public userId: string, public rawError: JSON_Unknown){
+    super("External User Error");
+  }
+}
+
+export class UserMessegeError extends Error {
+  constructor(public userId: string, public message: string){
+    super(message);
+  }
+}

package/src/handle-room/version-1/file-routes.ts

@@ -0,0 +1,68 @@
+
+import { RosterLockV1Config, RosterLockPiece } from "@roster-lock/types";
+import { jsonBody, HTTPRequestHandler, HTTPError } from "../../utils/http-router";
+import { V1Env } from "./globals/types";
+import z, { ZodType } from "zod";
+
+import { engineCaster, pieceFileInfoCaster } from "./schema/lock";
+import { pipeline } from "node:stream/promises";
+import { mimeTypeFor } from "../../utils/fs";
+
+type GetPieceInfo = {
+  engine: RosterLockV1Config["engine"]
+  pieceType: string
+  piece: Pick<RosterLockPiece, "version" | "pathVariables">
+}
+
+const getAssetSchema: ZodType<(
+  & GetPieceInfo
+  & { assetName: string }
+)> = z.object({
+  engine: engineCaster,
+  pieceType: z.string(),
+  piece: pieceFileInfoCaster,
+  assetName: z.string(),
+})
+
+export const getFilesOfAsset: HTTPRequestHandler = async function (this: V1Env, { req, res }){
+  const { fileDB } = this;
+  const body = await jsonBody(req)
+  const parsedValue = getAssetSchema.safeParse(body);
+  if(!parsedValue.success){
+    throw new HTTPError(400, "Bad Form", parsedValue.error);
+  }
+  const { engine, pieceType, piece, assetName } = parsedValue.data;
+  const files = [];
+  for await (const filePath of fileDB.getFilesofAsset(
+    engine, pieceType, piece, assetName
+  )){
+    files.push(filePath)
+  }
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(files));
+}
+
+
+const getContentsSchema: ZodType<(
+  & GetPieceInfo
+  & { filePath: string }
+)> = z.object({
+  engine: engineCaster,
+  pieceType: z.string(),
+  piece: pieceFileInfoCaster,
+  filePath: z.string(),
+})
+export const getPieceFileContents: HTTPRequestHandler = async function (this: V1Env, { req, res }){
+  const { fileDB } = this;
+  const body = await jsonBody(req)
+  const parsedValue = getContentsSchema.safeParse(body);
+  if(!parsedValue.success){
+    throw new HTTPError(400, "Bad Form", parsedValue.error);
+  }
+  const { engine, pieceType, piece, filePath } = parsedValue.data;
+  const stream = await fileDB.getPieceFileContents(
+    engine, pieceType, piece, filePath
+  );
+  res.setHeader("Content-Type", mimeTypeFor(filePath));
+  await pipeline(stream, res);
+}

package/src/handle-room/version-1/globals/FolderDB/SQLFolderDB/MultiAbort.ts

@@ -0,0 +1,83 @@
+
+import { ProgressHandlers } from "../../../handleDownloads/types";
+
+export class MultiAbortSignal {
+  private abortController = new AbortController();
+  private handlers = new Map<ProgressHandlers, ()=>void>();
+  get abortSignal(){
+    return this.abortController.signal;
+  }
+
+  constructor(signals: ProgressHandlers[] = []){
+    for(const signal of signals){
+      this.addSignal(signal);
+    }
+  }
+
+  emitEvent(
+    event: Parameters<ProgressHandlers["onProgress"]>[0]
+  ){
+    for(const handler of this.handlers.keys()){
+      try {
+        handler.onProgress(event);
+      }catch(e){
+        console.error("Error Emitting Event", e);
+      }
+    }
+  }
+
+  addSignal(newHandler: ProgressHandlers){
+    if(this.abortController.signal.aborted) return;
+    if(newHandler.abortSignal.aborted) return;
+    if(this.handlers.has(newHandler)) return;
+    const listener = ()=>{
+      this.removeSignal(newHandler);
+      if(this.handlers.size === 0) this.abort();
+    };
+    this.handlers.set(newHandler, listener);
+    newHandler.abortSignal.addEventListener("abort", listener);
+  }
+  removeSignal(oldHandler: ProgressHandlers){
+    const listener = this.handlers.get(oldHandler);
+    if(!listener) return;
+    oldHandler.abortSignal.removeEventListener("abort", listener);
+    this.handlers.delete(oldHandler);
+  }
+  clear(){
+    for(const [handler, listener] of this.handlers.entries()) {
+      handler.abortSignal.removeEventListener("abort", listener);
+    }
+    this.handlers.clear();
+  }
+  abort(){
+    this.clear();
+    this.abortController.abort();
+  }
+}
+
+export async function raceWithAbort<T>(
+  promise: Promise<T>,
+  abortSignal: AbortSignal
+): Promise<T> {
+  if(abortSignal.aborted) throw new Error('Download aborted by caller');
+
+  const { promise: abortPromise, reject } = Promise.withResolvers<T>();
+
+  const listener = ()=>{
+    reject(new Error('Download aborted by caller'));
+  }
+
+  abortSignal.addEventListener("abort", listener, { once: true });
+ 
+  // promise is also awaited via Promise.race below; catch here too so this
+  // second attached continuation doesn't count as an unhandled rejection.
+  promise.finally(()=>{
+    abortSignal.removeEventListener("abort", listener);
+  }).catch(()=>{});
+
+  return Promise.race([
+    promise,
+    abortPromise
+  ]);
+}
+