@gholl-studio/pier-connector 0.0.3 → 0.0.5

package/openclaw.plugin.json

@@ -25,6 +25,11 @@
                 "default": "",
                 "description": "Bot Secret Key (obtain from pier-connector.gholl.com)"
             },
+            "privateKey": {
+                "type": "string",
+                "default": "",
+                "description": "(Optional/Advanced) Wallet Private Key for AI Auto-Hosting"
+            },
             "natsUrl": {
                 "type": "string",
                 "default": "wss://pier.gholl.com/nexus",
@@ -45,6 +50,11 @@
                 "default": "openclaw-workers",
                 "description": "NATS Queue Group to join for load balancing tasks"
             },
+            "agentId": {
+                "type": "string",
+                "default": "",
+                "description": "(Optional) The Agent ID to bind this connector to for context handling"
+            },
             "walletAddress": {
                 "type": "string",
                 "default": "",
@@ -65,6 +75,10 @@
             "label": "Bot Secret Key (Secret)",
             "placeholder": "sk_..."
         },
+        "privateKey": {
+            "label": "Private Key (Optional Auto-Host)",
+            "placeholder": "0x..."
+        },
         "natsUrl": {
             "label": "NATS WebSocket URL (Override)",
             "placeholder": "wss://pier.gholl.com/nexus"
@@ -81,6 +95,10 @@
             "label": "Queue Group",
             "placeholder": "openclaw-workers"
         },
