@bankr/cli 0.1.0-beta.9 → 0.1.3

package/dist/commands/sounds.js

@@ -0,0 +1,262 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { tmpdir } from "node:os";
+import { readConfig, writeConfig } from "../lib/config.js";
+import { DEFAULT_SOUND_CONFIG, emitCESP, getPacksDir, listInstalledPacks, } from "../lib/cesp/engine.js";
+import * as output from "../lib/output.js";
+const execFileAsync = promisify(execFile);
+const REGISTRY_URL = "https://peonping.github.io/registry/index.json";
+function getSoundConfig() {
+    return readConfig().sound ?? { ...DEFAULT_SOUND_CONFIG };
+}
+function saveSoundConfig(sound) {
+    const config = readConfig();
+    config.sound = sound;
+    writeConfig(config);
+}
+export async function soundsStatusCommand() {
+    const sound = getSoundConfig();
+    output.brandBold("  Sound Configuration");
+    console.log();
+    output.keyValue("Enabled", sound.enabled ? "yes" : "no");
+    output.keyValue("Muted", sound.muted ? "yes" : "no");
+    output.keyValue("Volume", `${Math.round(sound.volume * 100)}%`);
+    output.keyValue("Active Pack", sound.activePack ?? "(none)");
+    if (sound.disabledCategories?.length) {
+        output.keyValue("Disabled Categories", sound.disabledCategories.join(", "));
+    }
+    console.log();
+    const packs = listInstalledPacks();
+    if (packs.length === 0) {
+        output.dim(`  No sound packs installed. Add packs to ${getPacksDir()}`);
+    }
+    else {
+        output.dim(`  ${packs.length} pack(s) installed. Run: bankr sounds list`);
+    }
+}
+export async function soundsEnableCommand() {
+    const sound = getSoundConfig();
+    sound.enabled = true;
+    saveSoundConfig(sound);
+    output.success("Sounds enabled");
+}
+export async function soundsDisableCommand() {
+    const sound = getSoundConfig();
+    sound.enabled = false;
+    saveSoundConfig(sound);
+    output.success("Sounds disabled");
+}
+export async function soundsListCommand() {
+    const packs = listInstalledPacks();
+    const sound = getSoundConfig();
+    if (packs.length === 0) {
+        output.dim("No sound packs installed.");
+        output.dim(`Install packs to ${getPacksDir()}`);
+        return;
+    }
+    output.brandBold("  Installed Sound Packs");
+    console.log();
+    for (const pack of packs) {
+        const active = pack.name === sound.activePack ? " (active)" : "";
+        const cats = Object.keys(pack.manifest.categories).length;
+        const totalSounds = Object.values(pack.manifest.categories).reduce((sum, c) => sum + (c.sounds?.length ?? 0), 0);
+        console.log(`  ${output.fmt.brand(pack.name)}${active ? output.fmt.brand(active) : ""}`);
+        output.dim(`    ${cats} categories, ${totalSounds} sounds`);
+    }
+}
+export async function soundsUseCommand(packName) {
+    const packs = listInstalledPacks();
+    const match = packs.find((p) => p.name === packName);
+    if (!match) {
+        output.error(`Pack "${packName}" not found. Run: bankr sounds list`);
+        process.exit(1);
+    }
+    const sound = getSoundConfig();
+    sound.activePack = packName;
+    saveSoundConfig(sound);
+    output.success(`Active sound pack: ${match.manifest.display_name ?? packName}`);
+}
+export async function soundsVolumeCommand(level) {
+    const sound = getSoundConfig();
+    if (!level) {
+        output.label("Volume", `${Math.round(sound.volume * 100)}%`);
+        return;
+    }
+    const vol = parseFloat(level);
+    if (isNaN(vol) || vol < 0 || vol > 1) {
+        output.error("Volume must be a number between 0.0 and 1.0");
+        process.exit(1);
+    }
+    sound.volume = vol;
+    saveSoundConfig(sound);
+    output.success(`Volume set to ${Math.round(vol * 100)}%`);
+}
+export async function soundsMuteCommand() {
+    const sound = getSoundConfig();
+    sound.muted = true;
+    saveSoundConfig(sound);
+    output.success("Sounds muted");
+}
+export async function soundsUnmuteCommand() {
+    const sound = getSoundConfig();
+    sound.muted = false;
+    saveSoundConfig(sound);
+    output.success("Sounds unmuted");
+}
+export async function soundsTestCommand(category) {
+    const sound = getSoundConfig();
+    if (!sound.activePack) {
+        output.error("No active sound pack. Run: bankr sounds use <pack>");
+        process.exit(1);
+    }
+    const cat = category ?? "task.complete";
+    output.dim(`Playing "${cat}" from ${sound.activePack}...`);
+    // Temporarily force enabled + unmuted for the test
+    const prev = { enabled: sound.enabled, muted: sound.muted };
+    sound.enabled = true;
+    sound.muted = false;
+    saveSoundConfig(sound);
+    emitCESP(cat);
+    // Restore previous state
+    sound.enabled = prev.enabled;
+    sound.muted = prev.muted;
+    saveSoundConfig(sound);
+}
+// -- Registry helpers --
+async function fetchRegistry() {
+    const res = await fetch(REGISTRY_URL);
+    if (!res.ok) {
+        throw new Error(`Failed to fetch registry: ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    return Array.isArray(body) ? body : body.packs;
+}
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(0)}KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+// -- Install command --
+export async function soundsInstallCommand(packName) {
+    const packsDir = getPacksDir();
+    const destDir = join(packsDir, packName);
+    // Check if already installed
+    if (existsSync(join(destDir, "openpeon.json"))) {
+        output.warn(`Pack "${packName}" is already installed at ${destDir}`);
+        return;
+    }
+    const spin = output.spinner(`Looking up "${packName}" in CESP registry...`);
+    let entry;
+    try {
+        const registry = await fetchRegistry();
+        const match = registry.find((e) => e.name.toLowerCase() === packName.toLowerCase());
+        if (!match) {
+            spin.fail(`Pack "${packName}" not found in registry`);
+            output.dim("Run: bankr sounds search <query> to browse available packs");
+            process.exit(1);
+        }
+        entry = match;
+        spin.succeed(`Found ${entry.display_name} (${entry.sound_count} sounds, ${formatSize(entry.total_size_bytes)})`);
+    }
+    catch (err) {
+        spin.fail("Failed to fetch registry");
+        output.error(err.message);
+        process.exit(1);
+    }
+    // Download and extract
+    const tarballUrl = `https://github.com/${entry.source_repo}/archive/refs/tags/${entry.source_ref}.tar.gz`;
+    const spin2 = output.spinner("Downloading and extracting...");
+    try {
+        const tmpDir = join(tmpdir(), `bankr-sound-${Date.now()}`);
+        mkdirSync(tmpDir, { recursive: true });
+        mkdirSync(packsDir, { recursive: true });
+        // Download tarball with curl and extract with tar
+        await execFileAsync("curl", ["-fsSL", "-o", join(tmpDir, "pack.tar.gz"), tarballUrl], { timeout: 30000 });
+        await execFileAsync("tar", ["xzf", join(tmpDir, "pack.tar.gz"), "-C", tmpDir], { timeout: 15000 });
+        // Find the extracted directory (name is <repo>-<ref>/<source_path>)
+        // The tarball extracts to <repo-name>-<tag>/ (e.g. og-packs-v1.0.0/)
+        const repoName = entry.source_repo.split("/")[1];
+        const refClean = entry.source_ref.replace(/^v/, "");
+        const extractedBase = join(tmpDir, `${repoName}-${refClean}`);
+        const sourcePath = join(extractedBase, entry.source_path);
+        if (!existsSync(join(sourcePath, "openpeon.json"))) {
+            // Try alternative naming (some tarballs keep the v prefix)
+            const altBase = join(tmpDir, `${repoName}-${entry.source_ref}`);
+            const altSource = join(altBase, entry.source_path);
+            if (!existsSync(join(altSource, "openpeon.json"))) {
+                spin2.fail("Pack manifest (openpeon.json) not found in archive");
+                process.exit(1);
+            }
+            // Copy from alt path
+            await execFileAsync("cp", ["-r", altSource, destDir]);
+        }
+        else {
+            await execFileAsync("cp", ["-r", sourcePath, destDir]);
+        }
+        // Cleanup temp dir
+        await execFileAsync("rm", ["-rf", tmpDir]).catch(() => { });
+        // Verify install
+        if (!existsSync(join(destDir, "openpeon.json"))) {
+            spin2.fail("Install failed: manifest not found after extraction");
+            process.exit(1);
+        }
+        spin2.succeed(`Installed "${entry.display_name}" to ${destDir}`);
+        // Auto-set as active pack if it's the first one
+        const sound = getSoundConfig();
+        if (!sound.activePack) {
+            sound.activePack = packName;
+            saveSoundConfig(sound);
+            output.dim(`Set as active pack. Run: bankr sounds enable`);
+        }
+        else {
+            output.dim(`Activate with: bankr sounds use ${packName}`);
+        }
+    }
+    catch (err) {
+        spin2.fail("Install failed");
+        output.error(err.message);
+        process.exit(1);
+    }
+}
+// -- Search command --
+export async function soundsSearchCommand(query) {
+    const spin = output.spinner("Fetching CESP registry...");
+    let registry;
+    try {
+        registry = await fetchRegistry();
+        spin.stop();
+    }
+    catch (err) {
+        spin.fail("Failed to fetch registry");
+        output.error(err.message);
+        process.exit(1);
+    }
+    // Filter by query if provided
+    let results = registry;
+    if (query) {
+        const q = query.toLowerCase();
+        results = registry.filter((e) => e.name.toLowerCase().includes(q) ||
+            e.display_name.toLowerCase().includes(q) ||
+            (e.description?.toLowerCase().includes(q) ?? false));
+    }
+    if (results.length === 0) {
+        output.dim(query ? `No packs matching "${query}"` : "No packs in registry");
+        return;
+    }
+    // Check which are already installed
+    const installed = new Set(listInstalledPacks().map((p) => p.name));
+    output.brandBold(`  ${results.length} sound pack(s) available`);
+    console.log();
+    for (const entry of results) {
+        const tag = installed.has(entry.name) ? " (installed)" : "";
+        console.log(`  ${output.fmt.brand(entry.name)}${tag ? output.fmt.dim(tag) : ""}  ${entry.display_name}`);
+        output.dim(`    ${entry.sound_count} sounds, ${formatSize(entry.total_size_bytes)}, ${entry.categories.length} categories`);
+    }
+    console.log();
+    output.dim("  Install with: bankr sounds install <name>");
+}
+//# sourceMappingURL=sounds.js.map

package/dist/commands/submit.js

@@ -1,13 +1,16 @@
 import { submit } from "../lib/api.js";
+import { emitCESP } from "../lib/cesp/engine.js";
 import * as output from "../lib/output.js";
 function displayResult(result) {
     if (!result.success) {
+        emitCESP("task.error");
         output.error(result.error || "Submission failed");
         if (result.transactionHash) {
             output.keyValue("Transaction Hash", result.transactionHash);
         }
         process.exit(1);
     }
+    emitCESP("task.complete");
     output.success("Transaction submitted");
     console.log();
     output.keyValue("Transaction Hash", result.transactionHash || "");
@@ -60,7 +63,9 @@ export async function submitCommand(opts) {
         waitForConfirmation: !opts.noWait,
     };
     // Execute submission with spinner
-    const spinner = output.spinner(opts.noWait ? "Submitting transaction..." : "Submitting and waiting for confirmation...");
+    const spinner = output.spinner(opts.noWait
+        ? "Submitting transaction..."
+        : "Submitting and waiting for confirmation...");
     try {
         const result = await submit(request);
         spinner.stop();
@@ -82,7 +87,9 @@ export async function submitJsonCommand(json, opts) {
         output.error("Invalid JSON. Expected: {to, chainId, value?, data?}");
         process.exit(1);
     }
-    if (!transaction || typeof transaction !== "object" || Array.isArray(transaction)) {
+    if (!transaction ||
+        typeof transaction !== "object" ||
+        Array.isArray(transaction)) {
         output.error("Invalid JSON. Expected object: {to, chainId, value?, data?}");
         process.exit(1);
     }
@@ -99,7 +106,8 @@ export async function submitJsonCommand(json, opts) {
         output.error("Transaction 'chainId' must be a number");
         process.exit(1);
     }
-    if (transaction.nonce !== undefined && (typeof transaction.nonce !== "number" || isNaN(transaction.nonce))) {
+    if (transaction.nonce !== undefined &&
+        (typeof transaction.nonce !== "number" || isNaN(transaction.nonce))) {
         output.error("Transaction 'nonce' must be a number");
         process.exit(1);
     }
@@ -109,7 +117,9 @@ export async function submitJsonCommand(json, opts) {
         waitForConfirmation: !opts.noWait,
     };
     // Execute submission with spinner
-    const spinner = output.spinner(opts.noWait ? "Submitting transaction..." : "Submitting and waiting for confirmation...");
+    const spinner = output.spinner(opts.noWait
+        ? "Submitting transaction..."
+        : "Submitting and waiting for confirmation...");
     try {
         const result = await submit(request);
         spinner.stop();

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { clearConfig, DEFAULT_API_URL, getApiKey, getApiUrl, readConfig, setConfigPath, writeConfig, } from "./lib/config.js";
 export type { BankrConfig } from "./lib/config.js";
-export { cancelJob, getJobStatus, getUserInfo, pollJob, submitPrompt, validateApiKey, } from "./lib/api.js";
-export type { JobStatusResponse, PromptResponse, UserInfoResponse, } from "./lib/api.js";
+export { cancelJob, getBalances, getJobStatus, getUserInfo, pollJob, submitPrompt, validateApiKey, } from "./lib/api.js";
+export type { BalancesResponse, ChainBalanceInfo, JobStatusResponse, PromptResponse, TokenBalanceInfo, UserInfoResponse, } from "./lib/api.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,3 +1,3 @@
 export { clearConfig, DEFAULT_API_URL, getApiKey, getApiUrl, readConfig, setConfigPath, writeConfig, } from "./lib/config.js";
-export { cancelJob, getJobStatus, getUserInfo, pollJob, submitPrompt, validateApiKey, } from "./lib/api.js";
+export { cancelJob, getBalances, getJobStatus, getUserInfo, pollJob, submitPrompt, validateApiKey, } from "./lib/api.js";
 //# sourceMappingURL=index.js.map

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