yappr 0.1.0

package/dist/config/skills/generate-meme/handler.d.ts

@@ -0,0 +1,2 @@
+import { type SkillHandler } from "yappr";
+export declare const handler: SkillHandler;

package/dist/config/skills/generate-meme/handler.js

@@ -0,0 +1,121 @@
+import { chat, payFetch, log } from "yappr";
+// generate-meme: turn a tweet into a funny, Crypto-Twitter-flavored meme. Two steps —
+// (1) ask the LLM to write a vivid, CT-aware image prompt from the tweet, then (2) render
+// it with BlockRun's gpt-image-1 over x402. Returns the image as `mediaUrl` so the reply
+// pipeline uploads and attaches it (the model just writes a caption). The render half
+// mirrors the generate-image skill; kept self-contained so either skill can be deleted.
+const ORIGIN = "https://blockrun.ai";
+const ENDPOINT = `${ORIGIN}/api/v1/images/generations`;
+const MODEL = "openai/gpt-image-1"; // $0.021 / image (1024x1024) — see generate-image for the full price list
+// gpt-image-1 only accepts these three sizes (1024x1024, 1536x1024, 1024x1536). Square default.
+const SIZES = {
+    square: "1024x1024",
+    landscape: "1536x1024",
+    portrait: "1024x1536",
+};
+const DEFAULT_SIZE = "square";
+function resolveSize(raw) {
+    const key = (raw ?? "").trim().toLowerCase();
+    if (key in SIZES)
+        return SIZES[key];
+    if (/^\d{3,4}x\d{3,4}$/.test(key))
+        return key;
+    return SIZES[DEFAULT_SIZE];
+}
+// Poll tuning — gpt-image-1 routinely exceeds the server's 30s inline window.
+const POST_TIMEOUT_MS = 60_000;
+const POLL_TIMEOUT_MS = 30_000;
+const POLL_INTERVAL_MS = 5_000;
+const POLL_MAX_ATTEMPTS = 24;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const imageUrl = (body) => body?.data?.[0]?.url;
+const GENERATED_NOTE = "Meme generated — it will be attached to your reply automatically. Write a short, funny caption that fits the meme described below. Do NOT paste any URL, link, or the prompt text itself.";
+// ── Step 1: craft a funny, CT-aware image prompt from the tweet subject ──
+const MEME_SYSTEM = `You are a Crypto Twitter (CT) meme director. Given the subject of a tweet, write ONE image-generation prompt for a single funny meme image.
+
+- Lean into CT humor and culture where it fits — degens, leverage and liquidations, rugs and exit liquidity, gm/wagmi/ngmi, "ser"/"anon", diamond vs paper hands, copium, "few understand this", and wojak/pepe/chad/virgin-vs-chad visual archetypes. Use what suits the subject; never force every trope in.
+- Describe a clear, vivid visual scene, and specify the EXACT short bold meme caption text to render in the image (impact-font style, just a few words).
+- Funny and a little edgy is good; never hateful, sexual, or harassing toward private individuals.
+- Output ONLY the image prompt itself — no preamble, no quotes, no explanation, no markdown.`;
+async function craftMemePrompt(subject, angle) {
+    const user = angle ? `Tweet subject: ${subject}\n\nExtra angle to play on: ${angle}` : `Tweet subject: ${subject}`;
+    const messages = [
+        { role: "system", content: MEME_SYSTEM },
+        { role: "user", content: user },
+    ];
+    return (await chat(messages)).trim();
+}
+// ── Step 2: render the crafted prompt with gpt-image-1 (POST, then poll if it goes async) ──
+async function generateImage(prompt, size) {
+    const res = await payFetch(ENDPOINT, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ prompt, model: MODEL, size }),
+        signal: AbortSignal.timeout(POST_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+        const detail = await res.text().catch(() => "");
+        log.warn({ status: res.status, detail }, "generate-meme: POST failed");
+        throw new Error(`image generation failed (HTTP ${res.status})`);
+    }
+    const body = await res.json();
+    const inline = imageUrl(body);
+    if (inline) {
+        log.info({ model: MODEL, size, url: inline }, "generate-meme: inline result");
+        return inline;
+    }
+    const pollPath = body?.poll_url;
+    if (!pollPath)
+        throw new Error("no image and no job to poll");
+    const pollUrl = new URL(pollPath, ORIGIN).toString();
+    log.info({ jobId: body?.id, status: body?.status, size, pollUrl }, "generate-meme: job queued, polling");
+    for (let attempt = 1; attempt <= POLL_MAX_ATTEMPTS; attempt++) {
+        await sleep(POLL_INTERVAL_MS);
+        let pb = null;
+        try {
+            const pr = await payFetch(pollUrl, { method: "GET", signal: AbortSignal.timeout(POLL_TIMEOUT_MS) });
+            pb = await pr.json().catch(() => null);
+        }
+        catch (err) {
+            // Transient poll error — the job may still finish, so log and try the next tick.
+            log.warn({ attempt, err: err instanceof Error ? err.message : String(err) }, "generate-meme: poll errored — retrying");
+            continue;
+        }
+        const url = imageUrl(pb);
+        if (url) {
+            log.info({ attempt, url }, "generate-meme: completed");
+            return url;
+        }
+        if (pb?.status === "failed")
+            throw new Error("job reported failed");
+        log.info({ attempt, status: pb?.status }, "generate-meme: still generating");
+    }
+    throw new Error("timed out before the job finished");
+}
+export const handler = async (params) => {
+    const subject = (params.subject ?? params.prompt ?? "").trim();
+    if (!subject)
+        return { text: "missing subject — pass the tweet's content/topic to meme about" };
+    const size = resolveSize(params.size ?? params.orientation);
+    // 1) Craft the funny, CT-aware image prompt.
+    let memePrompt;
+    try {
+        memePrompt = await craftMemePrompt(subject, params.angle?.trim() || undefined);
+        if (!memePrompt)
+            throw new Error("empty prompt");
+        log.info({ subject, size, memePrompt }, "generate-meme: crafted prompt");
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : String(err) }, "generate-meme: prompt crafting failed");
+        return { text: "couldn't come up with a meme for that — try again" };
+    }
+    // 2) Render it.
+    try {
+        const url = await generateImage(memePrompt, size);
+        return { text: `${GENERATED_NOTE}\n\nThe meme depicts: ${memePrompt}`, mediaUrl: url };
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : String(err) }, "generate-meme: generation failed");
+        return { text: "the meme image failed to generate — try again" };
+    }
+};

