openclaw-overlay-plugin 0.7.22

package/dist/scripts/messaging/handlers.js

@@ -0,0 +1,334 @@
+/**
+ * Message type handlers and processMessage function.
+ */
+import fs from 'node:fs';
+import { OVERLAY_URL, WALLET_DIR, PATHS } from '../config.js';
+import { signRelayMessage, verifyRelaySignature, loadWalletIdentity } from '../wallet/identity.js';
+import { loadServices, appendToJsonl } from '../utils/storage.js';
+import { fetchWithTimeout } from '../utils/woc.js';
+import { serviceManager } from '../../services/index.js';
+// Dynamic import for @bsv/sdk (needed for hash160 computation)
+let _sdk = null;
+async function getSdk() {
+    if (_sdk)
+        return _sdk;
+    try {
+        _sdk = await import('@bsv/sdk');
+        return _sdk;
+    }
+    catch {
+        const { fileURLToPath } = await import('node:url');
+        const path = await import('node:path');
+        const os = await import('node:os');
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const candidates = [
+            path.resolve(__dirname, '..', '..', '..', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(__dirname, '..', '..', '..', '..', '..', 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+            path.resolve(os.homedir(), 'a2a-bsv', 'packages', 'core', 'node_modules', '@bsv', 'sdk', 'dist', 'esm', 'mod.js'),
+        ];
+        for (const p of candidates) {
+            try {
+                _sdk = await import(p);
+                return _sdk;
+            }
+            catch {
+                // Try next
+            }
+        }
+        throw new Error('Cannot find @bsv/sdk. Run setup.sh first.');
+    }
+}
+import { BSVAgentWallet } from '../../core/index.js';
+async function getBSVAgentWallet() {
+    return BSVAgentWallet;
+}
+// Import NETWORK lazily to avoid circular dependencies
+async function getNetwork() {
+    const config = await import('../config.js');
+    return config.NETWORK;
+}
+/**
+ * Verify and accept a payment from a service request.
+ * Uses a2a-bsv wallet.acceptPayment() for proper BRC-29 handling.
+ */
+export async function verifyAndAcceptPayment(payment, minSats, senderKey, serviceId, ourHash160) {
+    if (!payment) {
+        return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: 'no payment' };
+    }
+    if (payment.error) {
+        return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: payment.error };
+    }
+    if (!payment.beef || !payment.satoshis) {
+        return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: 'missing beef or satoshis' };
+    }
+    if (payment.satoshis < minSats) {
+        return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: `insufficient payment: ${payment.satoshis} < ${minSats}` };
+    }
+    // Accept the payment using a2a-bsv wallet
+    const BSVAgentWallet = await getBSVAgentWallet();
+    const network = await getNetwork();
+    const wallet = await BSVAgentWallet.load({ network, storageDir: WALLET_DIR });
+    try {
+        // First verify the payment structure
+        const verifyResult = await wallet.verifyPayment({ beef: payment.beef });
+        if (!verifyResult.valid) {
+            await wallet.destroy();
+            return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: `verification failed: ${verifyResult.errors.join(', ')}` };
+        }
+        // Accept the payment (this broadcasts the transaction)
+        const acceptResult = await wallet.acceptPayment({
+            beef: payment.beef,
+            derivationPrefix: payment.derivationPrefix,
+            derivationSuffix: payment.derivationSuffix,
+            senderIdentityKey: payment.senderIdentityKey,
+            description: `Payment for ${serviceId}`,
+        });
+        await wallet.destroy();
+        if (!acceptResult.accepted) {
+            return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: 'wallet rejected payment' };
+        }
+        return {
+            accepted: true,
+            txid: payment.txid,
+            satoshis: payment.satoshis,
+            outputIndex: 0,
+            walletAccepted: true,
+            error: null,
+        };
+    }
+    catch (err) {
+        await wallet.destroy();
+        return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: err.message };
+    }
+}
+/**
+ * Queue a service request for agent processing.
+ */
+async function queueForAgent(msg, identityKey, privKey, serviceId) {
+    // Check if this request has already been processed to prevent duplicates
+    if (fs.existsSync(PATHS.serviceQueue)) {
+        const lines = fs.readFileSync(PATHS.serviceQueue, 'utf-8').trim().split('\n').filter(Boolean);
+        for (const line of lines) {
+            try {
+                const entry = JSON.parse(line);
+                if (entry.requestId === msg.id) {
+                    // Request already exists in queue - return existing status
+                    return {
+                        id: msg.id,
+                        type: 'service-request',
+                        serviceId,
+                        action: entry.status === 'pending' ? 'already-queued' : `already-${entry.status}`,
+                        paymentAccepted: true,
+                        paymentTxid: entry.paymentTxid,
+                        satoshisReceived: entry.satoshisReceived,
+                        from: msg.from,
+                        ack: true,
+                    };
+                }
+            }
+            catch { }
+        }
+    }
+    const sdk = await getSdk();
+    const payment = msg.payload?.payment;
+    const input = msg.payload?.input || msg.payload;
+    // Verify and accept payment
+    const walletIdentity = loadWalletIdentity();
+    const ourHash160 = sdk.Hash.hash160(sdk.PrivateKey.fromHex(walletIdentity.rootKeyHex).toPublicKey().encode(true));
+    // Find the service price using the service registry
+    const serviceDefinition = serviceManager.registry.get(serviceId);
+    let minPrice = 5; // default fallback
+    if (serviceDefinition) {
+        minPrice = serviceDefinition.defaultPrice;
+        // Validate service input if possible
+        const validation = serviceManager.validate(serviceId, input);
+        if (!validation.valid) {
+            // Send validation rejection
+            const rejectPayload = {
+                requestId: msg.id,
+                serviceId,
+                status: 'rejected',
+                reason: `Input validation failed: ${validation.error}`
+            };
+            const sig = await signRelayMessage(privKey, msg.from, 'service-response', rejectPayload);
+            await fetchWithTimeout(`${OVERLAY_URL}/relay/send`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ from: identityKey, to: msg.from, type: 'service-response', payload: rejectPayload, signature: sig }),
+            });
+            // Also add the rejected entry to the queue for tracking
+            const rejectedEntry = {
+                status: 'rejected',
+                requestId: msg.id,
+                serviceId,
+                from: msg.from,
+                identityKey,
+                input: input,
+                paymentTxid: null,
+                satoshisReceived: 0,
+                walletAccepted: false,
+                error: validation.error,
+                _ts: Date.now(),
+            };
+            appendToJsonl(PATHS.serviceQueue, rejectedEntry);
+            return {
+                id: msg.id,
+                type: 'service-request',
+                serviceId,
+                action: 'rejected',
+                reason: validation.error || 'input validation failed',
+                from: msg.from,
+                ack: true
+            };
+        }
+    }
+    else {
+        // Fall back to legacy service loading for backward compatibility
+        const services = loadServices();
+        const svc = services.find(s => s.serviceId === serviceId);
+        minPrice = svc?.priceSats || 5;
+    }
+    const payResult = await verifyAndAcceptPayment(payment, minPrice, msg.from, serviceId, ourHash160);
+    if (!payResult.accepted) {
+        // Send rejection
+        const rejectPayload = { requestId: msg.id, serviceId, status: 'rejected', reason: `Payment rejected: ${payResult.error}` };
+        const sig = await signRelayMessage(privKey, msg.from, 'service-response', rejectPayload);
+        await fetchWithTimeout(`${OVERLAY_URL}/relay/send`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ from: identityKey, to: msg.from, type: 'service-response', payload: rejectPayload, signature: sig }),
+        });
+        // Also add the rejected entry to the queue for tracking
+        const rejectedEntry = {
+            status: 'rejected',
+            requestId: msg.id,
+            serviceId,
+            from: msg.from,
+            identityKey,
+            input: input,
+            paymentTxid: null,
+            satoshisReceived: 0,
+            walletAccepted: false,
+            error: payResult.error,
+            _ts: Date.now(),
+        };
+        appendToJsonl(PATHS.serviceQueue, rejectedEntry);
+        return { id: msg.id, type: 'service-request', serviceId, action: 'rejected', reason: payResult.error || 'payment rejected', from: msg.from, ack: true };
+    }
+    // Queue for agent processing
+    const queueEntry = {
+        status: 'pending',
+        requestId: msg.id,
+        serviceId,
+        from: msg.from,
+        identityKey,
+        input: input,
+        paymentTxid: payResult.txid,
+        satoshisReceived: payResult.satoshis,
+        walletAccepted: payResult.walletAccepted,
+        _ts: Date.now(),
+    };
+    appendToJsonl(PATHS.serviceQueue, queueEntry);
+    return {
+        id: msg.id,
+        type: 'service-request',
+        serviceId,
+        action: 'queued-for-agent',
+        paymentAccepted: true,
+        paymentTxid: payResult.txid,
+        satoshisReceived: payResult.satoshis,
+        from: msg.from,
+        ack: true,
+    };
+}
+/**
+ * Process a single relay message.
+ * Handles pings, service requests, pongs, and service responses.
+ */
+export async function processMessage(msg, identityKey, privKey) {
+    // Verify signature if present
+    const sigCheck = msg.signature
+        ? await verifyRelaySignature(msg.from, msg.to, msg.type, msg.payload, msg.signature)
+        : { valid: null };
+    // Reject unsigned/forged service-requests
+    if (msg.type === 'service-request' && sigCheck.valid !== true) {
+        console.error(JSON.stringify({ event: 'signature-rejected', type: msg.type, from: msg.from, reason: sigCheck.reason || 'missing signature' }));
+        return {
+            id: msg.id,
+            type: msg.type,
+            from: msg.from,
+            action: 'rejected',
+            reason: 'invalid-signature',
+            signatureValid: sigCheck.valid,
+            ack: true,
+        };
+    }
+    if (msg.type === 'ping') {
+        // Auto-respond with pong
+        const pongPayload = {
+            text: 'pong',
+            inReplyTo: msg.id,
+            originalText: msg.payload?.text || null,
+        };
+        const pongSig = await signRelayMessage(privKey, msg.from, 'pong', pongPayload);
+        await fetch(`${OVERLAY_URL}/relay/send`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                from: identityKey,
+                to: msg.from,
+                type: 'pong',
+                payload: pongPayload,
+                signature: pongSig,
+            }),
+        });
+        return { id: msg.id, type: 'ping', action: 'replied-pong', from: msg.from, ack: true };
+    }
+    if (msg.type === 'service-request') {
+        const serviceId = msg.payload?.serviceId;
+        // Agent-routed mode: queue for the agent
+        if (process.env.AGENT_ROUTED === 'true') {
+            return await queueForAgent(msg, identityKey, privKey, serviceId);
+        }
+        // No hardcoded handlers in TypeScript version — always queue
+        return await queueForAgent(msg, identityKey, privKey, serviceId);
+    }
+    if (msg.type === 'pong') {
+        return {
+            id: msg.id,
+            type: 'pong',
+            action: 'received',
+            from: msg.from,
+            text: msg.payload?.text,
+            inReplyTo: msg.payload?.inReplyTo,
+            ack: true,
+        };
+    }
+    if (msg.type === 'service-response') {
+        const serviceId = msg.payload?.serviceId;
+        const status = msg.payload?.status;
+        const result = msg.payload?.result;
+        return {
+            id: msg.id,
+            type: 'service-response',
+            action: 'received',
+            from: msg.from,
+            serviceId,
+            status,
+            result,
+            requestId: msg.payload?.requestId,
+            direction: 'incoming-response',
+            ack: true,
+        };
+    }
+    // Unknown type
+    return {
+        id: msg.id,
+        type: msg.type,
+        from: msg.from,
+        payload: msg.payload,
+        signatureValid: sigCheck.valid,
+        action: 'unhandled',
+        ack: false,
+    };
+}

