@wowok/agent-mcp 2.7.0 → 2.7.2

package/dist/telemetry/storage.js

@@ -1,80 +1 @@
-import { mkdir, appendFile, stat, rename } from "fs/promises";
-import { dirname, join } from "path";
-import { getWowMcpDir } from "@wowok/wowok";
-const MAX_SIZE_BYTES = 10 * 1024 * 1024;
-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 {
-    filePath;
-    rotatedPath;
-    writeQueue = Promise.resolve();
-    constructor(filePath = TELEMETRY_FILE, rotatedPath = ROTATED_FILE) {
-        this.filePath = filePath;
-        this.rotatedPath = rotatedPath;
-    }
-    async append(event) {
-        this.writeQueue = this.writeQueue.then(async () => {
-            try {
-                await mkdir(dirname(this.filePath), { recursive: true });
-                const line = JSON.stringify(event) + "\n";
-                await appendFile(this.filePath, line, "utf8");
-                await this.maybeRotate();
-            }
-            catch {
-            }
-        });
-        return this.writeQueue;
-    }
-    async query(filter) {
-        try {
-            const { readFile } = await import("fs/promises");
-            const content = await readFile(this.filePath, "utf8");
-            const lines = content.split("\n").filter((l) => l.trim());
-            const events = lines.map((l) => {
-                try {
-                    return JSON.parse(l);
-                }
-                catch {
-                    return null;
-                }
-            }).filter((e) => e !== null);
-            return events.filter((e) => {
-                return Object.entries(filter).every(([k, v]) => e[k] === v);
-            });
-        }
-        catch {
-            return [];
-        }
-    }
-    async rotate() {
-        try {
-            await rename(this.filePath, this.rotatedPath).catch(() => { });
-        }
-        catch {
-        }
-    }
-    async maybeRotate() {
-        try {
-            const stats = await stat(this.filePath);
-            if (stats.size >= MAX_SIZE_BYTES) {
-                await this.rotate();
-            }
-        }
-        catch {
-        }
-    }
-}
-let _storage = null;
-export function getStorage() {
-    if (!_storage) {
-        _storage = new JsonlStorage();
-    }
-    return _storage;
-}
-export function setStorage(storage) {
-    _storage = storage;
-}
-export function getTelemetryFilePath() {
-    return TELEMETRY_FILE;
-}
+import{mkdir,appendFile,stat,rename}from'fs/promises';import{dirname,join}from'path';import{getWowMcpDir}from'@wowok/wowok';const MAX_SIZE_BYTES=0xa*0x400*0x400,DATA_DIR=join(getWowMcpDir(),'data'),TELEMETRY_FILE=join(DATA_DIR,'telemetry.jsonl'),ROTATED_FILE=join(DATA_DIR,'telemetry.jsonl.1');class JsonlStorage{['filePath'];['rotatedPath'];['writeQueue']=Promise['resolve']();constructor(a=TELEMETRY_FILE,b=ROTATED_FILE){this['filePath']=a,this['rotatedPath']=b;}async['append'](a){return this['writeQueue']=this['writeQueue']['then'](async()=>{try{await mkdir(dirname(this['filePath']),{'recursive':!![]});const b=JSON['stringify'](a)+'\x0a';await appendFile(this['filePath'],b,'utf8'),await this['maybeRotate']();}catch{}}),this['writeQueue'];}async['query'](a){try{const {readFile:b}=await import('fs/promises'),c=await b(this['filePath'],'utf8'),d=c['split']('\x0a')['filter'](f=>f['trim']()),e=d['map'](f=>{try{return JSON['parse'](f);}catch{return null;}})['filter'](f=>f!==null);return e['filter'](f=>{return Object['entries'](a)['every'](([g,h])=>f[g]===h);});}catch{return[];}}async['rotate'](){try{await rename(this['filePath'],this['rotatedPath'])['catch'](()=>{});}catch{}}async['maybeRotate'](){try{const a=await stat(this['filePath']);a['size']>=MAX_SIZE_BYTES&&await this['rotate']();}catch{}}}let _storage=null;export function getStorage(){return!_storage&&(_storage=new JsonlStorage()),_storage;}export function setStorage(a){_storage=a;}export function getTelemetryFilePath(){return TELEMETRY_FILE;}

package/dist/tools/handlers/bridge.js

@@ -1 +1 @@
-export { handleBridgeOperations } from "../../schema/call/bridge-handler.js";
+export{handleBridgeOperations}from'../../schema/call/bridge-handler.js';

package/dist/tools/handlers/config.js

