@bankr/cli 0.3.38 → 0.3.43

package/dist/commands/fees.js

@@ -3,6 +3,7 @@ import { confirm, password, checkbox } from "@inquirer/prompts";
 import { isAddress } from "viem";
 import { getCreatorFees, getBeneficiaryFeesStreaming, getTokenCreatorFees, getUserInfo, claimTokenLaunchFees, } from "../lib/api.js";
 import { emitCESP } from "../lib/cesp/engine.js";
+import { CHAIN_LABELS } from "../lib/chains.js";
 import { requireApiKey } from "../lib/config.js";
 import { txExplorer } from "../lib/explorer.js";
 import * as output from "../lib/output.js";
@@ -129,7 +130,7 @@ function drawChart(dailyData) {
     const xAxisPadding = " ".repeat(14);
     if (dailyData.length > 0) {
         const first = dailyData[0].date.slice(5);
-        const last = dailyData[dailyData.length - 1].date.slice(5);
+        const last = dailyData.at(-1).date.slice(5);
         const mid = dailyData[Math.floor(dailyData.length / 2)].date.slice(5);
         const gap1 = Math.floor(CHART_WIDTH / 2) - first.length;
         const gap2 = CHART_WIDTH - Math.floor(CHART_WIDTH / 2) - mid.length;
@@ -653,12 +654,21 @@ export async function feesClaimWalletCommand(address, opts) {
             ],
         },
     ];
