@godscene/shared 1.7.11

package/dist/es/us-keyboard-layout.mjs.LICENSE.txt

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/es/utils.mjs

@@ -0,0 +1,72 @@
+import { sha256 } from "js-sha256";
+import { v4 } from "uuid";
+const ifInBrowser = "u" > typeof window;
+const ifInWorker = "u" > typeof WorkerGlobalScope;
+const ifInNode = "u" > typeof process && process.versions?.node;
+function uuid() {
+    return v4();
+}
+const hashMap = {};
+function generateHashId(rect, content = '') {
+    const combined = JSON.stringify({
+        content,
+        rect
+    });
+    let sliceLength = 5;
+    let slicedHash = '';
+    const hashHex = sha256.create().update(combined).hex();
+    const toLetters = (hex)=>hex.split('').map((char)=>{
+            const code = Number.parseInt(char, 16);
+            return String.fromCharCode(97 + code % 26);
+        }).join('');
+    const hashLetters = toLetters(hashHex);
+    while(sliceLength < hashLetters.length - 1){
+        slicedHash = hashLetters.slice(0, sliceLength);
+        if (hashMap[slicedHash] && hashMap[slicedHash] !== combined) {
+            sliceLength++;
+            continue;
+        }
+        hashMap[slicedHash] = combined;
+        break;
+    }
+    return slicedHash;
+}
+function assert(condition, message) {
+    if (!condition) throw new Error(message || 'Assertion failed');
+}
+let isMcp = false;
+function setIsMcp(value) {
+    isMcp = value;
+}
+function logMsg(...message) {
+    if (!isMcp) console.log(...message);
+}
+async function repeat(times, fn) {
+    for(let i = 0; i < times; i++)await fn(i);
+}
+const utils_REGEXP_LT = /</g;
+const utils_REGEXP_GT = />/g;
+const REGEXP_LT_ESCAPE = '__midscene_lt__';
+const REGEXP_GT_ESCAPE = '__midscene_gt__';
+const escapeScriptTag = (html)=>html.replace(utils_REGEXP_LT, REGEXP_LT_ESCAPE).replace(utils_REGEXP_GT, REGEXP_GT_ESCAPE);
+const antiEscapeScriptTag = (html)=>{
+    const REGEXP_LT = new RegExp(REGEXP_LT_ESCAPE, 'g');
+    const REGEXP_GT = new RegExp(REGEXP_GT_ESCAPE, 'g');
+    return html.replace(REGEXP_LT, '<').replace(REGEXP_GT, '>');
+};
+function replaceIllegalPathCharsAndSpace(str) {
+    return str.replace(/[:*?"<>|# ]/g, '-');
+}
+function isPlainObject(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value);
+}
+function normalizeForComparison(str) {
+    return str.toLowerCase().replace(/[\s\-_]+/g, '');
+}
+function mergeAndNormalizeAppNameMapping(defaultMapping, userMapping) {
+    const result = {};
+    for (const [key, value] of Object.entries(defaultMapping))result[normalizeForComparison(key)] = value;
+    if (userMapping) for (const [key, value] of Object.entries(userMapping))result[normalizeForComparison(key)] = value;
+    return result;
+}
+export { antiEscapeScriptTag, assert, escapeScriptTag, generateHashId, ifInBrowser, ifInNode, ifInWorker, isPlainObject, logMsg, mergeAndNormalizeAppNameMapping, normalizeForComparison, repeat, replaceIllegalPathCharsAndSpace, setIsMcp, uuid };

package/dist/es/zod-schema-utils.mjs

@@ -0,0 +1,54 @@
+function unwrapZodField(field) {
+    const f = field;
+    if (!f._def) return f;
+    const typeName = f._def.typeName;
+    if ('ZodOptional' === typeName || 'ZodNullable' === typeName || 'ZodDefault' === typeName) return unwrapZodField(f._def.innerType);
+    if ('ZodEffects' === typeName) {
+        if (f._def.schema) return unwrapZodField(f._def.schema);
+    }
+    return f;
+}
+function isMidsceneLocatorField(field) {
+    const actualField = unwrapZodField(field);
+    if (actualField._def?.typeName === 'ZodObject') {
+        const shape = actualField._def.shape?.();
+        if (shape) {
+            if ('midscene_location_field_flag' in shape) return true;
+            if ('prompt' in shape && shape.prompt) return true;
+        }
+    }
+    return false;
+}
+function getZodTypeName(field, locatorTypeDescription) {
+    const actualField = unwrapZodField(field);
+    const fieldTypeName = actualField._def?.typeName;
+    if ('ZodString' === fieldTypeName) return 'string';
+    if ('ZodNumber' === fieldTypeName) return 'number';
+    if ('ZodBoolean' === fieldTypeName) return 'boolean';
+    if ('ZodArray' === fieldTypeName) return 'array';
+    if ('ZodObject' === fieldTypeName) {
+        if (isMidsceneLocatorField(actualField)) return locatorTypeDescription || 'object';
+        return 'object';
+    }
+    if ('ZodEnum' === fieldTypeName) {
+        const values = actualField._def?.values?.map((option)=>String(`'${option}'`)).join(', ') ?? 'enum';
+        return `enum(${values})`;
+    }
+    if ('ZodUnion' === fieldTypeName) {
+        const options = actualField._def?.options;
+        if (options && options.length > 0) {
+            const types = options.map((opt)=>getZodTypeName(opt, locatorTypeDescription));
+            return types.join(' | ');
+        }
+        return 'union';
+    }
+    return 'unknown';
+}
+function getZodDescription(field) {
+    if ("description" in field) return field.description || null;
+    const actualField = unwrapZodField(field);
+    if ("description" in actualField) return actualField.description || null;
+    if (isMidsceneLocatorField(actualField)) return 'Location information for the target element';
+    return null;
+}
+export { getZodDescription, getZodTypeName, isMidsceneLocatorField, unwrapZodField };

package/dist/lib/baseDB.js

@@ -0,0 +1,149 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    IndexedDBManager: ()=>IndexedDBManager,
+    createCleanupFunction: ()=>createCleanupFunction,
+    withErrorHandling: ()=>withErrorHandling
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class IndexedDBManager {
+    initDB() {
+        return new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, this.version);
+            request.onerror = ()=>reject(request.error);
+            request.onsuccess = ()=>resolve(request.result);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                this.storeConfigs.forEach(({ name, keyPath })=>{
+                    if (!db.objectStoreNames.contains(name)) {
+                        const store = db.createObjectStore(name, {
+                            keyPath
+                        });
+                        store.createIndex('timestamp', 'timestamp', {
+                            unique: false
+                        });
+                    }
+                });
+            };
+        });
+    }
+    async withTransaction(storeNames, mode, operation) {
+        const db = await this.dbPromise;
+        const transaction = db.transaction(storeNames, mode);
+        const stores = Array.isArray(storeNames) ? storeNames.map((name)=>transaction.objectStore(name)) : transaction.objectStore(storeNames);
+        return operation(stores);
+    }
+    promisifyRequest(request) {
+        return new Promise((resolve, reject)=>{
+            request.onsuccess = ()=>resolve(request.result);
+            request.onerror = ()=>reject(request.error);
+        });
+    }
+    async put(storeName, data) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.put(data));
+        });
+    }
+    async get(storeName, key) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.get(key)));
+    }
+    async getAll(storeName, sortByTimestamp = true) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>{
+            const objectStore = store;
+            const results = sortByTimestamp ? await this.promisifyRequest(objectStore.index('timestamp').getAll()) : await this.promisifyRequest(objectStore.getAll());
+            return sortByTimestamp ? results.sort((a, b)=>a.timestamp - b.timestamp) : results;
+        });
+    }
+    async clear(storeName) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.clear());
+        });
+    }
+    async delete(storeName, key) {
+        await this.withTransaction(storeName, 'readwrite', async (store)=>{
+            await this.promisifyRequest(store.delete(key));
+        });
+    }
+    async count(storeName) {
+        return this.withTransaction(storeName, 'readonly', async (store)=>this.promisifyRequest(store.count()));
+    }
+    getDBPromise() {
+        return this.dbPromise;
+    }
+    constructor(dbName, version, storeConfigs){
+        _define_property(this, "dbPromise", void 0);
+        _define_property(this, "dbName", void 0);
+        _define_property(this, "version", void 0);
+        _define_property(this, "storeConfigs", void 0);
+        this.dbName = dbName;
+        this.version = version;
+        this.storeConfigs = storeConfigs;
+        this.dbPromise = this.initDB();
+    }
+}
+const withErrorHandling = async (operation, errorMessage, defaultValue, onQuotaExceeded)=>{
+    try {
+        return await operation();
+    } catch (e) {
+        console.error(errorMessage, e);
+        if (e instanceof Error && 'QuotaExceededError' === e.name && onQuotaExceeded) {
+            console.log('Storage quota exceeded, running cleanup...');
+            await onQuotaExceeded();
+        }
+        return defaultValue;
+    }
+};
+const createCleanupFunction = (dbManager, storeName, maxItems)=>async ()=>{
+        try {
+            const results = await dbManager.getAll(storeName);
+            if (results.length > maxItems) {
+                const toDelete = results.sort((a, b)=>a.timestamp - b.timestamp).slice(0, results.length - maxItems);
+                await Promise.all(toDelete.map((item)=>dbManager.delete(storeName, item.id)));
+            }
+        } catch (e) {
+            console.error(`Failed to cleanup ${storeName}:`, e);
+        }
+    };
+exports.IndexedDBManager = __webpack_exports__.IndexedDBManager;
+exports.createCleanupFunction = __webpack_exports__.createCleanupFunction;
+exports.withErrorHandling = __webpack_exports__.withErrorHandling;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "IndexedDBManager",
+    "createCleanupFunction",
+    "withErrorHandling"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/cli-args.js

