@swf2es/desktop 0.1.15 → 0.1.17

package/src/main/main.ts

@@ -5,7 +5,8 @@
 //   electron apps/desktop [--trace] [file.swf | http(s)://host/movie.swf]
 //   electron apps/desktop [--trace] app.xml [root-dir] [-- arguments...]
 //
-// --ignore-certificate-errors[=host,...] leaves HTTPS certificates unchecked.
+// --ignore-certificate-errors[=host,...] leaves HTTPS and WSS certificates unchecked.
+// --proxy=socks5://[user:pass@]host:port (or http://...) sends the SWF's network through a proxy.
 //
 // The second runs an AIR application by its descriptor, as adl does.
 import { statSync } from "node:fs";
@@ -23,11 +24,13 @@ import {
   Menu,
   type MenuItemConstructorOptions,
   safeStorage,
+  screen,
   session,
   shell,
   type WebContents,
 } from "electron";
 import type {
+  AirScreenState,
   AirWindowState,
   LibraryName,
   NetworkResponse,
@@ -47,12 +50,24 @@ import {
   statOf,
   writeOf,
 } from "./air.ts";
+import { resolveCase } from "./case-paths.ts";
 import { bridgeFiles } from "./files.ts";
+import { failureLine, requestLine } from "./netlog.ts";
 import { type Movie, Network, Refused, unverifiedHosts } from "./network.ts";
 import { APP_ORIGIN, registerScheme, serve } from "./protocol.ts";
+import { describeProxy, proxyArgument, sameProxy } from "./proxy.ts";
 import { Sandbox } from "./sandbox.ts";
 import { SettingsFile } from "./settings.ts";
 import { bridgeSockets } from "./sockets.ts";
+import {
+  dispatchedOpener,
+  hasWebSocket,
+  type Opener,
+  proxiedDispatcher,
+  unverifiedDispatcher,
+  webSocketOpener,
+} from "./websocket-connections.ts";
+import { bridgeWebSockets } from "./websockets.ts";
 
 const preload = fileURLToPath(new URL("../preload/preload.cjs", import.meta.url));
 const promptPreload = fileURLToPath(new URL("../preload/prompt.cjs", import.meta.url));
@@ -77,6 +92,11 @@ app.enableSandbox();
 
 /** --trace: what the page logs, a SWF's trace() among it, goes to the terminal. */
 const trace = process.argv.includes("--trace");
+// Each request and socket of the SWF's said on stderr: the page's DevTools show none of them.
+// --log-sockets says what each socket sends and receives as well, and so the rest too.
+const logSockets = process.argv.includes("--log-sockets");
+const logNetwork = logSockets || process.argv.includes("--log-network");
+const netLog = logNetwork ? (line: string) => process.stderr.write(`${line}\n`) : null;
 const sandbox = new Sandbox();
 /** The SWF's http and https requests, judged as Flash's sandboxes had them. */
 /**
@@ -89,15 +109,61 @@ const unverified = unverifiedHosts(process.argv.slice(1));
 if (unverified) {
   process.stderr.write(
     unverified.all
-      ? "swf2es: --ignore-certificate-errors: no HTTPS server's certificate is verified\n"
+      ? "swf2es: --ignore-certificate-errors: no HTTPS or WSS server's certificate is verified\n"
       : `swf2es: --ignore-certificate-errors: certificates are not verified for ${unverified.hosts.join(", ") || "no host"}\n`,
   );
 }
 
-const network = new Network({
-  unverified: (host) =>
-    !!unverified && (unverified.all || unverified.hosts.includes(host.toLowerCase())),
-});
+const unverifiedHost = (host: string) =>
+  !!unverified && (unverified.all || unverified.hosts.includes(host.toLowerCase()));
+
+/**
+ * --proxy=<url>: what the SWF's requests, sockets and WebSockets go
+ * through. For this run alone, never kept, and said aloud, without its
+ * credentials. One that does not parse stops the app rather than letting
+ * it run without.
+ */
+const proxied = proxyArgument(process.argv.slice(1));
+if (proxied && "error" in proxied) {
+  process.stderr.write(`swf2es: ${proxied.error}\n`);
+  process.exit(2);
+}
+
+const proxy = proxied?.proxy ?? null;
+if (proxy) {
+  process.stderr.write(
+    `swf2es: --proxy: the SWF's requests, sockets and WebSockets go through ${describeProxy(proxy)}\n`,
+  );
+}
+
+/** What --log-network adds to a line of a connection that went through the proxy. */
+const via = proxy ? " via proxy" : "";
+const warn = (message: string) => process.stderr.write(`swf2es: ${message}\n`);
+const network = new Network({ unverified: unverifiedHost, proxy });
+// What opens an AIR application's WebSockets: the global's client, a wss: server's certificate
+// unchecked where the switch names its host; or every one through the proxy.
+const insecureWebSockets = unverified && !proxy ? unverifiedDispatcher() : null;
+if (unverified && !proxy && !insecureWebSockets) {
+  process.stderr.write(
+    "swf2es: --ignore-certificate-errors: a WebSocket's certificate is verified all the same\n",
+  );
+}
+
+const proxiedWebSockets = proxy ? proxiedDispatcher(proxy, unverifiedHost, warn) : null;
+// Never past the proxy: where none can be made, no WebSocket opens.
+const webSocketOpen: Opener | undefined = proxy
+  ? proxiedWebSockets
+    ? dispatchedOpener(proxiedWebSockets)
+    : () => {
+        throw new Error("no WebSocket through the proxy");
+      }
+  : insecureWebSockets
+    ? webSocketOpener(unverifiedHost, insecureWebSockets)
+    : undefined;
+if (proxy && !proxiedWebSockets) {
+  process.stderr.write("swf2es: --proxy: this Electron's WebSocket cannot go through a proxy\n");
+}
+
 /** What the page's requests under way abort with, by the preload's number. */
 const requests = new Map<number, AbortController>();
 let settings: SettingsFile;
@@ -560,6 +626,25 @@ async function askForSocket(name: string, swf: string, endpoint: string): Promis
   }
 }
 
