@vectorx/cloud-toolkit 0.0.0-beta-20251112071234

package/lib/services/upload-service.js

@@ -0,0 +1,192 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadService = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const inversify_1 = require("inversify");
+const config_1 = require("../config");
+const container_1 = require("../container");
+const cos_uploader_1 = require("../utils/cos-uploader");
+const env_helper_1 = require("../utils/env-helper");
+const logger_1 = require("../utils/logger");
+const request_1 = require("../utils/request");
+let UploadService = class UploadService {
+    constructor() {
+        this.authService = container_1.container.get(container_1.SERVICE_IDENTIFIERS.AuthService);
+    }
+    getCloudBaseSecretToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (env_helper_1.isIDE) {
+                return "";
+            }
+            const loginInfo = yield this.authService.getLoginInfo();
+            if (!loginInfo) {
+                throw new Error("未登录，请先登录");
+            }
+            return loginInfo.cli_token;
+        });
+    }
+    getToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let params = {};
+                if (!env_helper_1.isIDE) {
+                    const loginInfo = yield this.authService.getLoginInfo();
+                    if (!loginInfo) {
+                        throw new Error("未登录，请先登录");
+                    }
+                    params = {
+                        secret_id: loginInfo.secret_id,
+                        cli_token: loginInfo.cli_token,
+                    };
+                }
+                const response = yield request_1.request.fetch({
+                    url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/agent_pkg/upload/permit`,
+                    headers: {
+                        "Content-Type": "application/json",
+                    },
+                    method: "GET",
+                    data: {
+                        params,
+                    },
+                });
+                if (response.data.code === 0) {
+                    return response.data.data;
+                }
+                else {
+                    throw new Error(response.data.msg);
+                }
+            }
+            catch (error) {
+                throw new Error(`获取上传Token失败: ${(error === null || error === void 0 ? void 0 : error.message) || error}`);
+            }
+        });
+    }
+    buildPreCheck(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let query = {};
+                if (!env_helper_1.isIDE) {
+                    const loginInfo = yield this.authService.getLoginInfo();
+                    if (!loginInfo) {
+                        throw new Error("未登录，请先登录");
+                    }
+                    query = {
+                        secret_id: loginInfo.secret_id,
+                        cli_token: loginInfo.cli_token,
+                    };
+                }
+                const res = yield request_1.request.fetch({
+                    method: "POST",
+                    url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/agent_pkg/develop/upload_pre_check`,
+                    headers: {},
+                    data: {
+                        query,
+                        body: params,
+                    },
+                });
+                return res.data;
+            }
+            catch (error) {
+                throw new Error(`上传预检失败: ${(error === null || error === void 0 ? void 0 : error.message) || error}`);
+            }
+        });
+    }
+    deploy(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!env_helper_1.isIDE && !this.authService.hasLogin()) {
+                throw new Error("未登录，请先登录");
+            }
+            const uploader = new cos_uploader_1.Uploader({
+                bizName: "fe",
+                scene: "fe-platform",
+                getToken: () => this.getToken(),
+            });
+            const filePath = path_1.default.resolve(params.targetPath);
+            const file = fs_1.default.readFileSync(filePath);
+            const fileName = `miniapp-agent-${params.agentId}-${params.version}.zip`;
+            const stats = fs_1.default.statSync(filePath);
+            const response = yield uploader.post({
+                Body: file,
+                fileInfo: {
+                    name: fileName,
+                    type: "application/octet-stream",
+                    size: stats.size,
+                },
+                FilePath: filePath,
+            });
+            logger_1.logger.breakLine();
+            logger_1.logger.info(chalk_1.default.green(`资源包上传成功: ${response.previewUrl}`));
+            if (response.previewUrl) {
+                const res = yield this.uploadAgentPackage({
+                    agent_id: params.agentId,
+                    version: params.version,
+                    desc: params.desc,
+                    file_url: response.previewUrl,
+                    cloud_type: response.cloudType,
+                });
+                if (res.code !== 0) {
+                    throw new Error(`[${res.code}] ${res.msg}`);
+                }
+                return res;
+            }
+            else {
+                throw new Error(".zip 文件服务上传失败");
+            }
+        });
+    }
+    uploadAgentPackage(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let query = {};
+            if (!env_helper_1.isIDE) {
+                const loginInfo = yield this.authService.getLoginInfo();
+                if (!loginInfo) {
+                    throw new Error("未登录，请先登录");
+                }
+                query = {
+                    secret_id: loginInfo.secret_id,
+                    cli_token: loginInfo.cli_token,
+                };
+            }
+            const res = yield request_1.request.fetch({
+                method: "POST",
+                url: `${(0, config_1.getBaseUrl)()}/api/eros/mp/red/code/agent_pkg/develop/upload`,
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                data: {
+                    query,
+                    body: params,
+                },
+            });
+            return res.data;
+        });
+    }
+};
+exports.UploadService = UploadService;
+exports.UploadService = UploadService = __decorate([
+    (0, inversify_1.injectable)(),
+    __metadata("design:paramtypes", [])
+], UploadService);

