@aiscene/shared 8.0.2 → 8.0.4

package/dist/lib/mcp/error-formatter.js

@@ -0,0 +1,53 @@
+"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
+});
+function getErrorMessage(error) {
+    if (error instanceof Error) return error.message;
+    if (null == error) return String(error);
+    if ('object' != typeof error) return String(error);
+    const candidate = extractStringMessage(error);
+    if (candidate) return candidate;
+    try {
+        return JSON.stringify(error);
+    } catch  {
+        return Object.prototype.toString.call(error);
+    }
+}
+function extractStringMessage(error) {
+    const anyError = error;
+    if ('string' == typeof anyError.message && anyError.message) return anyError.message;
+    if (anyError.error && 'string' == typeof anyError.error.message && anyError.error.message) return anyError.error.message;
+    if (anyError.cause && 'string' == typeof anyError.cause.message && anyError.cause.message) return anyError.cause.message;
+}
+exports.getErrorMessage = __webpack_exports__.getErrorMessage;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "getErrorMessage"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/lib/mcp/index.js

@@ -9,6 +9,12 @@ var __webpack_modules__ = {
     "./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");
+    },
     "./inject-report-html-plugin" (module) {
         module.exports = require("./inject-report-html-plugin.js");
     },
@@ -73,25 +79,33 @@ var __webpack_exports__ = {};
     var __rspack_reexport = {};
     for(const __rspack_import_key in _base_tools__rspack_import_1)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_base_tools__rspack_import_1[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _tool_generator__rspack_import_2 = __webpack_require__("./tool-generator");
+    var _init_arg_utils__rspack_import_2 = __webpack_require__("./init-arg-utils");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _init_arg_utils__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_init_arg_utils__rspack_import_2[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _error_formatter__rspack_import_3 = __webpack_require__("./error-formatter");
+    var __rspack_reexport = {};
+    for(const __rspack_import_key in _error_formatter__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_error_formatter__rspack_import_3[__rspack_import_key];
+    __webpack_require__.d(__webpack_exports__, __rspack_reexport);
+    var _tool_generator__rspack_import_4 = __webpack_require__("./tool-generator");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _tool_generator__rspack_import_2)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_generator__rspack_import_2[__rspack_import_key];
+    for(const __rspack_import_key in _tool_generator__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_tool_generator__rspack_import_4[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _types__rspack_import_3 = __webpack_require__("./types");
+    var _types__rspack_import_5 = __webpack_require__("./types");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _types__rspack_import_3)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_3[__rspack_import_key];
+    for(const __rspack_import_key in _types__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_types__rspack_import_5[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _inject_report_html_plugin__rspack_import_4 = __webpack_require__("./inject-report-html-plugin");
+    var _inject_report_html_plugin__rspack_import_6 = __webpack_require__("./inject-report-html-plugin");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _inject_report_html_plugin__rspack_import_4)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_inject_report_html_plugin__rspack_import_4[__rspack_import_key];
+    for(const __rspack_import_key in _inject_report_html_plugin__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_inject_report_html_plugin__rspack_import_6[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _launcher_helper__rspack_import_5 = __webpack_require__("./launcher-helper");
+    var _launcher_helper__rspack_import_7 = __webpack_require__("./launcher-helper");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _launcher_helper__rspack_import_5)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_launcher_helper__rspack_import_5[__rspack_import_key];
+    for(const __rspack_import_key in _launcher_helper__rspack_import_7)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_launcher_helper__rspack_import_7[__rspack_import_key];
     __webpack_require__.d(__webpack_exports__, __rspack_reexport);
-    var _chrome_path__rspack_import_6 = __webpack_require__("./chrome-path");
+    var _chrome_path__rspack_import_8 = __webpack_require__("./chrome-path");
     var __rspack_reexport = {};
-    for(const __rspack_import_key in _chrome_path__rspack_import_6)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_chrome_path__rspack_import_6[__rspack_import_key];
+    for(const __rspack_import_key in _chrome_path__rspack_import_8)if ("default" !== __rspack_import_key) __rspack_reexport[__rspack_import_key] = ()=>_chrome_path__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];

package/dist/lib/mcp/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/mcp/inject-report-html-plugin.js

@@ -48,7 +48,7 @@ function injectReportHtmlFromCore(packageDir) {
         setup (api) {
             api.onAfterBuild(()=>{
                 const coreUtilsPath = external_node_path_default().resolve(packageDir, '..', 'core', 'dist', 'lib', 'utils.js');
-                if (!external_node_fs_default().existsSync(coreUtilsPath)) return void console.warn('[inject-report-html] @midscene/core dist not found, skipping');
+                if (!external_node_fs_default().existsSync(coreUtilsPath)) return void console.warn('[inject-report-html] @aiscene/core dist not found, skipping');
                 const coreContent = external_node_fs_default().readFileSync(coreUtilsPath, 'utf-8');
                 if (!coreContent.includes(REPLACED_MARK)) return void console.warn('[inject-report-html] HTML not found in core dist. Ensure report builds first.');
                 const markerIndex = coreContent.indexOf(REPLACED_MARK);

package/dist/lib/mcp/tool-generator.js

@@ -27,12 +27,10 @@ __webpack_require__.d(__webpack_exports__, {
     generateToolsFromActionSpace: ()=>generateToolsFromActionSpace,
     generateCommonTools: ()=>generateCommonTools
 });
+const img_namespaceObject = require("@aiscene/shared/img");
 const external_zod_namespaceObject = require("zod");
-const index_js_namespaceObject = require("../img/index.js");
 const external_zod_schema_utils_js_namespaceObject = require("../zod-schema-utils.js");
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
+const external_error_formatter_js_namespaceObject = require("./error-formatter.js");
 function describeActionForMCP(action) {
     const actionDesc = action.description || `Execute ${action.name} action`;
     if (!action.paramSchema) return `${action.name} action, ${actionDesc}`;
@@ -99,10 +97,13 @@ function transformSchemaField(key, value) {
         value
     ];
 }
-function extractActionSchema(paramSchema) {
+function extractActionSchema(paramSchema, actionName) {
     if (!paramSchema) return {};
     const shape = getZodObjectShape(paramSchema);
-    if (!shape) return paramSchema;
+    if (!shape) {
+        const typeName = paramSchema?._def?.typeName ?? 'unknown';
+        throw new Error(`Action "${actionName}" declared a non-object paramSchema (${typeName}). CLI and MCP tool schemas must be a ZodObject (e.g. z.object({ uri: z.string() })) or undefined. Wrap primitive fields in an object schema.`);
+    }
     return Object.fromEntries(Object.entries(shape).map(([key, value])=>transformSchemaField(key, value)));
 }
 function getPromptText(prompt) {
@@ -173,7 +174,7 @@ function serializeArgsToDescription(args) {
             return `${key}: "${value}"`;
         }).join(', ');
     } catch (error) {
-        const errorMessage = getErrorMessage(error);
+        const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
         console.error('Error serializing args:', errorMessage);
         return `[args serialization failed: ${errorMessage}]`;
     }
@@ -231,7 +232,7 @@ async function captureScreenshotResult(agent, actionName, actionResult) {
         if (!screenshot) return {
             content
         };
-        const { mimeType, body } = (0, index_js_namespaceObject.parseBase64)(screenshot);
+        const { mimeType, body } = (0, img_namespaceObject.parseBase64)(screenshot);
         content.push({
             type: 'image',
             data: body,
@@ -241,7 +242,7 @@ async function captureScreenshotResult(agent, actionName, actionResult) {
             content
         };
     } catch (error) {
-        const errorMessage = getErrorMessage(error);
+        const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
         console.error('Error capturing screenshot:', errorMessage);
         content[0] = {
             type: 'text',
@@ -283,7 +284,7 @@ async function captureFailureResult(agent, actionName, errorMessage) {
                 }
             ]
         };
-        const { mimeType, body } = (0, index_js_namespaceObject.parseBase64)(screenshot);
+        const { mimeType, body } = (0, img_namespaceObject.parseBase64)(screenshot);
         return {
             content: [
                 {
@@ -308,28 +309,41 @@ async function captureFailureResult(agent, actionName, errorMessage) {
         };
     }
 }
-function generateToolsFromActionSpace(actionSpace, getAgent) {
+function mergeToolCliMetadata(base, extra) {
+    const options = {
+        ...base?.options ?? {},
+        ...extra?.options ?? {}
+    };
+    return Object.keys(options).length > 0 ? {
+        options
+    } : void 0;
+}
+function generateToolsFromActionSpace(actionSpace, getAgent, sanitizeArgs = (args)=>args, initArgSchema = {}, initArgCliMetadata) {
     return actionSpace.map((action)=>{
-        const schema = extractActionSchema(action.paramSchema);
+        const schema = {
+            ...extractActionSchema(action.paramSchema, action.name),
+            ...initArgSchema
+        };
         return {
             name: action.name,
             description: describeActionForMCP(action),
             schema,
+            cli: initArgCliMetadata,
             handler: async (args)=>{
                 try {
-                    const agent = await getAgent();
-                    const normalizedArgs = normalizeActionArgs(args, action.paramSchema);
+                    const agent = await getAgent(args);
+                    const normalizedArgs = normalizeActionArgs(sanitizeArgs(args), action.paramSchema);
                     let actionResult;
                     try {
                         actionResult = await executeAction(agent, action.name, normalizedArgs);
                     } catch (error) {
-                        const errorMessage = getErrorMessage(error);
+                        const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
                         console.error(`Error executing action "${action.name}":`, errorMessage);
                         return await captureFailureResult(agent, action.name, errorMessage);
                     }
                     return await captureScreenshotResult(agent, action.name, actionResult);
                 } catch (error) {
-                    const errorMessage = getErrorMessage(error);
+                    const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
                     console.error(`Error in handler for "${action.name}":`, errorMessage);
                     return createErrorResult(`Failed to get agent or execute action "${action.name}": ${errorMessage}`);
                 }
@@ -337,18 +351,21 @@ function generateToolsFromActionSpace(actionSpace, getAgent) {
         };
     });
 }
-function generateCommonTools(getAgent) {
+function generateCommonTools(getAgent, initArgSchema = {}, initArgCliMetadata) {
     return [
         {
             name: 'take_screenshot',
             description: 'Capture screenshot of current page/screen',
-            schema: {},
-            handler: async ()=>{
+            schema: {
+                ...initArgSchema
+            },
+            cli: initArgCliMetadata,
+            handler: async (args = {})=>{
                 try {
-                    const agent = await getAgent();
+                    const agent = await getAgent(args);
                     const screenshot = await agent.page?.screenshotBase64();
                     if (!screenshot) return createErrorResult('Screenshot not available');
-                    const { mimeType, body } = (0, index_js_namespaceObject.parseBase64)(screenshot);
+                    const { mimeType, body } = (0, img_namespaceObject.parseBase64)(screenshot);
                     return {
                         content: [
                             {
@@ -359,7 +376,7 @@ function generateCommonTools(getAgent) {
                         ]
                     };
                 } catch (error) {
-                    const errorMessage = getErrorMessage(error);
+                    const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
                     console.error('Error taking screenshot:', errorMessage);
                     return createErrorResult(`Failed to capture screenshot: ${errorMessage}`);
                 }
@@ -369,12 +386,14 @@ function generateCommonTools(getAgent) {
             name: 'act',
             description: 'Execute a natural language action. The AI will plan and perform multi-step operations in a single invocation, useful for transient UI interactions (e.g., Spotlight, dropdown menus) that disappear between separate commands.',
             schema: {
-                prompt: external_zod_namespaceObject.z.string().describe('Natural language description of the action to perform, e.g. "press Command+Space, type Safari, press Enter"')
+                prompt: external_zod_namespaceObject.z.string().describe('Natural language description of the action to perform, e.g. "press Command+Space, type Safari, press Enter"'),
+                ...initArgSchema
             },
-            handler: async (args)=>{
+            cli: mergeToolCliMetadata(void 0, initArgCliMetadata),
+            handler: async (args = {})=>{
                 const prompt = args.prompt;
                 try {
-                    const agent = await getAgent();
+                    const agent = await getAgent(args);
                     if (!agent.aiAction) return createErrorResult('act is not supported by this agent');
                     const result = await agent.aiAction(prompt, {
                         deepThink: false
@@ -389,11 +408,40 @@ function generateCommonTools(getAgent) {
                     }
                     return screenshotResult;
                 } catch (error) {
-                    const errorMessage = getErrorMessage(error);
+                    const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
                     console.error('Error executing act:', errorMessage);
                     return createErrorResult(`Failed to execute act: ${errorMessage}`);
                 }
             }
+        },
+        {
+            name: 'assert',
+            description: 'Assert a natural language statement against the current page/screen.',
+            schema: {
+                prompt: external_zod_namespaceObject.z.string().describe('Natural language assertion to verify, e.g. "there is a login button visible"'),
+                ...initArgSchema
+            },
+            cli: mergeToolCliMetadata(void 0, initArgCliMetadata),
+            handler: async (args = {})=>{
+                const prompt = args.prompt;
+                try {
+                    const agent = await getAgent(args);
+                    if (!agent.aiAssert) return createErrorResult('assert is not supported by this agent');
+                    await agent.aiAssert(prompt);
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Assertion passed.'
+                            }
+                        ]
+                    };
+                } catch (error) {
+                    const errorMessage = (0, external_error_formatter_js_namespaceObject.getErrorMessage)(error);
+                    console.error('Error executing assert:', errorMessage);
+                    return createErrorResult(`Failed to execute assert: ${errorMessage}`);
+                }
+            }
         }
     ];
 }