@shotkit/shotium 0.0.1 → 0.2.0

package/src/lib/daemon.ts

@@ -0,0 +1,382 @@
+import {EventEmitter} from 'node:events';
+import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
+import path from 'node:path';
+
+import type {DaemonOptions, DaemonStatus} from '../types.js';
+
+import {resolveStartOptions} from './config.js';
+import type {ResolvedStartOptions} from './config.js';
+import {endpointFor} from './endpoint.js';
+import {Engine} from './engine.js';
+import {FrameReader, encodeFrame} from './protocol.js';
+import type {WireRequest} from './request.js';
+
+// Our own version, for status(). Read rather than imported: an import
+// attribute would do it too, but only on a node new enough that this package
+// would not run on the rest. The URL is relative to the built module, which
+// sits one directory below the manifest.
+const VERSION = (() => {
+  try {
+    const manifest =
+        fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8');
+    return (JSON.parse(manifest) as {version?: string}).version ?? '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+})();
+
+const DEFAULT_IDLE_TIMEOUT_MS = 300000;
+
+// One message off the socket. `op` defaults to screenshot because that is what
+// almost every message is.
+interface DaemonMessage {
+  id?: number|null;
+  op?: 'screenshot'|'status'|'ping'|'shutdown';
+  request?: WireRequest;
+  timeout?: number;
+  retry?: number;
+}
+
+interface DaemonReply {
+  id: number|null;
+  ok?: boolean;
+  error?: string;
+  bytes?: number;
+  path?: string;
+  stopping?: boolean;
+}
+
+// An engine that outlives the process that asked for it.
+//
+// The engine in index.ts is already resident, but only for as long as the Node
+// process holding it: a command-line invocation, a CI step, a serverless
+// handler and a `node -e` all pay for starting Blink and then throw it away.
+// This is the same engine behind a socket, so the second caller -- in a
+// different process, minutes later -- pays a connect() and nothing else.
+//
+// A request frame of JSON, answered by a header frame and a payload frame:
+//
+//   ->  [len][{"id":7,"op":"screenshot","request":{...}}]
+//   <-  [len][{"id":7,"ok":true,"bytes":97756}]  [len][<PNG>]
+//
+// `id` is on the wire so that a client may have several requests outstanding
+// on one connection. That is a convenience for the client, not concurrency:
+// there is one renderer here, because Blink is a process-wide singleton, so
+// the requests queue and come back in the order the engine finished them.
+// Wanting two at once means wanting two daemons, addressed by `name`.
+//
+// Nothing supervises a capture. The pool this replaced could time a worker out
+// and kill it; an in-process engine has no such seam -- there is no way to
+// abandon a render without abandoning the process. A page's own deadline
+// (`pageGotoParams.timeout`) is what bounds it, and the engine answers slow
+// pages by itself. `timeout` and `retry` on the wire are accepted and ignored,
+// so that an older client still talks to this.
+//
+// Events: ready, warm, request, response, idle-exit, error, close.
+class Daemon extends EventEmitter {
+  private readonly options: ResolvedStartOptions;
+  private readonly endpointPath: string;
+  private readonly idleTimeoutMs: number;
+  private readonly prewarmOnStart: boolean;
+  private readonly engine = new Engine();
+  private server: net.Server|null = null;
+  private sockets = new Set<net.Socket>();
+  private inFlight = 0;
+  private served = 0;
+  private warmed = false;
+  private startedAt = Date.now();
+  private idleTimer: NodeJS.Timeout|null = null;
+  private closing = false;
+
+  constructor(options: DaemonOptions = {}) {
+    super();
+    this.options = resolveStartOptions(options);
+    this.endpointPath = endpointFor({
+      ...this.options,
+      name: options.name,
+      endpoint: options.endpoint,
+    });
+    this.idleTimeoutMs = options.idleTimeoutMs === undefined ?
+        DEFAULT_IDLE_TIMEOUT_MS :
+        options.idleTimeoutMs;
+    this.prewarmOnStart = options.prewarm !== false;
+  }
+
+  get endpoint(): string {
+    return this.endpointPath;
+  }
+
+  get warm(): boolean {
+    return this.warmed;
+  }
+
+  // Brings the engine up and starts listening. The pipe existing *is* the
+  // readiness signal -- a client's connect() either succeeds or the daemon is
+  // not up -- so nothing is bound until the engine has started.
+  //
+  // Starting it here rather than on the first request is deliberate: a machine
+  // with no engine for its platform should fail while the caller is still
+  // watching, not answer a connect() and then reject every request on it.
+  async listen(): Promise<this> {
+    this.engine.start(this.options);
+
+    this.server = net.createServer((socket) => this.accept(socket));
+    this.server.on('error', (error) => this.emit('error', error));
+    await this.bind();
+    this.armIdleTimer();
+    this.emit('ready', {endpoint: this.endpointPath});
+    if (this.prewarmOnStart) {
+      await this.prewarm();
+    }
+    return this;
+  }
+
+  private bind(): Promise<void> {
+    return new Promise<void>((resolve, reject) => {
+      const server = this.server!;
+      const onError = (error: NodeJS.ErrnoException) => {
+        // A unix socket file outlives the process that made it, so EADDRINUSE
+        // means either a live daemon or a leftover path. Connecting is the only
+        // way to tell them apart: refused means nobody is home, and the file
+        // can go.
+        if (error.code === 'EADDRINUSE' && process.platform !== 'win32') {
+          const probe = net.connect(this.endpointPath);
+          probe.on('connect', () => {
+            probe.destroy();
+            reject(error);
+          });
+          probe.on('error', () => {
+            try {
+              fs.unlinkSync(this.endpointPath);
+            } catch {
+              reject(error);
+              return;
+            }
+            server.listen(this.endpointPath, () => {
+              this.restrict();
+              resolve();
+            });
+          });
+          return;
+        }
+        reject(error);
+      };
+      server.once('error', onError);
+      server.listen(this.endpointPath, () => {
+        server.removeListener('error', onError);
+        this.restrict();
+        resolve();
+      });
+    });
+  }
+
+  // Who may talk to this daemon.
+  //
+  // It matters because a request may set `allowFileAccess`, so a stranger who
+  // can connect can have a document read this machine's filesystem and get the
+  // result back as a picture. On POSIX the socket is a file and 0600 says only
+  // its owner may connect.
+  //
+  // On Windows it is a named pipe, and node exposes no way to give one an ACL:
+  // the default lets any account on the machine open it. A daemon on a shared
+  // Windows host is therefore as trusted as the machine's users are -- use the
+  // engine in your own process, where nothing is listening, if that is not
+  // acceptable.
+  private restrict(): void {
+    if (process.platform === 'win32') {
+      return;
+    }
+    try {
+      fs.chmodSync(this.endpointPath, 0o600);
+    } catch (error) {
+      this.emit('error', error);
+    }
+  }
+
+  // Renders one throwaway document so that the first real request does not pay
+  // for whatever the engine initialises lazily. One is enough: there is one
+  // renderer, and it is the same one every request lands on.
+  //
+  // A temporary file, not a `data:` URL. This used to send
+  // `data:text/html,...`, which the renderer rejects -- shot_capture.cc takes
+  // file, http and https and nothing else -- so every prewarm failed into the
+  // catch below and the step had never once done anything. The failure was
+  // invisible because a prewarm that does not work looks exactly like one that
+  // does, only slower on the first request.
+  //
+  // The document names no subresources, so it renders identically whether or
+  // not this daemon allows file access -- which is what the `data:` URL was
+  // reaching for. A top-level file: URL always loads; `allowFileAccess` gates
+  // what the document may then pull in.
+  async prewarm(): Promise<void> {
+    const blank = path.join(
+        os.tmpdir(), `shotium-prewarm-${process.pid}.html`);
+    try {
+      fs.writeFileSync(
+          blank, '<!doctype html><title>shotium</title><p>shotium');
+      await this.engine.capture({file: blank, width: 16, height: 16});
+      this.warmed = true;
+    } catch (error) {
+      // Not fatal: a daemon that could not prewarm still serves. But it is not
+      // warm, and status() should not claim it is.
+      this.emit('error', error);
+    } finally {
+      fs.rmSync(blank, {force: true});
+    }
+    this.emit('warm', {warm: this.warmed});
+  }
+
+  status(): DaemonStatus {
+    return {
+      ok: true,
+      pid: process.pid,
+      endpoint: this.endpointPath,
+      cacheDir: this.options.cacheDir,
+      userAgent: this.options.userAgent,
+      resourceDir: this.options.resourceDir,
+      warm: this.warmed,
+      uptimeMs: Date.now() - this.startedAt,
+      connections: this.sockets.size,
+      inFlight: this.inFlight,
+      served: this.served,
+      idleTimeoutMs: this.idleTimeoutMs,
+      version: VERSION,
+    };
+  }
+
+  private accept(socket: net.Socket): void {
+    socket.on('error', () => socket.destroy());
+    this.sockets.add(socket);
+    this.armIdleTimer();
+
+    const reader = new FrameReader();
+    socket.on('data', (chunk: Buffer) => {
+      reader.push(chunk);
+      for (;;) {
+        const frame = reader.next();
+        if (frame === null) {
+          return;
+        }
+        this.dispatch(socket, frame);
+      }
+    });
+    socket.on('close', () => {
+      this.sockets.delete(socket);
+      this.armIdleTimer();
+    });
+  }
+
+  private dispatch(socket: net.Socket, frame: Buffer): void {
+    let message: DaemonMessage;
+    try {
+      message = JSON.parse(frame.toString('utf8')) as DaemonMessage;
+    } catch {
+      this.reply(
+          socket, {id: null, ok: false, error: 'shotium: request is not JSON'});
+      return;
+    }
+
+    const id = message.id === undefined ? null : message.id;
+    const op = message.op || 'screenshot';
+    if (op === 'status') {
+      this.reply(socket, {...this.status(), id});
+      return;
+    }
+    if (op === 'ping') {
+      this.reply(socket, {id, ok: true});
+      return;
+    }
+    if (op === 'shutdown') {
+      this.reply(socket, {id, ok: true, stopping: true});
+      // After the reply is on the wire, not before: a client that asked for a
+      // shutdown is entitled to hear that it happened.
+      socket.end(() => void this.close());
+      return;
+    }
+    if (op !== 'screenshot') {
+      this.reply(socket, {id, ok: false, error: `shotium: unknown op "${op}"`});
+      return;
+    }
+
+    const request = message.request || ({} as WireRequest);
+
+    this.inFlight += 1;
+    this.armIdleTimer();
+    this.emit('request', {id, file: request.file});
+    this.engine.capture(request)
+        .then((image) => {
+          this.served += 1;
+          this.reply(
+              socket,
+              {
+                id,
+                ok: true,
+                bytes: image ? image.length : 0,
+                path: request.path,
+              },
+              image);
+        })
+        .catch((error: Error) => {
+          this.reply(
+              socket, {id, ok: false, error: String(error.message || error)});
+        })
+        .finally(() => {
+          this.inFlight -= 1;
+          this.emit('response', {id});
+          this.armIdleTimer();
+        });
+  }
+
+  private reply(
+      socket: net.Socket, header: DaemonReply|(DaemonStatus&{id: number|null}),
+      payload?: Buffer|null): void {
+    if (socket.destroyed) {
+      return;
+    }
+    socket.write(encodeFrame(Buffer.from(JSON.stringify(header), 'utf8')));
+    socket.write(encodeFrame(payload || Buffer.alloc(0)));
+  }
+
+  // Idle is "nobody connected and nothing rendering". A client that holds its
+  // socket open -- a long-lived service using connect() -- keeps the daemon
+  // alive without having to poll it.
+  private armIdleTimer(): void {
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    if (!this.idleTimeoutMs || this.closing) {
+      return;
+    }
+    if (this.sockets.size > 0 || this.inFlight > 0) {
+      return;
+    }
+    this.idleTimer = setTimeout(() => {
+      this.emit('idle-exit', {idleTimeoutMs: this.idleTimeoutMs});
+      void this.close();
+    }, this.idleTimeoutMs);
+    this.idleTimer.unref();
+  }
+
+  async close(): Promise<void> {
+    if (this.closing) {
+      return;
+    }
+    this.closing = true;
+    if (this.idleTimer) {
+      clearTimeout(this.idleTimer);
+      this.idleTimer = null;
+    }
+    for (const socket of this.sockets) {
+      socket.destroy();
+    }
+    this.sockets.clear();
+    await new Promise<void>((resolve) => this.server!.close(() => resolve()));
+    await this.engine.stop();
+    this.emit('close', {});
+  }
+}
+
+export {Daemon, DEFAULT_IDLE_TIMEOUT_MS};

package/src/lib/endpoint.ts

@@ -0,0 +1,70 @@
+import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
+
+// What endpointFor() needs to know: a resolved configuration, plus the two
+// ways of overriding the address it would derive from one.
+export interface EndpointOptions {
+  cacheDir?: string|null;
+  userAgent?: string;
+  resourceDir?: string;
+  name?: string;
+  endpoint?: string;
+}
+
+// Where a daemon listens, derived from what it was asked to be.
+//
+// The address is a hash of the configuration -- cache root, user agent,
+// resource directory -- rather than a fixed name, because attaching to
+// whatever daemon happens to be up would mean rendering with someone else's
+// settings. Two configurations are two daemons; the same configuration, from
+// any process, is one.
+//
+// Every field of EndpointOptions is optional, so nothing here fails to compile
+// when a field is dropped from the configuration -- it just stops being part
+// of the identity, and every caller collapses onto one address. That happened
+// once, when the worker pool went away and this was left hashing three fields
+// that no longer existed. If a field is added to StartOptions and it changes
+// what the engine renders, it belongs in the array below.
+//
+// A caller who wants a daemon by name instead of by configuration passes
+// `name`, which replaces the hash. That is the escape hatch for a service that
+// starts its daemon deliberately and wants clients to find it without
+// repeating the configuration.
+function endpointKey(options: EndpointOptions): string {
+  if (options.name) {
+    return String(options.name);
+  }
+  const identity = JSON.stringify([
+    options.cacheDir === null || options.cacheDir === undefined ?
+        null :
+        path.resolve(options.cacheDir),
+    options.userAgent ?? null,
+    options.resourceDir ? path.resolve(options.resourceDir) : null,
+  ]);
+  return crypto.createHash('sha256').update(identity).digest('hex').slice(0, 16);
+}
+
+// Windows has named pipes and no filesystem sockets; POSIX has the reverse.
+// Both are net.connect() addresses, which is the only reason the rest of the
+// daemon can ignore the difference.
+//
+// The pipe namespace is per-machine but the socket path is per-user, so the
+// uid goes in the POSIX name to keep two users on one host from colliding on a
+// path only one of them can open.
+function endpointFor(options: EndpointOptions = {}): string {
+  if (options.endpoint) {
+    return options.endpoint;
+  }
+  if (process.env.SHOTIUM_ENDPOINT) {
+    return process.env.SHOTIUM_ENDPOINT;
+  }
+  const key = endpointKey(options);
+  if (process.platform === 'win32') {
+    return `\\\\.\\pipe\\shotium-${key}`;
+  }
+  const uid = typeof process.getuid === 'function' ? process.getuid() : 0;
+  return path.join(os.tmpdir(), `shotium-${uid}-${key}.sock`);
+}
+
+export {endpointFor, endpointKey};

package/src/lib/engine.ts

@@ -0,0 +1,168 @@
+import * as binding from './binding.js';
+import type {Engine as Handle} from './binding.js';
+import {toRequest} from './request.js';
+import type {WireRequest} from './request.js';
+import type {PurgeOptions, ScreenshotOptions, StartOptions} from '../types.js';
+
+import {resolveStartOptions} from './config.js';
+
+// One per process, ever. Not one at a time -- one.
+//
+// This is not a rule of this file, it is what Blink is: initialising it writes
+// process-wide statics it has no path to undo, so shot_engine_destroy() gives
+// back what it can and the process still cannot make another. The C API
+// returns SHOT_ERR_STATE for a second create whether or not the first is
+// still alive. See shot/shot_api.h.
+//
+// So `stop()` is final for the process, and this flag exists to say that in
+// words at the call site. Without it a caller who stops and starts again gets
+// SHOT_ERR_STATE out of the addon -- a true error, arriving one layer too deep
+// to explain that the answer is a second process rather than a retry.
+let startedInThisProcess = false;
+
+/**
+ * Blink, in this process, and the queue in front of it.
+ *
+ * There is one renderer and there is no way to have two. Blink is a
+ * process-wide singleton: it is initialised once, there is no path to a second
+ * one, and `worker_threads` do not change that because they share the process.
+ * So captures are serialised however many callers there are, and a program
+ * that wants four at once wants four processes.
+ *
+ * The queue is not about fairness. Each capture occupies a libuv thread pool
+ * thread for as long as the render takes, and there are four of those by
+ * default, shared with fs and dns -- so letting four screenshots go at once
+ * would stall the host's file reads for a fifth of a second at a time while
+ * gaining nothing, since the engine serialises them anyway.
+ */
+export class Engine {
+  private handle: Handle|null = null;
+  private stopped = false;
+  private tail: Promise<unknown> = Promise.resolve();
+
+  get running(): boolean {
+    return this.handle !== null;
+  }
+
+  /**
+   * Starts the engine. Safe to call twice; the second call is a no-op, so that
+   * library code can call it defensively.
+   *
+   * Not safe to call after `stop()`, and not because of anything here: Blink
+   * starts once per process and cannot be restarted. Another engine means
+   * another process.
+   */
+  start(options: StartOptions = {}): this {
+    if (this.handle) {
+      return this;
+    }
+    if (this.stopped) {
+      throw new Error(
+          'shotium: this engine was stopped, and Blink cannot be started ' +
+          'again in a process that has already run it. Start another ' +
+          'process, or keep the engine up between screenshots.');
+    }
+    if (startedInThisProcess) {
+      throw new Error(
+          'shotium: an engine has already run in this process. Blink is a ' +
+          'process-wide singleton -- there is one per process, ever -- so a ' +
+          'second Runtime cannot have one. Use the shared `runtime`, or run ' +
+          'another process.');
+    }
+    const native = binding.load();
+    const resolved = resolveStartOptions(options);
+
+    const engineOptions: Record<string, unknown> = {};
+    if (resolved.cacheDir !== null) {
+      engineOptions.cacheDir = resolved.cacheDir;
+    }
+    if (resolved.userAgent !== undefined) {
+      engineOptions.userAgent = resolved.userAgent;
+    }
+    // The packs sit beside the library, and the library cannot find itself on
+    // Linux -- the path the engine resolves for "this module" goes through
+    // /proc/self/exe, which names node. Saying it here is cheaper than
+    // teaching the engine a second way to look. See shot_api.h.
+    engineOptions.resourceDir = resolved.resourceDir ?? binding.directory();
+
+    this.handle = native.create(JSON.stringify(engineOptions));
+    startedInThisProcess = true;
+    return this;
+  }
+
+  /**
+   * Stops the engine, after whatever is queued.
+   *
+   * Final for this process: see the note above. A program that will want
+   * another screenshot later should leave the engine up and call `purge()`
+   * instead, which hands back the memory without giving up the engine.
+   */
+  async stop(): Promise<void> {
+    if (!this.handle) {
+      return;
+    }
+    this.stopped = true;
+    // After the queue, not before: destroy() waits for a capture in flight
+    // anyway, and doing it in order means a caller's last screenshot resolves
+    // rather than racing the shutdown.
+    const handle = this.handle;
+    this.handle = null;
+    await this.tail.catch(() => {});
+    binding.load().destroy(handle);
+  }
+
+  /**
+   * Hands back what the engine is holding but can rebuild.
+   * `releaseWorkingSet` additionally asks the OS for the pages, which the next
+   * screenshot pays back in soft faults -- worth it when there may not be a
+   * next one soon.
+   *
+   * The daemon does this for itself on a timer because it can watch its own
+   * request stream go quiet. Here the queue belongs to the caller, so the
+   * caller is the one who knows a batch has ended.
+   */
+  purge({releaseWorkingSet = false}: PurgeOptions = {}): void {
+    if (!this.handle) {
+      return;
+    }
+    binding.load().purge(this.handle, releaseWorkingSet);
+  }
+
+  /**
+   * Renders one screenshot. Resolves to the encoded image, or to `null` when
+   * `path` was given and the engine wrote the file itself.
+   */
+  // `async` and not a plain function returning capture()'s promise: toRequest()
+  // throws, and a caller who wrote `screenshot(bad).catch(...)` would get the
+  // throw past the catch and into the surrounding frame. The whole surface is
+  // promise-shaped, so a bad request is a rejection like everything else.
+  async screenshot(options: ScreenshotOptions): Promise<Buffer|null> {
+    // Before anything else, and before the queue: a malformed request should
+    // be a rejection now rather than one that waits its turn.
+    return this.capture(toRequest(options));
+  }
+
+  /**
+   * The same, for a request that is already in wire form.
+   *
+   * The daemon reads these off a socket, where they arrived having been
+   * validated by the client that sent them. Re-deriving one from
+   * ScreenshotOptions would mean the daemon validating a request it cannot see
+   * the original of, and rejecting fields a newer client legitimately sent.
+   */
+  async capture(request: WireRequest): Promise<Buffer|null> {
+    if (!this.handle) {
+      this.start();
+    }
+    const handle = this.handle;
+    const native = binding.load();
+
+    // Chain onto the tail so that captures run one at a time. The catch keeps
+    // one failure from poisoning everything queued behind it.
+    const result = this.tail.catch(() => {}).then(
+        () => native.capture(handle, JSON.stringify(request)));
+    this.tail = result.catch(() => {});
+    const image = await result;
+    return request.path ? null : image;
+  }
+}

package/src/lib/platform.ts

@@ -0,0 +1,69 @@
+import {createRequire} from 'node:module';
+import path from 'node:path';
+
+// require.resolve is the resolver, and ESM has no synchronous equivalent
+// that answers for a package that may not be installed at all.
+const require = createRequire(import.meta.url);
+
+// Which package carries the engine for this machine.
+//
+// The engine is not in this package and cannot be: it is a Chromium build,
+// 41 MB per platform and architecture, six of them, and `npm install` is never
+// going to produce one. So the bytes live in six packages of their own and
+// this one depends on all six as optionalDependencies with `os` and `cpu` set,
+// which is npm's way of saying "install the one that matches this machine and
+// skip the other five". A machine nobody builds for installs none of them and
+// still gets a working package -- it just has to be pointed at an engine.
+//
+// The alternative, a postinstall script that downloads a tarball, was not
+// chosen. It defeats a lockfile, which is supposed to pin what you get; it
+// fails behind a registry mirror, which is the one place a large dependency
+// most needs to work; and it runs code at install time in exchange for saving
+// nothing that npm was not already doing.
+//
+// Key and name are both `${process.platform}-${process.arch}`, so the table is
+// the identity map with a prefix on it. That is deliberate: the value npm
+// matches `os` and `cpu` against is process.platform, and a package named for
+// anything else makes the reader hold two spellings of one machine in their
+// head. It is also what every other package of this shape does -- esbuild,
+// swc, lightningcss all publish darwin-arm64 and win32-x64.
+//
+// The release archives spell it win/mac instead -- shotium-mac-arm64.7z --
+// and that is not going to change either. They are downloaded by people, and
+// `mac` is what people call it. So the two spellings do differ, in the one
+// place where each is right: the registry gets node's, the download page gets
+// the reader's.
+const PACKAGES: Readonly<Record<string, string>> = {
+  'win32-x64': '@shotkit/shotium-win32-x64',
+  'win32-arm64': '@shotkit/shotium-win32-arm64',
+  'darwin-x64': '@shotkit/shotium-darwin-x64',
+  'darwin-arm64': '@shotkit/shotium-darwin-arm64',
+  'linux-x64': '@shotkit/shotium-linux-x64',
+  'linux-arm64': '@shotkit/shotium-linux-arm64',
+};
+
+function packageName(
+    platform: string = process.platform,
+    arch: string = process.arch): string|null {
+  return PACKAGES[`${platform}-${arch}`] ?? null;
+}
+
+// Where the matching platform package unpacked, or null if it is not installed.
+//
+// require.resolve rather than a path built from the module's own location: the
+// package can be hoisted to a workspace root, nested under this one, or left
+// in a pnpm store with a symlink pointing at it, and the resolver is the only
+// thing that knows which of those happened.
+function packageDir(): string|null {
+  const name = packageName();
+  if (!name) {
+    return null;
+  }
+  try {
+    return path.dirname(require.resolve(`${name}/package.json`));
+  } catch {
+    return null;
+  }
+}
+
+export {PACKAGES, packageDir, packageName};