deepv-code 1.0.182

package/bundle/node_modules/@vscode/ripgrep/lib/download.js

@@ -0,0 +1,357 @@
+// @ts-check
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const https = require('https');
+const util = require('util');
+const url = require('url');
+const stream = require('stream');
+const child_process = require('child_process');
+const proxy_from_env = require('proxy-from-env');
+const yauzl = require('yauzl'); // use yauzl ^2.9.2 because vscode already ships with it.
+const packageVersion = require('../package.json').version;
+const tmpDir = path.join(os.tmpdir(), `vscode-ripgrep-cache-${packageVersion}`);
+
+const fsUnlink = util.promisify(fs.unlink);
+const fsExists = util.promisify(fs.exists);
+const fsMkdir = util.promisify(fs.mkdir);
+
+const isWindows = os.platform() === 'win32';
+
+const REPO = 'microsoft/ripgrep-prebuilt';
+const pipelineAsync = util.promisify(stream.pipeline);
+
+/**
+ * @param {string} _url
+ */
+function isGithubUrl(_url) {
+    return url.parse(_url).hostname === 'api.github.com';
+}
+
+
+/**
+ * @param {string} _url
+ * @param {fs.PathLike} dest
+ * @param {any} opts
+ */
+function download(_url, dest, opts) {
+
+    const proxy = proxy_from_env.getProxyForUrl(url.parse(_url));
+    if (proxy !== '') {
+        var HttpsProxyAgent = require('https-proxy-agent');
+        opts = {
+            ...opts,
+            "agent": new HttpsProxyAgent.HttpsProxyAgent(proxy),
+            proxy
+        };
+    }
+
+
+    if (opts.headers && opts.headers.authorization && !isGithubUrl(_url)) {
+        delete opts.headers.authorization;
+    }
+
+    return new Promise((resolve, reject) => {
+        console.log(`Download options: ${JSON.stringify(opts)}`);
+        const outFile = fs.createWriteStream(dest);
+        const mergedOpts = {
+            ...url.parse(_url),
+            ...opts
+        };
+        https.get(mergedOpts, response => {
+            console.log('statusCode: ' + response.statusCode);
+            if (response.statusCode === 302) {
+                response.resume();
+                console.log('Following redirect to: ' + response.headers.location);
+                return download(response.headers.location, dest, opts)
+                    .then(resolve, reject);
+            } else if (response.statusCode !== 200) {
+                reject(new Error('Download failed with ' + response.statusCode));
+                return;
+            }
+
+            response.pipe(outFile);
+            outFile.on('finish', () => {
+                resolve();
+            });
+        }).on('error', async err => {
+            await fsUnlink(dest);
+            reject(err);
+        });
+    });
+}
+
+/**
+ * @param {string} _url
+ * @param {any} opts
+ */
+function get(_url, opts) {
+    console.log(`GET ${_url}`);
+
+    const proxy = proxy_from_env.getProxyForUrl(url.parse(_url));
+    if (proxy !== '') {
+        var HttpsProxyAgent = require('https-proxy-agent');
+        opts = {
+            ...opts,
+            "agent": new HttpsProxyAgent.HttpsProxyAgent(proxy)
+        };
+    }
+
+    return new Promise((resolve, reject) => {
+        let result = '';
+        opts = {
+            ...url.parse(_url),
+            ...opts
+        };
+        https.get(opts, response => {
+            if (response.statusCode !== 200) {
+                reject(new Error('Request failed: ' + response.statusCode));
+            }
+
+            response.on('data', d => {
+                result += d.toString();
+            });
+
+            response.on('end', () => {
+                resolve(result);
+            });
+
+            response.on('error', e => {
+                reject(e);
+            });
+        }).on('error', e => reject(e));
+    });
+}
+
+/**
+ * @param {string} repo
+ * @param {string} tag
+ */
+function getApiUrl(repo, tag) {
+    return `https://api.github.com/repos/${repo}/releases/tags/${tag}`;
+}
+
+/**
+ * @param {{ force: boolean; token: string; version: string; }} opts
+ * @param {string} assetName
+ * @param {string} downloadFolder
+ */
+async function getAssetFromGithubApi(opts, assetName, downloadFolder) {
+    const assetDownloadPath = path.join(downloadFolder, assetName);
+
+    // We can just use the cached binary
+    if (!opts.force && await fsExists(assetDownloadPath)) {
+        console.log('Using cached download: ' + assetDownloadPath);
+        return assetDownloadPath;
+    }
+
+    const downloadOpts = {
+        headers: {
+            'user-agent': 'vscode-ripgrep'
+        }
+    };
+
+    if (opts.token) {
+        downloadOpts.headers.authorization = `token ${opts.token}`;
+    }
+
+    console.log(`Finding release for ${opts.version}`);
+    const release = await get(getApiUrl(REPO, opts.version), downloadOpts);
+    let jsonRelease;
+    try {
+        jsonRelease = JSON.parse(release);
+    } catch (e) {
+        throw new Error('Malformed API response: ' + e.stack);
+    }
+
+    if (!jsonRelease.assets) {
+        throw new Error('Bad API response: ' + JSON.stringify(release));
+    }
+
+    const asset = jsonRelease.assets.find(a => a.name === assetName);
+    if (!asset) {
+        throw new Error('Asset not found with name: ' + assetName);
+    }
+
+    console.log(`Downloading from ${asset.url}`);
+    console.log(`Downloading to ${assetDownloadPath}`);
+
+    downloadOpts.headers.accept = 'application/octet-stream';
+    await download(asset.url, assetDownloadPath, downloadOpts);
+}
+
+/**
+ * @param {string} zipPath
+ * @param {string} destinationDir
+ */
+function unzipWindows(zipPath, destinationDir) {
+    // code from https://stackoverflow.com/questions/63932027/how-to-unzip-to-a-folder-using-yauzl
+    return new Promise((resolve, reject) => {
+        try {
+            // Create folder if not exists
+            fs.promises.mkdir(path.dirname(destinationDir), { recursive: true });
+
+            // Same as example we open the zip.
+            yauzl.open(zipPath, { lazyEntries: true }, (err, zipFile) => {
+                if (err) {
+                    zipFile?.close();
+                    reject(err);
+                    return;
+                }
+
+                // This is the key. We start by reading the first entry.
+                zipFile.readEntry();
+
+                // Now for every entry, we will write a file or dir
+                // to disk. Then call zipFile.readEntry() again to
+                // trigger the next cycle.
+                zipFile.on('entry', (entry) => {
+                    try {
+                        // Directories
+                        if (/\/$/.test(entry.fileName)) {
+                            // Create the directory then read the next entry.
+                            fs.promises.mkdir(path.join(destinationDir, entry.fileName), { recursive: true });
+                            zipFile.readEntry();
+                        }
+                        // Files
+                        else {
+                            // Write the file to disk.
+                            zipFile.openReadStream(entry, (readErr, readStream) => {
+                                if (readErr) {
+                                    zipFile.close();
+                                    reject(readErr);
+                                    return;
+                                }
+
+                                const file = fs.createWriteStream(path.join(destinationDir, entry.fileName));
+                                readStream.pipe(file);
+                                file.on('finish', () => {
+                                    // Wait until the file is finished writing, then read the next entry.
+                                    // @ts-ignore: Typing for close() is wrong.
+                                    file.close(() => {
+                                        zipFile.readEntry();
+                                    });
+
+                                    file.on('error', (err) => {
+                                        zipFile.close();
+                                        reject(err);
+                                    });
+                                });
+                            });
+                        }
+                    } catch (e) {
+                        zipFile.close();
+                        reject(e);
+                    }
+                });
+                zipFile.on('end', (err) => {
+                    resolve();
+                });
+                zipFile.on('error', (err) => {
+                    zipFile.close();
+                    reject(err);
+                });
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+
+/**
+ * Handle whitespace in filepath as powershell splits path with whitespaces
+ * @param {string} path
+ */
+function sanitizePathForPowershell(path) {
+    path = path.replace(/ /g, '` '); // replace whitespace with "` " as solution provided here https://stackoverflow.com/a/18537344/7374562
+    return path;
+}
+
+function untar(zipPath, destinationDir) {
+    return new Promise((resolve, reject) => {
+        const unzipProc = child_process.spawn('tar', ['xvf', zipPath, '-C', destinationDir], { stdio: 'inherit' });
+        unzipProc.on('error', err => {
+            reject(err);
+        });
+        unzipProc.on('close', code => {
+            console.log(`tar xvf exited with ${code}`);
+            if (code !== 0) {
+                reject(new Error(`tar xvf exited with ${code}`));
+                return;
+            }
+
+            resolve();
+        });
+    });
+}
+
+/**
+ * @param {string} zipPath
+ * @param {string} destinationDir
+ */
+async function unzipRipgrep(zipPath, destinationDir) {
+    if (isWindows) {
+        await unzipWindows(zipPath, destinationDir);
+    } else {
+        await untar(zipPath, destinationDir);
+    }
+
+    const expectedName = path.join(destinationDir, 'rg');
+    if (await fsExists(expectedName)) {
+        return expectedName;
+    }
+
+    if (await fsExists(expectedName + '.exe')) {
+        return expectedName + '.exe';
+    }
+
+    throw new Error(`Expecting rg or rg.exe unzipped into ${destinationDir}, didn't find one.`);
+}
+
+module.exports = async opts => {
+    if (!opts.version) {
+        return Promise.reject(new Error('Missing version'));
+    }
+
+    if (!opts.target) {
+        return Promise.reject(new Error('Missing target'));
+    }
+
+    const extension = isWindows ? '.zip' : '.tar.gz';
+    const assetName = ['ripgrep', opts.version, opts.target].join('-') + extension;
+
+    if (!await fsExists(tmpDir)) {
+        await fsMkdir(tmpDir);
+    }
+
+    const assetDownloadPath = path.join(tmpDir, assetName);
+    try {
+        await getAssetFromGithubApi(opts, assetName, tmpDir)
+    } catch (e) {
+        console.log('Deleting invalid download cache');
+        try {
+            await fsUnlink(assetDownloadPath);
+        } catch (e) { }
+
+        throw e;
+    }
+
+    console.log(`Unzipping to ${opts.destDir}`);
+    try {
+        const destinationPath = await unzipRipgrep(assetDownloadPath, opts.destDir);
+        if (!isWindows) {
+            await util.promisify(fs.chmod)(destinationPath, '755');
+        }
+    } catch (e) {
+        console.log('Deleting invalid download');
+
+        try {
+            await fsUnlink(assetDownloadPath);
+        } catch (e) { }
+
+        throw e;
+    }
+};

package/bundle/node_modules/@vscode/ripgrep/lib/index.d.ts

@@ -0,0 +1 @@
+export declare const rgPath: string;

package/bundle/node_modules/@vscode/ripgrep/lib/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+
+function getRgPath() {
+  const platform = process.platform;
+  const arch = process.arch;
+
+  // Normalize arch name
+  const normalizedArch = arch === 'x64' ? 'x64' : arch;
+  const platformKey = `${platform}-${normalizedArch}`;
+
+  // Define binary names by platform
+  const binaryName = platform === 'win32' ? 'rg.exe' : 'rg';
+
+  // Try platform-specific binary first
+  const platformSpecificPath = path.join(__dirname, `../bin/${platformKey}-${binaryName}`);
+  if (fs.existsSync(platformSpecificPath)) {
+    return platformSpecificPath;
+  }
+
+  // Fall back to standard binary name
+  const standardPath = path.join(__dirname, `../bin/${binaryName}`);
+  if (fs.existsSync(standardPath)) {
+    return standardPath;
+  }
+
+  // List available binaries for better error message
+  const binDir = path.join(__dirname, '../bin');
+  let availableBinaries = [];
+  if (fs.existsSync(binDir)) {
+    availableBinaries = fs.readdirSync(binDir);
+  }
+
+  throw new Error(`Ripgrep binary not found for platform ${platform}-${arch}.
+Available binaries: ${availableBinaries.join(', ')}
+Looking for: ${platformKey}-${binaryName} or ${binaryName}
+Please ensure the binary is available for your platform.`);
+}
+
+module.exports.rgPath = getRgPath();

package/bundle/node_modules/@vscode/ripgrep/lib/postinstall.js

@@ -0,0 +1,121 @@
+// @ts-check
+'use strict';
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const util = require('util');
+const child_process = require('child_process');
+
+const download = require('./download');
+
+const fsExists = util.promisify(fs.exists);
+const mkdir = util.promisify(fs.mkdir);
+const exec = util.promisify(child_process.exec);
+
+const forceInstall = process.argv.includes('--force');
+if (forceInstall) {
+    console.log('--force, ignoring caches');
+}
+
+const VERSION = 'v13.0.0-13';
+const MULTI_ARCH_LINUX_VERSION = 'v13.0.0-4';// use this for arm-unknown-linux-gnueabihf and powerpc64le-unknown-linux-gnu until we can fix https://github.com/microsoft/ripgrep-prebuilt/issues/24 and https://github.com/microsoft/ripgrep-prebuilt/issues/32 respectively.
+const BIN_PATH = path.join(__dirname, '../bin');
+
+process.on('unhandledRejection', (reason, promise) => {
+    console.log('Unhandled rejection: ', promise, 'reason:', reason);
+});
+
+async function getTarget() {
+    const arch = process.env.npm_config_arch || os.arch();
+
+    switch (os.platform()) {
+        case 'darwin':
+            return arch === 'arm64' ? 'aarch64-apple-darwin' :
+                'x86_64-apple-darwin';
+        case 'win32':
+            return arch === 'x64' ? 'x86_64-pc-windows-msvc' :
+                arch === 'arm64' ? 'aarch64-pc-windows-msvc' :
+                'i686-pc-windows-msvc';
+        case 'linux':
+            return arch === 'x64' ? 'x86_64-unknown-linux-musl' :
+                arch === 'arm' ? 'arm-unknown-linux-gnueabihf' :
+                arch === 'armv7l' ? 'arm-unknown-linux-gnueabihf' :
+                arch === 'arm64' ? 'aarch64-unknown-linux-musl':
+                arch === 'ppc64' ? 'powerpc64le-unknown-linux-gnu' :
+                arch === 'riscv64' ? 'riscv64gc-unknown-linux-gnu' :
+                arch === 's390x' ? 's390x-unknown-linux-gnu' :
+                    'i686-unknown-linux-musl'
+        default: throw new Error('Unknown platform: ' + os.platform());
+    }
+}
+
+/**
+ * Sleep for a specified number of milliseconds
+ * @param {number} ms Time to sleep in milliseconds
+ * @returns {Promise<void>}
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry a function with exponential backoff
+ * @param {Function} fn Function to retry
+ * @param {number} maxRetries Maximum number of retries
+ * @returns {Promise<any>}
+ */
+async function retry(fn, maxRetries = 5) {
+    let retries = 0;
+    let lastError;
+
+    while (retries < maxRetries) {
+        try {
+            return await fn();
+        } catch (err) {
+            lastError = err;
+            retries++;
+
+            if (retries >= maxRetries) {
+                break;
+            }
+
+            const delay = Math.pow(2, retries) * 1000;
+            console.error(err);
+            console.log(`Download attempt ${retries} failed, retrying in ${delay/1000} seconds...`);
+            await sleep(delay);
+        }
+    }
+
+    throw lastError;
+}
+
+async function main() {
+    const binExists = await fsExists(BIN_PATH);
+    if (!forceInstall && binExists) {
+        console.log('bin/ folder already exists, exiting');
+        process.exit(0);
+    }
+
+    if (!binExists) {
+        await mkdir(BIN_PATH);
+    }
+
+    const target = await getTarget();
+    const opts = {
+        version: target === "arm-unknown-linux-gnueabihf" || target === "powerpc64le-unknown-linux-gnu" || target === "s390x-unknown-linux-gnu" ? MULTI_ARCH_LINUX_VERSION: VERSION,
+        token: process.env['GITHUB_TOKEN'],
+        target: await getTarget(),
+        destDir: BIN_PATH,
+        force: forceInstall
+    };
+
+    try {
+        await retry(() => download(opts));
+    } catch (err) {
+        console.error(`Downloading ripgrep failed after multiple retries: ${err.stack}`);
+        process.exit(1);
+    }
+}
+
+main();

package/bundle/node_modules/@vscode/ripgrep/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@vscode/ripgrep",
+  "version": "1.15.14",
+  "description": "A module for using ripgrep in a Node project",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/vscode-ripgrep"
+  },
+  "scripts": {
+    "postinstall": "node ./lib/postinstall.js"
+  },
+  "author": "Rob Lourens",
+  "license": "MIT",
+  "dependencies": {
+    "https-proxy-agent": "^7.0.2",
+    "yauzl": "^2.9.2",
+    "proxy-from-env": "^1.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.8.4"
+  }
+}

package/bundle/node_modules/undici/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Matteo Collina and Undici contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.