package/lib/utils/config-merger.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeProjectConfigs = mergeProjectConfigs;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function mergeProjectConfigs(workDir) {
+    const projectConfigPath = path_1.default.join(workDir, "project.config.json");
+    const agentConfigPath = path_1.default.join(workDir, "agent-cloudbase-functions.json");
+    if (!fs_1.default.existsSync(projectConfigPath)) {
+        throw new Error(`project.config.json 文件不存在: ${projectConfigPath}`);
+    }
+    if (!fs_1.default.existsSync(agentConfigPath)) {
+        throw new Error(`agent-cloudbase-functions.json 文件不存在: ${agentConfigPath}`);
+    }
+    try {
+        const projectConfigContent = fs_1.default.readFileSync(projectConfigPath, "utf8");
+        const agentConfigContent = fs_1.default.readFileSync(agentConfigPath, "utf8");
+        const projectConfig = JSON.parse(projectConfigContent);
+        const agentConfig = JSON.parse(agentConfigContent);
+        let hasChanges = false;
+        if (projectConfig.agentId && projectConfig.agentId !== agentConfig.agentId) {
+            agentConfig.agentId = projectConfig.agentId;
+            hasChanges = true;
+        }
+        if (projectConfig.version && projectConfig.version !== agentConfig.version) {
+            agentConfig.version = projectConfig.version;
+            hasChanges = true;
+        }
+        if (projectConfig.desc && projectConfig.desc !== agentConfig.desc) {
+            agentConfig.desc = projectConfig.desc;
+            hasChanges = true;
+        }
+        if (hasChanges) {
+            const updatedContent = JSON.stringify(agentConfig, null, 2);
+            fs_1.default.writeFileSync(agentConfigPath, updatedContent, "utf8");
+            console.log("✅ 配置文件合并完成，已更新 agent-cloudbase-functions.json");
+            if (projectConfig.agentId) {
+                console.log(`   agentId: ${projectConfig.agentId}`);
+            }
+            if (projectConfig.version) {
+                console.log(`   version: ${projectConfig.version}`);
+            }
+        }
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error(`配置文件格式错误，请检查 JSON 格式是否正确: ${error.message}`);
+        }
+        throw new Error(`合并配置文件时发生错误: ${error.message}`);
+    }
+}

package/lib/utils/cos-uploader.js

