@swf2es/desktop 0.0.0-stage → 0.1.15

package/src/launch/electron.ts

@@ -0,0 +1,44 @@
+// Where Electron and the built app are, for launch.ts and the tests: from the
+// checkout's src/launch or the package's dist/launch, the app two folders up.
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+/** The app's folder: package.json, dist/ and static/. */
+export const appRoot = fileURLToPath(new URL("../../", import.meta.url));
+
+/**
+ * The Electron binary, or null where `pnpm install` skipped its download.
+ * Read from the package's path.txt and dist/, not by requiring it: its
+ * index.js downloads the binary when it is missing, which would make a
+ * check for it the download it is meant to avoid.
+ */
+export function electronBinary(): string | null {
+  try {
+    const root = electronPackage();
+    const name = readFileSync(join(root, "path.txt"), "utf8");
+    const path = join(root, "dist", name);
+    return existsSync(path) ? path : null;
+  } catch {
+    return null;
+  }
+}
+
+/** The electron package's folder; throws where it is not installed. */
+export function electronPackage(): string {
+  return dirname(createRequire(import.meta.url).resolve("electron/package.json"));
+}
+
+/** Why the app cannot start yet, or null. */
+export function missing(): string | null {
+  if (!electronBinary()) {
+    return "Electron is not downloaded: run `pnpm --filter @swf2es/desktop fetch-electron` once.";
+  }
+
+  if (!existsSync(`${appRoot}dist/main/main.js`)) {
+    return "The app is not built: run `pnpm build`.";
+  }
+
+  return null;
+}