-    // Robinhood-chain launches can't be claimed here: this flow signs and
-    // broadcasts on Base only, and a Base tx to a robinhood initializer is a
-    // gas-burning no-op. Skip them loudly.
-    const baseChainTokens = selectedTokens.filter((t) => (t.chain ?? "base") === "base");
-    if (baseChainTokens.length < selectedTokens.length) {
-        output.warn(`${selectedTokens.length - baseChainTokens.length} Robinhood Chain token(s) skipped — CLI claiming supports Base only for now. Claim at https://bankr.bot/launches instead.`);
+    // Launches on other chains can't be claimed here: this flow signs and
+    // broadcasts on Base only, and a Base tx to another chain's initializer is a
+    // gas-burning no-op. Skip them loudly, linking each token page's claim flow.
+    const chainOf = (t) => t.chain ?? "base";
+    const baseChainTokens = selectedTokens.filter((t) => chainOf(t) === "base");
+    const skippedTokens = selectedTokens.filter((t) => chainOf(t) !== "base");
+    if (skippedTokens.length > 0) {
+        const names = [...new Set(skippedTokens.map(chainOf))].map((chain) => CHAIN_LABELS[chain] ?? chain);
+        const skippedChains = names.length > 1
+            ? `${names.slice(0, -1).join(", ")} and ${names[names.length - 1]}`
+            : names[0];
+        output.warn(`${skippedTokens.length} ${skippedChains} token(s) skipped — CLI claiming supports Base only for now. Claim them on each token's page instead:`);
+        for (const t of skippedTokens) {
+            output.dim(`  ${t.symbol}: https://bankr.bot/terminal/trade?out=${t.tokenAddress}&chain=${chainOf(t)}`);
+        }
     }
     // Filter to tokens with initializer (required for local tx building)
     const buildableTokens = baseChainTokens.filter((t) => t.initializer);

package/dist/commands/llm.js

@@ -38,6 +38,15 @@ const GATEWAY_MODELS = [
         input: IMAGE_INPUT,
         cost: { input: 10.0, output: 50.0, cacheRead: 1.0, cacheWrite: 12.5 },
     },
+    {
+        id: "claude-opus-5.5",
+        name: "Claude Opus 5.5",
+        owned_by: "anthropic",
+        contextWindow: 1000000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 4.0, output: 20.0, cacheRead: 0.2, cacheWrite: 5.0 },
+    },
     {
         id: "claude-opus-5",
         name: "Claude Opus 5",
@@ -83,6 +92,15 @@ const GATEWAY_MODELS = [
         input: IMAGE_INPUT,
         cost: { input: 5.0, output: 25.0, cacheRead: 0.5, cacheWrite: 6.25 },
     },
+    {
+        id: "claude-sonnet-5.5",
+        name: "Claude Sonnet 5.5",
+        owned_by: "anthropic",
+        contextWindow: 1000000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 2.0, output: 10.0, cacheRead: 0.2, cacheWrite: 2.5 },
+    },
     {
         id: "claude-sonnet-5",
         name: "Claude Sonnet 5",
@@ -182,6 +200,12 @@ const GATEWAY_MODELS = [
         maxTokens: 65536,
         input: IMAGE_INPUT,
         cost: { input: 1.25, output: 10.0, cacheRead: 0.125, cacheWrite: 0.375 },
+        // Google retires the 2.5 line on 2026-10-20 (published on every Vertex
+        // endpoint). Without this the offline catalog advertises it as active.
+        deprecation: {
+            replaced_by: "gemini-3.1-pro",
+            removed_at: "2026-10-20T00:00:00.000Z",
+        },
     },
     {
         id: "gemini-2.5-flash",
@@ -191,6 +215,10 @@ const GATEWAY_MODELS = [
         maxTokens: 65535,
         input: IMAGE_INPUT,
         cost: { input: 0.3, output: 2.5, cacheRead: 0.03, cacheWrite: 0.0833 },
+        deprecation: {
+            replaced_by: "gemini-3.8-flash",
+            removed_at: "2026-10-20T00:00:00.000Z",
+        },
     },
     // Gemma
     {
@@ -243,6 +271,24 @@ const GATEWAY_MODELS = [
         input: IMAGE_INPUT,
         cost: { input: 10.0, output: 50.0, cacheRead: 1.0, cacheWrite: 12.5 },
     },
+    {
+        id: "gpt-6-sol",
+        name: "GPT 6 Sol",
+        owned_by: "openai",
+        contextWindow: 1050000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 2.0, output: 10.0, cacheRead: 0.2, cacheWrite: 2.5 },
+    },
+    {
+        id: "gpt-6-luna",
+        name: "GPT 6 Luna",
+        owned_by: "openai",
+        contextWindow: 1050000,
+        maxTokens: 128000,
+        input: IMAGE_INPUT,
+        cost: { input: 0.1, output: 0.5, cacheRead: 0.01, cacheWrite: 0.125 },
+    },
     {
         id: "gpt-5.6-sol",
         name: "GPT 5.6 Sol",
@@ -355,6 +401,15 @@ const GATEWAY_MODELS = [
         cost: { input: 0.05, output: 0.4, cacheRead: 0.005, cacheWrite: 0 },
     },
     // Other providers
+    {
+        id: "grok-4.7",
+        name: "Grok 4.7",
+        owned_by: "x-ai",
+        contextWindow: 500000,
+        maxTokens: 500000,
+        input: IMAGE_INPUT,
+        cost: { input: 2.0, output: 6.0, cacheRead: 0.5, cacheWrite: 0 },
+    },
     {
         id: "grok-4.6",
         name: "Grok 4.6",
@@ -604,6 +659,15 @@ const GATEWAY_MODELS = [
         input: TEXT_INPUT,
         cost: { input: 0.6, output: 2.4, cacheRead: 0.06, cacheWrite: 0 },
     },
+    {
+        id: "glm-5.3-flashx",
+        name: "GLM-5.3 FlashX",
+        owned_by: "z-ai",
+        contextWindow: 1048576,
+        maxTokens: 131072,
+        input: IMAGE_INPUT,
+        cost: { input: 0.37, output: 1.25, cacheRead: 0.075, cacheWrite: 0 },
+    },
     {
         id: "glm-5.3-flash",
         name: "GLM-5.3 Flash",

package/dist/commands/login.d.ts

@@ -11,6 +11,37 @@ export declare class MfaStepUpError extends Error {
 /** Keyed on `code`, never on message text, so a server wording change can't
  * silently turn this back into the opaque failure. */
 export declare function mfaStepUpErrorFrom(body: unknown): MfaStepUpError | null;
+/** Any 5xx: a gateway page (ALB/CloudFront 502/503/504) the API never saw, or
+ * an API catch-all such as a DB blip. Idempotent callers retry it; the API's
+ * own message, when it sent one, is kept for the final report. */
+export declare class TransientHttpError extends Error {
+    readonly status: number;
+    constructor(status: number, apiMessage?: string);
+}
+/** True for a request the API never answered: undici's `fetch failed`, a
+ * socket-level code, or a gateway error page. An API refusal is not one. */
+export declare function isTransientNetworkError(err: unknown, depth?: number): boolean;
+/**
+ * Retry a login step on network blips only. The OTP is already spent by the
+ * time the wallet step runs, so a dropped connection here used to cost the
+ * user a fresh code; three quick attempts ride out the transient case.
+ */
+export declare function withNetworkRetry<T>(run: () => Promise<T>, opts?: {
+    attempts?: number;
+    baseDelayMs?: number;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<T>;
+/** Key names are unique per user, so the default carries the time to the
+ * second: a scripted re-login seconds after a dropped mint response (which
+ * already created the key) must not collide with the earlier default. */
+export declare function defaultCliKeyName(now?: Date): string;
+/** Headless login (`--code` / `--ni`) accepts the Terms of Service as part of
+ * logging in, so the one-time code isn't burned on a missing flag. Interactive
+ * login returns undefined to defer to the prompt. */
+export declare function resolveTermsAcceptance(opts: {
+    headless: boolean;
+    acceptTerms?: boolean;
+}): boolean | undefined;
 /** The web app that fronts an API URL: `BANKR_WEB_URL` when set (local dev,
  * staging), bankr.bot for the official API, else the API host with its
  * `api.`/`api-` prefix dropped. */
@@ -41,6 +72,13 @@ export declare function resolveKeyPermissionOverrides(opts: {
     readOnly?: boolean;
     agentApiEnabled?: boolean;
 };
+/**
+ * Parse a login-gated response. The body is read as text first so a gateway
+ * HTML error page becomes a `TransientHttpError` instead of a `SyntaxError`
+ * from `res.json()`. Every 5xx is transient (callers that opted into the
+ * retry replay it; others just report it); a 4xx keeps the API's message.
+ */
+export declare function readGatedResponse<T>(res: Response, label: string): Promise<T>;
 declare const CHALLENGE_STATUSES: readonly ["pending", "verified", "expired", "abandoned", "failed"];
 export type ChallengeStatus = (typeof CHALLENGE_STATUSES)[number];
 /**

package/dist/commands/login.js

@@ -35,6 +35,77 @@ export function mfaStepUpErrorFrom(body) {
         return null;
     return new MfaStepUpError(typeof context === "string" ? context : "unknown");
 }
+const NETWORK_ERROR_CODES = new Set([
+    "ECONNRESET",
+    "ECONNREFUSED",
+    "ETIMEDOUT",
+    "ENOTFOUND",
+    "EAI_AGAIN",
+    "EPIPE",
+    "UND_ERR_SOCKET",
+    "UND_ERR_CONNECT_TIMEOUT",
+]);
+/** Any 5xx: a gateway page (ALB/CloudFront 502/503/504) the API never saw, or
+ * an API catch-all such as a DB blip. Idempotent callers retry it; the API's
+ * own message, when it sent one, is kept for the final report. */
+export class TransientHttpError extends Error {
+    constructor(status, apiMessage) {
+        super(apiMessage ?? `Bankr API unavailable (${status})`);
+        this.status = status;
+        this.name = "TransientHttpError";
+    }
+}
+/** True for a request the API never answered: undici's `fetch failed`, a
+ * socket-level code, or a gateway error page. An API refusal is not one. */
+export function isTransientNetworkError(err, depth = 0) {
+    if (depth > 5)
+        return false;
+    if (!(err instanceof Error) || err instanceof MfaStepUpError)
+        return false;
+    if (err instanceof TransientHttpError)
+        return true;
+    // undici: "fetch failed" when no connection, "terminated" on a mid-body drop.
+    if (err instanceof TypeError &&
+        (err.message === "fetch failed" || err.message === "terminated")) {
+        return true;
+    }
+    const code = err.code;
+    if (typeof code === "string" && NETWORK_ERROR_CODES.has(code))
+        return true;
+    return isTransientNetworkError(err.cause, depth + 1);
+}
+/**
+ * Retry a login step on network blips only. The OTP is already spent by the
+ * time the wallet step runs, so a dropped connection here used to cost the
+ * user a fresh code; three quick attempts ride out the transient case.
+ */
+export async function withNetworkRetry(run, opts = {}) {
+    const { attempts = 3, baseDelayMs = 1000, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), } = opts;
+    for (let attempt = 1;; attempt++) {
+        try {
+            return await run();
+        }
+        catch (err) {
+            if (attempt >= attempts || !isTransientNetworkError(err))
+                throw err;
+            await sleep(baseDelayMs * 2 ** (attempt - 1));
+        }
+    }
+}
+/** Key names are unique per user, so the default carries the time to the
+ * second: a scripted re-login seconds after a dropped mint response (which
+ * already created the key) must not collide with the earlier default. */
+export function defaultCliKeyName(now = new Date()) {
+    const iso = now.toISOString();
+    return `CLI-${iso.slice(0, 10)}-${iso.slice(11, 19).replace(/:/g, "")}`;
+}
+/** Headless login (`--code` / `--ni`) accepts the Terms of Service as part of
+ * logging in, so the one-time code isn't burned on a missing flag. Interactive
+ * login returns undefined to defer to the prompt. */
+export function resolveTermsAcceptance(opts) {
+    // `--accept-terms` is set-only (no `--no-accept-terms`), so `||` is safe.
+    return opts.acceptTerms || opts.headless || undefined;
+}
 /** The web app that fronts an API URL: `BANKR_WEB_URL` when set (local dev,
  * staging), bankr.bot for the official API, else the API host with its
  * `api.`/`api-` prefix dropped. */
@@ -111,7 +182,9 @@ export function resolveKeyPermissionOverrides(opts) {
     return overrides;
 }
 async function verifyPrivyOtp(privyConfig, email, code) {
-    const res = await fetch("https://auth.privy.io/api/v1/passwordless/authenticate", {
+    // Retry only a request that never got an answer. If Privy did answer and
+    // the socket dropped, the replay reads as INVALID_CODE: no worse than today.
+    const res = await withNetworkRetry(() => fetch("https://auth.privy.io/api/v1/passwordless/authenticate", {
         method: "POST",
         headers: {
             "Content-Type": "application/json",
@@ -119,7 +192,7 @@ async function verifyPrivyOtp(privyConfig, email, code) {
             "privy-client-id": privyConfig.privyClientId,
         },
         body: JSON.stringify({ email, code, mode: "login-or-sign-up" }),
-    });
+    }));
     if (!res.ok) {
         if (INVALID_CODE_STATUSES.includes(res.status)) {
             throw new Error("INVALID_CODE");
@@ -131,30 +204,49 @@ async function verifyPrivyOtp(privyConfig, email, code) {
     }
     return (await res.json());
 }
+/**
+ * Parse a login-gated response. The body is read as text first so a gateway
+ * HTML error page becomes a `TransientHttpError` instead of a `SyntaxError`
+ * from `res.json()`. Every 5xx is transient (callers that opted into the
+ * retry replay it; others just report it); a 4xx keeps the API's message.
+ */
+export async function readGatedResponse(res, label) {
+    const text = await res.text();
+    let body;
+    try {
+        body = JSON.parse(text);
+    }
+    catch {
+        body = undefined;
+    }
+    const isJsonObject = !!body && typeof body === "object";
+    const { message, error } = (isJsonObject ? body : {});
+    const apiMessage = (typeof message === "string" && message) ||
+        (typeof error === "string" && error) ||
+        undefined;
+    if (!res.ok) {
+        if (res.status >= 500)
+            throw new TransientHttpError(res.status, apiMessage);
+        throw (mfaStepUpErrorFrom(body) ??
+            new Error(apiMessage ?? `${label} (${res.status})`));
+    }
+    if (!isJsonObject)
+        throw new Error(`${label}: unexpected response`);
+    return body;
+}
 async function callGenerateWallet(apiUrl, tokens) {
     const res = await fetch(`${apiUrl}/cli/generate-wallet`, {
         method: "POST",
         headers: authHeaders(tokens),
     });
-    const body = (await res.json());
-    if (!res.ok) {
-        throw (mfaStepUpErrorFrom(body) ??
-            new Error(body.message ||
-                body.error ||
-                `Wallet generation failed (${res.status})`));
-    }
-    return body;
+    return readGatedResponse(res, "Wallet generation failed");
 }
 async function callAcceptTerms(apiUrl, tokens) {
     const res = await fetch(`${apiUrl}/user/accept-terms`, {
         method: "POST",
         headers: authHeaders(tokens),
     });
-    if (!res.ok) {
-        const body = (await res.json().catch(() => ({})));
-        throw (mfaStepUpErrorFrom(body) ??
-            new Error(body.message || body.error || `Accept terms failed (${res.status})`));
-    }
+    await readGatedResponse(res, "Accept terms failed");
 }
 async function callGenerateApiKey(apiUrl, tokens, opts) {
     const res = await fetch(`${apiUrl}/api-keys`, {
@@ -162,14 +254,9 @@ async function callGenerateApiKey(apiUrl, tokens, opts) {
         headers: authHeaders(tokens),
         body: JSON.stringify(opts),
     });
-    const body = (await res.json());
-    if (!res.ok) {
-        throw (mfaStepUpErrorFrom(body) ??
-            new Error(body.message ||
-                body.error ||
-                `API key generation failed (${res.status})`));
-    }
-    return body;
+    // Parsed through the same seam so a gateway page reports cleanly; the mint
+    // itself is still never retried (see runGatedStep).
+    return readGatedResponse(res, "API key generation failed");
 }
 // ── Out-of-band MFA approval ─────────────────────────────────────────
 // Mirrors `MFA_CHALLENGE_STATUSES` in @bankr/shared (the CLI can't import it).
@@ -370,13 +457,18 @@ async function authenticateWithEmail(apiUrl, providedEmail, providedCode) {
 /**
  * Run a login-gated call; on the MFA step-up envelope, take the browser
  * approval hop once and retry. A second refusal, or an approval that expires
- * or fails, exits with the browser-key guidance.
+ * or fails, exits with the browser-key guidance. Network blips are retried
+ * only where the caller opts in, so a step is never replayed by default: a key
+ * mint whose response was dropped has already consumed its unique name.
  */
-async function runGatedStep(apiUrl, tokens, label, run) {
+async function runGatedStep(apiUrl, tokens, label, run, opts = {}) {
+    const { retryOnNetworkBlip = false } = opts;
     for (const retry of [false, true]) {
         const spin = output.spinner(label);
         try {
-            const result = await run();
+            const result = retryOnNetworkBlip
+                ? await withNetworkRetry(run)
+                : await run();
             spin.stop();
             return result;
         }
@@ -416,8 +508,9 @@ function exitWithApiKeyGuidance(apiUrl) {
 async function emailLoginFlow(apiUrl, opts) {
     // Step 1: Authenticate via email OTP
     const { tokens } = await authenticateWithEmail(apiUrl, opts.email, opts.code);
-    // Step 2: Generate/resolve wallet
-    const wallet = await runGatedStep(apiUrl, tokens, "Setting up wallet...", () => callGenerateWallet(apiUrl, tokens));
+    // Step 2: Resolve (or create) the wallet. The label stays neutral because
+    // whether the user is new only comes back in the response.
+    const wallet = await runGatedStep(apiUrl, tokens, "Loading wallet...", () => callGenerateWallet(apiUrl, tokens), { retryOnNetworkBlip: true });
     // Show wallet info
     output.blank();
     if (wallet.isNewUser) {
@@ -437,23 +530,21 @@ async function emailLoginFlow(apiUrl, opts) {
         output.blank();
         output.dim("  Please review our Terms of Service: https://bankr.bot/terms");
         output.blank();
-        const accepted = opts.acceptTerms ??
-            (headless
-                ? false
-                : await confirm({
-                    message: "Do you accept the Terms of Service?",
-                    default: false,
-                    theme: output.bankrTheme,
-                }));
+        const accepted = resolveTermsAcceptance({ headless, acceptTerms: opts.acceptTerms }) ??
+            (await confirm({
+                message: "Do you accept the Terms of Service?",
+                default: false,
+                theme: output.bankrTheme,
+            }));
         if (!accepted) {
             output.fatal("Terms must be accepted to continue.");
         }
-        await runGatedStep(apiUrl, tokens, "Accepting terms...", () => callAcceptTerms(apiUrl, tokens));
+        await runGatedStep(apiUrl, tokens, "Accepting terms...", () => callAcceptTerms(apiUrl, tokens), { retryOnNetworkBlip: true });
         output.success("Terms accepted");
     }
     // Step 4: Generate API key
     output.blank();
-    const defaultKeyName = `CLI-${new Date().toISOString().slice(0, 10)}`;
+    const defaultKeyName = defaultCliKeyName();
     const keyName = opts.keyName ??
         (headless
             ? defaultKeyName

package/dist/commands/{profile.d.ts → project.d.ts}

@@ -1,7 +1,7 @@
-export declare function profileViewCommand(opts: {
+export declare function projectViewCommand(opts: {
     json?: boolean;
 }): Promise<void>;
-export declare function profileCreateCommand(opts: {
+export declare function projectCreateCommand(opts: {
     name?: string;
     description?: string;
     token?: string;
@@ -9,7 +9,7 @@ export declare function profileCreateCommand(opts: {
     website?: string;
     json?: boolean;
 }): Promise<void>;
-export declare function profileUpdateCommand(opts: {
+export declare function projectUpdateCommand(opts: {
     slug?: string;
     name?: string;
     description?: string;
@@ -18,13 +18,13 @@ export declare function profileUpdateCommand(opts: {
     website?: string;
     json?: boolean;
 }): Promise<void>;
-export declare function profileDeleteCommand(opts: {
+export declare function projectDeleteCommand(opts: {
     slug?: string;
 }): Promise<void>;
-export declare function profileAddUpdateCommand(opts: {
+export declare function projectAddUpdateCommand(opts: {
     slug?: string;
     title?: string;
     content?: string;
     json?: boolean;
 }): Promise<void>;
-//# sourceMappingURL=profile.d.ts.map
+//# sourceMappingURL=project.d.ts.map