@swf2es/desktop 0.1.14 → 0.1.16

package/src/main/main.ts

@@ -5,7 +5,7 @@
 //   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.
 //
 // The second runs an AIR application by its descriptor, as adl does.
 import { statSync } from "node:fs";
@@ -23,11 +23,13 @@ import {
   Menu,
   type MenuItemConstructorOptions,
   safeStorage,
+  screen,
   session,
   shell,
   type WebContents,
 } from "electron";
 import type {
+  AirScreenState,
   AirWindowState,
   LibraryName,
   NetworkResponse,
@@ -48,11 +50,14 @@ import {
   writeOf,
 } from "./air.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 { Sandbox } from "./sandbox.ts";
 import { SettingsFile } from "./settings.ts";
 import { bridgeSockets } from "./sockets.ts";
+import { hasWebSocket, 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 +82,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 +99,23 @@ 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()));
+const network = new Network({ unverified: unverifiedHost });
+// What opens an AIR application's WebSockets: the global's client, a wss: server's certificate
+// unchecked where the switch names its host.
+const insecureWebSockets = unverified ? unverifiedDispatcher() : null;
+if (unverified && !insecureWebSockets) {
+  process.stderr.write(
+    "swf2es: --ignore-certificate-errors: a WebSocket's certificate is verified all the same\n",
+  );
+}
+
 /** What the page's requests under way abort with, by the preload's number. */
 const requests = new Map<number, AbortController>();
 let settings: SettingsFile;
@@ -376,6 +394,37 @@ async function openUrl(text: string): Promise<void> {
   show(url.href, { url: url.href, name, sandbox: "remote" }, { kind: "remote", url: url.href });
 }
 
+/**
+ * Open the file the user chose in the dialog, dropped on the window or
+ * opened with the app: an AIR application's descriptor (`.xml`) runs the
+ * application, anything else is played as a SWF.
+ */
+async function openChosen(path: string): Promise<void> {
+  if (!/\.xml$/i.test(path)) {
+    return open(path);
+  }
+
+  // An application has an installed program's reach, which a file chosen in
+  // passing should not get unasked: asked once, until it leaves the recent list.
+  if (window && !settings.settings.recent.includes(path)) {
+    const { response } = await dialog.showMessageBox(window, {
+      type: "question",
+      message: `Run ${basename(path)} as an AIR application?`,
+      detail:
+        "An AIR application reads and writes your files and reaches the network unasked, as an installed program does. Run only one you trust.",
+      buttons: ["Run", "Cancel"],
+      defaultId: 1,
+      cancelId: 1,
+    });
+    if (response !== 0) {
+      return;
+    }
+  }
+
+  // Run from its own directory, with no arguments, as one started by its icon is.
+  return openAir({ descriptor: path, root: null, arguments: [] }, dirname(path));
+}
+
 /** Play the SWF at `path` in the window, in place of what plays, in its sandbox. */
 async function open(path: string): Promise<void> {
   const name = basename(path);
@@ -529,21 +578,38 @@ 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()) {
+    return true;
+  }
+
+  const why = sandbox.application
+    ? "this Electron has no WebSocket client"
+    : "only an AIR application has one";
+  process.stderr.write(`swf2es: no WebSocket to ${url.slice(0, 2048)}: ${why}\n`);
+  return false;
+}
+
 async function showOpenDialog(): Promise<void> {
   if (!window) {
     return;
   }
 
   const result = await dialog.showOpenDialog(window, {
-    title: "Open a SWF",
+    title: "Open a SWF or an AIR application",
     properties: ["openFile"],
     filters: [
-      { name: "SWF", extensions: ["swf"] },
+      { name: "SWF and AIR application descriptors", extensions: ["swf", "xml"] },
       { name: "All files", extensions: ["*"] },
     ],
   });
   if (!result.canceled && result.filePaths[0]) {
-    await open(result.filePaths[0]);
+    await openChosen(result.filePaths[0]);
   }
 }
 
