thaifi-wallet-cli 0.3.5 → 0.4.0

package/README.md

@@ -44,6 +44,8 @@ Set `THAIFI_WALLET_URL` / `THAIFI_RPC_URL` to target other deployments.
 | `tokens` | List supported TIP-20 tokens (symbol, decimals, address) |
 | `balance [--token <symbol\|addr>]` | Balances (default: all supported tokens) |
 | `transfer <to> <amount> [--token <symbol\|addr>]` | Send tokens (default: pathUSD; limit enforced on-chain) |
+| `fund [--no-browser]` | Show the deposit address and open the web Deposit page |
+| `deposit --amount <THB> [--token THCFI\|THCOC] [--ref <id>] [--no-open] [--json]` | **PromptPay QR top-up (1 THB = 1 token)**: order a QR, show it for a human to scan, poll until the tokens are minted |
 | `request <url> [-X -H -d --json --dry-run --max-spend]` | HTTP with automatic x402/MPP payment **and ThaiFiAgent identity auth (401/403 answered by signing the challenge)** |
 | `services [--search q]` | Discover services from the MPP registry (`THAIFI_MPP_REGISTRY`) |
 | `logout` | Remove the local key (revoke on-chain from the web wallet) |
@@ -51,6 +53,38 @@ Set `THAIFI_WALLET_URL` / `THAIFI_RPC_URL` to target other deployments.
 `--token` accepts a symbol (case-insensitive) or a contract address; unknown
 addresses are treated as custom TIP-20s (6 decimals).
 
+## Deposit (PromptPay top-up)
+
+`thaifi deposit --amount 50` orders a PromptPay QR for the paired wallet and
+waits until the tokens are minted (1 THB = 1 token). There is **no API key**:
+the backend verifies on-chain (AccountKeychain precompile, TIP-1011) that the
+agent's access key belongs to a wallet and credits THAT wallet — the recipient
+never comes from the CLI.
+
+```
+$ thaifi deposit --amount 50
+PromptPay deposit — 50.00 THB -> THCFI (1 THB = 1 token)
+Credited wallet: 0x…
+<terminal QR block>
+QR_FILE=~/.thaifi/qr-<referenceNo>.png
+REFERENCE=<referenceNo>
+AMOUNT=50.00 THB -> THCFI
+RESUME=thaifi deposit --ref <referenceNo>
+STATUS=pending  (scan the QR to pay)
+STATUS=delivered
+TX=0x…  Explorer: https://exp.thaifi.com/tx/0x…
+```
+
+- The QR is saved to `~/.thaifi/qr-<referenceNo>.png` (chmod 600), rendered as
+  terminal blocks, and opened in the default viewer (disable with `--no-open`).
+- Orders expire after 15 minutes; paying late still delivers. Resume watching
+  any order with `--ref <referenceNo>` — the status response includes the QR
+  again, so a restarted CLI can re-display it.
+- Limits: 6–10,000 THB per order, 50,000 THB per wallet per 24h, 5 pending
+  orders per wallet. `--json` prints machine-readable output.
+- Requires an approved pairing (`thaifi login`); a revoked/expired key fails
+  with 401 on-chain verification.
+
 ## Security notes
 
 - The recovery password / passphrase is never involved here — the agent key is

package/dist/agentAuth.js

@@ -18,6 +18,31 @@ const ZERO_BODY_HASH = `0x${"00".repeat(32)}`;
 function b64uDecodeBytes(value) {
     return new Uint8Array(Buffer.from(value.replace(/-/g, "+").replace(/_/g, "/"), "base64"));
 }
