@gholl-studio/pier-connector 0.0.7 → 0.0.9

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.0.7",
+    "version": "0.0.9",
     "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",
@@ -31,9 +31,11 @@
     ],
     "license": "MIT",
     "dependencies": {
+        "@nats-io/jetstream": "^3.3.1",
         "@nats-io/transport-node": "^3.0.0",
         "ethers": "^6.16.0",
-        "inquirer": "^13.3.0"
+        "inquirer": "^13.3.0",
+        "pako": "^2.1.0"
     },
     "peerDependencies": {
         "openclaw": ">=2.0.0"

package/src/compression.js

@@ -0,0 +1,12 @@
+/**
+ * Simple pass-through utility for messaging.
+ * Compression was removed for simplicity and ease of debugging.
+ */
+
+export function compress(text) {
+  return text;
+}
+
+export function decompress(content) {
+  return content;
+}

package/src/index.js

@@ -12,6 +12,7 @@ import { createNatsConnection, drainConnection } from './nats-client.js';
 import { parseJob, safeRespond, truncate } from './job-handler.js';
 import { createRequestPayload, createResultPayload, createErrorPayload } from './protocol.js';
 import { DEFAULTS } from './config.js';
+import { jetstream, jetstreamManager, AckPolicy, DeliverPolicy } from '@nats-io/jetstream';
 import inquirer from 'inquirer';
 import { ethers } from 'ethers';
 import fs from 'fs';
@@ -29,6 +30,12 @@ export default function register(api) {
 
     /** @type {import('@nats-io/transport-node').NatsConnection | null} */
     let nc = null;
+    
+    /** @type {import('@nats-io/transport-node').JetStreamContext | null} */
+    let js = null;
+    
+    /** @type {any | null} */
+    let jsm = null;
 
     /** @type {import('@nats-io/transport-node').Subscription | null} */
     let subscription = null;
@@ -39,6 +46,10 @@ export default function register(api) {
     let jobsCompleted = 0;
     let jobsFailed = 0;
     let connectedAt = null;
+    
+    /** @type {Map<string, import('@nats-io/transport-node').Subscription>} */
+    const jobSubscriptions = new Map();
+const jobStopTimeouts = new Map();
 
     // ── resolve plugin config ──────────────────────────────────────────
 
@@ -59,7 +70,7 @@ export default function register(api) {
             secretKey: mergedCfg.secretKey || DEFAULTS.SECRET_KEY,
             privateKey: mergedCfg.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
             natsUrl: mergedCfg.natsUrl || DEFAULTS.NATS_URL,
-            subject: mergedCfg.subject || DEFAULTS.PIER_SUBJECT,
+            subject: mergedCfg.subject || DEFAULTS.SUBJECT,
             publishSubject: mergedCfg.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
             queueGroup: mergedCfg.queueGroup || DEFAULTS.QUEUE_GROUP,
             agentId: mergedCfg.agentId || DEFAULTS.AGENT_ID,
@@ -186,13 +197,48 @@ export default function register(api) {
                         walletAddress: getActiveConfig().walletAddress,
                     });
 
-                    safeRespond(msg, responsePayload);
+                    if (isRealtimeMsg && js) {
+                        try {
+                            const config = getActiveConfig();
+                            const replySubject = `jobs.job.${jobId}.msg`;
+                            await js.publish(replySubject, new TextEncoder().encode(JSON.stringify({
+                                sender_id: config.nodeId,
+                                content: text,
+                                created_at: new Date().toISOString()
+                            })));
+                            logger.info(`[pier-connector] 💬 Published agent reply to realtime chat for job ${jobId}`);
+                        } catch (err) {
+                            logger.error(`[pier-connector] Failed to send realtime reply: ${err.message}`);
+                        }
+                    } else {
+                        safeRespond(msg, responsePayload);
 
-                    jobsCompleted++;
-                    logger.info(
-                        `[pier-connector] ✔ Job ${jobId} completed` +
-                        (elapsed ? ` — latency: ${elapsed}ms` : ''),
-                    );
+                        jobsCompleted++;
+                        logger.info(
+                            `[pier-connector] ✔ Job ${jobId} completed` +
+                            (elapsed ? ` — latency: ${elapsed}ms` : ''),
+                        );
+                    }
+
+                    // Delayed stop for job-specific message listener
+                    // This allows for follow-up chat messages even after a job is "completed"
+                    if (jobSubscriptions.has(jobId)) {
+                        if (jobStopTimeouts.has(jobId)) {
+                            clearTimeout(jobStopTimeouts.get(jobId));
+                        }
+                        
+                        const timeout = setTimeout(() => {
+                            const sub = jobSubscriptions.get(jobId);
+                            if (sub) {
+                                logger.info(`[pier-connector] 🛑 Stopping listener for job ${jobId} (inactivity)`);
+                                sub.stop();
+                                jobSubscriptions.delete(jobId);
+                                jobStopTimeouts.delete(jobId);
+                            }
+                        }, 60000); // 60s grace period
+                        
+                        jobStopTimeouts.set(jobId, timeout);
+                    }
                 }
 
                 return { ok: true };
@@ -290,6 +336,8 @@ export default function register(api) {
 
                 // 4. Connect to NATS
                 nc = await createNatsConnection(activeNatsUrl, logger);
+                js = jetstream(nc);
+                jsm = await jetstreamManager(nc);
                 connectionStatus = 'connected';
                 connectedAt = new Date();
 
@@ -297,18 +345,140 @@ export default function register(api) {
                 const publicSubject = config.subject;
                 const privateSubject = `jobs.node.${config.nodeId}`;
 
-                logger.info(`[pier-connector] 👂 Listening to Marketplace: ${publicSubject}`);
-                logger.info(`[pier-connector] 👂 Listening to Direct Messages: ${privateSubject}`);
+                // Public pool with load balancing via JetStream Durable Consumer
+                if (publicSubject) {
+                    const durableName = `pier_marketplace_${config.queueGroup || 'default'}`;
+                    const streamName = 'PIER_JOBS';
+                    logger.info(`[pier-connector] 👂 Listening to Marketplace (JetStream): ${publicSubject} (Durable: ${durableName})`);
+                    
+                    (async () => {
+                        try {
+                            let consumer = await js.consumers.get(streamName, durableName).catch(async () => {
+                                logger.info(`[pier-connector] Creating new Marketplace Consumer: ${durableName}`);
+                                await jsm.consumers.add(streamName, {
+                                    durable_name: durableName,
+                                    filter_subject: publicSubject,
+                                    deliver_policy: DeliverPolicy.All,
+                                    ack_policy: AckPolicy.Explicit,
+                                    deliver_group: config.queueGroup
+                                });
+                                return await js.consumers.get(streamName, durableName);
+                            });
 
-                // Public pool with load balancing
-                nc.subscribe(publicSubject, { 
-                    queue: config.queueGroup,
-                    callback: (err, msg) => handleMessage(msg)
-                });
-                // Private direct channel (no queue group for broadcast/direct)
-                nc.subscribe(privateSubject, { 
-                    callback: (err, msg) => handleMessage(msg)
-                });
+                            const iter = await consumer.consume();
+                            for await (const msg of iter) {
+                                await handleMessage(msg);
+                                msg.ack();
+                            }
+                        } catch (err) {
+                            logger.error(`[pier-connector] Marketplace JetStream error: ${err.message}`);
+                        }
+                    })();
+                } else {
+                    logger.warn('[pier-connector] ⚠ No Marketplace subject defined. Skipping.');
+                }
+                
+                // Private direct channel (JetStream Durable per Node)
+                if (privateSubject) {
+                    const durableName = `pier_node_${config.nodeId.replace(/-/g, '_')}`;
+                    const streamName = 'PIER_JOBS';
+                    logger.info(`[pier-connector] 👂 Listening to Direct Messages (JetStream): ${privateSubject} (Durable: ${durableName})`);
+                    
+                    (async () => {
+                        try {
+                            let consumer = await js.consumers.get(streamName, durableName).catch(async () => {
+                                logger.info(`[pier-connector] Creating new Direct Consumer: ${durableName}`);
+                                await jsm.consumers.add(streamName, {
+                                    durable_name: durableName,
+                                    filter_subject: privateSubject,
+                                    deliver_policy: DeliverPolicy.All,
+                                    ack_policy: AckPolicy.Explicit
+                                });
+                                return await js.consumers.get(streamName, durableName);
+                            });
+
+                            const iter = await consumer.consume();
+                            for await (const msg of iter) {
+                                await handleMessage(msg);
+                                msg.ack();
+                            }
+                        } catch (err) {
+                            logger.error(`[pier-connector] Direct JetStream error: ${err.message}`);
+                        }
+                    })();
+                }
+
+                // Reusable job message subscriber
+                async function subscribeToJobMessages(jobId) {
+                    if (jobSubscriptions.has(jobId)) {
+                        // Already subscribed, just reset timeout
+                        if (jobStopTimeouts.has(jobId)) {
+                            clearTimeout(jobStopTimeouts.get(jobId));
+                            jobStopTimeouts.delete(jobId);
+                        }
+                        return;
+                    }
+
+                    const msgSubject = `jobs.job.${jobId}.msg`;
+                    const streamName = 'PIER_JOBS';
+                    
+                    try {
+                        const cInfo = await jsm.consumers.add(streamName, {
+                            filter_subject: msgSubject,
+                            deliver_policy: DeliverPolicy.All,
+                            ack_policy: AckPolicy.Explicit
+                        });
+                        const consumer = await js.consumers.get(streamName, cInfo.name);
+
+                        const iter = await consumer.consume();
+                        jobSubscriptions.set(jobId, iter);
+                        
+                        for await (const msg of iter) {
+                            msg.ack();
+                            const rawMsg = new TextDecoder().decode(msg.data);
+                            let msgPayload;
+                            try {
+                                msgPayload = JSON.parse(rawMsg);
+                            } catch (e) { continue; }
+
+                            // Ignore my own messages
+                            if (msgPayload.sender_id === config.nodeId) continue;
+
+                            if (msgPayload.type === 'receipt') continue;
+
+                            // Send read receipt back
+                            if (js && msgPayload.id) {
+                                try {
+                                    const replySubject = `jobs.job.${jobId}.msg`;
+                                    await js.publish(replySubject, new TextEncoder().encode(JSON.stringify({
+                                        type: 'receipt',
+                                        msg_id: msgPayload.id,
+                                        reader_id: config.nodeId
+                                    })));
+                                    logger.info(`[pier-connector] 👁️ Sent read receipt for message ${msgPayload.id}`);
+                                } catch (err) {
+                                    logger.error(`[pier-connector] Failed to send read receipt: ${err.message}`);
+                                }
+                            }
+
+                            const content = msgPayload.content;
+                            logger.info(`[pier-connector] 💬 Message for job ${jobId}: "${truncate(content, 40)}"`);
+                            
+                            await api.runtime.sendIncoming({
+                                channelId: 'pier',
+                                accountId: 'default',
+                                senderId: `pier:${msgPayload.sender_id}`,
+                                text: content,
+                                metadata: {
+                                    pierJobId: jobId,
+                                    isRealtimeMsg: true
+                                }
+                            });
+                        }
+                    } catch (err) {
+                        logger.error(`[pier-connector] Job JS message error for ${jobId}: ${err.message}`);
+                    }
+                }
 
                 // Unified Message Handler
                 async function handleMessage(msg) {
@@ -323,6 +493,16 @@ export default function register(api) {
                         return;
                     }
 
+                    // WAKEUP SIGNAL HANDLING
+                    if (payload.type === 'wakeup') {
+                        const { jobId } = payload;
+                        if (jobId) {
+                            logger.info(`[pier-connector] ⏰ Received wakeup signal for job ${jobId}`);
+                            subscribeToJobMessages(jobId);
+                        }
+                        return;
+                    }
+
                     // V1.1 FEATURE: Task Poisoning / Poaching Protection
                     if (payload.assigned_node_id && payload.assigned_node_id !== config.nodeId) {
                         // Silent ignore - don't reply, don't log heavily
@@ -366,6 +546,9 @@ export default function register(api) {
 
                         if (api.runtime?.sendIncoming) {
                             await api.runtime.sendIncoming(inbound);
+                            
+                            // SUBSCRIBE to job-specific messages for real-time communication
+                            subscribeToJobMessages(job.id);
                         } else {
                             throw new Error('Agent runtime not available');
                         }
@@ -516,6 +699,62 @@ export default function register(api) {
         { optional: true },
     );
 
+    api.registerTool(
+        {
+            name: 'pier_chat',
+            description: 'Send a message to the employer regarding a specific job. Use this for clarification or progress updates.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    jobId: {
+                        type: 'string',
+                        description: 'The ID of the job to send the message for'
+                    },
+                    text: {
+                        type: 'string',
+                        description: 'The message content'
+                    }
+                },
+                required: ['jobId', 'text']
+            },
+            async execute(_id, params) {
+                if (!nc || connectionStatus !== 'connected') {
+                    return { content: [{ type: 'text', text: 'Error: NATS not connected' }] };
+                }
+
+                try {
+                    const payload = {
+                        sender_id: getActiveConfig().nodeId,
+                        content: params.text,
+                        created_at: new Date().toISOString()
+                    };
+
+                    const subject = `jobs.job.${params.jobId}.msg`;
+                    await js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
+
+                    // Also SAVE to database for persistence
+                    const config = getActiveConfig();
+                    await fetch(`${config.pierApiUrl}/jobs/${params.jobId}/messages`, {
+                        method: 'POST',
+                        headers: { 
+                            'Content-Type': 'application/json',
+                            'X-API-Key': config.secretKey // Assuming secretKey can be used as API key for node-specific actions
+                        },
+                        body: JSON.stringify({
+                            sender_id: config.nodeId,
+                            content: params.text
+                        })
+                    });
+
+                    return { content: [{ type: 'text', text: 'Message sent' }] };
+                } catch (err) {
+                    return { content: [{ type: 'text', text: `Error: ${err.message}` }] };
+                }
+            }
+        },
+        { optional: true }
+    );
+
     // ── 4. Register /pier status command ───────────────────────────────
 
     api.registerCommand({

package/src/nats-client.js

@@ -6,6 +6,7 @@
  */
 
 import { wsconnect } from '@nats-io/transport-node';
+import { jetstream } from '@nats-io/jetstream';
 
 /**
  * Create and return a NATS connection over WebSocket.