@anweather/game-plugin-ssdk 1.16.0 → 1.17.0

package/dist-cjs/runtime/live/protocol.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_KICK_REASON = exports.LinkCloseCode = exports.MAX_LINK_FRAME_BYTES = exports.LIVE_HEADERS = exports.LIVE_PATH = exports.LIVE_PROTOCOL_VERSION = void 0;
+exports.decodePlatformFrame = decodePlatformFrame;
+exports.decodePluginFrame = decodePluginFrame;
+exports.isKickCode = isKickCode;
+exports.encodeFrame = encodeFrame;
+exports.byteLength = byteLength;
+exports.parseScope = parseScope;
+exports.checkHandshake = checkHandshake;
+const auth_1 = require("../auth");
+exports.LIVE_PROTOCOL_VERSION = 1;
+exports.LIVE_PATH = "/v1/live";
+exports.LIVE_HEADERS = {
+    auth: "x-plugin-auth",
+    scope: "x-live-scope",
+    epoch: "x-live-epoch",
+    gameType: "x-game-type",
+    protocol: "x-live-protocol",
+};
+exports.MAX_LINK_FRAME_BYTES = 64 * 1024;
+exports.LinkCloseCode = {
+    NORMAL: 1000,
+    GOING_AWAY: 1001,
+    POLICY: 1008,
+    TOO_BIG: 1009,
+    INTERNAL_ERROR: 1011,
+    RESTART: 1012,
+    TOO_SLOW: 4008,
+    SUPERSEDED: 4409,
+    GONE: 4410,
+};
+function parseObject(text) {
+    let value;
+    try {
+        value = JSON.parse(text);
+    }
+    catch {
+        return "not JSON";
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return "not a JSON object";
+    return value;
+}
+const isStr = (v) => typeof v === "string";
+const isNonEmpty = (v) => typeof v === "string" && v.length > 0;
+class Malformed extends Error {
+}
+function need(o, field, check, what) {
+    const v = o[field];
+    if (!check(v))
+        throw new Malformed(`${o.t}: ${field} must be ${what}`);
+    return v;
+}
+const isRole = (v) => v === "PARTICIPANT" || v === "SPECTATOR";
+const isState = (v) => v === "ACTIVE" || v === "AWAY";
+const isRevision = (v) => typeof v === "number" && Number.isInteger(v) && v >= 0;
+const isMember = (v) => {
+    if (typeof v !== "object" || v === null)
+        return false;
+    const m = v;
+    return isNonEmpty(m.playerId) && isStr(m.displayName) && isStr(m.role) && isStr(m.status);
+};
+const isMembers = (v) => Array.isArray(v) && v.every(isMember);
+const isBool = (v) => typeof v === "boolean";
+const isAnything = (v) => v !== undefined;
+function decodePlatformFrame(text) {
+    const o = parseObject(text);
+    if (typeof o === "string")
+        return { ok: false, unknown: false, error: o };
+    if (!isStr(o.t))
+        return { ok: false, unknown: false, error: "t must be a string" };
+    try {
+        switch (o.t) {
+            case "join":
+                return {
+                    ok: true,
+                    frame: {
+                        t: "join",
+                        conn: need(o, "conn", isNonEmpty, "a non-empty string"),
+                        participantId: need(o, "participantId", isNonEmpty, "a non-empty string"),
+                        playerId: need(o, "playerId", isNonEmpty, "a non-empty string"),
+                        displayName: need(o, "displayName", isStr, "a string"),
+                        role: need(o, "role", isRole, "PARTICIPANT or SPECTATOR"),
+                        gameId: need(o, "gameId", isNonEmpty, "a non-empty string"),
+                        hidden: o.hidden === undefined ? false : need(o, "hidden", isBool, "a boolean"),
+                        state: o.state === undefined ? "ACTIVE" : need(o, "state", isState, "ACTIVE or AWAY"),
+                    },
+                };
+            case "leave":
+                return {
+                    ok: true,
+                    frame: {
+                        t: "leave",
+                        conn: need(o, "conn", isNonEmpty, "a non-empty string"),
+                        reason: o.reason === undefined ? "closed" : need(o, "reason", isStr, "a string"),
+                    },
+                };
+            case "sig":
+                return {
+                    ok: true,
+                    frame: {
+                        t: "sig",
+                        conn: need(o, "conn", isNonEmpty, "a non-empty string"),
+                        participantId: need(o, "participantId", isNonEmpty, "a non-empty string"),
+                        d: need(o, "d", isAnything, "present"),
+                    },
+                };
+            case "presence":
+                return {
+                    ok: true,
+                    frame: {
+                        t: "presence",
+                        conn: need(o, "conn", isNonEmpty, "a non-empty string"),
+                        state: need(o, "state", isState, "ACTIVE or AWAY"),
+                    },
+                };
+            case "game":
+                return {
+                    ok: true,
+                    frame: {
+                        t: "game",
+                        gameId: need(o, "gameId", isNonEmpty, "a non-empty string"),
+                        revision: need(o, "revision", isRevision, "a non-negative integer"),
+                    },
+                };
+            case "members":
+                return { ok: true, frame: { t: "members", members: need(o, "members", isMembers, "an array of members") } };
+            default:
+                return { ok: false, unknown: true, t: o.t };
+        }
+    }
+    catch (e) {
+        if (e instanceof Malformed)
+            return { ok: false, unknown: false, error: e.message };
+        throw e;
+    }
+}
+function decodePluginFrame(text) {
+    const o = parseObject(text);
+    if (typeof o === "string")
+        return { ok: false, unknown: false, error: o };
+    if (!isStr(o.t))
+        return { ok: false, unknown: false, error: "t must be a string" };
+    try {
+        switch (o.t) {
+            case "send": {
+                const to = o.to;
+                if (!(to === "all" || (Array.isArray(to) && to.every(isNonEmpty)))) {
+                    throw new Malformed(`send: to must be "all" or an array of conn ids`);
+                }
+                const frame = { t: "send", to: to, d: need(o, "d", isAnything, "present") };
+                if (o.k !== undefined)
+                    frame.k = need(o, "k", isNonEmpty, "a non-empty string");
+                return { ok: true, frame };
+            }
+            case "kick": {
+                const frame = {
+                    t: "kick",
+                    conn: need(o, "conn", isNonEmpty, "a non-empty string"),
+                    code: need(o, "code", isKickCode, "4403 or an integer from 4900 to 4999"),
+                };
+                if (o.reason !== undefined)
+                    frame.reason = need(o, "reason", isCloseReason, "a string of at most 120 characters");
+                return { ok: true, frame };
+            }
+            case "ready":
+                return { ok: true, frame: { t: "ready" } };
+            default:
+                return { ok: false, unknown: true, t: o.t };
+        }
+    }
+    catch (e) {
+        if (e instanceof Malformed)
+            return { ok: false, unknown: false, error: e.message };
+        throw e;
+    }
+}
+exports.MAX_KICK_REASON = 120;
+const isCloseReason = (v) => typeof v === "string" && v.length <= exports.MAX_KICK_REASON;
+function isKickCode(v) {
+    return typeof v === "number" && Number.isInteger(v) && (v === 4403 || (v >= 4900 && v <= 4999));
+}
+function encodeFrame(frame) {
+    return JSON.stringify(frame);
+}
+function byteLength(text) {
+    return Buffer.byteLength(text, "utf8");
+}
+function parseScope(header) {
+    if (!header)
+        return null;
+    const colon = header.indexOf(":");
+    if (colon <= 0)
+        return null;
+    const kind = header.slice(0, colon);
+    const id = header.slice(colon + 1);
+    if (!id || /\s/.test(id))
+        return null;
+    if (kind !== "game" && kind !== "space")
+        return null;
+    return { kind, id, key: `${kind}:${id}` };
+}
+const header = (h, name) => {
+    const v = h[name];
+    return Array.isArray(v) ? v[0] : v;
+};
+function checkHandshake(headers, expect) {
+    if (expect.authToken && !(0, auth_1.bearerMatches)(header(headers, exports.LIVE_HEADERS.auth), expect.authToken)) {
+        return { ok: false, status: 401, message: "missing or invalid X-Plugin-Auth" };
+    }
+    const protocol = header(headers, exports.LIVE_HEADERS.protocol);
+    if (protocol !== String(exports.LIVE_PROTOCOL_VERSION)) {
+        return { ok: false, status: 400, message: `unsupported X-Live-Protocol ${protocol ?? "(absent)"}; this plugin speaks ${exports.LIVE_PROTOCOL_VERSION}` };
+    }
+    const gameType = header(headers, exports.LIVE_HEADERS.gameType);
+    if (gameType !== expect.gameType) {
+        return { ok: false, status: 404, message: `this plugin hosts ${expect.gameType}, not ${gameType ?? "(absent)"}` };
+    }
+    const scope = parseScope(header(headers, exports.LIVE_HEADERS.scope));
+    if (!scope)
+        return { ok: false, status: 400, message: "X-Live-Scope must be game:{id} or space:{id}" };
+    const epoch = header(headers, exports.LIVE_HEADERS.epoch);
+    if (!epoch)
+        return { ok: false, status: 400, message: "X-Live-Epoch is required" };
+    return { ok: true, scope, epoch, protocol: exports.LIVE_PROTOCOL_VERSION };
+}