@bankr/cli 0.1.0-beta.6 → 0.1.0

package/dist/lib/api.d.ts

@@ -48,6 +48,34 @@ export declare function getJobStatus(jobId: string): Promise<JobStatusResponse>;
 export declare function cancelJob(jobId: string): Promise<JobStatusResponse>;
 export declare function validateApiKey(): Promise<boolean>;
 export declare function getUserInfo(): Promise<UserInfoResponse>;
+export interface TokenBalanceInfo {
+    network: string;
+    token: {
+        balance: number;
+        balanceUSD: number;
+        baseToken: {
+            name: string;
+            address: string;
+            symbol: string;
+            price: number;
+            imgUrl: string;
+            decimals: number;
+        };
+    };
+}
+export interface ChainBalanceInfo {
+    nativeBalance: string;
+    nativeUsd: string;
+    tokenBalances: TokenBalanceInfo[];
+    total: string;
+}
+export interface BalancesResponse {
+    success: boolean;
+    evmAddress: string;
+    solAddress?: string;
+    balances: Record<string, ChainBalanceInfo>;
+}
+export declare function getBalances(chains?: string[]): Promise<BalancesResponse>;
 export declare function pollJob(jobId: string, opts?: {
     interval?: number;
     maxAttempts?: number;
@@ -112,4 +140,189 @@ export interface SubmitResponse {
     error?: string;
 }
 export declare function submit(request: SubmitRequest): Promise<SubmitResponse>;
+export type FeeRecipientType = "wallet" | "x" | "farcaster" | "ens";
+export interface DeployTokenRequest {
+    tokenName: string;
+    tokenSymbol?: string;
+    image?: string;
+    description?: string;
+    tweetUrl?: string;
+    websiteUrl?: string;
+    feeRecipient?: {
+        type: FeeRecipientType;
+        value: string;
+    };
+    simulateOnly?: boolean;
+}
+export interface DeployTokenResponse {
+    success: boolean;
+    tokenAddress: string;
+    poolId: string;
+    txHash?: string;
+    activityId: string;
+    chain: string;
+    simulated?: boolean;
+    feeDistribution: Record<string, {
+        address: string;
+        bps: number;
+    }>;
+    error?: string;
+}
+export declare function deployToken(request: DeployTokenRequest): Promise<DeployTokenResponse>;
+export interface CreatorFeesTokenResult {
+    tokenAddress: string;
+    name: string;
+    symbol: string;
+    poolId: string;
+    initializer?: string;
+    share: string;
+    token0Label: string;
+    token1Label: string;
+    claimable: {
+        token0: string;
+        token1: string;
+    };
+    claimed: {
+        token0: string;
+        token1: string;
+        count: number;
+    };
+    source?: "doppler" | "clanker";
+}
+export interface CreatorFeesResponse {
+    address: string;
+    chain: "base";
+    days: number;
+    tokens: CreatorFeesTokenResult[];
+    dailyEarnings: Array<{
+        date: string;
+        weth: string;
+    }>;
+    totals: {
+        claimableWeth: string;
+        claimedWeth: string;
+        claimCount: number;
+    };
+}
+export interface BeneficiaryFeesResponse {
+    address: string;
+    chain: "base";
+    totalLaunches: number;
+    poolsWithShares: number;
+    tokens: CreatorFeesTokenResult[];
+}
+export interface DopplerClaimTxResponse {
+    to: string;
+    data: string;
+    chainId: number;
+    description: string;
+}
+/**
+ * Fetch creator fee data for a wallet address. Unauthenticated — calls
+ * the public endpoint directly.
+ */
+export declare function getCreatorFees(address: string, days?: number): Promise<CreatorFeesResponse>;
+/**
+ * Fetch fee data for a wallet address as ANY beneficiary role (creator,
+ * protocol, platform, etc.). Processes ALL launches server-side in one
+ * request (mirrors the internal claim-doppler-fees script).
+ * Unauthenticated — calls the public endpoint.
+ */
+export declare function getBeneficiaryFees(address: string): Promise<BeneficiaryFeesResponse>;
+export interface StreamProgress {
+    phase: string;
+    scanned: number;
+    total: number;
+    found?: number;
+}
+/**
+ * Fetch beneficiary fees with NDJSON streaming. The server sends progress
+ * lines during processing and a final result line. The onProgress callback
+ * is invoked for each progress update so the caller can update a spinner.
+ */
+export declare function getBeneficiaryFeesStreaming(address: string, onProgress: (progress: StreamProgress) => void): Promise<BeneficiaryFeesResponse>;
+/**
+ * Fetch creator fee data for a specific token address. Unauthenticated —
+ * looks up the token's creator beneficiary and returns their fee data.
+ */
+export declare function getTokenCreatorFees(tokenAddress: string, days?: number): Promise<CreatorFeesResponse>;
+/**
+ * Build a Doppler fee claim transaction. Requires authentication.
+ * The returned transaction data should be submitted via `submit()`.
+ */
+export declare function buildDopplerClaimTx(tokenAddress: string): Promise<DopplerClaimTxResponse>;
+export interface BuildClaimTx {
+    tokenAddress: string;
+    tokenName: string;
+    tokenSymbol: string;
+    to: string;
+    data: string;
+    chainId: number;
+    gasEstimate: string;
+    maxFeePerGas: string;
+    maxPriorityFeePerGas: string;
+    description: string;
+}
+export interface BuildClaimResponse {
+    transactions: BuildClaimTx[];
+    errors?: Array<{
+        tokenAddress: string;
+        error: string;
+    }>;
+}
+/**
+ * Build unsigned claim transactions for the given beneficiary and tokens.
+ * Unauthenticated -- calls the public endpoint. The CLI signs and
+ * broadcasts locally.
+ */
+export interface AgentProfileResponse {
+    id: string;
+    slug: string;
+    projectName: string;
+    description?: string;
+    profileImageUrl?: string;
+    tokenAddress?: string;
+    tokenChainId?: string;
+    tokenSymbol?: string;
+    tokenName?: string;
+    marketCapUsd?: number;
+    weeklyRevenueWeth?: string;
+    twitterUsername?: string;
+    website?: string;
+    teamMembers: Array<{
+        name: string;
+        role?: string;
+        links: Array<{
+            type: string;
+            url: string;
+        }>;
+    }>;
+    products: Array<{
+        name: string;
+        description?: string;
+        url?: string;
+    }>;
+    revenueSources: Array<{
+        name: string;
+        description?: string;
+    }>;
+    projectUpdates: Array<{
+        title: string;
+        content: string;
+        createdAt: string;
+    }>;
+    approved: boolean;
+    createdAt: string;
+}
+export declare function getOwnProfile(): Promise<AgentProfileResponse>;
+export declare function createProfile(data: Record<string, unknown>): Promise<AgentProfileResponse>;
+export declare function updateProfile(data: Record<string, unknown>): Promise<AgentProfileResponse>;
+export declare function deleteProfile(): Promise<{
+    success: boolean;
+}>;
+export declare function addProjectUpdate(data: {
+    title: string;
+    content: string;
+}): Promise<AgentProfileResponse>;
+export declare function buildPublicClaimTxs(beneficiaryAddress: string, tokenAddresses: string[]): Promise<BuildClaimResponse>;
 //# sourceMappingURL=api.d.ts.map

package/dist/lib/api.js

@@ -1,4 +1,4 @@
-import { getApiUrl, requireApiKey } from "./config.js";
+import { CLI_USER_AGENT, getApiUrl, readConfig, requireApiKey, } from "./config.js";
 const TERMINAL_STATUSES = [
     "completed",
     "failed",
@@ -8,10 +8,16 @@ function isTerminalStatus(status) {
     return TERMINAL_STATUSES.includes(status);
 }
 function authHeaders() {
-    return {
+    const headers = {
         "X-API-Key": requireApiKey(),
         "Content-Type": "application/json",
+        "User-Agent": CLI_USER_AGENT,
     };
+    const config = readConfig();
+    if (config.partnerKey) {
+        headers["X-Partner-Key"] = config.partnerKey;
+    }
+    return headers;
 }
 async function handleResponse(res) {
     if (!res.ok) {
@@ -47,7 +53,7 @@ export async function cancelJob(jobId) {
 export async function validateApiKey() {
     try {
         const res = await fetch(`${getApiUrl()}/_health`, {
-            headers: { "X-API-Key": requireApiKey() },
+            headers: { "X-API-Key": requireApiKey(), "User-Agent": CLI_USER_AGENT },
         });
         return res.ok;
     }
@@ -61,6 +67,13 @@ export async function getUserInfo() {
     });
     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(),
+    });
+    return handleResponse(res);
+}
 export async function pollJob(jobId, opts = {}) {
     const { interval = 2000, maxAttempts = 150, onStatus } = opts;
     let attempts = 0;
@@ -91,4 +104,165 @@ export async function submit(request) {
     });
     return handleResponse(res);
 }
+export async function deployToken(request) {
+    const res = await fetch(`${getApiUrl()}/token-launches/deploy`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(request),
+    });
+    return handleResponse(res);
+}
+/**
+ * Fetch creator fee data for a wallet address. Unauthenticated — calls
+ * the public endpoint directly.
+ */
+export async function getCreatorFees(address, days) {
+    const params = days ? `?days=${days}` : "";
+    const res = await fetch(`${getApiUrl()}/public/doppler/creator-fees/${address}${params}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+        },
+    });
+    return handleResponse(res);
+}
+/**
+ * Fetch fee data for a wallet address as ANY beneficiary role (creator,
+ * protocol, platform, etc.). Processes ALL launches server-side in one
+ * request (mirrors the internal claim-doppler-fees script).
+ * Unauthenticated — calls the public endpoint.
+ */
+export async function getBeneficiaryFees(address) {
+    const res = await fetch(`${getApiUrl()}/public/doppler/beneficiary-fees/${address}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+        },
+    });
+    return handleResponse(res);
+}
+/**
+ * Fetch beneficiary fees with NDJSON streaming. The server sends progress
+ * lines during processing and a final result line. The onProgress callback
+ * is invoked for each progress update so the caller can update a spinner.
+ */
+export async function getBeneficiaryFeesStreaming(address, onProgress) {
+    const res = await fetch(`${getApiUrl()}/public/doppler/beneficiary-fees/${address}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+            Accept: "application/x-ndjson",
+        },
+    });
+    if (!res.ok) {
+        const body = (await res
+            .json()
+            .catch(() => ({ message: res.statusText })));
+        const msg = body.message || body.error || res.statusText;
+        throw new Error(`API error (${res.status}): ${msg}`);
+    }
+    if (!res.body) {
+        throw new Error("No response body");
+    }
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let result = null;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            const msg = JSON.parse(line);
+            if (msg.type === "progress") {
+                onProgress(msg);
+            }
+            else if (msg.type === "result") {
+                result = msg.data;
+            }
+            else if (msg.type === "error") {
+                throw new Error(msg.message || "Server error during streaming");
+            }
+        }
+    }
+    if (!result) {
+        throw new Error("No result received from server");
+    }
+    return result;
+}
+/**
+ * Fetch creator fee data for a specific token address. Unauthenticated —
+ * looks up the token's creator beneficiary and returns their fee data.
+ */
+export async function getTokenCreatorFees(tokenAddress, days) {
+    const params = days ? `?days=${days}` : "";
+    const res = await fetch(`${getApiUrl()}/public/doppler/token-fees/${tokenAddress}${params}`, {
+        headers: {
+            "User-Agent": CLI_USER_AGENT,
+        },
+    });
+    return handleResponse(res);
+}
+/**
+ * Build a Doppler fee claim transaction. Requires authentication.
+ * The returned transaction data should be submitted via `submit()`.
+ */
+export async function buildDopplerClaimTx(tokenAddress) {
+    const res = await fetch(`${getApiUrl()}/agent/doppler/claim`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify({ tokenAddress }),
+    });
+    return handleResponse(res);
+}
+export async function getOwnProfile() {
+    const res = await fetch(`${getApiUrl()}/agent/profile`, {
+        headers: authHeaders(),
+    });
+    return handleResponse(res);
+}
+export async function createProfile(data) {
+    const res = await fetch(`${getApiUrl()}/agent/profile`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(data),
+    });
+    return handleResponse(res);
+}
+export async function updateProfile(data) {
+    const res = await fetch(`${getApiUrl()}/agent/profile`, {
+        method: "PUT",
+        headers: authHeaders(),
+        body: JSON.stringify(data),
+    });
+    return handleResponse(res);
+}
+export async function deleteProfile() {
+    const res = await fetch(`${getApiUrl()}/agent/profile`, {
+        method: "DELETE",
+        headers: authHeaders(),
+    });
+    return handleResponse(res);
+}
+export async function addProjectUpdate(data) {
+    const res = await fetch(`${getApiUrl()}/agent/profile/update`, {
+        method: "POST",
+        headers: authHeaders(),
+        body: JSON.stringify(data),
+    });
+    return handleResponse(res);
+}
+export async function buildPublicClaimTxs(beneficiaryAddress, tokenAddresses) {
+    const res = await fetch(`${getApiUrl()}/public/doppler/build-claim`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            "User-Agent": CLI_USER_AGENT,
+        },
+        body: JSON.stringify({ beneficiaryAddress, tokenAddresses }),
+    });
+    return handleResponse(res);
+}
 //# sourceMappingURL=api.js.map

package/dist/lib/cesp/engine.d.ts

@@ -0,0 +1,13 @@
+import type { InstalledPack, SoundConfig } from "./types.js";
+/** Default sound config values (off by default). */
+export declare const DEFAULT_SOUND_CONFIG: SoundConfig;
+/**
+ * Fire a CESP sound event. Call from any command at the relevant lifecycle
+ * moment. Fire-and-forget: never throws, never blocks.
+ */
+export declare function emitCESP(category: string): void;
+/** List all installed packs by scanning the packs directory. */
+export declare function listInstalledPacks(): InstalledPack[];
+/** Get the directory where packs are stored. */
+export declare function getPacksDir(): string;
+//# sourceMappingURL=engine.d.ts.map

package/dist/lib/cesp/engine.js

@@ -0,0 +1,132 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readConfig } from "../config.js";
+import { playSound } from "./player.js";
+const DEBOUNCE_MS = 500;
+const PACKS_DIR = join(homedir(), ".bankr", "sounds");
+/** In-memory state for the lifetime of the CLI process. */
+const state = {
+    lastPlayed: new Map(),
+    lastTimestamp: new Map(),
+};
+/** Default sound config values (off by default). */
+export const DEFAULT_SOUND_CONFIG = {
+    enabled: false,
+    volume: 0.7,
+    muted: false,
+};
+/**
+ * Fire a CESP sound event. Call from any command at the relevant lifecycle
+ * moment. Fire-and-forget: never throws, never blocks.
+ */
+export function emitCESP(category) {
+    try {
+        const config = readConfig();
+        const sound = config.sound ?? DEFAULT_SOUND_CONFIG;
+        if (!sound.enabled || sound.muted || !sound.activePack)
+            return;
+        if (sound.disabledCategories?.includes(category))
+            return;
+        const pack = loadPack(sound.activePack);
+        if (!pack)
+            return;
+        // Debounce: skip if same category fired within threshold
+        const now = Date.now();
+        const lastTime = state.lastTimestamp.get(category) ?? 0;
+        if (now - lastTime < DEBOUNCE_MS)
+            return;
+        // Resolve category (direct match, then alias fallback)
+        const resolved = resolveCategory(pack.manifest, category);
+        if (!resolved)
+            return;
+        const cat = pack.manifest.categories[resolved];
+        if (!cat?.sounds?.length)
+            return;
+        const files = cat.sounds.map((s) => s.file);
+        const picked = pickSound(category, files);
+        if (!picked)
+            return;
+        // Update runtime state
+        state.lastPlayed.set(category, picked);
+        state.lastTimestamp.set(category, now);
+        // Resolve file path relative to manifest directory
+        const filePath = resolveFilePath(pack.path, picked);
+        if (existsSync(filePath)) {
+            playSound(filePath, sound.volume);
+        }
+    }
+    catch {
+        // Sound must never crash the CLI
+    }
+}
+/** Resolve a CESP category, falling back through aliases. */
+function resolveCategory(manifest, category) {
+    if (manifest.categories[category])
+        return category;
+    const alias = manifest.category_aliases?.[category];
+    if (alias && manifest.categories[alias])
+        return alias;
+    return undefined;
+}
+/** Pick a random sound, excluding the last-played file for the category. */
+function pickSound(category, files) {
+    if (files.length === 0)
+        return undefined;
+    if (files.length === 1)
+        return files[0];
+    const last = state.lastPlayed.get(category);
+    const eligible = files.filter((f) => f !== last);
+    const candidates = eligible.length > 0 ? eligible : files;
+    return candidates[Math.floor(Math.random() * candidates.length)];
+}
+/** Resolve a manifest file path. Paths without slashes get sounds/ prefix. */
+function resolveFilePath(packDir, filePath) {
+    // If the path has no directory component, prefix with sounds/
+    if (!filePath.includes("/")) {
+        return join(packDir, "sounds", filePath);
+    }
+    return join(packDir, filePath);
+}
+// -- Pack discovery --
+const packCache = new Map();
+function loadPack(name) {
+    if (packCache.has(name))
+        return packCache.get(name);
+    const packDir = join(PACKS_DIR, name);
+    const manifestPath = join(packDir, "openpeon.json");
+    if (!existsSync(manifestPath)) {
+        packCache.set(name, null);
+        return null;
+    }
+    try {
+        const raw = readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(raw);
+        const pack = { name, path: packDir, manifest };
+        packCache.set(name, pack);
+        return pack;
+    }
+    catch {
+        packCache.set(name, null);
+        return null;
+    }
+}
+/** List all installed packs by scanning the packs directory. */
+export function listInstalledPacks() {
+    if (!existsSync(PACKS_DIR))
+        return [];
+    const packs = [];
+    for (const entry of readdirSync(PACKS_DIR, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const pack = loadPack(entry.name);
+        if (pack)
+            packs.push(pack);
+    }
+    return packs;
+}
+/** Get the directory where packs are stored. */
+export function getPacksDir() {
+    return PACKS_DIR;
+}
+//# sourceMappingURL=engine.js.map

package/dist/lib/cesp/player.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Play a sound file asynchronously. Never throws, never blocks the CLI.
+ * Spawns a detached child process so the sound continues even if Node exits.
+ */
+export declare function playSound(filePath: string, volume: number): void;
+//# sourceMappingURL=player.d.ts.map

package/dist/lib/cesp/player.js

@@ -0,0 +1,50 @@
+import { execFile } from "node:child_process";
+import { platform } from "node:os";
+/**
+ * Play a sound file asynchronously. Never throws, never blocks the CLI.
+ * Spawns a detached child process so the sound continues even if Node exits.
+ */
+export function playSound(filePath, volume) {
+    const os = platform();
+    try {
+        if (os === "darwin") {
+            // afplay volume: 0 = silent, 1 = normal, higher = amplified
+            const vol = Math.max(0, Math.min(volume, 2)).toString();
+            execFile("afplay", ["-v", vol, filePath], { timeout: 15000 }, noop);
+        }
+        else if (os === "linux") {
+            playLinux(filePath, volume);
+        }
+        else if (os === "win32") {
+            const script = [
+                "$p = New-Object System.Media.SoundPlayer",
+                `$p.SoundLocation = '${filePath.replace(/'/g, "''")}'`,
+                "$p.PlaySync()",
+            ].join("; ");
+            execFile("powershell", ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 15000 }, noop);
+        }
+        // Unsupported platforms: silent no-op
+    }
+    catch {
+        // Audio failure must never crash the CLI
+    }
+}
+function playLinux(filePath, volume) {
+    // PipeWire volume scale: cubic, 1.0 = 100%
+    const pwVol = Math.max(0, Math.min(volume, 1)).toFixed(2);
+    execFile("pw-play", ["--volume", pwVol, filePath], (err) => {
+        if (!err)
+            return;
+        // PulseAudio volume: 0-65536 where 65536 = 100%
+        const paVol = Math.round(volume * 65536).toString();
+        execFile("paplay", ["--volume", paVol, filePath], (err2) => {
+            if (!err2)
+                return;
+            // ALSA fallback (no volume control)
+            execFile("aplay", ["-q", filePath], noop);
+        });
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-empty-function
+function noop() { }
+//# sourceMappingURL=player.js.map

package/dist/lib/cesp/types.d.ts

@@ -0,0 +1,38 @@
+/** A single sound entry in a CESP manifest category. */
+export interface CESPSound {
+    file: string;
+    label?: string;
+}
+/** A category entry containing one or more sound variants. */
+export interface CESPCategory {
+    sounds: CESPSound[];
+}
+/** openpeon.json manifest (CESP v1.0). */
+export interface CESPManifest {
+    cesp_version: string;
+    name: string;
+    display_name?: string;
+    version: string;
+    categories: Record<string, CESPCategory>;
+    category_aliases?: Record<string, string>;
+}
+/** Metadata for an installed sound pack. */
+export interface InstalledPack {
+    name: string;
+    path: string;
+    manifest: CESPManifest;
+}
+/** Persisted sound configuration (stored in BankrConfig.sound). */
+export interface SoundConfig {
+    enabled: boolean;
+    volume: number;
+    muted: boolean;
+    activePack?: string;
+    disabledCategories?: string[];
+}
+/** In-memory runtime state (not persisted). */
+export interface CESPState {
+    lastPlayed: Map<string, string>;
+    lastTimestamp: Map<string, number>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/cesp/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/lib/config.d.ts

@@ -1,14 +1,18 @@
+import type { SoundConfig } from "./cesp/types.js";
 export interface BankrConfig {
     apiKey?: string;
     apiUrl?: string;
     llmKey?: string;
     llmUrl?: string;
     lastThreadId?: string;
+    partnerKey?: string;
+    sound?: SoundConfig;
 }
 export declare function setConfigPath(path: string): void;
 export declare function getConfigPath(): string;
 export declare const DEFAULT_API_URL = "https://api.bankr.bot";
 export declare const DEFAULT_LLM_URL = "https://llm.bankr.bot";
+export declare const CLI_USER_AGENT = "bankr-cli/0.1";
 export declare function readConfig(): BankrConfig;
 export declare function writeConfig(config: BankrConfig): void;
 export declare function clearConfig(): void;