@gholl-studio/pier-connector 0.2.51 → 0.3.0

package/src/index.js

@@ -1,1222 +0,0 @@
-/**
- * pier-connector — OpenClaw plugin entry point.
- *
- * Registers:
- *  1. A messaging channel ("pier") for routing NATS jobs through OpenClaw agent
- *  2. A background service that connects to NATS via WebSocket and subscribes
- *  3. A tool ("pier_publish") for publishing tasks back to Pier
- *  4. A command ("/pier") for checking connection status
- */
-
-import { PierClient, protocol } from '@gholl-studio/pier-sdk';
-const { createRequestPayload, createResultPayload, createErrorPayload } = protocol;
-import { parseJob, safeRespond, truncate } from './job-handler.js';
-import { DEFAULTS } from './config.js';
-import { jetstream, jetstreamManager, AckPolicy, DeliverPolicy } from '@nats-io/jetstream';
-import inquirer from 'inquirer';
-import fs from 'fs';
-import path from 'path';
-
-/**
- * OpenClaw plugin register function.
- *
- * @param {object} api – OpenClaw plugin API
- */
-export default function register(api) {
-    const logger = api.logger;
-
-    // ── shared state (Instances) ───────────────────────────────────
-    
-    /** @type {Map<string, any>} */
-    const instances = new Map();
-
-    /** Aggregated stats from all robots since start */
-    let totalJobsReceived = 0;
-    let totalJobsCompleted = 0;
-    let totalJobsFailed = 0;
-
-    // ── resolve plugin config ──────────────────────────────────────────
-
-    function resolveConfigs() {
-        const globalAccounts = api.runtime?.config?.channels?.['pier']?.accounts || {};
-        const pluginAccounts = api.config?.channels?.['pier']?.accounts || {};
-        const rawAccounts = { ...globalAccounts, ...pluginAccounts };
-        
-        const legacyCfg = api.config?.plugins?.entries?.['pier-connector']?.config || api.config || {};
-        
-        // If no accounts defined at all, fallback to 'default' using legacy/env config
-        if (Object.keys(rawAccounts).length === 0) {
-            logger.info(`[pier-connector] No accounts found in global or plugin config. Falling back to default.`);
-            return [{
-                accountId: 'default',
-                ...mergedCfgFrom(legacyCfg, {})
-            }];
-        }
-
-        const configs = Object.entries(rawAccounts).map(([id, account]) => ({
-            accountId: id,
-            ...mergedCfgFrom(legacyCfg, account)
-        }));
-
-        logger.info(`[pier-connector] Loaded ${configs.length} account(s): ${configs.map(c => c.accountId).join(', ')}`);
-        configs.forEach(c => {
-            if (c.agentId) logger.info(`[pier-connector] Account '${c.accountId}' has explicit agentId binding: ${c.agentId}`);
-        });
-
-        return configs;
-    }
-
-    function mergedCfgFrom(legacy, account) {
-        const merged = { ...legacy, ...account };
-        return {
-            pierApiUrl: merged.pierApiUrl || DEFAULTS.PIER_API_URL,
-            nodeId: merged.nodeId || DEFAULTS.NODE_ID,
-            secretKey: merged.secretKey || DEFAULTS.SECRET_KEY,
-            privateKey: merged.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
-            natsUrl: merged.natsUrl || DEFAULTS.NATS_URL,
-            subject: merged.subject || DEFAULTS.SUBJECT,
-            publishSubject: merged.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
-            queueGroup: merged.queueGroup || DEFAULTS.QUEUE_GROUP,
-            agentId: merged.agentId || DEFAULTS.AGENT_ID,
-            walletAddress: merged.walletAddress || DEFAULTS.WALLET_ADDRESS,
-            capabilities: merged.capabilities || ['translation', 'code-execution', 'reasoning', 'vision'],
-        };
-    }
-
-    /**
-     * PierRobot class encapsulates the connection, heartbeat, and job handling
-     * for a single robot account.
-     */
-    class PierRobot {
-        constructor(config) {
-            this.config = config;
-            this.accountId = config.accountId;
-            this.client = new PierClient({ 
-                apiUrl: config.pierApiUrl,
-                natsUrl: config.natsUrl, 
-                logger 
-            });
-            this.nc = null;
-            this.js = null;
-            this.jsm = null;
-            this.subscription = null;
-            this.heartbeatTimer = null;
-            this.connectionStatus = 'disconnected';
-            this.jobSubscriptions = new Map();
-            this.jobStopTimeouts = new Map();
-            this.activeNodeJobs = new Map();
-            this.isBusy = false;
-            this.stats = { received: 0, completed: 0, failed: 0 };
-            this.lastHeartbeatError = null;
-            this.connectedAt = null;
-        }
-
-        async init() {
-            try {
-                this.nc = await this.client.connectNats();
-                this.js = jetstream(this.nc);
-                this.jsm = await jetstreamManager(this.nc);
-                
-                this.connectedAt = new Date();
-                this.connectionStatus = 'connected';
-                
-                // Subscribe to tasks
-                await this.subscribeToTasks();
-                
-                // Start heartbeat
-                this.startHeartbeat();
-                
-                return true;
-            } catch (err) {
-                this.connectionStatus = 'error';
-                logger.error(`[pier-connector] Account ${this.accountId} failed to connect: ${err.message}`);
-                return false;
-            }
-        }
-
-        async heartbeat() {
-            if (!this.config.nodeId || !this.config.secretKey) return null;
-            try {
-                const data = await this.client.heartbeat(
-                    this.config.nodeId,
-                    this.config.secretKey,
-                    this.config.capabilities
-                );
-                this.lastHeartbeatError = null;
-                return data.nats_config || null;
-            } catch (err) {
-                this.lastHeartbeatError = err.message;
-                logger.warn(`[pier-connector][${this.accountId}] Heartbeat failed: ${err.message}`);
-                return null;
-            }
-        }
-
-        async claimJob(jobId) {
-            return await this.client.claimJob(jobId, this.config.nodeId, this.config.secretKey);
-        }
-
-    /**
-     * Routes an incoming message from Pier to the OpenClaw agent.
-     * Replaces the non-existent api.runtime.sendIncoming.
-     */
-        async receiveIncoming(inbound, jobId) {
-            if (!api.runtime?.channel?.reply) {
-                logger.error(`[pier-connector][${this.accountId}] SDK Error: api.runtime.channel.reply is not available.`);
-                return;
-            }
-
-            logger.info(`[pier-connector:trace] receiveIncoming triggered for jobId=${jobId}. accountId='${inbound.accountId}', senderId='${inbound.senderId}'`);
-
-            // 1. Resolve Global Configuration
-            // In OpenClaw V2, we need the FULL config for routing to work, but api.runtime.config is often scoped to the plugin.
-            // We search for the root config and fall back to whatever is available.
-            const rootConfig = api.rootConfig || api.runtime?.globalConfig || api.runtime?.config || {};
-            
-            // Diagnostic logging (only if we suspect it's still failing)
-            const bindingsCount = Array.isArray(rootConfig.bindings) ? rootConfig.bindings.length : 0;
-            const agentsCount = rootConfig.agents?.list ? (Array.isArray(rootConfig.agents.list) ? rootConfig.agents.list.length : Object.keys(rootConfig.agents.list).length) : 0;
-            
-            logger.info(`[pier-connector:trace] Diagnostic: rootConfig source=${api.rootConfig ? 'api.rootConfig' : (api.runtime?.globalConfig ? 'globalConfig' : 'runtime.config')}, bindings=${bindingsCount}, agents=${agentsCount}`);
-
-            // 2. Resolve Agent Route via SDK
-            const route = api.runtime.channel.routing.resolveAgentRoute({
-                cfg: rootConfig,
-                channel: 'pier',
-                account: inbound.accountId,
-                peer: { kind: 'direct', id: jobId }
-            });
-
-            logger.info(`[pier-connector:trace] resolveAgentRoute returned: route.agentId='${route?.agentId}', route.accountId='${route?.accountId}'`);
-
-            // 3. Robust Routing Decision Tree
-            let finalAgentId = null;
-            let routingSource = 'unresolved';
-
-            // A. Check explicit account-level binding in plugin local config (this.config)
-            if (this.config.agentId && this.config.agentId !== 'main' && this.config.agentId !== 'default') {
-                finalAgentId = this.config.agentId;
-                routingSource = 'plugin-local-config';
-            }
-
-            // B. Check Global Bindings (Manual Scan of rootConfig.bindings)
-            if (!finalAgentId) {
-                const bindings = Array.isArray(rootConfig.bindings) ? rootConfig.bindings : [];
-                const binding = bindings.find(b => 
-                    b.match?.channel === 'pier' && 
-                    (b.match?.accountId === inbound.accountId || b.match?.account === inbound.accountId)
-                );
-                if (binding?.agentId && binding.agentId !== 'main') {
-                    finalAgentId = binding.agentId;
-                    routingSource = 'manual-global-bindings-match';
-                }
-            }
-
-            // C. SDK Routing Result (if it actually found something non-default)
-            if (!finalAgentId && route.agentId && route.agentId !== 'main' && route.agentId !== 'default') {
-                finalAgentId = route.agentId;
-                routingSource = 'sdk-global-bindings';
-            }
-
-            // D. Name-Matching Fallback (CRITICAL: account name == agent ID)
-            // If we see account 'sunwukong', and we have an agent 'sunwukong', route there!
-            if (!finalAgentId && inbound.accountId && inbound.accountId !== 'default' && inbound.accountId !== 'main') {
-                // Check if such an agent exists in rootConfig
-                const agents = rootConfig.agents?.list || {};
-                const agentExists = Array.isArray(agents) ? agents.some(a => a.id === inbound.accountId) : !!agents[inbound.accountId];
-                
-                if (agentExists) {
-                    finalAgentId = inbound.accountId;
-                    routingSource = 'account-agent-name-match';
-                }
-            }
-
-            // E. Ultimate Fallback
-            if (!finalAgentId) {
-                finalAgentId = route.agentId || 'main'; // Use SDK result or hard default 'main'
-                routingSource = route.agentId ? 'sdk-default-fallback' : 'hardcoded-main-fallback';
-            }
-
-            logger.info(`[pier-connector] Routing account '${inbound.accountId}' -> agent '${finalAgentId}' (Source: ${routingSource})`);
-
-            const dynamicSessionKey = `pier-job-${jobId}`;
-            const metadata = this.activeNodeJobs.get(jobId);
-            let injectedPrompt = "";
-
-            if (metadata && metadata.isTargeted === false) {
-                injectedPrompt = [
-                    "=========================================",
-                    "CRITICAL DIRECTIVE - OPEN BIDDING MARKETPLACE",
-                    "=========================================",
-                    "You are an autonomous AI worker on Pier. This job currently has NO assigned worker.",
-                    "1. DO NOT directly solve the user's task or output the final answer right now.",
-                    "2. You MUST USE the \`pier_bid_task\` tool to send a pitch/bid to the employer explaining why you are best equipped to solve this.",
-                    "3. Stop executing after submitting the bid.",
-                    "4. You MUST use the Job ID provided below when calling the tool.",
-                    `Job ID: ${jobId}`,
-                    inbound.systemPrompt ? `\nEmployer Guidelines:\n${inbound.systemPrompt}` : ""
-                ].join('\n');
-            } else {
-                injectedPrompt = [
-                    "=========================================",
-                    "CRITICAL DIRECTIVE - PIER TRADING NETWORK",
-                    "=========================================",
-                    "You are an autonomous AI worker on Pier.",
-                    "1. You MUST USE the \`pier_finish_task\` tool to submit the final result when your work is complete.",
-                    "2. If you need to negotiate or clarify requirements with the employer, use \`pier_chat\`.",
-                    "3. Do not just wait in silence. Always officially finish the task if the employer's goal is met.",
-                    inbound.systemPrompt ? `\nEmployer Guidelines:\n${inbound.systemPrompt}` : ""
-                ].join('\n');
-            }
-
-            // MsgContext uses PascalCase for keys in OpenClaw V2 SDK
-            const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
-                agentId: finalAgentId, // Keep lowercase here as it's the target system ID
-                Body: inbound.text,
-                BodyForAgent: inbound.text,
-                RawBody: inbound.text,
-                From: inbound.senderId,
-                To: `pier:${jobId}`,
-                SessionKey: dynamicSessionKey,
-                AccountId: inbound.accountId, 
-                ChatType: 'direct',
-                SenderId: inbound.senderId,
-                Provider: 'pier',
-                Surface: 'pier',
-                OriginatingChannel: 'pier',
-                OriginatingTo: `pier:${jobId}`,
-                WasMentioned: true,
-                CommandAuthorized: true,
-                SystemPrompt: injectedPrompt,
-                MessageId: inbound.messageId || jobId,
-                Metadata: { 
-                    ...metadata,
-                    accountId: this.accountId,
-                    pierJobId: jobId,
-                    routingSource: routingSource
-                }
-            });
-
-            const { dispatcher, markDispatchIdle } = api.runtime.channel.reply.createReplyDispatcherWithTyping({
-                cfg: api.runtime.config,
-                agentId: finalAgentId,
-                deliver: async (payload) => {
-                    const currentMeta = this.activeNodeJobs.get(jobId);
-                    await pierChannel.outbound.sendText({
-                        text: payload.text,
-                        to: `pier:${jobId}`,
-                        metadata: { 
-                            ...currentMeta, 
-                            accountId: this.accountId,
-                            pierJobId: jobId 
-                        },
-                    });
-                }
-            });
-
-            if (api.runtime.channel.session?.recordSessionMetaFromInbound) {
-                try {
-                    const storePath = api.runtime.channel.session.resolveStorePath(api.config, dynamicSessionKey);
-                    await api.runtime.channel.session.recordSessionMetaFromInbound({
-                        storePath, sessionKey: dynamicSessionKey, ctx: ctxPayload
-                    });
-                } catch (err) {}
-            }
-
-            try {
-                await api.runtime.channel.reply.dispatchReplyFromConfig({
-                    ctx: ctxPayload, cfg: api.runtime.config, dispatcher
-                });
-            } finally {
-                markDispatchIdle();
-            }
-        }
-        async subscribeToJobMessages(jobId) {
-            if (!this.js) return;
-            
-            const chatSubject = `chat.${jobId}`;
-            const streamName = 'PIER_JOBS';
-            const nodeSlug = this.config.nodeId.replace(/[^a-zA-Z0-9]/g, '_');
-            const jobSlug = jobId.replace(/[^a-zA-Z0-9]/g, '_');
-            const durableName = `pier_chat_${nodeSlug}_${jobSlug}`;
-
-            try {
-                let consumer;
-                try {
-                    consumer = await this.js.consumers.get(streamName, durableName);
-                } catch {
-                    await this.jsm.consumers.add(streamName, {
-                        durable_name: durableName,
-                        filter_subject: chatSubject,
-                        deliver_policy: DeliverPolicy.New,
-                        ack_policy: AckPolicy.Explicit,
-                        ack_wait: 1000 * 60 * 60,
-                    });
-                    consumer = await this.js.consumers.get(streamName, durableName);
-                }
-
-                const iter = await consumer.consume();
-                this.jobSubscriptions.set(jobId, iter);
-
-                (async () => {
-                    logger.info(`[pier-connector][${this.accountId}] \u{1F442} Monitoring ${chatSubject}`);
-                    const processedMessages = new Set();
-                    for await (const msg of iter) {
-                        try {
-                            const rawMsg = new TextDecoder().decode(msg.data);
-                            let msgPayload = JSON.parse(rawMsg);
-
-                            if (msgPayload.id && processedMessages.has(msgPayload.id)) { msg.ack(); continue; }
-                            if (msgPayload.sender_id === this.config.nodeId) { msg.ack(); continue; }
-                            if (msgPayload.type === 'receipt') { msg.ack(); continue; }
-                            // Skip system_action messages — those are for the backend state machine
-                            if (msgPayload.type === 'system_action' || msgPayload.msg_type === 'system_action') { msg.ack(); continue; }
-
-                            // Send receipt
-                            try {
-                                await this.js.publish(chatSubject, new TextEncoder().encode(JSON.stringify({
-                                    type: 'receipt', msg_id: msgPayload.id, reader_id: this.config.nodeId
-                                })));
-                            } catch (err) {}
-
-                            const content = msgPayload.content;
-                            if (!content) { msg.ack(); continue; }
-
-                            logger.info(`[pier-connector][${this.accountId}] \u{1F4AC} Chat: [${jobId}] ${msgPayload.sender_id}: "${truncate(content, 40)}"`);
-                            if (msgPayload.id) processedMessages.add(msgPayload.id);
-
-                            // Only the assigned robot should process chat messages
-                            const jobMeta = this.activeNodeJobs.get(jobId);
-                            if (!jobMeta || !jobMeta.isTargeted) {
-                                msg.ack();
-                                continue;
-                            }
-
-                            msg.ack();
-
-                            logger.info(`[pier-connector:trace] NATS Chat Message received on PierRobot instance accountId='${this.accountId}'. Passing to receiveIncoming...`);
-                            await this.receiveIncoming({
-                                accountId: this.accountId,
-                                senderId: `pier:${msgPayload.sender_id}`,
-                                text: content,
-                            }, jobId);
-                        } catch (err) { logger.error(`[pier-connector] Chat err: ${err.message}`); }
-                    }
-                })();
-            } catch (err) {
-                logger.error(`[pier-connector][${this.accountId}] Failed to setup chat consumer: ${err.message}`);
-            }
-        }
-
-        async handleMessage(msg) {
-            const rawData = new TextDecoder().decode(msg.data);
-            let payload;
-            try {
-                payload = JSON.parse(rawData);
-            } catch (e) {
-                msg.ack();
-                return;
-            }
-
-            if (payload.type === 'wakeup') {
-                const { jobId } = payload;
-                if (jobId) {
-                    logger.info(`[pier-connector][${this.accountId}] ⏰ Received wakeup signal for job ${jobId}`);
-                    if (!this.jobSubscriptions.has(jobId)) {
-                        this.activeNodeJobs.set(jobId, { pierJobId: jobId, isTargeted: true });
-                        await this.subscribeToJobMessages(jobId);
-                    }
-                    msg.ack();
-                } else {
-                    msg.ack();
-                }
-                return;
-            }
-
-            if (this.isBusy) {
-                logger.debug(`[pier-connector][${this.accountId}] 🚫 Busy. Ignoring payload...`);
-                msg.nak();
-                return;
-            }
-
-            if (payload.assigned_node_id && payload.assigned_node_id !== this.config.nodeId) {
-                msg.nak();
-                return;
-            }
-
-            const jobIdToClaim = payload.id;
-            const isTargeted = !!(payload.assigned_node_id || payload.targetNodeId || payload.TargetNodeID);
-            
-            if (jobIdToClaim && isTargeted) {
-                const claimResult = await this.claimJob(jobIdToClaim);
-                if (!claimResult.ok) {
-                    if (claimResult.alreadyClaimed) msg.ack();
-                    else msg.nak();
-                    return;
-                }
-            }
-
-            this.isBusy = true;
-            msg.ack();
-
-            this.stats.received++;
-            totalJobsReceived++;
-
-            const parsed = parseJob(msg, logger);
-            if (!parsed.ok) {
-                this.stats.failed++;
-                totalJobsFailed++;
-                this.isBusy = false;
-                logger.error(`[pier-connector][${this.accountId}] Job parse error: ${parsed.error}`);
-                safeRespond(msg, createErrorPayload({
-                    id: jobIdToClaim || 'unknown',
-                    errorCode: 'PARSE_ERROR',
-                    errorMessage: parsed.error,
-                    workerId: this.config.nodeId,
-                    walletAddress: this.config.walletAddress,
-                }));
-                return;
-            }
-
-            const { job } = parsed;
-            const senderCore = job.meta?.sender ?? 'anonymous';
-            
-            this.activeNodeJobs.set(job.id, {
-                pierJobId: job.id,
-                pierNatsMsg: msg,
-                pierStartTime: performance.now(),
-                pierMeta: job.meta,
-                isRealtimeMsg: false,
-                isTargeted: isTargeted
-            });
-
-            let finalText = job.task;
-            if (!isTargeted) {
-                finalText = `【PIER MARKETPLACE OPEN JOB】\nJob ID: ${job.id}\nTask: ${job.task}\n\n=== CRITICAL ===\nYou MUST use \`pier_bid_task\` to bid. Do not solve directly.`;
-            } else {
-                // Only subscribe to chat for targeted/assigned jobs
-                await this.subscribeToJobMessages(job.id);
-            }
-
-            logger.info(`[pier-connector:trace] NATS Marketplace Job received on PierRobot instance accountId='${this.accountId}'. Passing to receiveIncoming...`);
-            await this.receiveIncoming({
-                accountId: this.accountId,
-                senderId: `pier:${senderCore}`,
-                text: finalText,
-            }, job.id);
-
-            this.isBusy = false;
-        }
-
-        async setupMarketplaceConsumer(streamName, subjectName, durableName) {
-            try {
-                let consumer;
-                try {
-                    consumer = await this.js.consumers.get(streamName, durableName);
-                } catch {
-                    await this.jsm.consumers.add(streamName, {
-                        durable_name: durableName,
-                        filter_subject: subjectName,
-                        deliver_policy: DeliverPolicy.New,
-                        ack_policy: AckPolicy.Explicit,
-                    });
-                    consumer = await this.js.consumers.get(streamName, durableName);
-                }
-
-                const iter = await consumer.consume();
-                this.subscription = iter;
-                
-                (async () => {
-                    for await (const msg of iter) {
-                        await this.handleMessage(msg);
-                    }
-                })().catch(err => {
-                    logger.error(`[pier-connector][${this.accountId}] Consumer error: ${err.message}`);
-                });
-            } catch (err) {
-                logger.error(`[pier-connector][${this.accountId}] Setup failed: ${err.message}`);
-                throw err;
-            }
-        }
-
-        async autoRegister() {
-            const hostName = `${api?.getRuntimeInfo?.()?.hostname ?? 'Auto'}-${this.accountId}`;
-            const { nodeId, secretKey } = await this.client.autoRegister(this.config.privateKey, hostName);
-            this.config.nodeId = nodeId;
-            this.config.secretKey = secretKey;
-        }
-
-        async start() {
-            this.connectionStatus = 'connecting';
-            try {
-                if (!this.config.nodeId && this.config.privateKey) await this.autoRegister();
-                const natsConfig = await this.heartbeat();
-                if (!natsConfig) throw new Error('No NATS config');
-                if (natsConfig.url) {
-                    // Update SDK NATS client with latest URL from heartbeat
-                    this.client.nats.url = natsConfig.url;
-                }
-                
-                this.nc = await this.client.connectNats();
-                this.js = jetstream(this.nc);
-                this.jsm = await jetstreamManager(this.nc);
-                this.connectionStatus = 'connected';
-                this.connectedAt = new Date();
-
-                const streamName = 'PIER_JOBS';
-                const durableNameMarket = `pier_market_${this.config.nodeId.replace(/-/g, '_')}`;
-                const durableNameDirect = `pier_node_${this.config.nodeId.replace(/-/g, '_')}`;
-
-                await this.setupMarketplaceConsumer(streamName, this.config.subject, durableNameMarket);
-                await this.setupMarketplaceConsumer(streamName, `jobs.node.${this.config.nodeId}`, durableNameDirect);
-
-                this.heartbeatTimer = setInterval(() => this.heartbeat(), 60000);
-            } catch (err) {
-                this.connectionStatus = 'error';
-                logger.error(`[pier-connector][${this.accountId}] Start failed: ${err.message}`);
-            }
-        }
-
-        async stop() {
-            if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-            if (this.nc) await this.client.drainNats();
-            this.connectionStatus = 'disconnected';
-        }
-    }
-
-    // ── 1. Register messaging channel ──────────────────────────────────
-
-    const pierChannel = {
-        id: 'pier',
-
-        meta: {
-            id: 'pier',
-            label: 'Pier',
-            selectionLabel: 'Pier (NATS Job Marketplace)',
-            docsPath: '/plugins/pier-connector',
-            blurb: 'Accept and publish tasks on the Pier job marketplace via NATS.',
-            aliases: ['pier-connector'],
-        },
-
-        id: 'pier',
-        
-        capabilities: {
-            chatTypes: ['direct'],
-        },
-
-        config: {
-            listAccountIds: (cfg) => Object.keys(cfg.channels?.pier?.accounts ?? {}),
-            resolveAccount: (cfg, accountId) => cfg.channels?.pier?.accounts?.[accountId ?? 'default'] ?? {
-                accountId: accountId ?? 'default',
-                enabled: true,
-            },
-            isConfigured: (account) => Boolean(account.nodeId && account.secretKey) || Boolean(account.privateKey),
-        },
-        
-        setup: {
-            applyAccountConfig: ({ cfg, accountId, input }) => {
-                const draft = structuredClone(cfg);
-                draft.channels = draft.channels || {};
-                draft.channels.pier = draft.channels.pier || {};
-                draft.channels.pier.accounts = draft.channels.pier.accounts || {};
-                
-                const acct = draft.channels.pier.accounts[accountId] || { enabled: true };
-                
-                if (input.token) {
-                    const parts = input.token.split(':');
-                    if (parts.length >= 2) {
-                        acct.nodeId = parts[0];
-                        acct.secretKey = parts.slice(1).join(':');
-                    } else {
-                        // fallback if user just pasted one string
-                        acct.nodeId = parts[0];
-                    }
-                }
-                
-                draft.channels.pier.accounts[accountId] = acct;
-                return draft;
-            }
-        },
-
-        // Note: login is now moved to top-level of api.registerChannel
-        
-        outbound: {
-            deliveryMode: 'direct',
-
-            sendText: async (ctx) => {
-                const text = ctx.text;
-                let metadata = ctx.metadata;
-                const accountId = metadata?.accountId || 'default';
-                const robot = instances.get(accountId);
-
-                logger.info(`[pier-connector][${accountId}] 📤 Agent sending reply: "${truncate(text, 40)}" (To: ${ctx.to})`);
-
-                if (!robot) {
-                    logger.error(`[pier-connector] ✖ No robot instance found for account ${accountId}`);
-                    return { ok: false, error: 'Robot instance not found' };
-                }
-
-                if (!metadata && ctx.to) {
-                    const toId = ctx.to.replace(/^pier:/, '');
-                    metadata = robot.activeNodeJobs.get(toId);
-                }
-                
-                const jobId = metadata?.pierJobId;
-
-                if (jobId && robot.js) {
-                    try {
-                        const replySubject = `chat.${jobId}`;
-                        
-                        // Only publish replies for jobs assigned to this robot
-                        if (!metadata?.isTargeted) {
-                            logger.debug(`[pier-connector][${accountId}] 🫨 Suppressing reply for non-assigned job ${jobId}`);
-                        } else {
-                            const chatPayload = {
-                                id: (typeof crypto !== 'undefined' && crypto.randomUUID) ? crypto.randomUUID() : (Math.random().toString(36).substring(2) + Date.now().toString(36)),
-                                job_id: jobId,
-                                sender_id: robot.config.nodeId || 'anonymous',
-                                sender_name: accountId,
-                                sender_type: 'node',
-                                content: text,
-                                created_at: new Date().toISOString(),
-                                auth_token: robot.config.secretKey
-                            };
-                            
-                            await robot.js.publish(replySubject, new TextEncoder().encode(JSON.stringify(chatPayload)));
-                            logger.info(`[pier-connector][${accountId}] 💬 Agent reply published to NATS for job ${jobId} (Subject: ${replySubject})`);
-                        }
-                    } catch (err) {
-                        logger.error(`[pier-connector][${accountId}] Failed to publish reply: ${err.message}`);
-                    }
-
-                    // Handle listener timeout
-                    if (robot.jobSubscriptions.has(jobId)) {
-                        if (robot.jobStopTimeouts.has(jobId)) clearTimeout(robot.jobStopTimeouts.get(jobId));
-                        
-                        const timeout = setTimeout(() => {
-                            const sub = robot.jobSubscriptions.get(jobId);
-                            if (sub) {
-                                logger.info(`[pier-connector][${accountId}] \u{1F6D1} Stopping listener for job ${jobId} (inactivity)`);
-                                sub.stop();
-                                robot.jobSubscriptions.delete(jobId);
-                                robot.jobStopTimeouts.delete(jobId);
-                            }
-                        }, 3600000); // 1 hour
-                        robot.jobStopTimeouts.set(jobId, timeout);
-                    }
-                }
-
-                return { ok: true };
-            },
-        },
-
-        status: {
-            defaultRuntime: {
-                accountId: 'default',
-                running: false,
-                connected: false,
-            },
-            buildAccountSnapshot: ({ account }) => {
-                const robot = instances.get(account.accountId);
-                return {
-                    accountId: account.accountId,
-                    name: account.name || `Robot ${account.accountId}`,
-                    enabled: account.enabled,
-                    configured: Boolean(account.nodeId && account.secretKey) || Boolean(account.privateKey),
-                    running: robot ? (robot.connectionStatus === 'connected' || robot.connectionStatus === 'connecting') : false,
-                    connected: robot ? (robot.connectionStatus === 'connected' && !robot.lastHeartbeatError) : false,
-                    lastError: robot?.lastHeartbeatError || null,
-                };
-            }
-        },
-    };
-
-    api.registerChannel({ 
-        id: 'pier',
-        plugin: pierChannel,
-        login: {
-            handler: async () => {
-                console.log('\n🚢 \x1b[1m\x1b[36mPier Channel Login\x1b[0m');
-                
-                const answers = await inquirer.prompt([
-                    { 
-                        type: 'input', 
-                        name: 'accountId', 
-                        message: 'Account Name (e.g., sunwukong, jolin):', 
-                        default: 'default',
-                        validate: (input) => input.trim().length > 0 || 'Account name is required'
-                    },
-                    { 
-                        type: 'input', 
-                        name: 'pierApiUrl', 
-                        message: 'Pier API URL:', 
-                        default: DEFAULTS.PIER_API_URL 
-                    },
-                    { 
-                        type: 'input', 
-                        name: 'nodeId', 
-                        message: 'Bot Node ID (UUID):',
-                        validate: (input) => input.trim().length > 0 || 'Node ID is required'
-                    },
-                    { 
-                        type: 'password', 
-                        name: 'secretKey', 
-                        message: 'Bot Secret Key:',
-                        validate: (input) => input.trim().length > 0 || 'Secret Key is required'
-                    },
-                ]);
-
-                console.log('\n\x1b[36mVerifying connection...\x1b[0m');
-                try {
-                    const tempClient = new PierClient({ apiUrl: answers.pierApiUrl });
-                    await tempClient.heartbeat(answers.nodeId, answers.secretKey);
-                    
-                    console.log('\x1b[32m✔ Verified successfully!\x1b[0m');
-                    
-                    return {
-                        accountId: answers.accountId,
-                        config: {
-                            enabled: true,
-                            pierApiUrl: answers.pierApiUrl,
-                            nodeId: answers.nodeId,
-                            secretKey: answers.secretKey
-                        }
-                    };
-                } catch (err) {
-                    throw new Error(`Failed to verify Pier credentials: ${err.message}`);
-                }
-            }
-        }
-    });
-
-    // ── 2. Register background service ─────────────────────────────────
-
-    api.registerService({
-        id: 'pier-connector',
-
-        start: async () => {
-            const configs = resolveConfigs();
-            logger.info(`[pier-connector] 🚀 Starting background service for ${configs.length} robots …`);
-
-            for (const config of configs) {
-                try {
-                    const robot = new PierRobot(config);
-                    instances.set(config.accountId, robot);
-                    await robot.start();
-                } catch (err) {
-                    logger.error(`[pier-connector] ✖ Failed to start robot ${config.accountId}: ${err.message}`);
-                }
-            }
-        },
-
-        stop: async () => {
-            logger.info('[pier-connector] 🛑 Stopping all robots …');
-            for (const [id, robot] of instances) {
-                try {
-                    await robot.stop();
-                } catch (err) {
-                    logger.error(`[pier-connector] ✖ Error stopping robot ${id}: ${err.message}`);
-                }
-            }
-            instances.clear();
-            logger.info('[pier-connector] ✔ All robots stopped');
-        },
-    });
-
-    // ── 3. Register pier_publish tool ──────────────────────────────────
-
-    api.registerTool(
-        {
-            name: 'pier_publish',
-            description: 'Publish a task to the Pier job marketplace.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    task: { type: 'string', description: 'The task description' },
-                    accountId: { type: 'string', description: 'Account to use (default: "default")' },
-                    meta: { type: 'object' },
-                    timeoutMs: { type: 'number' },
-                },
-                required: ['task'],
-            },
-
-            async execute(_id, params) {
-                const accountId = params.accountId || 'default';
-                const robot = instances.get(accountId) || instances.values().next().value;
-                if (!robot || robot.connectionStatus !== 'connected') {
-                    return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: 'Robot not connected' }) }] };
-                }
-
-                const timeout = params.timeoutMs || 60000;
-                const taskPayload = createRequestPayload({ task: params.task, timeoutMs: timeout, meta: params.meta });
-
-                try {
-                    const reply = await robot.nc.request(robot.config.publishSubject, new TextEncoder().encode(JSON.stringify(taskPayload)), { timeout });
-                    const resultData = JSON.parse(new TextDecoder().decode(reply.data));
-                    return { content: [{ type: 'text', text: JSON.stringify({ ok: true, taskId: taskPayload.id, result: resultData }) }] };
-                } catch (err) {
-                    return { content: [{ type: 'text', text: JSON.stringify({ ok: false, error: err.message }) }] };
-                }
-            },
-        },
-        { optional: true },
-    );
-
-    api.registerTool(
-        {
-            name: 'pier_chat',
-            description: 'Send a message to the employer regarding a specific job.',
-            parameters: {
-                type: 'object',
-                properties: {
-                    jobId: { type: 'string' },
-                    text: { type: 'string' },
-                    accountId: { type: 'string' }
-                },
-                required: ['jobId', 'text']
-            },
-            async execute(_id, params, ctx) {
-                const accountId = params.accountId || 'default';
-                logger.info(`[pier-connector] 🛠️ Tool called: pier_chat | jobId=${params.jobId} | accountId=${accountId}`);
-                const robot = instances.get(accountId) || instances.values().next().value;
-                if (!robot || robot.connectionStatus !== 'connected') {
-                    return { content: [{ type: 'text', text: 'Error: Robot not connected' }] };
-                }
-
-                try {
-                    const subject = `chat.${params.jobId}`;
-                    let metadata = robot.activeNodeJobs.get(params.jobId);
-                    
-                    if (!metadata && ctx.to) {
-                        const toId = ctx.to.replace(/^pier:/, '');
-                        metadata = robot.activeNodeJobs.get(toId);
-                    }
-                    
-                    const jobId = metadata?.pierJobId || params.jobId;
-
-                    const payload = {
-                        id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                        job_id: jobId,
-                        sender_id: robot.config.nodeId,
-                        sender_name: accountId,
-                        sender_type: 'node',
-                        content: params.text,
-                        created_at: new Date().toISOString(),
-                        auth_token: robot.config.secretKey
-                    };
-
-                    await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
-                    return { content: [{ type: 'text', text: 'Message sent' }] };
-                } catch (err) {
-                    return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
-                }
-            }
-        },
-        { optional: true }
-    );
-
-    // ── V2 System Action Tools ────────────────────────────────────────
-
-    const registerSystemActionTool = (name, description, action, extraParams, userRole = 'node') => {
-        api.registerTool({
-            name,
-            description,
-            parameters: {
-                type: 'object',
-                properties: {
-                    jobId: { type: 'string', description: 'The ID of the job/chat session' },
-                    accountId: { type: 'string' },
-                    ...extraParams
-                },
-                required: ['jobId', ...Object.keys(extraParams)]
-            },
-            async execute(_id, params) {
-                const accountId = params.accountId || 'default';
-                const robot = instances.get(accountId) || instances.values().next().value;
-                if (!robot || robot.connectionStatus !== 'connected') {
-                    return { content: [{ type: 'text', text: 'Error: Robot not connected' }] };
-                }
-
-                try {
-                    const subject = `chat.${params.jobId}`;
-                    const { jobId, accountId: _, ...payload } = params;
-
-                    const msgData = {
-                        id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                        job_id: params.jobId,
-                        sender_id: userRole === 'user' ? 'user_' + robot.config.nodeId : robot.config.nodeId, 
-                        sender_type: userRole,
-                        content: JSON.stringify({ type: 'system_action', action, payload }),
-                        created_at: new Date().toISOString(),
-                        auth_token: robot.config.secretKey,
-                        type: 'system_action',
-                        action: action
-                    };
-
-                    await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(msgData)));
-                    return { content: [{ type: 'text', text: `${action} executed successfully` }] };
-                } catch (err) {
-                    return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
-                }
-            }
-        }, { optional: true });
-    };
-
-    // For Node (Worker)
-    registerSystemActionTool('pier_bid_task', 'Bid on an open marketplace task to offer your services to the employer', 'task_bid', { message: { type: 'string', description: 'Your pitch explaining why you are a good fit for this task' } });
-    registerSystemActionTool('pier_accept_task', 'Accept an offered task from the employer in the current chat', 'task_accept', {});
-    registerSystemActionTool('pier_finish_task', 'Submit the final result for a task', 'task_submit', { result: { type: 'string', description: 'The final result or file links' } });
-
-    // For User (Employer Robot) - Spoofed identity using Node's config for A2A testing
-    registerSystemActionTool('pier_propose_task', 'Offer a task to a node with a specific price', 'task_offer', {
-        price: { type: 'number', description: 'The price in PIER tokens to offer' },
-        description: { type: 'string', description: 'The formal task description' }
-    }, 'user');
-    
-    registerSystemActionTool('pier_rate_task', 'Rate the node after completion', 'task_rate', {
-        score: { type: 'number', description: 'Rating from 1 to 5' },
-        comment: { type: 'string', description: 'A short review' }
-    }, 'user');
-
-    registerSystemActionTool('pier_reject_task', 'Reject an offered task from the employer in the current chat', 'task_reject', {
-        reason: { type: 'string', description: 'Reason for rejection' }
-    });
-
-    registerSystemActionTool('pier_fail_task', 'Report that the task has failed during execution', 'task_error', {
-        error: { type: 'string', description: 'Description of the error' }
-    });
-    
-    registerSystemActionTool('pier_cancel_task', 'Cancel a previously proposed task', 'task_cancel', {
-        reason: { type: 'string', description: 'Reason for cancellation' }
-    }, 'user');
-
-    api.registerTool({
-        name: 'pier_get_profile',
-        description: 'Get the current Pier profile, balance, and node stats.',
-        parameters: {
-            type: 'object',
-            properties: {
-                accountId: { type: 'string' }
-            }
-        },
-        async execute(_id, params) {
-            const accountId = params.accountId || 'default';
-            const robot = instances.get(accountId) || instances.values().next().value;
-            if (!robot) return { content: [{ type: 'text', text: 'Error: Robot not found' }] };
-
-            try {
-                const profile = await robot.client.getUserProfile(robot.config.secretKey);
-                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }] };
-            } catch (err) {
-                return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
-            }
-        }
-    }, { optional: true });
-
-    // ── 4. Register /pier status command ───────────────────────────────
-
-    api.registerCommand({
-        name: 'pier',
-        description: 'Show Pier connector status',
-        handler: () => {
-            if (instances.size === 0) return { text: 'No Pier robots active.' };
-
-            const lines = ['**Pier Connector Status**'];
-            for (const [id, robot] of instances) {
-                const uptime = robot.connectedAt
-                    ? `${Math.round((Date.now() - robot.connectedAt.getTime()) / 1000)}s`
-                    : 'N/A';
-                
-                lines.push(`\n**Account: ${id}**`);
-                lines.push(`• Connection: ${robot.connectionStatus}`);
-                lines.push(`• Node ID: ${robot.config.nodeId || 'N/A'}`);
-                lines.push(`• Uptime: ${uptime}`);
-                lines.push(`• Jobs: ${robot.stats.received} received, ${robot.stats.completed} completed, ${robot.stats.failed} failed`);
-                if (robot.lastHeartbeatError) {
-                    lines.push(`• \x1b[31mHeartbeat Error: ${robot.lastHeartbeatError}\x1b[0m`);
-                } else {
-                    lines.push(`• Heartbeat: OK`);
-                }
-            }
-            
-            lines.push(`\n**Global Stats:** ${totalJobsReceived} total jobs received`);
-
-            return { text: lines.join('\n') };
-        },
-    });
-
-    // ── 6. Register CLI Setup Command ──────────────────────────────────
-
-    api.registerCli(
-        ({ program }) => {
-            // Find or create the 'pier' command namespace to avoid root conflicts
-            let pier = program.commands.find(c => c.name() === 'pier');
-            if (!pier) {
-                pier = program.command('pier').description('Pier connector commands');
-            }
-
-            pier
-                .command('setup')
-                .description('Interactively configure the Pier connector settings')
-                .action(async () => {
-                    const currentConfig = resolveConfig();
-                    
-                    console.log('\n🚢 \x1b[1m\x1b[36mPier Connector Setup (V1.1)\x1b[0m');
-                    console.log('You can register manually or let the Auto-Host (Advanced) feature do it for you using a Wallet Private Key.\n');
-
-                    let setupMethod = 'manual';
-                    try {
-                        const answer = await inquirer.prompt([
-                            {
-                                type: 'list',
-                                name: 'method',
-                                message: 'How would you like to configure your node credentials?',
-                                choices: [
-                                    { name: 'Manual Entry (Recommended) - I have a Node ID and Secret Key', value: 'manual' },
-                                    { name: 'Auto-Host (Advanced) - Register automatically using my Wallet Private Key', value: 'auto' }
-                                ],
-                                default: 'manual'
-                            }
-                        ]);
-                        if (answer.method) {
-                            setupMethod = answer.method;
-                        }
-                    } catch (err) {
-                        console.log('\n\x1b[33mFalling back to Manual Entry mode due to terminal configuration.\x1b[0m');
-                        setupMethod = 'manual';
-                    }
-
-                    let finalNodeId = currentConfig.nodeId;
-                    let finalSecretKey = currentConfig.secretKey;
-                    let finalPrivateKey = currentConfig.privateKey;
-                    let finalWallet = currentConfig.walletAddress;
-
-                    if (setupMethod === 'manual') {
-                        const manualAnswers = await inquirer.prompt([
-                            { type: 'input', name: 'pierApiUrl', message: 'Pier API URL:', default: currentConfig.pierApiUrl },
-                            { type: 'input', name: 'nodeId', message: 'Bot Node ID (UUID):', default: finalNodeId },
-                            { type: 'password', name: 'secretKey', message: 'Bot Secret Key:', default: finalSecretKey },
-                            { type: 'input', name: 'walletAddress', message: 'Your Wallet Address (for payout):', default: finalWallet },
-                            { type: 'input', name: 'capabilities', message: 'Capabilities (comma-separated):', default: (currentConfig.capabilities || []).join(', ') }
-                        ]);
-                        finalNodeId = manualAnswers.nodeId;
-                        finalSecretKey = manualAnswers.secretKey;
-                        finalWallet = manualAnswers.walletAddress;
-                        currentConfig.capabilities = manualAnswers.capabilities ? manualAnswers.capabilities.split(',').map(s => s.trim()) : currentConfig.capabilities;
-                        currentConfig.pierApiUrl = manualAnswers.pierApiUrl;
-                    } else if (setupMethod === 'auto') {
-                        const autoAnswers = await inquirer.prompt([
-                            { type: 'input', name: 'pierApiUrl', message: 'Pier API URL:', default: currentConfig.pierApiUrl },
-                            { type: 'password', name: 'privateKey', message: 'Your Wallet Private Key (Hex, 0x...):', default: finalPrivateKey },
-                            { type: 'input', name: 'capabilities', message: 'Capabilities (comma-separated):', default: (currentConfig.capabilities || []).join(', ') }
-                        ]);
-                        console.log('\n\x1b[36mRegistering your node...\x1b[0m');
-                        try {
-                            const tempClient = new PierClient({ apiUrl: autoAnswers.pierApiUrl });
-                            const hostName = api?.getRuntimeInfo?.()?.hostname ?? 'Auto-Node';
-                            
-                            const { nodeId, secretKey, walletAddress } = await tempClient.autoRegister(autoAnswers.privateKey, hostName);
-
-                            finalWallet = finalWallet || walletAddress;
-                            finalPrivateKey = autoAnswers.privateKey;
-                            currentConfig.pierApiUrl = autoAnswers.pierApiUrl;
-                            currentConfig.capabilities = autoAnswers.capabilities ? autoAnswers.capabilities.split(',').map(s => s.trim()) : currentConfig.capabilities;
-                            finalNodeId = nodeId;
-                            finalSecretKey = secretKey;
-
-                            console.log(`\x1b[32m✔ Node registered automatically! Node ID: ${nodeId}\x1b[0m`);
-                        } catch (err) {
-                            console.error(`\x1b[31m✖ Failed to auto-register: ${err.message}\x1b[0m`);
-                            return; // Stop setup
-                        }
-                    }
-
-                    // ── Select Agent Binding ──
-                    let finalAgentId = currentConfig.agentId;
-                    try {
-                        let agentsInfo = [];
-                        if (api.runtime && typeof api.runtime.getAgents === 'function') {
-                            const agentsMap = await api.runtime.getAgents();
-                            if (agentsMap) {
-                                agentsInfo = Object.entries(agentsMap).map(([id, info]) => ({
-                                    name: `${info.name || 'Unnamed Agent'} (${id})`,
-                                    value: id
-                                }));
-                            }
-                        }
-
-                        if (agentsInfo.length > 0) {
-                            agentsInfo.unshift({ name: 'None (Default Routing)', value: '' });
-                            const agentAnswer = await inquirer.prompt([
-                                {
-                                    type: 'list',
-                                    name: 'agentId',
-                                    message: 'Select an Agent to bind for processing these tasks:',
-                                    choices: agentsInfo,
-                                    default: finalAgentId || ''
-                                }
-                            ]);
-                            finalAgentId = agentAnswer.agentId;
-                        }
-                    } catch (err) {
-                        logger.warn(`Could not load agents list: ${err.message}`);
-                    }
-
-                    // Determine how to save.
-                    console.log('\n✅ \x1b[32mConfiguration Captured!\x1b[0m\n');
-                    
-                    const newConfigBlock = {
-                        pierApiUrl: currentConfig.pierApiUrl,
-                        nodeId: finalNodeId,
-                        secretKey: finalSecretKey,
-                        walletAddress: finalWallet,
-                        agentId: finalAgentId,
-                        capabilities: currentConfig.capabilities
-                    };
-                    
-                    if (setupMethod === 'auto') {
-                        newConfigBlock.privateKey = finalPrivateKey;
-                        console.log('\x1b[33mNote: Private Key is included for future automatic reconnects.\x1b[0m');
-                    }
-
-                    // Write to openclaw.json
-                    try {
-                        const cwd = process.cwd();
-                        const configPath = path.join(cwd, 'openclaw.json');
-                        let existingConfig = {};
-                        if (fs.existsSync(configPath)) {
-                            const raw = fs.readFileSync(configPath, 'utf8');
-                            existingConfig = JSON.parse(raw);
-                        }
-
-                        if (!existingConfig.plugins) existingConfig.plugins = {};
-                        if (!existingConfig.plugins.entries) existingConfig.plugins.entries = {};
-                        if (!existingConfig.plugins.entries['pier-connector']) {
-                            existingConfig.plugins.entries['pier-connector'] = { enabled: true };
-                        }
-                        
-                        existingConfig.plugins.entries['pier-connector'].config = {
-                            ...(existingConfig.plugins.entries['pier-connector'].config || {}),
-                            ...newConfigBlock
-                        };
-
-                        fs.writeFileSync(configPath, JSON.stringify(existingConfig, null, 2), 'utf8');
-                        console.log(`\x1b[32m✔ Successfully wrote configuration to ${configPath}\x1b[0m`);
-                    } catch (err) {
-                        console.error(`\x1b[31m✖ Failed to write to openclaw.json automatically: ${err.message}\x1b[0m`);
-                        console.log('Please ensure your \x1b[1m\x1b[33mopenclaw.json\x1b[0m includes the following block in plugins.entries:\n');
-                        console.log(JSON.stringify({
-                            "pier-connector": {
-                                enabled: true,
-                                config: newConfigBlock
-                            }
-                        }, null, 2));
-                    }
-
-                    console.log('\nRestart OpenClaw (or reload plugins) to apply changes.');
-                });
-        },
-        { commands: ['pier'] }
-    );
-
-    logger.info('[pier-connector] Plugin registered');
-}