@web-auto/webauto 0.1.1 → 0.1.3

package/dist/modules/operations/src/operations/scroll.js

@@ -0,0 +1,126 @@
+async function runScroll(ctx, config) {
+    const rawDistance = typeof config.distance === 'number'
+        ? config.distance
+        : typeof config.amount === 'number'
+            ? config.amount
+            : 500;
+    const direction = config.direction || 'down';
+    const fullyVisible = config.fullyVisible === true;
+    const anchor = config.anchor ?? null;
+    // 单次滚动约束：不超过 800px，符合“用户手势范围”
+    const distance = Math.min(800, Math.max(0, Math.floor(Math.abs(rawDistance))));
+    const deltaY = direction === 'up' ? -distance : distance;
+    const useSystemMouse = config.useSystemMouse !== false;
+    const protocolMouse = ctx.page?.mouse;
+    if (useSystemMouse && !ctx.systemInput?.mouseWheel) {
+        return { success: false, error: 'system scroll not available' };
+    }
+    // 优先鼠标滚轮（系统级或协议级）
+    if ((useSystemMouse && ctx.systemInput?.mouseWheel) || (!useSystemMouse && protocolMouse?.wheel)) {
+        const selector = typeof config.selector === 'string' ? config.selector.trim() : '';
+        if (selector) {
+            const info = await ctx.page.evaluate(({ sel, fVisible, anchorPoint }) => {
+                const isVisible = (el) => {
+                    const r = el.getBoundingClientRect();
+                    return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < window.innerHeight && r.right > 0 && r.left < window.innerWidth;
+                };
+                const isFullyVisible = (el) => {
+                    const r = el.getBoundingClientRect();
+                    return r.width > 0 && r.height > 0 && r.top >= 0 && r.left >= 0 && r.bottom <= window.innerHeight && r.right <= window.innerWidth;
+                };
+                const el = document.querySelector(sel);
+                if (!el)
+                    return null;
+                const r = el.getBoundingClientRect();
+                const visible = isVisible(el);
+                const fVisibleCheck = isFullyVisible(el);
+                if (!visible)
+                    return { visible: false, fullyVisible: false, anchorMatch: false, points: [] };
+                if (fVisible && !fVisibleCheck)
+                    return { visible, fullyVisible: false, anchorMatch: false, points: [] };
+                let anchorMatch = true;
+                if (anchorPoint) {
+                    const hit = document.elementFromPoint(anchorPoint.x, anchorPoint.y);
+                    anchorMatch = hit !== null && (hit === el || el.contains(hit));
+                    if (!anchorMatch)
+                        return { visible, fullyVisible: fVisibleCheck, anchorMatch: false, points: [] };
+                }
+                const x1 = Math.max(0, r.left);
+                const y1 = Math.max(0, r.top);
+                const x2 = Math.min(window.innerWidth, r.right);
+                const y2 = Math.min(window.innerHeight, r.bottom);
+                const mx = Math.round((x1 + x2) / 2);
+                const pad = 24;
+                const points = [
+                    { x: mx, y: Math.round(y1 + pad) }, // top-middle (avoid center overlays)
+                    { x: mx, y: Math.round((y1 + y2) / 2) }, // middle
+                    { x: mx, y: Math.round(y2 - pad) }, // bottom-middle
+                    { x: Math.round(x1 + pad), y: Math.round(y1 + pad) }, // top-left
+                    { x: Math.round(x2 - pad), y: Math.round(y1 + pad) }, // top-right
+                ];
+                const ok = [];
+                for (const p of points) {
+                    if (!Number.isFinite(p.x) || !Number.isFinite(p.y))
+                        continue;
+                    if (p.x < 0 || p.y < 0 || p.x > window.innerWidth || p.y > window.innerHeight)
+                        continue;
+                    const hit = document.elementFromPoint(p.x, p.y);
+                    if (hit && (hit === el || el.contains(hit))) {
+                        ok.push(p);
+                    }
+                }
+                if (!ok.length)
+                    ok.push({ x: mx, y: Math.round((y1 + y2) / 2) });
+                return { visible: true, fullyVisible: fVisibleCheck, anchorMatch, points: ok };
+            }, { sel: selector, fVisible: fullyVisible, anchorPoint: anchor });
+            if (!info) {
+                return { success: false, error: 'element not found' };
+            }
+            if (!info.visible) {
+                return { success: false, error: 'element not visible' };
+            }
+            if (fullyVisible && !info.fullyVisible) {
+                return { success: false, error: 'element not fully visible in viewport' };
+            }
+            if (anchor && !info.anchorMatch) {
+                return { success: false, error: 'anchor point does not hit target element' };
+            }
+            if (Array.isArray(info.points) && info.points.length > 0) {
+                const p = info.points[0];
+                const x = Math.round(p.x);
+                const y = Math.round(p.y);
+                if (useSystemMouse) {
+                    if (ctx.systemInput?.mouseMove) {
+                        await ctx.systemInput.mouseMove(x, y, 2);
+                    }
+                }
+                else if (protocolMouse && typeof protocolMouse.move === 'function') {
+                    await protocolMouse.move(x, y, { steps: 2 });
+                }
+                await new Promise((r) => setTimeout(r, 80));
+            }
+        }
+        if (useSystemMouse) {
+            await ctx.systemInput.mouseWheel(0, deltaY);
+        }
+        else {
+            await protocolMouse.wheel(0, deltaY);
+        }
+        return { success: true, deltaY, inputMode: useSystemMouse ? 'system' : 'protocol' };
+    }
+    // fallback：系统键盘滚动（PageDown / PageUp）
+    const keyboard = ctx.page.keyboard;
+    if (keyboard?.press) {
+        const key = direction === 'up' ? 'PageUp' : 'PageDown';
+        await keyboard.press(key);
+        return { success: true, key, inputMode: useSystemMouse ? 'system' : 'protocol' };
+    }
+    return { success: false, error: 'no scroll capability available' };
+}
+export const scrollOperation = {
+    id: 'scroll',
+    description: 'Scroll page or target element',
+    requiredCapabilities: ['scroll'],
+    run: runScroll,
+};
+//# sourceMappingURL=scroll.js.map