@@ -1,74 +1 @@
-import { listServices, getServiceInfo, toggle as toggleService, setEnabled as setServiceEnabled, reset as resetService, } from "../../config/index.js";
-import { strictParse } from "../../schema/index.js";
-import { ConfigOperationInputSchema } from "../../schema/config/index.js";
-export async function handleConfigOperation(args) {
-    const validated = strictParse(ConfigOperationInputSchema, args, "config_operation input");
-    const { action, service: serviceRaw } = validated;
-    let result;
-    switch (action) {
-        case "list":
-            result = { action: "list", services: listServices() };
-            break;
-        case "toggle": {
-            if (!serviceRaw)
-                throw new Error("'service' param is required for toggle");
-            const service = serviceRaw;
-            const existing = getServiceInfo(service);
-            if (!existing) {
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            }
-            const newState = toggleService(service);
-            result = { action: "toggle", service, enabled: newState, reminder: existing.reminder };
-            break;
-        }
-        case "enable": {
-            if (!serviceRaw)
-                throw new Error("'service' param is required for enable");
-            const service = serviceRaw;
-            const existing = getServiceInfo(service);
-            if (!existing)
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            setServiceEnabled(service, true);
-            result = { action: "enable", service, enabled: true, reminder: existing.reminder };
-            break;
-        }
-        case "disable": {
-            if (!serviceRaw)
-                throw new Error("'service' param is required for disable");
-            const service = serviceRaw;
-            const existing = getServiceInfo(service);
-            if (!existing)
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            setServiceEnabled(service, false);
-            result = { action: "disable", service, enabled: false, reminder: existing.reminder };
-            break;
-        }
-        case "reset": {
-            if (!serviceRaw)
-                throw new Error("'service' param is required for reset");
-            const service = serviceRaw;
-            const existing = getServiceInfo(service);
-            if (!existing)
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            resetService(service);
-            result = { action: "reset", service, enabled: getServiceInfo(service)?.enabled, reminder: existing.reminder, reset: true };
-            break;
-        }
-        case "info": {
-            if (!serviceRaw)
-                throw new Error("'service' param is required for info");
-            const service = serviceRaw;
-            const info = getServiceInfo(service);
-            if (!info)
-                throw new Error(`Unknown service: ${service}. Use action='list' to see all valid services.`);
-            result = { action: "info", ...info };
-            break;
-        }
-        default:
-            throw new Error(`Unknown config_operation action: ${String(action)}`);
-    }
-    return {
-        content: [{ type: "text", text: JSON.stringify({ result }) }],
-        structuredContent: { result },
-    };
-}
+import{listServices,getServiceInfo,toggle as a300a,setEnabled as a300b,reset as a300c}from'../../config/index.js';import{strictParse}from'../../schema/index.js';import{ConfigOperationInputSchema}from'../../schema/config/index.js';export async function handleConfigOperation(a){const b=strictParse(ConfigOperationInputSchema,a,'config_operation\x20input'),{action:c,service:d}=b;let e;switch(c){case'list':e={'action':'list','services':listServices()};break;case'toggle':{if(!d)throw new Error('\x27service\x27\x20param\x20is\x20required\x20for\x20toggle');const f=d,g=getServiceInfo(f);if(!g)throw new Error('Unknown\x20service:\x20'+f+'.\x20Use\x20action=\x27list\x27\x20to\x20see\x20all\x20valid\x20services.');const h=a300a(f);e={'action':'toggle','service':f,'enabled':h,'reminder':g['reminder']};break;}case'enable':{if(!d)throw new Error('\x27service\x27\x20param\x20is\x20required\x20for\x20enable');const i=d,j=getServiceInfo(i);if(!j)throw new Error('Unknown\x20service:\x20'+i+'.\x20Use\x20action=\x27list\x27\x20to\x20see\x20all\x20valid\x20services.');a300b(i,!![]),e={'action':'enable','service':i,'enabled':!![],'reminder':j['reminder']};break;}case'disable':{if(!d)throw new Error('\x27service\x27\x20param\x20is\x20required\x20for\x20disable');const k=d,l=getServiceInfo(k);if(!l)throw new Error('Unknown\x20service:\x20'+k+'.\x20Use\x20action=\x27list\x27\x20to\x20see\x20all\x20valid\x20services.');a300b(k,![]),e={'action':'disable','service':k,'enabled':![],'reminder':l['reminder']};break;}case'reset':{if(!d)throw new Error('\x27service\x27\x20param\x20is\x20required\x20for\x20reset');const m=d,n=getServiceInfo(m);if(!n)throw new Error('Unknown\x20service:\x20'+m+'.\x20Use\x20action=\x27list\x27\x20to\x20see\x20all\x20valid\x20services.');a300c(m),e={'action':'reset','service':m,'enabled':getServiceInfo(m)?.['enabled'],'reminder':n['reminder'],'reset':!![]};break;}case'info':{if(!d)throw new Error('\x27service\x27\x20param\x20is\x20required\x20for\x20info');const o=d,p=getServiceInfo(o);if(!p)throw new Error('Unknown\x20service:\x20'+o+'.\x20Use\x20action=\x27list\x27\x20to\x20see\x20all\x20valid\x20services.');e={'action':'info',...p};break;}default:throw new Error('Unknown\x20config_operation\x20action:\x20'+String(c));}return{'content':[{'type':'text','text':JSON['stringify']({'result':e})}],'structuredContent':{'result':e}};}