package/dist/scripts/messaging/inbox.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Inbox and ack commands.
+ */
+/**
+ * Inbox command: fetch pending messages.
+ */
+export declare function cmdInbox(args: string[]): Promise<never>;
+/**
+ * Ack command: acknowledge processed messages.
+ */
+export declare function cmdAck(messageIds: string[]): Promise<never>;

package/dist/scripts/messaging/inbox.js

@@ -0,0 +1,51 @@
+/**
+ * Inbox and ack commands.
+ */
+import { OVERLAY_URL } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadIdentity, verifyRelaySignature } from '../wallet/identity.js';
+/**
+ * Inbox command: fetch pending messages.
+ */
+export async function cmdInbox(args) {
+    const { identityKey } = await loadIdentity();
+    let since = '';
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--since' && args[i + 1])
+            since = `&since=${args[++i]}`;
+    }
+    const resp = await fetch(`${OVERLAY_URL}/relay/inbox?identity=${identityKey}${since}`);
+    if (!resp.ok) {
+        const body = await resp.text();
+        return fail(`Relay inbox failed (${resp.status}): ${body}`);
+    }
+    const result = await resp.json();
+    // Verify signatures on received messages
+    const messages = await Promise.all(result.messages.map(async (msg) => ({
+        ...msg,
+        signatureValid: msg.signature
+            ? (await verifyRelaySignature(msg.from, msg.to, msg.type, msg.payload, msg.signature)).valid
+            : null,
+    })));
+    return ok({ messages, count: messages.length, identityKey });
+}
+/**
+ * Ack command: acknowledge processed messages.
+ */
+export async function cmdAck(messageIds) {
+    if (!messageIds || messageIds.length === 0) {
+        return fail('Usage: ack <messageId> [messageId2 ...]');
+    }
+    const { identityKey } = await loadIdentity();
+    const resp = await fetch(`${OVERLAY_URL}/relay/ack`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ identity: identityKey, messageIds }),
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        return fail(`Relay ack failed (${resp.status}): ${body}`);
+    }
+    const result = await resp.json();
+    return ok({ acked: result.acked, messageIds });
+}