@@ -769,6 +835,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}/`);
 }
@@ -800,6 +869,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();
@@ -830,7 +905,7 @@ function listen(): void {
   });
   ipcMain.on("desktop:open-path", (event, path: unknown) => {
     if (trusted(event) && typeof path === "string" && isAbsolute(path)) {
-      void open(path);
+      void openChosen(path);
     }
   });
   ipcMain.on("desktop:choose-library", (event, name: unknown) => {
@@ -838,7 +913,14 @@ function listen(): void {
       void chooseLibrary(name);
     }
   });
-  bridgeSockets(trusted, permitSocket);
+  bridgeSockets(trusted, permitSocket, netLog, logSockets);
+  bridgeWebSockets(
+    trusted,
+    permitWebSocket,
+    insecureWebSockets ? webSocketOpener(unverifiedHost, insecureWebSockets) : undefined,
+    netLog,
+    logSockets,
+  );
   ipcMain.handle("net:fetch", (event, id: unknown, request: unknown) => {
     if (!trusted(event) || typeof id !== "number") {
       throw new Error("not the app's page");
@@ -886,6 +968,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
@@ -968,6 +1061,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);
@@ -1037,7 +1133,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);
@@ -1048,13 +1144,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,
+      ),
+    );
+    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));
     }
 
     throw error;
@@ -1093,15 +1203,18 @@ app.on("second-instance", (_event, argv, workingDirectory) => {
 });
 
 let pending = movieFromArguments(process.argv);
+// Whether `pending` came from the system's "open with", not the command line: asked as a drop is.
+let pendingChosen = false;
 // An AIR application named adl's way, which the command line's SWF gives way to.
 const pendingAir = airCommand(process.argv.slice(process.defaultApp ? 2 : 1), process.cwd());
 // macOS hands a file opened from the Finder as an event, perhaps before the app is ready.
 app.on("open-file", (event, path) => {
   event.preventDefault();
   if (settings) {
-    void open(path);
+    void openChosen(path);
   } else {
     pending = path;
+    pendingChosen = true;
   }
 });
 
@@ -1141,6 +1254,6 @@ void app.whenReady().then(() => {
   if (pendingAir) {
     void openAir(pendingAir, process.cwd());
   } else if (pending) {
-    void openEntry(pending);
+    void (pendingChosen ? openChosen(pending) : openEntry(pending));
   }
 });

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}`;
+}

package/src/main/sockets.ts

@@ -3,15 +3,20 @@
 // connections (connections.ts) close as it navigates, reloads or goes.
 import { type IpcMainEvent, ipcMain, type WebContents } from "electron";
 import { Connections, validEndpoint } from "./connections.ts";
+import { socketDataLine, socketLine } from "./netlog.ts";
 
 /**
  * Carry socket messages from pages that `trusted` accepts, each connection
  * made only as `permit` allows it, to the address it gives where it gives
- * one; null refuses it.
+ * one; null refuses it. `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 bridgeSockets(
   trusted: (event: IpcMainEvent) => boolean,
   permit: (host: string, port: number) => Promise<{ address?: string } | null>,
+  log: ((line: string) => void) | null = null,
+  data = false,
 ): void {
   const pages = new Map<WebContents, Connections>();
 
@@ -22,6 +27,12 @@ export function bridgeSockets(
     }
 
     const connections = new Connections((id, event) => {
+      if (log && event.type !== "data") {
+        log(socketLine(id, event.type === "error" ? `error: ${event.message}` : event.type));
+      } else if (log && data && event.type === "data") {
+        log(socketDataLine(id, false, event.bytes));
+      }
+
       if (!contents.isDestroyed()) {
         contents.send("socket:event", id, event);
       }
@@ -59,6 +70,7 @@ export function bridgeSockets(
           return;
         }
 
+        log?.(socketLine(id, `${allowed ? "connecting to" : "refused"} ${host}:${port}`));
         if (allowed) {
           connections.connect(id, host, port, allowed.address);
         } else {
@@ -69,6 +81,10 @@ export function bridgeSockets(
 
   ipcMain.on("socket:send", (event, id: unknown, bytes: unknown) => {
     if (trusted(event) && typeof id === "number" && bytes instanceof Uint8Array) {
+      if (log && data) {
+        log(socketDataLine(id, true, bytes));
+      }
+
       pages.get(event.sender)?.send(id, bytes);
     }
   });