package/dist/tools/handlers/evaluation.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleEvaluationOperation(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/evaluation.js

@@ -0,0 +1 @@
+import{strictParse}from'../../schema/index.js';import{EvaluationOperationInputSchema}from'../../schema/evaluation/index.js';import{evaluateArbGame}from'../../evaluation/arbitration-game.js';import{evaluateNodeGame}from'../../evaluation/node-game.js';import{summarizeCapabilityGaps}from'../../evaluation/gap.js';import{composeServicesForDemand}from'../../evaluation/composer.js';import{matchDemandToServices,matchServiceToDemands}from'../../evaluation/builtins/demand-match.js';import{assessServiceRisk}from'../../evaluation/builtins/service-risk.js';import{registerBuiltinEvaluations}from'../../evaluation/builtins/index.js';import{getEffectivePersona,mergeInjections,personaToInjection}from'../../persona/index.js';registerBuiltinEvaluations();function capabilityFromInput(a){return{'id':a['id'],'kind':a['kind'],'owner':a['owner']??'','industry':a['industry'],'industry_confidence':a['industry_confidence']??0x0,'region':a['region'],'price_min':a['price_min']!==undefined?BigInt(a['price_min']):undefined,'price_max':a['price_max']!==undefined?BigInt(a['price_max']):undefined,'token_type':a['token_type']??'','ticket_size':a['ticket_size']??'medium','trust_score':a['trust_score']??0x32,'reputation_like_ratio':a['reputation_like_ratio']??0x1,'arbitration_independent':a['arbitration_independent']??![],'merchant_history_count':a['merchant_history_count']??0x0,'capabilities':a['capabilities'],'tags':a['tags']??[],'keywords':a['keywords']??[]};}function puzzleRawFromInput(a){return{'service':{...a['service'],'priceRaw':a['service']['priceRaw']!==undefined?BigInt(a['service']['priceRaw']):undefined,'compensation_fund':a['service']['compensation_fund']?{'balance':a['service']['compensation_fund']['balance']!==undefined?BigInt(a['service']['compensation_fund']['balance']):undefined}:undefined},'machine_nodes':a['machine_nodes'],'machine_published':a['machine_published'],'machine_paused':a['machine_paused'],'reviews':a['reviews'],'events':a['events'],'similar_services':a['similar_services']?.['map'](b=>({'price':BigInt(b['price'])})),'order_amount':a['order_amount']!==undefined?BigInt(a['order_amount']):undefined,'trust_score':a['trust_score'],'arbitration_owner':a['arbitration_owner'],'service_owner':a['service_owner'],'wip_verified':a['wip_verified'],'order_history':a['order_history'],'merchant_reputation':a['merchant_reputation']};}async function resolveInjection(a,b){const c=a?personaToInjection(await getEffectivePersona(a)):undefined;return mergeInjections(c,b);}export async function handleEvaluationOperation(a){const b=strictParse(EvaluationOperationInputSchema,a,'evaluation_operation\x20input');let c;switch(b['action']){case'arb_game':{const d=b['account']?await getEffectivePersona(b['account']):null,e=b['appetite']??d?.['layer']['preferences']?.['risk_appetite'],f=b['requirements']??d?.['layer']['requirements'];c={'action':'arb_game',...evaluateArbGame(b['status'],b['perspective'],{'risk_appetite':e,'requirements':f})};break;}case'node_game':{const g=b['account']?await getEffectivePersona(b['account']):null,h=b['appetite']??g?.['layer']['preferences']?.['risk_appetite'],i=b['requirements']??g?.['layer']['requirements'];c={'action':'node_game',...evaluateNodeGame({'current_node':b['current_node'],'perspective':b['perspective'],'appetite':h,'requirements':i,'threshold':b['threshold'],'allocation':b['allocation'],'order_amount':b['order_amount'],'compensation_fund':b['compensation_fund'],'operable':b['operable'],'waiting_on':b['waiting_on']??[]})};break;}case'capability_gap':{c={'action':'capability_gap','report':summarizeCapabilityGaps(capabilityFromInput(b['demand']),capabilityFromInput(b['service']))};break;}case'compose_service':{c={'action':'compose_service','plan':composeServicesForDemand(capabilityFromInput(b['demand']),b['services']['map'](capabilityFromInput))};break;}case'demand_match':{c={'action':'demand_match','matches':await matchDemandToServices(capabilityFromInput(b['demand_cap']),b['services'],await resolveInjection(b['account'],b['injection']))};break;}case'service_match':{c={'action':'service_match','matches':await matchServiceToDemands(capabilityFromInput(b['service_cap']),b['demands'],await resolveInjection(b['account'],b['injection']))};break;}case'service_risk':{c={'action':'service_risk','result':await assessServiceRisk(b['service_id'],puzzleRawFromInput(b['puzzle_raw']),await resolveInjection(b['account'],b['injection']),b['depth']??'preorder')};break;}default:throw new Error('Unknown\x20evaluation_operation\x20action');}return{'content':[{'type':'text','text':JSON['stringify']({'result':c})}],'structuredContent':{'result':c}};}

package/dist/tools/handlers/file-export.js

@@ -1,90 +1 @@
-import { resolve } from "path";
-import { strictParse, getEnvConfig, Guard2File_InputSchema, MachineNode2File_InputSchema, } from "../../schema/index.js";
-import { guard2file, machineNode2file, } from "@wowok/wowok";
-export async function handleGuard2File(args) {
-    const validated = strictParse(Guard2File_InputSchema, args, "guard2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await guard2file(validated.guard, validated.file_path, validated.format || "json", env.network);
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    guard_object: validated.guard,
-                },
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
-export async function handleMachineNode2File(args) {
-    const validated = strictParse(MachineNode2File_InputSchema, args, "machineNode2file input");
-    const env = getEnvConfig(validated.env);
-    try {
-        await machineNode2file(validated.machine, validated.file_path, validated.format || "json", env.network);
-        let node_count = undefined;
-        try {
-            const filePath = resolve(validated.file_path);
-            const fileContent = await import('fs/promises').then(fs => fs.readFile(filePath, 'utf-8'));
-            if ((validated.format || "json") === "json") {
-                const parsed = JSON.parse(fileContent);
-                if (Array.isArray(parsed)) {
-                    node_count = parsed.length;
-                }
-            }
-            else {
-                const nodeMatches = fileContent.match(/^##\s+Node:/gm);
-                node_count = nodeMatches ? nodeMatches.length : 0;
-            }
-        }
-        catch {
-            node_count = undefined;
-        }
-        const result = {
-            result: {
-                status: "success",
-                data: {
-                    file_path: resolve(validated.file_path),
-                    format: validated.format || "json",
-                    machine_object: validated.machine,
-                },
-            },
-        };
-        if (node_count !== undefined) {
-            result.result.data.node_count = node_count;
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-    catch (error) {
-        const result = {
-            result: {
-                status: "error",
-                error: error.message,
-            },
-        };
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: result,
-        };
-    }
-}
+import{resolve}from'path';import{strictParse,getEnvConfig,Guard2File_InputSchema,MachineNode2File_InputSchema}from'../../schema/index.js';import{guard2file,machineNode2file}from'@wowok/wowok';export async function handleGuard2File(a){const b=strictParse(Guard2File_InputSchema,a,'guard2file\x20input'),c=getEnvConfig(b['env']);try{await guard2file(b['guard'],b['file_path'],b['format']||'json',c['network']);const d={'result':{'status':'success','data':{'file_path':resolve(b['file_path']),'format':b['format']||'json','guard_object':b['guard']}}};return{'content':[{'type':'text','text':JSON['stringify'](d)}],'structuredContent':d};}catch(e){const f={'result':{'status':'error','error':e['message']}};return{'content':[{'type':'text','text':JSON['stringify'](f)}],'structuredContent':f};}}export async function handleMachineNode2File(a){const b=strictParse(MachineNode2File_InputSchema,a,'machineNode2file\x20input'),c=getEnvConfig(b['env']);try{await machineNode2file(b['machine'],b['file_path'],b['format']||'json',c['network']);let d=undefined;try{const f=resolve(b['file_path']),g=await import('fs/promises')['then'](h=>h['readFile'](f,'utf-8'));if((b['format']||'json')==='json'){const h=JSON['parse'](g);Array['isArray'](h)&&(d=h['length']);}else{const i=g['match'](/^##\s+Node:/gm);d=i?i['length']:0x0;}}catch{d=undefined;}const e={'result':{'status':'success','data':{'file_path':resolve(b['file_path']),'format':b['format']||'json','machine_object':b['machine']}}};return d!==undefined&&(e['result']['data']['node_count']=d),{'content':[{'type':'text','text':JSON['stringify'](e)}],'structuredContent':e};}catch(j){const k={'result':{'status':'error','error':j['message']}};return{'content':[{'type':'text','text':JSON['stringify'](k)}],'structuredContent':k};}}

package/dist/tools/handlers/intent-radar.d.ts

@@ -0,0 +1,2 @@
+import type { ToolDispatchResult } from "../types.js";
+export declare function handleIntentRadar(args: unknown): Promise<ToolDispatchResult>;

package/dist/tools/handlers/intent-radar.js

@@ -0,0 +1 @@
+import{strictParse}from'../../schema/index.js';import{IntentRadarInputSchema}from'../../schema/intent-radar/index.js';import{createIntent,listIntents,matchAllIntents,matchIntent,removeIntent}from'../../intent/index.js';import{enrichEventsWithObjectText}from'../../intent/enrich.js';import{query_events}from'@wowok/wowok';const AUTO_PULL_TYPES=['NewOrderEvent','DemandPresentEvent','DemandFeedbackEvent','ProgressEvent','NewEntityEvent','ArbEvent'];async function pullRecentEvents(a,b){const c=[];for(const d of AUTO_PULL_TYPES){try{const e=await query_events({'type':d,'cursor':null,'limit':b,'order':'descending','no_cache':![],'network':a}),f=e?.['data'];if(Array['isArray'](f))c['push'](...f);}catch{}}return c;}export async function handleIntentRadar(a){const b=strictParse(IntentRadarInputSchema,a,'intent_radar\x20input');let c;switch(b['action']){case'save':{const d=await createIntent({'intent':b['intent'],'account':b['account'],'role':b['role'],'target_types':b['target_types']});c={'action':'save','intent':d};break;}case'list':{c={'action':'list','intents':await listIntents(b['account'])};break;}case'remove':{c={'action':'remove','removed':await removeIntent(b['id'])};break;}case'match':{let e=b['events']??[];e['length']===0x0&&(e=await pullRecentEvents(b['network'],b['limit']??0x5));e=await enrichEventsWithObjectText(e,b['network']);const f=b['intent_id']?[await matchIntent(b['intent_id'],e)]['filter'](g=>g!==null):await matchAllIntents(e,b['account']);c={'action':'match','results':f};break;}default:throw new Error('Unknown\x20intent_radar\x20action');}return{'content':[{'type':'text','text':JSON['stringify']({'result':c})}],'structuredContent':{'result':c}};}

package/dist/tools/handlers/local.js

@@ -1,53 +1 @@
-import { wrapLocalHandler } from "../shared.js";
-import { withFaucetRetry } from "../retry.js";
-import { AccountOperationSchema, LocalMarkOperationSchema, LocalInfoOperationSchema, } from "../../schema/index.js";
-import { account_operation, local_mark_operation, local_info_operation, } from "@wowok/wowok";
-function deriveOpType(prefix, validated) {
-    for (const key of Object.keys(validated)) {
-        if (validated[key] !== undefined) {
-            return `${prefix}_${String(key)}`;
-        }
-    }
-    return `${prefix}_unknown`;
-}
-export const handleAccountOperation = wrapLocalHandler({
-    schema: AccountOperationSchema,
-    operationFn: withFaucetRetry(account_operation),
-    parseLabel: "account_operation input",
-    buildContext: (validated) => ({
-        operation_type: deriveOpType("account", validated),
-        data: validated,
-    }),
-});
-export const handleMarkOperation = wrapLocalHandler({
-    schema: LocalMarkOperationSchema,
-    operationFn: local_mark_operation,
-    parseLabel: "local_mark_operation input",
-    buildContext: (validated) => {
-        const ctx = {
-            operation_type: deriveOpType("mark", validated),
-            data: validated,
-        };
-        const v = validated;
-        if (v.add && Array.isArray(v.add.data) && v.add.data.length > 0) {
-            ctx.pre_warnings = [
-                "Cross-network consistency (FIX-011): LocalMark names are scoped per network. " +
-                    "When creating marks for the same logical object on different networks " +
-                    "(e.g. testnet and mainnet), use the SAME name value to keep name-based " +
-                    "references portable. Before creating a mark on mainnet, consider querying " +
-                    "testnet via query_local with network='testnet' to check for an existing " +
-                    "same-named mark and replicate it.",
-            ];
-        }
-        return ctx;
-    },
-});
-export const handleInfoOperation = wrapLocalHandler({
-    schema: LocalInfoOperationSchema,
-    operationFn: local_info_operation,
-    parseLabel: "local_info_operation input",
-    buildContext: (validated) => ({
-        operation_type: deriveOpType("local_info", validated),
-        data: validated,
-    }),
-});
+import{wrapLocalHandler}from'../shared.js';import{withFaucetRetry}from'../retry.js';import{AccountOperationSchema,LocalMarkOperationSchema,LocalInfoOperationSchema}from'../../schema/index.js';import{account_operation,local_mark_operation,local_info_operation}from'@wowok/wowok';function deriveOpType(a,b){for(const c of Object['keys'](b)){if(b[c]!==undefined)return a+'_'+String(c);}return a+'_unknown';}export const handleAccountOperation=wrapLocalHandler({'schema':AccountOperationSchema,'operationFn':withFaucetRetry(account_operation),'parseLabel':'account_operation\x20input','buildContext':a=>({'operation_type':deriveOpType('account',a),'data':a})});export const handleMarkOperation=wrapLocalHandler({'schema':LocalMarkOperationSchema,'operationFn':local_mark_operation,'parseLabel':'local_mark_operation\x20input','buildContext':a=>{const b={'operation_type':deriveOpType('mark',a),'data':a},c=a;return c['add']&&Array['isArray'](c['add']['data'])&&c['add']['data']['length']>0x0&&(b['pre_warnings']=['Cross-network\x20consistency\x20(FIX-011):\x20LocalMark\x20names\x20are\x20scoped\x20per\x20network.\x20'+'When\x20creating\x20marks\x20for\x20the\x20same\x20logical\x20object\x20on\x20different\x20networks\x20'+'(e.g.\x20testnet\x20and\x20mainnet),\x20use\x20the\x20SAME\x20name\x20value\x20to\x20keep\x20name-based\x20'+'references\x20portable.\x20Before\x20creating\x20a\x20mark\x20on\x20mainnet,\x20consider\x20querying\x20'+'testnet\x20via\x20query_local\x20with\x20network=\x27testnet\x27\x20to\x20check\x20for\x20an\x20existing\x20'+'same-named\x20mark\x20and\x20replicate\x20it.']),b;}});export const handleInfoOperation=wrapLocalHandler({'schema':LocalInfoOperationSchema,'operationFn':local_info_operation,'parseLabel':'local_info_operation\x20input','buildContext':a=>({'operation_type':deriveOpType('local_info',a),'data':a})});

package/dist/tools/handlers/messenger.js

@@ -1,188 +1 @@
-import { strictParse, MessengerOperationInputSchema, } from "../../schema/index.js";
-import { watch_conversations, send_message, send_file, watch_messages, extract_zip_messages, pull_messages, generate_wts, verify_wts, sign_wts, wts2html, proof_message, mark_messages_as_viewed, mark_conversation_as_viewed, blacklist, friendslist, guardlist, settings, } from "@wowok/wowok";
-import { classifyError, buildDataSemantic, } from "../../schema/call/semantic.js";
-export function normalizeAccountOrMark(input) {
-    if (typeof input === 'string') {
-        return { name_or_address: input, local_mark_first: true };
-    }
-    return input;
-}
-export function normalizeManyAccountOrMark(input) {
-    if (Array.isArray(input)) {
-        return {
-            entities: input.map(item => typeof item === 'string' ? { name_or_address: item, local_mark_first: true } : item),
-            check_all_founded: true,
-        };
-    }
-    return input;
-}
-export async function handleMessengerOperation(args) {
-    let validated;
-    try {
-        validated = strictParse(MessengerOperationInputSchema, args, "messenger_operation input");
-        const opLiteral = validated.operation;
-        let result;
-        switch (validated.operation) {
-            case "watch_conversations": {
-                const conversations = await watch_conversations(validated.filter);
-                result = { operation: "watch_conversations", result: conversations };
-                break;
-            }
-            case "send_message": {
-                const sendResult = await send_message(validated.from, normalizeAccountOrMark(validated.to), validated.content, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_message", result: filteredResult };
-                break;
-            }
-            case "send_file": {
-                const sendResult = await send_file(validated.from, normalizeAccountOrMark(validated.to), validated.filePath, validated.options);
-                const filteredResult = {
-                    ...sendResult,
-                    merkleData: sendResult.merkleData ? {
-                        leafIndex: sendResult.merkleData.leafIndex,
-                        prevRoot: sendResult.merkleData.prevRoot,
-                        newRoot: sendResult.merkleData.newRoot,
-                        serverSignature: sendResult.merkleData.serverSignature,
-                        serverTimestamp: sendResult.merkleData.serverTimestamp,
-                        serverPublicKey: sendResult.merkleData.serverPublicKey,
-                    } : undefined,
-                };
-                result = { operation: "send_file", result: filteredResult };
-                break;
-            }
-            case "watch_messages": {
-                const filter = validated.filter ? {
-                    ...validated.filter,
-                    peerAddress: validated.filter.peerAddress ? normalizeAccountOrMark(validated.filter.peerAddress) : undefined,
-                } : undefined;
-                const messages = await watch_messages(filter);
-                result = { operation: "watch_messages", result: messages };
-                break;
-            }
-            case "extract_zip_messages": {
-                const extractedPaths = await extract_zip_messages(validated.account, validated.messages, validated.outputDir);
-                result = { operation: "extract_zip_messages", result: extractedPaths };
-                break;
-            }
-            case "generate_wts": {
-                const params = validated.params ? {
-                    ...validated.params,
-                    peerAccount: normalizeAccountOrMark(validated.params.peerAccount),
-                } : undefined;
-                const wtsResult = await generate_wts(params);
-                result = { operation: "generate_wts", result: wtsResult };
-                break;
-            }
-            case "verify_wts": {
-                const verifyResult = await verify_wts(validated.wtsFilePath);
-                result = { operation: "verify_wts", result: verifyResult };
-                break;
-            }
-            case "sign_wts": {
-                const signedPath = await sign_wts(validated.wtsFilePath, validated.account, validated.outputPath);
-                result = { operation: "sign_wts", result: signedPath };
-                break;
-            }
-            case "wts2html": {
-                const htmlResult = await wts2html(validated.wtsPath, validated.options);
-                result = { operation: "wts2html", result: htmlResult };
-                break;
-            }
-            case "proof_message": {
-                const proofResult = await proof_message(validated.account, validated.messageId, validated.network);
-                result = { operation: "proof_message", result: proofResult };
-                break;
-            }
-            case "blacklist": {
-                const blacklistParams = {
-                    account: validated.account,
-                    op: validated.blacklist.op,
-                };
-                if ('users' in validated.blacklist) {
-                    blacklistParams.users = normalizeManyAccountOrMark(validated.blacklist.users);
-                }
-                const blacklistResult = await blacklist(blacklistParams);
-                result = { operation: "blacklist", op: validated.blacklist.op, result: blacklistResult.result };
-                break;
-            }
-            case "friendslist": {
-                const friendslistParams = {
-                    account: validated.account,
-                    op: validated.friendslist.op,
-                };
-                if ('users' in validated.friendslist) {
-                    friendslistParams.users = normalizeManyAccountOrMark(validated.friendslist.users);
-                }
-                const friendslistResult = await friendslist(friendslistParams);
-                result = { operation: "friendslist", op: validated.friendslist.op, result: friendslistResult.result };
-                break;
-            }
-            case "guardlist": {
-                const guardlistResult = await guardlist({
-                    account: validated.account,
-                    ...validated.guardlist,
-                });
-                result = { operation: "guardlist", op: validated.guardlist.op, result: guardlistResult.result };
-                break;
-            }
-            case "settings": {
-                const settingsResult = await settings({
-                    account: validated.account,
-                    ...validated.settings,
-                });
-                result = { operation: "settings", op: validated.settings.op, result: settingsResult.result };
-                break;
-            }
-            case "mark_messages_as_viewed": {
-                const markedCount = await mark_messages_as_viewed(validated.messageIds, validated.account);
-                result = { operation: "mark_messages_as_viewed", result: markedCount };
-                break;
-            }
-            case "mark_conversation_as_viewed": {
-                const markedCount = await mark_conversation_as_viewed(normalizeAccountOrMark(validated.peerAddress), validated.account);
-                result = { operation: "mark_conversation_as_viewed", result: markedCount };
-                break;
-            }
-            case "pull_messages": {
-                const messages = await pull_messages(validated.account, validated.limit);
-                result = { operation: "pull_messages", result: messages };
-                break;
-            }
-            default:
-                throw new Error(`Unknown messenger operation: ${opLiteral}`);
-        }
-        return {
-            content: [{ type: "text", text: JSON.stringify(result) }],
-            structuredContent: { result },
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        const ctx = validated ? { operation_type: "messenger_" + validated.operation, data: validated } : undefined;
-        const classified = classifyError(errorMessage);
-        const errorResult = { operation: "error", error: errorMessage };
-        if (classified.error_code !== undefined)
-            errorResult.error_code = classified.error_code;
-        if (classified.retryable !== undefined)
-            errorResult.retryable = classified.retryable;
-        if (classified.recovery_hint !== undefined)
-            errorResult.recovery_hint = classified.recovery_hint;
-        return {
-            content: [{ type: "text", text: `Error: ${errorMessage}` }],
-            structuredContent: {
-                result: errorResult,
-                semantic: buildDataSemantic(undefined, ctx, true, errorMessage),
-            },
-        };
-    }
-}
+import{strictParse,MessengerOperationInputSchema}from'../../schema/index.js';import{watch_conversations,send_message,send_file,watch_messages,extract_zip_messages,pull_messages,generate_wts,verify_wts,sign_wts,wts2html,proof_message,mark_messages_as_viewed,mark_conversation_as_viewed,blacklist,friendslist,guardlist,settings}from'@wowok/wowok';import{classifyError,buildDataSemantic}from'../../schema/call/semantic.js';export function normalizeAccountOrMark(a){if(typeof a==='string')return{'name_or_address':a,'local_mark_first':!![]};return a;}export function normalizeManyAccountOrMark(a){if(Array['isArray'](a))return{'entities':a['map'](b=>typeof b==='string'?{'name_or_address':b,'local_mark_first':!![]}:b),'check_all_founded':!![]};return a;}export async function handleMessengerOperation(a){let b;try{b=strictParse(MessengerOperationInputSchema,a,'messenger_operation\x20input');const c=b['operation'];let d;switch(b['operation']){case'watch_conversations':{const e=await watch_conversations(b['filter']);d={'operation':'watch_conversations','result':e};break;}case'send_message':{const f=await send_message(b['from'],normalizeAccountOrMark(b['to']),b['content'],b['options']),g={...f,'merkleData':f['merkleData']?{'leafIndex':f['merkleData']['leafIndex'],'prevRoot':f['merkleData']['prevRoot'],'newRoot':f['merkleData']['newRoot'],'serverSignature':f['merkleData']['serverSignature'],'serverTimestamp':f['merkleData']['serverTimestamp'],'serverPublicKey':f['merkleData']['serverPublicKey']}:undefined};d={'operation':'send_message','result':g};break;}case'send_file':{const h=await send_file(b['from'],normalizeAccountOrMark(b['to']),b['filePath'],b['options']),i={...h,'merkleData':h['merkleData']?{'leafIndex':h['merkleData']['leafIndex'],'prevRoot':h['merkleData']['prevRoot'],'newRoot':h['merkleData']['newRoot'],'serverSignature':h['merkleData']['serverSignature'],'serverTimestamp':h['merkleData']['serverTimestamp'],'serverPublicKey':h['merkleData']['serverPublicKey']}:undefined};d={'operation':'send_file','result':i};break;}case'watch_messages':{const j=b['filter']?{...b['filter'],'peerAddress':b['filter']['peerAddress']?normalizeAccountOrMark(b['filter']['peerAddress']):undefined}:undefined,k=await watch_messages(j);d={'operation':'watch_messages','result':k};break;}case'extract_zip_messages':{const l=await extract_zip_messages(b['account'],b['messages'],b['outputDir']);d={'operation':'extract_zip_messages','result':l};break;}case'generate_wts':{const m=b['params']?{...b['params'],'peerAccount':normalizeAccountOrMark(b['params']['peerAccount'])}:undefined,n=await generate_wts(m);d={'operation':'generate_wts','result':n};break;}case'verify_wts':{const o=await verify_wts(b['wtsFilePath']);d={'operation':'verify_wts','result':o};break;}case'sign_wts':{const p=await sign_wts(b['wtsFilePath'],b['account'],b['outputPath']);d={'operation':'sign_wts','result':p};break;}case'wts2html':{const q=await wts2html(b['wtsPath'],b['options']);d={'operation':'wts2html','result':q};break;}case'proof_message':{const r=await proof_message(b['account'],b['messageId'],b['network']);d={'operation':'proof_message','result':r};break;}case'blacklist':{const s={'account':b['account'],'op':b['blacklist']['op']};'users'in b['blacklist']&&(s['users']=normalizeManyAccountOrMark(b['blacklist']['users']));const t=await blacklist(s);d={'operation':'blacklist','op':b['blacklist']['op'],'result':t['result']};break;}case'friendslist':{const u={'account':b['account'],'op':b['friendslist']['op']};'users'in b['friendslist']&&(u['users']=normalizeManyAccountOrMark(b['friendslist']['users']));const v=await friendslist(u);d={'operation':'friendslist','op':b['friendslist']['op'],'result':v['result']};break;}case'guardlist':{const w=await guardlist({'account':b['account'],...b['guardlist']});d={'operation':'guardlist','op':b['guardlist']['op'],'result':w['result']};break;}case'settings':{const x=await settings({'account':b['account'],...b['settings']});d={'operation':'settings','op':b['settings']['op'],'result':x['result']};break;}case'mark_messages_as_viewed':{const y=await mark_messages_as_viewed(b['messageIds'],b['account']);d={'operation':'mark_messages_as_viewed','result':y};break;}case'mark_conversation_as_viewed':{const z=await mark_conversation_as_viewed(normalizeAccountOrMark(b['peerAddress']),b['account']);d={'operation':'mark_conversation_as_viewed','result':z};break;}case'pull_messages':{const A=await pull_messages(b['account'],b['limit']);d={'operation':'pull_messages','result':A};break;}default:throw new Error('Unknown\x20messenger\x20operation:\x20'+c);}return{'content':[{'type':'text','text':JSON['stringify'](d)}],'structuredContent':{'result':d}};}catch(B){const C=B instanceof Error?B['message']:String(B),D=b?{'operation_type':'messenger_'+b['operation'],'data':b}:undefined,E=classifyError(C),F={'operation':'error','error':C};if(E['error_code']!==undefined)F['error_code']=E['error_code'];if(E['retryable']!==undefined)F['retryable']=E['retryable'];if(E['recovery_hint']!==undefined)F['recovery_hint']=E['recovery_hint'];return{'content':[{'type':'text','text':'Error:\x20'+C}],'structuredContent':{'result':F,'semantic':buildDataSemantic(undefined,D,!![],C)}};}}