@gholl-studio/pier-connector 0.2.7 → 0.2.9

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.2.7",
+    "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.
@@ -764,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
@@ -771,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,
@@ -810,13 +869,21 @@ 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 && job.id) || 'unknown',
@@ -884,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'],
             },
@@ -910,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,
             },
         };
     }