@bankr/cli 0.1.3 → 0.2.0

package/dist/commands/update.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import * as output from "../lib/output.js";
+const PACKAGE_NAME = "@bankr/cli";
+/**
+ * Compare two semver version strings.
+ * Returns -1 if a < b, 0 if equal, 1 if a > b.
+ */
+function compareSemver(a, b) {
+    const partsA = a.split(".").map(Number);
+    const partsB = b.split(".").map(Number);
+    for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
+        const numA = partsA[i] ?? 0;
+        const numB = partsB[i] ?? 0;
+        if (numA < numB)
+            return -1;
+        if (numA > numB)
+            return 1;
+    }
+    return 0;
+}
+async function fetchLatestVersion() {
+    const res = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok) {
+        throw new Error(`Failed to check for updates (HTTP ${res.status})`);
+    }
+    const data = (await res.json());
+    return data.version;
+}
+function getCurrentVersion() {
+    const pkg = JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8"));
+    return pkg.version;
+}
+/**
+ * Detect which package manager installed the CLI globally.
+ * Falls back to npm if we can't determine.
+ */
+function detectPackageManager() {
+    try {
+        const execPath = process.argv[1] ?? "";
+        // Check if running under bun
+        if (execPath.includes("/.bun/") || "bun" in process.versions) {
+            return "bun";
+        }
+        // Check if running under pnpm
+        if (execPath.includes("/pnpm/") || execPath.includes("/.pnpm/")) {
+            return "pnpm";
+        }
+        // Check if running under yarn
+        if (execPath.includes("/yarn/") || execPath.includes("/.yarn/")) {
+            return "yarn";
+        }
+    }
+    catch {
+        // ignore detection errors
+    }
+    return "npm";
+}
+function getInstallCommand(pm) {
+    switch (pm) {
+        case "bun":
+            return `bun install -g ${PACKAGE_NAME}@latest`;
+        case "pnpm":
+            return `pnpm add -g ${PACKAGE_NAME}@latest`;
+        case "yarn":
+            return `yarn global add ${PACKAGE_NAME}@latest`;
+        default:
+            return `npm install -g ${PACKAGE_NAME}@latest`;
+    }
+}
+export async function updateCommand(opts) {
+    const current = getCurrentVersion();
+    const spin = output.spinner("Checking for updates...");
+    let latest;
+    try {
+        latest = await fetchLatestVersion();
+    }
+    catch (err) {
+        spin.fail();
+        output.error(err.message);
+        process.exit(1);
+    }
+    const cmp = compareSemver(current, latest);
+    if (cmp === 0) {
+        spin.succeed(`Already on the latest version (${current})`);
+        return;
+    }
+    if (cmp > 0) {
+        spin.succeed(`You're ahead of latest (${current} > ${latest}). No update needed.`);
+        return;
+    }
+    spin.succeed(`Update available: ${current} → ${latest}`);
+    if (opts.check) {
+        return;
+    }
+    const pm = detectPackageManager();
+    const cmd = getInstallCommand(pm);
+    output.blank();
+    output.info(`Updating via ${pm}...`);
+    output.dim(`  $ ${cmd}`);
+    output.blank();
+    try {
+        execSync(cmd, { stdio: "inherit" });
+        output.blank();
+        output.success(`Updated to ${PACKAGE_NAME}@${latest}`);
+    }
+    catch {
+        output.blank();
+        output.error("Update failed. Try running manually:");
+        output.dim(`  $ ${cmd}`);
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/lib/api.d.ts

@@ -61,7 +61,29 @@ export interface TokenBalanceInfo {
             imgUrl: string;
             decimals: number;
         };
+        pnl?: {
+            realizedPnl: number;
+            unrealizedPnl: number;
+            totalPnl: number;
+            averageEntryPrice: number;
+        };
+    };
+}
+export interface NftInfo {
+    name?: string;
+    tokenId: string;
+    collection?: {
+        name: string;
+        address: string;
+        nftStandard?: string;
     };
+    chain: string;
+    chainName?: string;
+    image?: {
+        thumbnail?: string;
+        original?: string;
+    };
+    openSeaUrl?: string;
 }
 export interface ChainBalanceInfo {
     nativeBalance: string;
@@ -69,13 +91,23 @@ export interface ChainBalanceInfo {
     tokenBalances: TokenBalanceInfo[];
     total: string;
 }
-export interface BalancesResponse {
+export interface PortfolioResponse {
     success: boolean;
     evmAddress: string;
     solAddress?: string;
     balances: Record<string, ChainBalanceInfo>;
+    nfts?: NftInfo[];
+}
+export interface PortfolioOptions {
+    chains?: string[];
+    showLowValueTokens?: boolean;
+    include?: string[];
 }
-export declare function getBalances(chains?: string[]): Promise<BalancesResponse>;
+export declare function getPortfolio(opts?: PortfolioOptions): Promise<PortfolioResponse>;
+/** @deprecated Use PortfolioResponse instead */
+export type BalancesResponse = PortfolioResponse;
+/** @deprecated Use getPortfolio instead */
+export declare const getBalances: (chains?: string[], showLowValueTokens?: boolean) => Promise<PortfolioResponse>;
 export declare function pollJob(jobId: string, opts?: {
     interval?: number;
     maxAttempts?: number;
@@ -324,5 +356,30 @@ export declare function addProjectUpdate(data: {
     title: string;
     content: string;
 }): Promise<AgentProfileResponse>;
+export interface TokenSearchResult {
+    address: string;
+    symbol: string;
+    name: string;
+    decimals: number;
+    logoURI?: string;
+    priceUsd?: number;
+}
+export interface TokenSearchResponse {
+    tokens: TokenSearchResult[];
+}
+export declare function searchTokens(query: string, chainId?: number): Promise<TokenSearchResponse>;
+export interface TransferRequest {
+    tokenAddress: string;
+    recipientAddress: string;
+    amount: string;
+    isNativeToken: boolean;
+    chain?: string;
+}
+export interface TransferResponse {
+    success: boolean;
+    txHash?: string;
+    error?: string;
+}
+export declare function transfer(request: TransferRequest): Promise<TransferResponse>;
 export declare function buildPublicClaimTxs(beneficiaryAddress: string, tokenAddresses: string[]): Promise<BuildClaimResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/lib/api.js

@@ -62,18 +62,25 @@ export async function validateApiKey() {
     }
 }
 export async function getUserInfo() {
-    const res = await fetch(`${getApiUrl()}/agent/me`, {
+    const res = await fetch(`${getApiUrl()}/wallet/me`, {
         headers: authHeaders(),
     });
     return handleResponse(res);
 }
-export async function getBalances(chains) {
-    const params = chains?.length ? `?chains=${chains.join(",")}` : "";
-    const res = await fetch(`${getApiUrl()}/agent/balances${params}`, {
-        headers: authHeaders(),
-    });
+export async function getPortfolio(opts = {}) {
+    const query = new URLSearchParams();
+    if (opts.chains?.length)
+        query.set("chains", opts.chains.join(","));
+    if (opts.showLowValueTokens)
+        query.set("showLowValueTokens", "true");
+    if (opts.include?.length)
+        query.set("include", opts.include.join(","));
+    const qs = query.toString();
+    const res = await fetch(`${getApiUrl()}/wallet/portfolio${qs ? `?${qs}` : ""}`, { headers: authHeaders() });
     return handleResponse(res);
 }
+/** @deprecated Use getPortfolio instead */
+export const getBalances = (chains, showLowValueTokens) => getPortfolio({ chains, showLowValueTokens });
 export async function pollJob(jobId, opts = {}) {
     const { interval = 2000, maxAttempts = 150, onStatus } = opts;
     let attempts = 0;
@@ -89,7 +96,7 @@ export async function pollJob(jobId, opts = {}) {
     throw new Error(`Polling timed out after ${maxAttempts} attempts`);
 }
 export async function sign(request) {
-    const res = await fetch(`${getApiUrl()}/agent/sign`, {
+    const res = await fetch(`${getApiUrl()}/wallet/sign`, {
         method: "POST",
         headers: authHeaders(),
         body: JSON.stringify(request),
@@ -97,7 +104,7 @@ export async function sign(request) {
     return handleResponse(res);
 }
 export async function submit(request) {
-    const res = await fetch(`${getApiUrl()}/agent/submit`, {
+    const res = await fetch(`${getApiUrl()}/wallet/submit`, {
         method: "POST",
         headers: authHeaders(),
         body: JSON.stringify(request),
@@ -254,6 +261,25 @@ export async function addProjectUpdate(data) {
     });
     return handleResponse(res);
 }
+export async function searchTokens(query, chainId) {
+    const params = new URLSearchParams({ query });
+    if (chainId)
+        params.set("chainId", String(chainId));
+    const res = await fetch(`${getApiUrl()}/tokens/search?${params}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+        },
+    });
+    return handleResponse(res);
+}
+export async function transfer(request) {
+    const res = await fetch(`${getApiUrl()}/wallet/transfer`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(request),
+    });
+    return handleResponse(res);
+}
 export async function buildPublicClaimTxs(beneficiaryAddress, tokenAddresses) {
     const res = await fetch(`${getApiUrl()}/public/doppler/build-claim`, {
         method: "POST",

package/dist/lib/chains.d.ts

@@ -0,0 +1,5 @@
+export declare const CHAIN_LABELS: Record<string, string>;
+export declare const VALID_CHAINS: Set<string>;
+export declare const CHAIN_IDS: Record<string, number>;
+export declare const NATIVE_SYMBOLS: Record<string, string>;
+//# sourceMappingURL=chains.d.ts.map

package/dist/lib/chains.js

@@ -0,0 +1,35 @@
+export const CHAIN_LABELS = {
+    base: "Base",
+    polygon: "Polygon",
+    mainnet: "Ethereum",
+    unichain: "Unichain",
+    worldchain: "World Chain",
+    arbitrum: "Arbitrum",
+    solana: "Solana",
+};
+export const VALID_CHAINS = new Set([
+    "base",
+    "polygon",
+    "mainnet",
+    "unichain",
+    "worldchain",
+    "arbitrum",
+    "solana",
+]);
+export const CHAIN_IDS = {
+    base: 8453,
+    mainnet: 1,
+    polygon: 137,
+    unichain: 130,
+    worldchain: 480,
+    arbitrum: 42161,
+};
+export const NATIVE_SYMBOLS = {
+    base: "ETH",
+    mainnet: "ETH",
+    unichain: "ETH",
+    worldchain: "ETH",
+    arbitrum: "ETH",
+    polygon: "POL",
+};
+//# sourceMappingURL=chains.js.map

package/dist/lib/output.d.ts

@@ -29,5 +29,7 @@ export declare function keyValue(key: string, value: string): void;
 export declare function spinner(text: string): Ora;
 export declare function maskApiKey(key: string): string;
 export declare function formatDuration(ms: number): string;
+export declare function formatUsd(value: string | number): string;
+export declare function formatBalance(value: string | number, decimals?: number): string;
 export declare function formatStatus(status: string): string;
 //# sourceMappingURL=output.d.ts.map

package/dist/lib/output.js

@@ -66,6 +66,23 @@ export function formatDuration(ms) {
         return `${ms}ms`;
     return `${(ms / 1000).toFixed(1)}s`;
 }
+export function formatUsd(value) {
+    const num = typeof value === "string" ? parseFloat(value) : value;
+    if (isNaN(num) || num === 0)
+        return chalk.dim("$0.00");
+    return `$${num.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`;
+}
+export function formatBalance(value, decimals = 6) {
+    const num = typeof value === "string" ? parseFloat(value) : value;
+    if (isNaN(num) || num === 0)
+        return "0";
+    if (num < 0.000001)
+        return "<0.000001";
+    return num.toLocaleString("en-US", {
+        minimumFractionDigits: 0,
+        maximumFractionDigits: decimals,
+    });
+}
 export function formatStatus(status) {
     switch (status) {
         case "completed":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bankr/cli",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Official CLI for the Bankr AI agent platform",
   "type": "module",
   "bin": {