@tokenbuddy/tokenbuddy 1.0.4

package/tests/e2e.test.ts

@@ -0,0 +1,264 @@
+import { buildApp as buildBootstrapApp } from "../../wallet-bootstrap/src/server.js";
+import { buildSellerApp } from "../../seller/src/server.js";
+import { TokenbuddyDaemon } from "../src/daemon.js";
+import { AdminClient } from "../../admin-cli/src/client.js";
+import * as path from "path";
+import * as fs from "fs";
+import http from "http";
+import { AddressInfo } from "net";
+
+const TEMP_DIR = path.resolve(__dirname, "../../data-test");
+const TEMP_BOOTSTRAP_JSON = path.join(TEMP_DIR, "sellers-e2e.json");
+const TEMP_SELLER_DB = path.join(TEMP_DIR, "seller-e2e.db");
+const TEMP_BUYER_DB = path.join(TEMP_DIR, "buyer-e2e.db");
+
+describe("TokenBuddy Full End-to-End Integration Flow Tests", () => {
+  let bootstrapServer: http.Server;
+  let sellerServer: http.Server;
+  let upstreamServer: http.Server;
+  let daemon: TokenbuddyDaemon;
+
+  let bootstrapPort: number;
+  let sellerPort: number;
+  let upstreamPort: number;
+  let daemonControlPort: number;
+  let daemonProxyPort: number;
+
+  let sellerCloseFn: () => void;
+
+  beforeAll(async () => {
+    // Ensure clean temp dir
+    if (!fs.existsSync(TEMP_DIR)) {
+      fs.mkdirSync(TEMP_DIR, { recursive: true });
+    }
+    fs.writeFileSync(TEMP_BOOTSTRAP_JSON, JSON.stringify({ version: 1, sellers: [] }), "utf8");
+
+    if (fs.existsSync(TEMP_SELLER_DB)) {
+      try { fs.unlinkSync(TEMP_SELLER_DB); } catch (e) {}
+    }
+    if (fs.existsSync(TEMP_BUYER_DB)) {
+      try { fs.unlinkSync(TEMP_BUYER_DB); } catch (e) {}
+    }
+
+    // 1. Launch Mock Upstream OpenAI completions server
+    upstreamServer = http.createServer((req, res) => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      if (req.url === "/v1/chat/completions") {
+        res.end(JSON.stringify({
+          id: "chatcmpl-e2e-ok",
+          usage: { prompt_tokens: 20, completion_tokens: 30 },
+          choices: [{ message: { role: "assistant", content: "Hello back!" } }]
+        }));
+        return;
+      }
+      res.end("{}");
+    });
+    await new Promise<void>((resolve) => upstreamServer.listen(0, "127.0.0.1", () => resolve()));
+    upstreamPort = (upstreamServer.address() as AddressInfo).port;
+
+    // 2. Launch Wallet Bootstrap server
+    const bootstrapApp = buildBootstrapApp({
+      payTo: "test-activation-pay-to",
+      sm4KeyBase64: "MDEyMzQ1Njc4OUFCQ0RFRg==",
+      skillSlug: "test-activation-slug",
+      skillId: "test-activation-id",
+      description: "Activate registration",
+      resourceUrl: "http://127.0.0.1/verify",
+      activationFeeFen: 1,
+      microsPerFen: 1000000,
+      sellerRegistryPath: TEMP_BOOTSTRAP_JSON,
+      operatorSecret: "op-secret",
+      allowLocalSellerUrls: true
+    });
+    bootstrapServer = http.createServer(bootstrapApp);
+    await new Promise<void>((resolve) => bootstrapServer.listen(0, "127.0.0.1", () => resolve()));
+    bootstrapPort = (bootstrapServer.address() as AddressInfo).port;
+
+    // 3. Launch Seller server
+    const { app: sellerApp, close: closeDb } = buildSellerApp(TEMP_SELLER_DB, {
+      allowMock: true,
+      upstreamUrl: `http://127.0.0.1:${upstreamPort}`,
+      upstreamApiKey: "upstream-mock-key",
+      operatorSecret: "op-secret"
+    });
+    sellerCloseFn = closeDb;
+    sellerServer = http.createServer(sellerApp);
+    await new Promise<void>((resolve) => sellerServer.listen(0, "127.0.0.1", () => resolve()));
+    sellerPort = (sellerServer.address() as AddressInfo).port;
+
+    // 4. Launch TokenBuddy Buyer Proxy daemon
+    // Configure process.env to redirect to this mock seller port in the test environment
+    process.env.TOKENBUDDY_TEST_SELLER_URL = `http://127.0.0.1:${sellerPort}`;
+
+    daemon = new TokenbuddyDaemon({
+      controlPort: 0, // dynamic port for control plane
+      proxyPort: 0,   // dynamic port for proxy plane
+      dbPath: TEMP_BUYER_DB,
+      sellerRegistryUrl: `http://127.0.0.1:${bootstrapPort}/registry/sellers`
+    });
+
+    daemon.start();
+
+    // Retrieve active control plane & proxy ports
+    // Since we pass 0, the active listeners inside daemon have been dynamically assigned
+    // We fetch ports by inspecting process listener fields, or directly reading properties if exposed.
+    // In packages/tokenbuddy-cli/src/daemon.ts:
+    // this.controlServer = controlApp.listen(this.config.controlPort);
+    // this.proxyServer = proxyApp.listen(this.config.proxyPort);
+    const daemonCtrl = (daemon as any).controlServer.address() as AddressInfo;
+    const daemonProxy = (daemon as any).proxyServer.address() as AddressInfo;
+    daemonControlPort = daemonCtrl.port;
+    daemonProxyPort = daemonProxy.port;
+  });
+
+  afterAll(async () => {
+    // Cleanup servers
+    daemon.stop();
+    await new Promise<void>((resolve) => sellerServer.close(() => resolve()));
+    sellerCloseFn();
+    await new Promise<void>((resolve) => bootstrapServer.close(() => resolve()));
+    await new Promise<void>((resolve) => upstreamServer.close(() => resolve()));
+
+    // Delete temporary databases
+    if (fs.existsSync(TEMP_BOOTSTRAP_JSON)) {
+      try { fs.unlinkSync(TEMP_BOOTSTRAP_JSON); } catch (e) {}
+    }
+    if (fs.existsSync(TEMP_SELLER_DB)) {
+      try { fs.unlinkSync(TEMP_SELLER_DB); } catch (e) {}
+    }
+    if (fs.existsSync(TEMP_BUYER_DB)) {
+      try { fs.unlinkSync(TEMP_BUYER_DB); } catch (e) {}
+    }
+  });
+
+  test("💡 Verify Full E2E Loop: operator configure -> bootstrap list -> buyer daemon init -> concurrent proxy inference -> precise ledger check", async () => {
+    // Step 1: Initialize Admin Client & Verify operator connection
+    const admin = new AdminClient(`http://127.0.0.1:${sellerPort}`, "op-secret");
+    
+    const status = await admin.get("/operator/status");
+    expect(status.status).toBe("healthy");
+
+    // Step 2: Operator configures dynamically payment methods
+    const clawtipConfig = {
+      payTo: "test-merchant-acct",
+      sm4KeyBase64: "MDEyMzQ1Njc4OUFCQ0RFRg==",
+      skillSlug: "test-slug",
+      skillId: "test-id",
+      description: "Token purchase",
+      resourceUrl: "http://127.0.0.1/verify"
+    };
+    const paymentSetRes = await admin.put("/operator/admin/payments/clawtip", clawtipConfig);
+    expect(paymentSetRes.status).toBe("success");
+
+    // Verify payments listed
+    const serviceInfo = await admin.get("/operator/admin/service");
+    expect(serviceInfo.clawtipConfigured).toBe(true);
+
+    // Step 3: Register this seller in the wallet bootstrap registry
+    const bootstrapAdmin = new AdminClient(`http://127.0.0.1:${bootstrapPort}`, "op-secret");
+    const testRegistry = {
+      version: 1,
+      sellers: [
+        {
+          id: "seller-e2e-node",
+          name: "Seller E2E Node",
+          url: `http://127.0.0.1:${sellerPort}`,
+          supportedProtocols: ["openai"],
+          paymentMethods: ["mock"]
+        }
+      ]
+    };
+    const registered = await bootstrapAdmin.put("/operator/registry/sellers", testRegistry);
+    expect(registered.sellers.length).toBe(1);
+
+    // Verify registry list publicly available
+    const sellersPublicRes = await fetch(`http://127.0.0.1:${bootstrapPort}/registry/sellers`);
+    const sellersPublic = await sellersPublicRes.json() as any;
+    expect(sellersPublic.sellers[0].id).toBe("seller-e2e-node");
+
+    // Step 4: Validate daemon connection and check doctor
+    const daemonStatusRes = await fetch(`http://127.0.0.1:${daemonControlPort}/status`);
+    const daemonStatus = await daemonStatusRes.json() as any;
+    expect(daemonStatus.status).toBe("running");
+
+    // Step 5: Send concurrent inference chat requests to the buyer proxy plane (Port 17821 proxy equivalent)
+    const chatBody = {
+      model: "gpt-4",
+      messages: [{ role: "user", content: "How is the weather?" }],
+      requestId: "e2e_concurrency_req_1"
+    };
+
+    const sendProxyRequest = (reqId: string) => fetch(`http://127.0.0.1:${daemonProxyPort}/v1/chat/completions`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ ...chatBody, requestId: reqId })
+    });
+
+    // Fire 5 concurrent requests representing intense parallel LLM execution by coding terminal (like Claude Code)
+    const parallelResponses = await Promise.all([
+      sendProxyRequest("req_p_1"),
+      sendProxyRequest("req_p_2"),
+      sendProxyRequest("req_p_3"),
+      sendProxyRequest("req_p_4"),
+      sendProxyRequest("req_p_5")
+    ]);
+
+    for (const res of parallelResponses) {
+      expect(res.ok).toBe(true);
+      const data = await res.json() as any;
+      expect(data.id).toBe("chatcmpl-e2e-ok");
+      expect(data.choices[0].message.content).toBe("Hello back!");
+    }
+
+    // Step 6: Verify precise seller billing ledger
+    // A single token should have been purchased of amount 2,000,000 micros.
+    // 5 concurrent requests each used: prompt 20 * 1.0 + completion 30 * 3.0 = 110 micros.
+    // Total cost: 5 * 110 = 550 micros.
+    // Outstanding remaining balance should be: 2,000,000 - 550 = 1,999,450 micros!
+    // Let's connect directly to the seller DB using manual sync query or operator billing list
+    const { DatabaseSync } = require("node:sqlite");
+    const verifyDb = new DatabaseSync(TEMP_SELLER_DB);
+    const credRow = verifyDb.prepare("SELECT credit_balance_micros, reserved_micros, spent_micros FROM credentials").get() as any;
+    
+    expect(credRow.credit_balance_micros).toBe(1999450);
+    expect(credRow.reserved_micros).toBe(0);
+    expect(credRow.spent_micros).toBe(550);
+
+    // Also assert 5 distinct request settlement entries exist in ledger
+    const requestRows = verifyDb.prepare("SELECT state, settled_micros FROM requests").all() as any[];
+    expect(requestRows.length).toBe(5);
+    for (const r of requestRows) {
+      expect(r.state).toBe("settled");
+      expect(r.settled_micros).toBe(110);
+    }
+
+    verifyDb.close();
+
+    // Step 7: Fire subsequent inference request and assert it HITS local daemon token cache immediately (Zero-Purchase)
+    // We capture time elapsed to verify cache speed
+    const start = Date.now();
+    const hitResponse = await sendProxyRequest("req_subsequent_hit");
+    const duration = Date.now() - start;
+
+    expect(hitResponse.ok).toBe(true);
+    const hitData = await hitResponse.json() as any;
+    expect(hitData.id).toBe("chatcmpl-e2e-ok");
+    
+    // Total purchases should remain intact, meaning no extra purchases occurred!
+    const verifyDb2 = new DatabaseSync(TEMP_SELLER_DB);
+    const purchaseCount = (verifyDb2.prepare("SELECT COUNT(*) as count FROM purchases").get() as any).count;
+    // 1 original purchase coalesce from PromiseLocks
+    expect(purchaseCount).toBe(1);
+    verifyDb2.close();
+
+    // Step 8: Verify newly implemented admin query billing APIs (purchases & requests)
+    const billingPurchases = await admin.get("/operator/admin/purchases");
+    expect(billingPurchases.purchases.length).toBe(1);
+    expect(billingPurchases.purchases[0].state).toBe("funded");
+
+    const billingRequests = await admin.get("/operator/admin/requests");
+    // 5 concurrent requests + 1 subsequent hit = 6 total inference requests tracked on seller database
+    expect(billingRequests.requests.length).toBe(6);
+    expect(billingRequests.requests.every((r: any) => r.state === "settled")).toBe(true);
+  });
+});