package/dist/scripts/messaging/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Messaging module exports.
+ */
+export * from './send.js';
+export * from './inbox.js';
+export * from './handlers.js';
+export * from './poll.js';
+export * from './connect.js';

package/dist/scripts/messaging/index.js

@@ -0,0 +1,8 @@
+/**
+ * Messaging module exports.
+ */
+export * from './send.js';
+export * from './inbox.js';
+export * from './handlers.js';
+export * from './poll.js';
+export * from './connect.js';

package/dist/scripts/messaging/poll.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Poll command: fetch and process all pending messages.
+ */
+/**
+ * Poll command: fetch all pending messages and process them.
+ */
+export declare function cmdPoll(): Promise<never>;

package/dist/scripts/messaging/poll.js

@@ -0,0 +1,52 @@
+/**
+ * Poll command: fetch and process all pending messages.
+ */
+import { OVERLAY_URL } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadIdentity } from '../wallet/identity.js';
+import { processMessage } from './handlers.js';
+/**
+ * Poll command: fetch all pending messages and process them.
+ */
+export async function cmdPoll() {
+    const { identityKey, privKey } = await loadIdentity();
+    // Fetch inbox
+    const inboxResp = await fetch(`${OVERLAY_URL}/relay/inbox?identity=${identityKey}`);
+    if (!inboxResp.ok) {
+        const body = await inboxResp.text();
+        return fail(`Relay inbox failed (${inboxResp.status}): ${body}`);
+    }
+    const inbox = await inboxResp.json();
+    if (inbox.count === 0) {
+        return ok({ processed: 0, messages: [], summary: 'No pending messages.' });
+    }
+    const processed = [];
+    const ackedIds = [];
+    const unhandled = [];
+    for (const msg of inbox.messages) {
+        const result = await processMessage(msg, identityKey, privKey);
+        if (result.ack) {
+            ackedIds.push(result.id);
+            processed.push(result);
+        }
+        else {
+            unhandled.push(result);
+        }
+    }
+    // ACK processed messages
+    if (ackedIds.length > 0) {
+        await fetch(`${OVERLAY_URL}/relay/ack`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ identity: identityKey, messageIds: ackedIds }),
+        });
+    }
+    return ok({
+        processed: processed.length,
+        unhandled: unhandled.length,
+        total: inbox.count,
+        messages: processed,
+        unhandledMessages: unhandled,
+        ackedIds,
+    });
+}

