@tokenbuddy/tokenbuddy 1.0.4

package/src/buyer-store.ts

@@ -0,0 +1,536 @@
+// @ts-ignore node:sqlite types are not present in the current @types/node release.
+import { DatabaseSync } from "node:sqlite";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { createModuleLogger } from "@tokenbuddy/logging";
+
+const logger = createModuleLogger("tb-proxyd");
+
+export interface CachedToken {
+  token: string;
+  balanceMicros: number;
+}
+
+export interface PaymentConfig {
+  method: string;
+  enabled: boolean;
+  isDefault: boolean;
+  config?: Record<string, unknown>;
+  updatedAt: string;
+}
+
+export interface PendingPurchaseInput {
+  purchaseId: string;
+  sellerKey: string;
+  modelId: string;
+  paymentMethod: string;
+  amountUsdMicros: number;
+  status: string;
+  paymentReference?: string;
+  expiresAt?: string;
+}
+
+export interface PurchaseLedgerInput {
+  purchaseId: string;
+  sellerKey: string;
+  modelId: string;
+  paymentMethod: string;
+  status: string;
+  creditMicros: number;
+  currency: string;
+  paymentReference?: string;
+  completedAt?: string;
+}
+
+export interface SafePurchaseLedgerEntry {
+  purchaseId: string;
+  sellerKey: string;
+  modelId: string;
+  paymentMethod: string;
+  status: string;
+  creditMicros: number;
+  currency: string;
+  paymentReferenceHash?: string;
+  createdAt: string;
+  completedAt?: string;
+}
+
+export interface InferenceLedgerInput {
+  requestId: string;
+  sellerKey: string;
+  modelId: string;
+  endpoint: string;
+  status: string;
+  promptTokens: number;
+  completionTokens: number;
+  billedMicros: number;
+  prompt?: string;
+  response?: string;
+}
+
+export interface SafeInferenceLedgerEntry {
+  requestId: string;
+  sellerKey: string;
+  modelId: string;
+  endpoint: string;
+  status: string;
+  promptTokens: number;
+  completionTokens: number;
+  billedMicros: number;
+  promptHash?: string;
+  responseHash?: string;
+  createdAt: string;
+}
+
+export interface BuyerStoreSummary {
+  journalMode: string;
+  paymentsCount: number;
+  pendingPurchasesCount: number;
+  purchaseLedgerCount: number;
+  inferenceLedgerCount: number;
+}
+
+export interface ProviderInstallSnapshot {
+  providerId: string;
+  files: Array<{
+    path: string;
+    existed: boolean;
+    content?: string;
+  }>;
+}
+
+export interface BuyerStoreOptions {
+  root?: string;
+  dbPath?: string;
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function safeHash(value?: string): string | undefined {
+  if (!value) {
+    return undefined;
+  }
+  return crypto.createHash("sha256").update(value).digest("hex");
+}
+
+function boolFromSql(value: unknown): boolean {
+  return value === 1 || value === true;
+}
+
+function ensureDirForFile(filePath: string): void {
+  const dir = path.dirname(filePath);
+  if (dir !== "." && !fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function resolveBuyerStorePath(options: BuyerStoreOptions = {}): string {
+  if (options.dbPath) {
+    return options.dbPath;
+  }
+  const root = options.root || process.env.TOKENBUDDY_BUYER_STORE || path.join(os.homedir(), ".tokenbuddy-store");
+  return path.join(root, "buyer-store.db");
+}
+
+export class BuyerStore {
+  private db: DatabaseSync;
+
+  constructor(options: BuyerStoreOptions | string = {}) {
+    const dbPath = typeof options === "string" ? options : resolveBuyerStorePath(options);
+    ensureDirForFile(dbPath);
+    this.db = new DatabaseSync(dbPath);
+    this.db.exec("PRAGMA journal_mode = WAL;");
+    this.initSchema();
+  }
+
+  public journalMode(): string {
+    const row = this.db.prepare("PRAGMA journal_mode;").get() as { journal_mode: string };
+    return row.journal_mode;
+  }
+
+  public summary(): BuyerStoreSummary {
+    return {
+      journalMode: this.journalMode(),
+      paymentsCount: this.countRows("payment_config"),
+      pendingPurchasesCount: this.countRows("pending_purchases"),
+      purchaseLedgerCount: this.countRows("purchase_ledger"),
+      inferenceLedgerCount: this.countRows("inference_ledger")
+    };
+  }
+
+  public saveProviderInstallSnapshot(snapshot: ProviderInstallSnapshot): void {
+    const updatedAt = nowIso();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO provider_install_state (
+        provider_id, snapshot_json, created_at, updated_at
+      ) VALUES (
+        ?, ?,
+        COALESCE((SELECT created_at FROM provider_install_state WHERE provider_id = ?), ?),
+        ?
+      )`
+    ).run(
+      snapshot.providerId,
+      JSON.stringify(snapshot),
+      snapshot.providerId,
+      updatedAt,
+      updatedAt
+    );
+  }
+
+  public getProviderInstallSnapshot(providerId: string): ProviderInstallSnapshot | undefined {
+    const row = this.db.prepare(
+      "SELECT snapshot_json FROM provider_install_state WHERE provider_id = ?"
+    ).get(providerId) as { snapshot_json: string } | undefined;
+    if (!row) {
+      return undefined;
+    }
+    return JSON.parse(row.snapshot_json) as ProviderInstallSnapshot;
+  }
+
+  public removeProviderInstallSnapshot(providerId: string): boolean {
+    const result = this.db.prepare("DELETE FROM provider_install_state WHERE provider_id = ?").run(providerId) as { changes: number };
+    return result.changes > 0;
+  }
+
+  public getToken(sellerKey: string): CachedToken | undefined {
+    const stmt = this.db.prepare("SELECT token, balance_micros FROM token_cache WHERE seller_key = ?");
+    const row = stmt.get(sellerKey) as { token: string; balance_micros: number } | undefined;
+    if (!row) {
+      return undefined;
+    }
+    return {
+      token: row.token,
+      balanceMicros: row.balance_micros
+    };
+  }
+
+  public saveToken(sellerKey: string, token: string, tokenClass: string, balanceMicros: number, expiresAt: string): void {
+    const stmt = this.db.prepare(
+      `INSERT OR REPLACE INTO token_cache (
+        seller_key, token, token_class, balance_micros, expires_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?)`
+    );
+    stmt.run(sellerKey, token, tokenClass, balanceMicros, expiresAt, nowIso());
+  }
+
+  public deductBalance(sellerKey: string, amountMicros: number): void {
+    const token = this.getToken(sellerKey);
+    if (!token) {
+      return;
+    }
+    const newBalance = Math.max(0, token.balanceMicros - amountMicros);
+    const stmt = this.db.prepare("UPDATE token_cache SET balance_micros = ?, updated_at = ? WHERE seller_key = ?");
+    stmt.run(newBalance, nowIso(), sellerKey);
+    logger.info("token.cache.debited", "token cache balance debited", {
+      sellerKey,
+      amountMicros,
+      balanceMicros: newBalance
+    });
+  }
+
+  public listPayments(): PaymentConfig[] {
+    const rows = this.db.prepare(
+      `SELECT method, enabled, is_default, config_json, updated_at
+       FROM payment_config
+       ORDER BY method ASC`
+    ).all() as Array<{
+      method: string;
+      enabled: number;
+      is_default: number;
+      config_json: string | null;
+      updated_at: string;
+    }>;
+
+    return rows.map(row => ({
+      method: row.method,
+      enabled: boolFromSql(row.enabled),
+      isDefault: boolFromSql(row.is_default),
+      config: row.config_json ? JSON.parse(row.config_json) as Record<string, unknown> : undefined,
+      updatedAt: row.updated_at
+    }));
+  }
+
+  public savePayment(config: Omit<PaymentConfig, "updatedAt">): void {
+    const updatedAt = nowIso();
+    if (config.isDefault) {
+      this.db.prepare("UPDATE payment_config SET is_default = 0").run();
+    }
+    this.db.prepare(
+      `INSERT OR REPLACE INTO payment_config (
+        method, enabled, is_default, config_json, created_at, updated_at
+      ) VALUES (
+        ?, ?, ?, ?,
+        COALESCE((SELECT created_at FROM payment_config WHERE method = ?), ?),
+        ?
+      )`
+    ).run(
+      config.method,
+      config.enabled ? 1 : 0,
+      config.isDefault ? 1 : 0,
+      config.config ? JSON.stringify(config.config) : null,
+      config.method,
+      updatedAt,
+      updatedAt
+    );
+  }
+
+  public getPayment(method: string): PaymentConfig | undefined {
+    return this.listPayments().find((payment) => payment.method === method);
+  }
+
+  public removePayment(method: string): boolean {
+    const result = this.db.prepare("DELETE FROM payment_config WHERE method = ?").run(method) as { changes: number };
+    return result.changes > 0;
+  }
+
+  public upsertPendingPurchase(input: PendingPurchaseInput): void {
+    const updatedAt = nowIso();
+    this.db.prepare(
+      `INSERT OR REPLACE INTO pending_purchases (
+        purchase_id, seller_key, model_id, payment_method, amount_usd_micros,
+        status, payment_reference_hash, created_at, updated_at, expires_at
+      ) VALUES (
+        ?, ?, ?, ?, ?, ?, ?,
+        COALESCE((SELECT created_at FROM pending_purchases WHERE purchase_id = ?), ?),
+        ?, ?
+      )`
+    ).run(
+      input.purchaseId,
+      input.sellerKey,
+      input.modelId,
+      input.paymentMethod,
+      input.amountUsdMicros,
+      input.status,
+      safeHash(input.paymentReference) || null,
+      input.purchaseId,
+      updatedAt,
+      updatedAt,
+      input.expiresAt || null
+    );
+  }
+
+  public listPendingPurchases(): Array<PendingPurchaseInput & { paymentReferenceHash?: string; updatedAt: string }> {
+    const rows = this.db.prepare(
+      `SELECT purchase_id, seller_key, model_id, payment_method, amount_usd_micros,
+              status, payment_reference_hash, updated_at, expires_at
+       FROM pending_purchases
+       ORDER BY updated_at DESC, purchase_id ASC`
+    ).all() as Array<{
+      purchase_id: string;
+      seller_key: string;
+      model_id: string;
+      payment_method: string;
+      amount_usd_micros: number;
+      status: string;
+      payment_reference_hash: string | null;
+      updated_at: string;
+      expires_at: string | null;
+    }>;
+
+    return rows.map(row => ({
+      purchaseId: row.purchase_id,
+      sellerKey: row.seller_key,
+      modelId: row.model_id,
+      paymentMethod: row.payment_method,
+      amountUsdMicros: row.amount_usd_micros,
+      status: row.status,
+      paymentReferenceHash: row.payment_reference_hash || undefined,
+      updatedAt: row.updated_at,
+      expiresAt: row.expires_at || undefined
+    }));
+  }
+
+  public recordPurchaseLedger(input: PurchaseLedgerInput): void {
+    const createdAt = nowIso();
+    this.db.prepare(
+      `INSERT INTO purchase_ledger (
+        purchase_id, seller_key, model_id, payment_method, status, credit_micros,
+        currency, payment_reference_hash, created_at, completed_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.purchaseId,
+      input.sellerKey,
+      input.modelId,
+      input.paymentMethod,
+      input.status,
+      input.creditMicros,
+      input.currency,
+      safeHash(input.paymentReference) || null,
+      createdAt,
+      input.completedAt || null
+    );
+  }
+
+  public listPurchaseLedger(): SafePurchaseLedgerEntry[] {
+    const rows = this.db.prepare(
+      `SELECT purchase_id, seller_key, model_id, payment_method, status, credit_micros,
+              currency, payment_reference_hash, created_at, completed_at
+       FROM purchase_ledger
+       ORDER BY id ASC`
+    ).all() as Array<{
+      purchase_id: string;
+      seller_key: string;
+      model_id: string;
+      payment_method: string;
+      status: string;
+      credit_micros: number;
+      currency: string;
+      payment_reference_hash: string | null;
+      created_at: string;
+      completed_at: string | null;
+    }>;
+
+    return rows.map(row => ({
+      purchaseId: row.purchase_id,
+      sellerKey: row.seller_key,
+      modelId: row.model_id,
+      paymentMethod: row.payment_method,
+      status: row.status,
+      creditMicros: row.credit_micros,
+      currency: row.currency,
+      paymentReferenceHash: row.payment_reference_hash || undefined,
+      createdAt: row.created_at,
+      completedAt: row.completed_at || undefined
+    }));
+  }
+
+  public recordInferenceLedger(input: InferenceLedgerInput): void {
+    this.db.prepare(
+      `INSERT INTO inference_ledger (
+        request_id, seller_key, model_id, endpoint, status, prompt_tokens,
+        completion_tokens, billed_micros, prompt_hash, response_hash, created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      input.requestId,
+      input.sellerKey,
+      input.modelId,
+      input.endpoint,
+      input.status,
+      input.promptTokens,
+      input.completionTokens,
+      input.billedMicros,
+      safeHash(input.prompt) || null,
+      safeHash(input.response) || null,
+      nowIso()
+    );
+  }
+
+  public listInferenceLedger(): SafeInferenceLedgerEntry[] {
+    const rows = this.db.prepare(
+      `SELECT request_id, seller_key, model_id, endpoint, status, prompt_tokens,
+              completion_tokens, billed_micros, prompt_hash, response_hash, created_at
+       FROM inference_ledger
+       ORDER BY id ASC`
+    ).all() as Array<{
+      request_id: string;
+      seller_key: string;
+      model_id: string;
+      endpoint: string;
+      status: string;
+      prompt_tokens: number;
+      completion_tokens: number;
+      billed_micros: number;
+      prompt_hash: string | null;
+      response_hash: string | null;
+      created_at: string;
+    }>;
+
+    return rows.map(row => ({
+      requestId: row.request_id,
+      sellerKey: row.seller_key,
+      modelId: row.model_id,
+      endpoint: row.endpoint,
+      status: row.status,
+      promptTokens: row.prompt_tokens,
+      completionTokens: row.completion_tokens,
+      billedMicros: row.billed_micros,
+      promptHash: row.prompt_hash || undefined,
+      responseHash: row.response_hash || undefined,
+      createdAt: row.created_at
+    }));
+  }
+
+  public close(): void {
+    this.db.close();
+  }
+
+  private initSchema(): void {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS token_cache (
+        seller_key TEXT PRIMARY KEY,
+        token TEXT NOT NULL,
+        token_class TEXT NOT NULL,
+        balance_micros INTEGER NOT NULL,
+        expires_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS payment_config (
+        method TEXT PRIMARY KEY,
+        enabled INTEGER NOT NULL,
+        is_default INTEGER NOT NULL DEFAULT 0,
+        config_json TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS pending_purchases (
+        purchase_id TEXT PRIMARY KEY,
+        seller_key TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        payment_method TEXT NOT NULL,
+        amount_usd_micros INTEGER NOT NULL,
+        status TEXT NOT NULL,
+        payment_reference_hash TEXT,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL,
+        expires_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS purchase_ledger (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        purchase_id TEXT NOT NULL,
+        seller_key TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        payment_method TEXT NOT NULL,
+        status TEXT NOT NULL,
+        credit_micros INTEGER NOT NULL,
+        currency TEXT NOT NULL,
+        payment_reference_hash TEXT,
+        created_at TEXT NOT NULL,
+        completed_at TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS inference_ledger (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        request_id TEXT NOT NULL,
+        seller_key TEXT NOT NULL,
+        model_id TEXT NOT NULL,
+        endpoint TEXT NOT NULL,
+        status TEXT NOT NULL,
+        prompt_tokens INTEGER NOT NULL,
+        completion_tokens INTEGER NOT NULL,
+        billed_micros INTEGER NOT NULL,
+        prompt_hash TEXT,
+        response_hash TEXT,
+        created_at TEXT NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS provider_install_state (
+        provider_id TEXT PRIMARY KEY,
+        snapshot_json TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      );
+    `);
+  }
+
+  private countRows(tableName: string): number {
+    const row = this.db.prepare(`SELECT COUNT(*) AS count FROM ${tableName}`).get() as { count: number };
+    return row.count;
+  }
+}