tor-browser

fileUtil.ts (4756B)

---

/**
* @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']);
 }
}