@swf2es/desktop 0.1.14 → 0.1.16

package/src/main/websocket-connections.ts

@@ -0,0 +1,264 @@
+// One page's air.net.WebSocket connections, made with the WHATWG WebSocket
+// of Electron's Node: what the WebSocket bridge (websockets.ts) holds for
+// each page, apart from Electron so that node runs it in the tests
+// (tests/desktop/websocket-connections.test.ts).
+import type { WebSocketEvent } from "../shared/api.js";
+
+/** As many as a page may hold open at once; past it a connection is refused. */
+const MAX_OPEN = 64;
+
+/** The longest URL, and the most and longest subprotocols, a page may ask for. */
+const MAX_URL = 8192;
+const MAX_PROTOCOLS = 32;
+const MAX_PROTOCOL = 256;
+
+/**
+ * The bytes a connection may hold unsent, as a socket's (connections.ts)
+ * but for whole messages, which are larger than a socket's writes: a peer
+ * that stops reading would otherwise have the main process buffer all an
+ * application sends. Past this the connection fails.
+ */
+export const MAX_BUFFERED = 16 * 1024 * 1024;
+
+const OPEN = 1;
+
+/** What is used of the WHATWG WebSocket. */
+interface Client {
+  binaryType: string;
+  readonly protocol: string;
+  readonly readyState: number;
+  readonly bufferedAmount: number;
+  onopen: (() => void) | null;
+  onmessage: ((event: { data: unknown }) => void) | null;
+  onclose: ((event: { code: number }) => void) | null;
+  onerror: (() => void) | null;
+  send(data: string | Uint8Array): void;
+  close(code?: number): void;
+}
+
+type ClientConstructor = new (
+  url: string,
+  // Node's takes its options in the protocols' place: undici's dispatcher among them.
+  protocols: string[] | { protocols: string[]; dispatcher: unknown },
+) => Client;
+
+/** Opens a client; throws as the WebSocket constructor does. */
+export type Opener = (url: string, protocols: string[]) => unknown;
+
+const globalClient = (): ClientConstructor | undefined =>
+  (globalThis as { WebSocket?: ClientConstructor }).WebSocket;
+
+/** Whether this Node has the WHATWG WebSocket (22 and later, Electron's among them). */
+export function hasWebSocket(): boolean {
+  return typeof globalClient() === "function";
+}
+
+/**
+ * What sends a client's requests with no certificate verified, for
+ * --ignore-certificate-errors; null where this Node gives no way to make
+ * one. The WHATWG WebSocket has no option for it: Node's is undici's,
+ * which takes a dispatcher, and Node exports no class of one, so it is
+ * made from the class of the dispatcher undici keeps for everything else.
+ */
+export function unverifiedDispatcher(): unknown {
+  // Naming the global loads undici, which then sets its dispatcher.
+  if (!hasWebSocket()) {
+    return null;
+  }
+
+  const shared = (globalThis as Record<symbol, unknown>)[Symbol.for("undici.globalDispatcher.1")];
+  const Agent = (shared as { constructor?: unknown } | undefined)?.constructor;
+  if (typeof Agent !== "function" || Agent.name !== "Agent") {
+    return null;
+  }
+
+  try {
+    const agent = new (Agent as new (options: object) => { dispatch?: unknown })({
+      connect: { rejectUnauthorized: false },
+    });
+    return typeof agent.dispatch === "function" ? agent : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * An opener that leaves a wss: server's certificate unverified where
+ * `unverified` says so of its host, through `dispatcher`
+ * (unverifiedDispatcher's); any other connection is the global's as it is.
+ */
+export function webSocketOpener(
+  unverified: (host: string) => boolean,
+  dispatcher: unknown,
+): Opener {
+  return (url, protocols) => {
+    const Client = globalClient() as ClientConstructor;
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+    return dispatcher && parsed.protocol === "wss:" && unverified(host)
+      ? new Client(url, { protocols, dispatcher })
+      : new Client(url, protocols);
+  };
+}
+
+/** Whether the page asked for a ws: or wss: URL with a host, of a length a server takes. */
+export function validWebSocketUrl(url: unknown): url is string {
+  if (typeof url !== "string" || url.length > MAX_URL) {
+    return false;
+  }
+
+  try {
+    const parsed = new URL(url);
+    return (parsed.protocol === "ws:" || parsed.protocol === "wss:") && parsed.hostname !== "";
+  } catch {
+    return false;
+  }
+}
+
+export function validProtocols(protocols: unknown): protocols is string[] {
+  return (
+    Array.isArray(protocols) &&
+    protocols.length <= MAX_PROTOCOLS &&
+    protocols.every((p) => typeof p === "string" && p.length <= MAX_PROTOCOL)
+  );
+}
+
+/** The close codes the WHATWG WebSocket sends; any other throws. */
+const sendable = (code: unknown): code is number =>
+  code === 1000 || (typeof code === "number" && code >= 3000 && code <= 4999);
+
+export class WebSocketConnections {
+  private readonly clients = new Map<number, Client>();
+  private readonly tell: (id: number, event: WebSocketEvent) => void;
+  private readonly open: Opener;
+
+  /** `tell` carries each connection's events to its page; `open` makes a client, the global's by default. */
+  constructor(
+    tell: (id: number, event: WebSocketEvent) => void,
+    open: Opener = (url, protocols) => new (globalClient() as ClientConstructor)(url, protocols),
+  ) {
+    this.tell = tell;
+    this.open = open;
+  }
+
+  get size(): number {
+    return this.clients.size;
+  }
+
+  /** Counts closeAll's: a connection decided on before one belongs to a page that is gone. */
+  generation = 0;
+
+  /**
+   * Connect `id` to `url`, offering `protocols`, each checked, as the page
+   * asks; a refusal, a URL or protocols the client throws for among them,
+   * is an error, then a close.
+   */
+  connect(id: number, url: unknown, protocols: unknown): void {
+    if (
+      !validWebSocketUrl(url) ||
+      !validProtocols(protocols) ||
+      this.clients.has(id) ||
+      this.clients.size >= MAX_OPEN ||
+      !hasWebSocket()
+    ) {
+      this.refuse(id);
+      return;
+    }
+
+    let client: Client;
+    try {
+      client = this.open(url, protocols) as Client;
+    } catch {
+      this.refuse(id);
+      return;
+    }
+
+    client.binaryType = "arraybuffer";
+    this.clients.set(id, client);
+    client.onopen = () => this.tell(id, { type: "open", protocol: client.protocol });
+    client.onmessage = ({ data }) =>
+      this.tell(id, {
+        type: "message",
+        data: typeof data === "string" ? data : new Uint8Array(data as ArrayBuffer),
+      });
+    client.onerror = () => this.tell(id, { type: "error" });
+    client.onclose = ({ code }) => {
+      // Only the client under this id: a page that reused it has another by now.
+      if (this.clients.get(id) === client) {
+        this.clients.delete(id);
+      }
+
+      this.tell(id, { type: "close", code });
+    };
+  }
+
+  /**
+   * Send a text message for a string, a binary one for bytes, once the
+   * connection is open, unless the peer has left more than MAX_BUFFERED
+   * unread: then the connection fails.
+   */
+  send(id: number, data: string | Uint8Array): void {
+    const client = this.clients.get(id);
+    if (!client || client.readyState !== OPEN) {
+      return;
+    }
+
+    const size = typeof data === "string" ? Buffer.byteLength(data) : data.length;
+    if (client.bufferedAmount + size > MAX_BUFFERED) {
+      // The client has no way to drop a connection: its close waits behind
+      // what is buffered, so the page is told now and the client left to it.
+      this.silence(client);
+      this.clients.delete(id);
+      this.tell(id, { type: "error" });
+      this.tell(id, { type: "close", code: 1006 });
+      return;
+    }
+
+    client.send(data);
+  }
+
+  /** Refuse `id`, as a server that took no connection: an error, then a close with no frame. */
+  refuse(id: number): void {
+    this.tell(id, { type: "error" });
+    this.tell(id, { type: "close", code: 1006 });
+  }
+
+  /** A close frame with `code` where the client sends it, 1000 or 3000 to 4999, else with none. */
+  close(id: number, code?: unknown): void {
+    const client = this.clients.get(id);
+    if (!client) {
+      return;
+    }
+
+    try {
+      client.close(sendable(code) ? code : undefined);
+    } catch {
+      // Already closing.
+    }
+  }
+
+  /**
+   * Close every connection without a word: the page that held them is
+   * gone, and the next numbers its own from 1.
+   */
+  closeAll(): void {
+    for (const client of this.clients.values()) {
+      this.silence(client);
+    }
+
+    this.clients.clear();
+    this.generation++;
+  }
+
+  private silence(client: Client): void {
+    client.onopen = null;
+    client.onmessage = null;
+    client.onerror = null;
+    client.onclose = null;
+    try {
+      client.close();
+    } catch {
+      // Already closing.
+    }
+  }
+}

package/src/main/websockets.ts

@@ -0,0 +1,115 @@
+// air.net.WebSocket's connections, made here for the page, which has no
+// network of its own, and carried over IPC as flash.net.Socket's are
+// (sockets.ts). Each page's connections (websocket-connections.ts) close
+// as it navigates, reloads or goes.
+import { type IpcMainEvent, ipcMain, type WebContents } from "electron";
+import { webSocketDataLine, webSocketLine } from "./netlog.ts";
+import {
+  type Opener,
+  validProtocols,
+  validWebSocketUrl,
+  WebSocketConnections,
+} from "./websocket-connections.ts";
+
+/**
+ * Carry WebSocket messages from pages that `trusted` accepts, each
+ * connection made only where `permit` allows its URL, with `open` if
+ * given. `log`, where given, is told each connection asked for, opened,
+ * refused, failed and closed (--log-network), and with `data` what each
+ * sends and receives too (--log-sockets).
+ */
+export function bridgeWebSockets(
+  trusted: (event: IpcMainEvent) => boolean,
+  permit: (url: string) => boolean,
+  open: Opener | undefined,
+  log: ((line: string) => void) | null = null,
+  data = false,
+): void {
+  const pages = new Map<WebContents, WebSocketConnections>();
+
+  const connectionsOf = (contents: WebContents): WebSocketConnections => {
+    const known = pages.get(contents);
+    if (known) {
+      return known;
+    }
+
+    const connections = new WebSocketConnections((id, event) => {
+      if (log) {
+        switch (event.type) {
+          case "open":
+            log(webSocketLine(id, event.protocol === "" ? "open" : `open ${event.protocol}`));
+            break;
+          case "message":
+            if (data) {
+              log(webSocketDataLine(id, false, event.data));
+            }
+
+            break;
+          case "close":
+            log(webSocketLine(id, `close ${event.code}`));
+            break;
+          case "error":
+            log(webSocketLine(id, "error"));
+            break;
+        }
+      }
+
+      if (!contents.isDestroyed()) {
+        contents.send("websocket:event", id, event);
+      }
+    }, open);
+    pages.set(contents, connections);
+    contents.on("did-start-navigation", (details) => {
+      if (details.isMainFrame && !details.isSameDocument) {
+        connections.closeAll();
+      }
+    });
+    contents.once("destroyed", () => {
+      connections.closeAll();
+      pages.delete(contents);
+    });
+    return connections;
+  };
+
+  ipcMain.on("websocket:connect", (event, id: unknown, url: unknown, protocols: unknown) => {
+    if (!trusted(event) || typeof id !== "number") {
+      return;
+    }
+
+    const connections = connectionsOf(event.sender);
+    if (!validWebSocketUrl(url) || !validProtocols(protocols)) {
+      connections.refuse(id);
+      return;
+    }
+
+    // As the client will read it: what is said of it has nothing a terminal would act on.
+    const href = new URL(url).href;
+    const allowed = permit(href);
+    log?.(webSocketLine(id, `${allowed ? "connecting to" : "refused"} ${href}`));
+    if (allowed) {
+      connections.connect(id, href, protocols);
+    } else {
+      connections.refuse(id);
+    }
+  });
+
+  ipcMain.on("websocket:send", (event, id: unknown, message: unknown) => {
+    if (
+      trusted(event) &&
+      typeof id === "number" &&
+      (typeof message === "string" || message instanceof Uint8Array)
+    ) {
+      if (log && data) {
+        log(webSocketDataLine(id, true, message));
+      }
+
+      pages.get(event.sender)?.send(id, message);
+    }
+  });
+
+  ipcMain.on("websocket:close", (event, id: unknown, code: unknown) => {
+    if (trusted(event) && typeof id === "number") {
+      pages.get(event.sender)?.close(id, code);
+    }
+  });
+}

package/src/preload/preload.cts

@@ -7,11 +7,13 @@ import type {
   NetworkResponse,
   OpenedMovie,
   SocketEvent,
+  WebSocketEvent,
 } from "../shared/api.js";
 
 const { contextBridge, ipcRenderer, webUtils } = require("electron") as typeof import("electron");
 
 let nextSocket = 1;
+let nextWebSocket = 1;
 let nextRequest = 1;
 /** The requests waiting for their response, by number. */
 const responses = new Map<number, (response: NetworkResponse) => void>();
@@ -27,6 +29,12 @@ const api: DesktopApi = {
     write: (id, bytes) => ipcRenderer.invoke("files:write", id, bytes),
     release: (id) => ipcRenderer.send("files:release", id),
   },
+  fullScreen: {
+    set: (fullScreen) => ipcRenderer.send("desktop:full-screen", fullScreen === true),
+    onChange: (listener) => {
+      ipcRenderer.on("desktop:full-screen", (_event, fullScreen: boolean) => listener(fullScreen));
+    },
+  },
   start: () => ipcRenderer.invoke("desktop:start"),
   onOpen: (listener) => {
     ipcRenderer.on("desktop:open", (_event, movie: OpenedMovie) => listener(movie));
@@ -53,6 +61,20 @@ const api: DesktopApi = {
       );
     },
   },
+  webSockets: {
+    connect: (url, protocols) => {
+      const id = nextWebSocket++;
+      ipcRenderer.send("websocket:connect", id, String(url), Array.from(protocols, String));
+      return id;
+    },
+    send: (id, data) => ipcRenderer.send("websocket:send", id, data),
+    close: (id, code) => ipcRenderer.send("websocket:close", id, code),
+    onEvent: (listener) => {
+      ipcRenderer.on("websocket:event", (_event, id: number, event: WebSocketEvent) =>
+        listener(id, event),
+      );
+    },
+  },
   network: {
     fetch: (request, cancel) => {
       const id = nextRequest++;
@@ -95,6 +117,7 @@ const api: DesktopApi = {
     remove: (path) => ipcRenderer.sendSync("air:remove", String(path)),
     move: (from, to) => ipcRenderer.sendSync("air:move", String(from), String(to)),
     window: () => ipcRenderer.sendSync("air:window"),
+    screens: () => ipcRenderer.sendSync("air:screens"),
     setBounds: (bounds) => ipcRenderer.send("air:set-bounds", bounds),
     setTitle: (title) => ipcRenderer.send("air:set-title", String(title)),
     minimize: () => ipcRenderer.send("air:window-do", "minimize"),

package/src/renderer/air.ts

@@ -37,6 +37,7 @@ export function airHosts(
         close: () => air.close(),
         stageOffset: () => air.window().contentOffset,
       },
+      screens: () => air.screens(),
       exit: (code) => air.exit(code),
     },
     fileSystem: {

package/src/renderer/full-screen.ts

@@ -0,0 +1,44 @@
+// Stage.displayState's full screen in the desktop app: the window's, through
+// the shell, since the player's element already fills it. A SWF asks with
+// no gesture, as an AIR application and Flash's projector could, which the
+// Fullscreen API on the element would refuse. Esc leaves, as in Flash; the
+// menu's F11 enters and leaves too, and the SWF hears of either.
+import type { WindowFullScreen } from "@swf2es/web";
+import type { DesktopFullScreen } from "../shared/api.js";
+
+export function windowFullScreen(shell: DesktopFullScreen): WindowFullScreen {
+  const listeners = new Set<(fullScreen: boolean) => void>();
+  let full = false;
+  shell.onChange((fullScreen) => {
+    full = fullScreen;
+    for (const listener of listeners) {
+      listener(fullScreen);
+    }
+  });
+  // In the capture phase: before the SWF's own key handlers, whatever has the focus.
+  document.addEventListener(
+    "keydown",
+    (event) => {
+      if (event.key === "Escape" && full) {
+        full = false;
+        shell.set(false);
+        // No window manager tells of this one sooner than the SWF should hear.
+        for (const listener of listeners) {
+          listener(false);
+        }
+      }
+    },
+    true,
+  );
+
+  return {
+    set: (fullScreen) => {
+      full = fullScreen;
+      shell.set(fullScreen);
+    },
+    onChange: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  };
+}

package/src/renderer/index.ts

@@ -5,8 +5,10 @@ import { configure, type Swf2esPlayerElement } from "@swf2es/web";
 import type { AirLaunch, DesktopApi, LibraryState, OpenedMovie } from "../shared/api.js";
 import { airHosts, airPath } from "./air.js";
 import { shellFiles } from "./files.js";
+import { windowFullScreen } from "./full-screen.js";
 import { shellFetch } from "./network.js";
 import { shellSocketHost } from "./sockets.js";
+import { shellWebSocketHost } from "./websockets.js";
 
 declare global {
   interface Window {
@@ -22,6 +24,7 @@ configure({
   cache: true,
   fileHost: shellFiles(desktop.files),
   sockets: shellSocketHost(desktop.sockets),
+  webSockets: shellWebSocketHost(desktop.webSockets),
   fetch: shellFetch(desktop.network, () => {
     const launch = airLaunch;
     return launch
@@ -32,6 +35,7 @@ configure({
       : null;
   }),
   loadPolicyFile: (url) => desktop.network.loadPolicyFile(url),
+  fullScreen: windowFullScreen(desktop.fullScreen),
 });
 
 const byId = <T extends HTMLElement>(id: string) => document.getElementById(id) as T;

package/src/renderer/websockets.ts

@@ -0,0 +1,43 @@
+// air.net.WebSocket over the shell's connections: what the player asks of
+// a WebSocketHost, carried to the main process and back. The page's own
+// WebSocket reaches nothing: the page has no network.
+import type { WebSocketEvents, WebSocketHost } from "@swf2es/player";
+import type { DesktopWebSockets } from "../shared/api.js";
+
+export function shellWebSocketHost(webSockets: DesktopWebSockets): WebSocketHost {
+  // Until its close, which the shell sends after a failure too.
+  const open = new Map<number, WebSocketEvents>();
+  webSockets.onEvent((id, event) => {
+    const events = open.get(id);
+    if (!events) {
+      return;
+    }
+
+    switch (event.type) {
+      case "open":
+        events.open(event.protocol);
+        break;
+      case "message":
+        events.message(event.data);
+        break;
+      case "error":
+        events.error();
+        break;
+      case "close":
+        open.delete(id);
+        events.close(event.code);
+        break;
+    }
+  });
+
+  return {
+    connect(url, protocols, events) {
+      const id = webSockets.connect(url, protocols);
+      open.set(id, events);
+      return {
+        send: (data) => webSockets.send(id, data),
+        close: (code) => webSockets.close(id, code),
+      };
+    },
+  };
+}

package/src/shared/api.ts

@@ -50,6 +50,14 @@ export interface AirWindowState {
   visible: boolean;
 }
 
+/** One of the system's displays as flash.display.Screen reads it: all of it, and what a window may fill. */
+export interface AirScreenState {
+  bounds: { x: number; y: number; width: number; height: number };
+  visibleBounds: { x: number; y: number; width: number; height: number };
+  colorDepth: number;
+  main: boolean;
+}
+
 /**
  * An AIR application's own reach, only while one the user opened plays:
  * the file system, read and written synchronously as File does, and the
@@ -72,6 +80,8 @@ export interface DesktopAir {
   remove(path: string): boolean;
   move(from: string, to: string): boolean;
   window(): AirWindowState;
+  /** The displays as they are now; none where no application plays. */
+  screens(): AirScreenState[];
   setBounds(bounds: { x: number; y: number; width: number; height: number }): void;
   setTitle(title: string): void;
   minimize(): void;
@@ -134,6 +144,23 @@ export interface DesktopSockets {
   onEvent(listener: (id: number, event: SocketEvent) => void): void;
 }
 
+/** What befalls a WebSocket, as player's WebSocketEvents has it. */
+export type WebSocketEvent =
+  | { type: "open"; protocol: string }
+  | { type: "message"; data: string | Uint8Array }
+  | { type: "close"; code: number }
+  | { type: "error" };
+
+/** air.net.WebSocket's connections, opened by the shell, for an AIR application alone. */
+export interface DesktopWebSockets {
+  /** A connection's id; its events follow, an "error" then a "close" if the shell refuses it. */
+  connect(url: string, protocols: string[]): number;
+  /** A text message for a string, a binary one for bytes. */
+  send(id: number, data: string | Uint8Array): void;
+  close(id: number, code?: number): void;
+  onEvent(listener: (id: number, event: WebSocketEvent) => void): void;
+}
+
 /** A request of a SWF's, as player's FetchRequest has it. */
 export interface NetworkRequest {
   url: string;
@@ -182,8 +209,20 @@ export interface DesktopFiles {
   release(id: number): void;
 }
 
+/**
+ * The window's full screen, which a SWF's Stage.displayState asks for
+ * while one the user opened plays, with no gesture, as AIR's and the
+ * projector's did.
+ */
+export interface DesktopFullScreen {
+  set(fullScreen: boolean): void;
+  /** The window has entered or left full screen, a SWF's doing or the user's (F11). */
+  onChange(listener: (fullScreen: boolean) => void): void;
+}
+
 export interface DesktopApi {
   files: DesktopFiles;
+  fullScreen: DesktopFullScreen;
   /** The page has loaded and listens: what it is to show. */
   start(): Promise<StartState>;
   /** The shell opened a SWF: play it in place of what plays. */
@@ -199,6 +238,7 @@ export interface DesktopApi {
   /** Ask the user for a library; the page reloads once the shell has it. */
   chooseLibrary(name: LibraryName): void;
   sockets: DesktopSockets;
+  webSockets: DesktopWebSockets;
   network: DesktopNetwork;
   air: DesktopAir;
 }