@@ -0,0 +1,104 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Uploader = void 0;
+const cos_nodejs_sdk_v5_1 = __importDefault(require("cos-nodejs-sdk-v5"));
+const to_hump_1 = require("./to-hump");
+class Uploader {
+    constructor(args) {
+        this.bizName = args.bizName;
+        this.scene = args.scene;
+        this.getToken = args.getToken;
+        this.enableResume = args.enableResume;
+    }
+    getPermit(file, fileInfo, fileFormat, persistentOps, persistentNotifyUrl) {
+        return this.getToken().then(({ uploadTempPermits, uploadLimitPolicy }) => {
+            const fileType = fileInfo.type;
+            const fileSize = fileInfo.size;
+            if (uploadLimitPolicy) {
+                const { fileTypes, maxSize } = uploadLimitPolicy;
+                if ((fileTypes === null || fileTypes === void 0 ? void 0 : fileTypes.length) &&
+                    !fileTypes.reduce((a, c) => [...a, ...c.split("/")], []).some((f) => fileType.endsWith(f))) {
+                    throw new Error(`文件类型 ${fileType} 不在可上传的文件类型 ${fileTypes.join(", ")} 中。`);
+                }
+                if (maxSize !== undefined && fileSize > maxSize) {
+                    throw new Error(`文件尺寸（${fileSize / (1024 * 1024)} mb）超过最大尺寸（${maxSize / (1024 * 1024)} mb）。`);
+                }
+            }
+            if (!(uploadTempPermits === null || uploadTempPermits === void 0 ? void 0 : uploadTempPermits.length)) {
+                throw new Error("token 获取失败。");
+            }
+            const [permit] = uploadTempPermits.sort((a, b) => b.qos - a.qos);
+            return permit;
+        });
+    }
+    post(options) {
+        const startTime = Date.now();
+        const { fileFormat, onInstanceCreated } = options, rest = __rest(options, ["fileFormat", "onInstanceCreated"]);
+        return this.getPermit(options.Body, options.fileInfo, fileFormat)
+            .then((permit) => {
+            const [fileId] = permit.fileIds;
+            const cosInitParams = {
+                Domain: permit.uploadAddr,
+                getAuthorization(_, callback) {
+                    callback({
+                        TmpSecretId: permit.secretId || "null",
+                        TmpSecretKey: permit.secretKey || "null",
+                        SecurityToken: permit.token,
+                        StartTime: Math.floor(startTime / 1000),
+                        ExpiredTime: Math.floor(permit.expireTime / 1000),
+                    });
+                },
+            };
+            if (permit.bucket === "unknown") {
+                cosInitParams.AppId = "1251524319";
+            }
+            const cos = new cos_nodejs_sdk_v5_1.default(cosInitParams);
+            if (onInstanceCreated) {
+                onInstanceCreated(cos);
+            }
+            return cos
+                .uploadFile(Object.assign({ Bucket: permit.bucket, Region: permit.region, Key: fileId }, rest))
+                .then((resp) => {
+                const payload = Object.assign(Object.assign({}, resp), { bizName: this.bizName, scene: this.scene, cloudType: permit.cloudType, fileId, sliceSize: rest.SliceSize || 1048576, isSlice: options.fileInfo.size > (rest.SliceSize || 1048576), tokenFail: false });
+                if (permit.cdnDomain) {
+                    const cdnLink = `${permit.cdnDomain}/${fileId}`;
+                    payload.cdnDomain = permit.cdnDomain;
+                    payload.url = cdnLink;
+                    payload.previewUrl = cdnLink;
+                    payload.staticUrl = cdnLink;
+                }
+                if (resp === null || resp === void 0 ? void 0 : resp.headers) {
+                    Object.keys(resp.headers).forEach((v) => {
+                        var _a;
+                        if (v.startsWith("x-ros-")) {
+                            const key = (0, to_hump_1.toHump)(v.split("x-ros-")[1]);
+                            payload[key] = (_a = resp.headers) === null || _a === void 0 ? void 0 : _a[v];
+                        }
+                    });
+                }
+                return payload;
+            })
+                .catch((e) => {
+                throw e;
+            });
+        })
+            .catch((e) => {
+            throw e;
+        });
+    }
+}
+exports.Uploader = Uploader;

package/lib/utils/env-helper.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIDE = void 0;
+exports.isIDE = process.env.FROM_SOURCE === "IDE";

package/lib/utils/helper.js