package/dist/config/skills/generate-meme-prompt/handler.d.ts

@@ -0,0 +1,2 @@
+import { type SkillHandler } from "yappr";
+export declare const handler: SkillHandler;

package/dist/config/skills/generate-meme-prompt/handler.js

@@ -0,0 +1,38 @@
+import { chat, log } from "yappr";
+// generate-meme-prompt: craft a funny, Crypto-Twitter-flavored image PROMPT from a tweet.
+// It does NOT render anything — it returns the prompt for the model to hand to the
+// generate-image skill, which does the actual (paid) rendering and attaches the result.
+// Keeping the two apart means one render path (generate-image) and no duplicated image-gen
+// code here. Use it when the user wants a meme but hasn't described the visual themselves.
+// The prompt-crafting brief. Bakes in Crypto Twitter context so the meme lands.
+const MEME_SYSTEM = `You are a Crypto Twitter (CT) meme director. Given the subject of a tweet, write ONE image-generation prompt for a single funny meme image.
+
+- Lean into CT humor and culture where it fits — degens, leverage and liquidations, rugs and exit liquidity, gm/wagmi/ngmi, "ser"/"anon", diamond vs paper hands, copium, "few understand this", and wojak/pepe/chad/virgin-vs-chad visual archetypes. Use what suits the subject; never force every trope in.
+- Describe a clear, vivid visual scene, and specify the EXACT short bold meme caption text to render in the image (impact-font style, just a few words).
+- Funny and a little edgy is good; never hateful, sexual, or harassing toward private individuals.
+- Output ONLY the image prompt itself — no preamble, no quotes, no explanation, no markdown.`;
+export const handler = async (params) => {
+    const subject = (params.subject ?? params.prompt ?? "").trim();
+    if (!subject)
+        return { text: "missing subject — pass the tweet's content/topic to meme about" };
+    const angle = params.angle?.trim() || undefined;
+    const user = angle ? `Tweet subject: ${subject}\n\nExtra angle to play on: ${angle}` : `Tweet subject: ${subject}`;
+    const messages = [
+        { role: "system", content: MEME_SYSTEM },
+        { role: "user", content: user },
+    ];
+    try {
+        const memePrompt = (await chat(messages)).trim();
+        if (!memePrompt)
+            throw new Error("empty prompt");
+        log.info({ subject, memePrompt }, "generate-meme-prompt: crafted prompt");
+        // Return just the prompt (as data). The chaining — "now call generate-image with this"
+        // — is driven by skill.md (a trusted instruction), since observations are fed to the
+        // model as data, not instructions.
+        return { text: `Meme image prompt (pass verbatim to the generate-image skill's "prompt"):\n\n${memePrompt}` };
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : String(err) }, "generate-meme-prompt: prompt crafting failed");
+        return { text: "couldn't come up with a meme for that — try again" };
+    }
+};