+        "agentId": {
+            "label": "Bound Agent ID",
+            "placeholder": "uuid-..."
+        },
         "walletAddress": {
             "label": "Wallet Address (Rewards)",
             "placeholder": "0x..."

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.0.3",
+    "version": "0.0.5",
     "description": "OpenClaw plugin that connects to the Pier job marketplace. Automatically fetches, executes, and reports distributed tasks for rewards.",
     "type": "module",
     "main": "src/index.js",
@@ -32,6 +32,7 @@
     "license": "MIT",
     "dependencies": {
         "@nats-io/transport-node": "^3.0.0",
+        "ethers": "^6.16.0",
         "inquirer": "^13.3.0"
     },
     "peerDependencies": {

package/src/config.js

@@ -26,6 +26,12 @@ export const DEFAULTS = Object.freeze({
     /** Secret key for node authentication and heartbeats */
     SECRET_KEY: '',
 
+    /** Optional Private Key for auto-registration via Wallet Signature (Advanced) */
+    PRIVATE_KEY: '',
+
     /** Optional Wallet address to receive points/payments for completed tasks */
     WALLET_ADDRESS: '',
+
+    /** Optional Agent ID to bind tasks to, instead of creating new sessions */
+    AGENT_ID: '',
 });

package/src/index.js

@@ -13,6 +13,9 @@ import { parseJob, safeRespond, truncate } from './job-handler.js';
 import { createRequestPayload, createResultPayload, createErrorPayload } from './protocol.js';
 import { DEFAULTS } from './config.js';
 import inquirer from 'inquirer';
+import { ethers } from 'ethers';
+import fs from 'fs';
+import path from 'path';
 
 /**
  * OpenClaw plugin register function.
@@ -45,14 +48,24 @@ export default function register(api) {
             pierApiUrl: cfg.pierApiUrl || DEFAULTS.PIER_API_URL,
             nodeId: cfg.nodeId || DEFAULTS.NODE_ID,
             secretKey: cfg.secretKey || DEFAULTS.SECRET_KEY,
+            privateKey: cfg.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
             natsUrl: cfg.natsUrl || DEFAULTS.NATS_URL,
             subject: cfg.subject || DEFAULTS.PIER_SUBJECT,
             publishSubject: cfg.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
             queueGroup: cfg.queueGroup || DEFAULTS.QUEUE_GROUP,
+            agentId: cfg.agentId || DEFAULTS.AGENT_ID,
             walletAddress: cfg.walletAddress || DEFAULTS.WALLET_ADDRESS,
         };
     }
 
+    /** Runtime config caching to remember newly generated auto-credentials */
+    let runtimeConfigCache = null;
+
+    function getActiveConfig() {
+        if (runtimeConfigCache) return runtimeConfigCache;
+        return resolveConfig();
+    }
+
     /** Heartbeat timer reference */
     let heartbeatTimer = null;
 
@@ -135,8 +148,8 @@ export default function register(api) {
                         id: jobId,
                         reply: text,
                         latencyMs: elapsed ? Number(elapsed) : undefined,
-                        workerId: resolveConfig().nodeId,
-                        walletAddress: resolveConfig().walletAddress,
+                        workerId: getActiveConfig().nodeId,
+                        walletAddress: getActiveConfig().walletAddress,
                     });
 
                     safeRespond(msg, responsePayload);
@@ -162,15 +175,65 @@ export default function register(api) {
 
         start: async () => {
             const config = resolveConfig();
+            runtimeConfigCache = config;
             logger.info('[pier-connector] 🚀 Starting background service …');
 
             try {
-                // 1. Mandatory credentials check
+                // 1. Mandatory credentials check or Auto Register
                 if (!config.nodeId || !config.secretKey) {
-                    logger.warn('[pier-connector] ⚠️ Bot Node ID or Secret is missing.');
-                    logger.warn('[pier-connector]    Please run "openclaw pier setup" or go to pier-connector.gholl.com to create a bot.');
-                    connectionStatus = 'error';
-                    return;
+                    if (config.privateKey) {
+                        logger.info('[pier-connector] 🛠 No Node ID found. Executing automatic registration via Private Key...');
+                        try {
+                            const wallet = new ethers.Wallet(config.privateKey);
+                            const address = wallet.address;
+                            logger.info(`[pier-connector] 🛠 Wallet Address: ${address}`);
+
+                            const challengeRes = await fetch(`${config.pierApiUrl}/auth/challenge?wallet_address=${address}`);
+                            if (!challengeRes.ok) throw new Error("Failed to get challenge");
+                            const { challenge } = await challengeRes.json();
+
+                            const signature = await wallet.signMessage(challenge);
+
+                            const loginRes = await fetch(`${config.pierApiUrl}/auth/login`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ wallet_address: address, challenge, signature })
+                            });
+                            if (!loginRes.ok) throw new Error("Failed to login");
+                            const { api_key } = await loginRes.json();
+
+                            logger.info(`[pier-connector] 🛠 Authenticated. Registering node...`);
+
+                            const hostName = api?.getRuntimeInfo?.()?.hostname ?? 'Auto-Node';
+                            const regRes = await fetch(`${config.pierApiUrl}/nodes/register`, {
+                                method: 'POST',
+                                headers: { 
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${api_key}`
+                                },
+                                body: JSON.stringify({ wallet_address: address, name: hostName })
+                            });
+                            
+                            if (!regRes.ok) throw new Error("Failed to register node");
+                            const { id, secret_key } = await regRes.json();
+
+                            logger.info(`[pier-connector] ✔ Node registered automatically: ${id}`);
+                            config.nodeId = id;
+                            config.secretKey = secret_key;
+                            if (!config.walletAddress) {
+                                config.walletAddress = address;
+                            }
+                        } catch (err) {
+                            logger.error(`[pier-connector] ✖ Auto-registration failed: ${err.message}`);
+                            connectionStatus = 'error';
+                            return;
+                        }
+                    } else {
+                        logger.warn('[pier-connector] ⚠️ Bot Node ID or Secret is missing.');
+                        logger.warn('[pier-connector]    Please run "openclaw pier setup" or provide a privateKey for auto-hosting.');
+                        connectionStatus = 'error';
+                        return;
+                    }
                 }
 
                 connectionStatus = 'connecting';
@@ -185,7 +248,7 @@ export default function register(api) {
 
                 // 3. Start Heartbeat Timer
                 const runHeartbeat = async () => {
-                    const currentConfig = resolveConfig();
+                    const currentConfig = getActiveConfig();
                     if (!currentConfig.nodeId) return;
                     await heartbeatNode(currentConfig);
                 };
@@ -256,6 +319,7 @@ export default function register(api) {
                             accountId: 'default',
                             senderId: `pier:${job.meta?.sender ?? 'anonymous'}`,
                             text: job.task,
+                            assignedAgentId: config.agentId || undefined,
                             metadata: {
                                 pierJobId: job.id,
                                 pierNatsMsg: msg,
@@ -360,7 +424,7 @@ export default function register(api) {
                     };
                 }
 
-                const config = resolveConfig();
+                const config = getActiveConfig();
                 const timeout = params.timeoutMs || 60000;
                 
                 const taskPayload = createRequestPayload({
@@ -424,7 +488,7 @@ export default function register(api) {
         name: 'pier',
         description: 'Show Pier connector status',
         handler: () => {
-            const config = resolveConfig();
+            const config = getActiveConfig();
             const uptime = connectedAt
                 ? `${Math.round((Date.now() - connectedAt.getTime()) / 1000)}s`
                 : 'N/A';
@@ -462,58 +526,175 @@ export default function register(api) {
                     const currentConfig = resolveConfig();
                     
                     console.log('\n🚢 \x1b[1m\x1b[36mPier Connector Setup (V1.1)\x1b[0m');
-                    console.log('Please register your bot at \x1b[1m\x1b[33mhttps://pier-connector.gholl.com\x1b[0m first.\n');
-
-                    const answers = await inquirer.prompt([
-                        {
-                            type: 'input',
-                            name: 'pierApiUrl',
-                            message: 'Pier API URL:',
-                            default: currentConfig.pierApiUrl,
-                        },
-                        {
-                            type: 'input',
-                            name: 'nodeId',
-                            message: 'Bot Node ID (UUID):',
-                            default: currentConfig.nodeId,
-                        },
-                        {
-                            type: 'password',
-                            name: 'secretKey',
-                            message: 'Bot Secret Key:',
-                            default: currentConfig.secretKey,
-                        },
-                        {
-                            type: 'input',
-                            name: 'walletAddress',
-                            message: 'Your Wallet Address (for payout):',
-                            default: currentConfig.walletAddress,
-                        },
-                    ]);
+                    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;
+                    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 }
+                        ]);
+                        finalNodeId = manualAnswers.nodeId;
+                        finalSecretKey = manualAnswers.secretKey;
+                        finalWallet = manualAnswers.walletAddress;
+                        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 }
+                        ]);
+                        console.log('\n\x1b[36mRegistering your node...\x1b[0m');
+                        try {
+                            const wallet = new ethers.Wallet(autoAnswers.privateKey);
+                            console.log(`\x1b[32m✔ Loaded wallet: ${wallet.address}\x1b[0m`);
+                            finalWallet = finalWallet || wallet.address;
+                            finalPrivateKey = autoAnswers.privateKey;
+                            currentConfig.pierApiUrl = autoAnswers.pierApiUrl;
+
+                            const challengeRes = await fetch(`${currentConfig.pierApiUrl}/auth/challenge?wallet_address=${wallet.address}`);
+                            if (!challengeRes.ok) throw new Error("Failed to get challenge");
+                            const { challenge } = await challengeRes.json();
+
+                            const signature = await wallet.signMessage(challenge);
+
+                            const loginRes = await fetch(`${currentConfig.pierApiUrl}/auth/login`, {
+                                method: 'POST',
+                                headers: { 'Content-Type': 'application/json' },
+                                body: JSON.stringify({ wallet_address: wallet.address, challenge, signature })
+                            });
+                            if (!loginRes.ok) throw new Error("Failed to login");
+                            const { api_key } = await loginRes.json();
+
+                            const hostName = api?.getRuntimeInfo?.()?.hostname ?? 'Auto-Node';
+                            const regRes = await fetch(`${currentConfig.pierApiUrl}/nodes/register`, {
+                                method: 'POST',
+                                headers: { 
+                                    'Content-Type': 'application/json',
+                                    'Authorization': `Bearer ${api_key}`
+                                },
+                                body: JSON.stringify({ wallet_address: wallet.address, name: hostName })
+                            });
+                            
+                            if (!regRes.ok) throw new Error(`Failed to auto-register node (${regRes.status})`);
+                            const { id, secret_key } = await regRes.json();
+
+                            finalNodeId = id;
+                            finalSecretKey = secret_key;
+                            console.log(`\x1b[32m✔ Node registered automatically! Node ID: ${id}\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 = {
-                        plugins: {
-                            entries: {
-                                "pier-connector": {
-                                    enabled: true,
-                                    config: {
-                                        pierApiUrl: answers.pierApiUrl,
-                                        nodeId: answers.nodeId,
-                                        secretKey: answers.secretKey,
-                                        walletAddress: answers.walletAddress
-                                    }
-                                }
-                            }
-                        }
+                        pierApiUrl: currentConfig.pierApiUrl,
+                        nodeId: finalNodeId,
+                        secretKey: finalSecretKey,
+                        walletAddress: finalWallet,
+                        agentId: finalAgentId
                     };
+                    
+                    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('Currently, CLI automatic config writes depend on the framework host.');
-                    console.log('Please ensure your \x1b[1m\x1b[33mopenclaw.config.json\x1b[0m includes the following block:\n');
-                    console.log(JSON.stringify(newConfigBlock, null, 2));
-                    console.log('\nRestart OpenClaw to apply changes.');
+                    console.log('\nRestart OpenClaw (or reload plugins) to apply changes.');
                 });
         },
         { commands: ['pier'] }