@tokenbuddy/tokenbuddy 1.0.6 → 1.0.8

package/src/terminal-image.ts

@@ -0,0 +1,187 @@
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+
+type TerminalEnv = Readonly<Record<string, string | undefined>>;
+
+export type TerminalImageDisplayMethod =
+  | "inline-iterm"
+  | "inline-kitty"
+  | "system-open"
+  | "manual";
+
+export interface TerminalImageDisplayResult {
+  method: TerminalImageDisplayMethod;
+  displayed: boolean;
+  message: string;
+  fallbackCommand?: string;
+}
+
+export interface DisplayTerminalImageOptions {
+  env?: TerminalEnv;
+  platform?: NodeJS.Platform;
+  stdoutIsTTY?: boolean;
+  write?: (chunk: string) => void;
+  runCommand?: (command: string, args: string[]) => Promise<void>;
+  fileExists?: (filePath: string) => boolean;
+  readFile?: (filePath: string) => Buffer;
+}
+
+type InlineImageProtocol = "iterm" | "kitty";
+
+function defaultRunCommand(command: string, args: string[]): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: "ignore",
+    });
+    child.on("error", reject);
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(new Error(`${command} exited with ${code}`));
+    });
+  });
+}
+
+function terminalSupportsInlineImages(
+  env: TerminalEnv,
+  stdoutIsTTY: boolean,
+): InlineImageProtocol | undefined {
+  if (!stdoutIsTTY) {
+    return undefined;
+  }
+
+  const term = env.TERM || "";
+  if (env.KITTY_WINDOW_ID || term.includes("xterm-kitty")) {
+    return "kitty";
+  }
+
+  const termProgram = env.TERM_PROGRAM || "";
+  if (termProgram === "iTerm.app" || termProgram === "WezTerm" || env.WEZTERM_EXECUTABLE) {
+    return "iterm";
+  }
+
+  return undefined;
+}
+
+function basenameBase64(filePath: string): string {
+  return Buffer.from(path.basename(filePath), "utf8").toString("base64");
+}
+
+function itermInlineImageSequence(filePath: string, image: Buffer): string {
+  const payload = image.toString("base64");
+  return `\u001B]1337;File=name=${basenameBase64(filePath)};inline=1;width=60%;preserveAspectRatio=1:${payload}\u0007\n`;
+}
+
+function kittyInlineImageSequence(filePath: string): string {
+  const payload = Buffer.from(filePath, "utf8").toString("base64");
+  return `\u001B_Ga=T,t=f,f=100,c=60;${payload}\u001B\\\n`;
+}
+
+function openCommandForPlatform(platform: NodeJS.Platform, filePath: string): { command: string; args: string[]; label: string } | undefined {
+  if (platform === "darwin") {
+    return {
+      command: "open",
+      args: [filePath],
+      label: `open ${filePath}`,
+    };
+  }
+  if (platform === "linux") {
+    return {
+      command: "xdg-open",
+      args: [filePath],
+      label: `xdg-open ${filePath}`,
+    };
+  }
+  if (platform === "win32") {
+    return {
+      command: "cmd",
+      args: ["/c", "start", "", filePath],
+      label: `start ${filePath}`,
+    };
+  }
+  return undefined;
+}
+
+export function detectTerminalImageDisplay(
+  options: DisplayTerminalImageOptions = {},
+): InlineImageProtocol | undefined {
+  return terminalSupportsInlineImages(
+    options.env || process.env,
+    options.stdoutIsTTY ?? Boolean(process.stdout.isTTY),
+  );
+}
+
+export async function displayTerminalImage(
+  filePath: string,
+  options: DisplayTerminalImageOptions = {},
+): Promise<TerminalImageDisplayResult> {
+  const fileExists = options.fileExists || fs.existsSync;
+  const readFile = options.readFile || fs.readFileSync;
+  const write = options.write || ((chunk: string) => process.stdout.write(chunk));
+  const env = options.env || process.env;
+  const platform = options.platform || process.platform;
+  const stdoutIsTTY = options.stdoutIsTTY ?? Boolean(process.stdout.isTTY);
+  const openCommand = openCommandForPlatform(platform, filePath);
+  const fallbackCommand = openCommand?.label;
+
+  if (!fileExists(filePath)) {
+    return {
+      method: "manual",
+      displayed: false,
+      fallbackCommand,
+      message: `QR image file is missing: ${filePath}`,
+    };
+  }
+
+  const inlineProtocol = terminalSupportsInlineImages(env, stdoutIsTTY);
+  if (inlineProtocol === "kitty") {
+    write(kittyInlineImageSequence(filePath));
+    return {
+      method: "inline-kitty",
+      displayed: true,
+      fallbackCommand,
+      message: "Displayed the ClawTip wallet QR image inline using the Kitty graphics protocol.",
+    };
+  }
+
+  if (inlineProtocol === "iterm") {
+    write(itermInlineImageSequence(filePath, readFile(filePath)));
+    return {
+      method: "inline-iterm",
+      displayed: true,
+      fallbackCommand,
+      message: "Displayed the ClawTip wallet QR image inline using the iTerm2 image protocol.",
+    };
+  }
+
+  if (openCommand) {
+    try {
+      const runCommand = options.runCommand || defaultRunCommand;
+      await runCommand(openCommand.command, openCommand.args);
+      return {
+        method: "system-open",
+        displayed: true,
+        fallbackCommand,
+        message: `Opened the ClawTip wallet QR image with the system image viewer: ${openCommand.label}`,
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        method: "manual",
+        displayed: false,
+        fallbackCommand,
+        message: `Could not open QR image automatically: ${message}`,
+      };
+    }
+  }
+
+  return {
+    method: "manual",
+    displayed: false,
+    fallbackCommand,
+    message: "This terminal does not advertise inline image support and no system opener is available.",
+  };
+}

