bdy 1.16.28-stage → 1.16.30-dev

package/distTs/src/utils.js

@@ -43,16 +43,20 @@ exports.isFile = isFile;
 exports.getAppWorkspaceUrl = getAppWorkspaceUrl;
 exports.getAppWorkspaceSettingsUrl = getAppWorkspaceSettingsUrl;
 exports.getAppUrl = getAppUrl;
+exports.untarGz = untarGz;
+exports.unzipFile = unzipFile;
 exports.getDockerRegistryHostByApiBaseUrl = getDockerRegistryHostByApiBaseUrl;
 exports.getAppHostByApiBaseUrl = getAppHostByApiBaseUrl;
-const node_path_1 = __importStar(require("node:path"));
-const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importStar(require("node:fs"));
 const texts_1 = require("./texts");
 const ssh2_1 = __importDefault(require("ssh2"));
 const node_sea_1 = require("node:sea");
 const commander_1 = require("commander");
 const node_os_1 = __importStar(require("node:os"));
 const node_child_process_1 = require("node:child_process");
+const fflate_1 = require("fflate");
+const tar_stream_1 = __importDefault(require("tar-stream"));
 exports.TUNNEL_HTTP_RATE_LIMIT = 2000;
 exports.TUNNEL_HTTP_RATE_WINDOW = 60000;
 exports.TUNNEL_HTTP_LOG_MAX_BODY = 5242880; // 5MB
@@ -388,7 +392,7 @@ const getVersion = () => {
         }
         else {
             const root = (0, exports.getRootDir)();
-            packageJson = JSON.parse((0, node_fs_1.readFileSync)((0, node_path_1.resolve)(root, 'package.json'), 'utf8'));
+            packageJson = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.resolve(root, 'package.json'), 'utf8'));
         }
         cachedVersion = packageJson.version;
     }
