@skillbuilder/minitool-core 0.0.0-beta-20261027053041051

package/lib/services/upload-service.js

@@ -0,0 +1,183 @@
+"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 __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadService = void 0;
+exports.normalizeUploadPermit = normalizeUploadPermit;
+require("reflect-metadata");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const minitool_cli_auth_1 = require("@skillbuilder/minitool-cli-auth");
+const inversify_1 = require("inversify");
+const tokens_1 = require("../di/tokens");
+const cos_uploader_1 = require("../utils/cos-uploader");
+const minitool_api_1 = require("./minitool-api");
+const minitool_contract_1 = require("./minitool-contract");
+/** 与具体业务无关的上传服务：获取临时凭证并把本地文件传输到 COS。 */
+let UploadService = class UploadService {
+    createCos;
+    constructor(createCos) {
+        this.createCos = createCos;
+    }
+    async upload(input) {
+        const filePath = node_path_1.default.resolve(input.filePath);
+        const stat = node_fs_1.default.lstatSync(filePath);
+        if (!stat.isFile() || stat.size === 0)
+            throw new Error("上传文件必须是非空普通文件");
+        const uploader = new cos_uploader_1.Uploader({
+            bizName: input.bizName,
+            scene: input.scene,
+            getToken: input.getPermit,
+            createCos: this.createCos,
+        });
+        const body = node_fs_1.default.createReadStream(filePath);
+        let result;
+        try {
+            result = await uploader.post({
+                Body: body,
+                FilePath: filePath,
+                fileInfo: {
+                    name: node_path_1.default.basename(filePath),
+                    size: stat.size,
+                    type: input.contentType ?? "application/octet-stream",
+                },
+            });
+        }
+        catch (error) {
+            if (error instanceof minitool_contract_1.MiniToolError ||
+                error instanceof minitool_cli_auth_1.AuthenticationRequiredError ||
+                error instanceof minitool_cli_auth_1.CredentialStoreUnavailableError)
+                throw error;
+            throw new Error("文件上传失败，请检查网络和上传权限");
+        }
+        finally {
+            body.destroy();
+        }
+        if (!result.fileId)
+            throw new Error("上传服务未返回 fileId");
+        // ROS 的附带地址可能是 HTTP 或临时签名链接。上传已经成功，业务以 fileId 为准；
+        // 仅向调用方提供可安全展示的持久地址，缺少地址不应阻断后续预览/提审。
+        const url = safeArtifactUrl(result.previewUrl) ?? safeArtifactUrl(result.url);
+        return { fileId: result.fileId, url, cloudType: result.cloudType };
+    }
+};
+exports.UploadService = UploadService;
+exports.UploadService = UploadService = __decorate([
+    (0, inversify_1.injectable)(),
+    __param(0, (0, inversify_1.inject)(tokens_1.MINITOOL_TOKENS.cosClientFactory)),
+    __metadata("design:paramtypes", [Function])
+], UploadService);
+function safeArtifactUrl(value) {
+    if (typeof value !== "string" || !value.trim())
+        return undefined;
+    try {
+        const parsed = new URL(value);
+        if (parsed.protocol === "https:" &&
+            !parsed.username &&
+            !parsed.password &&
+            !parsed.search &&
+            !parsed.hash)
+            return parsed.href;
+    }
+    catch {
+        // 上传返回的可选展示地址格式无效时，仍保留已经成功上传的 fileId。
+    }
+    return undefined;
+}
+/** ROS 上传授权允许 snake_case 与 camelCase；对外只返回文件标识。 */
+function normalizeUploadPermit(data) {
+    const raw = data.uploadTempPermits ?? data.upload_temp_permits;
+    if (!Array.isArray(raw) || !raw.length)
+        throw new Error("没有可用上传授权");
+    const permits = raw.map((item) => {
+        if (!(0, minitool_api_1.isRecord)(item))
+            throw new Error("上传授权格式无效");
+        const value = (camel, snake) => item[camel] ?? item[snake];
+        const fileIds = value("fileIds", "file_ids");
+        const uploadAddr = value("uploadAddr", "upload_addr");
+        if (!Array.isArray(fileIds) ||
+            !fileIds.length ||
+            fileIds.some((id) => typeof id !== "string" || !id) ||
+            typeof uploadAddr !== "string" ||
+            !uploadAddr ||
+            typeof item.token !== "string" ||
+            !item.token ||
+            typeof item.bucket !== "string" ||
+            !item.bucket.trim() ||
+            typeof item.region !== "string" ||
+            !item.region.trim())
+            throw new Error("上传授权字段不完整");
+        const host = new URL(uploadAddr.includes("://") ? uploadAddr : ["https:", "", uploadAddr].join("/"));
+        if (host.protocol !== "https:" || host.username || host.password || host.search || host.hash)
+            throw new Error("上传地址不安全");
+        const secretId = value("secretId", "secret_id");
+        const secretKey = value("secretKey", "secret_key");
+        if (item.bucket !== "unknown" &&
+            (typeof secretId !== "string" || typeof secretKey !== "string" || !secretId || !secretKey))
+            throw new Error("上传授权缺少临时密钥");
+        const numeric = (raw, fallback) => {
+            const number = raw === undefined ? fallback : Number(raw);
+            if ((raw !== undefined && typeof raw !== "number" && typeof raw !== "string") ||
+                (typeof raw === "string" && !raw.trim()) ||
+                !Number.isFinite(number) ||
+                number < 0)
+                throw new Error("上传授权数值无效");
+            return number;
+        };
+        const expireTime = numeric(value("expireTime", "expire_time"), Date.now() + 300_000);
+        if (expireTime <= Date.now())
+            throw new Error("上传授权已过期");
+        return {
+            secretId: typeof secretId === "string" ? secretId : undefined,
+            secretKey: typeof secretKey === "string" ? secretKey : undefined,
+            token: item.token,
+            uploadAddr,
+            bucket: item.bucket,
+            region: item.region,
+            fileIds: fileIds,
+            expireTime,
+            qos: numeric(item.qos, 0),
+            cloudType: numeric(value("cloudType", "cloud_type"), 0),
+            masterCloudId: numeric(value("masterCloudId", "master_cloud_id"), 0),
+            uploadId: numeric(value("uploadId", "upload_id"), 0),
+            cdnDomain: typeof value("cdnDomain", "cdn_domain") === "string"
+                ? String(value("cdnDomain", "cdn_domain"))
+                : undefined,
+        };
+    });
+    const policy = data.uploadLimitPolicy ?? data.upload_limit_policy;
+    if (policy !== undefined && !(0, minitool_api_1.isRecord)(policy))
+        throw new Error("上传限制策略无效");
+    const maxSize = (0, minitool_api_1.isRecord)(policy) ? (policy.maxSize ?? policy.max_size) : undefined;
+    const fileTypes = (0, minitool_api_1.isRecord)(policy) ? (policy.fileTypes ?? policy.file_types) : undefined;
+    if (maxSize !== undefined &&
+        (typeof maxSize !== "number" || !Number.isFinite(maxSize) || maxSize < 0))
+        throw new Error("上传大小限制无效");
+    if (fileTypes !== undefined &&
+        (!Array.isArray(fileTypes) ||
+            fileTypes.some((type) => typeof type !== "string" || !type.trim())))
+        throw new Error("上传文件类型限制无效");
+    return {
+        uploadTempPermits: permits,
+        uploadLimitPolicy: (0, minitool_api_1.isRecord)(policy)
+            ? {
+                // 平台以 0 表示不限大小；本地产物仍受 10 MiB 上限约束。
+                maxSize: typeof maxSize === "number" && maxSize > 0 ? maxSize : undefined,
+                fileTypes: fileTypes,
+            }
+            : undefined,
+    };
+}

