@wowok/agent-mcp 2.5.4 → 2.6.0

package/dist/schemas/query_toolkit.output.json

@@ -572,12 +572,13 @@
             "type": "number",
             "description": "Timestamp when account was last updated"
           },
-          "m": {
-            "type": [
-              "string",
-              "null"
-            ],
-            "description": "Messenger name, indicates this account has messenger enabled"
+          "messenger": {
+            "type": "boolean",
+            "description": "Whether messenger is enabled for this account"
+          },
+          "suspendedName": {
+            "type": "string",
+            "description": "Name before suspension (set by suspend, cleared by resume)"
           }
         },
         "required": [

package/dist/schemas/query_toolkit.schema.json

@@ -99,10 +99,6 @@
                   "type": "boolean",
                   "description": "Filter accounts with messenger enabled"
                 },
-                "m": {
-                  "$ref": "#/definitions/query_toolkit/anyOf/0/properties/filter/properties/name",
-                  "description": "Filter by messenger name (supports fuzzy match)"
-                },
                 "createdAt": {
                   "type": "object",
                   "properties": {

package/dist/telemetry/storage.js

@@ -1,8 +1,8 @@
 import { mkdir, appendFile, stat, rename } from "fs/promises";
 import { dirname, join } from "path";
-import { homedir } from "os";
+import { getWowMcpDir } from "@wowok/wowok";
 const MAX_SIZE_BYTES = 10 * 1024 * 1024;
-const DATA_DIR = join(homedir(), ".wowok", "data");
+const DATA_DIR = join(getWowMcpDir(), "data");
 const TELEMETRY_FILE = join(DATA_DIR, "telemetry.jsonl");
 const ROTATED_FILE = join(DATA_DIR, "telemetry.jsonl.1");
 class JsonlStorage {

package/dist/tools/handlers/onchain.js

@@ -1,6 +1,6 @@
 import { readFileSync } from "fs";
 import { resolve } from "path";
-import { CallService, CallMachine, CallProgress, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
+import { CallService, CallMachine, CallProgress, CallGuard, CallArbitration, CallRepository, CallContact, CallTreasury, CallReward, CallAllocation, CallPersonal, CallPayment, CallDemand, CallOrder, gen_passport, CallProof, gen_proof, ResponseData, LocalProject, parseGuardFile, formatGuardParseErrors, transformRewardInput, transformPersonalInput, } from "@wowok/wowok";
 import { OnchainOperationsSchema, strictParse, getEnvConfig, handleCallResult, checkClientSchemaCompatibility, parseMachineNodesFromText, formatNodeErrors as formatMachineNodeErrors, transformSubmission, } from "../../schema/index.js";
 import { handlePermissionOperations } from "../../schema/call/permission-handler.js";
 import { isProjectServiceEnabled, normalize as projectNormalize, } from "../../project/index.js";
@@ -9,6 +9,41 @@ export async function handleOnchainOperations(args) {
     let validated;
     let constraintWarnings = [];
     let projectWarnings = [];
+    async function autoAddToProject(projectPrefix, operationType, result) {
+        if (!projectPrefix)
+            return;
+        const creationOps = new Set([
+            "service", "machine", "progress", "repository",
+            "arbitration", "contact", "treasury", "reward",
+            "allocation", "permission", "guard", "personal",
+            "demand", "order", "proof",
+        ]);
+        if (!creationOps.has(operationType))
+            return;
+        if (!result || typeof result !== 'object' || 'error' in result)
+            return;
+        if (!result.digest)
+            return;
+        try {
+            const lp = LocalProject.Instance();
+            const project = await lp.getProjectByPrefix(projectPrefix);
+            if (!project) {
+                console.warn(`[autoAddToProject] Project with prefix '${projectPrefix}' not found — object not auto-associated. Create the project first via project_operation action='create_project'.`);
+                return;
+            }
+            const rData = ResponseData(result);
+            const created = rData.filter((r) => r.change === "created" && r.object);
+            for (const obj of created) {
+                await lp.addObject(project.id, {
+                    objectAddress: obj.object,
+                    objectType: obj.type_raw,
+                    role: "reference",
+                });
+            }
+        }
+        catch {
+        }
+    }
     try {
         if (typeof args === 'object' && args !== null
             && 'description' in args && !('operation_type' in args)) {
@@ -59,7 +94,9 @@ export async function handleOnchainOperations(args) {
                     : await callService.call(env);
                 const data = validated.data;
                 const intent = data?.publish ? "publish service" : data?.bPublished !== undefined ? "modify service" : "create service";
-                return handleCallResult(result, withHarness(buildCtx(data), "service", intent));
+                const output = handleCallResult(result, withHarness(buildCtx(data), "service", intent));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "machine": {
                 if (validated.data.node && typeof validated.data.node === 'object' && 'json_or_markdown_file' in validated.data.node) {
@@ -90,42 +127,61 @@ export async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callMachine.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callMachine.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "progress": {
+                if (validated.data?.operate) {
+                    constraintWarnings.push("Progress routing hint: if this Progress is bound to an Order and the target " +
+                        "Forward uses namedOperator=\"\" (empty string = OrderHolder), use " +
+                        "order.progress (NOT progress.operate). Direct progress::next fails with " +
+                        "Permission denied for OrderHolder forwards. Use progress.operate only for " +
+                        "non-empty namedOperator or permissionIndex-only forwards.");
+                }
                 const callProgress = new CallProgress(validated.data);
                 const result = validated.submission
                     ? await callProgress.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProgress.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "repository": {
                 const callRepository = new CallRepository(validated.data);
                 const result = validated.submission
                     ? await callRepository.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callRepository.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "arbitration": {
                 const callArbitration = new CallArbitration(validated.data);
                 const result = validated.submission
                     ? await callArbitration.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callArbitration.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "contact": {
                 const callContact = new CallContact(validated.data);
                 const result = validated.submission
                     ? await callContact.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callContact.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "treasury": {
                 const callTreasury = new CallTreasury(validated.data);
                 const result = validated.submission
                     ? await callTreasury.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callTreasury.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "reward": {
                 const transformedData = transformRewardInput(validated.data);
@@ -133,17 +189,30 @@ export async function handleOnchainOperations(args) {
                 const result = validated.submission
                     ? await callReward.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callReward.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "allocation": {
                 const callAllocation = new CallAllocation(validated.data);
                 const result = validated.submission
                     ? await callAllocation.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callAllocation.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "permission": {
-                return handlePermissionOperations(validated.data, env, buildCtx);
+                const opType = validated.operation_type;
+                const output = handlePermissionOperations(validated.data, env, buildCtx);
+                if (output && typeof output === 'object' && 'then' in output) {
+                    output.then((resolved) => {
+                        if (resolved?.structuredContent?.result) {
+                            autoAddToProject(projectEnvPrefix, opType, resolved.structuredContent.result).catch(() => { });
+                        }
+                    }).catch(() => { });
+                }
+                return output;
             }
             case "guard": {
                 const validatedData = validated.data;
@@ -190,47 +259,69 @@ export async function handleOnchainOperations(args) {
                 }
                 const callGuard = new CallGuard(validatedData);
                 const result = await callGuard.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "personal": {
                 const transformedData = transformPersonalInput(validated.data);
                 const callPersonal = new CallPersonal(transformedData);
                 const result = await callPersonal.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "payment": {
                 const callPayment = new CallPayment(validated.data);
                 const result = await callPayment.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "demand": {
                 const callDemand = new CallDemand(validated.data);
                 const result = validated.submission
                     ? await callDemand.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callDemand.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "order": {
+                if (validated.data?.progress) {
+                    constraintWarnings.push("Order routing hint: order.progress works only for Forwards with " +
+                        "namedOperator=\"\" (OrderHolder). If the target Forward uses a " +
+                        "non-empty namedOperator or permissionIndex-only, use progress.operate " +
+                        "on the Progress object directly instead.");
+                }
                 const callOrder = new CallOrder(validated.data);
                 const result = validated.submission
                     ? await callOrder.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callOrder.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "gen_passport": {
                 const result = await gen_passport(env, validated.guard, validated.info);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "proof": {
                 const callProof = new CallProof(validated.data);
                 const result = validated.submission
                     ? await callProof.call_with_submission(env, await transformSubmission(validated.submission))
                     : await callProof.call(env);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
             case "gen_proof": {
                 const result = await gen_proof(env, validated.proof, validated.server_pubkey, validated.server_signature, validated.proof_type, validated.description, validated.item_count, validated.about_address);
-                return handleCallResult(result, buildCtx(validated.data));
+                const output = handleCallResult(result, buildCtx(validated.data));
+                autoAddToProject(projectEnvPrefix, validated.operation_type, result).catch(() => { });
+                return output;
             }
         }
         const exhaustiveOp = validated;