2020117-agent 0.3.4 → 0.3.6

package/dist/agent.js

@@ -69,7 +69,7 @@ import { randomBytes } from 'crypto';
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { createProcessor } from './processor.js';
 import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, getProfile, reportSession, } from './api.js';
-import { generateInvoice } from './clink.js';
+import { initClinkAgent, collectPayment, generateInvoice } from './clink.js';
 import { readFileSync } from 'fs';
 import WebSocket from 'ws';
 // Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
@@ -161,7 +161,12 @@ async function main() {
             console.log(`[${label}] Lightning Address loaded from platform: ${LIGHTNING_ADDRESS}`);
         }
     }
-    // 3. Platform registration + heartbeat
+    // 3. Initialize CLINK agent identity (for P2P session debit)
+    if (LIGHTNING_ADDRESS) {
+        const { pubkey } = initClinkAgent();
+        console.log(`[${label}] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
+    }
+    // 4. Platform registration + heartbeat
     await setupPlatform(label);
     // 5. Async inbox poller
     startInboxPoller(label);
@@ -336,6 +341,12 @@ async function startSwarmListener(label) {
                 node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
                 return;
             }
+            // Negotiate payment method: customer requests "invoice" or "ndebit" (default)
+            const paymentMethod = msg.payment_method || (msg.ndebit ? 'ndebit' : 'invoice');
+            if (paymentMethod === 'ndebit' && !msg.ndebit) {
+                node.send(socket, { type: 'error', id: msg.id, message: 'ndebit payment requires ndebit authorization' });
+                return;
+            }
             const satsPerMinute = state.skill?.pricing?.sats_per_minute
                 || Number(process.env.SATS_PER_MINUTE)
                 || msg.sats_per_minute
@@ -343,12 +354,14 @@ async function startSwarmListener(label) {
             const BILLING_INTERVAL_MIN = 10;
             const debitAmount = satsPerMinute * BILLING_INTERVAL_MIN;
             const sessionId = randomBytes(8).toString('hex');
-            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, billing every ${BILLING_INTERVAL_MIN}min (${debitAmount} sats)`);
+            console.log(`[${label}] Session ${sessionId} from ${tag}: ${satsPerMinute} sats/min, payment=${paymentMethod}, billing every ${BILLING_INTERVAL_MIN}min (${debitAmount} sats)`);
             const session = {
                 socket,
                 peerId,
                 sessionId,
                 satsPerMinute,
+                paymentMethod,
+                ndebit: msg.ndebit || '',
                 totalEarned: 0,
                 startedAt: Date.now(),
                 lastDebitAt: Date.now(),
@@ -356,60 +369,134 @@ async function startSwarmListener(label) {
                 timeoutTimer: null,
             };
             activeSessions.set(sessionId, session);
-            // Generate first invoice and send to customer for payment
-            let firstInvoice;
-            try {
-                firstInvoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
-            }
-            catch (e) {
-                console.warn(`[${label}] Session ${sessionId}: invoice error: ${e.message}`);
-                node.send(socket, { type: 'error', id: msg.id, message: `Invoice error: ${e.message}` });
-                activeSessions.delete(sessionId);
-                return;
+            if (paymentMethod === 'ndebit') {
+                // --- CLINK pull mode: provider debits customer immediately ---
+                let firstDebit;
+                try {
+                    firstDebit = await collectPayment({
+                        ndebit: session.ndebit,
+                        lightningAddress: LIGHTNING_ADDRESS,
+                        amountSats: debitAmount,
+                    });
+                }
+                catch (e) {
+                    console.warn(`[${label}] Session ${sessionId}: first debit error: ${e.message}`);
+                    node.send(socket, { type: 'error', id: msg.id, message: `Payment error: ${e.message}` });
+                    activeSessions.delete(sessionId);
+                    return;
+                }
+                if (!firstDebit.ok) {
+                    console.warn(`[${label}] Session ${sessionId}: first debit failed: ${firstDebit.error}`);
+                    node.send(socket, { type: 'error', id: msg.id, message: `Payment failed: ${firstDebit.error}` });
+                    activeSessions.delete(sessionId);
+                    return;
+                }
+                session.totalEarned += debitAmount;
+                session.lastDebitAt = Date.now();
+                console.log(`[${label}] Session ${sessionId}: first ${BILLING_INTERVAL_MIN}min paid (${debitAmount} sats)`);
+                node.send(socket, {
+                    type: 'session_ack',
+                    id: msg.id,
+                    session_id: sessionId,
+                    sats_per_minute: satsPerMinute,
+                    payment_method: 'ndebit',
+                });
+                node.send(socket, {
+                    type: 'session_tick_ack',
+                    id: sessionId,
+                    session_id: sessionId,
+                    amount: debitAmount,
+                    balance: msg.budget ? msg.budget - session.totalEarned : undefined,
+                });
+                // Recurring debit every 10 minutes
+                session.debitTimer = setInterval(async () => {
+                    let debit;
+                    try {
+                        debit = await collectPayment({
+                            ndebit: session.ndebit,
+                            lightningAddress: LIGHTNING_ADDRESS,
+                            amountSats: debitAmount,
+                        });
+                    }
+                    catch (e) {
+                        console.log(`[${label}] Session ${sessionId}: debit error (${e.message}) — ending session`);
+                        endSession(node, session, label);
+                        return;
+                    }
+                    if (!debit.ok) {
+                        console.log(`[${label}] Session ${sessionId}: debit failed (${debit.error}) — ending session`);
+                        endSession(node, session, label);
+                        return;
+                    }
+                    session.totalEarned += debitAmount;
+                    session.lastDebitAt = Date.now();
+                    console.log(`[${label}] Session ${sessionId}: debit OK (+${debitAmount}, total: ${session.totalEarned} sats)`);
+                    node.send(socket, {
+                        type: 'session_tick_ack',
+                        id: sessionId,
+                        session_id: sessionId,
+                        amount: debitAmount,
+                        balance: msg.budget ? msg.budget - session.totalEarned : undefined,
+                    });
+                }, BILLING_INTERVAL_MIN * 60_000);
             }
-            // Accept session first, then request payment
-            node.send(socket, {
-                type: 'session_ack',
-                id: msg.id,
-                session_id: sessionId,
-                sats_per_minute: satsPerMinute,
-            });
-            // Send invoice to customer — wait for session_tick_ack with preimage
-            const tickId = randomBytes(4).toString('hex');
-            node.send(socket, {
-                type: 'session_tick',
-                id: tickId,
-                session_id: sessionId,
-                bolt11: firstInvoice,
-                amount: debitAmount,
-            });
-            console.log(`[${label}] Session ${sessionId}: waiting for first payment (${debitAmount} sats)`);
-            // Billing every 10 minutes — send invoice, wait for customer to pay
-            session.debitTimer = setInterval(async () => {
-                let invoice;
+            else {
+                // --- Invoice push mode: provider sends bolt11, customer pays ---
+                node.send(socket, {
+                    type: 'session_ack',
+                    id: msg.id,
+                    session_id: sessionId,
+                    sats_per_minute: satsPerMinute,
+                    payment_method: 'invoice',
+                });
+                // Generate and send first invoice
+                let firstInvoice;
                 try {
-                    invoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+                    firstInvoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
                 }
                 catch (e) {
-                    console.log(`[${label}] Session ${sessionId}: invoice error (${e.message}) — ending session`);
-                    endSession(node, session, label);
+                    console.warn(`[${label}] Session ${sessionId}: invoice error: ${e.message}`);
+                    node.send(socket, { type: 'error', id: msg.id, message: `Invoice error: ${e.message}` });
+                    activeSessions.delete(sessionId);
                     return;
                 }
-                const tid = randomBytes(4).toString('hex');
+                const tickId = randomBytes(4).toString('hex');
                 node.send(socket, {
                     type: 'session_tick',
-                    id: tid,
+                    id: tickId,
                     session_id: sessionId,
-                    bolt11: invoice,
+                    bolt11: firstInvoice,
                     amount: debitAmount,
                 });
-                console.log(`[${label}] Session ${sessionId}: sent invoice for ${debitAmount} sats`);
-            }, BILLING_INTERVAL_MIN * 60_000);
+                console.log(`[${label}] Session ${sessionId}: sent first invoice (${debitAmount} sats)`);
+                // Recurring invoices every 10 minutes
+                session.debitTimer = setInterval(async () => {
+                    let invoice;
+                    try {
+                        invoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+                    }
+                    catch (e) {
+                        console.log(`[${label}] Session ${sessionId}: invoice error (${e.message}) — ending session`);
+                        endSession(node, session, label);
+                        return;
+                    }
+                    const tid = randomBytes(4).toString('hex');
+                    node.send(socket, {
+                        type: 'session_tick',
+                        id: tid,
+                        session_id: sessionId,
+                        bolt11: invoice,
+                        amount: debitAmount,
+                    });
+                    console.log(`[${label}] Session ${sessionId}: sent invoice for ${debitAmount} sats`);
+                }, BILLING_INTERVAL_MIN * 60_000);
+            }
             return;
         }
-        if (msg.type === 'session_tick_ack') {
+        // Handle invoice payment confirmation (invoice mode only)
+        if (msg.type === 'session_tick_ack' && msg.preimage) {
             const session = activeSessions.get(msg.session_id || '');
-            if (!session)
+            if (!session || session.paymentMethod !== 'invoice')
                 return;
             const amount = msg.amount || 0;
             session.totalEarned += amount;

package/dist/session.d.ts

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute wallet payments.
+ * per-minute payments (CLINK ndebit or Lightning invoice).
  *
  * Features:
- *   - Customer pays provider's invoices via built-in wallet
+ *   - Payment negotiation: ndebit (provider pulls) or invoice (customer pushes)
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *

package/dist/session.js

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 /**
  * P2P Session Client — "rent" a provider's service over Hyperswarm with
- * per-minute wallet payments.
+ * per-minute payments (CLINK ndebit or Lightning invoice).
  *
  * Features:
- *   - Customer pays provider's invoices via built-in wallet
+ *   - Payment negotiation: ndebit (provider pulls) or invoice (customer pushes)
  *   - HTTP proxy server for browser-based access to provider APIs
  *   - Interactive CLI REPL (generate, status, skill, help, quit)
  *
@@ -39,21 +39,25 @@ for (const arg of process.argv.slice(2)) {
             break;
         case '--ndebit':
             process.env.CLINK_NDEBIT = val;
-            break; // legacy, ignored
+            break;
     }
 }
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
-import { walletPayInvoice, walletGetBalance } from './api.js';
+import { loadNdebit, walletPayInvoice, walletGetBalance, hasApiKey } from './api.js';
 import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
 import { mkdirSync, writeFileSync } from 'fs';
 import { WebSocketServer, WebSocket as WsWebSocket } from 'ws';
+// Polyfill global WebSocket for Node.js < 22 (needed by @shocknet/clink-sdk)
+if (!globalThis.WebSocket)
+    globalThis.WebSocket = WsWebSocket;
 // --- Config ---
 const KIND = Number(process.env.DVM_KIND) || 5200;
 const BUDGET = Number(process.env.BUDGET_SATS) || 500;
 const PORT = Number(process.env.SESSION_PORT) || 8080;
+const NDEBIT = process.env.CLINK_NDEBIT || loadNdebit() || '';
 const TICK_INTERVAL_MS = 60_000;
 const HTTP_TIMEOUT_MS = 60_000;
 const state = {
@@ -159,7 +163,7 @@ function setupMessageHandler() {
                 break;
             }
             case 'session_tick': {
-                // Provider sent an invoice for the next billing period — pay it
+                // Invoice mode: provider sent a bolt11 invoice — pay it
                 if (msg.bolt11 && msg.amount !== undefined) {
                     const amount = msg.amount;
                     if (state.totalSpent + amount > BUDGET) {
@@ -188,7 +192,7 @@ function setupMessageHandler() {
                 break;
             }
             case 'session_tick_ack': {
-                // Legacy: provider-pull model notification (backward compat)
+                // Ndebit mode: provider debited our wallet and is reporting the result
                 if (msg.amount !== undefined) {
                     state.totalSpent += msg.amount;
                 }
@@ -663,13 +667,28 @@ async function main() {
     state.satsPerMinute = satsPerMinute;
     log(`Pricing: ${satsPerMinute} sats/min`);
     log(`Budget: ${BUDGET} sats (~${Math.floor(BUDGET / satsPerMinute)} min)`);
-    // 4. Check wallet balance
-    const balance = await walletGetBalance();
-    if (balance < BUDGET) {
-        warn(`Wallet balance (${balance} sats) is less than budget (${BUDGET} sats).`);
-        warn(`Fund your wallet: curl -X POST ${process.env.API_2020117_URL || 'https://2020117.xyz'}/api/wallet/invoice -H "Authorization: Bearer ..." -d '{"amount_sats":${BUDGET}}'`);
+    // 4. Negotiate payment method: ndebit (CLINK pull) or invoice (wallet push)
+    let paymentMethod;
+    if (NDEBIT) {
+        paymentMethod = 'ndebit';
+        log(`Payment: CLINK ndebit (provider pulls per-minute)`);
+    }
+    else if (hasApiKey()) {
+        paymentMethod = 'invoice';
+        const balance = await walletGetBalance();
+        if (balance < BUDGET) {
+            warn(`Wallet balance (${balance} sats) is less than budget (${BUDGET} sats).`);
+            warn(`Fund your wallet: POST ${process.env.API_2020117_URL || 'https://2020117.xyz'}/api/wallet/invoice`);
+        }
+        log(`Payment: invoice (wallet pays provider, balance: ${balance} sats)`);
+    }
+    else {
+        warn('No payment method available.');
+        warn('  Option 1: --ndebit=ndebit1... (CLINK wallet authorization)');
+        warn('  Option 2: --agent=NAME (built-in wallet via API key)');
+        await node.destroy();
+        process.exit(1);
     }
-    log(`Wallet balance: ${balance} sats`);
     // 5. Send session_start, wait for session_ack
     const startId = randomBytes(4).toString('hex');
     const ackResp = await sendAndWait({
@@ -677,6 +696,8 @@ async function main() {
         id: startId,
         budget: BUDGET,
         sats_per_minute: satsPerMinute,
+        payment_method: paymentMethod,
+        ...(paymentMethod === 'ndebit' ? { ndebit: NDEBIT } : {}),
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);
@@ -691,7 +712,7 @@ async function main() {
         log(`Provider adjusted rate: ${ackResp.sats_per_minute} sats/min`);
     }
     log(`Session started: ${state.sessionId}`);
-    log(`Billing: ${state.satsPerMinute} sats/min (wallet → provider invoice)`);
+    log(`Billing: ${state.satsPerMinute} sats/min via ${paymentMethod}`);
     // 6. Start HTTP proxy
     try {
         await startHttpProxy();

package/dist/swarm.d.ts

@@ -46,6 +46,7 @@ export interface SwarmMessage {
     balance?: number;
     duration_s?: number;
     ndebit?: string;
+    payment_method?: 'ndebit' | 'invoice';
     bolt11?: string;
     preimage?: string;
     method?: string;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "2020117-agent",
-  "version": "0.3.4",
-  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + wallet Lightning payments",
+  "version": "0.3.6",
+  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
   "type": "module",
   "bin": {
     "2020117-agent": "./dist/agent.js",