package/dist/modules/operations/src/operations/type.js

@@ -0,0 +1,190 @@
+async function runType(ctx, config) {
+    const selector = typeof config.selector === 'string' ? config.selector.trim() : '';
+    if (!selector) {
+        return { success: false, error: 'selector required for type operation' };
+    }
+    const index = Number.isFinite(config.index) ? Math.max(0, Math.floor(config.index)) : 0;
+    const keyboard = ctx.page.keyboard;
+    const fullyVisible = config.fullyVisible !== false;
+    const anchor = config.anchor ?? null;
+    const useSystemMouse = config.useSystemMouse !== false;
+    const protocolMouse = ctx.page?.mouse;
+    if (useSystemMouse && !ctx.systemInput?.mouseClick) {
+        return { success: false, error: 'system mouse not available' };
+    }
+    if (!useSystemMouse && (!protocolMouse || typeof protocolMouse.click !== 'function')) {
+        return { success: false, error: 'protocol mouse not available' };
+    }
+    if (!keyboard || typeof keyboard.type !== 'function') {
+        return { success: false, error: 'keyboard type not available' };
+    }
+    const getClickableRect = async () => ctx.page.evaluate(({ sel, idx, fVisible, anchorPoint }) => {
+        const isVisible = (el) => {
+            const r = el.getBoundingClientRect();
+            return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < window.innerHeight && r.right > 0 && r.left < window.innerWidth;
+        };
+        const isFullyVisible = (el) => {
+            const r = el.getBoundingClientRect();
+            return r.width > 0 && r.height > 0 && r.top >= 0 && r.left >= 0 && r.bottom <= window.innerHeight && r.right <= window.innerWidth;
+        };
+        const nodes = Array.from(document.querySelectorAll(sel));
+        const candidates = nodes.filter((n) => isVisible(n));
+        const root = candidates[idx];
+        if (!root)
+            return null;
+        const focusEl = root instanceof HTMLInputElement ||
+            root instanceof HTMLTextAreaElement ||
+            (root instanceof HTMLElement && root.isContentEditable)
+            ? root
+            : root.querySelector('input,textarea,[contenteditable="true"],[contenteditable="plaintext-only"]') ||
+                root;
+        const r = focusEl.getBoundingClientRect();
+        const visible = isVisible(focusEl);
+        const fVisibleCheck = isFullyVisible(focusEl);
+        if (!visible)
+            return { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom, visible: false, fullyVisible: false, anchorMatch: false, clickPoints: [] };
+        if (fVisible && !fVisible)
+            return { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom, visible, fullyVisible: false, anchorMatch: false, clickPoints: [] };
+        let anchorMatch = true;
+        if (anchorPoint) {
+            const hit = document.elementFromPoint(anchorPoint.x, anchorPoint.y);
+            anchorMatch = hit !== null && (hit === focusEl || focusEl.contains(hit));
+            if (!anchorMatch)
+                return { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom, visible, fullyVisible: fVisibleCheck, anchorMatch: false, clickPoints: [] };
+        }
+        const midY = Math.round((r.top + r.bottom) / 2);
+        const points = [
+            { x: Math.round((r.left + r.right) / 2), y: midY },
+            { x: Math.round(r.left + 8), y: midY },
+            { x: Math.round(r.right - 8), y: midY },
+        ];
+        const clickPoints = [];
+        for (const p of points) {
+            if (!Number.isFinite(p.x) || !Number.isFinite(p.y))
+                continue;
+            const hit = document.elementFromPoint(p.x, p.y);
+            if (hit && (hit === focusEl || focusEl.contains(hit))) {
+                clickPoints.push(p);
+            }
+        }
+        if (!clickPoints.length)
+            clickPoints.push(points[0]);
+        return { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom, visible, fullyVisible: fVisibleCheck, anchorMatch, clickPoints };
+    }, { sel: selector, idx: index, fVisible: fullyVisible, anchorPoint: anchor });
+    const getTextLen = async () => ctx.page.evaluate(({ sel, idx }) => {
+        const nodes = Array.from(document.querySelectorAll(sel));
+        const root = nodes[idx];
+        if (!root)
+            return null;
+        const focusEl = root instanceof HTMLInputElement ||
+            root instanceof HTMLTextAreaElement ||
+            (root instanceof HTMLElement && root.isContentEditable)
+            ? root
+            : root.querySelector('input,textarea,[contenteditable="true"],[contenteditable="plaintext-only"]') ||
+                root;
+        if (focusEl instanceof HTMLInputElement || focusEl instanceof HTMLTextAreaElement)
+            return focusEl.value.length;
+        if (focusEl instanceof HTMLElement && focusEl.isContentEditable)
+            return (focusEl.textContent || '').trim().length;
+        return (focusEl.textContent || '').trim().length;
+    }, { sel: selector, idx: index });
+    const isFocused = async () => ctx.page.evaluate(({ sel, idx }) => {
+        const nodes = Array.from(document.querySelectorAll(sel));
+        const root = nodes[idx];
+        if (!root)
+            return false;
+        const active = document.activeElement;
+        if (!active)
+            return false;
+        if (!(active instanceof Element))
+            return false;
+        return root === active || root.contains(active);
+    }, { sel: selector, idx: index });
+    // 1) 定位目标元素（只读）并系统点击聚焦
+    const rect = await getClickableRect();
+    if (!rect || !rect.visible) {
+        return { success: false, error: 'element not visible' };
+    }
+    if (fullyVisible && !rect.fullyVisible) {
+        return { success: false, error: 'element not fully visible in viewport' };
+    }
+    if (anchor && !rect.anchorMatch) {
+        return { success: false, error: 'anchor point does not hit target element' };
+    }
+    let focused = false;
+    for (const p of rect.clickPoints) {
+        const x = Math.round(p.x);
+        const y = Math.round(p.y);
+        if (useSystemMouse) {
+            await ctx.systemInput.mouseClick(x, y);
+        }
+        else {
+            await protocolMouse.click(x, y);
+        }
+        await new Promise((r) => setTimeout(r, 160));
+        try {
+            focused = await isFocused();
+        }
+        catch {
+            focused = false;
+        }
+        if (focused)
+            break;
+    }
+    if (!focused) {
+        return { success: false, error: 'unable to focus element' };
+    }
+    // 2) 清空（系统级：全选 + 删除）
+    if (config.clear_first && typeof keyboard.press === 'function') {
+        // 先尽量把光标落到末尾，避免某些站点的输入框未自动聚焦导致清空失败
+        await keyboard.press('End').catch(() => { });
+        await new Promise((r) => setTimeout(r, 80));
+        // macOS 用 Meta+A；其他平台用 Control+A（macOS 的 Control+A 会把光标移到行首，反而破坏全选）
+        const isMac = process.platform === 'darwin';
+        if (isMac) {
+            await keyboard.press('Meta+A').catch(() => { });
+        }
+        else {
+            await keyboard.press('Control+A').catch(() => { });
+        }
+        await new Promise((r) => setTimeout(r, 80));
+        await keyboard.press('Backspace').catch(() => { });
+        await keyboard.press('Delete').catch(() => { });
+        await new Promise((r) => setTimeout(r, 120));
+        // 兜底：如果仍未清空，使用有限次 Backspace 清空（系统级）
+        let len = null;
+        try {
+            len = await getTextLen();
+        }
+        catch {
+            len = null;
+        }
+        if (typeof len === 'number' && len > 0) {
+            await keyboard.press('End').catch(() => { });
+            const maxBackspace = Math.min(80, len + 10);
+            for (let i = 0; i < maxBackspace; i += 1) {
+                await keyboard.press('Backspace').catch(() => { });
+            }
+            await new Promise((r) => setTimeout(r, 120));
+        }
+    }
+    // 3) 系统级输入
+    const delay = config.human_typing ? 80 : 0;
+    await keyboard.type(String(config.text ?? ''), { delay });
+    // 4) 提交（可选）
+    if (config.submit && typeof keyboard.press === 'function') {
+        await new Promise((r) => setTimeout(r, 200));
+        await keyboard.press('Enter');
+    }
+    if (config.pause_after) {
+        await new Promise((r) => setTimeout(r, config.pause_after));
+    }
+    return { success: true, inputMode: useSystemMouse ? 'system' : 'protocol' };
+}
+export const typeOperation = {
+    id: 'type',
+    description: 'Type text into input element',
+    requiredCapabilities: ['input'],
+    run: runType,
+};
+//# sourceMappingURL=type.js.map

