@midscene/test 1.12.4-beta-20260903111111.0 → 1.12.4

package/dist/lib/test-cli.js

@@ -17,7 +17,7 @@ workflow:
         continue-on-error: false
 \`\`\`
 
-A string step value is shorthand for \`{ prompt: value }\`. Whether that input is valid depends on the node input schema.`;
+A Node may map a string step value to one declared input field. Each Node section states whether it supports this shorthand and names the target field.`;
 const sortJsonValue = (value)=>{
     if (Array.isArray(value)) return value.map(sortJsonValue);
     if ('object' != typeof value || null === value) return value;
@@ -65,6 +65,8 @@ const renderNode = (node, warnings)=>{
         warnings.push(`node "${node.name}" has no description`);
         sections.push("> Description not declared. Do not infer this node's behavior.");
     }
+    if (false === node.stringInputKey || void 0 === node.stringInputKey) sections.push('**String shorthand:** Not supported by this Node.');
+    else sections.push(`**String shorthand:** Maps to \`{ ${node.stringInputKey}: value }\`.`);
     sections.push('### Input Schema');
     if (node.inputSchema) sections.push(`\`\`\`json\n${JSON.stringify(toJsonSchema(node), null, 2)}\n\`\`\``);
     else {
@@ -290,7 +292,15 @@ const validateDefinition = (options)=>{
     if ('string' != typeof options.name || 0 === options.name.trim().length) throw new NodeDefinitionError('Node name must be a non-empty string.');
     validateOptionalText(options.title, 'title', options.name);
     validateOptionalText(options.description, "description", options.name);
+    if (void 0 !== options.stringInputKey && false !== options.stringInputKey && ('string' != typeof options.stringInputKey || 0 === options.stringInputKey.trim().length)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must be a non-empty string or false.`, {
+        node: options.name,
+        field: 'stringInputKey'
+    });
     validateInputSchema(options.inputSchema, options.name);
+    if ('string' == typeof options.stringInputKey && options.inputSchema instanceof v4_namespaceObject.z.ZodObject && !(options.stringInputKey in options.inputSchema.shape)) throw new NodeDefinitionError(`Node "${options.name}" stringInputKey must reference a field in inputSchema.`, {
+        node: options.name,
+        field: 'stringInputKey'
+    });
     if ('function' != typeof options.execute) throw new NodeDefinitionError(`Node "${options.name}" must provide an execute function.`, {
         node: options.name
     });
@@ -451,10 +461,11 @@ const platforms = new Set([
     'web',
     'android',
     'ios',
+    'harmony',
     'computer'
 ]);
 const validatePlatform = (value, label)=>{
-    if ('string' != typeof value || !platforms.has(value)) throw new TypeError(`Midscene config ${label} must be one of web, android, ios, computer.`);
+    if ('string' != typeof value || !platforms.has(value)) throw new TypeError(`Midscene config ${label} must be one of web, android, ios, harmony, computer.`);
     return value;
 };
 const validateProjectSetup = (value, projectPlatform, label)=>{
@@ -748,88 +759,6 @@ const createProjectRuntime = (options)=>{
         }
     };
 };
-const supportedMetaKeys = new Set([
-    'timeout',
-    'continue-on-error'
-]);
-function isMapping(value) {
-    return 'object' == typeof value && null !== value && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
-}
-function formatStep(index) {
-    return `step ${index + 1}`;
-}
-function normalizeMeta(value, index) {
-    if (void 0 === value) return {
-        continueOnError: false
-    };
-    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} "$" must be a mapping.`, {
-        index
-    });
-    for (const key of Object.keys(value))if (!supportedMetaKeys.has(key)) throw new WorkflowParseError(`${formatStep(index)} has unsupported engine metadata "${key}".`, {
-        index,
-        key
-    });
-    const timeout = value.timeout;
-    if (void 0 !== timeout && ('number' != typeof timeout || !Number.isFinite(timeout) || timeout <= 0)) throw new WorkflowParseError(`${formatStep(index)} "$.timeout" must be a positive number of milliseconds.`, {
-        index,
-        timeout
-    });
-    const continueOnError = value['continue-on-error'];
-    if (void 0 !== continueOnError && 'boolean' != typeof continueOnError) throw new WorkflowParseError(`${formatStep(index)} "$.continue-on-error" must be a boolean.`, {
-        index,
-        continueOnError
-    });
-    return {
-        ...void 0 === timeout ? {} : {
-            timeoutMs: timeout
-        },
-        continueOnError: continueOnError ?? false
-    };
-}
-function validateCommonNodeInput(input, index) {
-    if (void 0 !== input.prompt && 'string' != typeof input.prompt) throw new WorkflowParseError(`${formatStep(index)} "prompt" must be a string.`, {
-        index,
-        prompt: input.prompt
-    });
-}
-function normalizeStep(value, index = 0) {
-    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} must be a mapping.`, {
-        index
-    });
-    const entries = Object.entries(value);
-    if (1 !== entries.length) throw new WorkflowParseError(`${formatStep(index)} must contain exactly one node.`, {
-        index,
-        nodes: Object.keys(value)
-    });
-    const [node, rawValue] = entries[0];
-    if (0 === node.trim().length) throw new WorkflowParseError(`${formatStep(index)} node name must not be empty.`, {
-        index
-    });
-    if ('string' == typeof rawValue) return {
-        node,
-        input: {
-            prompt: rawValue
-        },
-        meta: {
-            continueOnError: false
-        }
-    };
-    if (!isMapping(rawValue)) throw new WorkflowParseError(`${formatStep(index)} value must be a string shorthand or a mapping.`, {
-        index,
-        node
-    });
-    const { $: rawMeta, ...input } = rawValue;
-    validateCommonNodeInput(input, index);
-    return {
-        node,
-        input,
-        meta: normalizeMeta(rawMeta, index)
-    };
-}
-function normalizeSteps(steps) {
-    if (!Array.isArray(steps)) throw new WorkflowParseError('Steps must be an array.');
-    return steps.map((step, index)=>normalizeStep(step, index));
-}
 const assertJsonSerializable = (value, label, node)=>{
     const visit = (candidate, path, seen)=>{
         if (null === candidate || 'string' == typeof candidate || 'boolean' == typeof candidate) return;
@@ -852,45 +781,6 @@ const assertJsonSerializable = (value, label, node)=>{
         throw new NodeExecutionError(node, error);
     }
 };
-const cloneAndFreezeJson = (value)=>{
-    if (Array.isArray(value)) return Object.freeze(value.map(cloneAndFreezeJson));
-    if ('object' == typeof value && null !== value) return Object.freeze(Object.fromEntries(Object.entries(value).map(([key, child])=>[
-            key,
-            cloneAndFreezeJson(child)
-        ])));
-    return value;
-};
-const toHistoryEntry = (result, scope)=>{
-    assertJsonSerializable(result.input, 'input', result.node);
-    if (result.output?.data !== void 0) assertJsonSerializable(result.output.data, 'output.data', result.node);
-    return Object.freeze({
-        scope,
-        phase: result.phase,
-        stepIndex: result.stepIndex,
-        node: result.node,
-        input: cloneAndFreezeJson(result.input),
-        ...'string' == typeof result.input?.prompt ? {
-            intent: result.input.prompt
-        } : {},
-        status: 'success' === result.status ? 'passed' : 'failed',
-        ...result.output?.summary === void 0 ? {} : {
-            summary: result.output.summary
-        },
-        ...result.output?.data === void 0 ? {} : {
-            data: cloneAndFreezeJson(result.output.data)
-        },
-        ...result.error ? {
-            error: Object.freeze({
-                name: result.error.name,
-                message: result.error.message
-            })
-        } : {}
-    });
-};
-const createHistory = (prefix, results, scope)=>Object.freeze([
-        ...prefix,
-        ...results.map((result)=>toHistoryEntry(result, scope))
-    ]);
 function validateNodeOutput(output, node) {
     if (void 0 === output) return;
     if ('object' != typeof output || null === output || Array.isArray(output)) throw new NodeExecutionError(node, new TypeError('Node output must be an object or undefined.'));
@@ -912,7 +802,6 @@ function createStepResultBase(step, startedAt, phase, stepIndex) {
     };
 }
 async function executeNode(step, execute, phase, stepIndex, options) {
-    validateCommonNodeInput(step.input, stepIndex);
     const startedAt = new Date();
     const abortController = new AbortController();
     const parentSignal = options.parentSignal;
@@ -996,7 +885,6 @@ async function executeStep(step, node, target, context, execution = {}) {
             $: step.meta,
             signal,
             context,
-            history: execution.history ?? Object.freeze([]),
             onTeardown: (teardown)=>{
                 if (!execution.onTeardown) throw new NodeExecutionError(step.node, new Error('The current execution scope cannot register teardown.'));
                 execution.onTeardown(step.node, teardown);
@@ -1033,7 +921,6 @@ function createDocumentRuntime(document, options) {
     const startedAt = new Date();
     const beforeAll = [];
     const afterAll = [];
-    const completedNodes = [];
     const nodes = {
         beforeAll: document.lifecycle.beforeAll.map((step)=>options.resolveNode(step.node)),
         afterAll: document.lifecycle.afterAll.map((step)=>options.resolveNode(step.node))
@@ -1064,7 +951,7 @@ function createDocumentRuntime(document, options) {
             projectId: document.projectId,
             projectName: project.name,
             sourcePath: document.sourcePath,
-            status: completedNodes.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
+            status: beforeAll.some((step)=>'failed' === step.status) || afterAll.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
             startedAt: startedAt.toISOString(),
             endedAt: endedAt.toISOString(),
             durationMs: Math.max(0, endedAt.getTime() - startedAt.getTime()),
@@ -1093,10 +980,7 @@ function createDocumentRuntime(document, options) {
                 projectName: project.name,
                 sourcePath: document.sourcePath,
                 phase,
-                stepIndex,
-                completedNodes: Object.freeze([
-                    ...completedNodes
-                ])
+                stepIndex
             };
             const stepInfo = {
                 scope: 'document',
@@ -1109,7 +993,6 @@ function createDocumentRuntime(document, options) {
                 scope: 'document',
                 document: documentContext
             }, context, {
-                history: createHistory([], completedNodes, 'document'),
                 signal: executionSignal,
                 defaultTimeoutMs: options.defaultTimeoutMs,
                 onTeardown (node, teardown) {
@@ -1132,7 +1015,6 @@ function createDocumentRuntime(document, options) {
             });
             await options.onStepResult?.(stepInfo, result);
             results.push(result);
-            completedNodes.push(result);
             if ('failed' === result.status && !result.continuedAfterError) break;
         }
     };
@@ -1140,9 +1022,6 @@ function createDocumentRuntime(document, options) {
         get context () {
             return context;
         },
-        get history () {
-            return createHistory([], completedNodes, 'document');
-        },
         get canRunCases () {
             return started && !signal.aborted && !beforeAll.some((step)=>'failed' === step.status);
         },
@@ -1202,7 +1081,6 @@ async function runCollectedCase(collectedCase, options) {
     const beforeEach = [];
     const steps = [];
     const afterEach = [];
-    const completedNodes = [];
     const teardownStack = [];
     let acceptingTeardowns = true;
     const onTeardown = (node, teardown)=>{
@@ -1231,13 +1109,7 @@ async function runCollectedCase(collectedCase, options) {
                 sourcePath: collectedCase.sourcePath,
                 caseIndex: collectedCase.caseIndex,
                 phase,
-                stepIndex,
-                completedSteps: Object.freeze([
-                    ...steps
-                ]),
-                completedNodes: Object.freeze([
-                    ...completedNodes
-                ])
+                stepIndex
             };
             const stepInfo = {
                 scope: 'case',
@@ -1250,14 +1122,12 @@ async function runCollectedCase(collectedCase, options) {
                 scope: 'case',
                 case: caseContext
             }, options.context, {
-                history: createHistory(options.documentHistory ?? [], completedNodes, 'case'),
                 signal,
                 defaultTimeoutMs: options.defaultTimeoutMs,
                 onTeardown
             });
             await options.onStepResult?.(stepInfo, result);
             results.push(result);
-            completedNodes.push(result);
             if ('failed' === result.status && !result.continuedAfterError) break;
         }
     };
@@ -1297,7 +1167,7 @@ async function runCollectedCase(collectedCase, options) {
         name: collectedCase.definition.name,
         sourcePath: collectedCase.sourcePath,
         caseIndex: collectedCase.caseIndex,
-        status: completedNodes.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
+        status: beforeEach.some((step)=>'failed' === step.status) || steps.some((step)=>'failed' === step.status) || afterEach.some((step)=>'failed' === step.status) || teardownErrors.length > 0 ? 'failed' : 'success',
         beforeEach,
         steps,
         afterEach,
@@ -1367,7 +1237,6 @@ async function runWorkflowDocument(document, options) {
                     context: runtime.context,
                     projectName,
                     attemptIndex,
-                    documentHistory: runtime.history,
                     signal: options.signal,
                     defaultTimeoutMs: options.defaultTimeoutMs,
                     onStepStart: options.onStepStart,
@@ -1414,6 +1283,89 @@ async function runWorkflowDocument(document, options) {
     };
 }
 const external_js_yaml_namespaceObject = require("js-yaml");
+const supportedMetaKeys = new Set([
+    'timeout',
+    'continue-on-error'
+]);
+function isMapping(value) {
+    return 'object' == typeof value && null !== value && !Array.isArray(value) && (Object.getPrototypeOf(value) === Object.prototype || null === Object.getPrototypeOf(value));
+}
+function formatStep(index) {
+    return `step ${index + 1}`;
+}
+function normalizeMeta(value, index) {
+    if (void 0 === value) return {
+        continueOnError: false
+    };
+    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} "$" must be a mapping.`, {
+        index
+    });
+    for (const key of Object.keys(value))if (!supportedMetaKeys.has(key)) throw new WorkflowParseError(`${formatStep(index)} has unsupported engine metadata "${key}".`, {
+        index,
+        key
+    });
+    const timeout = value.timeout;
+    if (void 0 !== timeout && ('number' != typeof timeout || !Number.isFinite(timeout) || timeout <= 0)) throw new WorkflowParseError(`${formatStep(index)} "$.timeout" must be a positive number of milliseconds.`, {
+        index,
+        timeout
+    });
+    const continueOnError = value['continue-on-error'];
+    if (void 0 !== continueOnError && 'boolean' != typeof continueOnError) throw new WorkflowParseError(`${formatStep(index)} "$.continue-on-error" must be a boolean.`, {
+        index,
+        continueOnError
+    });
+    return {
+        ...void 0 === timeout ? {} : {
+            timeoutMs: timeout
+        },
+        continueOnError: continueOnError ?? false
+    };
+}
+function normalizeStep(value, index = 0, resolveNode) {
+    if (!isMapping(value)) throw new WorkflowParseError(`${formatStep(index)} must be a mapping.`, {
+        index
+    });
+    const entries = Object.entries(value);
+    if (1 !== entries.length) throw new WorkflowParseError(`${formatStep(index)} must contain exactly one node.`, {
+        index,
+        nodes: Object.keys(value)
+    });
+    const [node, rawValue] = entries[0];
+    if (0 === node.trim().length) throw new WorkflowParseError(`${formatStep(index)} node name must not be empty.`, {
+        index
+    });
+    if ('string' == typeof rawValue) {
+        const resolvedNode = resolveNode?.(node);
+        const stringInputKey = resolvedNode ? resolvedNode.stringInputKey : 'prompt';
+        if (false === stringInputKey || void 0 === stringInputKey) throw new WorkflowParseError(`${formatStep(index)} node "${node}" does not accept string shorthand.`, {
+            index,
+            node
+        });
+        return {
+            node,
+            input: {
+                [stringInputKey]: rawValue
+            },
+            meta: {
+                continueOnError: false
+            }
+        };
+    }
+    if (!isMapping(rawValue)) throw new WorkflowParseError(`${formatStep(index)} value must be a string shorthand or a mapping.`, {
+        index,
+        node
+    });
+    const { $: rawMeta, ...input } = rawValue;
+    return {
+        node,
+        input,
+        meta: normalizeMeta(rawMeta, index)
+    };
+}
+function normalizeSteps(steps, resolveNode) {
+    if (!Array.isArray(steps)) throw new WorkflowParseError('Steps must be an array.');
+    return steps.map((step, index)=>normalizeStep(step, index, resolveNode));
+}
 const interpolationExpression = /\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}|\$\{([^{}]+)\}/g;
 const exactEnvExpression = /^\$\{\{([A-Za-z_][A-Za-z0-9_]*)\}\}$/;
 const exactProjectExpression = /^\$\{([^{}]+)\}$/;
