Update dashboard, kb, memory +4 more (+28 ~18 -1)

node_modules/@puppeteer/browsers/src/fileUtil.ts

@@ -0,0 +1,183 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import type {ChildProcessByStdio} from 'node:child_process';
+import {spawnSync, spawn} from 'node:child_process';
+import {createReadStream} from 'node:fs';
+import {mkdir, readdir} from 'node:fs/promises';
+import * as path from 'node:path';
+import type {Readable, Transform, Writable} from 'node:stream';
+import {Stream} from 'node:stream';
+
+import debug from 'debug';
+
+const debugFileUtil = debug('puppeteer:browsers:fileUtil');
+
+/**
+ * @internal
+ */
+export async function unpackArchive(
+  archivePath: string,
+  folderPath: string,
+): Promise<void> {
+  if (!path.isAbsolute(folderPath)) {
+    folderPath = path.resolve(process.cwd(), folderPath);
+  }
+  if (archivePath.endsWith('.zip')) {
+    const extractZip = await import('extract-zip');
+    await extractZip.default(archivePath, {dir: folderPath});
+  } else if (archivePath.endsWith('.tar.bz2')) {
+    await extractTar(archivePath, folderPath, 'bzip2');
+  } else if (archivePath.endsWith('.dmg')) {
+    await mkdir(folderPath);
+    await installDMG(archivePath, folderPath);
+  } else if (archivePath.endsWith('.exe')) {
+    // Firefox on Windows.
+    const result = spawnSync(archivePath, [`/ExtractDir=${folderPath}`], {
+      env: {
+        __compat_layer: 'RunAsInvoker',
+      },
+    });
+    if (result.status !== 0) {
+      throw new Error(
+        `Failed to extract ${archivePath} to ${folderPath}: ${result.output}`,
+      );
+    }
+  } else if (archivePath.endsWith('.tar.xz')) {
+    await extractTar(archivePath, folderPath, 'xz');
+  } else {
+    throw new Error(`Unsupported archive format: ${archivePath}`);
+  }
+}
+
+function createTransformStream(
+  child: ChildProcessByStdio<Writable, Readable, null>,
+): Transform {
+  const stream = new Stream.Transform({
+    transform(chunk, encoding, callback) {
+      if (!child.stdin.write(chunk, encoding)) {
+        child.stdin.once('drain', callback);
+      } else {
+        callback();
+      }
+    },
+
+    flush(callback) {
+      if (child.stdout.destroyed) {
+        callback();
+      } else {
+        child.stdin.end();
+        child.stdout.on('close', callback);
+      }
+    },
+  });
+
+  child.stdin.on('error', e => {
+    if ('code' in e && e.code === 'EPIPE') {
+      // finished before reading the file finished (i.e. head)
+      stream.emit('end');
+    } else {
+      stream.destroy(e);
+    }
+  });
+
+  child.stdout
+    .on('data', data => {
+      return stream.push(data);
+    })
+    .on('error', e => {
+      return stream.destroy(e);
+    });
+
+  child.once('close', () => {
+    return stream.end();
+  });
+
+  return stream;
+}
+
+/**
+ * @internal
+ */
+export const internalConstantsForTesting = {
+  xz: 'xz',
+  bzip2: 'bzip2',
+};
+
+/**
+ * @internal
+ */
+async function extractTar(
+  tarPath: string,
+  folderPath: string,
+  decompressUtilityName: keyof typeof internalConstantsForTesting,
+): Promise<void> {
+  const tarFs = await import('tar-fs');
+  return await new Promise<void>((fulfill, reject) => {
+    function handleError(utilityName: string) {
+      return (error: Error) => {
+        if ('code' in error && error.code === 'ENOENT') {
+          error = new Error(
+            `\`${utilityName}\` utility is required to unpack this archive`,
+            {
+              cause: error,
+            },
+          );
+        }
+        reject(error);
+      };
+    }
+    const unpack = spawn(
+      internalConstantsForTesting[decompressUtilityName],
+      ['-d'],
+      {
+        stdio: ['pipe', 'pipe', 'inherit'],
+      },
+    )
+      .once('error', handleError(decompressUtilityName))
+      .once('exit', code => {
+        debugFileUtil(`${decompressUtilityName} exited, code=${code}`);
+      });
+
+    const tar = tarFs.extract(folderPath);
+    tar.once('error', handleError('tar'));
+    tar.once('finish', fulfill);
+    createReadStream(tarPath).pipe(createTransformStream(unpack)).pipe(tar);
+  });
+}
+
+/**
+ * @internal
+ */
+async function installDMG(dmgPath: string, folderPath: string): Promise<void> {
+  const {stdout} = spawnSync(`hdiutil`, [
+    'attach',
+    '-nobrowse',
+    '-noautoopen',
+    dmgPath,
+  ]);
+
+  const volumes = stdout.toString('utf8').match(/\/Volumes\/(.*)/m);
+  if (!volumes) {
+    throw new Error(`Could not find volume path in ${stdout}`);
+  }
+  const mountPath = volumes[0]!;
+
+  try {
+    const fileNames = await readdir(mountPath);
+    const appName = fileNames.find(item => {
+      return typeof item === 'string' && item.endsWith('.app');
+    });
+    if (!appName) {
+      throw new Error(`Cannot find app in ${mountPath}`);
+    }
+    const mountedPath = path.join(mountPath!, appName);
+
+    spawnSync('cp', ['-R', mountedPath, folderPath]);
+  } finally {
+    spawnSync('hdiutil', ['detach', mountPath, '-quiet']);
+  }
+}