package/dist/modules/operations/src/queue.js

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'node:events';
+import { getOperation } from './registry.js';
+import { containerAllowsOperation } from './container-binding.js';
+export class ContainerOperationQueue extends EventEmitter {
+    queues = new Map();
+    processing = new Set();
+    options;
+    taskCounter = 0;
+    constructor(options = {}) {
+        super();
+        this.options = { autoStart: true, ...options };
+    }
+    enqueue(container, operationId, config = {}) {
+        containerAllowsOperation(container, operationId);
+        const queue = this.ensureQueue(container.id);
+        const task = {
+            id: `${container.id}:${operationId}:${Date.now()}:${this.taskCounter++}`,
+            container,
+            operationId,
+            priority: config.priority ?? 0,
+            config: (config.config || {}),
+            status: 'pending',
+            enqueuedAt: Date.now(),
+            event: config.event,
+        };
+        queue.push(task);
+        queue.sort((a, b) => b.priority - a.priority || a.enqueuedAt - b.enqueuedAt);
+        this.emit('task:queued', { task });
+        if (this.options.autoStart) {
+            void this.process(container.id);
+        }
+        return task;
+    }
+    async process(containerId) {
+        if (this.processing.has(containerId)) {
+            return;
+        }
+        const queue = this.ensureQueue(containerId);
+        if (!queue.length) {
+            return;
+        }
+        this.processing.add(containerId);
+        try {
+            while (queue.length) {
+                const task = queue.shift();
+                await this.runTask(task);
+            }
+        }
+        finally {
+            this.processing.delete(containerId);
+        }
+    }
+    async runTask(task) {
+        const operation = getOperation(task.operationId);
+        if (!operation) {
+            task.status = 'failed';
+            task.error = `Operation ${task.operationId} not found`;
+            this.emit('task:failed', { task, error: task.error });
+            return;
+        }
+        if (!this.options.contextProvider) {
+            task.status = 'failed';
+            task.error = 'No OperationContext provider configured';
+            this.emit('task:failed', { task, error: task.error });
+            return;
+        }
+        const context = await this.options.contextProvider(task);
+        task.startedAt = Date.now();
+        task.status = 'running';
+        this.emit('task:started', { task });
+        try {
+            const executor = this.options.executor ?? this.defaultExecutor;
+            const result = await executor(task, context);
+            task.result = result;
+            task.status = 'completed';
+            task.finishedAt = Date.now();
+            this.emit('task:completed', { task, result });
+        }
+        catch (err) {
+            task.status = 'failed';
+            task.error = err?.message || String(err);
+            task.finishedAt = Date.now();
+            this.emit('task:failed', { task, error: task.error });
+        }
+    }
+    async defaultExecutor(task, context) {
+        const operation = getOperation(task.operationId);
+        if (!operation) {
+            throw new Error(`Operation ${task.operationId} not registered`);
+        }
+        return operation.run(context, task.config);
+    }
+    ensureQueue(containerId) {
+        if (!this.queues.has(containerId)) {
+            this.queues.set(containerId, []);
+        }
+        return this.queues.get(containerId);
+    }
+}
+//# sourceMappingURL=queue.js.map