+/**
+ * Whether what plays may open a WebSocket to `url`: an AIR application,
+ * unasked and anywhere, as AIR's application sandbox connects and as its
+ * sockets do here. air.net.WebSocket is AIR's alone, so nothing else has one.
+ */
+function permitWebSocket(url: string): boolean {
+  if (sandbox.application && hasWebSocket() && (!proxy || proxiedWebSockets)) {
+    return true;
+  }
+
+  const why = !sandbox.application
+    ? "only an AIR application has one"
+    : !hasWebSocket()
+      ? "this Electron has no WebSocket client"
+      : "this Electron's WebSocket cannot go through the proxy";
+  process.stderr.write(`swf2es: no WebSocket to ${url.slice(0, 2048)}: ${why}\n`);
+  return false;
+}
+
 async function showOpenDialog(): Promise<void> {
   if (!window) {
     return;
@@ -608,10 +693,22 @@ async function chooseLibrary(name: LibraryName): Promise<void> {
     refuse("The settings could not be saved.", `swf2es uses ${path} until it quits.`);
   }
 
+  buildMenu();
+
   // The page fetched the libraries once; a fresh page fetches the new one.
   window.webContents.reload();
 }
 
+/** Play on the library the app ships again, in place of one the user chose. */
+function resetLibrary(name: LibraryName): void {
+  if (!settings.clearLibrary(name)) {
+    refuse("The settings could not be saved.", `swf2es uses its own ${name} until it quits.`);
+  }
+
+  buildMenu();
+  window?.webContents.reload();
+}
+
 function buildMenu(): void {
   const recent = settings.settings.recent;
   const template: MenuItemConstructorOptions[] = [
@@ -646,6 +743,11 @@ function buildMenu(): void {
         },
         { type: "separator" },
         { label: "Choose playerglobal.abc…", click: () => void chooseLibrary("playerglobal") },
+        {
+          label: "Use the App's playerglobal",
+          enabled: !!settings.settings.playerglobal,
+          click: () => resetLibrary("playerglobal"),
+        },
         { type: "separator" },
         { role: "quit" },
       ],
@@ -800,6 +902,9 @@ function createWindow(): void {
   window.on("closed", () => {
     window = null;
   });
+  // The page hears of full screen however it came, a SWF's Stage.displayState or the menu's F11.
+  window.on("enter-full-screen", () => window?.webContents.send("desktop:full-screen", true));
+  window.on("leave-full-screen", () => window?.webContents.send("desktop:full-screen", false));
   guard(window.webContents);
   void window.loadURL(`${APP_ORIGIN}/`);
 }
@@ -831,6 +936,12 @@ function listen(): void {
       build,
     };
   });
