2020117-agent 0.3.4 → 0.3.5

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 } 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,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' });
+                return;
+            }
             const satsPerMinute = state.skill?.pricing?.sats_per_minute
                 || Number(process.env.SATS_PER_MINUTE)
                 || msg.sats_per_minute
@@ -349,6 +358,7 @@ async function startSwarmListener(label) {
                 peerId,
                 sessionId,
                 satsPerMinute,
+                ndebit: msg.ndebit,
                 totalEarned: 0,
                 startedAt: Date.now(),
                 lastDebitAt: Date.now(),
@@ -356,67 +366,78 @@ async function startSwarmListener(label) {
                 timeoutTimer: null,
             };
             activeSessions.set(sessionId, session);
-            // Generate first invoice and send to customer for payment
-            let firstInvoice;
+            // Debit first 10 minutes immediately (prepaid model)
+            let firstDebit;
             try {
-                firstInvoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+                firstDebit = await collectPayment({
+                    ndebit: session.ndebit,
+                    lightningAddress: LIGHTNING_ADDRESS,
+                    amountSats: 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}` });
+                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;
             }
-            // Accept session first, then request payment
+            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,
             });
-            // Send invoice to customer — wait for session_tick_ack with preimage
-            const tickId = randomBytes(4).toString('hex');
+            // Notify customer of the debit
             node.send(socket, {
-                type: 'session_tick',
-                id: tickId,
+                type: 'session_tick_ack',
+                id: sessionId,
                 session_id: sessionId,
-                bolt11: firstInvoice,
                 amount: debitAmount,
+                balance: msg.budget ? msg.budget - session.totalEarned : undefined,
             });
-            console.log(`[${label}] Session ${sessionId}: waiting for first payment (${debitAmount} sats)`);
-            // Billing every 10 minutes — send invoice, wait for customer to pay
+            // Debit every 10 minutes
             session.debitTimer = setInterval(async () => {
-                let invoice;
+                let debit;
                 try {
-                    invoice = await generateInvoice(LIGHTNING_ADDRESS, debitAmount);
+                    debit = await collectPayment({
+                        ndebit: session.ndebit,
+                        lightningAddress: LIGHTNING_ADDRESS,
+                        amountSats: debitAmount,
+                    });
                 }
                 catch (e) {
-                    console.log(`[${label}] Session ${sessionId}: invoice error (${e.message}) — ending session`);
+                    console.log(`[${label}] Session ${sessionId}: debit error (${e.message}) — ending session`);
                     endSession(node, session, label);
                     return;
                 }
-                const tid = randomBytes(4).toString('hex');
+                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)`);
+                // Notify customer
                 node.send(socket, {
-                    type: 'session_tick',
-                    id: tid,
+                    type: 'session_tick_ack',
+                    id: sessionId,
                     session_id: sessionId,
-                    bolt11: invoice,
                     amount: debitAmount,
+                    balance: msg.budget ? msg.budget - session.totalEarned : undefined,
                 });
-                console.log(`[${label}] Session ${sessionId}: sent invoice for ${debitAmount} sats`);
             }, BILLING_INTERVAL_MIN * 60_000);
             return;
         }
-        if (msg.type === 'session_tick_ack') {
-            const session = activeSessions.get(msg.session_id || '');
-            if (!session)
-                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') {
             const session = activeSessions.get(msg.session_id || '');
             if (!session)

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 CLINK debit payments.
  *
  * Features:
- *   - Customer pays provider's invoices via built-in wallet
+ *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
  *   - 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 CLINK debit payments.
  *
  * Features:
- *   - Customer pays provider's invoices via built-in wallet
+ *   - Provider pulls per-minute payments via CLINK debit (ndebit authorization)
  *   - 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 } 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 = {
@@ -108,7 +112,7 @@ function sendAndWait(msg, timeoutMs) {
 }
 // --- 6. Message handler ---
 function setupMessageHandler() {
-    state.node.on('message', async (msg) => {
+    state.node.on('message', (msg) => {
         // Handle chunked HTTP responses — reassemble before resolving
         if (msg.type === 'http_response' && msg.chunk_total && msg.chunk_total > 1) {
             const id = msg.id;
@@ -158,37 +162,8 @@ function setupMessageHandler() {
                 cleanup();
                 break;
             }
-            case 'session_tick': {
-                // Provider sent an invoice for the next billing period — 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': {
-                // Legacy: provider-pull model notification (backward compat)
+                // Provider debited our wallet and is reporting the result
                 if (msg.amount !== undefined) {
                     state.totalSpent += msg.amount;
                 }
@@ -663,20 +638,22 @@ 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. 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).');
+        await node.destroy();
+        process.exit(1);
     }
-    log(`Wallet balance: ${balance} sats`);
-    // 5. Send session_start, wait for session_ack
+    log(`Payment: CLINK debit (provider pulls per-minute)`);
+    // 5. Send session_start with ndebit, 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,
     }, 15_000);
     if (ackResp.type !== 'session_ack' || !ackResp.session_id) {
         warn(`Unexpected response: ${ackResp.type}`);
@@ -691,7 +668,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(`Provider will debit ${state.satsPerMinute} sats/min via CLINK`);
     // 6. Start HTTP proxy
     try {
         await startHttpProxy();

package/dist/swarm.d.ts

@@ -46,8 +46,6 @@ export interface SwarmMessage {
     balance?: number;
     duration_s?: number;
     ndebit?: string;
-    bolt11?: string;
-    preimage?: string;
     method?: string;
     path?: string;
     headers?: Record<string, 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.5",
+  "description": "2020117 agent runtime — API polling + Hyperswarm P2P + CLINK Lightning payments",
   "type": "module",
   "bin": {
     "2020117-agent": "./dist/agent.js",