@gholl-studio/pier-connector 0.6.3 → 0.6.5

package/dist/index.js

@@ -0,0 +1,644 @@
+/**
+ * @file index.ts
+ * @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 { protocol, PierCrypto } from '@gholl-studio/pier-sdk';
+const { createRequestPayload } = protocol;
+import { DEFAULTS } from './config.js';
+import { PierRobot } from './robot.js';
+import { handleInbound } from './inbound.js';
+import { registerCli } from './cli.js';
+// Global instances map to track active robots by account ID
+const instances = new Map();
+/**
+ * Merges global/legacy config with account-specific overrides.
+ */
+function mergedCfgFrom(legacy, account) {
+    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 || 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'],
+    };
+}
+/**
+ * Resolves all configured accounts for the Pier channel.
+ */
+function getAccountConfigs(cfg, pluginConfig) {
+    const globalAccounts = cfg?.channels?.['pier']?.accounts || {};
+    const pluginAccounts = pluginConfig?.accounts || {};
+    const rawAccounts = { ...globalAccounts, ...pluginAccounts };
+    const legacyCfg = pluginConfig || {};
+    if (Object.keys(rawAccounts).length === 0) {
+        return [mergedCfgFrom(legacyCfg, { accountId: 'default' })];
+    }
+    return Object.entries(rawAccounts).map(([id, account]) => mergedCfgFrom(legacyCfg, { ...account, accountId: id }));
+}
+const pierPlugin = {
+    id: 'pier',
+    meta: {
+        id: 'pier',
+        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?.channels?.['pier']?.accounts || {};
+            const ids = Object.keys(accounts);
+            return ids.length > 0 ? ids : ['default'];
+        },
+        resolveAccount: (cfg, accountId) => {
+            const accounts = cfg?.channels?.['pier']?.accounts || {};
+            const account = accounts[accountId || 'default'] || {};
+            return mergedCfgFrom(cfg?.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}`);
+        }
+    },
+    // -------------------------------------------------------------------------
+    // 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 jobMeta = robot.activeNodeJobs.get(jobId);
+            const isWorkspace = jobMeta?.workspace === true || ctx.metadata?.workspace === true;
+            const subject = isWorkspace ? `workspace.${jobId}.chat` : `chat.${jobId}`;
+            const payload = {
+                id: globalThis.crypto.randomUUID ? globalThis.crypto.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
+            };
+        }
+    },
+    // -------------------------------------------------------------------------
+    // Status Adapter
+    // -------------------------------------------------------------------------
+    status: {
+        buildAccountSnapshot: ({ account, cfg }) => {
+            const robot = instances.get(account.accountId);
+            return {
+                accountId: account.accountId,
+                running: !!robot,
+                connected: robot?.connectionStatus === 'connected',
+                lastStartAt: robot?.lastStartAt,
+                lastStopAt: robot?.lastStopAt,
+                lastError: robot?.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;
+            // Use ctx as the runtime provider as it contains .channelRuntime, .log, etc.
+            const robot = new PierRobot(config, ctx, async (inbound, jobId) => {
+                // Pass the context containing channelRuntime
+                await handleInbound(ctx, inbound, jobId, robot, pierPlugin);
+            });
+            instances.set(ctx.accountId, robot);
+            try {
+                robot.lastStartAt = Date.now();
+                await robot.start();
+                ctx.setStatus({
+                    ...ctx.getStatus(),
+                    running: true,
+                    connected: true,
+                    lastStartAt: robot.lastStartAt
+                });
+                // 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((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) {
+                robot.lastError = err.message;
+                ctx.setStatus({
+                    ...ctx.getStatus(),
+                    running: false,
+                    lastError: err.message
+                });
+                throw err;
+            }
+        },
+        stopAccount: async (ctx) => {
+            const robot = instances.get(ctx.accountId);
+            if (robot) {
+                robot.lastStopAt = Date.now();
+                await robot.stop();
+                instances.delete(ctx.accountId);
+            }
+            ctx.setStatus({
+                ...ctx.getStatus(),
+                running: false,
+                lastStopAt: robot.lastStopAt
+            });
+        }
+    }
+};
+const register = (api) => {
+    const logger = api.logger;
+    const globalStats = { received: 0, completed: 0, failed: 0 };
+    // Register our new ChannelPlugin
+    api.registerChannel({ plugin: pierPlugin });
+    // Tools and CLI registration
+    api.registerTool({
+        name: 'pier_publish',
+        label: 'Publish to Pier',
+        description: 'Publish a task to the Pier job marketplace.',
+        parameters: {
+            type: 'object',
+            properties: {
+                task: { type: 'string' },
+                accountId: { type: 'string' }
+            },
+            required: ['task']
+        },
+        async execute(_id, params, ctx) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+            const robot = instances.get(accountId) || instances.values().next().value;
+            if (!robot || robot.connectionStatus !== 'connected') {
+                return {
+                    content: [{ type: 'text', text: 'Robot not connected' }],
+                    details: {}
+                };
+            }
+            const taskPayload = createRequestPayload({ task: params.task });
+            const reply = await robot.nc.request(robot.config.publishSubject, new TextEncoder().encode(JSON.stringify(taskPayload)));
+            return {
+                content: [{ type: 'text', text: new TextDecoder().decode(reply.data) }],
+                details: {}
+            };
+        }
+    }, { 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) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.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.randomUUID ? globalThis.crypto.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) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    // Helper to register marketplace action tools
+    const registerSystemActionTool = (name, label, description, action, extraParams, 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, ctx) {
+                const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.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 { jobId: j, accountId: _, ...p } = params;
+                    if (!robot.js) {
+                        return { content: [{ type: 'text', text: 'Error: JetStream not available' }], details: {} };
+                    }
+                    const msgData = {
+                        id: globalThis.crypto.randomUUID ? globalThis.crypto.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(`chat.${params.jobId}`, new TextEncoder().encode(JSON.stringify(msgData)));
+                    return { content: [{ type: 'text', text: `${action} executed successfully` }], details: {} };
+                }
+                catch (err) {
+                    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, ctx) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+            const robot = instances.get(accountId) || 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) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    // Multi-Agent Workspace Tools
+    api.registerTool({
+        name: 'pier_create_workspace',
+        label: 'Create Workspace',
+        description: 'Creates a decentralized multi-agent workspace (group chat) and initializes its whiteboard.',
+        parameters: {
+            type: 'object',
+            properties: {
+                namespace: { type: 'string', description: 'Federation namespace. Default to "default" if omitted.' }
+            }
+        },
+        async execute(_id, params, ctx) {
+            const accountId = params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default';
+            const robot = instances.get(accountId) || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
+            try {
+                const groupId = globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2));
+                const kv = await robot.client.nats.getWorkspaceKV(groupId);
+                await kv.put('status', new TextEncoder().encode('Active Workspace Created'));
+                await kv.put('budget', new TextEncoder().encode('100'));
+                return { content: [{ type: 'text', text: `Workspace created successfully. Group ID: ${groupId}. Initial budget set to 100.` }], details: { groupId } };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: 'pier_read_whiteboard',
+        label: 'Read Whiteboard',
+        description: 'Read the current shared state from the workspace whiteboard (NATS KV)',
+        parameters: {
+            type: 'object',
+            properties: {
+                groupId: { type: 'string', description: 'The Workspace Group ID' },
+                key: { type: 'string', description: 'The key to read' },
+                namespace: { type: 'string', description: 'Federation namespace' }
+            },
+            required: ['groupId', 'key']
+        },
+        async execute(_id, params, ctx) {
+            const robot = instances.get(params.accountId || ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Error: Robot not found' }], details: {} };
+            try {
+                const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
+                const entry = await kv.get(params.key);
+                if (!entry)
+                    return { content: [{ type: 'text', text: '[Whiteboard: Key Not Found. Use revision 0 to update.]' }], details: { revision: 0 } };
+                const valueStr = new TextDecoder().decode(entry.value);
+                const result = JSON.stringify({ revision: entry.revision, value: valueStr });
+                return { content: [{ type: 'text', text: `Data retrieved:\n${result}\n(Supply this revision to pier_update_whiteboard)` }], details: { revision: entry.revision } };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: 'pier_update_whiteboard',
+        label: 'Update Whiteboard',
+        description: 'Update the shared state on the workspace whiteboard using CAS (Compare-And-Swap). Provide expected_revision from read.',
+        parameters: {
+            type: 'object',
+            properties: {
+                groupId: { type: 'string' },
+                key: { type: 'string' },
+                value: { type: 'string' },
+                expected_revision: { type: 'number', description: 'The revision number from the last read (use 0 if key not found)' },
+                namespace: { type: 'string' }
+            },
+            required: ['groupId', 'key', 'value', 'expected_revision']
+        },
+        async execute(_id, params, ctx) {
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Robot not found' }], details: {} };
+            try {
+                const kv = await robot.client.nats.getWorkspaceKV(params.groupId);
+                try {
+                    // if expected_revision is 0 it means we expect the key does not exist yet (or we use create)
+                    if (params.expected_revision === 0) {
+                        try {
+                            await kv.create(params.key, new TextEncoder().encode(params.value));
+                        }
+                        catch (e) {
+                            if (e.message?.includes('wrong last sequence'))
+                                throw e; // Pass to conflict handler
+                            await kv.update(params.key, new TextEncoder().encode(params.value), 0); // fallback
+                        }
+                    }
+                    else {
+                        await kv.update(params.key, new TextEncoder().encode(params.value), params.expected_revision);
+                    }
+                    return { content: [{ type: 'text', text: `Whiteboard key '${params.key}' updated successfully.` }], details: {} };
+                }
+                catch (updateErr) {
+                    if (updateErr.message && (updateErr.message.includes('wrong last sequence') || updateErr.code === '400' || updateErr.api_error?.err_code === 10071)) {
+                        return { content: [{ type: 'text', text: `ERROR: CAS Conflict - Another agent modified this key while you were working. Please use pier_read_whiteboard to get the latest revision and try again.` }], details: {} };
+                    }
+                    throw updateErr;
+                }
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: 'pier_group_mention',
+        label: 'Mention in Workspace',
+        description: 'Send a message in the workspace group chat explicitly mentioning an agent to wake them up',
+        parameters: {
+            type: 'object',
+            properties: {
+                groupId: { type: 'string' },
+                mentions: { type: 'array', items: { type: 'string' }, description: 'Array of target Agent Node IDs' },
+                content: { type: 'string', description: 'Message content' },
+                namespace: { type: 'string' }
+            },
+            required: ['groupId', 'mentions', 'content']
+        },
+        async execute(_id, params, ctx) {
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Robot not found' }], details: {} };
+            try {
+                const msgId = globalThis.crypto.randomUUID ? globalThis.crypto.randomUUID() : (Math.random().toString(36).substring(2));
+                const ns = params.namespace || 'default';
+                let payload = {
+                    version: 'psp-1.0',
+                    id: msgId,
+                    namespace: ns,
+                    timestamp: Date.now(),
+                    senderId: robot.accountId,
+                    groupId: params.groupId,
+                    content: params.content,
+                    mentions: params.mentions
+                };
+                if (robot.config.privateKey) {
+                    payload = await PierCrypto.signSwarmMessage(payload, robot.config.privateKey);
+                }
+                await robot.client.nats.publishGroupChat(params.groupId, payload, ns);
+                return { content: [{ type: 'text', text: `Message sent to workspace ${params.groupId} successfully.` }], details: {} };
+            }
+            catch (err) {
+                return { content: [{ type: 'text', text: `Error: ${err.message}` }], details: {} };
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: 'pier_search_workers',
+        label: 'Search Workers',
+        description: 'Find active agents on the Pier network. When \`capability\` is provided, uses fast Subject-based Discovery (PSP 1.0). Falls back to KV full-scan if omitted.',
+        parameters: {
+            type: 'object',
+            properties: {
+                capability: { type: 'string', description: '(Recommended) Filter by a specific capability e.g. "translation", "code-execution". Uses fast per-subject discovery when set.' }
+            }
+        },
+        async execute(_id, params, ctx) {
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Error' }], details: {} };
+            // --- PSP 1.0 Subject-based Discovery (fast path, used when capability is specified) ---
+            if (params.capability) {
+                try {
+                    const nodes = await robot.client.nats.queryDiscovery(params.capability);
+                    return { content: [{ type: 'text', text: JSON.stringify(nodes, null, 2) }], details: {} };
+                }
+                catch (e) {
+                    // Fall through to KV scan
+                }
+            }
+            // --- KV Full-scan (fallback when no capability filter, or subject discovery fails) ---
+            try {
+                const kv = await robot.client.nats.getWorkspaceKV('active_nodes');
+                const activeNodes = [];
+                const iter = await kv.keys();
+                for await (const k of iter) {
+                    const entry = await kv.get(k);
+                    if (entry) {
+                        try {
+                            // S10: DoS protection
+                            if (entry.value.length > 1024 * 1024)
+                                continue;
+                            const nodeData = JSON.parse(new TextDecoder().decode(entry.value));
+                            if (Date.now() - nodeData.timestamp < 120000) {
+                                // --- Zero-Trust: Verify signed heartbeat (PSP 1.0 Hard-Block) ---
+                                if (nodeData.version === 'psp-1.0' && nodeData.signature && nodeData.publicKey) {
+                                    const isValid = PierCrypto.verifySwarmMessage(nodeData);
+                                    if (!isValid) {
+                                        console.warn(`[pier_search_workers] 🔴 Dropping node ${k}: invalid signature (spoofed identity).`);
+                                        continue;
+                                    }
+                                }
+                                activeNodes.push(nodeData);
+                            }
+                        }
+                        catch (e) { }
+                    }
+                }
+                return { content: [{ type: 'text', text: JSON.stringify(activeNodes.slice(0, 10), null, 2) }], details: {} };
+            }
+            catch (e) {
+                // Final fallback: central API
+                try {
+                    const resp = await fetch(`${robot.client.apiUrl}/nodes`);
+                    const nodes = await resp.json();
+                    const active = nodes.filter((n) => n.is_online).slice(0, 10);
+                    return { content: [{ type: 'text', text: JSON.stringify(active, null, 2) }], details: {} };
+                }
+                catch (fallbackErr) {
+                    return { content: [{ type: 'text', text: `All discovery methods failed: ${e.message}` }], details: {} };
+                }
+            }
+        }
+    }, { optional: true });
+    api.registerTool({
+        name: 'pier_invite_collaborator',
+        label: 'Invite to Workspace',
+        description: 'Send a targeted job request to a node to invite them.',
+        parameters: {
+            type: 'object',
+            properties: {
+                nodeId: { type: 'string' },
+                groupId: { type: 'string' },
+                roleDescription: { type: 'string' },
+                namespace: { type: 'string' }
+            },
+            required: ['nodeId', 'groupId', 'roleDescription']
+        },
+        async execute(_id, params, ctx) {
+            const robot = instances.get(ctx?.metadata?.accountId || ctx?.accountId || 'default') || instances.values().next().value;
+            if (!robot)
+                return { content: [{ type: 'text', text: 'Error' }], details: {} };
+            try {
+                let req = createRequestPayload({
+                    task: `INVITATION: Join my workspace ${params.groupId}.\nRole: ${params.roleDescription}\nPlease use 'pier_group_mention' tool to reply in group ${params.groupId}.\nYou can also use 'pier_read_whiteboard' with groupId=${params.groupId} to view the plan.`,
+                    targetNodeId: params.nodeId,
+                    namespace: params.namespace || 'default',
+                    senderId: robot.accountId,
+                    meta: { sender: robot.accountId, workspace: params.groupId }
+                });
+                if (robot.config.privateKey) {
+                    req = await PierCrypto.signSwarmMessage(req, robot.config.privateKey);
+                }
+                await robot.js.publish(`jobs.node.${params.nodeId}`, new TextEncoder().encode(JSON.stringify(req)));
+                return { content: [{ type: 'text', text: `Invitation sent to ${params.nodeId}` }], details: {} };
+            }
+            catch (e) {
+                return { content: [{ type: 'text', text: e.message }], details: {} };
+            }
+        }
+    }, { optional: true });
+    // Status Command
+    api.registerCommand({
+        name: 'pier',
+        description: 'Show Pier status',
+        handler: () => {
+            const lines = ['**Pier Connector Status**'];
+            instances.forEach((r, id) => {
+                lines.push(`\n**Account: ${id}**\n• Status: ${r.connectionStatus}\n• Jobs: ${r.stats.received}/${r.stats.completed}/${r.stats.failed}`);
+            });
+            return { text: lines.join('\n') };
+        }
+    });
+    registerCli(api, globalStats);
+    logger.info('[pier-connector] Plugin registered');
+};
+export default definePluginEntry({
+    id: 'pier-connector',
+    name: 'Pier Connector',
+    description: 'Connects OpenClaw to the Pier job marketplace.',
+    register
+});
+//# sourceMappingURL=index.js.map