dredless 0.2.0

package/src/index.js

@@ -0,0 +1,125 @@
+export {Session, AnonSession} from "./network/session.js";
+export {Connection} from "./network/connection.js";
+export {DredlessClient, WrenchMode, TurretMode} from "./client/index.js";
+export {WorldStore, WorldState} from "./state/world/index.js";
+export {FabricatorType, ModelState, decodeModelData} from "./state/model/index.js";
+export {generateGeneratorMaze, solveGeneratorMazeSeed, maybeSolveGeneratorMazeSeed} from "./state/generator-maze.js";
+export {buildBlueprintPlacementMessage} from "./protocol/outbound/blueprint.js";
+export {decodeMsgpack, encodeMsgpack} from "./protocol/codec/msgpack.js";
+export {
+    buildCommsMessage,
+    flattenRichText,
+    normalizeCommsEvent
+} from "./protocol/outbound/comms.js";
+export {buildSignedCommandPacket} from "./protocol/outbound/commands.js";
+export {
+    buildEquipItemCommand,
+    buildInventoryDragCommand,
+    buildUnequipItemCommand,
+    equipmentSlotName,
+    normalizeEquipmentSlot,
+    normalizeInventoryEvent,
+    EquipmentSlot
+} from "./protocol/outbound/inventory.js";
+export {
+    buildBanPlayerMessage,
+    buildDemoteSelfMessage,
+    buildInviteResetMessage,
+    buildKickPlayerMessage,
+    buildPlayerListMessage,
+    buildShipManagementMessage,
+    buildSetPlayerRankMessage,
+    buildShipPrivacyMessage,
+    buildStarterRecoveryMessage,
+    normalizeCaptainSubrank,
+    normalizeShipPlayerList,
+    normalizePlayerRank,
+    normalizePrivacy,
+    normalizeShipConfig
+} from "./protocol/outbound/ship-management.js";
+export {
+    SignDisplayMode,
+    buildSignTextMessage,
+    normalizeSignDisplayMode,
+    signDisplayModeName
+} from "./protocol/outbound/sign.js";
+export {
+    buildCargoEjectorClipboardDirectionData,
+    buildCargoEjectorCopyConfigData,
+    buildCargoEjectorDirectionData,
+    buildCargoEjectorPasteConfigData,
+    buildCargoHatchCopyConfigData,
+    buildCargoHatchFilterConfigData,
+    buildCargoHatchFilterItemsData,
+    buildCargoHatchFullConfigData,
+    buildClipboardConfigData,
+    buildClipboardFixedAngleData,
+    buildExpandoClipboardAngleData,
+    buildGeneratorClipboardDirectionData,
+    buildGeneratorMazePuzzleData,
+    buildLoaderClipboardConfigData,
+    buildLoaderConfigData,
+    buildLoaderCopyConfigData,
+    buildLoaderFilterConfigData,
+    buildLoaderFilterItemsData,
+    buildLoaderFullConfigData,
+    buildNavigationUnitClipboardConfigData,
+    buildNavigationUnitConfigData,
+    buildNavigationUnitPasteConfigData,
+    buildPusherConfigData,
+    buildPusherFilterItemsData,
+    PusherMode,
+    LoaderPosition,
+    LoaderFilterMode,
+    FixedAngleDirection,
+    LoaderPriority
+} from "./protocol/outbound/ui-config.js";
+export {decryptPayload} from "./crypto/chacha.js";
+export {decompressLz4Frame} from "./compression/lz4.js";
+
+import {AnonSession, createAnonSession, createAnonToken, createSession, Session} from "./network/session.js";
+import {Connection} from "./network/connection.js";
+import {DredlessClient} from "./client/index.js";
+import {fetchGameVersion, fetchNoticeVersion, fetchServers} from "./network/servers.js";
+import {fetchShipList, fetchShips} from "./network/ships.js";
+
+async function sessionOrAnon(session) {
+    return session || createAnonSession();
+}
+
+export async function joinShip(server, ship = null, session = null) {
+    return (await sessionOrAnon(session)).joinShip(server, ship);
+}
+
+export async function startShip(server, ship = null, session = null) {
+    return (await sessionOrAnon(session)).startShip(server, ship);
+}
+
+export async function startNewShip(server, name = "", color = "", session = null) {
+    return (await sessionOrAnon(session)).startNewShip(server, name, color);
+}
+
+export async function joinInvite(server, code, session = null) {
+    return (await sessionOrAnon(session)).joinInvite(server, code);
+}
+
+export const Dredless = {
+    Session,
+    AnonSession,
+    Connection,
+    DredlessClient,
+    createSession,
+    createAnonSession,
+    createAnonToken,
+    fetchNoticeVersion,
+    fetchGameVersion,
+    fetchServers,
+    fetchShips,
+    fetchShipList,
+    joinShip,
+    startShip,
+    startNewShip,
+    joinInvite
+};
+
+export default Dredless;