package/dist/modules/operations/src/registry.js

@@ -0,0 +1,11 @@
+const registry = new Map();
+export function registerOperation(definition) {
+    registry.set(definition.id, definition);
+}
+export function getOperation(id) {
+    return registry.get(id);
+}
+export function listOperations() {
+    return Array.from(registry.values());
+}
+//# sourceMappingURL=registry.js.map

package/dist/modules/operations/src/system/mouse.js

@@ -0,0 +1,33 @@
+async function ensureRobot(ctx) {
+    if (ctx.systemInput?.mouseMove && ctx.systemInput.mouseClick) {
+        return ctx.systemInput;
+    }
+    // robotjs has been removed due to CI build issues on Linux
+    // TODO: Replace with a cross-platform alternative or implement platform-specific solutions
+    throw new Error('robotjs removed from dependencies. System-level mouse operations are currently unavailable.');
+}
+export const mouseMoveOperation = {
+    id: 'system:mouse-move',
+    description: '移动系统鼠标到屏幕坐标',
+    run: async (ctx, config) => {
+        if (typeof config.x !== 'number' || typeof config.y !== 'number') {
+            throw new Error('只支持全局屏幕坐标 (x,y)');
+        }
+        const sys = await ensureRobot(ctx);
+        await sys.mouseMove(config.x, config.y, config.steps);
+        return { success: true };
+    },
+};
+export const mouseClickOperation = {
+    id: 'system:mouse-click',
+    description: '在屏幕坐标点击鼠标',
+    run: async (ctx, config) => {
+        if (typeof config.x !== 'number' || typeof config.y !== 'number') {
+            throw new Error('只支持全局屏幕坐标 (x,y)');
+        }
+        const sys = await ensureRobot(ctx);
+        await sys.mouseClick(config.x, config.y, config.button, config.clicks);
+        return { success: true };
+    },
+};
+//# sourceMappingURL=mouse.js.map

