@gholl-studio/pier-connector 0.3.20 → 0.3.22

package/package.json

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

@@ -7,21 +7,22 @@ import type { InboundMessage } from './types.js';
 import { truncate } from './job-handler.js';
 
 export async function handleInbound(
-    runtime: any, // Using context-aware runtime from gateway
+    ctx: any, // Gateway Context
     inbound: InboundMessage,
     jobId: string,
     robot: any,
     pierPlugin: any
 ) {
-    const logger = runtime.log || console;
+    const logger = ctx.log || console;
+    const channelRuntime = ctx.channelRuntime;
     
-    if (!runtime.reply) {
-        console.error(`[pier-connector][${robot.accountId}] SDK Error: runtime.reply is not available.`);
+    if (!channelRuntime?.reply) {
+        console.error(`[pier-connector][${robot.accountId}] SDK Error: channelRuntime.reply is not available.`);
         return;
     }
 
     // 1. Resolve Account-Scoped Configuration
-    const rootConfig = runtime.cfg || {};
+    const rootConfig = ctx.cfg || {};
     const accountScopedCfg = {
         ...rootConfig,
         channels: { 
@@ -31,7 +32,7 @@ export async function handleInbound(
     };
 
     // 2. Resolve Agent Route
-    const route = runtime.routing.resolveAgentRoute({
+    const route = channelRuntime.routing.resolveAgentRoute({
         cfg: accountScopedCfg,
         channel: 'pier',
         accountId: robot.accountId,
@@ -72,7 +73,7 @@ export async function handleInbound(
     }
 
     // 3. Finalize Context
-    const ctxPayload = runtime.reply.finalizeInboundContext({
+    const ctxPayload = channelRuntime.reply.finalizeInboundContext({
         Body: inbound.body,
         BodyForAgent: inbound.body,
         RawBody: inbound.body,
@@ -102,7 +103,7 @@ export async function handleInbound(
     });
 
     // 4. Create Dispatcher
-    const { dispatcher, markDispatchIdle } = runtime.reply.createReplyDispatcherWithTyping({
+    const { dispatcher, markDispatchIdle } = channelRuntime.reply.createReplyDispatcherWithTyping({
         deliver: async (payload: any, info: any) => {
             const currentMeta = robot.activeNodeJobs.get(jobId);
             const resAgent = payload.agentId || finalAgentId;
@@ -126,10 +127,10 @@ export async function handleInbound(
     });
 
     // 5. Session Recording
-    if (runtime.session?.recordSessionMetaFromInbound) {
+    if (channelRuntime.session?.recordSessionMetaFromInbound) {
         try {
-            const storePath = runtime.session.resolveStorePath(dynamicSessionKey);
-            await runtime.session.recordSessionMetaFromInbound({
+            const storePath = channelRuntime.session.resolveStorePath(dynamicSessionKey);
+            await channelRuntime.session.recordSessionMetaFromInbound({
                 storePath, sessionKey: dynamicSessionKey, ctx: ctxPayload
             });
         } catch (err: any) {
@@ -139,7 +140,7 @@ export async function handleInbound(
 
     // 6. Dispatch
     try {
-        await runtime.reply.dispatchReplyFromConfig({
+        await channelRuntime.reply.dispatchReplyFromConfig({
             ctx: ctxPayload, 
             cfg: accountScopedCfg, 
             dispatcher,

package/src/index.ts

@@ -141,51 +141,83 @@ 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, async (inbound, jobId) => {
-                // Pass the context-aware runtime and the plugin instance
-                await handleInbound(ctx.runtime, inbound, jobId, robot, pierPlugin);
+            // Use ctx as the runtime provider as it contains .channelRuntime, .log, etc.
+            const robot = new PierRobot(config, ctx as any, async (inbound, jobId) => {
+                // Pass the context containing channelRuntime
+                await handleInbound(ctx, inbound, jobId, robot, pierPlugin);
             });
             instances.set(ctx.accountId, robot);
             
             try {
+                (robot as any).lastStartAt = Date.now();
                 await robot.start();
+                
                 ctx.setStatus({ 
                     ...ctx.getStatus(),
                     running: true, 
-                    lastStartAt: Date.now() 
+                    connected: true,
+                    lastStartAt: (robot as any).lastStartAt 
                 } as any);
 
-                // Keep the account active until the abort signal is received
+                // IMPORTANT: Keep startAccount promise active for the lifetime of the connection.
+                // If this promise resolves, the Gateway will auto-restart the account.
                 await new Promise<void>((resolve) => {
                     ctx.abortSignal.addEventListener('abort', () => {
                         resolve();
                     }, { once: true });
+                    
+                    if (ctx.abortSignal.aborted) resolve();
                 });
+                
+                console.log(`[pier-connector][${ctx.accountId}] Account signal aborted. Stopping...`);
             } catch (err: any) {
+                (robot as any).lastError = err.message;
                 ctx.setStatus({
                     ...ctx.getStatus(),
                     running: false,
                     lastError: err.message
                 } as any);
-                throw err; // Re-throw to signal failure to Gateway
+                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: Date.now() 
+                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,