package/dist/config/skills/stats/handler.d.ts

@@ -0,0 +1,2 @@
+import { type SkillHandler } from "yappr";
+export declare const handler: SkillHandler;

package/dist/config/skills/stats/handler.js

@@ -0,0 +1,71 @@
+import { summary, getTreasury, llmCreditBalance, log } from "yappr";
+// stats: the agent's all-time metrics from its own ledger, plus a runway estimate (how
+// long the treasury lasts at the current burn). The runway mirrors the status dashboard's
+// two-tank model: USDC pays x-api + compute + x402, LLM credits pay inference — runway is
+// whichever tank empties first. (Burn math kept in sync with cli/status.ts by hand.)
+const RUNWAY_MIN_DATA_HOURS = 1; // trust the measured burn only after this much recorded window
+const X_API_POLL_COST_USD = 0.005; // always-on mentions-poll cost — the cold-start/floor burn
+function fmtDuration(hours) {
+    if (!Number.isFinite(hours))
+        return "∞";
+    if (hours < 1)
+        return `${Math.round(hours * 60)}m`;
+    if (hours < 48)
+        return `${hours.toFixed(1)}h`;
+    return `${(hours / 24).toFixed(1)}d`;
+}
+export const handler = async () => {
+    const s = summary();
+    // Burn rates from the trailing window. usdcBurn = x-api+compute+x402 (total minus the
+    // inference slice), floored at the always-on poll cost so downtime can't inflate runway;
+    // llmBurn = inference. Before there's enough recorded window, fall back to the poll-cost
+    // estimate for USDC and treat inference as not-yet-binding.
+    const pollSeconds = Math.round((Number(process.env.POLL_INTERVAL_MS) || 20_000) / 1000);
+    const predictedUsdcBurn = pollSeconds > 0 ? (3600 / pollSeconds) * X_API_POLL_COST_USD : 0;
+    const hasRate = s.rateWindowHours >= RUNWAY_MIN_DATA_HOURS && s.spentUsdWindow > 0;
+    const usdcBurn = hasRate
+        ? Math.max((s.spentUsdWindow - s.inferenceUsdWindow) / s.rateWindowHours, predictedUsdcBurn)
+        : predictedUsdcBurn;
+    const llmBurn = hasRate ? s.inferenceUsdWindow / s.rateWindowHours : 0;
+    // Treasury value per tank: the USDC balance (live, on-chain) and the LLM credit balance.
+    let usdcUsd = null;
+    try {
+        usdcUsd = Number((await getTreasury().balances()).usdc) / 1e6;
+    }
+    catch (err) {
+        log.warn({ err: err instanceof Error ? err.message : String(err) }, "stats: balances fetch failed");
+    }
+    const creditUsd = await llmCreditBalance();
+    const usdcRunwayH = usdcBurn > 0 ? (usdcUsd != null ? usdcUsd / usdcBurn : Infinity) : Infinity;
+    const llmRunwayH = llmBurn > 0 ? (creditUsd != null ? creditUsd / llmBurn : Infinity) : Infinity;
+    const runwayHours = Math.min(usdcRunwayH, llmRunwayH);
+    const runwayKnown = usdcUsd != null || creditUsd != null;
+    const runway = !runwayKnown
+        ? { available: false }
+        : {
+            available: true,
+            human: fmtDuration(runwayHours),
+            hours: Number.isFinite(runwayHours) ? Number(runwayHours.toFixed(1)) : null, // null ≈ effectively infinite
+            days: Number.isFinite(runwayHours) ? Number((runwayHours / 24).toFixed(2)) : null,
+            estimated: !hasRate, // cold-start estimate — not enough recorded burn yet
+            limitedBy: usdcRunwayH <= llmRunwayH ? "usdc" : "llm-credits",
+            usdcBalanceUsd: usdcUsd,
+            llmCreditUsd: creditUsd,
+            usdcBurnUsdPerHour: Number(usdcBurn.toFixed(4)),
+            llmBurnUsdPerHour: Number(llmBurn.toFixed(4)),
+        };
+    return {
+        data: {
+            mentions: s.mentions,
+            replies: s.replies,
+            llmCalls: s.llm,
+            // warns/errors are deliberately omitted — internal health metrics, not user-facing
+            // (and this skill is public). They stay in summary() for the admin status dashboard.
+            spentUsd: Number(s.spentUsd.toFixed(4)),
+            spentByType: s.spentByType, // { "x-api", inference, compute, x402 }
+            earnedWeth: s.earnedWeth, // lifetime gross creator fees, in ETH/WETH
+            devWeth: s.devWeth, // dev cut within earnedWeth
+            runway,
+        },
+    };
+};

