Bernt
6989a98d75
- Arkitektur: docs/auth/passwordless-architecture.md - Backend: iom/quixzoom-auth-service/ (FastAPI + Redis) - Webb: quixzoom-market-pages/se/login/ (QR-kod + polling) - App: iom/quixzoom-app/src/features/auth/ (push + deep links) Flöde: QR-kod → app-godkännande → webb-inloggad
316 lines
11 KiB
JavaScript
316 lines
11 KiB
JavaScript
/**
|
|
* @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
|