@gholl-studio/pier-connector 0.2.51 → 0.3.0

package/src/robot.ts

@@ -0,0 +1,300 @@
+import { PierClient, protocol } from '@gholl-studio/pier-sdk';
+const { createRequestPayload, createResultPayload, createErrorPayload } = protocol;
+import { parseJob, safeRespond, truncate } from './job-handler.js';
+import { jetstream, jetstreamManager, AckPolicy, DeliverPolicy, type JetStreamClient, type JetStreamManager } from '@nats-io/jetstream';
+import type { PierAccountConfig, PierPluginApi, InboundMessage } from './types.js';
+
+type NatsConnection = any; // Fallback for NatsConnection typing if not directly exported from jetstream
+
+
+export class PierRobot {
+    public config: PierAccountConfig;
+    public accountId: string;
+    public client: PierClient;
+    public nc: NatsConnection | null = null;
+    public js: JetStreamClient | null = null;
+    public jsm: JetStreamManager | null = null;
+    public activeNodeJobs: Map<string, any> = new Map();
+    public jobSubscriptions: Map<string, any> = new Map();
+    public isBusy: boolean = false;
+    public connectionStatus: 'disconnected' | 'connecting' | 'connected' | 'error' = 'disconnected';
+    public stats = { received: 0, completed: 0, failed: 0 };
+    
+    private api: PierPluginApi;
+    private logger: any;
+    private heartbeatTimer: NodeJS.Timeout | null = null;
+    private onInbound: (inbound: InboundMessage, jobId: string) => Promise<void>;
+
+    constructor(
+        config: PierAccountConfig, 
+        api: PierPluginApi, 
+        onInbound: (inbound: InboundMessage, jobId: string) => Promise<void>
+    ) {
+        this.config = config;
+        this.accountId = config.accountId;
+        this.api = api;
+        this.logger = api.logger;
+        this.onInbound = onInbound;
+        this.client = new PierClient({ 
+            apiUrl: config.pierApiUrl,
+            natsUrl: config.natsUrl, 
+            logger: this.logger 
+        });
+    }
+
+    async heartbeat() {
+        if (!this.config.nodeId || !this.config.secretKey) return null;
+        try {
+            const data = await this.client.heartbeat(
+                this.config.nodeId,
+                this.config.secretKey,
+                this.config.capabilities
+            );
+            return data.nats_config || null;
+        } catch (err: any) {
+            this.logger.warn(`[pier-connector][${this.accountId}] Heartbeat failed: ${err.message}`);
+            return null;
+        }
+    }
+
+    async claimJob(jobId: string) {
+        return await this.client.claimJob(jobId, this.config.nodeId, this.config.secretKey);
+    }
+
+    async subscribeToJobMessages(jobId: string) {
+        if (!this.js || !this.jsm) return;
+        
+        const chatSubject = `chat.${jobId}`;
+        const streamName = 'PIER_JOBS';
+        const nodeSlug = this.config.nodeId.replace(/[^a-zA-Z0-9]/g, '_');
+        const jobSlug = jobId.replace(/[^a-zA-Z0-9]/g, '_');
+        const durableName = `pier_chat_${nodeSlug}_${jobSlug}`;
+
+        try {
+            let consumer;
+            try {
+                consumer = await this.js.consumers.get(streamName, durableName);
+            } catch {
+                await this.jsm.consumers.add(streamName, {
+                    durable_name: durableName,
+                    filter_subject: chatSubject,
+                    deliver_policy: DeliverPolicy.New,
+                    ack_policy: AckPolicy.Explicit,
+                    ack_wait: 1000 * 60 * 60,
+                });
+                consumer = await this.js.consumers.get(streamName, durableName);
+            }
+
+            const iter = await consumer.consume();
+            this.jobSubscriptions.set(jobId, iter);
+
+            (async () => {
+                this.logger.info(`[pier-connector][${this.accountId}] \u{1F442} Monitoring ${chatSubject}`);
+                const processedMessages = new Set();
+                for await (const msg of iter) {
+                    try {
+                        const rawMsg = new TextDecoder().decode(msg.data);
+                        let msgPayload = JSON.parse(rawMsg);
+
+                        if (msgPayload.id && processedMessages.has(msgPayload.id)) { msg.ack(); continue; }
+                        if (msgPayload.sender_id === this.config.nodeId) { msg.ack(); continue; }
+                        if (msgPayload.type === 'receipt') { msg.ack(); continue; }
+                        if (msgPayload.type === 'system_action' || msgPayload.msg_type === 'system_action') { msg.ack(); continue; }
+
+                        try {
+                            await this.js!.publish(chatSubject, new TextEncoder().encode(JSON.stringify({
+                                type: 'receipt', msg_id: msgPayload.id, reader_id: this.config.nodeId
+                            })));
+                        } catch (err) {}
+
+                        const content = msgPayload.content;
+                        if (!content) { msg.ack(); continue; }
+
+                        this.logger.info(`[pier-connector][${this.accountId}] \u{1F4AC} Chat: [${jobId}] ${msgPayload.sender_id}: "${truncate(content, 40)}"`);
+                        if (msgPayload.id) processedMessages.add(msgPayload.id);
+
+                        const jobMeta = this.activeNodeJobs.get(jobId);
+                        if (!jobMeta || !jobMeta.isTargeted) {
+                            msg.ack();
+                            continue;
+                        }
+
+                        msg.ack();
+                        await this.onInbound({
+                            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}`); }
+                }
+            })();
+        } catch (err: any) {
+            this.logger.error(`[pier-connector][${this.accountId}] Failed to setup chat consumer: ${err.message}`);
+        }
+    }
+
+    async handleMessage(msg: any) {
+        const rawData = new TextDecoder().decode(msg.data);
+        let payload: any;
+        try {
+            payload = JSON.parse(rawData);
+        } catch (e) {
+            msg.ack();
+            return;
+        }
+
+        if (payload.type === 'wakeup') {
+            const { jobId } = payload;
+            if (jobId) {
+                this.logger.info(`[pier-connector][${this.accountId}] ⏰ Received wakeup signal for job ${jobId}`);
+                if (!this.jobSubscriptions.has(jobId)) {
+                    this.activeNodeJobs.set(jobId, { pierJobId: jobId, isTargeted: true });
+                    await this.subscribeToJobMessages(jobId);
+                }
+            }
+            msg.ack();
+            return;
+        }
+
+        if (this.isBusy) {
+            msg.nak();
+            return;
+        }
+
+        if (payload.assigned_node_id && payload.assigned_node_id !== this.config.nodeId) {
+            msg.nak();
+            return;
+        }
+
+        const jobIdToClaim = payload.id;
+        const isTargeted = !!(payload.assigned_node_id || payload.targetNodeId || payload.TargetNodeID);
+        
+        if (jobIdToClaim && isTargeted) {
+            const claimResult = await this.claimJob(jobIdToClaim);
+            if (!claimResult.ok) {
+                if (claimResult.alreadyClaimed) msg.ack();
+                else msg.nak();
+                return;
+            }
+        }
+
+        this.isBusy = true;
+        msg.ack();
+
+        this.stats.received++;
+        const parsed = parseJob(msg, this.logger);
+        if (!parsed.ok) {
+            this.stats.failed++;
+            this.isBusy = false;
+            safeRespond(msg, createErrorPayload({
+                id: jobIdToClaim || 'unknown',
+                errorCode: 'PARSE_ERROR',
+                errorMessage: parsed.error,
+                workerId: this.config.nodeId,
+                walletAddress: this.config.walletAddress,
+            }));
+            return;
+        }
+
+        const { job } = parsed;
+        const senderCore = job.meta?.sender ?? 'anonymous';
+        
+        this.activeNodeJobs.set(job.id, {
+            pierJobId: job.id,
+            pierNatsMsg: msg,
+            pierStartTime: performance.now(),
+            pierMeta: job.meta,
+            isTargeted: isTargeted
+        });
+
+        let finalText = job.task;
+        if (!isTargeted) {
+            finalText = `【PIER MARKETPLACE OPEN JOB】\nJob ID: ${job.id}\nTask: ${job.task}\n\n=== CRITICAL ===\nYou MUST use \`pier_bid_task\` to bid. Do not solve directly.`;
+        } else {
+            await this.subscribeToJobMessages(job.id);
+        }
+
+        await this.onInbound({
+            accountId: this.accountId,
+            senderId: `pier:${senderCore}`,
+            body: finalText,
+            jobId: job.id
+        }, job.id);
+
+        this.isBusy = false;
+    }
+
+    async setupMarketplaceConsumer(streamName: string, subjectName: string, durableName: string) {
+        if (!this.js || !this.jsm) return;
+        try {
+            let consumer;
+            try {
+                consumer = await this.js.consumers.get(streamName, durableName);
+            } catch {
+                await this.jsm.consumers.add(streamName, {
+                    durable_name: durableName,
+                    filter_subject: subjectName,
+                    deliver_policy: DeliverPolicy.New,
+                    ack_policy: AckPolicy.Explicit,
+                });
+                consumer = await this.js.consumers.get(streamName, durableName);
+            }
+
+            const iter = await consumer.consume();
+            (async () => {
+                for await (const msg of iter) {
+                    await this.handleMessage(msg);
+                }
+            })().catch(err => {
+                this.logger.error(`[pier-connector][${this.accountId}] Consumer error: ${err.message}`);
+            });
+        } catch (err: any) {
+            this.logger.error(`[pier-connector][${this.accountId}] Setup failed: ${err.message}`);
+            throw err;
+        }
+    }
+
+    async autoRegister() {
+        if (!this.config.privateKey) return;
+        const hostName = `${(this.api as any).getRuntimeInfo?.()?.hostname ?? 'Auto'}-${this.accountId}`;
+        const { nodeId, secretKey } = await this.client.autoRegister(this.config.privateKey, hostName);
+        this.config.nodeId = nodeId;
+        this.config.secretKey = secretKey;
+    }
+
+    async start() {
+        this.connectionStatus = 'connecting';
+        try {
+            if (!this.config.nodeId && this.config.privateKey) await this.autoRegister();
+            const natsConfig = await this.heartbeat();
+            if (!natsConfig) throw new Error('No NATS config');
+            if (natsConfig.url) {
+                this.client.nats.url = natsConfig.url;
+            }
+            
+            this.nc = await this.client.connectNats();
+            this.js = jetstream(this.nc);
+            this.jsm = await jetstreamManager(this.nc);
+            this.connectionStatus = 'connected';
+
+            const streamName = 'PIER_JOBS';
+            const durableNameMarket = `pier_market_${this.config.nodeId.replace(/-/g, '_')}_${this.accountId}`;
+            const durableNameDirect = `pier_node_${this.config.nodeId.replace(/-/g, '_')}_${this.accountId}`;
+
+            await this.setupMarketplaceConsumer(streamName, this.config.subject, durableNameMarket);
+            await this.setupMarketplaceConsumer(streamName, `jobs.node.${this.config.nodeId}`, durableNameDirect);
+
+            this.heartbeatTimer = setInterval(() => this.heartbeat(), 60000);
+        } catch (err: any) {
+            this.connectionStatus = 'error';
+            this.logger.error(`[pier-connector][${this.accountId}] Start failed: ${err.message}`);
+        }
+    }
+
+    async stop() {
+        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+        if (this.nc) await this.client.drainNats();
+        this.connectionStatus = 'disconnected';
+    }
+}

package/src/types/pier-sdk.d.ts

@@ -0,0 +1,20 @@
+declare module '@gholl-studio/pier-sdk' {
+  export class PierClient {
+    constructor(config: { apiUrl: string; natsUrl?: string; logger?: any });
+    connectNats(): Promise<any>;
+    getNatsConnection(): Promise<any>;
+    heartbeat(nodeId: string, secretKey: string, capabilities: string[]): Promise<any>;
+    claimJob(jobId: string, nodeId: string, secretKey: string): Promise<any>;
+    autoRegister(privateKey: string, hostName: string): Promise<{ nodeId: string; secretKey: string; walletAddress: string }>;
+    getUserProfile(secretKey: string): Promise<any>;
+    drainNats(): Promise<void>;
+    nats: { url: string };
+  }
+
+  export const protocol: {
+    normalizeInboundPayload(payload: any): { ok: boolean; job?: any; error?: string };
+    createRequestPayload(data: any): any;
+    createResultPayload(data: any): any;
+    createErrorPayload(data: any): any;
+  };
+}

package/src/types.ts

@@ -0,0 +1,32 @@
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk/plugin-entry';
+
+export interface PierAccountConfig {
+  accountId: string;
+  pierApiUrl: string;
+  nodeId: string;
+  secretKey: string;
+  privateKey: string;
+  natsUrl: string;
+  subject: string;
+  publishSubject: string;
+  queueGroup: string;
+  agentId: string;
+  walletAddress: string;
+  capabilities: string[];
+}
+
+export interface PierJob {
+  id: string;
+  subject: string;
+  data: any;
+  metadata?: any;
+}
+
+export interface InboundMessage {
+  accountId: string;
+  senderId: string;
+  body: string;
+  jobId: string;
+}
+
+export type PierPluginApi = OpenClawPluginApi;

package/src/config.js

@@ -1,37 +0,0 @@
-/**
- * Default configuration constants for pier-connector.
- * Values can be overridden via OpenClaw plugin config
- * (plugins.entries.pier-connector.config).
- */
-
-export const DEFAULTS = Object.freeze({
-    /** Pier Backend API Base URL */
-    PIER_API_URL: 'https://pier-connector.gholl.com/api/v1',
-
-    /** NATS WebSocket server URL (usually provided by Heartbeat) */
-    NATS_URL: 'wss://pier.gholl.com/nexus',
-
-    /** NATS subject to subscribe for incoming jobs */
-    SUBJECT: 'jobs.worker',
-
-    /** NATS subject for outbound task publishing */
-    PUBLISH_SUBJECT: 'jobs.submit',
-
-    /** Default Queue Group for processing jobs (prevents duplicate work) */
-    QUEUE_GROUP: 'openclaw-workers',
-
-    /** Unique identifier for this agent worker node (UUID) */
-    NODE_ID: '',
-
-    /** Secret key for node authentication and heartbeats */
-    SECRET_KEY: '',
-
-    /** Optional Private Key for auto-registration via Wallet Signature (Advanced) */
-    PRIVATE_KEY: '',
-
-    /** Optional Wallet address to receive points/payments for completed tasks */
-    WALLET_ADDRESS: '',
-
-    /** Optional Agent ID to bind tasks to, instead of creating new sessions */
-    AGENT_ID: '',
-});