package/src/network/browser-session.js

@@ -0,0 +1,291 @@
+import {DEFAULT_BASE_URL, DEFAULT_NOTICE_VERSION} from "../constants.js";
+import {normalizeBaseUrl} from "../runtime.js";
+import {browserCookies, cookieName, readBrowserCookie} from "./cookies.js";
+import {fetchGameVersion, fetchNoticeVersion, resolveServer, serverId} from "./servers.js";
+import {
+    createInviteShipSpec,
+    createShipSpec,
+    fetchShipList,
+    fetchShips as fetchSessionShips,
+    shipRef
+} from "./ships.js";
+import {Connection} from "./connection.js";
+import {DredlessClient} from "../client/index.js";
+import {Session} from "./session.js";
+
+export class BrowserSession extends Session {
+    constructor(baseUrl = DEFAULT_BASE_URL) {
+        super(null, null, baseUrl);
+        this.baseUrl = normalizeBaseUrl(baseUrl);
+        this.ambientAuth = true;
+    }
+
+    get gameSession() {
+        return browserCookies().get(cookieName(this.baseUrl, "game_session")) || "";
+    }
+
+    get gameToken() {
+        return browserCookies().get(cookieName(this.baseUrl, "game_token")) || "";
+    }
+
+    get anonKey() {
+        return this._anonKey || browserCookies().get(cookieName(this.baseUrl, "anon_key")) || "";
+    }
+
+    async readAnonKey() {
+        const key = await readBrowserCookie(cookieName(this.baseUrl, "anon_key"));
+        if (key) this._anonKey = key;
+        return key || "";
+    }
+
+    async fetchAnonKey(noticeVersion = null) {
+        this.noticeVersion = await browserNoticeVersion(noticeVersion, this.baseUrl);
+        await createAnonLogin(this);
+        const key = await this.readAnonKey();
+        if (!key) throw new Error("Unable to read anon_key after anon login. Browser support is tested in page and content-script contexts; background, popup, worker, and other non-page contexts are unlikely to expose drednot.io cookies.");
+        return key;
+    }
+
+    get noticeVersion() {
+        return this._noticeVersion ?? browserCookies().get(cookieName(this.baseUrl, "notice_version")) ?? null;
+    }
+
+    set noticeVersion(value) {
+        this._noticeVersion = value == null ? null : Number(value);
+        if (typeof document === "undefined" || value == null) return;
+        document.cookie = `${cookieName(this.baseUrl, "notice_version")}=${encodeURIComponent(String(value))}; path=/; SameSite=Lax`;
+    }
+
+    mergeSetCookies() {
+        // Browsers own the cookie jar. Set-Cookie is intentionally not readable.
+    }
+
+    async joinShipConnection(server, ship = null) {
+        return this.#joinBrowserConnection(server, ship, true);
+    }
+
+    async startShipConnection(server, ship = null) {
+        return this.#joinBrowserConnection(server, ship, false);
+    }
+
+    async startNewShipConnection(server, name = "", color = "") {
+        return this.#joinBrowserConnection(server, createShipSpec(name, color), false);
+    }
+
+    async joinInviteConnection(server, code) {
+        return this.#joinBrowserConnection(server, createInviteShipSpec(code), false);
+    }
+
+    async joinShip(server, ship = null) {
+        return readyBrowserClient(await this.joinShipConnection(server, ship));
+    }
+
+    async startShip(server, ship = null) {
+        return readyBrowserClient(await this.startShipConnection(server, ship));
+    }
+
+    async startNewShip(server, name = "", color = "") {
+        return readyBrowserClient(await this.startNewShipConnection(server, name, color));
+    }
+
+    async joinInvite(server, code) {
+        return readyBrowserClient(await this.joinInviteConnection(server, code));
+    }
+
+    async #joinBrowserConnection(server, ship, neverLoad) {
+        if (server == null) throw new Error("A server id or server object is required");
+        const resolvedServer = await resolveServer(server, this.baseUrl);
+        if (!resolvedServer) throw new Error(`Unable to resolve server ${serverId(server)}`);
+        if (!this.gameVersion) this.gameVersion = await fetchGameVersion(this.baseUrl);
+        if (this.noticeVersion == null) this.noticeVersion = DEFAULT_NOTICE_VERSION;
+
+        const joinShip = ship == null ? createShipSpec("", "") : shipRef(ship);
+        const response = await this.request("join", {
+            method: "POST",
+            mode: "cors",
+            credentials: "include",
+            referrer: `${this.baseUrl}/`,
+            body: {
+                join_info: {
+                    game_version: this.gameVersion,
+                    hide_badges: false,
+                    never_load: Boolean(neverLoad),
+                    server_id: resolvedServer.index,
+                    ship: joinShip
+                }
+            },
+            headers: browserJoinHeaders(this.baseUrl)
+        });
+        if (!response.ok) throw new Error(`Join request failed: ${await response.text()}`);
+        const join = await response.json();
+        if (join.reject != null) {
+            const error = new Error(joinRejectMessage(join.reject, {
+                neverLoad,
+                ship: joinShip,
+                server: resolvedServer
+            }));
+            error.code = join.reject;
+            error.join = join;
+            throw error;
+        }
+        if (join.okay !== true) throw new Error("Bad join result");
+
+        const token = join.game_token ?? join.gameToken ?? this.gameToken;
+        return new Connection(this, token || "", join.net_port, Number.isInteger(join.server_id) ? join.server_id : resolvedServer.index, resolvedServer);
+    }
+
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            ambientAuth: true,
+            cookies: Object.fromEntries(browserCookies())
+        };
+    }
+}
+
+let defaultBrowserSession = null;
+
+export function browserSession(baseUrl = DEFAULT_BASE_URL) {
+    const normalized = normalizeBaseUrl(baseUrl);
+    if (!defaultBrowserSession || defaultBrowserSession.baseUrl !== normalized) defaultBrowserSession = new BrowserSession(normalized);
+    return defaultBrowserSession;
+}
+
+export function setBrowserSession(session = null) {
+    defaultBrowserSession = session;
+    return defaultBrowserSession;
+}
+
+export const createBrowserSession = browserSession;
+
+export async function createSession(noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 2 ? arguments[1] : baseUrl);
+    const session = browserSession(resolvedBaseUrl);
+    session.noticeVersion = await browserNoticeVersion(noticeVersion, resolvedBaseUrl);
+    await session.fetchAccountStatus();
+    return session;
+}
+
+export async function createAnonSession(anonKey = null, noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    if (typeof noticeVersion === "string" && noticeVersion.includes("://") && (baseUrl == null || baseUrl === DEFAULT_BASE_URL)) {
+        baseUrl = noticeVersion;
+        noticeVersion = null;
+    }
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 3 ? arguments[2] : baseUrl);
+    const session = browserSession(resolvedBaseUrl);
+    session.noticeVersion = await browserNoticeVersion(noticeVersion, resolvedBaseUrl);
+    if (anonKey) {
+        session._anonKey = String(anonKey);
+        await setAmbientCookie(resolvedBaseUrl, "anon_key", anonKey);
+    } else {
+        await session.fetchAnonKey(session.noticeVersion);
+    }
+    await session.fetchAccountStatus();
+    return session;
+}
+
+export async function fetchAnonKey(noticeVersion = null, baseUrl = DEFAULT_BASE_URL) {
+    const resolvedBaseUrl = normalizeBaseUrl(arguments.length >= 2 ? arguments[1] : baseUrl);
+    return browserSession(resolvedBaseUrl).fetchAnonKey(noticeVersion);
+}
+
+export const createAnonToken = fetchAnonKey;
+
+export async function fetchAccountStatus(session = null) {
+    return (session || browserSession()).fetchAccountStatus();
+}
+
+export async function fetchShips(server, session = null) {
+    return fetchSessionShips(session || browserSession(), server);
+}
+
+export async function fetchShipListForBrowser(server, session = null) {
+    return fetchShipList(session || browserSession(), server);
+}
+
+export async function joinShip(server, ship = null, session = null) {
+    return (session || browserSession()).joinShip(server, ship);
+}
+
+export async function startShip(server, ship = null, session = null) {
+    return (session || browserSession()).startShip(server, ship);
+}
+
+export async function startNewShip(server, name = "", color = "", session = null) {
+    return (session || browserSession()).startNewShip(server, name, color);
+}
+
+export async function joinInvite(server, code, session = null) {
+    return (session || browserSession()).joinInvite(server, code);
+}
+
+async function readyBrowserClient(connection) {
+    const client = new DredlessClient(connection);
+    await client.whenReady();
+    return client;
+}
+
+async function createAnonLogin(session) {
+    const response = await session.request("account/login/anon", {
+        method: "POST",
+        mode: "cors",
+        credentials: "include",
+        referrer: `${session.baseUrl}/`,
+        headers: browserAnonHeaders(session.baseUrl)
+    });
+    if (response.status === 503) throw new Error("Anon session creation is rate limited by the server");
+    if (!response.ok) throw new Error(`account/login/anon failed: ${response.status} ${response.statusText}`);
+    session.mergeSetCookies(response, ["anon_key", "game_session"]);
+}
+
+async function browserNoticeVersion(value, baseUrl = DEFAULT_BASE_URL) {
+    if (value != null) return value;
+    try {
+        return await fetchNoticeVersion(baseUrl);
+    } catch (_) {
+        return DEFAULT_NOTICE_VERSION;
+    }
+}
+
+async function setAmbientCookie(baseUrl, name, value) {
+    const key = cookieName(baseUrl, name);
+    if (typeof globalThis.cookieStore !== "undefined" && typeof globalThis.cookieStore.set === "function") {
+        try {
+            await globalThis.cookieStore.set(key, String(value));
+            return;
+        } catch (_) {
+            // Fall through to document.cookie.
+        }
+    }
+    if (typeof document === "undefined") return;
+    document.cookie = `${key}=${encodeURIComponent(String(value))}; path=/; SameSite=Lax`;
+}
+
+function browserAnonHeaders(baseUrl) {
+    const origin = normalizeBaseUrl(baseUrl);
+    return {
+        accept: "*/*",
+        origin,
+        referer: `${origin}/`
+    };
+}
+
+function browserJoinHeaders(baseUrl) {
+    const origin = normalizeBaseUrl(baseUrl);
+    return {
+        accept: "*/*",
+        "content-type": "application/json",
+        origin,
+        referer: `${origin}/`
+    };
+}
+
+function joinRejectMessage(code, {neverLoad, ship, server} = {}) {
+    if (code === 4007 && neverLoad) {
+        const name = ship?.name ? ` "${ship.name}"` : "";
+        const id = ship?.id != null ? ` (${ship.id})` : "";
+        const serverText = server?.description ? ` on ${server.description}` : "";
+        return `join rejected: 4007. ${name}${id}${serverText} could not be joined with never_load=true. Use startShip(server, ship) instead of joinShip(server, ship) when loading or starting a saved ship.`;
+    }
+    return `join rejected: ${code}`;
+}

