@wowok/agent-mcp 2.6.0 → 2.6.1

package/dist/schema-query/index.js

@@ -1,9 +1,15 @@
-import { readFileSync, existsSync } from "fs";
-import { resolve, join } from "path";
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs";
+import { resolve, join, dirname } from "path";
 import { fileURLToPath } from "url";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = fileURLToPath(new URL(".", import.meta.url));
 const SCHEMAS_DIR = resolve(__dirname, "../../dist/schemas");
+const GUARD_TEMPLATES_PATH_SCRIPTS = resolve(__dirname, "../../scripts/guard-templates.json");
+const GUARD_TEMPLATES_PATH_DIST = resolve(__dirname, "../../dist/schemas/guard-templates.json");
+const GUARD_TEMPLATES_PATH = existsSync(GUARD_TEMPLATES_PATH_SCRIPTS)
+    ? GUARD_TEMPLATES_PATH_SCRIPTS
+    : GUARD_TEMPLATES_PATH_DIST;
+const WORKSPACE_TMP_DIR = resolve(process.cwd(), ".trae", "tmp");
 export function areSchemasAvailable() {
     return existsSync(SCHEMAS_DIR) && existsSync(join(SCHEMAS_DIR, "index.json"));
 }
@@ -59,6 +65,78 @@ export function getOutputSchema(name) {
         return null;
     }
 }
+export function getGuardTemplates(templateName) {
+    try {
+        if (!existsSync(GUARD_TEMPLATES_PATH)) {
+            return null;
+        }
+        const content = readFileSync(GUARD_TEMPLATES_PATH, "utf-8");
+        const catalog = JSON.parse(content);
+        if (!templateName) {
+            return {
+                version: catalog.version,
+                description: catalog.description,
+                templates: (catalog.templates || []).map((t) => ({
+                    name: t.name,
+                    title: t.title,
+                    description: t.description,
+                    use_case: t.use_case,
+                })),
+                query_reference: catalog.query_reference,
+                node_return_types: catalog.node_return_types,
+            };
+        }
+        const template = (catalog.templates || []).find((t) => t.name === templateName);
+        if (!template) {
+            return null;
+        }
+        return template;
+    }
+    catch {
+        return null;
+    }
+}
+export function getSchemaField(name, fieldPath) {
+    const schema = getSchema(name);
+    if (!schema)
+        return null;
+    const parts = fieldPath.split(".").filter(Boolean);
+    let current = schema;
+    for (const part of parts) {
+        if (!current || typeof current !== "object")
+            return null;
+        if (current.properties && part in current.properties) {
+            current = current.properties[part];
+            continue;
+        }
+        if (current.items && typeof current.items === "object") {
+            if (/^\d+$/.test(part)) {
+                current = current.items;
+                continue;
+            }
+            if (current.items.properties && part in current.items.properties) {
+                current = current.items.properties[part];
+                continue;
+            }
+        }
+        if (Array.isArray(current.oneOf) || Array.isArray(current.anyOf)) {
+            const variants = current.oneOf ?? current.anyOf;
+            for (const v of variants) {
+                if (v && typeof v === "object" && v.properties && part in v.properties) {
+                    current = v.properties[part];
+                    break;
+                }
+            }
+            continue;
+        }
+        if (part in current) {
+            current = current[part];
+            continue;
+        }
+        return null;
+    }
+    return current;
+}
 function resolveSchemaRefs(schema, visited = new Set()) {
     if (!schema || typeof schema !== "object") {
         return schema;
@@ -124,8 +202,71 @@ export function listOperations() {
         return [];
     return (index.operations || []).filter(op => op.name.startsWith("onchain_operations_"));
 }
+function writeResponseToFile(data, preferredPath) {
+    try {
+        let targetPath;
+        if (preferredPath) {
+            targetPath = resolve(process.cwd(), preferredPath);
+        }
+        else {
+            if (!existsSync(WORKSPACE_TMP_DIR)) {
+                mkdirSync(WORKSPACE_TMP_DIR, { recursive: true });
+            }
+            const timestamp = Date.now();
+            targetPath = join(WORKSPACE_TMP_DIR, `schema-${timestamp}.json`);
+        }
+        const parentDir = dirname(targetPath);
+        if (!existsSync(parentDir)) {
+            mkdirSync(parentDir, { recursive: true });
+        }
+        const jsonStr = typeof data === "string" ? data : JSON.stringify(data, null, 2);
+        writeFileSync(targetPath, jsonStr, "utf-8");
+        return targetPath;
+    }
+    catch (e) {
+        return null;
+    }
+}
 export function processSchemaQuery(request) {
-    const { action, name, query } = request;
+    const { action, name, query, field_path, template, output_file } = request;
+    if (action === "get_guard_templates") {
+        const templates = getGuardTemplates(template);
+        if (!templates) {
+            return {
+                success: false,
+                action,
+                data: null,
+                message: template
+                    ? `Guard template '${template}' not found. Omit 'template' to list all available templates.`
+                    : "Guard templates file not found. Ensure scripts/guard-templates.json exists.",
+                suggestions: [
+                    "Omit 'template' to list all available templates.",
+                    "Available template names: signer_verification, progress_node_check, order_owner_verification, service_belonging_check, reward_not_claimed, combined_reward_guard",
+                ],
+            };
+        }
+        if (output_file) {
+            const filePath = writeResponseToFile(templates, output_file);
+            if (filePath) {
+                return {
+                    success: true,
+                    action,
+                    data: null,
+                    message: `Guard template${template ? ` '${template}'` : "s"} written to file: ${filePath}`,
+                    output_file_path: filePath,
+                    suggestions: [`Use Read tool to open ${filePath}`],
+                };
+            }
+        }
+        return {
+            success: true,
+            action,
+            data: templates,
+            message: template
+                ? `Retrieved Guard template: ${template}`
+                : `Retrieved ${Array.isArray(templates.templates) ? templates.templates.length : 0} Guard templates`,
+        };
+    }
     if (!areSchemasAvailable()) {
         return {
             success: false,
@@ -168,6 +309,19 @@ export function processSchemaQuery(request) {
                         : ["Use 'list' action to see available schemas"],
                 };
             }
+            if (output_file) {
+                const filePath = writeResponseToFile(schema, output_file);
+                if (filePath) {
+                    return {
+                        success: true,
+                        action,
+                        data: null,
+                        message: `Schema '${name}' written to file: ${filePath}`,
+                        output_file_path: filePath,
+                        suggestions: [`Use Read tool to open ${filePath}`],
+                    };
+                }
+            }
             return {
                 success: true,
                 action,
@@ -175,6 +329,39 @@ export function processSchemaQuery(request) {
                 message: `Retrieved schema: ${name}`,
             };
         }
+        case "get_field": {
+            if (!name || !field_path) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: "Both 'name' and 'field_path' are required for 'get_field' action",
+                    suggestions: [
+                        "Example: {action: 'get_field', name: 'onchain_operations_machine', field_path: 'data.node'}",
+                        "Use 'get' action to retrieve the full schema",
+                    ],
+                };
+            }
+            const fieldSchema = getSchemaField(name, field_path);
+            if (!fieldSchema) {
+                return {
+                    success: false,
+                    action,
+                    data: null,
+                    message: `Field path '${field_path}' not found in schema '${name}'`,
+                    suggestions: [
+                        "Check the field path (dot-separated, e.g. 'data.node')",
+                        "Use 'get' action to see the full schema structure",
+                    ],
+                };
+            }
+            return {
+                success: true,
+                action,
+                data: fieldSchema,
+                message: `Retrieved field '${field_path}' from schema '${name}'`,
+            };
+        }
         case "search": {
             if (!query) {
                 return {
@@ -235,6 +422,19 @@ export function processSchemaQuery(request) {
                         : ["Use 'list' action to see available tools"],
                 };
             }
+            if (output_file) {
+                const filePath = writeResponseToFile(schema, output_file);
+                if (filePath) {
+                    return {
+                        success: true,
+                        action,
+                        data: null,
+                        message: `Output schema '${name}' written to file: ${filePath}`,
+                        output_file_path: filePath,
+                        suggestions: [`Use Read tool to open ${filePath}`],
+                    };
+                }
+            }
             return {
                 success: true,
                 action,
@@ -248,7 +448,7 @@ export function processSchemaQuery(request) {
                 action,
                 data: null,
                 message: `Unknown action: ${action}`,
-                suggestions: ["Use 'list', 'get', 'search', or 'list_operations'"],
+                suggestions: ["Use 'list', 'get', 'get_field', 'get_output', 'search', 'list_operations', or 'get_guard_templates'"],
             };
     }
 }

package/dist/schemas/account_operation.output.json

@@ -1271,7 +1271,7 @@
                             "testnet",
                             "mainnet"
                           ],
-                          "description": "Network entrypoint: Specifies which network the operation occurs on"
+                          "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
                         }
                       },
                       "required": [
@@ -1359,6 +1359,12 @@
                     "permission_denied",
                     "immutable_violation",
                     "network_error",
+                    "rate_limit",
+                    "gas_exceeded",
+                    "bcs_error",
+                    "signature_error",
+                    "config_error",
+                    "wip_verification_failed",
                     "unknown"
                   ],
                   "description": "Error classification for programmatic recovery"

