@swf2es/cli 0.0.0-stage → 0.1.0

package/src/commands/run.ts

@@ -0,0 +1,131 @@
+// swf2es run: ABCs run as avmshell runs them, each compiled by codegen and
+// loaded into the runtime, their trace and print on stdout.
+import { readFileSync, statSync, writeFileSync, writeSync } from "node:fs";
+import { basename, extname, resolve } from "node:path";
+import { parseArgs } from "node:util";
+import { createCodegen } from "@swf2es/codegen";
+import { builtinLibrary, createRuntime, type ShellFiles } from "@swf2es/runtime/avm2";
+import { InputError, RejectedError, readInput } from "../aot.js";
+import { COMMON_OPTIONS, COMMON_USAGE, type Command, parse } from "../args.js";
+import { codegenModule, read, readLibraries } from "../files.js";
+import { fail, usageError } from "../output.js";
+import { runShell } from "../shell.js";
+import { shellToplevelLibrary } from "../shell-toplevel-library.js";
+import { nodeShellThreads } from "../threads.js";
+
+const USAGE = `usage: swf2es run <file.abc> [more.abc ...] [options]
+
+Runs ABCs as avmshell does: its libraries first, their scripts run on
+first use, then each ABC in the order given, in one domain, its entry
+point run once it loads. What they trace and print goes to stdout. An ABC
+rejected with a VerifyError, or an exception nothing catches, is printed
+there too, as avmshell prints it, and ends the run; the ABCs after it do
+not run. avmshell's File reads and writes in the working directory, and
+its workers run on threads of their own, stopped when the ABCs end.
+
+options:
+  --lib <file.abc>     a library to load first, into the root domain, in
+                       the order given; repeat for each. Default:
+                       avmshell's builtin.abc and shell_toplevel.abc,
+                       which swf2es ships
+${COMMON_USAGE}
+
+exit status: 0 when every ABC ran to its end, 1 as avmshell's for a
+VerifyError or an uncaught exception, 2 for a mistake in the command line,
+and 1 for what stopped it besides (an unreadable input or library, a SWF,
+a library rejected, an error of swf2es' own), said on stderr`;
+
+/** avmshell's libraries, as its own build has them. */
+const SHELL_LIBRARIES = [
+  { name: "builtin", abc: builtinLibrary },
+  { name: "shell_toplevel", abc: shellToplevelLibrary },
+];
+
+const SWF_SIGNATURES = new Set(["FWS", "CWS", "ZWS"]);
+
+const OPTIONS = {
+  lib: { type: "string", multiple: true },
+  ...COMMON_OPTIONS,
+} as const;
+
+/** avmshell's File: the working directory's files, as it reads and writes them. */
+function workingFiles(): ShellFiles {
+  return {
+    read(name) {
+      // One it cannot open, unreadable or a directory, avmshell's File cannot
+      // open either: Error #1500 for the ABC to catch, not swf2es failing.
+      try {
+        const path = resolve(name);
+        return statSync(path).isFile() ? new Uint8Array(readFileSync(path)) : null;
+      } catch {
+        return null;
+      }
+    },
+    write(name, bytes) {
+      try {
+        writeFileSync(resolve(name), bytes);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+  };
+}
+
+export const run: Command = {
+  name: "run",
+  summary: "run ABCs as avmshell does, printing what they trace",
+  usage: USAGE,
+  async main(argv) {
+    const parsed = parse(run, () =>
+      parseArgs({ args: argv, allowPositionals: true, options: OPTIONS }),
+    );
+    if (!parsed) {
+      return;
+    }
+
+    const { values, positionals } = parsed;
+    if (positionals.length === 0) {
+      usageError("expected an ABC file to run", "run");
+    }
+
+    const abcs: { name: string; abc: Uint8Array }[] = [];
+    for (const file of positionals) {
+      const abc = await read(file, "input");
+      if (SWF_SIGNATURES.has(String.fromCharCode(...abc.subarray(0, 3)))) {
+        fail(`${file}: a SWF; run takes ABCs, as a SWF's code needs the player's playerglobal`);
+      }
+
+      try {
+        readInput(abc);
+      } catch (e) {
+        fail(e instanceof InputError ? `${file}: ${e.message}` : String(e));
+      }
+
+      abcs.push({ name: basename(file, extname(file)), abc });
+    }
+
+    const libs = values.lib ? await readLibraries(values.lib) : SHELL_LIBRARIES;
+    const codegen = await codegenModule();
+    const compiler = await createCodegen(codegen);
+    // A line at a time, as avmshell's console writes it; its workers' threads write their own.
+    const print = (line: string) => writeSync(1, `${line}\n`);
+    const threads = nodeShellThreads({ codegen, libraries: libs, abcs });
+    try {
+      process.exitCode = await runShell(libs, abcs, {
+        compiler,
+        createRuntime,
+        print,
+        files: workingFiles(),
+        workers: threads.host,
+      });
+      await threads.close();
+    } catch (e) {
+      if (e instanceof RejectedError) {
+        fail(e.message);
+      }
+
+      fail(`swf2es itself failed: ${(e as Error).stack ?? e}`);
+    }
+  },
+};

package/src/files.ts

@@ -0,0 +1,38 @@
+// Reading the commands' inputs and writing their outputs, a failure said
+// as such rather than as a stack.
+import { readFile } from "node:fs/promises";
+import { basename, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { fail } from "./output.js";
+
+export async function read(path: string, what: string): Promise<Uint8Array> {
+  try {
+    return new Uint8Array(await readFile(path));
+  } catch (e) {
+    fail(`cannot read ${what} ${path}: ${(e as NodeJS.ErrnoException).code ?? e}`);
+  }
+}
+
+export async function writing(path: string, write: () => Promise<unknown>): Promise<void> {
+  try {
+    await write();
+  } catch (e) {
+    fail(`cannot write ${path}: ${(e as NodeJS.ErrnoException).code ?? e}`);
+  }
+}
+
+/** The libraries at `paths`, read, each named by its file. */
+export function readLibraries(paths: string[]): Promise<{ name: string; abc: Uint8Array }[]> {
+  return Promise.all(
+    paths.map(async (path) => ({
+      name: basename(path, extname(path)),
+      abc: await read(path, "library"),
+    })),
+  );
+}
+
+/** The release codegen.wasm, compiled. */
+export async function codegenModule(): Promise<WebAssembly.Module> {
+  const path = fileURLToPath(import.meta.resolve("@swf2es/codegen/codegen.wasm"));
+  return WebAssembly.compile(await readFile(path));
+}

package/src/index.ts

@@ -0,0 +1,25 @@
+/** The ahead-of-time compiler and avmshell's way of running ABCs as a library, for a host that does without the command. */
+export {
+  type AbcInput,
+  type ActionsModule,
+  AIR_API_VERSION,
+  API_VERSION,
+  type Avm1Input,
+  compileActionsAhead,
+  compileAhead,
+  type Input,
+  type Module,
+  RejectedError,
+  readInput,
+  sha256,
+} from "./aot.js";
+export {
+  evaluateModule,
+  runShell,
+  type ShellCompiler,
+  type ShellLibrary,
+  type ShellModule,
+  type ShellOptions,
+  shellDomain,
+} from "./shell.js";
+export { nodeShellThreads, type ShellThreads, type ShellThreadsOptions } from "./threads.js";

package/src/main.ts

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+// The swf2es command: the first argument names a command, and any other
+// first argument is compile's input, as before there were commands.
+import { existsSync } from "node:fs";
+import { printVersion } from "./args.js";
+import { compile } from "./commands/compile.js";
+import { commands, usage } from "./commands/help.js";
+import { USAGE_ERROR, usageError } from "./output.js";
+
+async function main(argv: string[]): Promise<void> {
+  const [first, ...rest] = argv;
+  const command = commands.get(first);
+  if (command) {
+    await command.main(rest);
+    return;
+  }
+
+  switch (first) {
+    case undefined:
+      process.stderr.write(`${usage()}\n`);
+      process.exitCode = USAGE_ERROR;
+      return;
+    case "-h":
+    case "--help":
+      if (rest.length === 0) {
+        console.log(usage());
+        return;
+      }
+
+      break;
+    case "-v":
+    case "--version":
+      if (rest.length === 0) {
+        printVersion();
+        return;
+      }
+
+      break;
+  }
+
+  // An option before the input, as `swf2es -o dir file.swf`, is compile's
+  // too; a word that is no command nor a file is taken for a mistyped command.
+  if (first.startsWith("-") || /[./\\]/.test(first) || existsSync(first)) {
+    await compile.main(argv);
+    return;
+  }
+
+  usageError(`no command ${first}; to compile a file of that name, swf2es compile ${first}`);
+}
+
+await main(process.argv.slice(2));

package/src/output.ts

@@ -0,0 +1,23 @@
+// What the command says about itself on stderr. styleText colours only a
+// terminal that takes colour: not with NO_COLOR, nor when stderr is a pipe
+// or a file, unless FORCE_COLOR asks.
+import { styleText } from "node:util";
+
+/** The exit status for a mistake in how the command was run. */
+export const USAGE_ERROR = 2;
+
+/** Say what went wrong, and a hint on another line if there is one, and exit. */
+export function fail(message: string, status = 1, hint?: string): never {
+  const head = styleText(["bold", "red"], "error:", { stream: process.stderr });
+  process.stderr.write(`swf2es: ${head} ${message}\n`);
+  if (hint) {
+    process.stderr.write(`${styleText("dim", hint, { stream: process.stderr })}\n`);
+  }
+
+  process.exit(status);
+}
+
+/** A mistake in the command line, with where to read how to run it. */
+export function usageError(message: string, command?: string): never {
+  fail(message, USAGE_ERROR, `run swf2es help${command ? ` ${command}` : ""} for usage`);
+}

package/src/shell-memories.ts

@@ -0,0 +1,35 @@
+// The shared memory of a primordial's threads, kept by a thread of its own
+// (threads.ts): every shareable ByteArray's memory a thread shares is
+// posted on the group's BroadcastChannel, which this thread, its event
+// loop always free, keeps, and answers a thread that asks for one it
+// missed, as one does that was still starting when the memory was shared.
+import { workerData } from "node:worker_threads";
+import type { SharedBytesMemory } from "@swf2es/runtime/avm2";
+import type { MemoriesData, MemoryMessage } from "./threads.js";
+
+const { group, memories: seen, ready } = workerData as MemoriesData;
+const memories = new Map<number, SharedBytesMemory>(seen.map((m) => [m.id, m]));
+const channel = new BroadcastChannel(group);
+channel.onmessage = (event) => {
+  const message = (event as unknown as { data: MemoryMessage }).data;
+  switch (message.type) {
+    case "memory":
+      memories.set(message.memory.id, message.memory);
+      break;
+    case "ask":
+      channel.postMessage({
+        type: "answer",
+        id: message.id,
+        memory: memories.get(message.id) ?? null,
+      } satisfies MemoryMessage);
+      Atomics.store(message.answered, 0, 1);
+      Atomics.notify(message.answered, 0);
+      break;
+    case "answer":
+      break;
+  }
+};
+
+// Subscribed: the threads may start.
+Atomics.store(ready, 0, 1);
+Atomics.notify(ready, 0);

package/src/shell-thread.ts

@@ -0,0 +1,54 @@
+// A background worker's thread (threads.ts): its ABCs, or the primordial's,
+// run after the libraries as runShell runs them, in a runtime that is the
+// worker's; the workers it starts run on threads of its own, which it waits
+// for once its code ends, as they outlive it in avmshell.
+import { writeSync } from "node:fs";
+import { parentPort, workerData } from "node:worker_threads";
+import { createCodegen } from "@swf2es/codegen";
+import {
+  createRuntime,
+  endShellWorker,
+  shellWorkerTerminated,
+  startShellWorker,
+} from "@swf2es/runtime/avm2";
+import { runShell } from "./shell.js";
+import { nodeShellThreads, type ShellThreadData } from "./threads.js";
+
+const { codegen, libraries, abcs, init, post, group, memories, apiVersion } =
+  workerData as ShellThreadData;
+const print = post
+  ? (line: string) => parentPort?.postMessage(line)
+  : (line: string) => writeSync(1, `${line}\n`);
+
+if (startShellWorker(init)) {
+  const threads = nodeShellThreads({
+    codegen,
+    libraries,
+    abcs,
+    group,
+    memories,
+    apiVersion,
+    ...(post ? { print } : {}),
+  });
+  let exception = true;
+  try {
+    const code = init.code ? [{ name: `worker-${init.id}`, abc: init.code }] : abcs;
+    const exitCode = await runShell(libraries, code, {
+      compiler: await createCodegen(codegen),
+      createRuntime,
+      print,
+      workers: threads.host,
+      worker: init,
+      apiVersion,
+    });
+    exception = exitCode !== 0;
+  } catch (e) {
+    // Terminated by another worker, its code stops where it was.
+    if (!shellWorkerTerminated(init)) {
+      print(`swf2es: a background worker failed: ${(e as Error).stack ?? e}`);
+    }
+  } finally {
+    endShellWorker(init, exception);
+    await threads.ended();
+  }
+}

package/src/shell-toplevel-library.ts

@@ -0,0 +1,28 @@
+// avmplus' shell_toplevel.abc: avmshell's own classes, which `swf2es run` loads after builtin.
+// Generated by tools/avmplus-libraries.ts --update; not to be edited.
+//
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+//
+// Its source form is the ActionScript in shell/ and extensions/ (Sampler.as, Trace.as)
+// of avmplus, https://github.com/swf2es/avmplus at commit
+// 858d034a3bd3a54d9b70909386435cf4aec81d21,
+// which shell/shell_toplevel.py compiles into generated/shell_toplevel.abc.
+
+declare function atob(data: string): string;
+
+/** Base64 to bytes with a plain loop: Uint8Array.from with a callback takes some 8 times as long. */
+function decode(text: string): Uint8Array {
+  const raw = atob(text);
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i++) {
+    bytes[i] = raw.charCodeAt(i);
+  }
+
+  return bytes;
+}
+
+export const shellToplevelLibrary: Uint8Array = decode(
+  "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",
+);

package/src/shell.ts

@@ -0,0 +1,211 @@
+// avmshell's way of running ABCs, in node: the libraries it loads (builtin
+// and shell_toplevel), their scripts run on first use, then each ABC given,
+// added to the same domain and its entry point run, until one throws. One
+// compiler domain serves the one runtime, each ABC compiled in the
+// application domain the runtime loads it into, so that an ABC
+// Domain.loadBytes loads compiles against what its domain sees, a
+// sibling's ABCs left out.
+import { createHash } from "node:crypto";
+import { API_VERSION, type Codegen } from "@swf2es/codegen";
+import type {
+  Abc,
+  CompileUnit,
+  Runtime,
+  RuntimeOptions,
+  ShellFiles,
+  ShellWorkerHost,
+  ShellWorkerInit,
+  Value,
+} from "@swf2es/runtime/avm2";
+import { floatLibrary, hasFloatLibrary } from "@swf2es/runtime/avm2";
+import { RejectedError } from "./aot.js";
+
+/** What the shell needs of a compiler: a Codegen, or a build of it for tests. */
+export type ShellCompiler = Pick<
+  Codegen,
+  "reset" | "add" | "childDomain" | "found" | "compileModule"
+>;
+
+/** A module the compiler wrote, loaded: run with a runtime, it gives the ABC. */
+export type ShellModule = (rt: Runtime) => Abc;
+
+export interface ShellLibrary {
+  name: string;
+  abc: Uint8Array;
+  /** Its module, compiled before for the same libraries before it: linked again but not compiled. */
+  module?: ShellModule;
+}
+
+export interface ShellOptions {
+  compiler: ShellCompiler;
+  /** The runtime's createRuntime, or another build's. */
+  createRuntime: (options: RuntimeOptions) => Runtime;
+  /** Where trace and print write a line. */
+  print: (line: string) => void;
+  /** Where avmshell's File reads and writes; the runtime keeps them in memory by default. */
+  files?: ShellFiles;
+  /**
+   * Load a module the compiler has just written, `name` naming its script
+   * (which Runtime.codeDomain tells domains by); by default evaluated as a
+   * script of its own.
+   */
+  load?: (js: string, name: string) => ShellModule | Promise<ShellModule>;
+  /** What starts the background workers' threads (RuntimeOptions.workers), as nodeShellThreads does. */
+  workers?: ShellWorkerHost;
+  /** The background worker these ABCs run as, in the thread its host started (RuntimeOptions.worker). */
+  worker?: ShellWorkerInit;
+  /**
+   * The ABCs' API version, as avmshell's -api gives it, whose series is
+   * the run's: Flash Player's latest, 50, by default.
+   */
+  apiVersion?: number;
+}
+
+const sha256 = (bytes: Uint8Array) => createHash("sha256").update(bytes).digest("hex");
+
+/** A module's source as a script of its own: its default export returned, `name` its sourceURL. */
+export function evaluateModule(js: string, name: string): ShellModule {
+  // Strict, as a module is: a sloppy function boxes a primitive `this`, such
+  // as the string a String method is called on.
+  const script = `"use strict";${js.replace(/^export default /, "return ")}//# sourceURL=${name}\n`;
+  return new Function(script)();
+}
+
+/**
+ * The compiler for one runtime: the libraries and ABCs added to the root
+ * domain, and RuntimeOptions.compileAbc for those Domain.loadBytes loads.
+ */
+export function shellDomain(compiler: ShellCompiler, apiVersion = API_VERSION) {
+  // The compiler's number for each of the runtime's domains, and the
+  // compiler's index of each ABC loaded into one, in load order.
+  const domains = new Map<number, number>([[0, 0]]);
+  const abcs = new Map<number, number[]>([[0, []]]);
+  // The findings each domain has been told, reported once.
+  const reported = new Map<number, Set<string>>();
+  // Every ABC's hash, in load order, as the compiler names a module's.
+  const hashes: string[] = [];
+  let added = 0;
+  let evaluated = 0;
+
+  compiler.reset(apiVersion);
+
+  /** Add an ABC to the runtime's domain `domain`: 0, or the VerifyError it was rejected with. */
+  const add = (bytes: Uint8Array, builtin: boolean, domain = 0): number => {
+    const error = compiler.add(bytes, builtin, domains.get(domain));
+    if (!error) {
+      abcs.get(domain)?.push(added++);
+      hashes.push(sha256(bytes));
+    }
+
+    return error;
+  };
+
+  return {
+    /** Add an ABC to the root domain, as avmshell loads its libraries and the ABCs it runs. */
+    add: (bytes: Uint8Array, builtin: boolean): number => add(bytes, builtin),
+    /** The module of the ABC added last. */
+    compile: (): string => compiler.compileModule(hashes),
+    /** RuntimeOptions.compileAbc: `bytes` compiled into the unit's domain, evaluated at once. */
+    compileAbc(bytes: Uint8Array, unit: CompileUnit): ShellModule | number {
+      for (let i = unit.domains.length - 2; i >= 0; i--) {
+        const id = unit.domains[i];
+        if (!domains.has(id)) {
+          domains.set(id, compiler.childDomain(domains.get(unit.domains[i + 1]) ?? 0));
+          abcs.set(id, []);
+        }
+      }
+
+      const domain = unit.domains[0];
+      const at = domains.get(domain) ?? 0;
+      const told = reported.get(domain) ?? new Set<string>();
+      reported.set(domain, told);
+      for (const f of unit.found) {
+        const key = JSON.stringify([f.asType, f.nsKind, f.uri, f.name, f.domain, f.index]);
+        const abc = abcs.get(f.domain)?.[f.index];
+        if (abc !== undefined && !told.has(key)) {
+          told.add(key);
+          const { nsKind, uri, name, asType } = f;
+          compiler.found({ domain: at, nsKind, uri, name, abc, asType });
+        }
+      }
+
+      const error = add(bytes, false, domain);
+      if (error) {
+        return error;
+      }
+
+      // A script of its own, by which Runtime.codeDomain finds its frames.
+      return evaluateModule(compiler.compileModule(hashes), `loaded-${evaluated++}.js`);
+    },
+  };
+}
+
+/**
+ * Run `abcs` after `libraries` as avmshell runs them, printing what they
+ * trace: avmshell's exit status, 0, or 1 once an ABC is rejected, with
+ * its VerifyError, or throws an exception nothing catches, printed as its
+ * string; the ABCs after it do not run. A library's rejection throws a
+ * RejectedError, and an error of the host's, a JavaScript Error, is thrown.
+ */
+export async function runShell(
+  libraries: ShellLibrary[],
+  abcs: { name: string; abc: Uint8Array }[],
+  options: ShellOptions,
+): Promise<number> {
+  if (
+    abcs.some(
+      ({ abc }) =>
+        abc.length >= 4 && abc[2] === 47 && abc[3] === 0 && (abc[0] | (abc[1] << 8)) >= 16,
+    ) &&
+    !hasFloatLibrary(libraries.map((lib) => lib.abc))
+  ) {
+    libraries = [...libraries, { name: "float", abc: floatLibrary }];
+  }
+
+  const { print } = options;
+  const load = options.load ?? evaluateModule;
+  const apiVersion = options.apiVersion ?? API_VERSION;
+  const domain = shellDomain(options.compiler, apiVersion);
+  const rt = options.createRuntime({
+    print,
+    apiVersion,
+    // Domain.loadBytes runs the ABC at once, so its module is evaluated, not imported.
+    compileAbc: (bytes, unit) => domain.compileAbc(bytes, unit),
+    ...(options.files ? { files: options.files } : {}),
+    ...(options.workers ? { workers: options.workers } : {}),
+    ...(options.worker ? { worker: options.worker } : {}),
+  });
+
+  for (const { name, abc, module } of libraries) {
+    const error = domain.add(abc, true);
+    if (error) {
+      throw new RejectedError(`library ${name}`, error, true);
+    }
+
+    // The libraries' scripts run on first use, as avmshell's builtins do.
+    (module ?? (await load(domain.compile(), `${name}.js`)))(rt);
+  }
+
+  for (const { name, abc } of abcs) {
+    const error = domain.add(abc, false);
+    if (error) {
+      print(`VerifyError: Error #${error}`);
+      return 1;
+    }
+
+    const loaded = (await load(domain.compile(), `${name}.js`))(rt);
+    try {
+      rt.run(loaded);
+    } catch (e) {
+      // An AS3 exception nothing caught: avmshell prints it, as its string, and exits with 1.
+      if (e instanceof Error) {
+        throw e;
+      }
+
+      print(rt.toString(e as Value));
+      return 1;
+    }
+  }
+
+  return 0;
+}