node_modules/@puppeteer/browsers/lib/fileUtil.js - devtools/devtools-frontend - Git at Google

 /**
  * @license
  * Copyright 2023 Google Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
 import { spawnSync, spawn, execFile } from 'node:child_process';
 import { constants, createReadStream, createWriteStream } from 'node:fs';
 import { mkdir, readdir, symlink } from 'node:fs/promises';
 import * as path from 'node:path';
 import { Stream, Writable } from 'node:stream';
 import { pipeline } from 'node:stream/promises';
 import { promisify } from 'node:util';
 import { debug } from './debug.js';
 const execFileAsync = promisify(execFile);
 const debugFileUtil = debug('puppeteer:browsers:fileUtil');
 /**
  * @internal
  */
 export async function unpackArchive(archivePath, folderPath) {
     if (!path.isAbsolute(folderPath)) {
         folderPath = path.resolve(process.cwd(), folderPath);
     }
     if (archivePath.endsWith('.zip')) {
         await mkdir(folderPath, { recursive: true });
         await extractZip(archivePath, 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) {
     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, folderPath, decompressUtilityName) {
     const { unpackTar } = await import('modern-tar/fs');
     return await new Promise((fulfill, reject) => {
         function handleError(utilityName) {
             return (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 = unpackTar(folderPath);
         tar.once('error', handleError('tar'));
         tar.once('finish', fulfill);
         createReadStream(tarPath).pipe(createTransformStream(unpack)).pipe(tar);
     });
 }
 /**
  * @internal
  */
 async function installDMG(dmgPath, folderPath) {
     const { stdout } = await execFileAsync('hdiutil', [
         'attach',
         '-nobrowse',
         '-noautoopen',
         dmgPath,
     ]);
     const volumes = stdout.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);
         await execFileAsync('cp', ['-R', mountedPath, folderPath]);
     }
     finally {
         await execFileAsync('hdiutil', ['detach', mountPath, '-quiet']);
     }
 }
 /**
  * @internal
  */
 class ArchiverUnavailableError extends Error {
 }
 /**
  * @internal
  */
 async function extractZip(archivePath, folderPath) {
     for (const extract of [extractZipWithCli, extractZipWithYauzl]) {
         try {
             await extract(archivePath, folderPath);
             return;
         }
         catch (error) {
             if (!(error instanceof ArchiverUnavailableError)) {
                 throw error;
             }
         }
     }
     throw new Error(`Extraction failed: no zip archiver is available. Install \`unzip\` (or \`tar.exe\`/Powershell on Windows), or add the optional \`yauzl\` dependency.`);
 }
 /**
  * @internal
  */
 export async function extractZipWithYauzl(archivePath, folderPath) {
     const { default: yauzl } = await import(
     /* webpackIgnore: true */ 'yauzl').catch(() => {
         throw new ArchiverUnavailableError('Extraction failed: The optional `yauzl` dependency is not installed.');
     });
     const open = promisify(yauzl.open);
     try {
         const zipFile = await open(archivePath, { lazyEntries: true });
         await new Promise((resolve, reject) => {
             zipFile
                 .on('error', reject)
                 .on('end', resolve)
                 .on('entry', entry => {
                 extractZipEntry(zipFile, entry, folderPath).then(() => {
                     zipFile.readEntry();
                 }, reject);
             })
                 .readEntry();
         });
     }
     catch (error) {
         throw new Error(`Extraction failed: ${archivePath}`, { cause: error });
     }
 }
 /**
  * @internal
  */
 async function extractZipWithCli(archivePath, folderPath) {
     try {
         if (process.platform === 'win32') {
             const systemRoot = process.env['SystemRoot'] ?? process.env['SYSTEMROOT'] ?? 'C:\\Windows';
             try {
                 const systemTar = `${systemRoot}\\System32\\tar.exe`;
                 // -x: extract files
                 // -f: specify the archive file
                 // -C: extract to the specified directory
                 await execFileAsync(systemTar, ['-xf', archivePath, '-C', folderPath]);
                 return;
             }
             catch (tarError) {
                 debugFileUtil?.(`tar.exe extraction failed: ${tarError}`);
             }
             try {
                 await execFileAsync('powershell.exe', [
                     '-NoProfile',
                     '-NonInteractive',
                     '-Command',
                     '& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
                     archivePath,
                     folderPath,
                 ]);
                 return;
             }
             catch (powershellError) {
                 debugFileUtil?.(`powershell.exe extraction failed: ${powershellError}`);
             }
             await execFileAsync('pwsh.exe', [
                 '-NoProfile',
                 '-NonInteractive',
                 '-Command',
                 '& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
                 archivePath,
                 folderPath,
             ]);
         }
         else {
             // -o: overwrite existing files without prompting
             // -d: extract files into the specified directory
             await execFileAsync('unzip', ['-o', archivePath, '-d', folderPath]);
         }
     }
     catch (error) {
         if (error?.code === 'ENOENT') {
             throw new ArchiverUnavailableError(`Extraction failed: Required native binary ('tar.exe', 'powershell.exe', 'pwsh.exe' or 'unzip') was not found in the system PATH.`);
         }
         throw new Error(`Extraction failed: ${error?.stderr?.toString() || error?.message}`);
     }
 }
 /**
  * @internal
  */
 function isInsideDirectory(directory, candidate) {
     const resolvedDirectory = path.resolve(directory);
     const resolvedCandidate = path.resolve(candidate);
     return (resolvedCandidate === resolvedDirectory ||
         resolvedCandidate.startsWith(resolvedDirectory + path.sep));
 }
 /**
  * @internal
  */
 async function extractZipEntry(zipFile, entry, folderPath) {
     const { S_IFMT, S_IFDIR, S_IFLNK } = constants;
     // see https://github.com/max-mapper/extract-zip/blob/v2.0.1/index.js#L90-L107
     const unixMode = entry.externalFileAttributes >>> 16;
     const isDirectory = (unixMode & S_IFMT) === S_IFDIR ||
         entry.fileName.endsWith('/') ||
         (entry.versionMadeBy >> 8 === 0 && entry.externalFileAttributes === 0x10);
     const isSymlink = (unixMode & S_IFMT) === S_IFLNK;
     // Fall back to sensible defaults for archives without Unix attributes.
     const mode = unixMode === 0 ? (isDirectory ? 0o755 : 0o644) : unixMode & 0o777;
     const destination = path.join(folderPath, entry.fileName);
     if (isDirectory) {
         await mkdir(destination, { recursive: true, mode });
         return;
     }
     await mkdir(path.dirname(destination), { recursive: true });
     const readStream = await promisify(zipFile.openReadStream.bind(zipFile))(entry);
     if (isSymlink) {
         // Consume the symlink target in pipe semantics rather than via async
         // iteration (e.g. stream/consumers `text()`): yauzl <3.3.1 read streams
         // never emit "close", which hangs consumers (thejoshwolfe/yauzl#169)
         const chunks = [];
         await pipeline(readStream, new Writable({
             write(chunk, _encoding, callback) {
                 // yauzl opens entries in binary mode, so chunks are always Buffers.
                 if (chunk instanceof Buffer) {
                     chunks.push(chunk);
                 }
                 callback();
             },
         }));
         const linkTarget = Buffer.concat(chunks).toString();
         // Verify that the link does not resolve outside of the target directory.
         const resolvedLinkTarget = path.resolve(path.dirname(destination), linkTarget);
         if (!isInsideDirectory(folderPath, resolvedLinkTarget)) {
             throw new Error(`Zip symlink "${entry.fileName}" would point outside of the target directory.`);
         }
         await symlink(linkTarget, destination);
         return;
     }
     await pipeline(readStream, createWriteStream(destination, { mode }));
 }
 //# sourceMappingURL=fileUtil.js.map
	/**
	* @license
	* Copyright 2023 Google Inc.
	* SPDX-License-Identifier: Apache-2.0
	*/
	import { spawnSync, spawn, execFile } from 'node:child_process';
	import { constants, createReadStream, createWriteStream } from 'node:fs';
	import { mkdir, readdir, symlink } from 'node:fs/promises';
	import * as path from 'node:path';
	import { Stream, Writable } from 'node:stream';
	import { pipeline } from 'node:stream/promises';
	import { promisify } from 'node:util';
	import { debug } from './debug.js';
	const execFileAsync = promisify(execFile);
	const debugFileUtil = debug('puppeteer:browsers:fileUtil');
	/**
	* @internal
	*/
	export async function unpackArchive(archivePath, folderPath) {
	if (!path.isAbsolute(folderPath)) {
	folderPath = path.resolve(process.cwd(), folderPath);
	}
	if (archivePath.endsWith('.zip')) {
	await mkdir(folderPath, { recursive: true });
	await extractZip(archivePath, 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) {
	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, folderPath, decompressUtilityName) {
	const { unpackTar } = await import('modern-tar/fs');
	return await new Promise((fulfill, reject) => {
	function handleError(utilityName) {
	return (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 = unpackTar(folderPath);
	tar.once('error', handleError('tar'));
	tar.once('finish', fulfill);
	createReadStream(tarPath).pipe(createTransformStream(unpack)).pipe(tar);
	});
	}
	/**
	* @internal
	*/
	async function installDMG(dmgPath, folderPath) {
	const { stdout } = await execFileAsync('hdiutil', [
	'attach',
	'-nobrowse',
	'-noautoopen',
	dmgPath,
	]);
	const volumes = stdout.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);
	await execFileAsync('cp', ['-R', mountedPath, folderPath]);
	}
	finally {
	await execFileAsync('hdiutil', ['detach', mountPath, '-quiet']);
	}
	}
	/**
	* @internal
	*/
	class ArchiverUnavailableError extends Error {
	}
	/**
	* @internal
	*/
	async function extractZip(archivePath, folderPath) {
	for (const extract of [extractZipWithCli, extractZipWithYauzl]) {
	try {
	await extract(archivePath, folderPath);
	return;
	}
	catch (error) {
	if (!(error instanceof ArchiverUnavailableError)) {
	throw error;
	}
	}
	}
	throw new Error(`Extraction failed: no zip archiver is available. Install \`unzip\` (or \`tar.exe\`/Powershell on Windows), or add the optional \`yauzl\` dependency.`);
	}
	/**
	* @internal
	*/
	export async function extractZipWithYauzl(archivePath, folderPath) {
	const { default: yauzl } = await import(
	/* webpackIgnore: true */ 'yauzl').catch(() => {
	throw new ArchiverUnavailableError('Extraction failed: The optional `yauzl` dependency is not installed.');
	});
	const open = promisify(yauzl.open);
	try {
	const zipFile = await open(archivePath, { lazyEntries: true });
	await new Promise((resolve, reject) => {
	zipFile
	.on('error', reject)
	.on('end', resolve)
	.on('entry', entry => {
	extractZipEntry(zipFile, entry, folderPath).then(() => {
	zipFile.readEntry();
	}, reject);
	})
	.readEntry();
	});
	}
	catch (error) {
	throw new Error(`Extraction failed: ${archivePath}`, { cause: error });
	}
	}
	/**
	* @internal
	*/
	async function extractZipWithCli(archivePath, folderPath) {
	try {
	if (process.platform === 'win32') {
	const systemRoot = process.env['SystemRoot'] ?? process.env['SYSTEMROOT'] ?? 'C:\\Windows';
	try {
	const systemTar = `${systemRoot}\\System32\\tar.exe`;
	// -x: extract files
	// -f: specify the archive file
	// -C: extract to the specified directory
	await execFileAsync(systemTar, ['-xf', archivePath, '-C', folderPath]);
	return;
	}
	catch (tarError) {
	debugFileUtil?.(`tar.exe extraction failed: ${tarError}`);
	}
	try {
	await execFileAsync('powershell.exe', [
	'-NoProfile',
	'-NonInteractive',
	'-Command',
	'& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
	archivePath,
	folderPath,
	]);
	return;
	}
	catch (powershellError) {
	debugFileUtil?.(`powershell.exe extraction failed: ${powershellError}`);
	}
	await execFileAsync('pwsh.exe', [
	'-NoProfile',
	'-NonInteractive',
	'-Command',
	'& { Expand-Archive -LiteralPath $args[0] -DestinationPath $args[1] -Force }',
	archivePath,
	folderPath,
	]);
	}
	else {
	// -o: overwrite existing files without prompting
	// -d: extract files into the specified directory
	await execFileAsync('unzip', ['-o', archivePath, '-d', folderPath]);
	}
	}
	catch (error) {
	if (error?.code === 'ENOENT') {
	throw new ArchiverUnavailableError(`Extraction failed: Required native binary ('tar.exe', 'powershell.exe', 'pwsh.exe' or 'unzip') was not found in the system PATH.`);
	}
	throw new Error(`Extraction failed: ${error?.stderr?.toString() \|\| error?.message}`);
	}
	}
	/**
	* @internal
	*/
	function isInsideDirectory(directory, candidate) {
	const resolvedDirectory = path.resolve(directory);
	const resolvedCandidate = path.resolve(candidate);
	return (resolvedCandidate === resolvedDirectory \|\|
	resolvedCandidate.startsWith(resolvedDirectory + path.sep));
	}
	/**
	* @internal
	*/
	async function extractZipEntry(zipFile, entry, folderPath) {
	const { S_IFMT, S_IFDIR, S_IFLNK } = constants;
	// see https://github.com/max-mapper/extract-zip/blob/v2.0.1/index.js#L90-L107
	const unixMode = entry.externalFileAttributes >>> 16;
	const isDirectory = (unixMode & S_IFMT) === S_IFDIR \|\|
	entry.fileName.endsWith('/') \|\|
	(entry.versionMadeBy >> 8 === 0 && entry.externalFileAttributes === 0x10);
	const isSymlink = (unixMode & S_IFMT) === S_IFLNK;
	// Fall back to sensible defaults for archives without Unix attributes.
	const mode = unixMode === 0 ? (isDirectory ? 0o755 : 0o644) : unixMode & 0o777;
	const destination = path.join(folderPath, entry.fileName);
	if (isDirectory) {
	await mkdir(destination, { recursive: true, mode });
	return;
	}
	await mkdir(path.dirname(destination), { recursive: true });
	const readStream = await promisify(zipFile.openReadStream.bind(zipFile))(entry);
	if (isSymlink) {
	// Consume the symlink target in pipe semantics rather than via async
	// iteration (e.g. stream/consumers `text()`): yauzl <3.3.1 read streams
	// never emit "close", which hangs consumers (thejoshwolfe/yauzl#169)
	const chunks = [];
	await pipeline(readStream, new Writable({
	write(chunk, _encoding, callback) {
	// yauzl opens entries in binary mode, so chunks are always Buffers.
	if (chunk instanceof Buffer) {
	chunks.push(chunk);
	}
	callback();
	},
	}));
	const linkTarget = Buffer.concat(chunks).toString();
	// Verify that the link does not resolve outside of the target directory.
	const resolvedLinkTarget = path.resolve(path.dirname(destination), linkTarget);
	if (!isInsideDirectory(folderPath, resolvedLinkTarget)) {
	throw new Error(`Zip symlink "${entry.fileName}" would point outside of the target directory.`);
	}
	await symlink(linkTarget, destination);
	return;
	}
	await pipeline(readStream, createWriteStream(destination, { mode }));
	}
	//# sourceMappingURL=fileUtil.js.map