package/dist/config/skills/wallet/handler.d.ts

@@ -0,0 +1,2 @@
+import { type SkillHandler } from "yappr";
+export declare const handler: SkillHandler;

package/dist/config/skills/wallet/handler.js

@@ -0,0 +1,54 @@
+import { agentPrompt } from "yappr";
+// Bankr returns a natural-language response, so we pull transaction hashes out of
+// it and append the right block-explorer link. Hash format tells us the chain:
+//   EVM:    0x + 64 hex chars        -> basescan.org (our EVM actions run on Base)
+//   Solana: base58 signature ~88 chars -> solscan.io
+// (EVM addresses are 0x+40 hex, so they never match the 64-hex tx pattern; Solana
+// addresses are <=44 base58 chars, so they never match the long-signature pattern.)
+const EVM_TX = /0x[0-9a-fA-F]{64}/g;
+const SOL_TX = /\b[1-9A-HJ-NP-Za-km-z]{80,90}\b/g;
+function appendTxLinks(text) {
+    const links = [];
+    const seen = new Set();
+    const add = (hash, base) => {
+        if (seen.has(hash))
+            return;
+        seen.add(hash);
+        links.push(`${base}${hash}`);
+    };
+    for (const h of text.match(EVM_TX) ?? [])
+        add(h, "https://basescan.org/tx/");
+    for (const s of text.match(SOL_TX) ?? [])
+        add(s, "https://solscan.io/tx/");
+    if (links.length === 0)
+        return text;
+    return `${text}\n\nTransaction${links.length > 1 ? "s" : ""}:\n${links.join("\n")}`;
+}
+export const handler = async (params, _tweet) => {
+    switch (params.action) {
+        case "claim":
+            return { text: appendTxLinks(await agentPrompt("claim my token fees on base")) };
+        case "burn": {
+            const amount = params.amount ?? "50%";
+            return { text: appendTxLinks(await agentPrompt(`burn ${amount} of my tokens on base`)) };
+        }
+        case "swap": {
+            const from = params.from ?? "WETH";
+            const to = params.to ?? "USDC";
+            const amount = params.swap_amount ?? "all";
+            return { text: appendTxLinks(await agentPrompt(`swap ${amount} of ${from} to ${to} on base`)) };
+        }
+        case "send": {
+            if (!params.send_to)
+                return { text: "missing recipient — specify an address, ENS name, or X @handle" };
+            if (!params.send_amount)
+                return { text: "missing amount — specify how much to send" };
+            const token = params.send_token ?? "ETH";
+            return { text: appendTxLinks(await agentPrompt(`send ${params.send_amount} ${token} to ${params.send_to} on base`)) };
+        }
+        case "balance":
+            return { text: await agentPrompt("what are my token balances on base") };
+        default:
+            return { text: `unknown action "${params.action}" — try: claim, burn, swap, send, balance` };
+    }
+};

