@aiscene/shared 8.0.2 → 8.0.4

package/dist/lib/agent-tools/cli-report-session.js

@@ -0,0 +1,121 @@
+"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 ('undefined' != 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__, {
+    createCliReportSession: ()=>createCliReportSession,
+    generateCliReportSession: ()=>generateCliReportSession,
+    readCliReportSession: ()=>readCliReportSession,
+    writeCliReportSession: ()=>writeCliReportSession
+});
+const external_node_fs_namespaceObject = require("node:fs");
+const external_node_path_namespaceObject = require("node:path");
+const external_common_js_namespaceObject = require("../common.js");
+const sessionDirName = 'cli-report-session';
+function sanitizeSessionName(sessionName) {
+    return sessionName.replace(/[^a-zA-Z0-9._-]/g, '_') || 'default';
+}
+function sanitizeFileSegment(segment) {
+    const sanitized = segment.replace(/[^a-zA-Z0-9._-]/g, '_') || 'unknown';
+    return sanitized.slice(0, 80);
+}
+function ensureHtmlFileName(reportFileName) {
+    return reportFileName.endsWith('.html') ? reportFileName : `${reportFileName}.html`;
+}
+function formatDateForFileName(date) {
+    const pad = (value)=>String(value).padStart(2, '0');
+    const day = [
+        date.getFullYear(),
+        pad(date.getMonth() + 1),
+        pad(date.getDate())
+    ].join('-');
+    const time = [
+        pad(date.getHours()),
+        pad(date.getMinutes()),
+        pad(date.getSeconds())
+    ].join('-');
+    return `${day}_${time}`;
+}
+function randomId() {
+    return Math.random().toString(36).slice(2, 10);
+}
+function getCliReportSessionDir() {
+    const dir = (0, external_node_path_namespaceObject.join)((0, external_common_js_namespaceObject.getMidsceneRunBaseDir)(), sessionDirName);
+    if (!(0, external_node_fs_namespaceObject.existsSync)(dir)) (0, external_node_fs_namespaceObject.mkdirSync)(dir, {
+        recursive: true
+    });
+    return dir;
+}
+function getCliReportSessionPath(sessionName) {
+    return (0, external_node_path_namespaceObject.join)(getCliReportSessionDir(), `${sanitizeSessionName(sessionName)}.json`);
+}
+function generateCliReportSession(sessionName, targetIdentity) {
+    const identitySegment = targetIdentity ? `-${sanitizeFileSegment(targetIdentity)}` : '';
+    const reportFileName = `${sanitizeSessionName(sessionName)}${identitySegment}-${formatDateForFileName(new Date())}-${randomId()}`;
+    const reportPath = (0, external_node_path_namespaceObject.join)((0, external_common_js_namespaceObject.getMidsceneRunSubDir)('report'), ensureHtmlFileName(reportFileName));
+    const session = {
+        version: 1,
+        sessionName,
+        ...targetIdentity ? {
+            targetIdentity
+        } : {},
+        reportFileName,
+        reportPath,
+        createdAt: Date.now()
+    };
+    return session;
+}
+function writeCliReportSession(session) {
+    (0, external_node_fs_namespaceObject.writeFileSync)(getCliReportSessionPath(session.sessionName), JSON.stringify(session, null, 2), 'utf-8');
+}
+function createCliReportSession(sessionName, targetIdentity) {
+    const session = generateCliReportSession(sessionName, targetIdentity);
+    writeCliReportSession(session);
+    return session;
+}
+function readCliReportSession(sessionName) {
+    const sessionPath = getCliReportSessionPath(sessionName);
+    if (!(0, external_node_fs_namespaceObject.existsSync)(sessionPath)) return;
+    try {
+        const raw = (0, external_node_fs_namespaceObject.readFileSync)(sessionPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (1 !== parsed.version || parsed.sessionName !== sessionName || 'string' != typeof parsed.reportFileName || !parsed.reportFileName.trim() || /[\\/]/.test(parsed.reportFileName)) return;
+        return parsed;
+    } catch  {
+        return;
+    }
+}
+exports.createCliReportSession = __webpack_exports__.createCliReportSession;
+exports.generateCliReportSession = __webpack_exports__.generateCliReportSession;
+exports.readCliReportSession = __webpack_exports__.readCliReportSession;
+exports.writeCliReportSession = __webpack_exports__.writeCliReportSession;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createCliReportSession",
+    "generateCliReportSession",
+    "readCliReportSession",
+    "writeCliReportSession"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/agent-tools/error-formatter.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 ('undefined' != 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__, {
+    getErrorMessage: ()=>getErrorMessage,
+    getErrorStack: ()=>getErrorStack,
+    serializeError: ()=>serializeError,
+    truncateSerializedErrorString: ()=>truncateSerializedErrorString
+});
+const maxSerializedStringLength = 4096;
+const truncatedStringSuffix = '… [truncated]';
+function isObject(error) {
+    return 'object' == typeof error && null !== error || 'function' == typeof error;
+}
+function safelyReadProperty(error, key) {
+    try {
+        return Reflect.get(error, key);
+    } catch  {
+        return;
+    }
+}
+function readBoundedDiagnostic(error, keys) {
+    for (const key of keys){
+        const value = safelyReadProperty(error, key);
+        if ('number' == typeof value) return value;
+        if ('string' == typeof value) return truncateSerializedErrorString(value);
+    }
+}
+function truncateSerializedErrorString(value) {
+    if (value.length <= maxSerializedStringLength) return value;
+    return `${value.slice(0, maxSerializedStringLength - truncatedStringSuffix.length)}${truncatedStringSuffix}`;
+}
+function readNonEmptyMessage(error) {
+    const message = safelyReadProperty(error, 'message');
+    return 'string' == typeof message && message ? message : void 0;
+}
+function extractStringMessage(error) {
+    const directMessage = readNonEmptyMessage(error);
+    if (directMessage) return directMessage;
+    for (const nestedKey of [
+        'error',
+        'cause'
+    ]){
+        const nestedError = safelyReadProperty(error, nestedKey);
+        if (!isObject(nestedError)) continue;
+        const nestedMessage = readNonEmptyMessage(nestedError);
+        if (nestedMessage) return nestedMessage;
+    }
+}
+function getErrorMessage(error) {
+    const result = serializeErrorValue(error);
+    const serialized = result.error;
+    if (!isObject(error) || result.hasMessage) return serialized.message;
+    const summary = {
+        name: serialized.name,
+        message: serialized.message
+    };
+    for (const key of [
+        'code',
+        'status',
+        'requestId'
+    ]){
+        const value = serialized[key];
+        if (void 0 !== value) summary[key] = value;
+    }
+    return truncateSerializedErrorString(JSON.stringify(summary));
+}
+function getErrorStack(error) {
+    if (!isObject(error)) return;
+    const stack = safelyReadProperty(error, 'stack');
+    return 'string' == typeof stack ? stack : void 0;
+}
+function serializeErrorValue(error) {
+    if (!isObject(error)) {
+        const message = truncateSerializedErrorString(String(error));
+        return {
+            error: {
+                name: 'NonError',
+                message: message.trim() ? message : 'Empty string thrown'
+            },
+            hasMessage: Boolean(message.trim())
+        };
+    }
+    const name = safelyReadProperty(error, 'name');
+    const serializedName = truncateSerializedErrorString('string' == typeof name && name ? name : 'Error');
+    const message = extractStringMessage(error);
+    const serialized = {
+        name: serializedName,
+        message: truncateSerializedErrorString(message ?? `${serializedName} without a message`)
+    };
+    const stack = getErrorStack(error);
+    if (stack) serialized.stack = truncateSerializedErrorString(stack);
+    const code = readBoundedDiagnostic(error, [
+        'code'
+    ]);
+    const status = readBoundedDiagnostic(error, [
+        'status',
+        'statusCode'
+    ]);
+    const requestId = readBoundedDiagnostic(error, [
+        'requestId',
+        'requestID'
+    ]);
+    if (void 0 !== code) serialized.code = code;
+    if (void 0 !== status) serialized.status = status;
+    if (void 0 !== requestId) serialized.requestId = requestId;
+    return {
+        error: serialized,
+        hasMessage: void 0 !== message
+    };
+}
+function serializeError(error) {
+    return serializeErrorValue(error).error;
+}
+exports.getErrorMessage = __webpack_exports__.getErrorMessage;
+exports.getErrorStack = __webpack_exports__.getErrorStack;
+exports.serializeError = __webpack_exports__.serializeError;
+exports.truncateSerializedErrorString = __webpack_exports__.truncateSerializedErrorString;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getErrorMessage",
+    "getErrorStack",
+    "serializeError",
+    "truncateSerializedErrorString"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/agent-tools/index.js

@@ -0,0 +1,114 @@
+"use strict";
+var __webpack_modules__ = {
+    "./agent-behavior-init-args" (module) {
+        module.exports = require("./agent-behavior-init-args.js");
+    },
+    "./base-tools" (module) {
+        module.exports = require("./base-tools.js");
+    },
+    "./chrome-path" (module) {
+        module.exports = require("./chrome-path.js");
+    },
+    "./error-formatter" (module) {
+        module.exports = require("./error-formatter.js");
+    },
+    "./init-arg-utils" (module) {
+        module.exports = require("./init-arg-utils.js");
+    },
+    "./observation-record" (module) {
+        module.exports = require("./observation-record.js");
+    },
+    "./tool-defaults" (module) {
+        module.exports = require("./tool-defaults.js");
+    },
+    "./tool-generator" (module) {
+        module.exports = require("./tool-generator.js");
+    },
+    "./types" (module) {
+        module.exports = require("./types.js");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __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 ('undefined' != 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__);
+    var _base_tools__rspack_import_0 = __webpack_require__("./base-tools");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _base_tools__rspack_import_0)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_base_tools__rspack_import_0[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _tool_defaults__rspack_import_1 = __webpack_require__("./tool-defaults");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _tool_defaults__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_defaults__rspack_import_1[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _agent_behavior_init_args__rspack_import_2 = __webpack_require__("./agent-behavior-init-args");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _agent_behavior_init_args__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_agent_behavior_init_args__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _init_arg_utils__rspack_import_3 = __webpack_require__("./init-arg-utils");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _init_arg_utils__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_init_arg_utils__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _error_formatter__rspack_import_4 = __webpack_require__("./error-formatter");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _error_formatter__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_error_formatter__rspack_import_4[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _tool_generator__rspack_import_5 = __webpack_require__("./tool-generator");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _tool_generator__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_generator__rspack_import_5[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _types__rspack_import_6 = __webpack_require__("./types");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _types__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_6[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _chrome_path__rspack_import_7 = __webpack_require__("./chrome-path");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _chrome_path__rspack_import_7)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_chrome_path__rspack_import_7[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _observation_record__rspack_import_8 = __webpack_require__("./observation-record");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _observation_record__rspack_import_8)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_observation_record__rspack_import_8[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+})();
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/agent-tools/init-arg-utils.js

@@ -0,0 +1,78 @@
+"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 ('undefined' != 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__, {
+    createNamespacedInitArgSchema: ()=>createNamespacedInitArgSchema,
+    extractNamespacedArgs: ()=>extractNamespacedArgs,
+    sanitizeNamespacedArgs: ()=>sanitizeNamespacedArgs
+});
+const external_key_alias_utils_js_namespaceObject = require("../key-alias-utils.js");
+function readAliasedValue(args, key) {
+    for (const alias of (0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(key))if (alias in args) return args[alias];
+}
+function readNamespacedArg(args, namespace, key) {
+    const namespacedArgs = readAliasedValue(args, namespace);
+    if ((0, external_key_alias_utils_js_namespaceObject.isRecord)(namespacedArgs)) {
+        const nestedValue = readAliasedValue(namespacedArgs, key);
+        if (void 0 !== nestedValue) return nestedValue;
+    }
+    const dottedValue = readAliasedValue(args, `${namespace}.${key}`);
+    if (void 0 !== dottedValue) return dottedValue;
+    const directValue = readAliasedValue(args, key);
+    if (void 0 !== directValue) return directValue;
+}
+function extractNamespacedArgs(args, namespace, keys) {
+    const extracted = {};
+    for (const key of keys){
+        const value = readNamespacedArg(args, namespace, key);
+        if (void 0 !== value) extracted[key] = value;
+    }
+    return Object.keys(extracted).length > 0 ? extracted : void 0;
+}
+function sanitizeNamespacedArgs(args, namespace, keys) {
+    const excludedKeys = new Set((0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(namespace));
+    for (const key of keys){
+        for (const alias of (0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(key))excludedKeys.add(alias);
+        for (const alias of (0, external_key_alias_utils_js_namespaceObject.getKeyAliases)(`${namespace}.${key}`))excludedKeys.add(alias);
+    }
+    return Object.fromEntries(Object.entries(args).filter(([key])=>!excludedKeys.has(key)));
+}
+function createNamespacedInitArgSchema(namespace, shape) {
+    return Object.fromEntries(Object.entries(shape).map(([key, value])=>[
+            `${namespace}.${key}`,
+            value
+        ]));
+}
+exports.createNamespacedInitArgSchema = __webpack_exports__.createNamespacedInitArgSchema;
+exports.extractNamespacedArgs = __webpack_exports__.extractNamespacedArgs;
+exports.sanitizeNamespacedArgs = __webpack_exports__.sanitizeNamespacedArgs;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createNamespacedInitArgSchema",
+    "extractNamespacedArgs",
+    "sanitizeNamespacedArgs"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/agent-tools/observation-artifact.js

@@ -0,0 +1,42 @@
+"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 ('undefined' != 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__, {
+    observationArtifactAdapterSymbol: ()=>observationArtifactAdapterSymbol,
+    resolveObservationArtifactAdapter: ()=>resolveObservationArtifactAdapter
+});
+const observationArtifactAdapterSymbol = Symbol('midscene.observationArtifactAdapter');
+function resolveObservationArtifactAdapter(agent) {
+    return agent[observationArtifactAdapterSymbol];
+}
+exports.observationArtifactAdapterSymbol = __webpack_exports__.observationArtifactAdapterSymbol;
+exports.resolveObservationArtifactAdapter = __webpack_exports__.resolveObservationArtifactAdapter;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "observationArtifactAdapterSymbol",
+    "resolveObservationArtifactAdapter"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});