2020117-agent 0.3.0 → 0.3.2

package/README.md

@@ -15,7 +15,7 @@ npx 2020117-agent --kind=5302 --processor=exec:./translate.sh
 npx 2020117-agent --kind=5200 --processor=http://localhost:7860 --models=sdxl-lightning,sd3.5-turbo
 
 # P2P session — rent an agent by the minute
-npx 2020117-session --kind=5200 --budget=500 --port=8080
+npx -p 2020117-agent 2020117-session --kind=5200 --budget=500 --port=8080
 ```
 
 ## Setup

package/dist/agent.js

@@ -68,10 +68,13 @@ for (const arg of process.argv.slice(2)) {
 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, } from './api.js';
+import { hasApiKey, loadAgentName, registerService, startHeartbeatLoop, getInbox, acceptJob, sendFeedback, submitResult, createJob, getJob, getProfile, reportSession, } from './api.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)
+if (!globalThis.WebSocket)
+    globalThis.WebSocket = WebSocket;
 // --- Config from env ---
 const KIND = Number(process.env.DVM_KIND) || 5100;
 const MAX_CONCURRENT = Number(process.env.MAX_JOBS) || 3;
@@ -669,6 +672,10 @@ function endSession(node, session, label) {
     // Update P2P lifetime counters — no batch claim needed with CLINK (payments settled instantly)
     state.p2pSessionsCompleted++;
     state.p2pTotalEarnedSats += session.totalEarned;
+    // Report session to platform activity feed (best-effort, no content exposed)
+    if (hasApiKey()) {
+        reportSession({ kind: KIND, durationS, totalSats: session.totalEarned });
+    }
     activeSessions.delete(session.sessionId);
 }
 // --- 5. Graceful shutdown ---

package/dist/api.d.ts

@@ -7,6 +7,8 @@
  */
 /** Returns the resolved agent name from env or first key in file */
 export declare function loadAgentName(): string | null;
+/** Returns the ndebit from env or .2020117_keys file */
+export declare function loadNdebit(): string | null;
 export declare function hasApiKey(): boolean;
 /** Fetch the authenticated agent's profile from the platform. */
 export declare function getProfile(): Promise<{
@@ -100,3 +102,12 @@ export declare function proxyDebit(opts: {
     lightningAddress: string;
     amountSats: number;
 }): Promise<ProxyDebitResult | null>;
+/**
+ * Report a completed P2P session to the platform for the activity feed.
+ * Content stays private — only metadata (kind, duration, sats) is sent.
+ */
+export declare function reportSession(opts: {
+    kind: number;
+    durationS: number;
+    totalSats: number;
+}): Promise<void>;

package/dist/api.js

@@ -51,6 +51,29 @@ export function loadAgentName() {
     }
     return null;
 }
+/** Returns the ndebit from env or .2020117_keys file */
+export function loadNdebit() {
+    if (process.env.CLINK_NDEBIT)
+        return process.env.CLINK_NDEBIT;
+    const agentName = process.env.AGENT_NAME || process.env.AGENT;
+    for (const dir of [process.cwd(), homedir()]) {
+        try {
+            const raw = readFileSync(join(dir, '.2020117_keys'), 'utf-8');
+            const keys = JSON.parse(raw);
+            if (agentName && keys[agentName]?.ndebit)
+                return keys[agentName].ndebit;
+            if (!agentName) {
+                const first = Object.values(keys)[0];
+                if (first?.ndebit)
+                    return first.ndebit;
+            }
+        }
+        catch {
+            // try next
+        }
+    }
+    return null;
+}
 const API_KEY = loadApiKey();
 // --- Helpers ---
 async function apiGet(path, auth = true) {
@@ -282,3 +305,19 @@ export async function proxyDebit(opts) {
         amount_sats: opts.amountSats,
     });
 }
+/**
+ * Report a completed P2P session to the platform for the activity feed.
+ * Content stays private — only metadata (kind, duration, sats) is sent.
+ */
+export async function reportSession(opts) {
+    try {
+        await apiPost('/api/dvm/session-report', {
+            kind: opts.kind,
+            duration_s: opts.durationS,
+            total_sats: opts.totalSats,
+        });
+    }
+    catch {
+        // Best-effort — don't break session cleanup
+    }
+}

package/dist/clink.d.ts

@@ -1,5 +1,5 @@
 /**
- * CLINK payment utilities — replaces Cashu for P2P payments
+ * CLINK payment utilities — debit-based Lightning payments for P2P sessions
  *
  * Provider uses ndebit to pull payments from customer's wallet.
  * Invoice generation via LNURL-pay from provider's own Lightning Address.

package/dist/clink.js

@@ -1,5 +1,5 @@
 /**
- * CLINK payment utilities — replaces Cashu for P2P payments
+ * CLINK payment utilities — debit-based Lightning payments for P2P sessions
  *
  * Provider uses ndebit to pull payments from customer's wallet.
  * Invoice generation via LNURL-pay from provider's own Lightning Address.

package/dist/p2p-customer.d.ts

@@ -13,7 +13,7 @@
  */
 import { SwarmNode } from './swarm.js';
 /**
- * Configuration for a P2P streaming session.
+ * Configuration for a P2P connection.
  */
 export interface P2PStreamOptions {
     /** DVM kind number (e.g. 5100 for text generation) */

package/dist/p2p-customer.js

@@ -35,7 +35,7 @@ import { randomBytes } from 'crypto';
 export async function* streamFromProvider(opts) {
     const { kind, input, budgetSats, ndebit, maxSatsPerChunk = 5, timeoutMs = 120_000, label = 'p2p', params, } = opts;
     if (!ndebit) {
-        throw new Error('ndebit authorization required for P2P streaming');
+        throw new Error('ndebit authorization required for P2P connection');
     }
     const jobId = randomBytes(8).toString('hex');
     const tag = `${label}-${jobId.slice(0, 8)}`;

package/dist/session.js

@@ -44,16 +44,20 @@ 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 { 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 || '';
+const NDEBIT = process.env.CLINK_NDEBIT || loadNdebit() || '';
 const TICK_INTERVAL_MS = 60_000;
 const HTTP_TIMEOUT_MS = 60_000;
 const state = {

package/package.json

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

package/dist/cashu.d.ts

@@ -1,41 +0,0 @@
-/**
- * Cashu eCash helper — mint, send, receive, melt tokens
- *
- * Uses testnut.cashu.space (fake sats) for PoC.
- * Switch to mint.coinos.io for production.
- */
-import { Mint, Wallet } from '@cashu/cashu-ts';
-export declare function createWallet(mintUrl?: string): {
-    mint: Mint;
-    wallet: Wallet;
-};
-/**
- * Mint new tokens (testnut mints fake tokens without real Lightning payment)
- */
-export declare function mintTokens(amount: number, mintUrl?: string): Promise<{
-    token: string;
-    proofs: import("@cashu/cashu-ts").Proof[];
-}>;
-/**
- * Verify and receive a Cashu token — swaps proofs with the mint to prevent double-spend
- */
-export declare function receiveToken(tokenStr: string): Promise<{
-    proofs: import("@cashu/cashu-ts").Proof[];
-    amount: number;
-    mintUrl: string;
-}>;
-/**
- * Get the total amount of a token without claiming it
- */
-export declare function peekToken(tokenStr: string): {
-    amount: number;
-    mint: string;
-    proofCount: number;
-};
-/**
- * Split a large token into multiple micro-tokens of a given amount.
- * Used for streaming payments: customer pre-splits budget into per-payment chunks.
- *
- * Example: splitTokens(token_100sats, 10) → 10 tokens of 10 sats each
- */
-export declare function splitTokens(tokenStr: string, perAmount: number): Promise<string[]>;

package/dist/cashu.js

@@ -1,112 +0,0 @@
-/**
- * Cashu eCash helper — mint, send, receive, melt tokens
- *
- * Uses testnut.cashu.space (fake sats) for PoC.
- * Switch to mint.coinos.io for production.
- */
-import { Mint, Wallet, getEncodedToken, getDecodedToken, MintQuoteState } from '@cashu/cashu-ts';
-const DEFAULT_MINT_URL = process.env.CASHU_MINT_URL || 'https://nofee.testnut.cashu.space';
-export function createWallet(mintUrl = DEFAULT_MINT_URL) {
-    const mint = new Mint(mintUrl);
-    const wallet = new Wallet(mint);
-    return { mint, wallet };
-}
-/**
- * Mint new tokens (testnut mints fake tokens without real Lightning payment)
- */
-export async function mintTokens(amount, mintUrl = DEFAULT_MINT_URL) {
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    // Request a mint quote
-    const quote = await wallet.createMintQuote(amount);
-    console.log(`[cashu] Mint quote created: ${quote.quote}`);
-    // For testnut, quotes are auto-paid. For real mints, you'd pay the Lightning invoice.
-    // Poll until quote is paid
-    let state = quote.state;
-    for (let i = 0; i < 30 && state !== MintQuoteState.PAID; i++) {
-        await sleep(1000);
-        const check = await wallet.checkMintQuote(quote.quote);
-        state = check.state;
-    }
-    if (state !== MintQuoteState.PAID) {
-        throw new Error(`Mint quote not paid after 30s (state: ${state}). For real mints, pay invoice: ${quote.request}`);
-    }
-    // Mint the tokens (v3.5 returns Proof[] directly)
-    const proofs = await wallet.mintProofs(amount, quote.quote);
-    console.log(`[cashu] Minted ${amount} sats (${proofs.length} proofs)`);
-    // Encode as a portable token string
-    const token = getEncodedToken({ mint: mintUrl, proofs });
-    return { token, proofs };
-}
-/**
- * Verify and receive a Cashu token — swaps proofs with the mint to prevent double-spend
- */
-export async function receiveToken(tokenStr) {
-    const decoded = getDecodedToken(tokenStr);
-    const mintUrl = decoded.mint;
-    if (!mintUrl)
-        throw new Error('Token has no mint URL');
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    // Swap proofs with the mint (this claims them, preventing re-use)
-    const proofs = await wallet.receive(tokenStr);
-    const total = proofs.reduce((sum, p) => sum + p.amount, 0);
-    console.log(`[cashu] Received ${total} sats from token (${proofs.length} proofs)`);
-    return { proofs, amount: total, mintUrl };
-}
-/**
- * Get the total amount of a token without claiming it
- */
-export function peekToken(tokenStr) {
-    const decoded = getDecodedToken(tokenStr);
-    const total = decoded.proofs.reduce((sum, p) => sum + p.amount, 0);
-    return { amount: total, mint: decoded.mint, proofCount: decoded.proofs.length };
-}
-/**
- * Split a large token into multiple micro-tokens of a given amount.
- * Used for streaming payments: customer pre-splits budget into per-payment chunks.
- *
- * Example: splitTokens(token_100sats, 10) → 10 tokens of 10 sats each
- */
-export async function splitTokens(tokenStr, perAmount) {
-    const decoded = getDecodedToken(tokenStr);
-    const mintUrl = decoded.mint;
-    if (!mintUrl)
-        throw new Error('Token has no mint URL');
-    const { wallet } = createWallet(mintUrl);
-    await wallet.loadMint();
-    const microTokens = [];
-    let remaining = decoded.proofs;
-    while (true) {
-        const total = remaining.reduce((sum, p) => sum + p.amount, 0);
-        if (total < perAmount)
-            break;
-        let retries = 5;
-        while (retries > 0) {
-            try {
-                const { send, keep: kept } = await wallet.send(perAmount, remaining);
-                microTokens.push(getEncodedToken({ mint: mintUrl, proofs: send }));
-                remaining = kept;
-                break;
-            }
-            catch (e) {
-                if (retries > 1 && /rate.limit/i.test(e.message || '')) {
-                    const delay = (6 - retries) * 2000; // 2s, 4s, 6s, 8s
-                    console.log(`[cashu] Rate limited, waiting ${delay / 1000}s... (${retries - 1} retries left)`);
-                    await sleep(delay);
-                    retries--;
-                }
-                else {
-                    throw e;
-                }
-            }
-        }
-        if (remaining.length === 0)
-            break;
-    }
-    console.log(`[cashu] Split into ${microTokens.length} micro-tokens of ${perAmount} sats each`);
-    return microTokens;
-}
-function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}

package/dist/customer.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone P2P Customer — connects to a provider, streams results with CLINK debit payments.
- *
- * Usage:
- *   2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "Explain quantum computing"
- */
-export {};

package/dist/customer.js

@@ -1,64 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone P2P Customer — connects to a provider, streams results with CLINK debit payments.
- *
- * Usage:
- *   2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "Explain quantum computing"
- */
-// --- CLI args → env (before any imports) ---
-for (const arg of process.argv.slice(2)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--kind':
-            process.env.DVM_KIND = val;
-            break;
-        case '--budget':
-            process.env.BUDGET_SATS = val;
-            break;
-        case '--max-price':
-            process.env.MAX_SATS_PER_CHUNK = val;
-            break;
-        case '--ndebit':
-            process.env.CLINK_NDEBIT = val;
-            break;
-    }
-}
-import { streamFromProvider } from './p2p-customer.js';
-const KIND = Number(process.env.DVM_KIND) || 5100;
-const BUDGET_SATS = Number(process.env.BUDGET_SATS) || 100;
-const MAX_SATS_PER_CHUNK = Number(process.env.MAX_SATS_PER_CHUNK) || 5;
-const NDEBIT = process.env.CLINK_NDEBIT || '';
-async function main() {
-    const prompt = process.argv.slice(2).filter(a => !a.startsWith('--')).join(' ');
-    if (!prompt) {
-        console.error('Usage: 2020117-customer --kind=5100 --budget=50 --ndebit=ndebit1... "your prompt here"');
-        process.exit(1);
-    }
-    if (!NDEBIT) {
-        console.error('[customer] Error: --ndebit=ndebit1... required (CLINK debit authorization)');
-        process.exit(1);
-    }
-    console.log(`[customer] Prompt: "${prompt.slice(0, 60)}..."`);
-    console.log(`[customer] Budget: ${BUDGET_SATS} sats, max price: ${MAX_SATS_PER_CHUNK} sat/chunk`);
-    // Stream from provider (handles connection, negotiation, CLINK payments internally)
-    let output = '';
-    for await (const chunk of streamFromProvider({
-        kind: KIND,
-        input: prompt,
-        budgetSats: BUDGET_SATS,
-        ndebit: NDEBIT,
-        maxSatsPerChunk: MAX_SATS_PER_CHUNK,
-        label: 'customer',
-    })) {
-        process.stdout.write(chunk);
-        output += chunk;
-    }
-    console.log(`\n[customer] Done (${output.length} chars)`);
-}
-main().catch(err => { console.error('[customer] Fatal:', err.message || err); process.exit(1); });

package/dist/p2p-provider.d.ts

@@ -1,62 +0,0 @@
-/**
- * Shared P2P provider protocol — reusable building blocks for provider-side
- * streaming with credit-based flow control and CLINK debit payments.
- *
- * Provider actively pulls payments from customer's wallet via CLINK ndebit,
- * generating invoices from their own Lightning Address via LNURL-pay.
- *
- * Consumers: agent.ts, provider.ts
- */
-import { SwarmNode } from './swarm.js';
-/** Per-connection job state for P2P streaming */
-export interface P2PJobState {
-    socket: any;
-    credit: number;
-    ndebit: string;
-    totalEarned: number;
-    stopped: boolean;
-}
-/** Options for {@link streamToCustomer} */
-export interface StreamOptions {
-    node: SwarmNode;
-    job: P2PJobState;
-    jobId: string;
-    source: AsyncIterable<string>;
-    satsPerChunk: number;
-    chunksPerPayment: number;
-    lightningAddress: string;
-    label: string;
-}
-/**
- * Provider pulls a payment cycle from the customer's wallet via CLINK debit.
- *
- * Generates an invoice from the provider's Lightning Address, then sends a
- * debit request to the customer's wallet service via Nostr relay.
- *
- * Returns true if payment succeeded and credit was added.
- */
-export declare function collectP2PPayment(opts: {
-    job: P2PJobState;
-    node: SwarmNode;
-    jobId: string;
-    satsPerChunk: number;
-    chunksPerPayment: number;
-    lightningAddress: string;
-    label: string;
-}): Promise<boolean>;
-/**
- * Handle an incoming `stop` message: mark the job as stopped.
- */
-export declare function handleStop(job: P2PJobState, jobId: string, label: string): void;
-/**
- * Stream chunks from an async source to the customer with credit-based
- * flow control. When credit runs out, the provider debits the customer's
- * wallet via CLINK before continuing.
- *
- * Returns the concatenated full output string.
- *
- * **Cleanup note**: this function does NOT delete the job from any map or
- * release any capacity slot — callers are responsible for post-stream
- * cleanup.
- */
-export declare function streamToCustomer(opts: StreamOptions): Promise<string>;

package/dist/p2p-provider.js

@@ -1,105 +0,0 @@
-/**
- * Shared P2P provider protocol — reusable building blocks for provider-side
- * streaming with credit-based flow control and CLINK debit payments.
- *
- * Provider actively pulls payments from customer's wallet via CLINK ndebit,
- * generating invoices from their own Lightning Address via LNURL-pay.
- *
- * Consumers: agent.ts, provider.ts
- */
-import { collectPayment } from './clink.js';
-// ---------------------------------------------------------------------------
-// Payment helpers
-// ---------------------------------------------------------------------------
-/**
- * Provider pulls a payment cycle from the customer's wallet via CLINK debit.
- *
- * Generates an invoice from the provider's Lightning Address, then sends a
- * debit request to the customer's wallet service via Nostr relay.
- *
- * Returns true if payment succeeded and credit was added.
- */
-export async function collectP2PPayment(opts) {
-    const { job, node, jobId, satsPerChunk, chunksPerPayment, lightningAddress, label } = opts;
-    const amount = satsPerChunk * chunksPerPayment;
-    try {
-        const result = await collectPayment({
-            ndebit: job.ndebit,
-            lightningAddress,
-            amountSats: amount,
-        });
-        if (!result.ok) {
-            console.log(`[${label}] P2P job ${jobId}: debit failed: ${result.error}`);
-            return false;
-        }
-        job.credit += chunksPerPayment;
-        job.totalEarned += amount;
-        console.log(`[${label}] P2P job ${jobId}: debit OK +${amount} sats → +${chunksPerPayment} chunks (credit: ${job.credit}, total: ${job.totalEarned} sats)`);
-        node.send(job.socket, { type: 'payment_ack', id: jobId, amount });
-        return true;
-    }
-    catch (e) {
-        console.log(`[${label}] P2P job ${jobId}: debit error: ${e.message}`);
-        return false;
-    }
-}
-/**
- * Handle an incoming `stop` message: mark the job as stopped.
- */
-export function handleStop(job, jobId, label) {
-    console.log(`[${label}] P2P job ${jobId}: customer requested stop`);
-    job.stopped = true;
-}
-// ---------------------------------------------------------------------------
-// Streaming
-// ---------------------------------------------------------------------------
-/**
- * Stream chunks from an async source to the customer with credit-based
- * flow control. When credit runs out, the provider debits the customer's
- * wallet via CLINK before continuing.
- *
- * Returns the concatenated full output string.
- *
- * **Cleanup note**: this function does NOT delete the job from any map or
- * release any capacity slot — callers are responsible for post-stream
- * cleanup.
- */
-export async function streamToCustomer(opts) {
-    const { node, job, jobId, source, satsPerChunk, chunksPerPayment, lightningAddress, label } = opts;
-    let fullOutput = '';
-    try {
-        for await (const chunk of source) {
-            if (job.stopped) {
-                console.log(`[${label}] P2P job ${jobId}: stopped by customer`);
-                break;
-            }
-            if (job.credit <= 0) {
-                // Pull next payment from customer's wallet
-                console.log(`[${label}] P2P job ${jobId}: credit exhausted, debiting customer...`);
-                const paid = await collectP2PPayment({
-                    job, node, jobId, satsPerChunk, chunksPerPayment, lightningAddress, label,
-                });
-                if (!paid || job.stopped) {
-                    console.log(`[${label}] P2P job ${jobId}: ending (paid=${paid}, stopped=${job.stopped})`);
-                    break;
-                }
-            }
-            fullOutput += chunk;
-            node.send(job.socket, { type: 'chunk', id: jobId, data: chunk });
-            job.credit--;
-        }
-    }
-    catch (e) {
-        console.error(`[${label}] P2P job ${jobId} generation error: ${e.message}`);
-        node.send(job.socket, { type: 'error', id: jobId, message: e.message });
-    }
-    // Send final result
-    node.send(job.socket, {
-        type: 'result',
-        id: jobId,
-        output: fullOutput,
-        total_sats: job.totalEarned,
-    });
-    console.log(`[${label}] P2P job ${jobId} completed (${fullOutput.length} chars, ${job.totalEarned} sats earned)`);
-    return fullOutput;
-}

package/dist/pipeline.d.ts

@@ -1,8 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pipeline — chain multiple P2P providers in sequence.
- *
- * Usage:
- *   BUDGET_SATS=100 CLINK_NDEBIT=ndebit1... TARGET_LANG=Chinese npm run pipeline "Write a short poem"
- */
-export {};

package/dist/pipeline.js

@@ -1,106 +0,0 @@
-#!/usr/bin/env node
-/**
- * Pipeline — chain multiple P2P providers in sequence.
- *
- * Usage:
- *   BUDGET_SATS=100 CLINK_NDEBIT=ndebit1... TARGET_LANG=Chinese npm run pipeline "Write a short poem"
- */
-// --- CLI args → env (before any imports) ---
-for (const arg of process.argv.slice(2)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--ndebit':
-            process.env.CLINK_NDEBIT = val;
-            break;
-        case '--budget':
-            process.env.BUDGET_SATS = val;
-            break;
-    }
-}
-import { streamFromProvider } from './p2p-customer.js';
-import { getOnlineProviders } from './api.js';
-const BUDGET_SATS = Number(process.env.BUDGET_SATS) || 100;
-const MAX_SATS_PER_CHUNK = Number(process.env.MAX_SATS_PER_CHUNK) || 5;
-const NDEBIT = process.env.CLINK_NDEBIT || '';
-const GEN_KIND = Number(process.env.GEN_KIND) || 5100;
-const TRANS_KIND = Number(process.env.TRANS_KIND) || 5302;
-const TARGET_LANG = process.env.TARGET_LANG || 'Chinese';
-async function showProviders(kind, label) {
-    try {
-        const agents = await getOnlineProviders(kind);
-        if (agents.length === 0) {
-            console.log(`[${label}] No providers online for kind ${kind}`);
-        }
-        else {
-            console.log(`[${label}] ${agents.length} provider(s) online for kind ${kind}:`);
-            for (const a of agents) {
-                const cap = a.capacity !== undefined ? `, capacity: ${a.capacity}` : '';
-                const price = a.pricing ? `, pricing: ${JSON.stringify(a.pricing)}` : '';
-                console.log(`[${label}]   - ${a.username || a.user_id} (${a.status}${cap}${price})`);
-            }
-        }
-    }
-    catch {
-        console.log(`[${label}] Could not query platform`);
-    }
-}
-async function collectStream(opts) {
-    let output = '';
-    for await (const chunk of streamFromProvider(opts)) {
-        process.stdout.write(chunk);
-        output += chunk;
-    }
-    return output;
-}
-async function main() {
-    const prompt = process.argv.slice(2).filter(a => !a.startsWith('--')).join(' ');
-    if (!prompt) {
-        console.error('Usage: 2020117-pipeline --ndebit=ndebit1... --budget=100 "your prompt"');
-        process.exit(1);
-    }
-    if (!NDEBIT) {
-        console.error('[pipeline] Error: --ndebit=ndebit1... required (CLINK debit authorization)');
-        process.exit(1);
-    }
-    console.log('='.repeat(60));
-    console.log(`Pipeline: generate (kind ${GEN_KIND}) → translate to ${TARGET_LANG} (kind ${TRANS_KIND})`);
-    console.log(`Total budget: ${BUDGET_SATS} sats`);
-    console.log('='.repeat(60));
-    const genBudget = Math.ceil(BUDGET_SATS * 0.6);
-    const transBudget = BUDGET_SATS - genBudget;
-    // Phase 1: Text Generation
-    console.log(`\n${'─'.repeat(60)}`);
-    console.log(`Phase 1: Text Generation (budget: ${genBudget} sats)`);
-    console.log('─'.repeat(60));
-    await showProviders(GEN_KIND, 'gen');
-    const generated = await collectStream({
-        kind: GEN_KIND, input: prompt, budgetSats: genBudget, ndebit: NDEBIT,
-        maxSatsPerChunk: MAX_SATS_PER_CHUNK, label: 'gen',
-    });
-    if (!generated.trim()) {
-        console.error('\n[pipeline] Phase 1 produced no output, aborting');
-        process.exit(1);
-    }
-    // Phase 2: Translation
-    console.log(`\n${'─'.repeat(60)}`);
-    console.log(`Phase 2: Translation to ${TARGET_LANG} (budget: ${transBudget} sats)`);
-    console.log('─'.repeat(60));
-    await showProviders(TRANS_KIND, 'trans');
-    const translated = await collectStream({
-        kind: TRANS_KIND, input: `Translate the following text to ${TARGET_LANG}:\n\n${generated}`,
-        budgetSats: transBudget, ndebit: NDEBIT, maxSatsPerChunk: MAX_SATS_PER_CHUNK, label: 'trans',
-    });
-    // Summary
-    console.log(`\n${'='.repeat(60)}`);
-    console.log('Pipeline complete!');
-    console.log('='.repeat(60));
-    console.log(`\nGenerated (${generated.length} chars):\n${generated}`);
-    console.log(`\nTranslated (${translated.length} chars):\n${translated}`);
-}
-main().catch(err => { console.error('[pipeline] Fatal:', err.message || err); process.exit(1); });

package/dist/provider.d.ts

@@ -1,6 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone Provider daemon — thin wrapper around shared P2P provider protocol.
- * For most use cases, prefer `2020117-agent` which handles both API + P2P.
- */
-export {};

package/dist/provider.js

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-/**
- * Standalone Provider daemon — thin wrapper around shared P2P provider protocol.
- * For most use cases, prefer `2020117-agent` which handles both API + P2P.
- */
-// --- CLI args → env (before any imports) ---
-for (const arg of process.argv.slice(2)) {
-    if (!arg.startsWith('--'))
-        continue;
-    const eq = arg.indexOf('=');
-    if (eq === -1)
-        continue;
-    const key = arg.slice(0, eq);
-    const val = arg.slice(eq + 1);
-    switch (key) {
-        case '--kind':
-            process.env.DVM_KIND = val;
-            break;
-        case '--lightning-address':
-            process.env.LIGHTNING_ADDRESS = val;
-            break;
-    }
-}
-import { SwarmNode, topicFromKind } from './swarm.js';
-import { createProcessor } from './processor.js';
-import { hasApiKey, registerService, startHeartbeatLoop } from './api.js';
-import { initClinkAgent } from './clink.js';
-import { collectP2PPayment, handleStop, streamToCustomer } from './p2p-provider.js';
-const KIND = Number(process.env.DVM_KIND) || 5100;
-const SATS_PER_CHUNK = Number(process.env.SATS_PER_CHUNK) || 1;
-const CHUNKS_PER_PAYMENT = Number(process.env.CHUNKS_PER_PAYMENT) || 10;
-const LIGHTNING_ADDRESS = process.env.LIGHTNING_ADDRESS || '';
-const jobs = new Map();
-async function main() {
-    if (!LIGHTNING_ADDRESS) {
-        console.error('[provider] Error: --lightning-address=you@wallet.com required');
-        process.exit(1);
-    }
-    const processor = await createProcessor();
-    await processor.verify();
-    console.log(`[provider] Processor "${processor.name}" verified`);
-    // Initialize CLINK agent identity
-    const { pubkey } = initClinkAgent();
-    console.log(`[provider] CLINK: ${LIGHTNING_ADDRESS} (agent pubkey: ${pubkey.slice(0, 16)}...)`);
-    // Platform registration
-    let stopHeartbeat = null;
-    if (hasApiKey()) {
-        console.log('[provider] Registering on platform...');
-        await registerService({ kind: KIND, satsPerChunk: SATS_PER_CHUNK, chunksPerPayment: CHUNKS_PER_PAYMENT, model: processor.name });
-        stopHeartbeat = startHeartbeatLoop();
-    }
-    else {
-        console.log('[provider] No API key — P2P-only mode');
-    }
-    const satsPerPayment = SATS_PER_CHUNK * CHUNKS_PER_PAYMENT;
-    const node = new SwarmNode();
-    const topic = topicFromKind(KIND);
-    console.log(`[provider] Streaming payment: ${SATS_PER_CHUNK} sat/chunk, ${CHUNKS_PER_PAYMENT} chunks/payment (${satsPerPayment} sats/cycle)`);
-    await node.listen(topic);
-    console.log(`[provider] Listening for customers...\n`);
-    node.on('message', async (msg, socket, peerId) => {
-        const tag = peerId.slice(0, 8);
-        if (msg.type === 'request') {
-            console.log(`[provider] Job ${msg.id} from ${tag}: "${(msg.input || '').slice(0, 60)}..."`);
-            if (!msg.ndebit) {
-                node.send(socket, { type: 'error', id: msg.id, message: 'Request requires ndebit authorization' });
-                return;
-            }
-            if (msg.budget !== undefined) {
-                console.log(`[provider] Customer budget: ${msg.budget} sats`);
-            }
-            const job = {
-                socket, credit: 0, ndebit: msg.ndebit, totalEarned: 0, stopped: false,
-            };
-            jobs.set(msg.id, job);
-            node.send(socket, { type: 'offer', id: msg.id, sats_per_chunk: SATS_PER_CHUNK, chunks_per_payment: CHUNKS_PER_PAYMENT });
-            // Debit first payment cycle via CLINK
-            const paid = await collectP2PPayment({
-                job, node, jobId: msg.id,
-                satsPerChunk: SATS_PER_CHUNK, chunksPerPayment: CHUNKS_PER_PAYMENT,
-                lightningAddress: LIGHTNING_ADDRESS, label: 'provider',
-            });
-            if (!paid) {
-                jobs.delete(msg.id);
-                return;
-            }
-            node.send(socket, { type: 'accepted', id: msg.id });
-            const source = processor.generateStream({ input: msg.input || '', params: msg.params });
-            await streamToCustomer({
-                node, job, jobId: msg.id, source,
-                satsPerChunk: SATS_PER_CHUNK, chunksPerPayment: CHUNKS_PER_PAYMENT,
-                lightningAddress: LIGHTNING_ADDRESS, label: 'provider',
-            });
-            jobs.delete(msg.id);
-        }
-        if (msg.type === 'stop') {
-            const job = jobs.get(msg.id);
-            if (job)
-                handleStop(job, msg.id, 'provider');
-        }
-    });
-    process.on('SIGINT', async () => {
-        console.log('\n[provider] Shutting down...');
-        if (stopHeartbeat)
-            stopHeartbeat();
-        await node.destroy();
-        process.exit(0);
-    });
-}
-main().catch(err => { console.error('[provider] Fatal:', err); process.exit(1); });