@swf2es/desktop 0.1.15 → 0.1.17

package/src/main/websocket-connections.ts

@@ -0,0 +1,344 @@
+// 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 { isIP, type Socket } from "node:net";
+import * as tls from "node:tls";
+import type { WebSocketEvent } from "../shared/api.js";
+import { connectThrough, type ProxyConfig, type ProxyError } from "./proxy.ts";
+
+/** 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 {
+  const Agent = agentClass();
+  if (!Agent) {
+    return null;
+  }
+
+  try {
+    const agent = new Agent({
+      connect: { rejectUnauthorized: false },
+    });
+    return typeof agent.dispatch === "function" ? agent : null;
+  } catch {
+    return null;
+  }
+}
+
+/** undici's Agent, the class of the dispatcher it keeps for everything else; null where none. */
+function agentClass(): (new (options: object) => { dispatch?: unknown }) | null {
+  // 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;
+  return typeof Agent === "function" && Agent.name === "Agent"
+    ? (Agent as new (
+        options: object,
+      ) => { dispatch?: unknown })
+    : null;
+}
+
+/**
+ * What sends every client's requests through `proxy` (--proxy): a tunnel to
+ * the URL's host, by name for the proxy to resolve, and TLS over it for
+ * wss:, its certificate unverified where `unverified` says so of its host.
+ * `warn` is told why a proxy did not make one. Null where this Node gives
+ * no way to make one, as unverifiedDispatcher.
+ */
+export function proxiedDispatcher(
+  proxy: ProxyConfig,
+  unverified: (host: string) => boolean,
+  warn: (message: string) => void = () => {},
+): unknown {
+  const Agent = agentClass();
+  if (!Agent) {
+    return null;
+  }
+
+  // undici's connector: its options name the target, and its callback takes the socket made.
+  const connect = (
+    options: { hostname: string; protocol: string; port: string | number; servername?: string },
+    done: (error: Error | null, socket: Socket | null) => void,
+  ) => {
+    const host = options.hostname.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+    const https = options.protocol === "https:";
+    const port = Number(options.port) || (https ? 443 : 80);
+    connectThrough(proxy, host, port).then(
+      (tunnel) => {
+        if (!https) {
+          done(null, tunnel);
+          return;
+        }
+
+        const secure = tls.connect({
+          socket: tunnel,
+          servername: isIP(host) ? undefined : (options.servername ?? host),
+          ALPNProtocols: ["http/1.1"],
+          ...(unverified(host) ? { rejectUnauthorized: false } : {}),
+        });
+        const failed = (error: Error) => done(error, null);
+        secure.once("error", failed);
+        secure.once("secureConnect", () => {
+          secure.removeListener("error", failed);
+          done(null, secure);
+        });
+      },
+      (error: ProxyError) => {
+        warn(`no WebSocket to ${host}:${port}: ${error.message}`);
+        done(error, null);
+      },
+    );
+  };
+  try {
+    const agent = new Agent({ connect });
+    return typeof agent.dispatch === "function" ? agent : null;
+  } catch {
+    return null;
+  }
+}
+
+/** An opener whose every connection is `dispatcher`'s: proxiedDispatcher's. */
+export function dispatchedOpener(dispatcher: unknown): Opener {
+  return (url, protocols) => {
+    const Client = globalClient() as ClientConstructor;
+    return new Client(url, { protocols, dispatcher });
+  };
+}
+
+/**
+ * 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,117 @@
+// 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), the connections' lines ending
+ * in `via`.
+ */
+export function bridgeWebSockets(
+  trusted: (event: IpcMainEvent) => boolean,
+  permit: (url: string) => boolean,
+  open: Opener | undefined,
+  log: ((line: string) => void) | null = null,
+  data = false,
+  via = "",
+): 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 ${href}${via}` : `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),
+      };
+    },
+  };
+}