package/dist/modules/state/src/atomic-json.js

@@ -0,0 +1,33 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+export async function readJsonMaybe(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (err) {
+        if (err?.code === 'ENOENT')
+            return null;
+        throw err;
+    }
+}
+export async function atomicWriteJson(filePath, data, options = {}) {
+    const encoding = options.encoding || 'utf8';
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true });
+    const tmpPath = path.join(dir, `${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
+    await fs.writeFile(tmpPath, JSON.stringify(data, null, 2), encoding);
+    try {
+        await fs.rename(tmpPath, filePath);
+    }
+    catch (err) {
+        // Windows: rename 不允许覆盖已存在文件
+        if (err?.code === 'EEXIST' || err?.code === 'EPERM') {
+            await fs.rm(filePath, { force: true });
+            await fs.rename(tmpPath, filePath);
+            return;
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=atomic-json.js.map

package/dist/modules/workflow/blocks/AnchorVerificationBlock.js

@@ -0,0 +1,71 @@
+/**
+ * Workflow Block: AnchorVerificationBlock
+ *
+ * 职责：
+ * - 基于容器定义（container-library）验证指定容器锚点是否在视口内且可见
+ * - 支持进入锚点 / 离开锚点两种语义（enter/exit）
+ * - 避免在这里直接调用 containers:match，降低超时对主流程的影响
+ */
+export async function execute(input) {
+    const { sessionId, containerId, operation, expectedVisible = operation === 'enter', 
+    // timeoutMs 目前只用于 browser:execute 的防御性超时
+    timeoutMs = 10000, serviceUrl = 'http://127.0.0.1:7701' } = input;
+    try {
+        console.log(`[AnchorVerification] ${operation} anchor: ${containerId}`);
+        // 通过 container-library 定义获取 selector，并在页面内高亮 + 读取 Rect。
+        // 注意：这里不再调用 containers:match，避免复用阶段性 P0 问题。
+        const { verifyAnchorByContainerId } = await import('./helpers/containerAnchors.js');
+        const anchor = await verifyAnchorByContainerId(containerId, sessionId, serviceUrl, '3px solid #ff4444', 2000);
+        if (!anchor.found) {
+            return {
+                success: false,
+                verified: false,
+                containerFound: false,
+                visible: false,
+                error: anchor.error || `容器未找到: ${containerId}`
+            };
+        }
+        const rect = anchor.rect;
+        if (!rect) {
+            return {
+                success: false,
+                verified: false,
+                containerFound: true,
+                visible: false,
+                error: '未获取到锚点 Rect'
+            };
+        }
+        // 视口内判定：在这里不直接依赖 window.innerHeight，
+        // 仅要求宽高 > 0，由调用方结合 Rect 再做更严格判断。
+        const visible = rect.width > 0 && rect.height > 0;
+        // enter: 期望可见；exit: 期望不可见/不可命中
+        const verified = visible === !!expectedVisible;
+        if (!verified) {
+            return {
+                success: false,
+                verified: false,
+                containerFound: true,
+                visible,
+                rect,
+                error: `锚点验证失败: 期望${expectedVisible ? '可见' : '不可见'}, 实际${visible ? '可见' : '不可见'}`
+            };
+        }
+        return {
+            success: true,
+            verified: true,
+            containerFound: true,
+            visible,
+            rect
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            verified: false,
+            containerFound: false,
+            visible: false,
+            error: `锚点验证异常: ${err.message}`
+        };
+    }
+}
+//# sourceMappingURL=AnchorVerificationBlock.js.map

package/dist/modules/workflow/blocks/BehaviorRandomizer.js

@@ -0,0 +1,26 @@
+/**
+ * BehaviorRandomizer - 行为随机化工具
+ *
+ * 用于降低自动化痕迹：
+ * - 随机延迟
+ * - 随机滚动偏移
+ * - 随机输入节奏
+ */
+export function randomDelay(options = {}) {
+    const min = options.minMs ?? 300;
+    const max = options.maxMs ?? 1200;
+    const delay = Math.floor(Math.random() * (max - min + 1)) + min;
+    return new Promise(resolve => setTimeout(resolve, delay));
+}
+export function randomOffset(base, variance = 50) {
+    const offset = Math.floor(Math.random() * variance * 2) - variance;
+    return base + offset;
+}
+export async function typeWithDelay(text, onChar, minDelay = 50, maxDelay = 200) {
+    for (const char of text) {
+        await onChar(char);
+        const delay = Math.floor(Math.random() * (maxDelay - minDelay + 1)) + minDelay;
+        await new Promise(resolve => setTimeout(resolve, delay));
+    }
+}
+//# sourceMappingURL=BehaviorRandomizer.js.map

package/dist/modules/workflow/blocks/CallWorkflowBlock.js

@@ -0,0 +1,38 @@
+import { WorkflowExecutor } from './WorkflowExecutor.js';
+import { getWorkflowDefinition } from '../config/workflowRegistry.js';
+export async function execute(input) {
+    const { workflowId, context, mergeMode = 'merge', stopOnFailure = true } = input;
+    if (!workflowId) {
+        return { success: false, error: 'workflowId is required' };
+    }
+    const def = getWorkflowDefinition(workflowId);
+    if (!def) {
+        return { success: false, error: `Workflow not found: ${workflowId}` };
+    }
+    const executor = new WorkflowExecutor();
+    // 由上层统一注册 Block 集（这里不做默认注册），只负责执行定义
+    const initialContext = context || {};
+    const childResult = await executor.execute(def, initialContext);
+    if (!childResult.success && stopOnFailure) {
+        return {
+            success: false,
+            error: `Child workflow failed: ${workflowId}`,
+            childResult,
+        };
+    }
+    let contextPatch = {};
+    if (mergeMode === 'namespace') {
+        contextPatch = { [workflowId]: childResult };
+    }
+    else {
+        // merge 模式：简单暴露最后一步输出（如果存在），否则只暴露 success
+        const lastStep = childResult.results[childResult.results.length - 1] || {};
+        contextPatch = { ...lastStep };
+    }
+    return {
+        success: true,
+        childResult,
+        contextPatch,
+    };
+}
+//# sourceMappingURL=CallWorkflowBlock.js.map