package/src/network/connection.d.ts

@@ -0,0 +1 @@
+export {Connection} from "../index.js";

package/src/network/connection.js

@@ -0,0 +1,31 @@
+import {DEFAULT_BASE_URL} from "../constants.js";
+import {normalizeBaseUrl} from "../runtime.js";
+import {cookieName} from "./cookies.js";
+
+export class Connection {
+    constructor(session, gameToken, netPort, serverId, server = null) {
+        if (!session) throw new Error("Connection requires a session");
+        if (!gameToken && !session.ambientAuth) throw new Error("Connection requires a game token");
+        if (netPort == null) throw new Error("Connection requires a net port");
+
+        this.session = session;
+        this.baseUrl = normalizeBaseUrl(session.baseUrl || DEFAULT_BASE_URL);
+        this.gameToken = gameToken ? String(gameToken) : "";
+        this.netPort = Number(netPort);
+        this.server = serverId && typeof serverId === "object" ? serverId : server;
+        this.serverId = Number(serverId && typeof serverId === "object" ? serverId.index ?? serverId.id : serverId);
+
+        this.session.cookies?.set(cookieName(this.baseUrl, "game_token"), this.gameToken);
+    }
+
+    toJSON() {
+        return {
+            baseUrl: this.baseUrl,
+            gameToken: this.gameToken,
+            netPort: this.netPort,
+            serverId: this.serverId,
+            server: this.server,
+            session: this.session?.toJSON?.() || this.session
+        };
+    }
+}