@@ -0,0 +1,66 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHump = exports.getFixedFormatTime = void 0;
+exports.getNonce = getNonce;
+exports.getMd5 = getMd5;
+exports.guid = guid;
+exports.retry = retry;
+const crypto_1 = __importDefault(require("crypto"));
+const dayjs_1 = __importDefault(require("dayjs"));
+const uuid_1 = require("uuid");
+const getFixedFormatTime = (format, timeDistance = 0) => {
+    const current = (0, dayjs_1.default)();
+    const time = current.add(timeDistance, "millisecond").format(format);
+    return time;
+};
+exports.getFixedFormatTime = getFixedFormatTime;
+function getNonce() {
+    return "xxxxxxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === "x" ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+function getMd5(str) {
+    const hash = crypto_1.default.createHash("md5");
+    hash.update(str);
+    const md5 = hash.digest("hex");
+    return md5;
+}
+function guid() {
+    return (0, uuid_1.v4)();
+}
+function retry(fn_1) {
+    return __awaiter(this, arguments, void 0, function* (fn, maxRetries = 5, delay = 0) {
+        let lastError;
+        for (let i = 0; i < maxRetries; i++) {
+            try {
+                if (delay > 0 && i > 0) {
+                    yield new Promise((resolve) => setTimeout(resolve, delay));
+                }
+                return yield fn();
+            }
+            catch (error) {
+                lastError = error;
+                if (i === maxRetries - 1) {
+                    throw lastError;
+                }
+            }
+        }
+        throw lastError;
+    });
+}
+const toHump = (str) => str.replace(/\-(\w)/g, (letter) => letter[1].toUpperCase());
+exports.toHump = toHump;

package/lib/utils/loading.js

@@ -0,0 +1,68 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execWithLoading = exports.loadingFactory = void 0;
+const ora_1 = __importDefault(require("ora"));
+class Loading {
+    constructor() {
+        process.on(EVENT.PROCESS_EXIT, this.stop.bind(this));
+        process.on(EVENT.PROCESS_ERROR, this.stop.bind(this));
+        this.spinner = (0, ora_1.default)({
+            discardStdin: false,
+        });
+    }
+    set text(text) {
+        this.spinner.text = text;
+    }
+    start(text) {
+        this.spinner = this.spinner.start(text);
+    }
+    stop() {
+        if (this.spinner) {
+            this.spinner = this.spinner.stop();
+        }
+    }
+    succeed(text) {
+        if (this.spinner) {
+            this.spinner = this.spinner.succeed(text);
+        }
+    }
+    fail(text) {
+        if (this.spinner) {
+            this.spinner = this.spinner.fail(text);
+        }
+    }
+}
+const loadingFactory = () => {
+    return new Loading();
+};
+exports.loadingFactory = loadingFactory;
+const execWithLoading = (task_1, ...args_1) => __awaiter(void 0, [task_1, ...args_1], void 0, function* (task, options = {}) {
+    const { startTip, successTip, failTip } = options;
+    const loading = (0, exports.loadingFactory)();
+    const flush = (text) => {
+        loading.text = text;
+    };
+    try {
+        loading.start(startTip || "执行中...");
+        const res = yield task(flush);
+        successTip ? loading.succeed(successTip) : loading.stop();
+        return res;
+    }
+    catch (e) {
+        failTip ? loading.fail(failTip) : loading.stop();
+        throw e;
+    }
+});
+exports.execWithLoading = execWithLoading;

package/lib/utils/logger.js