@@ -577,6 +581,278 @@ function getAppWorkspaceSettingsUrl(baseUrl, workspace) {
 function getAppUrl(baseUrl, path) {
     return `https://${getAppHostByApiBaseUrl(baseUrl)}${path}`;
 }
+function untarGz(dirPath, tarGzPath, onFile) {
+    return new Promise((resolve, reject) => {
+        let _startedFiles = 0;
+        let _finishedFiles = 0;
+        let _finishedStream = false;
+        let _finishedError = null;
+        let _calledResolve = false;
+        const rs = node_fs_1.default.createReadStream(tarGzPath);
+        const extract = tar_stream_1.default.extract();
+        const _finish = () => {
+            if (_finishedError || _finishedStream) {
+                try {
+                    rs.removeAllListeners();
+                    rs.close();
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (_calledResolve)
+                return;
+            if (_finishedError) {
+                _calledResolve = true;
+                reject(_finishedError);
+                return;
+            }
+            if (_finishedStream && _startedFiles === _finishedFiles) {
+                _calledResolve = true;
+                resolve();
+            }
+        };
+        const finishFile = (err, fws) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            const complete = () => {
+                _finishedFiles += 1;
+                onFile();
+                _finish();
+            };
+            if (fws) {
+                fws.once('finish', () => {
+                    fws.removeAllListeners();
+                    complete();
+                });
+                fws.end();
+            }
+            else {
+                complete();
+            }
+        };
+        const finishStream = (err) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            _finishedStream = true;
+            _finish();
+        };
+        extract.on('entry', async (header, stream, next) => {
+            if (_finishedError) {
+                stream.resume();
+                next();
+                return;
+            }
+            _startedFiles += 1;
+            const fullPath = node_path_1.default.join(dirPath, header.name);
+            const parentPath = node_path_1.default.dirname(fullPath);
+            let fws;
+            try {
+                await node_fs_1.default.promises.rm(fullPath, {
+                    recursive: true,
+                    force: true,
+                });
+            }
+            catch {
+                // do nothing
+            }
+            try {
+                if (header.type === 'directory') {
+                    await node_fs_1.default.promises.mkdir(fullPath, {
+                        recursive: true,
+                    });
+                    stream.resume();
+                    finishFile();
+                    next();
+                    return;
+                }
+                await node_fs_1.default.promises.mkdir(parentPath, {
+                    recursive: true,
+                });
+                fws = node_fs_1.default.createWriteStream(fullPath, {
+                    flags: 'w',
+                });
+                fws.on('error', (err) => {
+                    finishFile(err, fws);
+                });
+            }
+            catch (err) {
+                stream.resume();
+                finishFile(err, fws);
+                next();
+                return;
+            }
+            stream.on('data', (chunk) => {
+                if (_finishedError)
+                    return;
+                if (fws) {
+                    fws.write(chunk);
+                }
+            });
+            stream.on('end', () => {
+                finishFile(null, fws);
+                next();
+            });
+            stream.on('error', (err) => {
+                finishFile(err, fws);
+                next();
+            });
+        });
+        extract.on('finish', () => {
+            finishStream();
+        });
+        extract.on('error', (err) => {
+            finishStream(err);
+        });
+        const gunzip = new fflate_1.Gunzip((data, final) => {
+            if (_finishedError)
+                return;
+            extract.write(Buffer.from(data));
+            if (final) {
+                extract.end();
+            }
+        });
+        rs.on('data', (chunk) => {
+            try {
+                gunzip.push(chunk, false);
+            }
+            catch (err) {
+                finishStream(err);
+            }
+        });
+        rs.on('error', (err) => {
+            finishStream(err);
+        });
+        rs.on('end', () => {
+            try {
+                gunzip.push(new Uint8Array(0), true);
+            }
+            catch (err) {
+                finishStream(err);
+            }
+        });
+    });
+}
+function unzipFile(dirPath, zipPath, onFile) {
+    return new Promise((resolve, reject) => {
+        let _startedFiles = 0;
+        let _finishedFiles = 0;
+        let _finishedStream = false;
+        let _finishedError = null;
+        let _calledResolve = false;
+        const rs = node_fs_1.default.createReadStream(zipPath);
+        const _finish = () => {
+            if (_finishedError || _finishedStream) {
+                try {
+                    rs.removeAllListeners();
+                    rs.close();
+                }
+                catch {
+                    // do nothing
+                }
+            }
+            if (_calledResolve)
+                return;
+            if (_finishedError) {
+                _calledResolve = true;
+                reject(_finishedError);
+                return;
+            }
+            if (_finishedStream && _startedFiles === _finishedFiles) {
+                _calledResolve = true;
+                resolve();
+            }
+        };
+        const finishFile = (err, fws) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            const complete = () => {
+                _finishedFiles += 1;
+                onFile();
+                _finish();
+            };
+            if (fws) {
+                fws.once('finish', () => {
+                    fws.removeAllListeners();
+                    complete();
+                });
+                fws.end();
+            }
+            else {
+                complete();
+            }
+        };
+        const finishStream = (err) => {
+            if (!_finishedError && err)
+                _finishedError = err;
+            _finishedStream = true;
+            _finish();
+        };
+        const unzip = new fflate_1.Unzip(async (file) => {
+            if (_finishedError)
+                return;
+            _startedFiles += 1;
+            const fullPath = node_path_1.default.join(dirPath, file.name);
+            const parentPath = node_path_1.default.dirname(fullPath);
+            let fws;
+            try {
+                await node_fs_1.default.promises.rm(fullPath, {
+                    recursive: true,
+                    force: true,
+                });
+            }
+            catch {
+                // do nothing
+            }
+            try {
+                if (fullPath.endsWith('/')) {
+                    await node_fs_1.default.promises.mkdir(fullPath, {
+                        recursive: true,
+                    });
+                    finishFile();
+                    return;
+                }
+                await node_fs_1.default.promises.mkdir(parentPath, {
+                    recursive: true,
+                });
+                fws = node_fs_1.default.createWriteStream(fullPath, {
+                    flags: 'w',
+                });
+                fws.on('error', (err) => {
+                    finishFile(err, fws);
+                });
+            }
+            catch (err) {
+                finishFile(err, fws);
+                return;
+            }
+            file.ondata = (err, data, final) => {
+                if (_finishedError)
+                    return;
+                if (err)
+                    finishFile(err, fws);
+                else {
+                    if (fws)
+                        fws.write(data);
+                    if (final)
+                        finishFile(null, fws);
+                }
+            };
+            file.start();
+        });
+        unzip.register(fflate_1.AsyncUnzipInflate);
+        rs.on('data', (chunk) => {
+            unzip.push(chunk, false);
+        });
+        rs.on('error', (err) => {
+            finishStream(err);
+        });
+        rs.on('end', () => {
+            unzip.push(new Uint8Array(0), true);
+            finishStream();
+        });
+    });
+}
 function getDockerRegistryHostByApiBaseUrl(baseUrl) {
     if (baseUrl.hostname.includes('api.buddy.works')) {
         return 'container-pkg.buddy.works';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bdy",
   "preferGlobal": false,
-  "version": "1.16.28-stage",
+  "version": "1.16.30-dev",
   "type": "commonjs",
   "license": "MIT",
   "scripts": {