@bimatrix-aud-platform/aud_mcp_server 1.1.48 → 1.1.50

package/dist/generators/mtsd-builder.d.ts

@@ -171,6 +171,7 @@ export declare class MtsdBuilder extends ElementContainer {
     private _variables;
     private _scriptText;
     private _moduleCode;
+    private _workFlow;
     constructor(reportName: string, opts?: {
         moduleCode?: string;
     });
@@ -188,6 +189,106 @@ export declare class MtsdBuilder extends ElementContainer {
     addVariable(name: string, value?: string, type?: string): this;
     /** Set client script text */
     setScript(text: string): this;
+    /**
+     * Control Type → WorkFlowEvents mapping
+     * Based on each control's WorkFlowEvents definition in 2.Sources/src/control/
+     */
+    private static readonly CONTROL_WORKFLOW_EVENTS;
+    /** Get default WorkFlowEvents for a control type */
+    static getControlWorkFlowEvents(controlType: string): string[];
+    /** Initialize WorkFlow model */
+    setWorkFlow(useEvent?: boolean): this;
+    /** Add Report node (ID="_ROOT_", 7 standard events) */
+    addWorkFlowReportNode(opts?: {
+        left?: number;
+        top?: number;
+        width?: number;
+        height?: number;
+        collapsed?: boolean;
+    }): this;
+    /** Add Control node. events 생략 시 controlType에 맞는 기본 이벤트 자동 사용 */
+    addWorkFlowControlNode(name: string, controlType: string, events?: string[], opts?: {
+        left?: number;
+        top?: number;
+        width?: number;
+        height?: number;
+    }): this;
+    /**
+     * Add Module node.
+     *
+     * - name: get_module_list의 MODULE_SUBJECT 값 사용
+     * - opts.description: get_module_list의 MODULE_DESCRIPTION 값 사용
+     * - opts.eventYn: get_module_list의 EVENT_YN 값.
+     *   "N"이면 Report 노드의 OnDocumentLoadComplete에 자동 링크 생성 (문서 로드 시 무조건 실행).
+     *   "Y"이면 컨트롤/보고서 이벤트에 자유롭게 연결 가능 (addWorkFlowLink로 적절한 이벤트에 연결 필요).
+     */
+    addWorkFlowModuleNode(id: string, name: string, moduleCode: string, params?: Array<{
+        id: string;
+        name: string;
+        value: any;
+        paramType?: string;
+        paramDescription?: string;
+        paramSeq?: string;
+        nullable?: string;
+        defaultValue?: string;
+        moduleCode?: string;
+        attr1?: string;
+        attr2?: string;
+        attr3?: string;
+    }>, opts?: {
+        left?: number;
+        top?: number;
+        width?: number;
+        height?: number;
+        isEventActive?: boolean;
+        description?: string;
+        eventYn?: string;
+    }): this;
+    /**
+     * Add Switch node (조건 분기).
+     *
+     * cases 배열의 각 항목:
+     * - operand: 비교 대상 변수명 (예: "VS_CODE", "VS_STATUS"). `:` 접두사 불필요.
+     *   → 실행 시 GlobalParam → Variables → Control 값 순으로 검색.
+     * - operator: 비교 연산자 (=, ==, <>, !=, >, >=, <, <=, IS NULL, IS NOT NULL,
+     *   START WITH, END WITH, CONTAIN, NOT CONTAIN)
+     * - value: 비교 값 (IS NULL/IS NOT NULL일 때는 빈 문자열)
+     * - id (선택): 케이스 ID. 생략 시 자동 생성 (CD + UUID).
+     * - name (선택): 케이스 표시명. 생략 시 "operand operator value" 형태로 자동 생성.
+     * - default: true이면 DEFAULT 케이스 (조건 없이 항상 매치). 반드시 마지막에 배치.
+     */
+    addWorkFlowSwitchNode(id: string, name: string, cases?: Array<{
+        operand?: string;
+        operator?: string;
+        value?: string;
+        id?: string;
+        name?: string;
+        description?: string;
+        default?: boolean;
+    }>, opts?: {
+        left?: number;
+        top?: number;
+        width?: number;
+        height?: number;
+    }): this;
+    /**
+     * Add WorkFlow link between nodes.
+     *
+     * 링크 유형별 사용법:
+     * - **Report/Control → 노드**: `fromParam`에 이벤트명 지정 (예: "OnClick", "OnDocumentLoadComplete")
+     * - **Switch → 노드**: `fromParam`에 케이스 ID 지정 (예: "CD..." 또는 "DEFAULT")
+     * - **Module → Module (성공)**: `fromParam` 생략, `type: 0` (기본값)
+     * - **Module → Module (실패)**: `fromParam` 생략, `type: 1`
+     *
+     * ID 자동 생성:
+     * - fromParam 있으면: `{from}.{fromParam}~{to}`
+     * - fromParam 없으면: `{from}~{to}`
+     */
+    addWorkFlowLink(from: string, to: string, opts?: {
+        fromParam?: string;
+        type?: number;
+    }): this;
+    private _ensureWorkFlow;
     /** Get the report code */
     getReportCode(): string;
     /** Build the complete MTSD document */

package/dist/generators/mtsd-builder.js

@@ -818,6 +818,7 @@ export class MtsdBuilder extends ElementContainer {
     _variables = [];
     _scriptText = "";
     _moduleCode = "SD";
+    _workFlow = null;
     constructor(reportName, opts) {
         super();
         this._reportName = reportName;
@@ -875,6 +876,300 @@ export class MtsdBuilder extends ElementContainer {
         this._scriptText = text;
         return this;
     }
+    // ---- WorkFlow Builder Methods ----
+    /**
+     * Control Type → WorkFlowEvents mapping
+     * Based on each control's WorkFlowEvents definition in 2.Sources/src/control/
+     */
+    static CONTROL_WORKFLOW_EVENTS = {
+        // Button
+        "Button": ["OnClick"],
+        "FileUploadButton": ["OnClick", "OnUploadCompleted"],
+        // Input
+        "TextBox": ["OnTextChange", "OnTextKeydown", "OnTextKeypress", "OnTextKeyup"],
+        "NumberBox": ["OnTextChange", "OnTextKeydown", "OnTextKeypress", "OnTextKeyup"],
+        "MaskTextBox": ["OnTextChange", "OnTextKeydown", "OnTextKeypress", "OnTextKeyup"],
+        "RichTextBox": ["OnTextChange", "OnTextKeydown", "OnTextKeypress", "OnTextKeyup"],
+        // Check / Radio
+        "CheckBox": ["OnValueChange"],
+        "RadioButton": ["OnValueChange"],
+        // ComboBox / PickList
+        "ComboBox": ["OnDataBindEnd", "OnValueChanged"],
+        "MultiComboBox": ["OnExecuteStart", "OnNodeClick", "OnTextKeyup", "OnValueChange", "OnDataBindEnd"],
+        "PickList": ["OnValueChange"],
+        // Calendar
+        "Calendar": ["OnValueChanged"],
+        "CalendarYear": ["OnValueChanged"],
+        "CalendarYM": ["OnValueChanged"],
+        "CalendarFromTo": ["OnValueChanged", "OnFromValueChanged"],
+        // Tree (checkbox tree)
+        "Tree": ["OnDataBindEnd", "OnNodeClick", "OnNodeDbClick"],
+        // Label / Image
+        "Label": ["OnClick", "OnMouseOut", "OnMouseOver"],
+        "Image": ["OnClick"],
+        // DataGrid (base 31 events)
+        "DataGrid": [
+            "OnCellClick", "OnCellDoubleClick", "OnCellTouch", "OnCellDoubleTouch",
+            "OnScroll", "OnStartEdit", "OnEndEdit", "OnDeletingRow",
+            "OnGridColumnHeaderClicked", "OnGridColumnHeaderDoubleClicked",
+            "OnGridMultiHeaderClicked", "OnGridMultiHeaderDoubleClicked",
+            "OnGridCheckBoxClicked", "OnGridMultiHeaderCheckBoxClicked",
+            "OnCellLoaded", "OnGridMultiHeaderCellLoaded",
+            "OnCurrentCellChanged", "OnCurrentRowChanged",
+            "OnValidate", "OnGridContextMenuOpening",
+            "OnGridExportStart", "OnGridComboBoxChanged", "OnMouseMove",
+            "OnDataBindEnd", "OnStartClipBoardPaste", "OnEndClipBoardPaste",
+            "OnGridFilterChanged", "OnCreateNewRow", "OnClick",
+            "OnCellKeyDown", "OnSelectedCellsDeleted",
+        ],
+        "TreeGrid": [
+            "OnCellClick", "OnCellDoubleClick", "OnCellTouch", "OnCellDoubleTouch",
+            "OnScroll", "OnStartEdit", "OnEndEdit", "OnDeletingRow",
+            "OnGridColumnHeaderClicked", "OnGridColumnHeaderDoubleClicked",
+            "OnGridMultiHeaderClicked", "OnGridMultiHeaderDoubleClicked",
+            "OnGridCheckBoxClicked", "OnGridMultiHeaderCheckBoxClicked",
+            "OnCellLoaded", "OnGridMultiHeaderCellLoaded",
+            "OnCurrentCellChanged", "OnCurrentRowChanged",
+            "OnValidate", "OnGridContextMenuOpening",
+            "OnGridExportStart", "OnGridComboBoxChanged", "OnMouseMove",
+            "OnDataBindEnd", "OnStartClipBoardPaste", "OnEndClipBoardPaste",
+            "OnGridFilterChanged", "OnCreateNewRow", "OnClick",
+            "OnCellKeyDown", "OnSelectedCellsDeleted",
+            "OnTreeCellClick",
+        ],
+        "CompactDataGrid": [
+            "OnCellClick", "OnCellDoubleClick", "OnCellTouch", "OnCellDoubleTouch",
+            "OnScroll", "OnStartEdit", "OnEndEdit", "OnDeletingRow",
+            "OnGridColumnHeaderClicked", "OnGridColumnHeaderDoubleClicked",
+            "OnGridMultiHeaderClicked", "OnGridMultiHeaderDoubleClicked",
+            "OnGridCheckBoxClicked", "OnGridMultiHeaderCheckBoxClicked",
+            "OnCellLoaded", "OnGridMultiHeaderCellLoaded",
+            "OnCurrentCellChanged", "OnCurrentRowChanged",
+            "OnValidate", "OnGridContextMenuOpening",
+            "OnGridExportStart", "OnGridComboBoxChanged", "OnMouseMove",
+            "OnDataBindEnd", "OnStartClipBoardPaste", "OnEndClipBoardPaste",
+            "OnGridFilterChanged", "OnCreateNewRow", "OnClick",
+            "OnCellKeyDown", "OnSelectedCellsDeleted",
+        ],
+        // iGrid (MX-GRID)
+        "iGrid": ["OnDataBindEnd", "OnCellDoubleClick", "OnSelectionChange"],
+        // OlapGrid
+        "OlapGrid": [
+            "OnExportStart", "OnDataCellDoubleClick", "OnSelectionChanged",
+            "OnHeaderClicked", "OnHeaderDoubleClicked",
+            "OnMultiHeaderClicked", "OnMultiHeaderDoubleClicked",
+            "OnDataBindEnd",
+        ],
+        // Chart
+        "Chart": ["OnDataBindEnd", "OnDataPointClick"],
+        "PieChart": ["OnDataBindEnd", "OnDataPointClick"],
+        "ScatterChart": ["OnDataBindEnd", "OnDataPointClick"],
+        "PolygonChart": ["OnDataBindEnd", "OnDataPointClick"],
+        // Container
+        "Tab": ["OnActiveTabChanged"],
+        "TableLayout": ["OnRowLineDragStart", "OnRowLineDragEnd", "OnColumnLineDragStart", "OnColumnLineDragEnd", "OnRowLineMouseOver", "OnColumnLineMouseOver"],
+        "ReportContainer": ["OnLoaded"],
+        // Slider / ColorSelector
+        "Slider": ["OnStart", "OnFinish", "OnChange"],
+        "ColorSelector": ["OnValueChange"],
+    };
+    /** Get default WorkFlowEvents for a control type */
+    static getControlWorkFlowEvents(controlType) {
+        return MtsdBuilder.CONTROL_WORKFLOW_EVENTS[controlType] || [];
+    }
+    /** Initialize WorkFlow model */
+    setWorkFlow(useEvent = true) {
+        this._workFlow = {
+            Version: 2,
+            UseEvent: useEvent,
+            Nodes: [],
+            Links: [],
+        };
+        return this;
+    }
+    /** Add Report node (ID="_ROOT_", 7 standard events) */
+    addWorkFlowReportNode(opts = {}) {
+        this._ensureWorkFlow();
+        this._workFlow.Nodes.push({
+            ID: "_ROOT_",
+            Type: "Report",
+            ModuleCode: "",
+            Name: "Report",
+            Description: "",
+            Left: opts.left ?? 10,
+            Top: opts.top ?? 10,
+            Width: opts.width ?? 200,
+            Height: opts.height ?? 207,
+            ControlType: "Report",
+            Collapsed: opts.collapsed ?? true,
+            Parameters: [
+                { ID: "OnDocumentLoadComplete", Name: "OnDocumentLoadComplete", Value: null, Description: "" },
+                { ID: "OnLoadComplete", Name: "OnLoadComplete", Value: null, Description: "" },
+                { ID: "OnExecuteStart", Name: "OnExecuteStart", Value: null, Description: "" },
+                { ID: "OnRefreshComplete", Name: "OnRefreshComplete", Value: null, Description: "" },
+                { ID: "OnActiveSheetChange", Name: "OnActiveSheetChange", Value: null, Description: "" },
+                { ID: "OnDestroy", Name: "OnDestroy", Value: null, Description: "" },
+                { ID: "OnViewerSizeChanged", Name: "OnViewerSizeChanged", Value: null, Description: "" },
+            ],
+        });
+        return this;
+    }
+    /** Add Control node. events 생략 시 controlType에 맞는 기본 이벤트 자동 사용 */
+    addWorkFlowControlNode(name, controlType, events, opts = {}) {
+        this._ensureWorkFlow();
+        const resolvedEvents = (events && events.length > 0)
+            ? events
+            : MtsdBuilder.getControlWorkFlowEvents(controlType);
+        this._workFlow.Nodes.push({
+            ID: name,
+            Type: "Control",
+            ModuleCode: "",
+            Name: name,
+            Description: "",
+            Left: opts.left ?? 300,
+            Top: opts.top ?? 10,
+            Width: opts.width ?? 200,
+            Height: opts.height ?? 80,
+            ControlType: controlType,
+            Collapsed: false,
+            Parameters: resolvedEvents.map(evt => ({
+                ID: evt, Name: evt, Value: null, Description: "",
+            })),
+        });
+        return this;
+    }
+    /**
+     * Add Module node.
+     *
+     * - name: get_module_list의 MODULE_SUBJECT 값 사용
+     * - opts.description: get_module_list의 MODULE_DESCRIPTION 값 사용
+     * - opts.eventYn: get_module_list의 EVENT_YN 값.
+     *   "N"이면 Report 노드의 OnDocumentLoadComplete에 자동 링크 생성 (문서 로드 시 무조건 실행).
+     *   "Y"이면 컨트롤/보고서 이벤트에 자유롭게 연결 가능 (addWorkFlowLink로 적절한 이벤트에 연결 필요).
+     */
+    addWorkFlowModuleNode(id, name, moduleCode, params = [], opts = {}) {
+        this._ensureWorkFlow();
+        this._workFlow.Nodes.push({
+            ID: id,
+            Type: "Module",
+            ModuleCode: moduleCode,
+            Name: name,
+            Description: opts.description ?? "",
+            Left: opts.left ?? 500,
+            Top: opts.top ?? 10,
+            Width: opts.width ?? 200,
+            Height: opts.height ?? 80,
+            ControlType: "",
+            Collapsed: false,
+            ...(opts.isEventActive !== undefined ? { IsEventActive: opts.isEventActive } : {}),
+            Parameters: params.map((p, idx) => ({
+                ID: p.id,
+                Name: p.name,
+                Value: p.value,
+                Description: "",
+                MODULE_CODE: p.moduleCode ?? moduleCode,
+                DEFAULT_VALUE: p.defaultValue ?? "",
+                NULLABLE: p.nullable ?? "N",
+                PARAM_DESCRIPTION: p.paramDescription ?? "",
+                PARAM_SEQ: p.paramSeq ?? String(idx + 1),
+                PARAM_TYPE: p.paramType ?? "INP001",
+                ATTR1: p.attr1 ?? "",
+                ATTR2: p.attr2 ?? "",
+                ATTR3: p.attr3 ?? "",
+            })),
+        });
+        // EVENT_YN="N"인 모듈은 Report 노드의 OnDocumentLoadComplete에 자동 링크
+        if (opts.eventYn === "N") {
+            this.addWorkFlowLink("_ROOT_", id, { fromParam: "OnDocumentLoadComplete" });
+        }
+        return this;
+    }
+    /**
+     * Add Switch node (조건 분기).
+     *
+     * cases 배열의 각 항목:
+     * - operand: 비교 대상 변수명 (예: "VS_CODE", "VS_STATUS"). `:` 접두사 불필요.
+     *   → 실행 시 GlobalParam → Variables → Control 값 순으로 검색.
+     * - operator: 비교 연산자 (=, ==, <>, !=, >, >=, <, <=, IS NULL, IS NOT NULL,
+     *   START WITH, END WITH, CONTAIN, NOT CONTAIN)
+     * - value: 비교 값 (IS NULL/IS NOT NULL일 때는 빈 문자열)
+     * - id (선택): 케이스 ID. 생략 시 자동 생성 (CD + UUID).
+     * - name (선택): 케이스 표시명. 생략 시 "operand operator value" 형태로 자동 생성.
+     * - default: true이면 DEFAULT 케이스 (조건 없이 항상 매치). 반드시 마지막에 배치.
+     */
+    addWorkFlowSwitchNode(id, name, cases = [], opts = {}) {
+        this._ensureWorkFlow();
+        const parameters = cases.map(c => {
+            if (c.default) {
+                return {
+                    ID: "DEFAULT",
+                    Name: "Default",
+                    Value: "DEFAULT",
+                    Description: c.description ?? "",
+                };
+            }
+            const operand = c.operand ?? "";
+            const operator = c.operator ?? "=";
+            const val = c.value ?? "";
+            const autoName = operator === "IS NULL" || operator === "IS NOT NULL"
+                ? `${operand} ${operator} `
+                : `${operand} ${operator} ${val}`;
+            return {
+                ID: c.id || generateId("CD"),
+                Name: c.name || autoName,
+                Value: { Operand: operand, Operator: operator, Value: val },
+                Description: c.description ?? "",
+            };
+        });
+        this._workFlow.Nodes.push({
+            ID: id,
+            Type: "Switch",
+            ModuleCode: "",
+            Name: name,
+            Description: "",
+            Left: opts.left ?? 700,
+            Top: opts.top ?? 10,
+            Width: opts.width ?? 200,
+            Height: opts.height ?? 100,
+            ControlType: "",
+            Collapsed: false,
+            IsEventActive: true,
+            Deprecated: false,
+            Parameters: parameters,
+        });
+        return this;
+    }
+    /**
+     * Add WorkFlow link between nodes.
+     *
+     * 링크 유형별 사용법:
+     * - **Report/Control → 노드**: `fromParam`에 이벤트명 지정 (예: "OnClick", "OnDocumentLoadComplete")
+     * - **Switch → 노드**: `fromParam`에 케이스 ID 지정 (예: "CD..." 또는 "DEFAULT")
+     * - **Module → Module (성공)**: `fromParam` 생략, `type: 0` (기본값)
+     * - **Module → Module (실패)**: `fromParam` 생략, `type: 1`
+     *
+     * ID 자동 생성:
+     * - fromParam 있으면: `{from}.{fromParam}~{to}`
+     * - fromParam 없으면: `{from}~{to}`
+     */
+    addWorkFlowLink(from, to, opts = {}) {
+        this._ensureWorkFlow();
+        const fromParam = opts.fromParam ?? "";
+        const linkId = fromParam ? `${from}.${fromParam}~${to}` : `${from}~${to}`;
+        this._workFlow.Links.push({
+            ID: linkId,
+            From: from,
+            To: to,
+            Type: opts.type ?? 0,
+            FromParam: fromParam,
+        });
+        return this;
+    }
+    _ensureWorkFlow() {
+        if (!this._workFlow) {
+            this._workFlow = { Version: 2, UseEvent: true, Nodes: [], Links: [] };
+        }
+    }
     /** Get the report code */
     getReportCode() {
         return this._reportCode;
@@ -955,6 +1250,7 @@ export class MtsdBuilder extends ElementContainer {
             Langs: [],
             WorkFlowModules: [],
             WorkFlowInfo: "",
+            ...(this._workFlow ? { WORK_FLOW: this._workFlow } : {}),
         };
     }
     /** Alias for build() */

package/dist/index.js

@@ -15,7 +15,7 @@ import { getControlInfo } from "./generators/control-info.js";
 import { generateOlapFields } from "./generators/olap-field.js";
 import { executeMtsdScript } from "./generators/mtsd-builder.js";
 import { generateId } from "./utils/uuid.js";
-import { callSchemaService, callDbmsList, callBoxStyleService, callBoxStyleSaveService, callSaveReportService, callReadReportService, downloadReportResources, getAudConfig, isAudConfigured, setWorkspaceRoots } from "./utils/aud-api-client.js";
+import { callSchemaService, callDbmsList, callBoxStyleService, callBoxStyleSaveService, callSaveReportService, callReadReportService, downloadReportResources, getAudConfig, isAudConfigured, setWorkspaceRoots, callModuleService } from "./utils/aud-api-client.js";
 import { buildSaveModel, writeReportResponse, writePullResponse } from "./utils/report-publisher.js";
 import { execSync, execFile } from "child_process";
 const __filename = fileURLToPath(import.meta.url);
@@ -668,7 +668,7 @@ const tools = [
     // ── i-AUD Database Query Tools ──────────────────────
     {
         name: "execute_query",
-        description: "i-AUD 서버를 통해 SQL 쿼리를 실행하고 결과를 반환합니다. SELECT 문 실행에 사용하며, 연결 코드(connectionCode)로 대상 데이터베이스를 지정합니다.",
+        description: "i-AUD 서버를 통해 SQL 쿼리를 실행하고 결과를 반환합니다. SELECT 문 실행에 사용하며, 연결 코드(connectionCode)로 대상 데이터베이스를 지정합니다. SQL에 바인딩 변수(:VS_XXX, :VN_XXX)가 있으면 params에 값을 전달하세요.",
         inputSchema: {
             type: "object",
             properties: {
@@ -685,6 +685,11 @@ const tools = [
                     description: "최대 반환 행 수 (기본값: 100, 최대: 1000)",
                     default: 100,
                 },
+                params: {
+                    type: "object",
+                    description: "SQL 바인딩 변수 값. SQL 내 :VS_CODE, :VN_COUNT 등의 바인딩 변수에 대응하는 값을 전달합니다. 예: { \"VS_CODE\": \"A001\", \"VN_COUNT\": \"10\" }",
+                    additionalProperties: { type: "string" },
+                },
             },
             required: ["connectionCode", "sql"],
         },
@@ -890,6 +895,40 @@ const tools = [
             required: ["script"],
         },
     },
+    // ── Module List Tool ──────────────
+    {
+        name: "get_module_list",
+        description: "i-AUD 서버에서 WorkFlow 모듈 목록을 조회합니다. ProcessBot(WorkFlow)에서 사용할 모듈의 MODULE_CODE를 확인할 때 사용합니다.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filter: {
+                    type: "string",
+                    description: "검색어 (모듈명, 설명에서 대소문자 무시 검색)",
+                },
+                limitRows: {
+                    type: "number",
+                    description: "최대 반환 행 수 (기본값: 500)",
+                    default: 500,
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "get_module_params",
+        description: "i-AUD 서버에서 특정 모듈의 파라미터 목록을 조회합니다. get_module_list에서 조회한 MODULE_CODE를 사용합니다.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                moduleCode: {
+                    type: "string",
+                    description: "모듈 코드 (get_module_list로 조회)",
+                },
+            },
+            required: ["moduleCode"],
+        },
+    },
 ];
 // Create MCP server
 const server = new Server({
@@ -1674,6 +1713,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const connectionCode = args?.connectionCode;
                 const sql = args?.sql;
                 const limitRows = Math.min(Number(args?.limitRows) || 100, 1000);
+                const bindParams = args?.params;
                 if (!connectionCode || !sql) {
                     return {
                         content: [{
@@ -1682,11 +1722,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             }],
                     };
                 }
-                const result = await callSchemaService("SQL_EXECUTE", [
+                const serviceParams = [
                     { Key: "VS_CONN", Value: [connectionCode] },
                     { Key: "#QUERY#", Value: [sql] },
                     { Key: "VN_LIMIT_ROWS", Value: [String(limitRows)] },
-                ]);
+                ];
+                // 바인딩 변수 값 추가
+                if (bindParams) {
+                    for (const [key, value] of Object.entries(bindParams)) {
+                        serviceParams.push({ Key: key, Value: [String(value)] });
+                    }
+                }
+                const result = await callSchemaService("SQL_EXECUTE", serviceParams);
                 if (result.CODE !== 0) {
                     return {
                         content: [{
@@ -2272,6 +2319,102 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     ],
                 };
             }
+            case "get_module_list": {
+                if (!isAudConfigured()) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "i-AUD 서버 접속 정보가 설정되지 않았습니다. 환경변수 AUD_SERVICE_URL, AUD_API_KEY, AUD_USER_NAME을 설정해 주세요.",
+                                }),
+                            }],
+                    };
+                }
+                const filter = args?.filter || "";
+                const limitRows = Number(args?.limitRows) || 500;
+                const params = [
+                    { Key: "VN_LIMIT_ROWS", Value: [String(limitRows)] },
+                ];
+                if (filter) {
+                    params.push({ Key: "VS_FILTER_TEXT", Value: [filter] });
+                }
+                const result = await callModuleService("MODULE_LIST", params);
+                if (result.CODE !== 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({ error: result.MSG, code: result.CODE }),
+                            }],
+                    };
+                }
+                const modules = result.ROWS.map((row) => {
+                    const obj = {};
+                    for (let i = 0; i < result.COLUMNS.length; i++) {
+                        obj[result.COLUMNS[i].Name] = row[i];
+                    }
+                    return obj;
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                count: modules.length,
+                                modules,
+                            }, null, 2),
+                        }],
+                };
+            }
+            case "get_module_params": {
+                if (!isAudConfigured()) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({
+                                    error: "i-AUD 서버 접속 정보가 설정되지 않았습니다. 환경변수 AUD_SERVICE_URL, AUD_API_KEY, AUD_USER_NAME을 설정해 주세요.",
+                                }),
+                            }],
+                    };
+                }
+                const moduleCode = args?.moduleCode;
+                if (!moduleCode) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({ error: "moduleCode 파라미터가 필요합니다." }),
+                            }],
+                    };
+                }
+                const result = await callModuleService("MODULE_PARAM", [
+                    { Key: "VS_MODULE_CODE", Value: [moduleCode] },
+                ]);
+                if (result.CODE !== 0) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: JSON.stringify({ error: result.MSG, code: result.CODE }),
+                            }],
+                    };
+                }
+                const params = result.ROWS.map((row) => {
+                    const obj = {};
+                    for (let i = 0; i < result.COLUMNS.length; i++) {
+                        obj[result.COLUMNS[i].Name] = row[i];
+                    }
+                    return obj;
+                });
+                return {
+                    content: [{
+                            type: "text",
+                            text: JSON.stringify({
+                                success: true,
+                                moduleCode,
+                                paramCount: params.length,
+                                params,
+                            }, null, 2),
+                        }],
+                };
+            }
             default:
                 return {
                     content: [

package/dist/resources/encrypted-commands.d.ts

@@ -8,3 +8,4 @@ export declare const BOXSTYLE_SAVE_COMMAND = "wi5lPLVCtMfgAqg1MAW8gaknSOJnlmhA33
 export declare const DBMS_LIST_COMMAND = "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";
 export declare const SAVE_REPORT_COMMAND = "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";
 export declare const READ_REPORT_COMMAND = "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";
+export declare const MODULE_SERVICE_COMMAND = "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";

package/dist/resources/encrypted-commands.js

@@ -12,3 +12,5 @@ export const DBMS_LIST_COMMAND = "SnGZTXoWgLwnWaQFwynZkMloOIQcnzfw03AihKOUcMghlu
 //SAVE REPORT
 export const SAVE_REPORT_COMMAND = "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";
 export const READ_REPORT_COMMAND = "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";
+// TODO: @MODULE_SERVICE 암호화 커맨드 — 서버 배포 후 실제 값으로 교체 필요
+export const MODULE_SERVICE_COMMAND = "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";

package/dist/utils/aud-api-client.d.ts

@@ -43,6 +43,16 @@ export declare function callSchemaService(schemaType: string, params: {
     Key: string;
     Value: any[];
 }[]): Promise<SchemaServiceResult>;
+/**
+ * i-AUD 서버의 @MODULE_SERVICE 서버 스크립트를 호출합니다.
+ * 모듈 목록(MODULE_LIST) 및 모듈 파라미터(MODULE_PARAM)를 조회합니다.
+ * @param schemaType MODULE_LIST | MODULE_PARAM
+ * @param params 추가 파라미터
+ */
+export declare function callModuleService(schemaType: string, params: {
+    Key: string;
+    Value: any[];
+}[]): Promise<SchemaServiceResult>;
 /**
  * i-AUD 서버의 @DBMS_LIST 서버 스크립트를 호출하여
  * 현재 사용자에게 권한이 있는 DB 연결 목록을 가져옵니다.

package/dist/utils/aud-api-client.js

@@ -10,7 +10,7 @@
 import { readFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
 import { join, dirname, resolve, basename } from "path";
 import { fileURLToPath } from "url";
-import { SCHEMA_SERVICE_COMMAND, DBMS_LIST_COMMAND, BOXSTYLE_LIST_COMMAND, BOXSTYLE_SAVE_COMMAND, SAVE_REPORT_COMMAND, READ_REPORT_COMMAND } from "../resources/encrypted-commands.js";
+import { SCHEMA_SERVICE_COMMAND, DBMS_LIST_COMMAND, BOXSTYLE_LIST_COMMAND, BOXSTYLE_SAVE_COMMAND, SAVE_REPORT_COMMAND, READ_REPORT_COMMAND, MODULE_SERVICE_COMMAND } from "../resources/encrypted-commands.js";
 // 캐시: 한 번 읽으면 재사용
 let _cachedConfig = null;
 // MCP 클라이언트에서 전달받은 워크스페이스 루트 경로들
@@ -263,6 +263,52 @@ export async function callSchemaService(schemaType, params) {
     }
     return data;
 }
+/**
+ * i-AUD 서버의 @MODULE_SERVICE 서버 스크립트를 호출합니다.
+ * 모듈 목록(MODULE_LIST) 및 모듈 파라미터(MODULE_PARAM)를 조회합니다.
+ * @param schemaType MODULE_LIST | MODULE_PARAM
+ * @param params 추가 파라미터
+ */
+export async function callModuleService(schemaType, params) {
+    const config = getAudConfig();
+    if (!config.serviceUrl || !config.apiKey) {
+        throw new Error("i-AUD 서버 접속 정보를 찾을 수 없습니다.\n"
+            + "다음 중 하나를 설정해 주세요:\n"
+            + "  1) .vscode/settings.json의 aud.config (ServiceURL, ApiKey, UserName)\n"
+            + "  2) 환경변수: AUD_SERVICE_URL, AUD_API_KEY, AUD_USER_NAME");
+    }
+    const allParams = [
+        { Key: "#SCHEMA_TYPE#", Value: [schemaType] },
+        ...params,
+    ];
+    const url = config.serviceUrl
+        + (config.serviceUrl.endsWith("/") ? "servlet/DataSet.maf" : "/servlet/DataSet.maf");
+    const packetStr = buildPacket(config, "@AUD_SAVE_SERVICE@MODULE_SERVICE", MODULE_SERVICE_COMMAND, allParams);
+    // multipart/form-data 형식으로 전송 (VS Code Extension과 동일)
+    const formBody = new URLSearchParams();
+    formBody.append("ENC", "false");
+    formBody.append("OUT", "1");
+    formBody.append("hashcode", "aud.mcp." + config.userName);
+    formBody.append("ver", "400");
+    formBody.append("PACKET", packetStr);
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/x-www-form-urlencoded",
+            "Authorization": "Bearer " + config.apiKey,
+        },
+        body: formBody.toString(),
+    });
+    if (!response.ok) {
+        throw new Error(`i-AUD 서버 요청 실패: HTTP ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    // 서버 레벨 오류 체크
+    if (data.retCode && data.retMsg) {
+        throw new Error(`i-AUD 서버 오류: [${data.retCode}] ${data.retMsg}`);
+    }
+    return data;
+}
 /**
  * i-AUD 서버의 @DBMS_LIST 서버 스크립트를 호출하여
  * 현재 사용자에게 권한이 있는 DB 연결 목록을 가져옵니다.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bimatrix-aud-platform/aud_mcp_server",
-  "version": "1.1.48",
+  "version": "1.1.50",
   "description": "MCP Server for i-AUD MTSD document validation, generation, schema querying, control info extraction, and database operations",
   "type": "module",
   "main": "dist/index.js",

package/schemas/mtsd.interface.ts

@@ -2222,7 +2222,7 @@ export interface IVariable {
 export interface IModule {
   /** 모듈 표시 이름 */
   Name: string;
-  /** 모듈 키 (고유 식별자) */
+  /** 모듈 키 (WorkFlow내 고유 식별자/동일한 MODULE_CODE가 여러개 배치될 수 잇음.) */
   MODULE_KEY: string;
   /** 모듈 코드 */
   MODULE_CODE: string;

package/schemas/mtsd.schema.json

@@ -54,6 +54,10 @@
       "type": "string",
       "description": "워크플로우 JSON 데이터 (CS Processbot)"
     },
+    "WORK_FLOW": {
+      "$ref": "#/$defs/WorkFlowModel",
+      "description": "신규 버전 프로세스 봇(WorkFlow) 모델 — Nodes(노드)와 Links(연결)로 구성"
+    },
     "UsePersonalConditions": {
       "type": "boolean",
       "description": "조건 개인화 기능 사용 여부"
@@ -2006,6 +2010,86 @@
         "Id": { "type": "string" },
         "Name": { "type": "string" }
       }
+    },
+    "WorkFlowModel": {
+      "type": "object",
+      "description": "신규 버전 프로세스 봇(WorkFlow) 모델. Nodes와 Links로 구성된 실행 흐름 정의",
+      "required": ["Version", "UseEvent", "Nodes", "Links"],
+      "properties": {
+        "Version": { "type": "integer", "description": "문서 버전 (현재 2)" },
+        "UseEvent": { "type": "boolean", "description": "이벤트 사용 여부 (false이면 초기화 시 모든 모듈 순차 실행)" },
+        "Nodes": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/WorkFlowNode" },
+          "description": "워크플로우 노드(Activity) 배열"
+        },
+        "Links": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/WorkFlowLink" },
+          "description": "노드 간 연결(실행 흐름) 배열"
+        }
+      }
+    },
+    "WorkFlowNode": {
+      "type": "object",
+      "description": "워크플로우 노드 — Report, Control, Module, Switch 중 하나",
+      "required": ["ID", "Type", "Name", "Left", "Top", "Width", "Height", "Parameters"],
+      "properties": {
+        "ID": { "type": "string", "description": "노드 ID (Control: 컨트롤명, Report: '_ROOT_', Module: 식별자)" },
+        "Type": {
+          "type": "string",
+          "enum": ["Control", "Report", "Module", "Switch"],
+          "description": "노드 유형"
+        },
+        "ModuleCode": { "type": "string", "description": "모듈 코드 (Module 타입일 때 사용)" },
+        "Name": { "type": "string", "description": "노드 이름" },
+        "Description": { "type": "string", "description": "노드 설명" },
+        "Left": { "type": "number", "description": "다이어그램 X 좌표" },
+        "Top": { "type": "number", "description": "다이어그램 Y 좌표" },
+        "Width": { "type": "number", "description": "노드 너비" },
+        "Height": { "type": "number", "description": "노드 높이" },
+        "ControlType": { "type": "string", "description": "Control/Report 타입의 구체적 컨트롤 종류 (DataGrid, Button 등)" },
+        "Collapsed": { "type": "boolean", "description": "다이어그램에서 노드 접힘 여부" },
+        "IsEventActive": { "type": "boolean", "description": "이벤트 활성화 여부" },
+        "Deprecated": { "type": "boolean", "description": "삭제(사용중지) 여부" },
+        "Parameters": {
+          "type": "array",
+          "items": { "$ref": "#/$defs/WorkFlowNodeParam" },
+          "description": "파라미터 목록 (Control/Report: 이벤트, Module: 파라미터, Switch: case 값)"
+        }
+      }
+    },
+    "WorkFlowNodeParam": {
+      "type": "object",
+      "description": "워크플로우 노드 파라미터 — 이벤트, 모듈 파라미터, 또는 Switch case",
+      "required": ["Name", "Value"],
+      "properties": {
+        "ID": { "type": "string", "description": "파라미터 ID (이벤트명 또는 파라미터 식별자)" },
+        "Name": { "type": "string", "description": "파라미터 이름" },
+        "Value": { "description": "파라미터 값 (Module: 설정값, Switch: {Operand,Operator,Value} 객체, Control: 이벤트 연결 정보)" },
+        "Description": { "type": "string", "description": "파라미터 설명" },
+        "MODULE_CODE": { "type": "string", "description": "소속 모듈 코드" },
+        "DEFAULT_VALUE": { "type": "string", "description": "기본값" },
+        "NULLABLE": { "type": "string", "enum": ["Y", "N"], "description": "필수 여부" },
+        "PARAM_DESCRIPTION": { "type": "string", "description": "파라미터 설명 (사용자 표시용)" },
+        "PARAM_SEQ": { "type": "string", "description": "파라미터 순서" },
+        "PARAM_TYPE": { "type": "string", "description": "파라미터 타입 (INP001~INP999)" },
+        "ATTR1": { "type": "string", "description": "속성1 (INP999: 선택 옵션 목록)" },
+        "ATTR2": { "type": "string", "description": "속성2" },
+        "ATTR3": { "type": "string", "description": "속성3" }
+      }
+    },
+    "WorkFlowLink": {
+      "type": "object",
+      "description": "워크플로우 링크 — 노드 간 연결(실행 흐름)",
+      "required": ["ID", "From", "To", "Type"],
+      "properties": {
+        "ID": { "type": "string", "description": "링크 ID (From노드.이벤트~To노드 형태)" },
+        "From": { "type": "string", "description": "출발 노드 ID" },
+        "To": { "type": "string", "description": "도착 노드 ID" },
+        "Type": { "type": "integer", "enum": [0, 1], "description": "0: Success (성공 시 실행), 1: Fail (실패 시 실행)" },
+        "FromParam": { "type": "string", "description": "출발 파라미터 (이벤트명 또는 Switch 케이스 ID)" }
+      }
     }
   }
 }