package/src/launch/launch.ts

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+// Starts the desktop app in Electron, with a SWF if one is named: the
+// swf2es-desktop command of the package npm installs, and a checkout's
+// `start`.
+//
+//   npx @swf2es/desktop [--trace] [file.swf | https://host/movie.swf]
+//   npx @swf2es/desktop [--trace] app.xml [root-dir] [-- arguments...]
+//   pnpm --filter @swf2es/desktop start ...        the same, in a checkout
+//
+// A relative path is the caller's: from the directory the command was run
+// in, which pnpm and npm name in INIT_CWD where they change it.
+import { execFileSync, spawn, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { appRoot, electronBinary, electronPackage, missing } from "./electron.ts";
+
+// Electron's binary comes by its package's install script, which a package manager may not
+// have run: pnpm runs none it was not told to, and a checkout's install skips this one. Then
+// it is fetched now, once, as that script fetches it.
+if (!electronBinary()) {
+  let install = "";
+  try {
+    install = join(electronPackage(), "install.js");
+  } catch {
+    // Not installed at all: `missing` says so.
+  }
+
+  if (install && existsSync(install)) {
+    console.error("swf2es: downloading Electron, once...");
+    spawnSync(process.execPath, [install], { stdio: "inherit" });
+  }
+}
+
+const why = missing();
+if (why) {
+  console.error(why);
+  process.exit(1);
+}
+
+const cwd = process.env.INIT_CWD ?? process.cwd();
+// Switches and URLs as they are; a path from where the command was run. What follows "--" is
+// an AIR application's own arguments, as they are.
+const given = process.argv.slice(2);
+const end = given.indexOf("--");
+const own = end < 0 ? given : given.slice(0, end);
+const args = [
+  ...own.map((a) => (a.startsWith("-") || /^https?:\/\//i.test(a) ? a : resolve(cwd, a))),
+  ...(end < 0 ? [] : given.slice(end)),
+];
+// What the context menu's About item names: a checkout's commit, else the package's version.
+let build = "";
+try {
+  build = execFileSync("git", ["rev-parse", "--short=12", "HEAD"], {
+    cwd: appRoot,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"],
+  }).trim();
+} catch {
+  // Not a checkout, or no git.
+}
+
+// An installed package may sit inside some other project's checkout: its commit is not the app's.
+if (!build || appRoot.includes(`${join("node_modules", "@swf2es")}`)) {
+  build = JSON.parse(readFileSync(join(appRoot, "package.json"), "utf8")).version;
+}
+
+const env = { ...process.env, SWF2ES_DESKTOP_BUILD: build };
+const child = spawn(electronBinary() as string, [appRoot, ...args], { stdio: "inherit", env });
+child.on("exit", (code, signal) => process.exit(signal ? 1 : (code ?? 0)));
+for (const signal of ["SIGINT", "SIGTERM"] as const) {
+  process.on(signal, () => child.kill(signal));
+}

package/src/launch/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "../../../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "outDir": "../../dist/launch",
+    "tsBuildInfoFile": "../../dist/launch/.tsbuildinfo",
+    "types": ["node"],
+    // Its modules import each other by their .ts names, so that node runs
+    // them as they are in the tests, and the build writes .js.
+    "rewriteRelativeImportExtensions": true,
+    "lib": ["ES2022"]
+  },
+  "include": ["*.ts"]
+}

package/src/main/addresses.ts

@@ -0,0 +1,184 @@
+// Where an IP address is, for the network the desktop app reaches for a
+// SWF: on the internet, on a private network (a LAN, a link, a cloud's
+// metadata service at 169.254.169.254), or on this machine. A SWF reaches
+// a place more private than the one it came from only as that place's own
+// policy file allows, as Chromium's Private Network Access asks a server
+// there before a public page may. Some addresses no request may reach.
+// Pure, so that node tests it (tests/desktop/network.test.ts).
+import { isIPv4, isIPv6 } from "node:net";
+
+export type AddressClass = "public" | "private" | "loopback";
+
+/** How private a class is: a request to a higher rank than its SWF's needs the target's word. */
+export const RANK: Record<AddressClass, number> = { public: 0, private: 1, loopback: 2 };
+
+/** An IPv4 address as a number, or null. */
+function ipv4(text: string): number | null {
+  if (!isIPv4(text)) {
+    return null;
+  }
+
+  return text.split(".").reduce((n, part) => n * 256 + Number(part), 0);
+}
+
+const inV4 = (n: number, base: string, bits: number): boolean => {
+  const mask = bits === 0 ? 0 : (0xffffffff << (32 - bits)) >>> 0;
+  return (n & mask) >>> 0 === ((ipv4(base) as number) & mask) >>> 0;
+};
+
+function classOfV4(n: number): AddressClass | null {
+  // This network, multicast, and the reserved block with broadcast: never a server.
+  if (inV4(n, "0.0.0.0", 8) || inV4(n, "224.0.0.0", 4) || inV4(n, "240.0.0.0", 4)) {
+    return null;
+  }
+
+  if (inV4(n, "127.0.0.0", 8)) {
+    return "loopback";
+  }
+
+  const special: [string, number][] = [
+    ["10.0.0.0", 8],
+    // Carrier-grade NAT.
+    ["100.64.0.0", 10],
+    // Link-local, where clouds keep their metadata service.
+    ["169.254.0.0", 16],
+    ["172.16.0.0", 12],
+    ["192.0.0.0", 24],
+    // The documentation and benchmarking blocks, never on the internet.
+    ["192.0.2.0", 24],
+    ["192.168.0.0", 16],
+    ["198.18.0.0", 15],
+    ["198.51.100.0", 24],
+    ["203.0.113.0", 24],
+  ];
+  return special.some(([base, bits]) => inV4(n, base, bits)) ? "private" : "public";
+}
+
+/** An IPv6 address's 16 bytes, its zone dropped; null if it is not one. */
+function ipv6(text: string): Uint8Array | null {
+  const address = text.replace(/%.*$/, "");
+  if (!isIPv6(address)) {
+    return null;
+  }
+
+  let head = address;
+  let tail = "";
+  const bytes = new Uint8Array(16);
+  // A dotted IPv4 tail fills the last four bytes.
+  const dotted = /^(.*:)(\d+\.\d+\.\d+\.\d+)$/.exec(address);
+  let v4: number | null = null;
+  if (dotted) {
+    v4 = ipv4(dotted[2]);
+    head = `${dotted[1]}0:0`;
+  }
+
+  const halves = head.split("::");
+  [head, tail] = [halves[0], halves[1] ?? ""];
+  const groups = (part: string) => (part === "" ? [] : part.split(":"));
+  const front = groups(head);
+  const back = groups(tail);
+  const all = [...front, ...Array(8 - front.length - back.length).fill("0"), ...back];
+  all.forEach((group, i) => {
+    const value = Number.parseInt(group, 16);
+    bytes[i * 2] = value >> 8;
+    bytes[i * 2 + 1] = value & 0xff;
+  });
+  if (v4 !== null) {
+    bytes.set([v4 >>> 24, (v4 >>> 16) & 0xff, (v4 >>> 8) & 0xff, v4 & 0xff], 12);
+  }
+
+  return bytes;
+}
+
+const v4At = (bytes: Uint8Array, at: number): number =>
+  ((bytes[at] << 24) | (bytes[at + 1] << 16) | (bytes[at + 2] << 8) | bytes[at + 3]) >>> 0;
+
+function startsWith(bytes: Uint8Array, prefix: number[], bits: number): boolean {
+  for (let bit = 0; bit < bits; bit++) {
+    const byte = bit >> 3;
+    const mask = 0x80 >> (bit & 7);
+    if ((bytes[byte] & mask) !== ((prefix[byte] ?? 0) & mask)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+function classOfV6(bytes: Uint8Array): AddressClass | null {
+  const zero = (from: number, to: number) => bytes.subarray(from, to).every((b) => b === 0);
+  if (zero(0, 16)) {
+    return null;
+  }
+
+  if (zero(0, 15) && bytes[15] === 1) {
+    return "loopback";
+  }
+
+  // An IPv4 address within, mapped, translated (RFC 2765's ::ffff:0:a.b.c.d),
+  // compatible, by NAT64 or by 6to4: that address's class.
+  if (zero(0, 10) && bytes[10] === 0xff && bytes[11] === 0xff) {
+    return classOfV4(v4At(bytes, 12));
+  }
+
+  if (zero(0, 8) && bytes[8] === 0xff && bytes[9] === 0xff && zero(10, 12)) {
+    return classOfV4(v4At(bytes, 12));
+  }
+
+  if (zero(0, 12)) {
+    return classOfV4(v4At(bytes, 12));
+  }
+
+  if (startsWith(bytes, [0, 0x64, 0xff, 0x9b], 96)) {
+    return classOfV4(v4At(bytes, 12));
+  }
+
+  if (startsWith(bytes, [0x20, 0x02], 16)) {
+    return classOfV4(v4At(bytes, 2));
+  }
+
+  // Multicast, and the discard block.
+  if (bytes[0] === 0xff || startsWith(bytes, [0x01, 0x00], 64)) {
+    return null;
+  }
+
+  const special: [number[], number][] = [
+    // Unique local, link-local and the old site-local.
+    [[0xfc], 7],
+    [[0xfe, 0x80], 10],
+    [[0xfe, 0xc0], 10],
+    // NAT64 for local use, Teredo, whose IPv4 address is hidden, and documentation.
+    [[0, 0x64, 0xff, 0x9b, 0, 1], 48],
+    [[0x20, 0x01, 0, 0], 32],
+    [[0x20, 0x01, 0x0d, 0xb8], 32],
+  ];
+  return special.some(([prefix, bits]) => startsWith(bytes, prefix, bits)) ? "private" : "public";
+}
+
+/** Where `address` is; null for one no request may reach, or for what is no IP address. */
+export function addressClass(address: string): AddressClass | null {
+  const v4 = ipv4(address);
+  if (v4 !== null) {
+    return classOfV4(v4);
+  }
+
+  const v6 = ipv6(address.replace(/^\[(.*)\]$/, "$1"));
+  return v6 ? classOfV6(v6) : null;
+}
+
+/**
+ * The ports the Fetch standard blocks, as browsers do, so that a request
+ * cannot speak HTTP to a mail, shell or name server; Flash in a browser
+ * went through the browser's network and met the same list.
+ */
+const BAD_PORTS = new Set([
+  1, 7, 9, 11, 13, 15, 17, 19, 20, 21, 22, 23, 25, 37, 42, 43, 53, 69, 77, 79, 87, 95, 101, 102,
+  103, 104, 109, 110, 111, 113, 115, 117, 119, 123, 135, 137, 139, 143, 161, 179, 389, 427, 465,
+  512, 513, 514, 515, 526, 530, 531, 532, 540, 548, 554, 556, 563, 587, 601, 636, 989, 990, 993,
+  995, 1719, 1720, 1723, 2049, 3659, 4045, 4190, 5060, 5061, 6000, 6566, 6665, 6666, 6667, 6668,
+  6669, 6679, 6697, 10080,
+]);
+
+export function badPort(port: number): boolean {
+  return BAD_PORTS.has(port);
+}

package/src/main/air.ts

@@ -0,0 +1,275 @@
+// An AIR application opened by its descriptor, as adl runs one
+// (`adl app.xml [root-dir] [-- arguments...]`): its launch, which the page
+// plays it with, and the file system its File reads and writes, while it
+// plays.
+// Apart from Electron, so that node tests it (tests/desktop/air.test.ts).
+import {
+  closeSync,
+  cpSync,
+  ftruncateSync,
+  lstatSync,
+  mkdirSync,
+  openSync,
+  readdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+  writeSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join, resolve, sep } from "node:path";
+import { readAirDescriptor } from "@swf2es/format";
+import type { AirFileStat, AirLaunch } from "../shared/api.js";
+
+/** What the command line asks adl's way: the descriptor, the application's directory, the arguments. */
+export interface AirCommand {
+  descriptor: string;
+  root: string | null;
+  arguments: string[];
+}
+
+/**
+ * The AIR application `argv` names, from `cwd`: a descriptor (`.xml`), the
+ * directory its content is under if one follows, and what follows `--`.
+ */
+export function airCommand(argv: string[], cwd: string): AirCommand | null {
+  const end = argv.indexOf("--");
+  const own = (end < 0 ? argv : argv.slice(0, end)).filter((a) => !a.startsWith("-"));
+  const at = own.findIndex((a) => /\.xml$/i.test(a));
+  if (at < 0) {
+    return null;
+  }
+
+  const next = own[at + 1];
+  const root = next && statSync(resolve(cwd, next), { throwIfNoEntry: false })?.isDirectory();
+  return {
+    descriptor: resolve(cwd, own[at]),
+    root: root ? resolve(cwd, next) : null,
+    arguments: end < 0 ? [] : argv.slice(end + 1),
+  };
+}
+
+/** What opening `command` plays: the content SWF's path, its launch, and its window's title and size. */
+export function airLaunch(
+  command: AirCommand,
+  currentDirectory: string,
+  userData: string,
+  directories: { documents: string; desktop: string; cache: string },
+): {
+  content: string;
+  /** The content's path under the application's directory, "/"-separated, as its app:/ URL has it. */
+  relative: string;
+  launch: AirLaunch;
+  title: string;
+  width: number | null;
+  height: number | null;
+} {
+  const xml = readFileSync(command.descriptor, "utf8");
+  const descriptor = readAirDescriptor(xml);
+  const application = command.root ?? dirname(command.descriptor);
+  // Each application's own, as AIR keeps one under the user's data by its id.
+  const applicationStorage = join(
+    userData,
+    "air",
+    descriptor.id.replace(/[^\w.-]/g, "_"),
+    "Local Store",
+  );
+  mkdirSync(applicationStorage, { recursive: true });
+  return {
+    content: resolve(application, ...descriptor.content.split("/")),
+    relative: descriptor.content,
+    launch: {
+      descriptor: xml,
+      id: descriptor.id,
+      arguments: command.arguments,
+      currentDirectory,
+      separator: sep,
+      directories: { application, applicationStorage, user: homedir(), ...directories },
+    },
+    title: descriptor.title ?? basename(descriptor.content),
+    width: descriptor.width,
+    height: descriptor.height,
+  };
+}
+
+/** What is at `path`, as File reads it; null where nothing is. */
+export function statOf(path: string): AirFileStat | null {
+  try {
+    const s = statSync(path);
+    const link = lstatSync(path).isSymbolicLink();
+    return {
+      directory: s.isDirectory(),
+      size: s.isDirectory() ? 0 : s.size,
+      modified: s.mtimeMs,
+      created: s.birthtimeMs || s.ctimeMs,
+      // A dot file is hidden where Windows' attribute is not at hand, as on macOS and Linux.
+      hidden: basename(path).startsWith("."),
+      symbolicLink: link,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** The names in the directory at `path`; null where it is none. */
+export function listOf(path: string): string[] | null {
+  try {
+    return readdirSync(path);
+  } catch {
+    return null;
+  }
+}
+
+/** The bytes of the file at `path`, as FileStream's open reads them at once; null where none can be read. */
+export function readOf(path: string): Uint8Array | null {
+  try {
+    return new Uint8Array(readFileSync(path));
+  } catch {
+    return null;
+  }
+}
+
+/** How the main process encrypts what it keeps: Electron's safeStorage where the system offers it. */
+export interface Cipher {
+  encrypt(text: string): Uint8Array;
+  decrypt(data: Uint8Array): string;
+}
+
+/**
+ * An AIR application's EncryptedLocalStore items, as AIR keeps them for
+ * it apart from its files: in one file at `path`, beside its storage
+ * directory, of the items' bytes by name, encrypted whole by `cipher`
+ * where one is given, as Electron's safeStorage encrypts by the system's
+ * keychain. Its first byte says which: "E" encrypted, "P" plain. Written
+ * whole as each item changes, through a file beside it renamed over it.
+ */
+export class EncryptedItems {
+  private readonly path: string;
+  private readonly cipher: Cipher | null;
+  private readonly items: Map<string, Uint8Array>;
+
+  constructor(path: string, cipher: Cipher | null) {
+    this.path = path;
+    this.cipher = cipher;
+    this.items = this.load();
+  }
+
+  get(name: string): Uint8Array | null {
+    return this.items.get(name) ?? null;
+  }
+
+  set(name: string, bytes: Uint8Array): void {
+    this.items.set(name, new Uint8Array(bytes));
+    this.save();
+  }
+
+  remove(name: string): void {
+    if (this.items.delete(name)) {
+      this.save();
+    }
+  }
+
+  reset(): void {
+    this.items.clear();
+    this.save();
+  }
+
+  /** What the file holds; nothing where there is none, or it cannot be read, as by another keychain. */
+  private load(): Map<string, Uint8Array> {
+    const items = new Map<string, Uint8Array>();
+    let text: string;
+    try {
+      const data = readFileSync(this.path);
+      if (data[0] === 0x45 && this.cipher) {
+        text = this.cipher.decrypt(new Uint8Array(data.subarray(1)));
+      } else if (data[0] === 0x50) {
+        text = data.subarray(1).toString("utf8");
+      } else {
+        return items;
+      }
+
+      const saved = JSON.parse(text) as Record<string, string>;
+      for (const [name, base64] of Object.entries(saved)) {
+        items.set(name, new Uint8Array(Buffer.from(base64, "base64")));
+      }
+    } catch {
+      // None yet, or unreadable: an empty store, as AIR's after a reset.
+    }
+
+    return items;
+  }
+
+  private save(): void {
+    const saved: Record<string, string> = {};
+    for (const [name, bytes] of this.items) {
+      saved[name] = Buffer.from(bytes).toString("base64");
+    }
+
+    const text = JSON.stringify(saved);
+    const data = this.cipher
+      ? Buffer.concat([Buffer.from("E"), this.cipher.encrypt(text)])
+      : Buffer.concat([Buffer.from("P"), Buffer.from(text, "utf8")]);
+    mkdirSync(dirname(this.path), { recursive: true });
+    writeFileSync(`${this.path}.new`, data);
+    renameSync(`${this.path}.new`, this.path);
+  }
+}
+
+/**
+ * Writes `bytes` into the file at `path` from `offset`, which is then
+ * `length` long, made with its directories where it is not: FileStream's
+ * writes. False where it cannot be written.
+ */
+export function writeOf(path: string, bytes: Uint8Array, offset: number, length: number): boolean {
+  return attempt(() => {
+    mkdirSync(dirname(path), { recursive: true });
+    // "a+" would only append; "r+" needs the file there, which "a" makes without emptying it.
+    closeSync(openSync(path, "a"));
+    const fd = openSync(path, "r+");
+    try {
+      writeSync(fd, bytes, 0, bytes.length, offset);
+      ftruncateSync(fd, length);
+    } finally {
+      closeSync(fd);
+    }
+  });
+}
+
+/** Makes the directory at `path` and those it is in; false where it cannot. */
+export function createDirectoryOf(path: string): boolean {
+  return attempt(() => mkdirSync(path, { recursive: true }));
+}
+
+/** Removes the file or directory at `path`, with all in it; false where it cannot. */
+export function removeOf(path: string): boolean {
+  return attempt(() => rmSync(path, { recursive: true }));
+}
+
+/** Moves what is at `from` to `to`, its directories made; false where it cannot. */
+export function moveOf(from: string, to: string): boolean {
+  return attempt(() => {
+    mkdirSync(dirname(to), { recursive: true });
+    try {
+      renameSync(from, to);
+    } catch (e) {
+      // Onto another disk, which a rename cannot reach.
+      if ((e as NodeJS.ErrnoException).code !== "EXDEV") {
+        throw e;
+      }
+
+      cpSync(from, to, { recursive: true });
+      rmSync(from, { recursive: true });
+    }
+  });
+}
+
+function attempt(change: () => void): boolean {
+  try {
+    change();
+    return true;
+  } catch {
+    return false;
+  }
+}