@@ -0,0 +1,89 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = void 0;
+const console_1 = require("console");
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const log_symbols_1 = __importDefault(require("log-symbols"));
+const ora_1 = __importDefault(require("ora"));
+const terminal_link_1 = __importDefault(require("terminal-link"));
+class Logger {
+    constructor(options = {}) {
+        this.c = {
+            _times: new Map(),
+            log(a, ...args) {
+                this.debug((0, util_1.format)(a, ...args));
+            },
+        };
+        const { verbose } = options;
+        this.verboseEnabled = verbose || false;
+    }
+    breakLine() {
+        console.log();
+    }
+    log(...args) {
+        console.log(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()}]`)} ${args.join(" ")}`);
+    }
+    info(msg) {
+        console.log(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()}]`)} ${log_symbols_1.default.info} ${msg}`);
+    }
+    success(msg) {
+        console.log(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()}]`)}${log_symbols_1.default.success} ${msg}`);
+    }
+    warn(msg) {
+        console.log(`▶️ ${chalk_1.default.gray(`[${new Date().toLocaleString()}]`)}${log_symbols_1.default.warning} ${msg}`);
+    }
+    error(msg) {
+        console.log(`▶️ ${chalk_1.default.red(`[${new Date().toLocaleString()}]`)}${log_symbols_1.default.error} ${msg}`);
+    }
+    verbose(...args) {
+        if (this.verboseEnabled) {
+            const msg = args.join(" ▶️ ");
+            console.log(`${chalk_1.default.bold("[debug]")} ${chalk_1.default.gray(`[${new Date().toLocaleString()}]`)} ${msg}`);
+        }
+    }
+    debug(...args) {
+        return this.verbose(...args);
+    }
+    genClickableLink(link) {
+        if (terminal_link_1.default.isSupported) {
+            const clickablelink = (0, terminal_link_1.default)(link, link);
+            return chalk_1.default.bold.cyan(clickablelink);
+        }
+        return chalk_1.default.bold.underline.cyan(link);
+    }
+    printClickableLink(link) {
+        const clickLink = this.genClickableLink(link);
+        this.info(clickLink);
+    }
+    time(label, fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promise = typeof fn === "function" ? fn() : fn;
+            if (this.verboseEnabled) {
+                this.c.log(label);
+                console_1.Console.prototype.time.call(this.c, label);
+                const r = yield promise;
+                console_1.Console.prototype.timeEnd.call(this.c, label);
+                return r;
+            }
+            return promise;
+        });
+    }
+    spinner(text, color = "cyan") {
+        return (0, ora_1.default)({ text, color }).start();
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/lib/utils/open-browser.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = void 0;
+const child_process_1 = require("child_process");
+const open_1 = __importDefault(require("open"));
+const openBrowser = (host, port) => {
+    const url = `http://${host}:${port}`;
+    try {
+        (0, child_process_1.execSync)(`osascript ${__dirname}/openChrome.applescript ${encodeURI(url)}`, {
+            stdio: "ignore",
+        });
+        return true;
+    }
+    catch (error) {
+        console.log("error", error);
+        (0, open_1.default)(url, {
+            app: ["google chrome", "--new-window", "--app", "--disable-extensions", "--disable-popup-blocking"],
+        });
+    }
+};
+exports.openBrowser = openBrowser;

package/lib/utils/openChrome.applescript

@@ -0,0 +1,78 @@
+property targetTab: null
+property targetTabIndex: -1
+property targetWindow: null
+
+on run argv
+  set theURL to item 1 of argv
+
+  with timeout of 2 seconds
+    tell application "Chrome"
+
+      if (count every window) = 0 then
+        make new window
+      end if
+
+      -- 1: Looking for tab running debugger
+      -- then, Reload debugging tab if found
+      -- then return
+      set found to my lookupTabWithUrl(theURL)
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        tell targetTab to reload
+        tell targetWindow to activate
+        set index of targetWindow to 1
+        return
+      end if
+
+      -- 2: Looking for Empty tab
+      -- In case debugging tab was not found
+      -- We try to find an empty tab instead
+      set found to my lookupTabWithUrl("chrome://newtab/")
+      if found then
+        set targetWindow's active tab index to targetTabIndex
+        set URL of targetTab to theURL
+        tell targetWindow to activate
+        return
+      end if
+
+      -- 3: Create new tab
+      -- both debugging and empty tab were not found
+      -- make a new tab with url
+      tell window 1
+        activate
+        make new tab with properties {URL:theURL}
+      end tell
+    end tell
+  end timeout
+end run
+
+-- Function:
+-- Lookup tab with given url
+-- if found, store tab, index, and window in properties
+-- (properties were declared on top of file)
+on lookupTabWithUrl(lookupUrl)
+  tell application "Chrome"
+    -- Find a tab with the given url
+    set found to false
+    set theTabIndex to -1
+    repeat with theWindow in every window
+      set theTabIndex to 0
+      repeat with theTab in every tab of theWindow
+        set theTabIndex to theTabIndex + 1
+        if (theTab's URL as string) contains lookupUrl then
+          -- assign tab, tab index, and window to properties
+          set targetTab to theTab
+          set targetTabIndex to theTabIndex
+          set targetWindow to theWindow
+          set found to true
+          exit repeat
+        end if
+      end repeat
+
+      if found then
+        exit repeat
+      end if
+    end repeat
+  end tell
+  return found
+end lookupTabWithUrl