package/src/network/cookies.js

@@ -0,0 +1,85 @@
+import {DEFAULT_BASE_URL} from "../constants.js";
+import {hostName, normalizeBaseUrl} from "../runtime.js";
+
+export function cookiePrefix(baseUrl = DEFAULT_BASE_URL) {
+    const host = hostName(baseUrl);
+    if (host === "test.drednot.io") return "test_";
+    if (host === "local.drednot.io") return "local_";
+    return "";
+}
+
+export const cookieName = (baseUrl, name) => `${cookiePrefix(baseUrl)}${name}`;
+
+export function parseCookies(text = "") {
+    const cookies = new Map();
+    for (const part of String(text).split(/;\s*/)) {
+        const index = part.indexOf("=");
+        if (index <= 0) continue;
+        cookies.set(part.slice(0, index).trim(), decodeURIComponent(part.slice(index + 1).trim()));
+    }
+    return cookies;
+}
+
+export function browserCookies() {
+    return canReadDocumentCookie() ? parseCookies(document.cookie || "") : new Map();
+}
+
+export function canReadDocumentCookie() {
+    try {
+        return typeof document !== "undefined" && typeof document.cookie === "string";
+    } catch (_) {
+        return false;
+    }
+}
+
+export function hasCookieStore() {
+    return typeof globalThis.cookieStore !== "undefined" && typeof globalThis.cookieStore.getAll === "function";
+}
+
+export async function readBrowserCookie(name) {
+    if (hasCookieStore()) {
+        try {
+            const cookie = typeof globalThis.cookieStore.get === "function" ? await globalThis.cookieStore.get(name) : null;
+            if (cookie?.value != null) return cookie.value;
+        } catch (_) {
+            // Fall through to document.cookie below.
+        }
+    }
+    return browserCookies().get(name) || "";
+}
+
+export function setCookieValues(baseUrl, source = {}) {
+    const base = normalizeBaseUrl(baseUrl);
+    const values = source instanceof Map ? source : source?.cookies instanceof Map ? source.cookies : Object.entries(source || {});
+    const cookies = new Map(values);
+    const prefix = cookiePrefix(base);
+    const anonKey = source.anonKey || source.anon_key;
+    const gameSession = source.gameSession || source.game_session;
+    const noticeVersion = source.noticeVersion || source.notice_version;
+    if (anonKey && !cookies.has(`${prefix}anon_key`)) cookies.set(`${prefix}anon_key`, anonKey);
+    if (gameSession && !cookies.has(`${prefix}game_session`)) cookies.set(`${prefix}game_session`, gameSession);
+    if (noticeVersion && !cookies.has(`${prefix}notice_version`)) cookies.set(`${prefix}notice_version`, noticeVersion);
+    return cookies;
+}
+
+export function cookieHeader(baseUrl, source = {}) {
+    return [...setCookieValues(baseUrl, source)].map(([key, value]) => `${key}=${encodeURIComponent(value)}`).join("; ");
+}
+
+export function readSetCookies(headers, names = ["game_session", "anon_key"], baseUrl = DEFAULT_BASE_URL) {
+    const values = typeof headers?.getSetCookie === "function"
+        ? headers.getSetCookie()
+        : headers?.get?.("set-cookie") ? [headers.get("set-cookie")] : [];
+    const found = new Map();
+    const prefix = cookiePrefix(baseUrl);
+    for (const header of values) {
+        for (const name of names) {
+            for (const key of prefix ? [name, `${prefix}${name}`] : [name]) {
+                const regex = new RegExp(`(?:^|,\\s*)${key}=([^;]+)`, "g");
+                let match;
+                while ((match = regex.exec(header))) found.set(key, decodeURIComponent(match[1]));
+            }
+        }
+    }
+    return found;
+}

