@testsmith/testblocks 0.9.4 → 0.9.7

package/dist/core/blocks/playwright/navigation/WebWaitForElementBlock.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebWaitForElementBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Wait for an element to appear/disappear.
+ */
+class WebWaitForElementBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_wait_for_element';
+        this.category = 'Web';
+        this.color = '#9C27B0';
+        this.tooltip = 'Wait for an element to appear/disappear';
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'STATE', type: 'field', fieldType: 'dropdown', options: [['Visible', 'visible'], ['Hidden', 'hidden'], ['Attached', 'attached'], ['Detached', 'detached']] },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const state = params.STATE;
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Waiting for ${selector} to be ${state}`);
+        await page.waitForSelector(selector, { state, timeout });
+        return {
+            _summary: `${params.SELECTOR} is ${state}`,
+            selector,
+            state,
+        };
+    }
+}
+exports.WebWaitForElementBlock = WebWaitForElementBlock;

package/dist/core/blocks/playwright/navigation/WebWaitForUrlBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Wait for URL to match.
+ */
+export declare class WebWaitForUrlBlock extends StatementBlock {
+    readonly type = "web_wait_for_url";
+    readonly category = "Web";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Wait for URL to match";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/navigation/WebWaitForUrlBlock.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebWaitForUrlBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Wait for URL to match.
+ */
+class WebWaitForUrlBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_wait_for_url';
+        this.category = 'Web';
+        this.color = '#9C27B0';
+        this.tooltip = 'Wait for URL to match';
+    }
+    getInputs() {
+        return [
+            { name: 'URL', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const url = (0, utils_1.resolveVariables)(params.URL, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        context.logger.info(`Waiting for URL to match: ${url}`);
+        await page.waitForURL(url, { timeout });
+        return {
+            _summary: url,
+            url,
+        };
+    }
+}
+exports.WebWaitForUrlBlock = WebWaitForUrlBlock;

package/dist/core/blocks/playwright/navigation/index.d.ts

@@ -0,0 +1,15 @@
+import { Block } from '../../base';
+import { BlockDefinition } from '../../../types';
+export { WebNavigateBlock } from './WebNavigateBlock';
+export { WebWaitForElementBlock } from './WebWaitForElementBlock';
+export { WebWaitForUrlBlock } from './WebWaitForUrlBlock';
+export { WebWaitBlock } from './WebWaitBlock';
+export { WebScreenshotBlock } from './WebScreenshotBlock';
+/**
+ * All navigation block class instances.
+ */
+export declare const navigationBlockClasses: Block[];
+/**
+ * Navigation blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const navigationBlocks: BlockDefinition[];

package/dist/core/blocks/playwright/navigation/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.navigationBlocks = exports.navigationBlockClasses = exports.WebScreenshotBlock = exports.WebWaitBlock = exports.WebWaitForUrlBlock = exports.WebWaitForElementBlock = exports.WebNavigateBlock = void 0;
+var WebNavigateBlock_1 = require("./WebNavigateBlock");
+Object.defineProperty(exports, "WebNavigateBlock", { enumerable: true, get: function () { return WebNavigateBlock_1.WebNavigateBlock; } });
+var WebWaitForElementBlock_1 = require("./WebWaitForElementBlock");
+Object.defineProperty(exports, "WebWaitForElementBlock", { enumerable: true, get: function () { return WebWaitForElementBlock_1.WebWaitForElementBlock; } });
+var WebWaitForUrlBlock_1 = require("./WebWaitForUrlBlock");
+Object.defineProperty(exports, "WebWaitForUrlBlock", { enumerable: true, get: function () { return WebWaitForUrlBlock_1.WebWaitForUrlBlock; } });
+var WebWaitBlock_1 = require("./WebWaitBlock");
+Object.defineProperty(exports, "WebWaitBlock", { enumerable: true, get: function () { return WebWaitBlock_1.WebWaitBlock; } });
+var WebScreenshotBlock_1 = require("./WebScreenshotBlock");
+Object.defineProperty(exports, "WebScreenshotBlock", { enumerable: true, get: function () { return WebScreenshotBlock_1.WebScreenshotBlock; } });
+const WebNavigateBlock_2 = require("./WebNavigateBlock");
+const WebWaitForElementBlock_2 = require("./WebWaitForElementBlock");
+const WebWaitForUrlBlock_2 = require("./WebWaitForUrlBlock");
+const WebWaitBlock_2 = require("./WebWaitBlock");
+const WebScreenshotBlock_2 = require("./WebScreenshotBlock");
+/**
+ * All navigation block class instances.
+ */
+exports.navigationBlockClasses = [
+    new WebNavigateBlock_2.WebNavigateBlock(),
+    new WebWaitForElementBlock_2.WebWaitForElementBlock(),
+    new WebWaitForUrlBlock_2.WebWaitForUrlBlock(),
+    new WebWaitBlock_2.WebWaitBlock(),
+    new WebScreenshotBlock_2.WebScreenshotBlock(),
+];
+/**
+ * Navigation blocks as BlockDefinition array for backward compatibility.
+ */
+exports.navigationBlocks = exports.navigationBlockClasses.map(block => block.toDefinition());

package/dist/core/blocks/playwright/retrieval/WebCountElementsBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Count the number of elements matching a selector.
+ */
+export declare class WebCountElementsBlock extends ValueBlock {
+    readonly type = "web_count_elements";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Count the number of elements matching a selector";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebCountElementsBlock.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCountElementsBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Count the number of elements matching a selector.
+ */
+class WebCountElementsBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_count_elements';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Count the number of elements matching a selector';
+        this.output = { type: 'Number' };
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const count = await page.locator(selector).count();
+        context.logger.debug(`Found ${count} elements matching ${selector}`);
+        return {
+            _summary: `${count} elements`,
+            _value: count,
+            selector,
+            count,
+        };
+    }
+}
+exports.WebCountElementsBlock = WebCountElementsBlock;

package/dist/core/blocks/playwright/retrieval/WebGetAttributeBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Get attribute value of an element (auto-waits).
+ */
+export declare class WebGetAttributeBlock extends ValueBlock {
+    readonly type = "web_get_attribute";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Get attribute value of an element (auto-waits)";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebGetAttributeBlock.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGetAttributeBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Get attribute value of an element (auto-waits).
+ */
+class WebGetAttributeBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_get_attribute';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Get attribute value of an element (auto-waits)';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+            { name: 'ATTRIBUTE', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const attribute = params.ATTRIBUTE;
+        const timeout = (0, utils_1.getTimeout)(context);
+        const locator = page.locator(selector);
+        await locator.waitFor({ state: 'attached', timeout });
+        const value = await locator.getAttribute(attribute, { timeout });
+        context.logger.debug(`Attribute ${attribute} of ${selector}: "${value}"`);
+        return {
+            _summary: `${attribute} = "${value}"`,
+            _value: value,
+            selector,
+            attribute,
+            value,
+        };
+    }
+}
+exports.WebGetAttributeBlock = WebGetAttributeBlock;

package/dist/core/blocks/playwright/retrieval/WebGetInputValueBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Get current value of an input field (auto-waits).
+ */
+export declare class WebGetInputValueBlock extends ValueBlock {
+    readonly type = "web_get_input_value";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Get current value of an input field (auto-waits)";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebGetInputValueBlock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGetInputValueBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Get current value of an input field (auto-waits).
+ */
+class WebGetInputValueBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_get_input_value';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Get current value of an input field (auto-waits)';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        const locator = page.locator(selector);
+        await locator.waitFor({ state: 'visible', timeout });
+        const value = await locator.inputValue({ timeout });
+        context.logger.debug(`Input value of ${selector}: "${value}"`);
+        const displayValue = value.length > 40 ? value.substring(0, 40) + '...' : value;
+        return {
+            _summary: `"${displayValue}"`,
+            _value: value,
+            selector,
+            value,
+        };
+    }
+}
+exports.WebGetInputValueBlock = WebGetInputValueBlock;

package/dist/core/blocks/playwright/retrieval/WebGetTextBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Get text content of an element (auto-waits).
+ */
+export declare class WebGetTextBlock extends ValueBlock {
+    readonly type = "web_get_text";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Get text content of an element (auto-waits)";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebGetTextBlock.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGetTextBlock = void 0;
+const base_1 = require("../../base");
+const utils_1 = require("../utils");
+/**
+ * Get text content of an element (auto-waits).
+ */
+class WebGetTextBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_get_text';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Get text content of an element (auto-waits)';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [
+            { name: 'SELECTOR', type: 'field', fieldType: 'text', required: true },
+        ];
+    }
+    async execute(params, context) {
+        const page = context.page;
+        const selector = (0, utils_1.resolveSelector)(params, context);
+        const timeout = (0, utils_1.getTimeout)(context);
+        const locator = page.locator(selector);
+        await locator.waitFor({ state: 'visible', timeout });
+        const text = await locator.textContent({ timeout });
+        context.logger.debug(`Text content of ${selector}: "${text}"`);
+        const displayText = text && text.length > 40 ? text.substring(0, 40) + '...' : text;
+        return {
+            _summary: `"${displayText}"`,
+            _value: text,
+            selector,
+            text,
+        };
+    }
+}
+exports.WebGetTextBlock = WebGetTextBlock;

package/dist/core/blocks/playwright/retrieval/WebGetTitleBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Get the page title.
+ */
+export declare class WebGetTitleBlock extends ValueBlock {
+    readonly type = "web_get_title";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Get the page title";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebGetTitleBlock.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGetTitleBlock = void 0;
+const base_1 = require("../../base");
+/**
+ * Get the page title.
+ */
+class WebGetTitleBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_get_title';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Get the page title';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [];
+    }
+    async execute(_params, context) {
+        const page = context.page;
+        const title = await page.title();
+        context.logger.debug(`Page title: "${title}"`);
+        return {
+            _summary: `"${title}"`,
+            _value: title,
+            title,
+        };
+    }
+}
+exports.WebGetTitleBlock = WebGetTitleBlock;

package/dist/core/blocks/playwright/retrieval/WebGetUrlBlock.d.ts

@@ -0,0 +1,16 @@
+import { ValueBlock } from '../../base';
+import { BlockInput, ExecutionContext } from '../../../types';
+/**
+ * Get the current URL.
+ */
+export declare class WebGetUrlBlock extends ValueBlock {
+    readonly type = "web_get_url";
+    readonly category = "Web";
+    readonly color = "#2196F3";
+    readonly tooltip = "Get the current URL";
+    readonly output: {
+        type: string;
+    };
+    getInputs(): BlockInput[];
+    execute(_params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/playwright/retrieval/WebGetUrlBlock.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebGetUrlBlock = void 0;
+const base_1 = require("../../base");
+/**
+ * Get the current URL.
+ */
+class WebGetUrlBlock extends base_1.ValueBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'web_get_url';
+        this.category = 'Web';
+        this.color = '#2196F3';
+        this.tooltip = 'Get the current URL';
+        this.output = { type: 'String' };
+    }
+    getInputs() {
+        return [];
+    }
+    async execute(_params, context) {
+        const page = context.page;
+        const url = page.url();
+        context.logger.debug(`Current URL: "${url}"`);
+        return {
+            _summary: url,
+            _value: url,
+            url,
+        };
+    }
+}
+exports.WebGetUrlBlock = WebGetUrlBlock;

package/dist/core/blocks/playwright/retrieval/index.d.ts

@@ -0,0 +1,16 @@
+import { Block } from '../../base';
+import { BlockDefinition } from '../../../types';
+export { WebGetTextBlock } from './WebGetTextBlock';
+export { WebGetAttributeBlock } from './WebGetAttributeBlock';
+export { WebGetInputValueBlock } from './WebGetInputValueBlock';
+export { WebGetTitleBlock } from './WebGetTitleBlock';
+export { WebGetUrlBlock } from './WebGetUrlBlock';
+export { WebCountElementsBlock } from './WebCountElementsBlock';
+/**
+ * All retrieval block class instances.
+ */
+export declare const retrievalBlockClasses: Block[];
+/**
+ * Retrieval blocks as BlockDefinition array for backward compatibility.
+ */
+export declare const retrievalBlocks: BlockDefinition[];

package/dist/core/blocks/playwright/retrieval/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.retrievalBlocks = exports.retrievalBlockClasses = exports.WebCountElementsBlock = exports.WebGetUrlBlock = exports.WebGetTitleBlock = exports.WebGetInputValueBlock = exports.WebGetAttributeBlock = exports.WebGetTextBlock = void 0;
+var WebGetTextBlock_1 = require("./WebGetTextBlock");
+Object.defineProperty(exports, "WebGetTextBlock", { enumerable: true, get: function () { return WebGetTextBlock_1.WebGetTextBlock; } });
+var WebGetAttributeBlock_1 = require("./WebGetAttributeBlock");
+Object.defineProperty(exports, "WebGetAttributeBlock", { enumerable: true, get: function () { return WebGetAttributeBlock_1.WebGetAttributeBlock; } });
+var WebGetInputValueBlock_1 = require("./WebGetInputValueBlock");
+Object.defineProperty(exports, "WebGetInputValueBlock", { enumerable: true, get: function () { return WebGetInputValueBlock_1.WebGetInputValueBlock; } });
+var WebGetTitleBlock_1 = require("./WebGetTitleBlock");
+Object.defineProperty(exports, "WebGetTitleBlock", { enumerable: true, get: function () { return WebGetTitleBlock_1.WebGetTitleBlock; } });
+var WebGetUrlBlock_1 = require("./WebGetUrlBlock");
+Object.defineProperty(exports, "WebGetUrlBlock", { enumerable: true, get: function () { return WebGetUrlBlock_1.WebGetUrlBlock; } });
+var WebCountElementsBlock_1 = require("./WebCountElementsBlock");
+Object.defineProperty(exports, "WebCountElementsBlock", { enumerable: true, get: function () { return WebCountElementsBlock_1.WebCountElementsBlock; } });
+const WebGetTextBlock_2 = require("./WebGetTextBlock");
+const WebGetAttributeBlock_2 = require("./WebGetAttributeBlock");
+const WebGetInputValueBlock_2 = require("./WebGetInputValueBlock");
+const WebGetTitleBlock_2 = require("./WebGetTitleBlock");
+const WebGetUrlBlock_2 = require("./WebGetUrlBlock");
+const WebCountElementsBlock_2 = require("./WebCountElementsBlock");
+/**
+ * All retrieval block class instances.
+ */
+exports.retrievalBlockClasses = [
+    new WebGetTextBlock_2.WebGetTextBlock(),
+    new WebGetAttributeBlock_2.WebGetAttributeBlock(),
+    new WebGetInputValueBlock_2.WebGetInputValueBlock(),
+    new WebGetTitleBlock_2.WebGetTitleBlock(),
+    new WebGetUrlBlock_2.WebGetUrlBlock(),
+    new WebCountElementsBlock_2.WebCountElementsBlock(),
+];
+/**
+ * Retrieval blocks as BlockDefinition array for backward compatibility.
+ */
+exports.retrievalBlocks = exports.retrievalBlockClasses.map(block => block.toDefinition());

package/dist/core/blocks/playwright/types.d.ts

@@ -55,6 +55,20 @@ export interface PlaywrightLocator {
     scrollIntoViewIfNeeded(options?: {
         timeout?: number;
     }): Promise<void>;
+    setInputFiles(files: string | string[] | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    } | {
+        name: string;
+        mimeType: string;
+        buffer: Buffer;
+    }[], options?: {
+        timeout?: number;
+    }): Promise<void>;
+    dragTo(target: PlaywrightLocator, options?: {
+        timeout?: number;
+    }): Promise<void>;
 }
 export interface PlaywrightPage {
     goto(url: string, options?: {

package/dist/core/blocks/procedures/ProcedureCallBlock.d.ts

@@ -0,0 +1,13 @@
+import { StatementBlock } from '../base';
+import { BlockInput, ExecutionContext } from '../../types';
+/**
+ * Call a defined procedure.
+ */
+export declare class ProcedureCallBlock extends StatementBlock {
+    readonly type = "procedure_call";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Call a defined procedure";
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}

package/dist/core/blocks/procedures/ProcedureCallBlock.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcedureCallBlock = void 0;
+const base_1 = require("../base");
+const utils_1 = require("../utils");
+const procedureRegistry_1 = require("./procedureRegistry");
+/**
+ * Call a defined procedure.
+ */
+class ProcedureCallBlock extends base_1.StatementBlock {
+    constructor() {
+        super(...arguments);
+        this.type = 'procedure_call';
+        this.category = 'Procedures';
+        this.color = '#9C27B0';
+        this.tooltip = 'Call a defined procedure';
+    }
+    getInputs() {
+        return [
+            { name: 'NAME', type: 'field', fieldType: 'text', required: true },
+            { name: 'ARGS', type: 'field', fieldType: 'text', default: '' }, // JSON object or comma-separated values
+        ];
+    }
+    async execute(params, context) {
+        const name = params.NAME;
+        const argsStr = (0, utils_1.resolveVariables)(params.ARGS, context);
+        // Look up procedure
+        const procedure = context.procedures?.get(name) || (0, procedureRegistry_1.getProcedure)(name);
+        if (!procedure) {
+            throw new Error(`Procedure not found: ${name}`);
+        }
+        // Parse arguments
+        let args = {};
+        if (argsStr.trim()) {
+            try {
+                // Try JSON format first: {"username": "test", "password": "123"}
+                args = JSON.parse(argsStr);
+            }
+            catch {
+                // Fall back to comma-separated values matching parameter order
+                const values = argsStr.split(',').map(v => {
+                    const trimmed = v.trim();
+                    try {
+                        return JSON.parse(trimmed);
+                    }
+                    catch {
+                        return trimmed;
+                    }
+                });
+                if (procedure.params) {
+                    procedure.params.forEach((param, index) => {
+                        if (index < values.length) {
+                            args[param.name] = values[index];
+                        }
+                        else if (param.default !== undefined) {
+                            args[param.name] = param.default;
+                        }
+                    });
+                }
+            }
+        }
+        context.logger.info(`Calling procedure: ${name}`);
+        return { procedureCall: true, name, args, procedure };
+    }
+}
+exports.ProcedureCallBlock = ProcedureCallBlock;

package/dist/core/blocks/procedures/ProcedureCallWithReturnBlock.d.ts

@@ -0,0 +1,14 @@
+import { ValueBlock } from '../base';
+import { BlockInput, BlockOutput, ExecutionContext } from '../../types';
+/**
+ * Call a procedure and get return value.
+ */
+export declare class ProcedureCallWithReturnBlock extends ValueBlock {
+    readonly type = "procedure_call_with_return";
+    readonly category = "Procedures";
+    readonly color = "#9C27B0";
+    readonly tooltip = "Call a procedure and get return value";
+    readonly output: BlockOutput;
+    getInputs(): BlockInput[];
+    execute(params: Record<string, unknown>, context: ExecutionContext): Promise<unknown>;
+}