2020117-agent 0.3.5 → 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 { initClinkAgent, collectPayment } 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)
@@ -341,8 +341,10 @@ async function startSwarmListener(label) {
                 node.send(socket, { type: 'error', id: msg.id, message: 'Provider has no Lightning Address configured' });
                 return;
             }
-            if (!msg.ndebit) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'session_start requires ndebit authorization' });
+            // 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
@@ -352,13 +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,
-                ndebit: msg.ndebit,
+                paymentMethod,
+                ndebit: msg.ndebit || '',
                 totalEarned: 0,
                 startedAt: Date.now(),
                 lastDebitAt: Date.now(),
@@ -366,68 +369,38 @@ async function startSwarmListener(label) {
                 timeoutTimer: null,
             };
             activeSessions.set(sessionId, session);
-            // Debit first 10 minutes immediately (prepaid model)
-            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,
-            });
-            // Notify customer of the debit
-            node.send(socket, {
-                type: 'session_tick_ack',
-                id: sessionId,
-                session_id: sessionId,
-                amount: debitAmount,
-                balance: msg.budget ? msg.budget - session.totalEarned : undefined,
-            });
-            // Debit every 10 minutes
-            session.debitTimer = setInterval(async () => {
-                let debit;
+            if (paymentMethod === 'ndebit') {
+                // --- CLINK pull mode: provider debits customer immediately ---
+                let firstDebit;
                 try {
-                    debit = await collectPayment({
+                    firstDebit = 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);
+                    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 (!debit.ok) {
-                    console.log(`[${label}] Session ${sessionId}: debit failed (${debit.error}) — ending session`);
-                    endSession(node, session, label);
+                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}: debit OK (+${debitAmount}, total: ${session.totalEarned} sats)`);
-                // Notify customer
+                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,
@@ -435,7 +408,100 @@ async function startSwarmListener(label) {
                     amount: debitAmount,
                     balance: msg.budget ? msg.budget - session.totalEarned : undefined,
                 });
-            }, BILLING_INTERVAL_MIN * 60_000);
+                // 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);
+            }
+            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 {
+                    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;
+                }
+                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}: 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;
+        }
+        // Handle invoice payment confirmation (invoice mode only)
+        if (msg.type === 'session_tick_ack' && msg.preimage) {
+            const session = activeSessions.get(msg.session_id || '');
+            if (!session || session.paymentMethod !== 'invoice')
+                return;
+            const amount = msg.amount || 0;
+            session.totalEarned += amount;
+            session.lastDebitAt = Date.now();
+            console.log(`[${label}] Session ${session.sessionId}: payment received (+${amount}, total: ${session.totalEarned} sats)`);
             return;
         }
         if (msg.type === 'session_end') {

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 CLINK debit payments.
+ * per-minute payments (CLINK ndebit or Lightning invoice).
  *
  * Features:
- *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
+ *   - 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 CLINK debit payments.
+ * per-minute payments (CLINK ndebit or Lightning invoice).
  *
  * Features:
- *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
+ *   - 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)
  *
@@ -44,7 +44,7 @@ for (const arg of process.argv.slice(2)) {
 }
 import { SwarmNode, topicFromKind } from './swarm.js';
 import { queryProviderSkill } from './p2p-customer.js';
-import { loadNdebit } from './api.js';
+import { loadNdebit, walletPayInvoice, walletGetBalance, hasApiKey } from './api.js';
 import { randomBytes } from 'crypto';
 import { createServer } from 'http';
 import { createInterface } from 'readline';
@@ -112,7 +112,7 @@ function sendAndWait(msg, timeoutMs) {
 }
 // --- 6. Message handler ---
 function setupMessageHandler() {
-    state.node.on('message', (msg) => {
+    state.node.on('message', async (msg) => {
         // Handle chunked HTTP responses — reassemble before resolving
         if (msg.type === 'http_response' && msg.chunk_total && msg.chunk_total > 1) {
             const id = msg.id;
@@ -162,8 +162,37 @@ function setupMessageHandler() {
                 cleanup();
                 break;
             }
+            case 'session_tick': {
+                // Invoice mode: provider sent a bolt11 invoice — pay it
+                if (msg.bolt11 && msg.amount !== undefined) {
+                    const amount = msg.amount;
+                    if (state.totalSpent + amount > BUDGET) {
+                        log(`Budget exhausted (need ${amount}, remaining ${remainingSats()}) — ending session`);
+                        endSession();
+                        break;
+                    }
+                    log(`Paying invoice: ${amount} sats...`);
+                    const payResult = await walletPayInvoice(msg.bolt11);
+                    if (payResult.ok) {
+                        state.totalSpent += amount;
+                        log(`Paid ${amount} sats (total: ${state.totalSpent}, ~${estimatedMinutesLeft()} min left)`);
+                        state.node.send(state.socket, {
+                            type: 'session_tick_ack',
+                            id: msg.id,
+                            session_id: state.sessionId,
+                            preimage: payResult.preimage,
+                            amount,
+                        });
+                    }
+                    else {
+                        warn(`Payment failed: ${payResult.error} — ending session`);
+                        endSession();
+                    }
+                }
+                break;
+            }
             case 'session_tick_ack': {
-                // Provider debited our wallet and is reporting the result
+                // Ndebit mode: provider debited our wallet and is reporting the result
                 if (msg.amount !== undefined) {
                     state.totalSpent += msg.amount;
                 }
@@ -638,22 +667,37 @@ async function main() {
     state.satsPerMinute = satsPerMinute;
     log(`Pricing: ${satsPerMinute} sats/min`);
     log(`Budget: ${BUDGET} sats (~${Math.floor(BUDGET / satsPerMinute)} min)`);
-    // 4. Verify CLINK ndebit authorization
-    if (!NDEBIT) {
-        warn('No ndebit authorization. Provide --ndebit=ndebit1... or set CLINK_NDEBIT env var.');
-        warn('Get your ndebit from your CLINK-compatible wallet (e.g. ShockWallet → Connections).');
+    // 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(`Payment: CLINK debit (provider pulls per-minute)`);
-    // 5. Send session_start with ndebit, wait for session_ack
+    // 5. Send session_start, wait for session_ack
     const startId = randomBytes(4).toString('hex');
     const ackResp = await sendAndWait({
         type: 'session_start',
         id: startId,
         budget: BUDGET,
         sats_per_minute: satsPerMinute,
-        ndebit: NDEBIT,
+        payment_method: paymentMethod,
+        ...(paymentMethod === 'ndebit' ? { ndebit: NDEBIT } : {}),
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);
@@ -668,7 +712,7 @@ async function main() {
         log(`Provider adjusted rate: ${ackResp.sats_per_minute} sats/min`);
     }
     log(`Session started: ${state.sessionId}`);
-    log(`Provider will debit ${state.satsPerMinute} sats/min via CLINK`);
+    log(`Billing: ${state.satsPerMinute} sats/min via ${paymentMethod}`);
     // 6. Start HTTP proxy
     try {
         await startHttpProxy();

package/dist/swarm.d.ts

@@ -46,6 +46,9 @@ export interface SwarmMessage {
     balance?: number;
     duration_s?: number;
     ndebit?: string;
+    payment_method?: 'ndebit' | 'invoice';
+    bolt11?: string;
+    preimage?: string;
     method?: string;
     path?: string;
     headers?: Record<string, string>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "2020117-agent",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
   "type": "module",
   "bin": {