package/tests/e2e.test.ts

@@ -243,6 +243,32 @@ describe("TokenBuddy Full End-to-End Integration Flow Tests", () => {
 
     verifyDb.close();
 
+    const buyerAfterConcurrent = new BuyerStore({ dbPath: TEMP_BUYER_DB });
+    try {
+      const tokenCache = buyerAfterConcurrent.getToken("seller-e2e-node");
+      expect(tokenCache).toMatchObject({
+        balanceMicros: 1999450,
+        reservedMicros: 0,
+        spentMicros: 550,
+        balanceSource: "seller_settlement_summary"
+      });
+      const inferenceLedger = buyerAfterConcurrent.listInferenceLedger();
+      expect(inferenceLedger.filter((entry) => entry.requestId.startsWith("req_p_"))).toHaveLength(5);
+      expect(inferenceLedger).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          requestId: "req_p_1",
+          billedMicros: 110,
+          estimatedMicros: 200,
+          settledMicros: 110,
+          settledUsdMicros: 110,
+          priceVersion: "openrouter_usd.v1",
+          balanceSource: "seller_authoritative"
+        })
+      ]));
+    } finally {
+      buyerAfterConcurrent.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();
@@ -260,14 +286,62 @@ describe("TokenBuddy Full End-to-End Integration Flow Tests", () => {
     expect(purchaseCount).toBe(1);
     verifyDb2.close();
 
-    // Step 8: Verify newly implemented admin query billing APIs (purchases & requests)
+    // Step 8: Force seller-authoritative insufficiency while buyer cache still looks funded.
+    // The daemon must refresh /v1/balance, auto-purchase once, and retry the same request idempotently.
+    const forcedDb = new DatabaseSync(TEMP_SELLER_DB);
+    const oldCredential = forcedDb.prepare("SELECT credential_id FROM credentials ORDER BY created_at ASC LIMIT 1").get() as any;
+    forcedDb.prepare("UPDATE credentials SET credit_balance_micros = 1, reserved_micros = 0 WHERE credential_id = ?").run(oldCredential.credential_id);
+    forcedDb.prepare("UPDATE tokens SET credit_balance_micros = 1, reserved_micros = 0 WHERE credential_id = ?").run(oldCredential.credential_id);
+    forcedDb.close();
+    const buyerBefore402 = new BuyerStore({ dbPath: TEMP_BUYER_DB });
+    try {
+      const cached = buyerBefore402.getToken("seller-e2e-node");
+      expect(cached?.balanceMicros).toBeGreaterThan(200000);
+    } finally {
+      buyerBefore402.close();
+    }
+
+    const retryResponse = await sendProxyRequest("req_402_rebuy_retry");
+    expect(retryResponse.ok).toBe(true);
+    const retryData = await retryResponse.json() as any;
+    expect(retryData.id).toBe("chatcmpl-e2e-ok");
+
+    const verifyDb3 = new DatabaseSync(TEMP_SELLER_DB);
+    const purchaseCountAfterRetry = (verifyDb3.prepare("SELECT COUNT(*) as count FROM purchases").get() as any).count;
+    const retryRows = verifyDb3.prepare("SELECT state, settled_micros FROM requests WHERE request_id = ?").all("req_402_rebuy_retry") as any[];
+    expect(purchaseCountAfterRetry).toBe(2);
+    expect(retryRows).toEqual([
+      expect.objectContaining({ state: "settled", settled_micros: 110 })
+    ]);
+    verifyDb3.close();
+
+    const buyerAfterRetry = new BuyerStore({ dbPath: TEMP_BUYER_DB });
+    try {
+      expect(buyerAfterRetry.listInferenceLedger()).toEqual(expect.arrayContaining([
+        expect.objectContaining({
+          requestId: "req_402_rebuy_retry",
+          billedMicros: 110,
+          estimatedMicros: 200,
+          settledMicros: 110,
+          balanceSource: "seller_authoritative"
+        })
+      ]));
+      expect(buyerAfterRetry.getToken("seller-e2e-node")).toMatchObject({
+        balanceMicros: 1999890,
+        balanceSource: "seller_settlement_summary"
+      });
+    } finally {
+      buyerAfterRetry.close();
+    }
+
+    // Step 9: 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");
+    expect(billingPurchases.purchases.length).toBe(2);
+    expect(billingPurchases.purchases.every((purchase: any) => purchase.state === "funded")).toBe(true);
 
     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);
+    // 5 concurrent requests + 1 cache hit + 1 retry-after-402 request = 7 settled inference requests.
+    expect(billingRequests.requests.length).toBe(7);
     expect(billingRequests.requests.every((r: any) => r.state === "settled")).toBe(true);
   });
 });