@gholl-studio/pier-connector 0.3.19 → 0.3.21

package/package.json

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

@@ -141,34 +141,76 @@ const pierPlugin: ChannelPlugin<PierAccountConfig> = {
         }
     },
 
+    // -------------------------------------------------------------------------
+    // Status Adapter
+    // -------------------------------------------------------------------------
+    status: {
+        buildAccountSnapshot: ({ account, cfg }) => {
+            const robot = instances.get(account.accountId);
+            return {
+                accountId: account.accountId,
+                running: !!robot,
+                connected: robot?.connectionStatus === 'connected',
+                lastStartAt: (robot as any)?.lastStartAt,
+                lastStopAt: (robot as any)?.lastStopAt,
+                lastError: (robot as any)?.lastError,
+                healthState: robot?.connectionStatus === 'connected' ? 'healthy' : 'degraded',
+            };
+        },
+        resolveAccountState: ({ configured, enabled }) => {
+            return configured && enabled ? 'enabled' : 'disabled';
+        }
+    },
+
     // -------------------------------------------------------------------------
     // Gateway Adapter
     // -------------------------------------------------------------------------
     gateway: {
         startAccount: async (ctx) => {
             const config = ctx.account;
-            const robot = new PierRobot(config, (ctx.runtime as any), async (inbound, jobId) => {
-                // Pass the context-aware runtime and the plugin instance
-                await handleInbound((ctx.runtime as any), inbound, jobId, robot, pierPlugin);
+            // ctx has .log, .runtime, .cfg, etc.
+            const robot = new PierRobot(config, ctx as any, async (inbound, jobId) => {
+                await handleInbound(ctx.runtime, inbound, jobId, robot, pierPlugin);
             });
             instances.set(ctx.accountId, robot);
-            await robot.start();
-            ctx.setStatus({ 
-                ...ctx.getStatus(),
-                running: true, 
-                lastStartAt: new Date().toISOString() 
-            } as any);
+            
+            try {
+                (robot as any).lastStartAt = Date.now();
+                await robot.start();
+                
+                ctx.setStatus({ 
+                    ...ctx.getStatus(),
+                    running: true, 
+                    connected: true,
+                    lastStartAt: (robot as any).lastStartAt 
+                } as any);
+
+                // Note: We resolve here to signal successful startup.
+                // The robot stays alive in the 'instances' map.
+                // If OpenClaw requires a long-running promise, we can revert to keeping it alive,
+                // but usually, status monitoring is enough for non-standard services.
+                console.log(`[pier-connector][${ctx.accountId}] Startup successful and resolved.`);
+            } catch (err: any) {
+                (robot as any).lastError = err.message;
+                ctx.setStatus({
+                    ...ctx.getStatus(),
+                    running: false,
+                    lastError: err.message
+                } as any);
+                throw err;
+            }
         },
         stopAccount: async (ctx) => {
             const robot = instances.get(ctx.accountId);
             if (robot) {
+                (robot as any).lastStopAt = Date.now();
                 await robot.stop();
                 instances.delete(ctx.accountId);
             }
             ctx.setStatus({ 
                 ...ctx.getStatus(),
                 running: false, 
-                lastStopAt: new Date().toISOString() 
+                lastStopAt: (robot as any).lastStopAt
             } as any);
         }
     }

package/src/robot.ts

@@ -38,8 +38,20 @@ export class PierRobot {
         this.config = config;
         this.accountId = config.accountId;
         this.runtime = runtime;
-        this.logger = runtime.log || console;
         this.onInbound = onInbound;
+
+        // Robust logger wrapper
+        if (runtime.log && typeof runtime.log === 'object' && 'error' in runtime.log) {
+            this.logger = runtime.log;
+        } else {
+            this.logger = {
+                info: (msg: string) => (typeof runtime.log === 'function' ? runtime.log(msg) : console.log(msg)),
+                error: (msg: string) => (typeof runtime.error === 'function' ? runtime.error(msg) : console.error(msg)),
+                warn: (msg: string) => (typeof runtime.warn === 'function' ? runtime.warn(msg) : console.warn(msg)),
+                debug: (msg: string) => (typeof runtime.debug === 'function' ? runtime.debug(msg) : console.debug ? console.debug(msg) : console.log(msg)),
+            };
+        }
+
         this.client = new PierClient({ 
             apiUrl: config.pierApiUrl,
             natsUrl: config.natsUrl, 
@@ -292,16 +304,24 @@ export class PierRobot {
             await this.setupMarketplaceConsumer(streamName, this.config.subject, durableNameMarket);
             await this.setupMarketplaceConsumer(streamName, `jobs.node.${this.config.nodeId}`, durableNameDirect);
 
+            if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
             this.heartbeatTimer = setInterval(() => this.heartbeat(), 60000);
         } catch (err: any) {
             this.connectionStatus = 'error';
             this.logger.error(`[pier-connector][${this.accountId}] Start failed: ${err.message}`);
+            throw err; // Re-throw to signal failure to Gateway
         }
     }
 
     async stop() {
-        if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
-        if (this.nc) await this.client.drainNats();
+        if (this.heartbeatTimer) {
+            clearInterval(this.heartbeatTimer);
+            this.heartbeatTimer = null;
+        }
+        if (this.nc) {
+            await this.client.drainNats();
+            this.nc = null;
+        }
         this.connectionStatus = 'disconnected';
     }
 }