@gholl-studio/pier-connector 0.3.0 → 0.3.1

package/package.json

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

@@ -102,7 +102,7 @@ export async function handleInbound(
     }
 
     const ctxPayload = api.runtime.channel.reply.finalizeInboundContext({
-        agentId: finalAgentId,
+        AgentId: finalAgentId,
         Body: inbound.body,
         BodyForAgent: inbound.body,
         RawBody: inbound.body,

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',