@gholl-studio/pier-connector 0.3.18 → 0.3.20

package/package.json

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

@@ -3,35 +3,25 @@
  * @description Manages inbound message processing, agent routing resolution, and session context propagation.
  */
 
-import type { PierPluginApi, InboundMessage } from './types.js';
+import type { InboundMessage } from './types.js';
 import { truncate } from './job-handler.js';
 
 export async function handleInbound(
-    api: PierPluginApi,
+    runtime: any, // Using context-aware runtime from gateway
     inbound: InboundMessage,
     jobId: string,
-    robot: any, // Avoiding circular dependency with type PierRobot
-    pierChannel: any
+    robot: any,
+    pierPlugin: any
 ) {
-    const logger = api.logger;
-    if (!api.runtime?.channel?.reply) {
-        logger.error(`[pier-connector][${robot.accountId}] SDK Error: api.runtime.channel.reply is not available.`);
+    const logger = runtime.log || console;
+    
+    if (!runtime.reply) {
+        console.error(`[pier-connector][${robot.accountId}] SDK Error: runtime.reply is not available.`);
         return;
     }
 
-    // 0. Log Online/Configured Agents
-    const agentsList = (api.config as any)?.agents?.list || [];
-    const agentIds = Array.isArray(agentsList) ? agentsList.map((a: any) => a.id) : Object.keys(agentsList);
-    logger.info(`[pier-connector][${robot.accountId}] Available agents in OpenClaw: ${JSON.stringify(agentIds)}`);
-
-    // 1. Resolve Account-Scoped Configuration (Flat Structure for SDK)
-    /**
-     * ★ Multi-Account Configuration Isolation: 
-     * SDK helpers like resolveAgentRoute expect the channel config at the top level 
-     * of cfg.channels.<channelName>. Replacing it with the robot's merged config 
-     * ensures the SDK sees the correct agentId/dmPolicy for this specific account.
-     */
-    const rootConfig = api.config || {};
+    // 1. Resolve Account-Scoped Configuration
+    const rootConfig = runtime.cfg || {};
     const accountScopedCfg = {
         ...rootConfig,
         channels: { 
@@ -40,8 +30,8 @@ export async function handleInbound(
         }
     };
 
-    // 2. Resolve Agent Route via SDK with Scoped Config
-    const route = api.runtime.channel.routing.resolveAgentRoute({
+    // 2. Resolve Agent Route
+    const route = runtime.routing.resolveAgentRoute({
         cfg: accountScopedCfg,
         channel: 'pier',
         accountId: robot.accountId,
@@ -53,30 +43,6 @@ export async function handleInbound(
 
     logger.info(`[pier-connector] Routing account '${robot.accountId}' -> agent '${finalAgentId}' (Source: ${routingSource})`);
     
-    // Debug: Check Agent Identity & Detailed Config
-    try {
-        const identity = (api.runtime as any).agent.resolveAgentIdentity(accountScopedCfg, finalAgentId);
-        logger.info(`[pier-connector:debug] Identity resolution [0.3.18] for ${finalAgentId}: ${JSON.stringify(identity)}`);
-        
-        // Deep Config Inspection
-        const agentsList = (accountScopedCfg as any)?.agents?.list || [];
-        const targetedAgent = agentsList.find((a: any) => a.id === finalAgentId);
-        if (targetedAgent) {
-            logger.info(`[pier-connector:debug] FULL AGENT CONFIG for ${finalAgentId}: ${JSON.stringify({
-                id: targetedAgent.id,
-                name: targetedAgent.name,
-                agentDir: targetedAgent.agentDir,
-                workspace: targetedAgent.workspace,
-                runtime: targetedAgent.runtime,
-                model: targetedAgent.model
-            })}`);
-        } else {
-            logger.warn(`[pier-connector:debug] Agent ${finalAgentId} NOT FOUND in agents.list of scoped config!`);
-        }
-    } catch (err: any) {
-        logger.warn(`[pier-connector:debug] Identity resolution crash for ${finalAgentId}: ${err.message}`);
-    }
-
     const dynamicSessionKey = `pier-job-${jobId}`;
     const metadata = robot.activeNodeJobs.get(jobId);
     let injectedPrompt = "";
@@ -105,19 +71,18 @@ 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({
+    // 3. Finalize Context
+    const ctxPayload = runtime.reply.finalizeInboundContext({
         Body: inbound.body,
         BodyForAgent: inbound.body,
         RawBody: inbound.body,
-        From: inbound.senderId, // Fix: senderId already includes "pier:" prefix
+        From: inbound.senderId,
         To: `chat:${jobId}`,
         SessionKey: dynamicSessionKey,
         AccountId: robot.accountId, 
         ChatType: 'direct',
         SenderId: inbound.senderId,
-        SenderName: inbound.senderId, // Use senderId as name if unknown
+        SenderName: inbound.senderId,
         Provider: 'pier',
         Surface: 'pier',
         OriginatingChannel: 'pier',
@@ -130,27 +95,25 @@ export async function handleInbound(
         Metadata: { 
             ...metadata,
             accountId: robot.accountId,
-            agentId: finalAgentId, // Explicitly tell SDK which agent we want
+            agentId: finalAgentId,
             pierJobId: jobId,
             routingSource: routingSource
         }
     });
 
-    logger.info(`[pier-connector:trace] FULL DISPATCH CONTEXT for job ${jobId}: ${JSON.stringify(ctxPayload)}`);
-
-    const { dispatcher, markDispatchIdle } = api.runtime.channel.reply.createReplyDispatcherWithTyping({
+    // 4. Create Dispatcher
+    const { dispatcher, markDispatchIdle } = runtime.reply.createReplyDispatcherWithTyping({
         deliver: async (payload: any, info: any) => {
             const currentMeta = robot.activeNodeJobs.get(jobId);
-            const rawResponder = payload.agentId || payload.btw?.agentId || payload.channelData?.agentId;
-            const resAgent = rawResponder || finalAgentId;
+            const resAgent = payload.agentId || finalAgentId;
             
-            logger.info(`[pier-connector:trace] Outbound delivery for ${jobId}. Mode: ${info?.kind}. Responder: ${resAgent} (Raw: ${rawResponder || 'none'}).`);
-            logger.info(`[pier-connector:debug] FULL PAYLOAD: ${JSON.stringify(payload)}`);
+            logger.info(`[pier-connector:trace] Outbound delivery for ${jobId}. Responder: ${resAgent}.`);
 
             if (payload.text && payload.text.length > 0) {
-                await pierChannel.outbound.sendText({
+                await pierPlugin.outbound.sendText({
                     text: payload.text,
                     to: `pier:${jobId}`,
+                    accountId: robot.accountId,
                     metadata: { 
                         ...currentMeta, 
                         accountId: robot.accountId,
@@ -162,11 +125,11 @@ export async function handleInbound(
         }
     });
 
-    if (api.runtime.channel.session?.recordSessionMetaFromInbound) {
+    // 5. Session Recording
+    if (runtime.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({
+            const storePath = runtime.session.resolveStorePath(dynamicSessionKey);
+            await runtime.session.recordSessionMetaFromInbound({
                 storePath, sessionKey: dynamicSessionKey, ctx: ctxPayload
             });
         } catch (err: any) {
@@ -174,22 +137,22 @@ export async function handleInbound(
         }
     }
 
+    // 6. Dispatch
     try {
-        logger.info(`[pier-connector:trace] Dispatching reply to agent ${finalAgentId}...`);
-        await api.runtime.channel.reply.dispatchReplyFromConfig({
+        await runtime.reply.dispatchReplyFromConfig({
             ctx: ctxPayload, 
             cfg: accountScopedCfg, 
             dispatcher,
             replyOptions: {
                 onModelSelected: (mCtx: any) => {
-                    logger.info(`[pier-connector:debug] Model selected for ${jobId}: ${mCtx.provider}/${mCtx.model} (Think: ${mCtx.thinkLevel})`);
+                    logger.info(`[pier-connector:debug] Model selected for ${jobId}: ${mCtx.provider}/${mCtx.model}`);
                 }
             }
-        } as any);
-        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();
+        markDispatchIdle?.();
     }
 }
+

package/src/index.ts

@@ -1,9 +1,11 @@
 /**
  * @file index.ts
- * @description Main entry point for the Pier Connector plugin. Orchestrates robots, tools, and channel registration.
+ * @description Main entry point for the Pier Connector plugin. 
+ * Implements the standard OpenClaw ChannelPlugin interface for native multi-account support.
  */
 
 import { definePluginEntry } from 'openclaw/plugin-sdk/plugin-entry';
+import type { ChannelPlugin, OpenClawConfig, PluginRuntime } from 'openclaw/plugin-sdk';
 import { protocol } from '@gholl-studio/pier-sdk';
 const { createRequestPayload } = protocol;
 import { DEFAULTS } from './config.js';
@@ -12,99 +14,191 @@ import { handleInbound } from './inbound.js';
 import { registerCli } from './cli.js';
 import type { PierAccountConfig, PierPluginApi } from './types.js';
 
-const register = (api: PierPluginApi) => {
-    const logger = api.logger;
-    const instances = new Map<string, PierRobot>();
-    const globalStats = { received: 0, completed: 0, failed: 0 };
+// Global instances map to track active robots by account ID
+const instances = new Map<string, PierRobot>();
 
-    function mergedCfgFrom(legacy: any, account: any): PierAccountConfig {
-        const merged = { ...legacy, ...account };
-        return {
-            accountId: account.accountId || 'default',
-            pierApiUrl: merged.pierApiUrl || DEFAULTS.PIER_API_URL,
-            nodeId: merged.nodeId || DEFAULTS.NODE_ID,
-            secretKey: merged.secretKey || DEFAULTS.SECRET_KEY,
-            privateKey: merged.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
-            natsUrl: merged.natsUrl || DEFAULTS.NATS_URL,
-            subject: merged.subject || DEFAULTS.SUBJECT,
-            publishSubject: merged.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
-            queueGroup: merged.queueGroup || DEFAULTS.QUEUE_GROUP,
-            agentId: merged.agentId || DEFAULTS.AGENT_ID,
-            walletAddress: merged.walletAddress || DEFAULTS.WALLET_ADDRESS,
-            capabilities: merged.capabilities || ['translation', 'code-execution', 'reasoning', 'vision'],
-        };
-    }
-
-    function resolveConfigs(): PierAccountConfig[] {
-        const globalAccounts = (api.config as any)?.channels?.['pier']?.accounts || {};
-        const pluginAccounts = (api.pluginConfig as any)?.accounts || {};
-        const rawAccounts = { ...globalAccounts, ...pluginAccounts };
-        const legacyCfg = api.pluginConfig || {};
+/**
+ * Merges global/legacy config with account-specific overrides.
+ */
+function mergedCfgFrom(legacy: any, account: any): PierAccountConfig {
+    const merged = { ...legacy, ...account };
+    return {
+        accountId: account.accountId || 'default',
+        pierApiUrl: merged.pierApiUrl || DEFAULTS.PIER_API_URL,
+        nodeId: merged.nodeId || DEFAULTS.NODE_ID,
+        secretKey: merged.secretKey || DEFAULTS.SECRET_KEY,
+        privateKey: merged.privateKey || process.env.PIER_PRIVATE_KEY || DEFAULTS.PRIVATE_KEY,
+        natsUrl: merged.natsUrl || DEFAULTS.NATS_URL,
+        subject: merged.subject || DEFAULTS.SUBJECT,
+        publishSubject: merged.publishSubject || DEFAULTS.PUBLISH_SUBJECT,
+        queueGroup: merged.queueGroup || DEFAULTS.QUEUE_GROUP,
+        agentId: merged.agentId || DEFAULTS.AGENT_ID,
+        walletAddress: merged.walletAddress || DEFAULTS.WALLET_ADDRESS,
+        capabilities: merged.capabilities || ['translation', 'code-execution', 'reasoning', 'vision'],
+    };
+}
 
-        if (Object.keys(rawAccounts).length === 0) {
-            return [mergedCfgFrom(legacyCfg, { accountId: 'default' })];
-        }
+/**
+ * Resolves all configured accounts for the Pier channel.
+ */
+function getAccountConfigs(cfg: OpenClawConfig, pluginConfig: any): PierAccountConfig[] {
+    const globalAccounts = (cfg as any)?.channels?.['pier']?.accounts || {};
+    const pluginAccounts = pluginConfig?.accounts || {};
+    const rawAccounts = { ...globalAccounts, ...pluginAccounts };
+    const legacyCfg = pluginConfig || {};
 
-        return Object.entries(rawAccounts).map(([id, account]: [string, any]) => 
-            mergedCfgFrom(legacyCfg, { ...account, accountId: id })
-        );
+    if (Object.keys(rawAccounts).length === 0) {
+        return [mergedCfgFrom(legacyCfg, { accountId: 'default' })];
     }
 
-    const pierChannel = {
+    return Object.entries(rawAccounts).map(([id, account]: [string, any]) => 
+        mergedCfgFrom(legacyCfg, { ...account, accountId: id })
+    );
+}
+
+const pierPlugin: ChannelPlugin<PierAccountConfig> = {
+    id: 'pier',
+
+    meta: {
         id: 'pier',
-        meta: {
-            id: 'pier',
-            label: 'Pier',
-            selectionLabel: 'Pier (NATS Job Marketplace)',
-            blurb: 'Connect to the Pier distributed job marketplace.'
+        label: 'Pier',
+        selectionLabel: 'Pier (NATS Job Marketplace)',
+        docsPath: '/channels/pier',
+        blurb: 'Connect to the Pier distributed job marketplace.',
+    },
+
+    capabilities: {
+        chatTypes: ['direct'],
+        media: false,
+        reactions: false,
+        threads: false,
+        nativeCommands: true,
+        blockStreaming: true,
+    },
+
+    // -------------------------------------------------------------------------
+    // Config Adapter
+    // -------------------------------------------------------------------------
+    config: {
+        listAccountIds: (cfg) => {
+            const accounts = (cfg as any)?.channels?.['pier']?.accounts || {};
+            const ids = Object.keys(accounts);
+            return ids.length > 0 ? ids : ['default'];
         },
-        outbound: {
-            sendText: async (params: any) => {
-                const robot = instances.get(params.metadata?.accountId || 'default') || instances.values().next().value;
-                if (!robot || !robot.js) return;
-                
-                const jobId = params.metadata?.pierJobId || params.to.replace(/^pier:/, '');
-                const subject = `chat.${jobId}`;
-                
-                const payload = {
-                    id: crypto.randomUUID ? crypto.randomUUID() : (Math.random().toString(36).substring(2)),
-                    job_id: jobId,
-                    sender_id: robot.config.nodeId,
-                    sender_name: robot.accountId,
-                    sender_type: 'node',
-                    content: params.text,
-                    created_at: new Date().toISOString(),
-                    auth_token: robot.config.secretKey
-                };
+        resolveAccount: (cfg, accountId) => {
+            const accounts = (cfg as any)?.channels?.['pier']?.accounts || {};
+            const account = accounts[accountId || 'default'] || {};
+            return mergedCfgFrom((cfg as any)?.channels?.['pier'] || {}, { ...account, accountId: accountId || 'default' });
+        },
+        defaultAccountId: () => 'default'
+    },
+
+    // -------------------------------------------------------------------------
+    // Pairing Adapter
+    // -------------------------------------------------------------------------
+    pairing: {
+        idLabel: 'pierJobId',
+        normalizeAllowEntry: (entry) => entry.replace(/^(pier|job):/i, ''),
+        notifyApproval: async ({ cfg, id, accountId }) => {
+            // Signal received when 'openclaw pairing approve pier <id>' is run.
+            // Useful if we want to trigger specific onboarding or status updates.
+            console.log(`[pier-connector] Pairing approved for Job ${id} on account ${accountId}`);
+        }
+    },
 
-                await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
+    // -------------------------------------------------------------------------
+    // Outbound Adapter
+    // -------------------------------------------------------------------------
+    outbound: {
+        deliveryMode: 'direct',
+        sendText: async (ctx) => {
+            const robot = instances.get(ctx.accountId || 'default') || instances.values().next().value;
+            if (!robot || !robot.js) {
+                throw new Error('Robot not connected');
             }
+            
+            const jobId = ctx.to.replace(/^pier:/, '');
+            const subject = `chat.${jobId}`;
+            
+            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: robot.accountId,
+                sender_type: 'node',
+                content: ctx.text,
+                created_at: new Date().toISOString(),
+                auth_token: robot.config.secretKey
+            };
+
+            await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(payload)));
+            
+            return { 
+                channel: 'pier',
+                messageId: payload.id,
+                conversationId: jobId
+            };
         }
-    };
+    },
 
-    api.registerChannel(pierChannel as any);
+    // -------------------------------------------------------------------------
+    // 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);
+            });
+            instances.set(ctx.accountId, robot);
+            
+            try {
+                await robot.start();
+                ctx.setStatus({ 
+                    ...ctx.getStatus(),
+                    running: true, 
+                    lastStartAt: Date.now() 
+                } as any);
 
-    api.registerService({
-        id: 'pier-connector',
-        start: async () => {
-            const configs = resolveConfigs();
-            for (const config of configs) {
-                const robot = new PierRobot(config, api, async (inbound, jobId) => {
-                    await handleInbound(api, inbound, jobId, robot, pierChannel);
-                    globalStats.received++;
+                // Keep the account active until the abort signal is received
+                await new Promise<void>((resolve) => {
+                    ctx.abortSignal.addEventListener('abort', () => {
+                        resolve();
+                    }, { once: true });
                 });
-                instances.set(config.accountId, robot);
-                await robot.start();
+            } catch (err: any) {
+                ctx.setStatus({
+                    ...ctx.getStatus(),
+                    running: false,
+                    lastError: err.message
+                } as any);
+                throw err; // Re-throw to signal failure to Gateway
             }
         },
-        stop: async () => {
-            for (const robot of instances.values()) {
+        stopAccount: async (ctx) => {
+            const robot = instances.get(ctx.accountId);
+            if (robot) {
                 await robot.stop();
+                instances.delete(ctx.accountId);
             }
-            instances.clear();
+            ctx.setStatus({ 
+                ...ctx.getStatus(),
+                running: false, 
+                lastStopAt: Date.now() 
+            } as any);
         }
-    });
+    }
+};
 
+const register = (api: PierPluginApi) => {
+    const logger = api.logger;
+    const globalStats = { received: 0, completed: 0, failed: 0 };
+
+    // Register our new ChannelPlugin
+    api.registerChannel({ plugin: pierPlugin as any });
+
+    // Tools and CLI registration
     api.registerTool({
         name: 'pier_publish',
         label: 'Publish to Pier',
@@ -193,6 +287,7 @@ const register = (api: PierPluginApi) => {
         { optional: true }
     );
 
+    // Helper to register marketplace action tools
     const registerSystemActionTool = (name: string, label: string, description: string, action: string, extraParams: any, userRole = 'node') => {
         api.registerTool({
             name,
@@ -215,7 +310,6 @@ const register = (api: PierPluginApi) => {
                 }
 
                 try {
-                    const subject = `chat.${params.jobId}`;
                     const { jobId: j, accountId: _, ...p } = params;
 
                     if (!robot.js) {
@@ -234,7 +328,7 @@ const register = (api: PierPluginApi) => {
                         action: action
                     };
 
-                    await robot.js.publish(subject, new TextEncoder().encode(JSON.stringify(msgData)));
+                    await robot.js.publish(`chat.${params.jobId}`, 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: {} };
@@ -279,7 +373,7 @@ const register = (api: PierPluginApi) => {
         }
     }, { optional: true });
 
-    // Register simple status command
+    // Status Command
     api.registerCommand({
         name: 'pier',
         description: 'Show Pier status',
@@ -302,3 +396,4 @@ export default definePluginEntry({
     description: 'Connects OpenClaw to the Pier job marketplace.',
     register
 });
+

package/src/robot.ts

@@ -25,20 +25,20 @@ export class PierRobot {
     public connectionStatus: 'disconnected' | 'connecting' | 'connected' | 'error' = 'disconnected';
     public stats = { received: 0, completed: 0, failed: 0 };
     
-    private api: PierPluginApi;
+    private runtime: any;
     private logger: any;
     private heartbeatTimer: NodeJS.Timeout | null = null;
     private onInbound: (inbound: InboundMessage, jobId: string) => Promise<void>;
 
     constructor(
         config: PierAccountConfig, 
-        api: PierPluginApi, 
+        runtime: any, 
         onInbound: (inbound: InboundMessage, jobId: string) => Promise<void>
     ) {
         this.config = config;
         this.accountId = config.accountId;
-        this.api = api;
-        this.logger = api.logger;
+        this.runtime = runtime;
+        this.logger = runtime.log || console;
         this.onInbound = onInbound;
         this.client = new PierClient({ 
             apiUrl: config.pierApiUrl,
@@ -264,7 +264,7 @@ export class PierRobot {
 
     async autoRegister() {
         if (!this.config.privateKey) return;
-        const hostName = `${(this.api as any).getRuntimeInfo?.()?.hostname ?? 'Auto'}-${this.accountId}`;
+        const hostName = `${this.runtime?.hostname ?? 'Auto'}-${this.accountId}`;
         const { nodeId, secretKey } = await this.client.autoRegister(this.config.privateKey, hostName);
         this.config.nodeId = nodeId;
         this.config.secretKey = secretKey;
@@ -292,16 +292,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';
     }
 }