package/dist/schemas/account_operation.schema.json

@@ -140,7 +140,7 @@
                 "testnet",
                 "mainnet"
               ],
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [
@@ -169,7 +169,7 @@
             },
             "network": {
               "$ref": "#/definitions/account_operation/properties/transfer/properties/network",
-              "description": "Network entrypoint: Specifies which network the operation occurs on"
+              "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
             }
           },
           "required": [

package/dist/schemas/bridge_operation.output.json

@@ -53,6 +53,12 @@
                     "permission_denied",
                     "immutable_violation",
                     "network_error",
+                    "rate_limit",
+                    "gas_exceeded",
+                    "bcs_error",
+                    "signature_error",
+                    "config_error",
+                    "wip_verification_failed",
                     "unknown"
                   ],
                   "description": "Error classification for programmatic recovery"

package/dist/schemas/bridge_operation.schema.json

@@ -81,7 +81,7 @@
                     "testnet",
                     "mainnet"
                   ],
-                  "description": "Network entrypoint: Specifies which network the operation occurs on"
+                  "description": "Network entrypoint: Specifies which network the operation occurs on. FIX-010 cross-network note: LocalMark names are scoped per network (testnet marks are invisible on mainnet and vice versa). When migrating from testnet to mainnet, recreate all objects on mainnet and re-register LocalMark names with the SAME names to keep name-based references working across networks. Use project_operation action='clone_project_to_network' to clone the project blueprint to the target network, then re-run onchain_operations with env.network=target_network to deploy."
                 },
                 "referrer": {
                   "$ref": "#/definitions/bridge_operation/anyOf/0/properties/env/properties/account",