@aiscene/shared 8.0.2 → 8.0.3

package/dist/es/mcp/cli-report-session.mjs

@@ -0,0 +1,78 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getMidsceneRunBaseDir, getMidsceneRunSubDir } from "../common.mjs";
+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 = join(getMidsceneRunBaseDir(), sessionDirName);
+    if (!existsSync(dir)) mkdirSync(dir, {
+        recursive: true
+    });
+    return dir;
+}
+function getCliReportSessionPath(sessionName) {
+    return 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 = join(getMidsceneRunSubDir('report'), ensureHtmlFileName(reportFileName));
+    const session = {
+        version: 1,
+        sessionName,
+        ...targetIdentity ? {
+            targetIdentity
+        } : {},
+        reportFileName,
+        reportPath,
+        createdAt: Date.now()
+    };
+    return session;
+}
+function writeCliReportSession(session) {
+    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 (!existsSync(sessionPath)) return;
+    try {
+        const raw = 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;
+    }
+}
+export { createCliReportSession, generateCliReportSession, readCliReportSession, writeCliReportSession };

package/dist/es/mcp/error-formatter.mjs

@@ -0,0 +1,19 @@
+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;
+}
+export { getErrorMessage };

package/dist/es/mcp/index.mjs

@@ -1,5 +1,7 @@
 export * from "./base-server.mjs";
 export * from "./base-tools.mjs";
+export * from "./init-arg-utils.mjs";
+export * from "./error-formatter.mjs";
 export * from "./tool-generator.mjs";
 export * from "./types.mjs";
 export * from "./inject-report-html-plugin.mjs";

package/dist/es/mcp/init-arg-utils.mjs

@@ -0,0 +1,38 @@
+import { getKeyAliases, isRecord } from "../key-alias-utils.mjs";
+function readAliasedValue(args, key) {
+    for (const alias of getKeyAliases(key))if (alias in args) return args[alias];
+}
+function readNamespacedArg(args, namespace, key) {
+    const namespacedArgs = readAliasedValue(args, namespace);
+    if (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(getKeyAliases(namespace));
+    for (const key of keys){
+        for (const alias of getKeyAliases(key))excludedKeys.add(alias);
+        for (const alias of 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
+        ]));
+}
+export { createNamespacedInitArgSchema, extractNamespacedArgs, sanitizeNamespacedArgs };

package/dist/es/mcp/inject-report-html-plugin.mjs

@@ -9,7 +9,7 @@ function injectReportHtmlFromCore(packageDir) {
         setup (api) {
             api.onAfterBuild(()=>{
                 const coreUtilsPath = node_path.resolve(packageDir, '..', 'core', 'dist', 'lib', 'utils.js');
-                if (!node_fs.existsSync(coreUtilsPath)) return void console.warn('[inject-report-html] @midscene/core dist not found, skipping');
+                if (!node_fs.existsSync(coreUtilsPath)) return void console.warn('[inject-report-html] @aiscene/core dist not found, skipping');
                 const coreContent = node_fs.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/es/mcp/tool-generator.mjs

@@ -1,9 +1,7 @@
+import { parseBase64 } from "@aiscene/shared/img";
 import { z } from "zod";
-import { parseBase64 } from "../img/index.mjs";
 import { getZodDescription, getZodTypeName, isMidsceneLocatorField, unwrapZodField } from "../zod-schema-utils.mjs";
-function getErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
+import { getErrorMessage } from "./error-formatter.mjs";
 function describeActionForMCP(action) {
     const actionDesc = action.description || `Execute ${action.name} action`;
     if (!action.paramSchema) return `${action.name} action, ${actionDesc}`;
@@ -70,10 +68,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) {
@@ -279,17 +280,30 @@ 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);
@@ -308,15 +322,18 @@ 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 } = parseBase64(screenshot);
@@ -340,12 +357,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: z.string().describe('Natural language description of the action to perform, e.g. "press Command+Space, type Safari, press Enter"')
+                prompt: 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
@@ -365,6 +384,35 @@ function generateCommonTools(getAgent) {
                     return createErrorResult(`Failed to execute act: ${errorMessage}`);
                 }
             }
+        },
+        {
+            name: 'assert',
+            description: 'Assert a natural language statement against the current page/screen.',
+            schema: {
+                prompt: 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 = getErrorMessage(error);
+                    console.error('Error executing assert:', errorMessage);
+                    return createErrorResult(`Failed to execute assert: ${errorMessage}`);
+                }
+            }
         }
     ];
 }