@gholl-studio/pier-connector 0.2.6 → 0.2.9

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.2.6",
+    "version": "0.2.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",

package/src/index.js

@@ -46,6 +46,12 @@ export default function register(api) {
     const jobStopTimeouts = new Map();
     const activeNodeJobs = new Map();
 
+    /** 
+     * Anti-Interference Flag (BUG-34)
+     * When true, the robot will ignore new marketplace jobs. 
+     */
+    let isBusy = false;
+
     let jobsReceived = 0;
     let jobsCompleted = 0;
     let jobsFailed = 0;
@@ -127,6 +133,39 @@ export default function register(api) {
         }
     }
 
+    /**
+     * Atomically claims a job from the backend before starting execution.
+     * Ensures "one-job-at-a-time" exclusivity.
+     */
+    async function claimJob(jobId) {
+        const config = getActiveConfig();
+        try {
+            const resp = await fetch(`${config.pierApiUrl}/jobs/${jobId}/claim`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${config.secretKey}`,
+                }
+            });
+
+            if (!resp.ok) {
+                if (resp.status === 409) {
+                    logger.warn(`[pier-connector] 🚫 Job ${jobId} was already claimed by someone else.`);
+                } else {
+                    const errData = await resp.json().catch(() => ({}));
+                    logger.error(`[pier-connector] ✖ Failed to claim job ${jobId}: ${errData.error || resp.statusText}`);
+                }
+                return false;
+            }
+
+            logger.info(`[pier-connector] ✅ Successfully claimed job ${jobId}`);
+            return true;
+        } catch (err) {
+            logger.error(`[pier-connector] ✖ Network error claiming job ${jobId}: ${err.message}`);
+            return false;
+        }
+    }
+
     /**
      * Routes an incoming message from Pier to the OpenClaw agent.
      * Replaces the non-existent api.runtime.sendIncoming.
@@ -477,24 +516,26 @@ export default function register(api) {
                 // 5. Subscribe to Subjects
                 const publicSubject = config.subject;
                 const privateSubject = `jobs.node.${config.nodeId}`;
-
                 // 5a. Restore active job subscriptions (BUG-32)
                 try {
-                    logger.info(`[pier-connector] 🔍 Checking for active jobs to restore for node ${config.nodeId}...`);
-                    const jobsResp = await fetch(`${config.apiBase}/jobs?assigned_node_id=${config.nodeId}&limit=50`);
-                    if (jobsResp.ok) {
-                        const jobsList = await jobsResp.json();
-                        const activeJobs = (jobsList || []).filter(j => j.status === 'PENDING' || j.status === 'PROCESSING');
-                        if (activeJobs.length > 0) {
-                            logger.info(`[pier-connector] ♻️  Restoring ${activeJobs.length} active job subscriptions...`);
-                            for (const job of activeJobs) {
-                                if (!jobSubscriptions.has(job.id)) {
-                                    activeNodeJobs.set(job.id, { pierJobId: job.id });
-                                    await subscribeToJobMessages(job.id);
+                    const activeConfig = getActiveConfig();
+                    if (activeConfig.apiBase) {
+                        logger.info(`[pier-connector] 🔍 Checking for active jobs to restore for node ${config.nodeId}...`);
+                        const jobsResp = await fetch(`${activeConfig.apiBase}/jobs?assigned_node_id=${config.nodeId}&limit=50`);
+                        if (jobsResp.ok) {
+                            const jobsList = await jobsResp.json();
+                            const activeJobs = (jobsList || []).filter(j => j.status === 'PENDING' || j.status === 'PROCESSING');
+                            if (activeJobs.length > 0) {
+                                logger.info(`[pier-connector] ♻️  Restoring ${activeJobs.length} active job subscriptions...`);
+                                for (const job of activeJobs) {
+                                    if (!jobSubscriptions.has(job.id)) {
+                                        activeNodeJobs.set(job.id, { pierJobId: job.id });
+                                        await subscribeToJobMessages(job.id);
+                                    }
                                 }
+                            } else {
+                                logger.info('[pier-connector] No active jobs found to restore.');
                             }
-                        } else {
-                            logger.info('[pier-connector] No active jobs found to restore.');
                         }
                     }
                 } catch (err) {
@@ -617,14 +658,20 @@ export default function register(api) {
                         // Use a unique durable name per node and job to avoid replaying acknowledged messages
                         const durableName = `pier_chat_${config.nodeId.replace(/[^a-zA-Z0-9]/g, '_')}_${jobId.replace(/[^a-zA-Z0-9]/g, '_')}`;
                         
-                        const cInfo = await jsm.consumers.add(streamName, {
-                            durable_name: durableName,
-                            filter_subject: msgSubject,
-                            deliver_policy: DeliverPolicy.New, // Reverted to New to stop message storms (BUG-27)
-                            ack_policy: AckPolicy.Explicit, // Explicit ACK is crucial for deduplication
-                            ack_wait: 1000 * 60 * 60, // 1 hour ACK wait to allow for long processing (BUG-30)
-                        });
-                        const consumer = await js.consumers.get(streamName, cInfo.name);
+                        let consumer;
+                        try {
+                            consumer = await js.consumers.get(streamName, durableName);
+                        } catch (err) {
+                            // Only add if it doesn't exist
+                            await jsm.consumers.add(streamName, {
+                                durable_name: durableName,
+                                filter_subject: msgSubject,
+                                deliver_policy: DeliverPolicy.New, // Reverted to New to stop message storms (BUG-27)
+                                ack_policy: AckPolicy.Explicit, // Explicit ACK is crucial for deduplication
+                                ack_wait: 1000 * 60 * 60, // 1 hour ACK wait to allow for long processing (BUG-30)
+                            });
+                            consumer = await js.consumers.get(streamName, durableName);
+                        }
 
                         const iter = await consumer.consume();
                         jobSubscriptions.set(jobId, iter);
@@ -756,6 +803,13 @@ export default function register(api) {
                         return;
                     }
 
+                    // Anti-Interference: If busy, ignore new marketplace jobs (BUG-34)
+                    if (isBusy) {
+                        // NAK so others in the queue group can take it
+                        msg.nak();
+                        return;
+                    }
+
                     // V1.1 FEATURE: Task Poisoning / Poaching Protection
                     if (payload.assigned_node_id && payload.assigned_node_id !== config.nodeId) {
                         // Not for us, nak it so others can take it
@@ -763,17 +817,30 @@ export default function register(api) {
                         return;
                     }
 
-                    // ACK the job early to 'claim' it and prevent redelivery while we process
+                    // For Marketplace jobs (those without assigned_node_id, or even those with it), 
+                    // we must ATOMICALLY CLAIM it from the backend before setting isBusy.
+                    const jobIdToClaim = payload.id;
+                    if (jobIdToClaim) {
+                        const success = await claimJob(jobIdToClaim);
+                        if (!success) {
+                            // Already taken or error, NAK it just in case someone else can try
+                            msg.nak();
+                            return;
+                        }
+                    }
+
+                    // Claimed successfully! Set busy state
+                    isBusy = true;
                     msg.ack();
 
                     jobsReceived++;
                     const parsed = parseJob(msg, logger);
                     if (!parsed.ok) {
                         jobsFailed++;
+                        isBusy = false; // Reset busy state on parse error
                         logger.error(`[pier-connector] Job parse error: ${parsed.error}`);
-                        // Since we already acked, we must send an error result back to Pier
                         safeRespond(msg, createErrorPayload({
-                            id: 'unknown',
+                            id: jobIdToClaim || 'unknown',
                             errorCode: 'PARSE_ERROR',
                             errorMessage: parsed.error,
                             workerId: config.nodeId,
@@ -802,17 +869,24 @@ export default function register(api) {
                             text: job.task,
                         };
 
-                        // SUBSCRIBE to job-specific messages FIRST so we don't miss follow-ups during the agent run
-                        // This handles the user's "can only receive one message" issue
+                        // SUBSCRIBE to job-specific messages FIRST so we don't miss follow-ups
                         subscribeToJobMessages(job.id);
 
                         // Trigger agent run
                         await receiveIncoming(inbound, job.id);
                         
+                        // NOTE: isBusy is reset when the agent completes. 
+                        // Because receiveIncoming (via OpenClaw core) might be async or callback-based, 
+                        // we need to be careful. However, for standard MCP tools/agents, 
+                        // we'll assume isBusy should stay true until the job lifecycle is managed.
+                        // For now, simple reset after agent returns or in error.
+                        isBusy = false;
+
                     } catch (err) {
+                        isBusy = false;
                         jobsFailed++;
                         safeRespond(msg, createErrorPayload({
-                            id: job.id,
+                            id: (job && job.id) || 'unknown',
                             errorCode: 'EXECUTION_FAILED',
                             errorMessage: err.message,
                             workerId: config.nodeId,
@@ -831,6 +905,7 @@ export default function register(api) {
                         logger.info('[pier-connector] NATS connection closed gracefully');
                     }
                 });
+
             } catch (err) {
                 connectionStatus = 'error';
                 if (heartbeatTimer) clearInterval(heartbeatTimer);
@@ -843,13 +918,10 @@ export default function register(api) {
             logger.info('[pier-connector] 🛑 Stopping background service …');
             connectionStatus = 'stopping';
 
-            if (subscription) {
-                subscription.unsubscribe();
-                subscription = null;
+            if (nc) {
+                await drainConnection(nc, logger);
+                nc = null;
             }
-
-            await drainConnection(nc, logger);
-            nc = null;
             connectionStatus = 'disconnected';
 
             logger.info('[pier-connector] ✔ Background service stopped');
@@ -879,6 +951,10 @@ export default function register(api) {
                         type: 'number',
                         description: 'Timeout in milliseconds to wait for a result (default 60000)',
                     },
+                    parentJobId: {
+                        type: 'string',
+                        description: 'Optional ID of the parent job triggering this sub-task (for delegation)',
+                    },
                 },
                 required: ['task'],
             },
@@ -905,6 +981,7 @@ export default function register(api) {
                     task: params.task,
                     timeoutMs: timeout,
                     meta: params.meta,
+                    parentJobId: params.parentJobId,
                 });
 
                 try {

package/src/protocol.js

@@ -4,7 +4,7 @@
  * Standardizes outbound and inbound JSON boundaries for NATS.
  */
 
-export const PROTOCOL_VERSION = '1.0';
+export const PROTOCOL_VERSION = '1.1';
 
 /**
  * Creates a standard task request payload to send to Pier.
@@ -15,18 +15,20 @@ export const PROTOCOL_VERSION = '1.0';
  * @param {number} [params.timeoutMs]
  * @param {object} [params.meta]
  * @param {string} [params.targetNodeId]
+ * @param {string} [params.parentJobId]
  * @returns {object}
  */
-export function createRequestPayload({ task, systemPrompt, timeoutMs, meta, targetNodeId }) {
+export function createRequestPayload({ task, systemPrompt, timeoutMs, meta, targetNodeId, parentJobId }) {
     return {
         version: PROTOCOL_VERSION,
         id: crypto.randomUUID(),
-        type: 'task_request',
+        type: 'task', // Changed from task_request to task to align with backend models
         task,
         systemPrompt,
         timeoutMs: timeoutMs || 60000,
         meta: meta || {},
         targetNodeId: targetNodeId || null,
+        parentJobId: parentJobId || null,
     };
 }
 
@@ -91,10 +93,10 @@ export function createErrorPayload({ id, errorCode, errorMessage, workerId, wall
  * @returns {{ ok: true, job: object } | { ok: false, error: string }}
  */
 export function normalizeInboundPayload(payload) {
-    // If it's a strict v1.0 protocol request
-    if (payload.type === 'task_request') {
+    // If it's a strict v1.1+ protocol request
+    if (payload.type === 'task' || payload.type === 'task_request') {
         if (!payload.task) {
-            return { ok: false, error: 'Missing "task" field in task_request payload' };
+            return { ok: false, error: 'Missing "task" field in task payload' };
         }
         return {
             ok: true,
@@ -104,6 +106,7 @@ export function normalizeInboundPayload(payload) {
                 systemPrompt: payload.systemPrompt,
                 meta: payload.meta || {},
                 targetNodeId: payload.targetNodeId || null,
+                parentJobId: payload.parentJobId || null,
             },
         };
     }