package/dist/scripts/messaging/send.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Send relay message command.
+ */
+/**
+ * Send command: send a typed message to another agent.
+ */
+export declare function cmdSend(targetKey: string | undefined, type: string | undefined, payloadStr: string | undefined): Promise<never>;

package/dist/scripts/messaging/send.js

@@ -0,0 +1,43 @@
+/**
+ * Send relay message command.
+ */
+import { OVERLAY_URL } from '../config.js';
+import { ok, fail } from '../output.js';
+import { loadIdentity, signRelayMessage } from '../wallet/identity.js';
+/**
+ * Send command: send a typed message to another agent.
+ */
+export async function cmdSend(targetKey, type, payloadStr) {
+    if (!targetKey || !type || !payloadStr) {
+        return fail('Usage: send <identityKey> <type> <json_payload>');
+    }
+    if (!/^0[23][0-9a-fA-F]{64}$/.test(targetKey)) {
+        return fail('Target must be a compressed public key (66 hex chars, 02/03 prefix)');
+    }
+    let payload;
+    try {
+        payload = JSON.parse(payloadStr);
+    }
+    catch {
+        return fail('payload must be valid JSON');
+    }
+    const { identityKey, privKey } = await loadIdentity();
+    const signature = await signRelayMessage(privKey, targetKey, type, payload);
+    const resp = await fetch(`${OVERLAY_URL}/relay/send`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            from: identityKey,
+            to: targetKey,
+            type,
+            payload,
+            signature,
+        }),
+    });
+    if (!resp.ok) {
+        const body = await resp.text();
+        return fail(`Relay send failed (${resp.status}): ${body}`);
+    }
+    const result = await resp.json();
+    return ok({ sent: true, messageId: result.id, to: targetKey, type, signed: true });
+}

package/dist/scripts/output.d.ts

