@wowok/agent-mcp 2.5.4 → 2.5.5

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,54 @@ 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": {
                 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 +182,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 +252,63 @@ 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": {
                 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;