package/src/network/http.js

@@ -0,0 +1,34 @@
+import {getFetch, isBrowser, normalizeBaseUrl, resolveUrl} from "../runtime.js";
+import {cookieHeader} from "./cookies.js";
+
+export class HttpClient {
+    constructor({baseUrl, session = null} = {}) {
+        this.baseUrl = normalizeBaseUrl(baseUrl);
+        this.session = session;
+    }
+
+    async request(path, init = {}) {
+        const headers = new Headers(init.headers || {});
+        const body = this.#body(init.body, headers);
+        const cookie = this.session && !isBrowser() ? cookieHeader(this.baseUrl, this.session) : "";
+        if (cookie) headers.set("cookie", cookie);
+        return getFetch()(resolveUrl(this.baseUrl, path), {
+            ...init,
+            body,
+            headers,
+            credentials: isBrowser() ? "include" : init.credentials
+        });
+    }
+
+    async json(path, init = {}) {
+        const response = await this.request(path, init);
+        if (!response.ok) throw new Error(`${path} failed: ${response.status} ${response.statusText}`);
+        return response.json();
+    }
+
+    #body(body, headers) {
+        if (body == null || typeof body === "string" || body instanceof ArrayBuffer || ArrayBuffer.isView(body)) return body;
+        if (!headers.has("content-type")) headers.set("content-type", "application/json");
+        return JSON.stringify(body);
+    }
+}

package/src/network/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./connection.js";
+export * from "./servers.js";
+export * from "./ships.js";
+export * from "./session.js";

package/src/network/index.js

@@ -0,0 +1,4 @@
+export {Connection} from "./connection.js";
+export {fetchGameVersion, fetchNoticeVersion, fetchServers, resolveServer} from "./servers.js";
+export {fetchShips, fetchShipList, createShipSpec, createInviteShipSpec, shipRef} from "./ships.js";
+export {Session, AnonSession, createSession, createAnonSession, createAnonToken} from "./session.js";

package/src/network/servers.d.ts

@@ -0,0 +1,7 @@
+export {
+    fetchNoticeVersion,
+    fetchGameVersion,
+    fetchServers,
+    type Server,
+    type ServerRef
+} from "../index.js";