@@ -1517,7 +1469,7 @@ function collectWorkflowDocument(source, options) {
         if (!Array.isArray(value)) throw new WorkflowParseError(`Workflow document ${phase} must be an array.`, {
             phase
         });
-        return normalizeSteps(value).map((normalized, stepIndex)=>{
+        return normalizeSteps(value, options.resolveNode).map((normalized, stepIndex)=>{
             const resolved = options.resolveNode(normalized.node);
             if (!resolved) throw new WorkflowParseError(`Workflow document ${phase} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                 phase,
@@ -1553,7 +1505,7 @@ function collectWorkflowDocument(source, options) {
         if (!Array.isArray(tags) || tags.some((tag)=>'string' != typeof tag || 0 === tag.trim().length)) throw new WorkflowParseError(`Case ${caseIndex + 1} tags must be an array of non-empty strings.`, {
             caseIndex
         });
-        const steps = normalizeSteps(definition.steps).map((normalized, stepIndex)=>{
+        const steps = normalizeSteps(definition.steps, options.resolveNode).map((normalized, stepIndex)=>{
             if (!options.resolveNode(normalized.node)) throw new WorkflowParseError(`Case ${caseIndex + 1} step ${stepIndex + 1} references unknown node "${normalized.node}".`, {
                 caseIndex,
                 stepIndex,