@@ -0,0 +1,12 @@
+/**
+ * JSON output helpers for CLI commands.
+ * All CLI output follows the { success, data/error } wrapper format.
+ */
+/**
+ * Output a successful result and exit.
+ */
+export declare function ok<T>(data: T): never;
+/**
+ * Output an error and exit.
+ */
+export declare function fail(error: string | Error): never;

package/dist/scripts/output.js

@@ -0,0 +1,19 @@
+/**
+ * JSON output helpers for CLI commands.
+ * All CLI output follows the { success, data/error } wrapper format.
+ */
+/**
+ * Output a successful result and exit.
+ */
+export function ok(data) {
+    console.log(JSON.stringify({ success: true, data }));
+    process.exit(0);
+}
+/**
+ * Output an error and exit.
+ */
+export function fail(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.log(JSON.stringify({ success: false, error: message }));
+    process.exit(1);
+}

package/dist/scripts/overlay/discover.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Overlay discovery commands.
+ */
+/**
+ * Discover command: query the overlay for agents and services.
+ */
+export declare function cmdDiscover(args: string[]): Promise<never>;

package/dist/scripts/overlay/discover.js

@@ -0,0 +1,72 @@
+/**
+ * Overlay discovery commands.
+ */
+import { OVERLAY_URL, LOOKUP_SERVICES } from '../config.js';
+import { ok } from '../output.js';
+import { lookupOverlay, parseOverlayOutput } from './transaction.js';
+/**
+ * Discover command: query the overlay for agents and services.
+ */
+export async function cmdDiscover(args) {
+    // Parse flags
+    let serviceFilter = null;
+    let agentFilter = null;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--service' && args[i + 1])
+            serviceFilter = args[++i];
+        else if (args[i] === '--agent' && args[i + 1])
+            agentFilter = args[++i];
+    }
+    const results = { agents: [], services: [] };
+    // Query agents
+    if (!serviceFilter) {
+        try {
+            const agentQuery = agentFilter ? { name: agentFilter } : { type: 'list' };
+            const agentResult = await lookupOverlay(LOOKUP_SERVICES.AGENTS, agentQuery);
+            if (agentResult.outputs) {
+                for (const output of agentResult.outputs) {
+                    try {
+                        const { data, txid } = await parseOverlayOutput(output.beef, output.outputIndex);
+                        if (data?.type === 'identity') {
+                            results.agents.push({ ...data, txid });
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        catch (err) {
+            results.agentError = String(err);
+        }
+    }
+    // Query services
+    if (!agentFilter) {
+        try {
+            const serviceQuery = serviceFilter ? { serviceType: serviceFilter } : {};
+            const serviceResult = await lookupOverlay(LOOKUP_SERVICES.SERVICES, serviceQuery);
+            if (serviceResult.outputs) {
+                for (const output of serviceResult.outputs) {
+                    try {
+                        const { data, txid } = await parseOverlayOutput(output.beef, output.outputIndex);
+                        if (data?.type === 'service') {
+                            results.services.push({ ...data, txid });
+                        }
+                    }
+                    catch { /* ignore */ }
+                }
+            }
+        }
+        catch (err) {
+            results.serviceError = String(err);
+        }
+    }
+    return ok({
+        overlayUrl: OVERLAY_URL,
+        agentCount: results.agents.length,
+        serviceCount: results.services.length,
+        agents: results.agents,
+        services: results.services,
+        ...(results.agentError && { agentError: results.agentError }),
+        ...(results.serviceError && { serviceError: results.serviceError }),
+    });
+}

package/dist/scripts/overlay/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Overlay module exports.
+ */
+export * from './transaction.js';
+export * from './registration.js';
+export * from './services.js';
+export * from './discover.js';

package/dist/scripts/overlay/index.js

@@ -0,0 +1,7 @@
+/**
+ * Overlay module exports.
+ */
+export * from './transaction.js';
+export * from './registration.js';
+export * from './services.js';
+export * from './discover.js';

package/dist/scripts/overlay/registration.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Overlay registration commands: register, unregister.
+ *
+ * Registration creates an identity record on the overlay network with:
+ * - identityKey: compressed public key (66 hex chars)
+ * - name: agent display name
+ * - description: what the agent does
+ * - channels: contact methods (e.g., { overlay: "https://..." })
+ * - capabilities: what the agent can do (e.g., ["services", "jokes"])
+ * - timestamp: ISO 8601 registration time
+ */
+/**
+ * Register command: register this agent on the overlay network.
+ */
+export declare function cmdRegister(): Promise<never>;
+/**
+ * Unregister command: submit revocation tx to remove agent from overlay network.
+ */
+export declare function cmdUnregister(): Promise<never>;