package/dist/config/skills/x/handler.d.ts

@@ -0,0 +1,2 @@
+import { type SkillHandler } from "yappr";
+export declare const handler: SkillHandler;

package/dist/config/skills/x/handler.js

@@ -0,0 +1,115 @@
+import { extractTweetId, getTweetById, getUserTweets, searchTweets, getTweetReplies, getRetweetedBy, getQuoteTweets, postTweet, deleteTweet, likeTweet, unlikeTweet, retweetTweet, unretweetTweet, bookmarkTweet, unbookmarkTweet, getUserByUsername, getUserById, getUsers, searchUsers, getFollowers, getFollowing, followUser, unfollowUser, setProfile, uploadMediaFromUrl, getArticle, getList, getListMembers, getListFollowers, getListTweets, getCommunity, getCommunityMembers, getCommunityPosts, getUserInsights, } from "yappr";
+// Wrap an action that needs an id (tweet/user/list/community — accepts a raw id or X URL).
+function withId(label, fn) {
+    return (p) => (p.id ? fn(extractTweetId(p.id), p) : Promise.resolve({ text: `missing ${label}` }));
+}
+// Wrap a write action that just acknowledges success with a short message.
+function ack(label, fn, verb) {
+    return withId(label, async (id) => {
+        await fn(id);
+        return { text: `${verb} ${id}` };
+    });
+}
+const ID = "tweet id or URL";
+// Upload one or more image URLs (comma-separated) to X and return their media_ids to
+// attach to a post. Bounded to X's 4-images-per-tweet limit.
+async function uploadMediaUrls(raw) {
+    const urls = (raw ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+    if (urls.length === 0)
+        return undefined;
+    const ids = [];
+    for (const url of urls.slice(0, 4))
+        ids.push(await uploadMediaFromUrl(url));
+    return ids.length ? ids : undefined;
+}
+const actions = {
+    // ── tweets (read) ──
+    "tweet": withId(ID, async (id) => ({ data: await getTweetById(id) })),
+    "tweet-search": async (p) => ({
+        data: await searchTweets({
+            words: p.words ?? p.query, phrase: p.phrase, anyWords: p.any_words, noneWords: p.none_words,
+            hashtags: p.hashtags, from: p.from, to: p.to, mentioning: p.mentioning,
+            minReplies: p.min_replies ? Number(p.min_replies) : undefined,
+            minLikes: p.min_likes ? Number(p.min_likes) : undefined,
+            minReposts: p.min_reposts ? Number(p.min_reposts) : undefined,
+            since: p.since, until: p.until,
+        }),
+    }),
+    "tweet-replies": withId(ID, async (id) => ({ data: await getTweetReplies(id) })),
+    "tweet-retweeters": withId(ID, async (id) => ({ data: await getRetweetedBy(id) })),
+    "tweet-quotes": withId(ID, async (id) => ({ data: await getQuoteTweets(id) })),
+    "timeline": async (p) => (p.username ? { data: await getUserTweets(p.username) } : { text: "missing username" }),
+    // ── tweets (write) ──
+    "post": async (p) => {
+        if (!p.text)
+            return { text: "missing tweet text" };
+        await postTweet(p.text, {
+            replyTo: p.reply_to ? extractTweetId(p.reply_to) : undefined,
+            quoteTweetId: p.quote_id ? extractTweetId(p.quote_id) : undefined,
+            mediaIds: await uploadMediaUrls(p.media_url),
+        });
+        return { text: "posted" };
+    },
+    "delete": ack(ID, deleteTweet, "deleted"),
+    "like": ack(ID, likeTweet, "liked"),
+    "unlike": ack(ID, unlikeTweet, "unliked"),
+    "retweet": ack(ID, retweetTweet, "retweeted"),
+    "unretweet": ack(ID, unretweetTweet, "unretweeted"),
+    "bookmark": ack(ID, bookmarkTweet, "bookmarked"),
+    "unbookmark": ack(ID, unbookmarkTweet, "removed bookmark"),
+    // ── users (read) ──
+    "user": async (p) => {
+        if (!p.username && !p.id)
+            return { text: "missing username or id" };
+        return { data: p.username ? await getUserByUsername(p.username) : await getUserById(p.id) };
+    },
+    "users": async (p) => {
+        const ids = (p.ids ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+        return ids.length ? { data: await getUsers(ids) } : { text: "missing ids (comma-separated numeric user IDs)" };
+    },
+    "user-search": async (p) => (p.query ? { data: await searchUsers(p.query) } : { text: "missing search query" }),
+    "followers": withId("user id", async (id) => ({ data: await getFollowers(id) })),
+    "following": withId("user id", async (id) => ({ data: await getFollowing(id) })),
+    // ── users (write) ──
+    "follow": async (p) => {
+        if (!p.username && !p.id)
+            return { text: "missing username or id" };
+        await followUser({ id: p.id, username: p.username });
+        return { text: `followed ${p.username ?? p.id}` };
+    },
+    "unfollow": async (p) => {
+        if (!p.username && !p.id)
+            return { text: "missing username or id" };
+        await unfollowUser({ id: p.id, username: p.username });
+        return { text: `unfollowed ${p.username ?? p.id}` };
+    },
+    "set-profile": async (p) => {
+        // All four fields are required (a profile set replaces the whole thing). `name` must
+        // be non-empty; bio/location/url may be an empty string, which CLEARS that field on X.
+        for (const f of ["name", "bio", "location", "url"]) {
+            if (p[f] === undefined) {
+                return { text: "set-profile requires all of: name, bio, location, url (pass an empty string for bio/location/url to clear them)" };
+            }
+        }
+        if (p.name.trim() === "")
+            return { text: "name cannot be empty" };
+        await setProfile({ name: p.name, bio: p.bio, location: p.location, url: p.url });
+        return { text: "profile updated" };
+    },
+    // ── other ──
+    "article": withId(ID, async (id) => ({ data: await getArticle(id) })),
+    "list": withId("list id", async (id) => ({ data: await getList(id) })),
+    "list-members": withId("list id", async (id) => ({ data: await getListMembers(id) })),
+    "list-followers": withId("list id", async (id) => ({ data: await getListFollowers(id) })),
+    "list-tweets": withId("list id", async (id) => ({ data: await getListTweets(id) })),
+    "community": withId("community id", async (id) => ({ data: await getCommunity(id) })),
+    "community-members": withId("community id", async (id) => ({ data: await getCommunityMembers(id) })),
+    "community-posts": withId("community id", async (id) => ({ data: await getCommunityPosts(id) })),
+    "user-insights": async (p) => (p.username ? { data: await getUserInsights(p.username) } : { text: "missing username" }),
+};
+export const handler = async (params) => {
+    const action = actions[params.action];
+    if (!action)
+        return { text: `unknown action "${params.action}"` };
+    return action(params);
+};

package/dist/src/agent-prompt.d.ts

@@ -0,0 +1 @@
+export declare function agentPrompt(prompt: string): Promise<string>;

package/dist/src/agent-prompt.js

@@ -0,0 +1,45 @@
+import { config } from "./config.js";
+import { log } from "./log.js";
+import { bankrApi } from "./bankr.js";
+import { sleep } from "./util.js";
+// Always submitted in Max Mode (an explicit model id), which bills the job
+// per-request from the LLM credit balance instead of counting against the
+// account's prompt quota (100/day for non-Club) — so callers don't need to
+// ration these. Uses the same model as the reply loop (LLM_MODEL): both run
+// against the LLM gateway's model catalog, so one knob configures all inference.
+export async function agentPrompt(prompt) {
+    if (config.treasuryDryRun) {
+        log.info({ prompt }, "agent-prompt [dry run]");
+        return `[dry run] ${prompt}`;
+    }
+    log.info({ prompt, model: config.llmModel }, "agent-prompt submitting");
+    const { jobId } = await bankrApi(config.bankrApiKey, "/agent/prompt", {
+        method: "POST",
+        body: JSON.stringify({
+            prompt,
+            maxMode: { enabled: true, model: config.llmModel },
+        }),
+    });
+    log.info({ jobId }, "agent-prompt job queued");
+    for (let i = 0; i < 60; i++) {
+        await sleep(2000);
+        let job;
+        try {
+            job = await bankrApi(config.bankrApiKey, `/agent/job/${jobId}`);
+        }
+        catch {
+            continue; // transient poll failure — retry
+        }
+        if (job.status === "completed") {
+            log.info({ jobId, attempts: i + 1 }, "agent-prompt job completed");
+            return job.response ?? "";
+        }
+        if (job.status === "failed") {
+            // warn before throwing: the catch site logs the (counted) error — see log.ts.
+            log.warn({ jobId }, "agent-prompt job failed");
+            throw new Error(`Bankr agent job failed: ${job.response ?? "unknown"}`);
+        }
+    }
+    log.warn({ jobId }, "agent-prompt job timed out");
+    throw new Error(`Bankr agent job timed out (jobId=${jobId})`);
+}

package/dist/src/bankr.d.ts

@@ -0,0 +1,41 @@
+type BankrAuth = "key" | "bearer";
+export type BankrX402PayResult<T = unknown> = {
+    success: boolean;
+    status: number;
+    response: T;
+    error?: string;
+    paymentMade?: {
+        amountUsd: number;
+        network: string;
+    };
+};
+export declare function bankrApi<T = unknown>(apiKey: string, path: string, init?: Omit<RequestInit, "headers"> & {
+    auth?: BankrAuth;
+    headers?: Record<string, string>;
+    tolerateHttpError?: boolean;
+}): Promise<T>;
+export declare function bankrSignTypedData(apiKey: string, typedData: unknown): Promise<`0x${string}`>;
+export declare function bankrSignMessage(apiKey: string, message: string): Promise<`0x${string}`>;
+export declare function bankrX402Pay<T = unknown>(apiKey: string, url: string, method: "GET" | "POST" | "PUT" | "DELETE", body: string | undefined, maxPaymentUsd: number): Promise<BankrX402PayResult<T>>;
+export type TokenLaunchInput = {
+    tokenName: string;
+    tokenSymbol: string;
+    feeRecipient?: {
+        type: "wallet" | "x" | "farcaster" | "ens";
+        value: string;
+    };
+    image?: string;
+    description?: string;
+    tweetUrl?: string;
+    websiteUrl?: string;
+};
+export type TokenLaunchResult = {
+    success?: boolean;
+    tokenAddress?: string;
+    poolId?: string;
+    txHash?: string;
+    chain?: string;
+    [k: string]: unknown;
+};
+export declare function deployTokenLaunch(input: TokenLaunchInput): Promise<TokenLaunchResult>;
+export {};

package/dist/src/bankr.js

@@ -0,0 +1,76 @@
+// Single client for the Bankr REST API (https://api.bankr.bot). Every Bankr
+// call goes through bankrApi() so the base URL, auth header, and error handling
+// live in exactly one place. Config-free (takes the API key as an argument) so
+// the deploy script can use it before env validation runs.
+const BANKR_API = "https://api.bankr.bot";
+function jsonStringify(value) {
+    return JSON.stringify(value, (key, v) => {
+        if (typeof v !== "bigint")
+            return v;
+        if (key === "chainId" && v <= BigInt(Number.MAX_SAFE_INTEGER))
+            return Number(v);
+        return v.toString();
+    });
+}
+export async function bankrApi(apiKey, path, init = {}) {
+    const { auth = "key", headers, tolerateHttpError, ...rest } = init;
+    const res = await fetch(`${BANKR_API}${path}`, {
+        ...rest,
+        headers: {
+            "Content-Type": "application/json",
+            ...(auth === "bearer" ? { Authorization: `Bearer ${apiKey}` } : { "X-API-Key": apiKey }),
+            ...headers,
+        },
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        if (tolerateHttpError) {
+            try {
+                return JSON.parse(body);
+            }
+            catch {
+                // not JSON — fall through to the throw below
+            }
+        }
+        throw new Error(`Bankr ${path} failed: ${res.status} ${body}`);
+    }
+    return res.json();
+}
+export async function bankrSignTypedData(apiKey, typedData) {
+    const { signature } = await bankrApi(apiKey, "/wallet/sign", {
+        method: "POST",
+        body: jsonStringify({ signatureType: "eth_signTypedData_v4", typedData }),
+    });
+    return signature;
+}
+// EIP-191 personal_sign over a UTF-8 message. Used for x402 Compute's wallet-
+// signature auth (X-Auth-* headers) on instance management endpoints.
+export async function bankrSignMessage(apiKey, message) {
+    const { signature } = await bankrApi(apiKey, "/wallet/sign", {
+        method: "POST",
+        body: jsonStringify({ signatureType: "personal_sign", message }),
+    });
+    return signature;
+}
+export async function bankrX402Pay(apiKey, url, method, body, maxPaymentUsd) {
+    return bankrApi(apiKey, "/wallet/x402-pay", {
+        method: "POST",
+        body: JSON.stringify({ url, method, body, maxPaymentUsd }),
+        // A failed payment comes back as HTTP 400 with a structured result body — let
+        // payFetch see it (and log paymentMade vs response) instead of throwing here.
+        tolerateHttpError: true,
+    });
+}
+// Dedicated launch-only Bankr key. Holds ONLY the token-launch permission (no
+// wallet/sign/spend), so every deployed instance can launch its agent token through
+// a Bankr Club account even when the operator has no Club key of their own. Shared
+// deliberately — note it ships compiled in the published package, so treat it as
+// public; rotate it on the Bankr side if it's ever abused (launches are the only
+// thing it can do, and fees always go to the operator's handle, not here).
+const TOKEN_LAUNCH_API_KEY = "bk_usr_F3xe6wBW_JCkQRJv2LMe769G3YsQxLBKQ942SAfAF";
+export async function deployTokenLaunch(input) {
+    return bankrApi(TOKEN_LAUNCH_API_KEY, "/token-launches/deploy", {
+        method: "POST",
+        body: JSON.stringify(input),
+    });
+}

package/dist/src/cli/backup.d.ts

@@ -0,0 +1,7 @@
+import type { NodeSSH } from "node-ssh";
+export declare const REMOTE_DB_PATH = "/var/lib/yappr/yappr.db";
+export declare function backupDir(): string;
+export declare function latestLocalBackup(): Promise<string | null>;
+export declare function remoteFileExists(ssh: NodeSSH, path: string): Promise<boolean>;
+export declare function backupRemoteDb(ssh: NodeSSH): Promise<string>;
+export declare function backupLabel(absPath: string): string;