@@ -0,0 +1,138 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    parseCliArgs: ()=>parseCliArgs,
+    parseValue: ()=>parseValue,
+    formatCliValidationError: ()=>formatCliValidationError,
+    getCliOptionDisplay: ()=>getCliOptionDisplay
+});
+const external_zod_namespaceObject = require("zod");
+const external_key_alias_utils_js_namespaceObject = require("../key-alias-utils.js");
+function parseValue(raw) {
+    if (raw.startsWith('{') || raw.startsWith('[')) try {
+        return JSON.parse(raw);
+    } catch  {}
+    if (/^-?\d+(\.\d+)?$/.test(raw)) return Number(raw);
+    return raw;
+}
+function walkCliArgs(args, setArgValue) {
+    for(let i = 0; i < args.length; i++){
+        const arg = args[i];
+        if (!arg.startsWith('--')) continue;
+        const body = arg.slice(2);
+        const eqIdx = body.indexOf('=');
+        if (eqIdx >= 0) setArgValue(body.slice(0, eqIdx), parseValue(body.slice(eqIdx + 1)));
+        else if (args[i + 1] && !args[i + 1].startsWith('--')) {
+            i++;
+            setArgValue(body, parseValue(args[i]));
+        } else setArgValue(body, true);
+    }
+}
+function parseCliArgs(args) {
+    const result = {};
+    walkCliArgs(args, (key, value)=>{
+        result[key] = value;
+    });
+    return result;
+}
+function formatCliOptionName(name) {
+    return `--${name}`;
+}
+function getCliOptionDisplay(key, cliOption) {
+    const label = formatCliOptionName(cliOption?.preferredName ?? key);
+    const aliases = [
+        ...new Set(cliOption?.aliases ?? [])
+    ].map((alias)=>formatCliOptionName(alias)).filter((alias)=>alias !== label);
+    return {
+        label,
+        aliases
+    };
+}
+function getAcceptedCliOptionNames(key, cliOption) {
+    return [
+        ...new Set(cliOption ? [
+            cliOption.preferredName ?? key,
+            ...cliOption.aliases ?? []
+        ] : [
+            key,
+            ...(0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(key)
+        ])
+    ];
+}
+function toOptionalCliSchemaField(field) {
+    if ('object' == typeof field && null !== field && 'function' == typeof field.optional) return field.optional();
+    const description = 'object' == typeof field && null !== field && "description" in field && 'string' == typeof field.description ? field.description : void 0;
+    return description ? external_zod_namespaceObject.z.any().describe(description) : external_zod_namespaceObject.z.any();
+}
+function buildCliArgSchema(def) {
+    return Object.fromEntries(Object.entries(def.schema).flatMap(([key, zodType])=>getAcceptedCliOptionNames(key, def.cli?.options?.[key]).map((cliKey)=>[
+                cliKey,
+                toOptionalCliSchemaField(zodType)
+            ])));
+}
+function buildDisallowedCliSpellings(def) {
+    const disallowedSpellings = new Set();
+    for (const [key] of Object.entries(def.schema)){
+        const cliOption = def.cli?.options?.[key];
+        const acceptedNames = new Set(getAcceptedCliOptionNames(key, cliOption));
+        const knownSpellings = new Set([
+            key,
+            ...(0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(key),
+            ...cliOption?.preferredName ? (0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(cliOption.preferredName) : [],
+            ...cliOption?.aliases ?? []
+        ]);
+        for (const spelling of knownSpellings)if (!acceptedNames.has(spelling)) disallowedSpellings.add(spelling);
+    }
+    return disallowedSpellings;
+}
+function formatCliValidationError(scriptName, commandName, def, rawArgs) {
+    if (0 === Object.keys(def.schema).length) return;
+    const cliSchema = external_zod_namespaceObject.z.object(buildCliArgSchema(def)).strict();
+    const parsed = cliSchema.safeParse(rawArgs);
+    if (parsed.success) return;
+    const disallowedSpellings = buildDisallowedCliSpellings(def);
+    const unknownKeys = parsed.error.issues.flatMap((issue)=>'unrecognized_keys' === issue.code ? issue.keys : []);
+    if (unknownKeys.length > 0) return unknownKeys.map((key)=>{
+        if (disallowedSpellings.has(key)) return `Unsupported option "--${key}" for ${scriptName} ${commandName}.`;
+        return `Unknown option "--${key}" for ${scriptName} ${commandName}.`;
+    }).join('\n');
+    const [issue] = parsed.error.issues;
+    const optionName = 'string' == typeof issue?.path[0] ? `--${issue.path[0]}` : 'CLI arguments';
+    return `Invalid value for "${optionName}" in ${scriptName} ${commandName}: ${issue?.message ?? parsed.error.message}`;
+}
+exports.formatCliValidationError = __webpack_exports__.formatCliValidationError;
+exports.getCliOptionDisplay = __webpack_exports__.getCliOptionDisplay;
+exports.parseCliArgs = __webpack_exports__.parseCliArgs;
+exports.parseValue = __webpack_exports__.parseValue;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "formatCliValidationError",
+    "getCliOptionDisplay",
+    "parseCliArgs",
+    "parseValue"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/cli-error.js

@@ -0,0 +1,61 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CLIError: ()=>CLIError,
+    reportCLIError: ()=>reportCLIError
+});
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class CLIError extends Error {
+    constructor(message, exitCode = 1){
+        super(message), _define_property(this, "exitCode", void 0), this.exitCode = exitCode;
+    }
+}
+function reportCLIError(error, log = console.error) {
+    if (error instanceof CLIError) {
+        log(error.message);
+        return error.exitCode;
+    }
+    log(error);
+    return 1;
+}
+exports.CLIError = __webpack_exports__.CLIError;
+exports.reportCLIError = __webpack_exports__.reportCLIError;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLIError",
+    "reportCLIError"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/cli/cli-runner.js

@@ -0,0 +1,181 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    CLIError: ()=>external_cli_error_js_namespaceObject.CLIError,
+    parseCliArgs: ()=>external_cli_args_js_namespaceObject.parseCliArgs,
+    parseValue: ()=>external_cli_args_js_namespaceObject.parseValue,
+    runToolsCLI: ()=>runToolsCLI,
+    reportCLIError: ()=>external_cli_error_js_namespaceObject.reportCLIError,
+    removePrefix: ()=>removePrefix
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_os_namespaceObject = require("node:os");
+const external_node_path_namespaceObject = require("node:path");
+const external_dotenv_namespaceObject = require("dotenv");
+var external_dotenv_default = /*#__PURE__*/ __webpack_require__.n(external_dotenv_namespaceObject);
+const external_logger_js_namespaceObject = require("../logger.js");
+const external_cli_args_js_namespaceObject = require("./cli-args.js");
+const external_cli_error_js_namespaceObject = require("./cli-error.js");
+const debug = (0, external_logger_js_namespaceObject.getDebug)('cli-runner');
+function outputContentItem(item, isError) {
+    switch(item.type){
+        case 'text':
+            if (isError) console.error(item.text);
+            else console.log(item.text);
+            break;
+        case 'image':
+            {
+                const filename = `screenshot-${Date.now()}.png`;
+                const filepath = (0, external_node_path_namespaceObject.join)((0, external_node_os_namespaceObject.tmpdir)(), filename);
+                (0, external_node_fs_namespaceObject.writeFileSync)(filepath, Buffer.from(item.data, 'base64'));
+                console.log(`Screenshot saved: ${filepath}`);
+                break;
+            }
+        default:
+            console.log(`[${item.type} content not displayed in CLI]`);
+    }
+}
+function outputResult(result) {
+    for (const item of result.content)outputContentItem(item, result.isError ?? false);
+}
+function removePrefix(name, prefix) {
+    if (prefix && name.startsWith(prefix)) return name.slice(prefix.length);
+    return name;
+}
+function printCommandHelp(scriptName, cmd) {
+    const { def } = cmd;
+    console.log(`\nUsage: ${scriptName} ${cmd.name} [options]\n`);
+    console.log(def.description);
+    const schemaEntries = Object.entries(def.schema);
+    if (schemaEntries.length > 0) {
+        const optionWidth = Math.max(22, ...schemaEntries.map(([key])=>(0, external_cli_args_js_namespaceObject.getCliOptionDisplay)(key, def.cli?.options?.[key]).label.length));
+        console.log('\nOptions:');
+        for (const [key, zodType] of schemaEntries){
+            const { label, aliases } = (0, external_cli_args_js_namespaceObject.getCliOptionDisplay)(key, def.cli?.options?.[key]);
+            const desc = zodType.description ?? '';
+            const aliasText = aliases.length > 0 ? ` (aliases: ${aliases.join(', ')})` : '';
+            console.log(`  ${label.padEnd(optionWidth)} ${desc}${aliasText}`);
+        }
+    }
+}
+function printVersion(scriptName, version) {
+    console.log(`${scriptName} v${version}`);
+}
+function printHelp(scriptName, commands, version) {
+    if (version) {
+        printVersion(scriptName, version);
+        console.log('');
+    }
+    console.log(`\nUsage: ${scriptName} <command> [options]\n`);
+    console.log('Commands:');
+    for (const { name, def } of commands.filter((command)=>!command.hidden))console.log(`  ${name.padEnd(30)} ${def.description}`);
+    console.log(`  ${'version'.padEnd(30)} Show CLI version`);
+    console.log(`\nRun "${scriptName} <command> --help" for more info.`);
+}
+async function runToolsCLI(tools, scriptName, options) {
+    const rawArgs = options?.argv ?? process.argv.slice(2);
+    debug('CLI invoked: %s %s', scriptName, rawArgs.join(' '));
+    const envFile = (0, external_node_path_namespaceObject.join)(process.cwd(), '.env');
+    if ((0, external_node_fs_namespaceObject.existsSync)(envFile)) external_dotenv_default().config({
+        path: envFile
+    });
+    await tools.initTools();
+    const commands = tools.getToolDefinitions().map((def)=>({
+            name: removePrefix(def.name, options?.stripPrefix).toLowerCase(),
+            def
+        }));
+    if (options?.extraCommands?.length) commands.push(...options.extraCommands.flatMap((cmd)=>[
+            {
+                name: cmd.name.toLowerCase(),
+                def: cmd.def,
+                hidden: cmd.hidden
+            },
+            ...(cmd.aliases ?? []).map((alias)=>({
+                    name: alias.toLowerCase(),
+                    def: cmd.def,
+                    hidden: true
+                }))
+        ]));
+    const cliVersion = options?.version;
+    const [commandName, ...restArgs] = rawArgs;
+    if (!commandName || '--help' === commandName || '-h' === commandName) {
+        debug('showing help (no command or --help flag)');
+        printHelp(scriptName, commands, cliVersion);
+        return;
+    }
+    if ('--version' === commandName || '-v' === commandName || 'version' === commandName.toLowerCase()) {
+        if (!cliVersion) throw new external_cli_error_js_namespaceObject.CLIError('Failed to determine CLI version');
+        printVersion(scriptName, cliVersion);
+        return;
+    }
+    const match = commands.find((c)=>c.name.toLowerCase() === commandName.toLowerCase());
+    if (!match) {
+        debug('unknown command: %s', commandName);
+        console.error(`Unknown command: ${commandName}`);
+        printHelp(scriptName, commands, cliVersion);
+        throw new external_cli_error_js_namespaceObject.CLIError(`Unknown command: ${commandName}`);
+    }
+    const parsedArgs = (0, external_cli_args_js_namespaceObject.parseCliArgs)(restArgs);
+    if (true === parsedArgs.help) {
+        debug('showing command help for: %s', match.name);
+        printCommandHelp(scriptName, match);
+        return;
+    }
+    const cliValidationError = (0, external_cli_args_js_namespaceObject.formatCliValidationError)(scriptName, match.name, match.def, parsedArgs);
+    if (cliValidationError) throw new external_cli_error_js_namespaceObject.CLIError(cliValidationError);
+    debug('command: %s, args: %s', match.name, JSON.stringify(parsedArgs));
+    const result = await match.def.handler(parsedArgs);
+    debug('command %s completed, isError: %s', match.name, result.isError ?? false);
+    outputResult(result);
+    await tools.destroy();
+    if (result.isError) throw new external_cli_error_js_namespaceObject.CLIError('Command failed', 1);
+}
+exports.CLIError = __webpack_exports__.CLIError;
+exports.parseCliArgs = __webpack_exports__.parseCliArgs;
+exports.parseValue = __webpack_exports__.parseValue;
+exports.removePrefix = __webpack_exports__.removePrefix;
+exports.reportCLIError = __webpack_exports__.reportCLIError;
+exports.runToolsCLI = __webpack_exports__.runToolsCLI;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "CLIError",
+    "parseCliArgs",
+    "parseValue",
+    "removePrefix",
+    "reportCLIError",
+    "runToolsCLI"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});