package/lib/utils/config-merger.js

@@ -0,0 +1,63 @@
+"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"));
+/**
+ * 历史 Agent/云函数配置工具，当前小工具 CLI 不调用。
+ * 合并 project.config.json 和 agent-cloudbase-functions.json 配置。
+ * 将 project.config.json 中的白名单属性（agentId、version）合并到 agent-cloudbase-functions.json
+ */
+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,120 @@
+"use strict";
+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 {
+    // 上传业务，用于和 scene 指定上传云服务的 bucket，需业务方从媒体中台申请
+    bizName;
+    // 上传场景，用于和 bizName 指定上传云服务的 bucket，需业务方从媒体中台申请
+    scene;
+    // 获取上传 token 的异步请求
+    getToken;
+    enableResume;
+    createCos;
+    constructor(args) {
+        this.bizName = args.bizName;
+        this.scene = args.scene;
+        this.getToken = args.getToken;
+        this.enableResume = args.enableResume;
+        this.createCos = args.createCos ?? ((options) => new cos_nodejs_sdk_v5_1.default(options));
+    }
+    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?.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?.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, ...rest } = options;
+        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") {
+                // @ts-ignore 特殊参数，自建通道时没有 bucket
+                cosInitParams.AppId = "1251524319";
+            }
+            const cos = this.createCos(cosInitParams);
+            if (onInstanceCreated) {
+                onInstanceCreated(cos);
+            }
+            return cos
+                .uploadFile({
+                Bucket: permit.bucket,
+                Region: permit.region,
+                Key: fileId,
+                ...rest,
+            })
+                .then((resp) => {
+                const payload = {
+                    ...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;
+                }
+                // 返回所有自定义 header（ 'x-ros' 自检服务约定）
+                if (resp?.headers) {
+                    Object.keys(resp.headers).forEach((v) => {
+                        if (v.startsWith("x-ros-")) {
+                            const key = (0, to_hump_1.toHump)(v.split("x-ros-")[1]);
+                            // @ts-ignore
+                            payload[key] = resp.headers?.[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,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toHump = void 0;
+exports.getFixedFormatTime = getFixedFormatTime;
+exports.getNonce = getNonce;
+exports.getMd5 = getMd5;
+exports.guid = guid;
+exports.retry = retry;
+const node_crypto_1 = require("node:crypto");
+const dayjs_1 = __importDefault(require("dayjs"));
+var to_hump_1 = require("./to-hump");
+Object.defineProperty(exports, "toHump", { enumerable: true, get: function () { return to_hump_1.toHump; } });
+function getFixedFormatTime(format, timeDistance = 0) {
+    return (0, dayjs_1.default)().add(timeDistance, "millisecond").format(format);
+}
+/** 安全随机数；可用于请求 nonce，不使用 Math.random。 */
+function getNonce() {
+    return (0, node_crypto_1.randomBytes)(8).toString("hex");
+}
+/** 仅供非安全场景的兼容性摘要，不应用于签名或密码存储。 */
+function getMd5(value) {
+    return (0, node_crypto_1.createHash)("md5").update(value).digest("hex");
+}
+function guid() {
+    return (0, node_crypto_1.randomUUID)();
+}
+async function retry(fn, maxRetries = 5, delay = 0) {
+    if (!Number.isInteger(maxRetries) || maxRetries < 1) {
+        throw new RangeError("maxRetries 必须是正整数");
+    }
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (attempt === maxRetries)
+                throw error;
+            if (delay > 0)
+                await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+    throw new Error("重试次数已用尽");
+}

package/lib/utils/loading.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loading = void 0;
+exports.loadingFactory = loadingFactory;
+exports.execWithLoading = execWithLoading;
+const ora_1 = __importDefault(require("ora"));
+class Loading {
+    spinner = (0, ora_1.default)({ discardStdin: false });
+    set text(value) {
+        this.spinner.text = value;
+    }
+    start(text) {
+        this.spinner.start(text);
+    }
+    stop() {
+        this.spinner.stop();
+    }
+    succeed(text) {
+        this.spinner.succeed(text);
+    }
+    fail(text) {
+        this.spinner.fail(text);
+    }
+}
+exports.Loading = Loading;
+function loadingFactory() {
+    return new Loading();
+}
+async function execWithLoading(task, options = {}) {
+    const loading = loadingFactory();
+    try {
+        loading.start(options.startTip || "执行中...");
+        const result = await task((text) => {
+            loading.text = text;
+        });
+        if (options.successTip)
+            loading.succeed(options.successTip);
+        else
+            loading.stop();
+        return result;
+    }
+    catch (error) {
+        if (options.failTip)
+            loading.fail(options.failTip);
+        else
+            loading.stop();
+        throw error;
+    }
+}

package/lib/utils/logger.js

@@ -0,0 +1,83 @@
+"use strict";
+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 {
+    c = {
+        _times: new Map(),
+        log(a, ...args) {
+            // @ts-ignore
+            this.debug((0, util_1.format)(a, ...args));
+        },
+    };
+    verboseEnabled;
+    constructor(options = {}) {
+        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}`);
+        }
+    }
+    /**
+     * alias for verbose
+     */
+    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);
+    }
+    async time(label, fn) {
+        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 = await 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,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openBrowser = openBrowser;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+const open_1 = __importDefault(require("open"));
+/** 打开本地预览页。参数通过 execFileSync 的 argv 传递，不经过 shell。 */
+async function openBrowser(host, port) {
+    if (!Number.isInteger(port) || port < 1 || port > 65535)
+        throw new RangeError("端口号无效");
+    const url = new URL(`http://${host}:${port}`);
+    if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) {
+        throw new Error("浏览器地址无效");
+    }
+    if (process.platform === "darwin") {
+        try {
+            (0, node_child_process_1.execFileSync)("osascript", [node_path_1.default.join(__dirname, "openChrome.applescript"), url.toString()], {
+                stdio: "ignore",
+                timeout: 2500,
+            });
+            return true;
+        }
+        catch {
+            // Chrome 不可用时改由系统默认浏览器打开。
+        }
+    }
+    await (0, open_1.default)(url.toString());
+    return true;
+}

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 "Google 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 "Google 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