+  // Stage.displayState of a SWF the user opened: the window's full screen, asked with no gesture.
+  ipcMain.on("desktop:full-screen", (event, fullScreen: unknown) => {
+    if (trusted(event) && current && window) {
+      window.setFullScreen(fullScreen === true);
+    }
+  });
   ipcMain.on("desktop:open-dialog", (event) => {
     if (trusted(event)) {
       void showOpenDialog();
@@ -869,7 +980,8 @@ function listen(): void {
       void chooseLibrary(name);
     }
   });
-  bridgeSockets(trusted, permitSocket);
+  bridgeSockets(trusted, permitSocket, netLog, logSockets, { proxy, warn });
+  bridgeWebSockets(trusted, permitWebSocket, webSocketOpen, netLog, logSockets, via);
   ipcMain.handle("net:fetch", (event, id: unknown, request: unknown) => {
     if (!trusted(event) || typeof id !== "number") {
       throw new Error("not the app's page");
@@ -917,6 +1029,17 @@ function windowState(w: BrowserWindow): AirWindowState {
   };
 }
 
+/** The displays as an AIR application's Screen reads them: the work area is past the system's bars. */
+function screenStates(): AirScreenState[] {
+  const primary = screen.getPrimaryDisplay().id;
+  return screen.getAllDisplays().map((display) => ({
+    bounds: display.bounds,
+    visibleBounds: display.workArea,
+    colorDepth: display.colorDepth,
+    main: display.id === primary,
+  }));
+}
+
 /**
  * An AIR application's reach, shared/api.ts DesktopAir: the file system
  * and the window, only while one the user opened plays and only for its
@@ -990,7 +1113,7 @@ function listenForAir(): void {
     }
 
     try {
-      const real = await realpath(path);
+      const real = await realpath(resolveCase(path));
       return sandbox.startApplication(real) ? new Uint8Array(await readFile(real)) : null;
     } catch {
       return null;
@@ -999,6 +1122,9 @@ function listenForAir(): void {
   ipcMain.on("air:window", (event) => {
     event.returnValue = playing(event) && window ? windowState(window) : null;
   });
+  ipcMain.on("air:screens", (event) => {
+    event.returnValue = playing(event) ? screenStates() : [];
+  });
   ipcMain.on("air:set-bounds", (event, bounds: unknown) => {
     const b = bounds as { x?: unknown; y?: unknown; width?: unknown; height?: unknown } | null;
     const n = (v: unknown) => (typeof v === "number" && Number.isFinite(v) ? Math.round(v) : null);
@@ -1068,7 +1194,7 @@ async function fetchForPage(
   request: unknown,
   deliver: (response: NetworkResponse) => void,
 ): Promise<NetworkResponse> {
-  const asked = request as { url?: unknown; purpose?: unknown } | null;
+  const asked = request as { url?: unknown; purpose?: unknown; method?: unknown } | null;
   const url = typeof asked?.url === "string" ? asked.url : "";
   const shown = url.slice(0, 2048);
   const movie = asked?.purpose === "movie" && sandbox.startRemote(url);
@@ -1079,13 +1205,27 @@ async function fetchForPage(
 
   const controller = new AbortController();
   requests.set(id, controller);
+  const started = performance.now();
+  const method = typeof asked?.method === "string" ? asked.method.slice(0, 16) : "GET";
   try {
-    return await network.fetch(request, controller.signal, deliver);
+    const response = await network.fetch(request, controller.signal, deliver);
+    netLog?.(
+      requestLine(
+        method,
+        url,
+        response.status,
+        response.bytes?.length ?? null,
+        performance.now() - started,
+      ) + via,
+    );
+    return response;
   } catch (error) {
     // A refusal says why; anything else, which should not happen, is said too.
     if (!controller.signal.aborted) {
       const why = error instanceof Refused ? error.message : `failed: ${error}`;
       process.stderr.write(`swf2es: not loading ${shown}: ${why}\n`);
+    } else {
+      netLog?.(failureLine(method, url, "aborted", performance.now() - started) + via);
     }
 
     throw error;
@@ -1099,10 +1239,25 @@ async function fetchForPage(
 // One app to a user data directory: a second start hands its SWF to the first and quits.
 const first = app.requestSingleInstanceLock();
 if (!first) {
+  if (proxied) {
+    process.stderr.write(
+      "swf2es: handed to the app already open, which opens it only if started with the same --proxy\n",
+    );
+  }
+
   app.quit();
 }
 
 app.on("second-instance", (_event, argv, workingDirectory) => {
+  // What it names would go through another proxy than this app's, or past it.
+  const asked = proxyArgument(argv.slice(1));
+  if (asked && !("proxy" in asked && sameProxy(asked.proxy, proxy))) {
+    process.stderr.write(
+      "swf2es: not opening what a second start named: its --proxy is not this app's\n",
+    );
+    return;
+  }
+
   if (window) {
     if (window.isMinimized()) {
       window.restore();
@@ -1152,6 +1307,15 @@ void app.whenReady().then(() => {
   }
 
   settings = new SettingsFile(app.getPath("userData"));
+  // A playerglobal chosen once is kept across versions of the app: said at each start, as a
+  // library older or newer than the app's own makes SWFs fail in ways nothing else explains.
+  const chosen = settings.libraries().playerglobal;
+  if (chosen) {
+    process.stderr.write(
+      `swf2es: playing on the playerglobal chosen in File, ${chosen}, not the app's own\n`,
+    );
+  }
+
   serve(session.defaultSession, sandbox, () => settings.libraries());
   // The page never goes to the network itself: a SWF's requests go through
   // the main process (network.ts), which sends them without this session.

package/src/main/netlog.ts

@@ -0,0 +1,108 @@
+// --log-network's lines: what a SWF asked of the network, as the terminal
+// shows it. The page has no network of its own, so its DevTools' Network
+// tab shows none of this; the main process, which sends the requests, says
+// them here instead. Apart from Electron, so that node tests it.
+
+/** A size as a person reads it: bytes, then kB and MB to one decimal. */
+function size(bytes: number): string {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+
+  return bytes < 1024 * 1024
+    ? `${(bytes / 1024).toFixed(1)} kB`
+    : `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+/** A URL short enough for a line, and with nothing a terminal would act on. */
+function shown(url: string): string {
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what is taken out
+  return url.slice(0, 2048).replace(/[\u0000-\u001f\u007f]/g, "?");
+}
+
+/** A request answered: its method, URL, status, body's size and how long it took. */
+export function requestLine(
+  method: string,
+  url: string,
+  status: number,
+  bytes: number | null,
+  ms: number,
+): string {
+  const body = bytes === null ? "no body" : size(bytes);
+  return `swf2es: net ${method} ${shown(url)} ${status} ${body} ${Math.round(ms)} ms`;
+}
+
+/** A request that got no answer: refused, failed or aborted, and why. */
+export function failureLine(method: string, url: string, why: string, ms: number): string {
+  return `swf2es: net ${method} ${shown(url)} ${why} ${Math.round(ms)} ms`;
+}
+
+/** A socket's connection asked for, opened, refused or closed. */
+export function socketLine(id: number, what: string): string {
+  return `swf2es: socket #${id} ${shown(what)}`;
+}
+
+/** How much of a message --log-sockets shows. */
+const PREVIEW = 512;
+
+/** The start of `bytes`: as text where it is text, bytes that are no printable ASCII as dots, else in hex. */
+function preview(bytes: Uint8Array): string {
+  const shownBytes = bytes.subarray(0, PREVIEW);
+  let printable = 0;
+  for (let i = 0; i < shownBytes.length; i++) {
+    const b = shownBytes[i];
+    if ((b >= 32 && b < 127) || b === 9 || b === 10 || b === 13 || b === 0) {
+      printable++;
+    }
+  }
+
+  let text = "";
+  // Mostly text, as a line protocol's messages are, a NUL ending each: shown as text.
+  if (printable * 10 >= shownBytes.length * 9) {
+    for (let i = 0; i < shownBytes.length; i++) {
+      const b = shownBytes[i];
+      text += b >= 32 && b < 127 ? String.fromCharCode(b) : ".";
+    }
+  } else {
+    for (let i = 0; i < shownBytes.length; i++) {
+      text += (i > 0 ? " " : "") + shownBytes[i].toString(16).padStart(2, "0");
+    }
+  }
+
+  return text + (bytes.length > PREVIEW ? "…" : "");
+}
+
+/**
+ * What a socket sent (">") or received ("<"): its size and its start, as
+ * text where it is text, bytes that are no printable ASCII as dots, else
+ * in hex. A message past PREVIEW bytes ends in an ellipsis.
+ */
+export function socketDataLine(id: number, sent: boolean, bytes: Uint8Array): string {
+  return `swf2es: socket #${id} ${sent ? ">" : "<"} ${bytes.length} B  ${preview(bytes)}`;
+}
+
+/** A WebSocket's connection asked for, opened, refused, failed or closed. */
+export function webSocketLine(id: number, what: string): string {
+  return `swf2es: websocket #${id} ${shown(what)}`;
+}
+
+/**
+ * What a WebSocket sent (">") or received ("<"): a text message's size
+ * in UTF-8 and its first PREVIEW characters, control characters as dots;
+ * a binary one's as a socket's.
+ */
+export function webSocketDataLine(id: number, sent: boolean, data: string | Uint8Array): string {
+  const head = `swf2es: websocket #${id} ${sent ? ">" : "<"}`;
+  if (typeof data !== "string") {
+    return `${head} binary ${data.length} B  ${preview(data)}`;
+  }
+
+  // By code point, so that no pair is cut in two.
+  const characters = Array.from(data.slice(0, PREVIEW * 2)).slice(0, PREVIEW);
+  const text = characters
+    .join("")
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: control characters are what is taken out
+    .replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, ".");
+  const more = text.length < data.length ? "…" : "";
+  return `${head} text ${Buffer.byteLength(data)} B  ${text}${more}`;
+}