@gholl-studio/pier-connector 0.3.0 → 0.3.11

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@gholl-studio/pier-connector",
     "author": "gholl",
-    "version": "0.3.0",
+    "version": "0.3.11",
     "description": "OpenClaw plugin that connects to the Pier job marketplace. Automatically fetches, executes, and reports distributed tasks for rewards.",
     "type": "module",
     "main": "src/index.ts",

package/src/inbound.ts

@@ -101,8 +101,10 @@ export async function handleInbound(
         ].join('\n');
     }
 
+    logger.info(`[pier-connector:trace] Finalized inbound context for job ${jobId}. Target Agent: ${finalAgentId}, Session: ${dynamicSessionKey}`);
+
     const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
-        agentId: finalAgentId,
+        AgentId: finalAgentId,
         Body: inbound.body,
         BodyForAgent: inbound.body,
         RawBody: inbound.body,
@@ -131,6 +133,7 @@ export async function handleInbound(
     const { dispatcher, markDispatchIdle } = api.runtime.channel.reply.createReplyDispatcherWithTyping({
         deliver: async (payload: any) => {
             const currentMeta = robot.activeNodeJobs.get(jobId);
+            logger.info(`[pier-connector:trace] Outbound delivery triggered for job ${jobId}. Text length: ${payload.text?.length || 0}`);
             await pierChannel.outbound.sendText({
                 text: payload.text,
                 to: `pier:${jobId}`,
@@ -146,16 +149,23 @@ export async function handleInbound(
     if (api.runtime.channel.session?.recordSessionMetaFromInbound) {
         try {
             const storePath = api.runtime.channel.session.resolveStorePath(dynamicSessionKey);
+            logger.info(`[pier-connector:trace] Recording session metadata at ${storePath}`);
             await api.runtime.channel.session.recordSessionMetaFromInbound({
                 storePath, sessionKey: dynamicSessionKey, ctx: ctxPayload
             });
-        } catch (err) {}
+        } catch (err: any) {
+            logger.error(`[pier-connector] ✖ Failed to record session metadata: ${err.message}`);
+        }
     }
 
     try {
+        logger.info(`[pier-connector:trace] Dispatching reply to agent ${finalAgentId}...`);
         await api.runtime.channel.reply.dispatchReplyFromConfig({
             ctx: ctxPayload, cfg: api.config, dispatcher
         });
+        logger.info(`[pier-connector:trace] dispatchReplyFromConfig completed for job ${jobId}`);
+    } catch (err: any) {
+        logger.error(`[pier-connector] ✖ Dispatch error for job ${jobId}: ${err.message}`);
     } finally {
         markDispatchIdle();
     }

package/src/index.ts

@@ -130,6 +130,148 @@ const register = (api: PierPluginApi) => {
         }
     }, { optional: true });
 
+    api.registerTool(
+        {
+            name: 'pier_chat',
+            label: '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: any) {
+                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' }], details: {} };
+                }
+
+                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;
+
+                    if (!robot.js) {
+                        return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
+                    }
+
+                    const payload = {
+                        id: (globalThis.crypto as any).randomUUID ? (globalThis.crypto as any).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' }], details: {} };
+                } catch (err: any) {
+                    return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                }
+            }
+        },
+        { optional: true }
+    );
+
+    const registerSystemActionTool = (name: string, label: string, description: string, action: string, extraParams: any, userRole = 'node') => {
+        api.registerTool({
+            name,
+            label,
+            description,
+            parameters: {
+                type: 'object',
+                properties: {
+                    jobId: { type: 'string', description: 'The ID of the job' },
+                    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' }], details: {} };
+                }
+
+                try {
+                    const subject = `chat.${params.jobId}`;
+                    const { jobId: j, accountId: _, ...p } = params;
+
+                    if (!robot.js) {
+                        return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
+                    }
+
+                    const msgData = {
+                        id: (globalThis.crypto as any).randomUUID ? (globalThis.crypto as any).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: p }),
+                        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` }], details: {} };
+                } catch (err: any) {
+                    return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+                }
+            }
+        }, { optional: true });
+    };
+
+    registerSystemActionTool('pier_bid_task', 'Bid on task', 'Bid on an marketplace task', 'task_bid', { message: { type: 'string', description: 'Your pitch' } });
+    registerSystemActionTool('pier_accept_task', 'Accept task', 'Accept offered task', 'task_accept', {});
+    registerSystemActionTool('pier_finish_task', 'Finish task', 'Submit final result', 'task_submit', { result: { type: 'string', description: 'Final result' } });
+    registerSystemActionTool('pier_propose_task', 'Offer task', 'Offer task to a node', 'task_offer', {
+        price: { type: 'number' },
+        description: { type: 'string' }
+    }, 'user');
+    registerSystemActionTool('pier_rate_task', 'Rate task', 'Rate the node', 'task_rate', {
+        score: { type: 'number' },
+        comment: { type: 'string' }
+    }, 'user');
+    registerSystemActionTool('pier_reject_task', 'Reject task', 'Reject task', 'task_reject', { reason: { type: 'string' } });
+    registerSystemActionTool('pier_fail_task', 'Report error', 'Report that the task has failed', 'task_error', { error: { type: 'string' } });
+    registerSystemActionTool('pier_cancel_task', 'Cancel task', 'Cancel the task', 'task_cancel', { reason: { type: 'string' } }, 'user');
+
+    api.registerTool({
+        name: 'pier_get_profile',
+        label: 'Pier Profile',
+        description: 'Get current Pier profile and node stats.',
+        parameters: {
+            type: 'object',
+            properties: { accountId: { type: 'string' } }
+        },
+        async execute(_id, params) {
+            const robot = instances.get(params.accountId || 'default') || instances.values().next().value;
+            if (!robot) return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
+            try {
+                const profile = await robot.client.getUserProfile(robot.config.secretKey);
+                return { content: [{ type: 'text', text: JSON.stringify(profile, null, 2) }], details: {} };
+            } catch (err: any) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+
     // Register simple status command
     api.registerCommand({
         name: 'pier',

package/src/robot.ts

@@ -120,13 +120,15 @@ export class PierRobot {
                         }
 
                         msg.ack();
-                        await this.onInbound({
+                        const inbound = {
                             accountId: this.accountId,
                             senderId: `pier:${msgPayload.sender_id}`,
                             body: content,
                             jobId: jobId
-                        }, jobId);
-                    } catch (err: any) { this.logger.error(`[pier-connector] Chat err: ${err.message}`); }
+                        };
+                        this.logger.info(`[pier-connector:trace] NATS Chat Message received on PierRobot instance accountId='${this.accountId}'. Passing to handleInbound...`);
+                        await this.onInbound(inbound, jobId);
+                    } catch (err: any) { this.logger.error(`[pier-connector][${this.accountId}] ✖ Failed to process chat message: ${err.message}`); }
                 }
             })();
         } catch (err: any) {