+/** base64url-encode (utf8) — used for the ThaiFiAgent credential header. */
+export function b64uEncode(s) {
+    return Buffer.from(s, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/, "");
+}
+/** Parse a `WWW-Authenticate: ThaiFiAgent realm="…", challenge="<b64u>"`
+ *  header — ThaiFi Agent Auth (identity proof, no payment). */
+export function parseAgentChallenge(header) {
+    const m = /^ThaiFiAgent\s+(.+)$/i.exec(header.trim());
+    if (!m)
+        return null;
+    const params = {};
+    const re = /([a-zA-Z]+)=((?:"((?:[^"\\]|\\.)*)")|[^\s,]+)/g;
+    let pm;
+    while ((pm = re.exec(m[1]))) {
+        const value = pm[3] !== undefined ? pm[3].replace(/\\(.)/g, "$1") : pm[2];
+        params[pm[1].toLowerCase()] = value;
+    }
+    if (!params.realm || !params.challenge)
+        return null;
+    return { realm: params.realm, nonce: params.challenge };
+}
 export function agentAuthHash(params) {
     const bodyHash = params.body && params.body.length > 0 ? sha256(stringToBytes(params.body)) : ZERO_BODY_HASH;
     return keccak256(concatHex([

package/dist/commands/deposit.js

@@ -0,0 +1,213 @@
+/** `thaifi deposit` — PromptPay QR top-up (1 THB = 1 token).
+ *
+ * Creates a QR order on wallet.thaifi.com and waits until the tokens are
+ * minted. Auth is ThaiFi Agent Auth (no API key): the backend verifies
+ * on-chain (AccountKeychain precompile) that this agent's access key belongs
+ * to a wallet and credits THAT wallet — the CLI never sends a recipient.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import png from "pngjs";
+import * as jsqrModule from "jsqr";
+import qrcodeTerminal from "qrcode-terminal";
+import { loadStore, storePath } from "../store.js";
+import { CONFIG } from "../config.js";
+import { b64uEncode, buildAgentAuthCredential, parseAgentChallenge, } from "../agentAuth.js";
+import { openBrowser } from "./fund.js";
+const ORDER_PATH = "/api/agent/deposit/qr";
+const MIN_THB = 6;
+const MAX_THB = 10000;
+/** Orders expire after 15 min, but a late payment still delivers — keep
+ *  watching that long past expiry. */
+const LATE_GRACE_MS = 15 * 60 * 1000;
+const TERMINAL_STATUSES = new Set(["delivered", "cancelled", "capped", "qr_error"]);
+const { PNG } = png;
+// NodeNext misbinds jsqr's CJS `export default` to the whole module namespace
+// when importing from ESM; at runtime the namespace's `.default` IS the
+// function (verified) — pick it with an explicit cast.
+const jsQR = jsqrModule.default;
+const STATUS_HINTS = {
+    pending: "scan the QR to pay",
+    paid: "payment received — minting",
+    delivering: "minting tokens",
+    delivered: "tokens are in the wallet",
+    cancelled: "order was cancelled",
+    capped: "over the daily cap — needs operator review",
+    qr_error: "QR creation failed",
+};
+// ---------------------------------------------------------------- HTTP + TAA
+/** fetch with automatic ThaiFi Agent Auth: on a 401/403 challenge, sign with
+ *  the agent access key (identity proof, no payment) and retry once. The
+ *  server verifies the key against the AccountKeychain precompile. */
+async function agentFetch(store, url, init) {
+    const headers = {};
+    if (init.body !== undefined)
+        headers["Content-Type"] = "application/json";
+    let res = await fetch(url, { method: init.method, headers, body: init.body });
+    if (res.status === 401 || res.status === 403) {
+        const challenge = parseAgentChallenge(res.headers.get("www-authenticate") ?? "");
+        if (challenge) {
+            const credential = await buildAgentAuthCredential(store, challenge, {
+                method: init.method,
+                url,
+                body: init.body,
+            });
+            res = await fetch(url, {
+                method: init.method,
+                headers: {
+                    ...headers,
+                    Authorization: "ThaiFiAgent " + b64uEncode(JSON.stringify(credential)),
+                },
+                body: init.body,
+            });
+        }
+    }
+    return res;
+}
+// ------------------------------------------------------------------ QR output
+/** Decode the payso QR PNG and re-render it as terminal blocks so a human
+ *  watching the session can scan straight off the screen. Best-effort. */
+function renderTerminalQr(dataUrl) {
+    try {
+        const b64 = dataUrl.slice(dataUrl.indexOf(",") + 1);
+        const img = PNG.sync.read(Buffer.from(b64, "base64"));
+        const decoded = jsQR(new Uint8ClampedArray(img.data), img.width, img.height);
+        if (!decoded?.data)
+            return;
+        console.log("");
+        qrcodeTerminal.generate(decoded.data, { small: true });
+        console.log("");
+    }
+    catch {
+        // terminal rendering is a convenience — the saved PNG always works
+    }
+}
+/** Save the QR image to ~/.thaifi/qr-<referenceNo>.<ext> (chmod 600) so the
+ *  agent has a durable path to show the user. Returns the path or null. */
+function saveQrImage(dataUrl, referenceNo) {
+    try {
+        const m = /^data:image\/(png|jpe?g|webp);base64,(.+)$/s.exec(dataUrl);
+        if (!m)
+            return null;
+        const ext = m[1] === "jpeg" ? "jpg" : m[1];
+        const dir = dirname(storePath);
+        const file = join(dir, `qr-${referenceNo}.${ext}`);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(file, Buffer.from(m[2], "base64"), { mode: 0o600 });
+        return file;
+    }
+    catch {
+        return null;
+    }
+}
+// --------------------------------------------------------------------- polling
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+/** Poll the order until a terminal status (or the late-payment grace runs
+ *  out). Prints STATUS=/TX= lines — machine-parsable like `PAIR_URL=`. */
+async function watchOrder(store, orderUrl, order, options) {
+    const statusUrl = `${orderUrl}/${order.referenceNo}`;
+    const deadline = (order.expiresAt || Date.now()) + LATE_GRACE_MS;
+    let last = "";
+    while (Date.now() < deadline) {
+        const res = await agentFetch(store, statusUrl, { method: "GET" });
+        const data = (await res.json().catch(() => null));
+        if (res.ok && data?.status && data.status !== last) {
+            last = data.status;
+            if (options.json) {
+                const { image, ...rest } = data;
+                console.log(JSON.stringify(rest, null, 2));
+            }
+            else {
+                const hint = STATUS_HINTS[data.status];
+                console.log(`STATUS=${data.status}${hint ? `  (${hint})` : ""}`);
+            }
+            if (data.status === "delivered" && data.txHash && !options.json) {
+                console.log(`TX=${data.txHash}`);
+                console.log(`Explorer: https://exp.thaifi.com/tx/${data.txHash}`);
+            }
+            if (TERMINAL_STATUSES.has(data.status)) {
+                if (data.status !== "delivered")
+                    process.exitCode = 1;
+                return;
+            }
+        }
+        await sleep(CONFIG.pollIntervalMs);
+    }
+    console.error("Timed out waiting for payment. Payment after expiry still delivers — resume later with:");
+    console.error(`  thaifi deposit --ref ${order.referenceNo}`);
+    process.exitCode = 1;
+}
+export async function deposit(options = {}) {
+    const store = loadStore();
+    if (!store?.userAddress) {
+        console.error("Not paired. Run `thaifi login` first.");
+        process.exitCode = 1;
+        return;
+    }
+    // CONFIG (env THAIFI_WALLET_URL > default) — same precedence as `login`,
+    // NOT store.walletUrl: a stale value would silently hit the wrong host.
+    const base = (process.env.THAIFI_WALLET_URL || CONFIG.walletUrl).replace(/\/+$/, "");
+    const orderUrl = base + ORDER_PATH;
+    // --ref: watch an existing order (e.g. after a restart) instead of creating one.
+    if (options.ref) {
+        const res = await agentFetch(store, `${orderUrl}/${options.ref.trim()}`, { method: "GET" });
+        const data = (await res.json().catch(() => null));
+        if (!res.ok || !data?.referenceNo) {
+            console.error(`${res.status}: ${data?.error ?? res.statusText}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!options.json) {
+            console.log(`REFERENCE=${data.referenceNo}`);
+            console.log(`AMOUNT=${data.total} THB -> ${data.token ?? "?"}`);
+        }
+        await watchOrder(store, orderUrl, data, options);
+        return;
+    }
+    const token = (options.token ?? "THCFI").toUpperCase();
+    if (token !== "THCFI" && token !== "THCOC") {
+        console.error("--token must be THCFI or THCOC");
+        process.exitCode = 1;
+        return;
+    }
+    const amount = Number(options.amount);
+    if (!options.amount || !Number.isFinite(amount) || amount < MIN_THB || amount > MAX_THB) {
+        console.error(`--amount must be ${MIN_THB}-${MAX_THB} THB`);
+        process.exitCode = 1;
+        return;
+    }
+    const body = JSON.stringify({ amount, token });
+    const res = await agentFetch(store, orderUrl, { method: "POST", body });
+    const data = (await res.json().catch(() => null));
+    if (!res.ok || !data?.referenceNo) {
+        console.error(`${res.status}: ${data?.error ?? res.statusText}`);
+        if (data?.detail && typeof data.detail === "object") {
+            console.error(JSON.stringify(data.detail).slice(0, 400));
+        }
+        process.exitCode = 1;
+        return;
+    }
+    const file = data.image ? saveQrImage(data.image, data.referenceNo) : null;
+    if (options.json) {
+        const { image, ...rest } = data;
+        console.log(JSON.stringify({ ...rest, qrFile: file }, null, 2));
+    }
+    else {
+        console.log(`PromptPay deposit — ${data.total} THB -> ${token} (1 THB = 1 token)`);
+        console.log(`Credited wallet: ${store.userAddress}`);
+        if (data.image)
+            renderTerminalQr(data.image);
+        if (file)
+            console.log(`QR_FILE=${file}`);
+        console.log(`REFERENCE=${data.referenceNo}`);
+        console.log(`AMOUNT=${data.total} THB -> ${token}`);
+        console.log(`RESUME=thaifi deposit --ref ${data.referenceNo}`);
+        console.log("");
+        console.log("Scan the QR with any banking app — polling until the tokens are minted");
+        console.log("(Ctrl-C to stop; resume with the RESUME command above).");
+    }
+    if (file && options.open !== false) {
+        await openBrowser("file://" + file);
+    }
+    await watchOrder(store, orderUrl, data, options);
+}

package/dist/commands/fund.js

@@ -1,6 +1,6 @@
 /** `thaifi fund` — show the deposit address and open the web Deposit page. */
 import { loadStore } from "../store.js";
-async function openBrowser(url) {
+export async function openBrowser(url) {
     const { exec } = await import("node:child_process");
     const cmd = process.platform === "darwin"
         ? `open "${url}"`

package/dist/commands/login.js

@@ -1,9 +1,17 @@
-/** `thaifi login` — pair this CLI with a wallet.thaifi.com account. */
+/** `thaifi login` — pair this CLI with a wallet.thaifi.com account.
+ *
+ * Reliability guarantees (0.3.6+):
+ * - The approval URL is always written to ~/.thaifi/pair.log (chmod 600), so
+ *   background launchers that lose stdout can recover it.
+ * - A pairing created but not yet approved is persisted in the store; re-running
+ *   `thaifi login` within the poll window REUSES it (same URL, same key) instead
+ *   of creating throwaway pairings on the server.
+ */
 import { hostname } from "node:os";
 import { generatePrivateKey } from "viem/accounts";
 import { Account } from "viem/tempo";
 import { CONFIG } from "../config.js";
-import { loadStore, saveStore, storePath } from "../store.js";
+import { loadStore, saveStore, storePath, writePairLog, pairLogPath } from "../store.js";
 const signatureType = "p256";
 async function openBrowser(url) {
     const { exec } = await import("node:child_process");
@@ -14,44 +22,97 @@ async function openBrowser(url) {
             : `xdg-open "${url}"`;
     exec(cmd, () => undefined);
 }
+function pairLogContent(p, status) {
+    return [
+        "# ThaiFi CLI pairing",
+        "created=" + new Date(p.createdAt).toISOString(),
+        "PAIR_URL=" + p.url,
+        "PAIR_CODE=" + p.code,
+        "KEY_ID=" + p.keyId,
+        "MACHINE=" + p.name,
+        "STATUS=" + status,
+        "",
+    ].join("\n");
+}
 export async function login(options = {}) {
-    if (loadStore()) {
+    const existing = loadStore();
+    if (existing?.userAddress) {
         console.error("Already paired (found " + storePath + "). Run `thaifi logout` first to re-pair.");
         process.exitCode = 1;
         return;
     }
-    // 1. Generate the agent access key (P256 — never leaves this machine).
-    const privateKey = generatePrivateKey();
-    const name = hostname();
-    const keyId = Account.fromP256(privateKey).address;
-    console.log("Agent key:  " + keyId);
-    console.log("Machine:    " + name);
-    console.log("");
-    // 2. Start pairing with the web wallet.
-    const startRes = await fetch(CONFIG.walletUrl + "/api/agent/pair/start", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ keyId, name, signatureType }),
-    });
-    if (!startRes.ok) {
-        console.error("Pairing failed to start: HTTP " + startRes.status + " " + (await startRes.text()));
-        process.exitCode = 1;
-        return;
+    // Reuse a still-fresh pending pairing instead of creating a new one —
+    // a re-run of `thaifi login` (crashed launcher, lost stdout, impatient
+    // retry) must never pile up throwaway pairings on the server.
+    const pending = existing?.pending;
+    let reused = false;
+    let privateKey;
+    let name;
+    let keyId;
+    let pairingId;
+    let code;
+    let url;
+    if (pending && Date.now() - pending.createdAt < CONFIG.pollTimeoutMs) {
+        reused = true;
+        privateKey = pending.privateKey;
+        keyId = pending.keyId;
+        name = pending.name;
+        pairingId = pending.pairingId;
+        code = pending.code;
+        url = pending.url;
+        console.log("Pairing already waiting for approval (started " +
+            Math.round((Date.now() - pending.createdAt) / 60000) +
+            " min ago) — reusing it, no new pairing created.");
+    }
+    else {
+        // 1. Generate the agent access key (P256 — never leaves this machine).
+        privateKey = generatePrivateKey();
+        name = hostname();
+        keyId = Account.fromP256(privateKey).address;
+        console.log("Agent key:  " + keyId);
+        console.log("Machine:    " + name);
+        console.log("");
+        // 2. Start pairing with the web wallet.
+        const startRes = await fetch(CONFIG.walletUrl + "/api/agent/pair/start", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ keyId, name, signatureType }),
+        });
+        if (!startRes.ok) {
+            console.error("Pairing failed to start: HTTP " + startRes.status + " " + (await startRes.text()));
+            process.exitCode = 1;
+            return;
+        }
+        ({ pairingId, code } = (await startRes.json()));
+        url = `${CONFIG.walletUrl}/pair?id=${pairingId}&code=${code}`;
+        // Persist the pending pairing BEFORE printing anything — if this process
+        // dies, a re-run recovers the same pairing instead of orphaning it.
+        saveStore({
+            privateKey,
+            keyId,
+            name,
+            walletUrl: CONFIG.walletUrl,
+            rpcUrl: CONFIG.rpcUrl,
+            chainId: CONFIG.chainId,
+            pending: { pairingId, code, url, keyId, name, privateKey, createdAt: Date.now() },
+        });
     }
-    const { pairingId, code } = (await startRes.json());
-    const url = `${CONFIG.walletUrl}/pair?id=${pairingId}&code=${code}`;
+    // 3. Print + persist the approval URL (both routes land here).
     console.log("Authorize this CLI in the ThaiFi Wallet:");
     console.log("");
     console.log("  " + url);
     console.log("");
+    console.log("PAIR_URL=" + url);
     console.log("Pairing code: " + code);
+    writePairLog(pairLogContent({ pairingId, code, url, keyId, name, privateKey, createdAt: pending?.createdAt ?? Date.now() }, reused ? "waiting-for-approval (reused)" : "waiting-for-approval"));
+    console.log("(approval link saved to " + pairLogPath + ")");
     if (options.browser !== false) {
         await openBrowser(url);
         console.log("(opened in your browser — use --no-browser on a headless machine)");
     }
     console.log("");
     console.log("Waiting for approval (timeout " + CONFIG.pollTimeoutMs / 60000 + " min)…");
-    // 3. Poll until approved.
+    // 4. Poll until approved.
     const deadline = Date.now() + CONFIG.pollTimeoutMs;
     let status = null;
     while (Date.now() < deadline) {
@@ -64,17 +125,22 @@ export async function login(options = {}) {
             break;
         if (status.status === "rejected" || status.status === "claimed") {
             console.error("Pairing was " + status.status + " on the web wallet.");
+            // Clear the dead pending pairing so the next login starts fresh.
+            if (existing)
+                saveStore({ ...existing, pending: undefined });
             process.exitCode = 1;
             return;
         }
         process.stdout.write(".");
     }
     if (status?.status !== "approved") {
-        console.error("\nPairing timed out.");
+        console.error("\nPairing timed out. The approval link is still in " +
+            pairLogPath +
+            " — run `thaifi login` again to reuse it (recommending the user approve) or wait for it to expire server-side.");
         process.exitCode = 1;
         return;
     }
-    // 4. Persist.
+    // 5. Persist the completed pairing (and clear pending).
     saveStore({
         privateKey,
         keyId,
@@ -87,7 +153,9 @@ export async function login(options = {}) {
         limitAmount: status.limitAmount,
         limitPeriod: status.limitPeriod,
         keyExpiry: status.expiry,
+        pending: undefined,
     });
+    writePairLog(pairLogContent({ pairingId, code, url, keyId, name, privateKey, createdAt: pending?.createdAt ?? Date.now() }, "approved"));
     console.log("");
     console.log("✓ Paired!");
     console.log("  Wallet account: " + status.userAddress);

package/dist/commands/request.js

@@ -2,23 +2,16 @@
 import { concatHex, keccak256, slice, stringToBytes } from "viem";
 import { loadStore } from "../store.js";
 import { createAgentClient, pickFeeToken } from "../chain.js";
-import { buildAgentAuthCredential } from "../agentAuth.js";
+import { b64uEncode, buildAgentAuthCredential, parseAgentChallenge, } from "../agentAuth.js";
 import { CONFIG, PATHUSD_DECIMALS } from "../config.js";
 import { PATHUSD, resolveToken } from "../tokens.js";
-function b64uDecode(s) {
-    return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
-}
-function b64uEncode(s) {
-    return Buffer.from(s, "utf8")
-        .toString("base64")
-        .replace(/\+/g, "-")
-        .replace(/\//g, "_")
-        .replace(/=+$/, "");
-}
 /**
  * Parse an MPP `WWW-Authenticate: Payment id="…", request="<b64u json>"` header.
  * See https://mpp.dev — Machine Payments Protocol.
  */
+function b64uDecode(s) {
+    return Buffer.from(s.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf8");
+}
 export function parseMppChallenge(header) {
     const m = /^Payment\s+(.+)$/i.exec(header.trim());
     if (!m)
@@ -53,26 +46,6 @@ export function parseMppChallenge(header) {
         challenge.expires = params.expires;
     return challenge;
 }
-/**
- * Parse a `WWW-Authenticate: ThaiFiAgent realm="…", challenge="<b64u>"`
- * header — ThaiFi Agent Auth (identity proof, no payment). The server
- * verifies our signature against the AccountKeychain precompile.
- */
-function parseAgentChallenge(header) {
-    const m = /^ThaiFiAgent\s+(.+)$/i.exec(header.trim());
-    if (!m)
-        return null;
-    const params = {};
-    const re = /([a-zA-Z]+)=((?:"((?:[^"\\]|\\.)*)")|[^\s,]+)/g;
-    let pm;
-    while ((pm = re.exec(m[1]))) {
-        const value = pm[3] !== undefined ? pm[3].replace(/\\(.)/g, "$1") : pm[2];
-        params[pm[1].toLowerCase()] = value;
-    }
-    if (!params.realm || !params.challenge)
-        return null;
-    return { realm: params.realm, nonce: params.challenge };
-}
 /** MPP tempo charge → on-chain TIP-20 transfer (push mode: we broadcast, then send the hash). */
 function mppTempoChallenge(challenge) {
     const req = challenge.request;

package/dist/index.js

@@ -10,6 +10,7 @@ import { transfer } from "./commands/transfer.js";
 import { request } from "./commands/request.js";
 import { services } from "./commands/services.js";
 import { fund } from "./commands/fund.js";
+import { deposit } from "./commands/deposit.js";
 import { tokens } from "./commands/tokens.js";
 // Resolve ../package.json at runtime (works from src/ via tsx and from dist/ when installed) — never hardcode the version here again.
 const { version } = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
@@ -53,6 +54,15 @@ program
     .description("Show your deposit address and open the web Deposit page")
     .option("--no-browser", "Print the address without opening a browser")
     .action(fund);
+program
+    .command("deposit")
+    .description("PromptPay QR top-up (1 THB = 1 token): create a QR order, show it for the user to scan, and wait until the tokens are minted")
+    .option("--amount <thb>", "Amount in THB (6-10000)")
+    .option("--token <symbol>", "Payout token: THCFI (default) or THCOC")
+    .option("--ref <referenceNo>", "Watch an existing order instead of creating a new one")
+    .option("--no-open", "Do not open the saved QR image in a viewer")
+    .option("--json", "Machine-readable output (JSON)")
+    .action(deposit);
 program
     .command("request")
     .description("HTTP request with automatic x402/MPP payments (curl-like)")

package/dist/store.js

@@ -6,6 +6,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 const DIR = join(homedir(), ".thaifi");
 const FILE = join(DIR, "store.json");
+const PAIR_LOG = join(DIR, "pair.log");
 export function loadStore() {
     if (!existsSync(FILE))
         return null;
@@ -31,3 +32,17 @@ export function clearStore() {
         rmSync(FILE);
 }
 export const storePath = FILE;
+export const pairLogPath = PAIR_LOG;
+/** Writes ~/.thaifi/pair.log (chmod 600) — the durable copy of the approval
+ * URL. Background launchers that lose stdout can always recover the link
+ * from this file. Overwritten on every `thaifi login`. */
+export function writePairLog(content) {
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(PAIR_LOG, content, { mode: 0o600 });
+    try {
+        chmodSync(PAIR_LOG, 0o600);
+    }
+    catch {
+        // best-effort on platforms without chmod
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thaifi-wallet-cli",
-  "version": "0.3.5",
+  "version": "0.4.0",
   "description": "ThaiFi Wallet CLI for AI agents — pair with wallet.thaifi.com, sign with on-chain access keys (spending limits enforced on-chain), x402/MPP payments",
   "type": "module",
   "bin": {
@@ -34,10 +34,14 @@
   },
   "dependencies": {
     "commander": "^14.0.0",
+    "jsqr": "^1.4.0",
+    "pngjs": "^7.0.0",
+    "qrcode-terminal": "^0.12.0",
     "viem": "^2.56.0"
   },
   "devDependencies": {
     "@types/node": "^24.13.2",
+    "@types/pngjs": "^6.0.5",
     "tsx": "^4.19.0",
     "typescript": "^5.9.0"
   }