cyberdyne-mcp 0.6.25 → 0.7.1

package/README.md

@@ -111,7 +111,9 @@ npx -y cyberdyne-mcp tasks                          # list your posted tasks + s
 
 | Command | Usage | What it does |
 |---|---|---|
-| `post` | `cyberdyne-mcp post --title <t> --reward <n> [--token USDC\|BNKR\|GITLAWB] [--quantity <n>] [--category <c>] [--action follow\|retweet\|reply\|quote\|original-post] [--url <x.com/…>]` | Like `bankr launch`. Opens a task. On the **pool** rail (default for BNKR/GITLAWB or `--quantity>1`) it autonomously signs the budget, pays the deploy fee from your wallet, and authorizes — printing each stage and the final task id + `escrow_status`. |
+| `post` | `cyberdyne-mcp post --title <t> --reward <n> [--token USDC\|BNKR\|GITLAWB] [--quantity <n>] [--category <c>] [--action follow\|retweet\|reply\|quote\|original-post] [--url <x.com/…>] [--bankr-wallet]` | Like `bankr launch`. Opens a task. On the **pool** rail (default for BNKR/GITLAWB or `--quantity>1`) it autonomously signs the budget, pays the deploy fee, and authorizes — printing each stage and the final task id + `escrow_status`. Add `--bankr-wallet` to fund from your Bankr custodial wallet (no key export). |
+| `launch-and-fund` | `cyberdyne-mcp launch-and-fund --token <0x…> --title <t> --reward <n> [--quantity <n>]` | Fund an engagement quest **in your own Bankr-launched token**, paid to verified humans (funds from your Bankr wallet by default). CYBERDYNE never launches a token — launch yours on Bankr first, then fund quests in it. |
+| `bankr-login` | `cyberdyne-mcp bankr-login [--private-key <0x…>] [--partner-key <k>]` | Headless SIWE → mint a Bankr `bk_` key with your wallet (zero-browser, no email OTP). Printed once; set it as `CYBERDYNE_BANKR_KEY`. Wallet API on by default; Agent API may need enabling at bankr.bot/api. |
 | `tasks` | `cyberdyne-mcp tasks` | Lists your own posted tasks: id, title, token, quantity, filled/remaining, status. |
 
 Flags accept both `--flag value` and `--flag=value`. `--title` and `--reward` (per
@@ -131,6 +133,7 @@ stdio MCP servers take their credentials from the environment. Set:
 |---|---|---|---|
 | `CYBERDYNE_IDENTITY_TOKEN` | yes (for any networked tool) | — | The agent's API key (`cyb_…`). |
 | `CYBERDYNE_API_URL` | no | `https://app.cyberdyne-os.xyz` | Base URL of the platform API. |
+| `CYBERDYNE_BANKR_KEY` | no | — | A `bk_…` Bankr Agent-API key. Enables `post --bankr-wallet` / `launch-and-fund` to fund from your Bankr custodial wallet. Falls back to `BANKR_API_KEY` / `~/.bankr/config.json`. Used against api.bankr.bot; never stored by CYBERDYNE. |
 
 No key is hardcoded anywhere. `list_categories` and `onboard` work without a token
 (`onboard` mints one); every other tool returns a clear error until a key is set —
@@ -281,39 +284,23 @@ The budget is frozen on the audited escrow at deploy in your token, and each app
 human captures the full reward in that same token. Pay your own community, in your own
 coin, straight from your agent.
 
-## CYBERDYNE is the human layer of the Bankr stack
+### Use with the full Bankr stack
 
-You already build with Bankr — wallets + swaps via `@bankr/sdk`, agent reasoning via
-the **Bankr LLM Gateway** (`llm.bankr.bot`), your token launched with **Clanker**.
-CYBERDYNE closes the loop: it turns that token into a **community**.
+CYBERDYNE is native to the Bankr ecosystem and consumes it where it helps — the core
+(non-custodial escrow + auth-capture signing) stays in CYBERDYNE; Bankr is a convenience
++ distribution layer around it:
 
-**The loop:** launch a token on Bankr → post **agent-funded engagement quests** on
-CYBERDYNE (follows, reposts, replies, quotes, original posts) → **verified-X humans**
-complete them → each is paid the full reward **in your own Bankr token**,
-non-custodially, on the **same x402 rail and the same wallet**. Real engagement from
-real people, paid in your coin — driving holders, utility, and velocity. No bots;
-settlement is the audited Base escrow.
-
-```bash
-# 1) launch your token on Bankr (Clanker)
-bankr launch ...
-
-# 2) grow its community — same agent, same Bankr wallet, same x402 rail:
-npx -y cyberdyne-mcp post --title "Quote-repost our launch" \
-  --token 0xYourBankrToken --reward 100 --quantity 25
-```
-
-### Use with the Bankr stack
-
-| Bankr surface | Pairs with CYBERDYNE for |
-|---|---|
-| **`@bankr/sdk`** (x402 SDK) | Sign the `deployFee` + `authIntent` txs that `post_task`/`authorize_task` return — fund quests from your existing Bankr wallet. |
-| **Bankr LLM Gateway** (`llm.bankr.bot`) | Powers your agent's reasoning — and CYBERDYNE's own AI proof-review routes through it (`BANKR_LLM_KEY`), so LLM spend stays in the Bankr rail. |
-| **Bankr CLI / Agent API** | The agent's canonical wallet + identity; reuse it instead of minting a separate signer. |
-| **Clanker** | Mints the token you then fund engagement quests in — the community loop above. |
-
-Same ecosystem, same wallet, one x402 rail: Bankr gives your agent hands and a wallet;
-CYBERDYNE gives it a verified-human workforce to grow the community around your token.
+| Capability | How | Status |
+|---|---|---|
+| **Pay in any Bankr token** | `--token USDC\|BNKR\|0x…` — humans paid in-token from the audited escrow | **live** |
+| **Fund from your Bankr wallet** | `post --bankr-wallet` — deploy fee via `/wallet/transfer`, escrow auth via `/wallet/sign` (`eth_signTypedData_v4`), no key export | BETA¹ |
+| **Headless Bankr key** | `bankr-login` — SIWE mint a `bk_` with your wallet (no browser/OTP) | built |
+| **Discoverable by Bankr agents** | an x402 "front door" published to Bankr's x402 Cloud discovery index | platform-side |
+| **LLM proof-grading on Bankr** | submission grading routes through the Bankr LLM gateway (Anthropic-compatible, Anthropic fallback) | platform-side |
+
+¹ USDC (EIP-3009) funds custodially with no allowance; ecosystem tokens (BNKR/GITLAWB/
+Permit2) also need a one-time ERC-20→Permit2 approval from the Bankr wallet first. BETA:
+the local-wallet path (`post` without `--bankr-wallet`) is the certified default.
 
 ### …or install the plugin (skill + MCP together)
 

package/dist/bankr-signer.js

@@ -0,0 +1,142 @@
+/**
+ * BETA — Bankr-wallet-native funding for CYBERDYNE (no private-key export).
+ *
+ * Lets an agent fund a quest entirely from its Bankr-managed (Privy) custodial wallet:
+ *   - the deploy fee  → POST /wallet/transfer (a plain ERC-20 send)
+ *   - the auth-capture authorization → signed via POST /wallet/sign (eth_signTypedData_v4)
+ *
+ * The auth-capture TYPED DATA is built by the SAME audited @x402/evm AuthCaptureEvmScheme
+ * the local path uses (src/evm-signer.ts) — we only swap the SIGNER: a viem custom account
+ * whose signTypedData/signMessage forward to Bankr's custodial signer. So the payload shape
+ * is identical to the certified local path; only the signature source differs.
+ *
+ * STATUS: this path requires a valid bk_ key with Bankr Agent API access and has NOT yet
+ * been certified end-to-end on mainnet (the proven default remains the local-wallet path in
+ * evm-signer.ts). It is opt-in only (`post --bankr-wallet` / CYBERDYNE_SIGNER=bankr).
+ *
+ * Permit2-method tokens (BNKR/GITLAWB/non-EIP-3009) need a one-time ERC-20→Permit2 approval
+ * sent from the wallet before the budget can freeze. Sending that approval from a custodial
+ * Bankr wallet is not automated here, so we READ the allowance first and fail with a clear,
+ * actionable error if it's missing — rather than producing a signature that would revert at
+ * authorize. EIP-3009 tokens (USDC) need no approval and work directly.
+ */
+import { createPublicClient, getAddress, http, isAddress } from "viem";
+import { toAccount } from "viem/accounts";
+import { base, baseSepolia } from "viem/chains";
+import { AuthCaptureEvmScheme, toClientEvmSigner } from "@x402/evm";
+import { bankrSignTypedData, bankrSignMessage, bankrTransfer, bankrWalletAddress, resolveBankrKey, MissingBankrKeyError } from "./bankr.js";
+function chain() {
+    return Number(process.env.CYBERDYNE_CHAIN_ID ?? 8453) === 8453 ? base : baseSepolia;
+}
+const PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3";
+const ERC20_ALLOWANCE_ABI = [
+    { name: "allowance", type: "function", stateMutability: "view", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ type: "uint256" }] },
+];
+/** True when a bk_ key is discoverable (so callers can offer the Bankr-wallet path). */
+export function hasBankrSigner() {
+    return !!resolveBankrKey();
+}
+/**
+ * A viem custom account backed by the Bankr custodial wallet. Its address is the
+ * canonical Bankr EVM wallet; its signTypedData/signMessage call POST /wallet/sign.
+ * signTransaction is unsupported (the custodial wallet broadcasts via /wallet/transfer
+ * | /wallet/submit, not via a locally-serialized signed tx).
+ */
+export async function bankrAccount(key) {
+    const bk = key ?? resolveBankrKey();
+    if (!bk)
+        throw new MissingBankrKeyError();
+    const address = getAddress(await bankrWalletAddress(bk));
+    return toAccount({
+        address,
+        // viem passes the full EIP-712 definition { domain, types, primaryType, message };
+        // we forward it verbatim to Bankr's eth_signTypedData_v4 signer (correct shape).
+        async signTypedData(typedData) {
+            return bankrSignTypedData(typedData, bk);
+        },
+        async signMessage({ message }) {
+            const text = typeof message === "string"
+                ? message
+                : typeof message?.raw === "string"
+                    ? (message.raw)
+                    : JSON.stringify(message);
+            return bankrSignMessage(text, bk);
+        },
+        async signTransaction() {
+            throw new Error("the Bankr custodial wallet does not export raw signed transactions — use /wallet/transfer (fees) or /wallet/submit");
+        },
+    });
+}
+/** The agent's Bankr wallet address (the on-chain payer the platform will verify). */
+export async function bankrSignerAddress(key) {
+    return bankrWalletAddress(key);
+}
+/**
+ * Guard Permit2-method tokens: the on-chain freeze needs an ERC-20→Permit2 allowance
+ * the signature alone can't set. Read it; if insufficient, fail with a clear next step
+ * instead of producing a payload that would revert at authorize.
+ */
+async function assertPermit2Ready(requirements, owner) {
+    const r = (requirements ?? {});
+    if (r.extra?.assetTransferMethod !== "permit2")
+        return; // USDC/EIP-3009: nothing to approve
+    const token = r.asset;
+    if (!token || !isAddress(token))
+        return;
+    const need = (() => { try {
+        return BigInt(r.amount ?? 0);
+    }
+    catch {
+        return 0n;
+    } })();
+    const pub = createPublicClient({ chain: chain(), transport: http(process.env.CYBERDYNE_RPC_URL) });
+    if (need === 0n)
+        return; // nothing to freeze → no approval needed
+    const allowance = (await pub.readContract({
+        address: getAddress(token), abi: ERC20_ALLOWANCE_ABI, functionName: "allowance", args: [getAddress(owner), PERMIT2_ADDRESS],
+    }));
+    if (allowance >= need)
+        return;
+    throw new Error(`Bankr-wallet funding for this Permit2 token (${token}) needs a one-time ERC-20→Permit2 approval ` +
+        `from your Bankr wallet (${owner}) that isn't in place yet. Approve Permit2 (spender ` +
+        `${PERMIT2_ADDRESS}) from the Bankr wallet first, or fund this token from a local wallet. ` +
+        "USDC (EIP-3009) needs no approval and works directly.");
+}
+/**
+ * Sign the auth-capture requirements with the Bankr custodial wallet → base64 payload
+ * the platform's /authorize route consumes as `signedPayment`. Same scheme + payload
+ * shape as the local path; only the signer is Bankr.
+ */
+export async function bankrSignAuthCapture(requirements, key) {
+    const bk = key ?? resolveBankrKey();
+    if (!bk)
+        throw new MissingBankrKeyError();
+    const account = await bankrAccount(bk);
+    await assertPermit2Ready(requirements, account.address);
+    const pub = createPublicClient({ chain: chain(), transport: http(process.env.CYBERDYNE_RPC_URL) });
+    const scheme = new AuthCaptureEvmScheme(toClientEvmSigner(account, pub));
+    const result = await scheme.createPaymentPayload(2, requirements);
+    return Buffer.from(JSON.stringify(result)).toString("base64");
+}
+/**
+ * Pay the SEPARATE deploy fee from the Bankr custodial wallet via /wallet/transfer.
+ * `amount` is the fee in the FEE TOKEN's own (human-readable) units, as post_task pins it
+ * (Bankr resolves on-chain decimals server-side from the token address). Returns the tx
+ * hash to pass to authorize as `fee_tx_hash`.
+ *
+ * Like the local payDeployFee, we WAIT for on-chain inclusion (2 confs) + a success status
+ * before returning: authorize runs immediately after and the platform's verifyFeePayment
+ * reads the tx on-chain, so returning an un-mined hash would make authorize fail spuriously.
+ */
+export async function bankrPayDeployFee(fee, key) {
+    if (!isAddress(fee.token) || !isAddress(fee.recipient)) {
+        throw new Error("deploy_fee.token/recipient is not a valid address — pass the full deployFee object from post_task");
+    }
+    const hash = await bankrTransfer({ tokenAddress: getAddress(fee.token), recipientAddress: getAddress(fee.recipient), amount: fee.amount, isNativeToken: false, chain: "base" }, key);
+    const pub = createPublicClient({ chain: chain(), transport: http(process.env.CYBERDYNE_RPC_URL) });
+    const receipt = await pub.waitForTransactionReceipt({ hash: hash, confirmations: 2 });
+    if (receipt.status !== "success") {
+        throw new Error(`Bankr deploy-fee tx ${hash} reverted on-chain — fee NOT paid (no budget will freeze)`);
+    }
+    return hash;
+}

package/dist/bankr.js

@@ -0,0 +1,273 @@
+/**
+ * Thin, typed client for the LIVE Bankr Agent API (https://api.bankr.bot).
+ *
+ * This is how CYBERDYNE consumes the Bankr stack so an agent can act through its
+ * Bankr-managed (Privy) custodial wallet WITHOUT exporting a private key:
+ *   - GET  /wallet/me                  → the agent's canonical Bankr wallet address
+ *   - POST /wallet/transfer            → send an ERC-20 (e.g. the deploy fee) → txHash
+ *   - POST /wallet/sign                → custodial EIP-712 / personal_sign → signature
+ *   - GET  /_health                    → API-key liveness
+ *   - GET  /tokens/search?query=       → resolve a symbol ↔ address (public)
+ *
+ * Endpoint shapes verified against the published `@bankr/cli` (0.3.1) source. Auth is
+ * the `bk_…` Agent API key in the `X-API-Key` header (Bankr Club / Agent API access
+ * required — a key without it returns 401 on /wallet/*). NOTHING here is x402-specific:
+ * CYBERDYNE's own auth-capture signing stays in src/evm-signer.ts (@x402/evm) — this
+ * module only forwards a typed-data struct to Bankr's signer and returns the signature.
+ *
+ * The bk_ key is read fresh from the env / ~/.bankr each call and is NEVER persisted by
+ * CYBERDYNE and NEVER logged.
+ */
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readSavedWalletKey } from "./client.js";
+export const BANKR_API_URL = "https://api.bankr.bot";
+/**
+ * Resolve the agent's Bankr `bk_` key, most-explicit first:
+ *   CYBERDYNE_BANKR_KEY → BANKR_API_KEY (Bankr's own standard env var) →
+ *   any bk_-prefixed value in ~/.bankr/config.json (the file Bankr's CLI/SDK use).
+ * Returns undefined when Bankr isn't configured (callers then skip Bankr cleanly).
+ */
+export function resolveBankrKey(env = process.env) {
+    const fromEnv = env.CYBERDYNE_BANKR_KEY?.trim() || env.BANKR_API_KEY?.trim();
+    if (fromEnv?.startsWith("bk_"))
+        return fromEnv;
+    try {
+        const cfg = JSON.parse(readFileSync(join(homedir(), ".bankr", "config.json"), "utf8"));
+        for (const v of Object.values(cfg)) {
+            if (typeof v === "string" && v.startsWith("bk_"))
+                return v.trim();
+        }
+    }
+    catch {
+        /* no ~/.bankr/config.json — Bankr just isn't configured here */
+    }
+    return undefined;
+}
+/** Thrown when a Bankr call is attempted without a discoverable bk_ key. */
+export class MissingBankrKeyError extends Error {
+    constructor() {
+        super("no Bankr key — set CYBERDYNE_BANKR_KEY or BANKR_API_KEY (a bk_… Agent API key from " +
+            "https://bankr.bot, Agent API access enabled), or put it in ~/.bankr/config.json.");
+        this.name = "MissingBankrKeyError";
+    }
+}
+/** A Bankr API error carrying the HTTP status + the API's message. */
+export class BankrApiError extends Error {
+    status;
+    path;
+    constructor(status, path, message) {
+        super(`Bankr ${path} → ${status}: ${message}`);
+        this.status = status;
+        this.path = path;
+        this.name = "BankrApiError";
+    }
+}
+function authHeaders(key) {
+    const h = { "X-API-Key": key, accept: "application/json", "user-agent": "cyberdyne-mcp" };
+    const partner = process.env.CYBERDYNE_BANKR_PARTNER_KEY?.trim();
+    if (partner)
+        h["X-Partner-Key"] = partner;
+    return h;
+}
+async function call(method, path, opts = {}) {
+    const key = opts.key ?? resolveBankrKey();
+    if (!key)
+        throw new MissingBankrKeyError();
+    const res = await fetch(`${BANKR_API_URL}${path}`, {
+        method,
+        headers: {
+            ...authHeaders(key),
+            ...(opts.body !== undefined ? { "content-type": "application/json" } : {}),
+        },
+        ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        signal: AbortSignal.timeout(20_000),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        const msg = String(json?.message ?? json?.error ?? `http_${res.status}`);
+        throw new BankrApiError(res.status, path, msg);
+    }
+    return json;
+}
+/** GET /wallet/me — the agent's Bankr identity, incl. its managed wallet address. */
+export async function bankrWalletMe(key) {
+    return call("GET", "/wallet/me", { key });
+}
+/** Resolve the canonical Bankr EVM wallet address (walletAddress | evmAddress | address). */
+export async function bankrWalletAddress(key) {
+    const me = await bankrWalletMe(key);
+    const addr = me.walletAddress || me.evmAddress || me.address;
+    if (typeof addr !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(addr)) {
+        throw new BankrApiError(200, "/wallet/me", "no EVM wallet address in response");
+    }
+    return addr;
+}
+/**
+ * POST /wallet/transfer — send an ERC-20 (or native) from the Bankr-managed wallet.
+ * `amount` is the HUMAN-readable token amount (the API resolves decimals), matching
+ * the `bankr transfer --amount` CLI. Returns the broadcast tx hash.
+ */
+export async function bankrTransfer(params, key) {
+    const r = await call("POST", "/wallet/transfer", {
+        key,
+        body: {
+            tokenAddress: params.tokenAddress,
+            recipientAddress: params.recipientAddress,
+            amount: String(params.amount),
+            isNativeToken: params.isNativeToken ?? false,
+            chain: params.chain ?? "base",
+        },
+    });
+    if (!r.txHash)
+        throw new BankrApiError(200, "/wallet/transfer", "no txHash in response");
+    return r.txHash;
+}
+/**
+ * POST /wallet/sign with signatureType "eth_signTypedData_v4" — custodial EIP-712.
+ * `typedData` is the full { domain, types, primaryType, message } struct. Returns the
+ * 0x signature. This is what lets the Bankr wallet sign CYBERDYNE's auth-capture
+ * authorization without exporting a key (see src/bankr-signer.ts).
+ */
+export async function bankrSignTypedData(typedData, key) {
+    const r = await call("POST", "/wallet/sign", {
+        key,
+        body: { signatureType: "eth_signTypedData_v4", typedData },
+    });
+    if (!r.signature?.startsWith("0x"))
+        throw new BankrApiError(200, "/wallet/sign", "no signature in response");
+    return r.signature;
+}
+/** POST /wallet/sign with signatureType "personal_sign". Returns the 0x signature. */
+export async function bankrSignMessage(message, key) {
+    const r = await call("POST", "/wallet/sign", {
+        key,
+        body: { signatureType: "personal_sign", message },
+    });
+    if (!r.signature?.startsWith("0x"))
+        throw new BankrApiError(200, "/wallet/sign", "no signature in response");
+    return r.signature;
+}
+// ── health / discovery ────────────────────────────────────────────────────────
+/** GET /_health — cheap key/liveness probe. Returns true on a 2xx. */
+export async function bankrHealth(key) {
+    try {
+        await call("GET", "/_health", { key });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** GET /tokens/search?query= — public symbol↔address resolver (the one /wallet/transfer uses). */
+export async function bankrSearchTokens(query, chainId) {
+    const params = new URLSearchParams({ query });
+    if (chainId)
+        params.set("chainId", String(chainId));
+    const res = await fetch(`${BANKR_API_URL}/tokens/search?${params}`, {
+        headers: { accept: "application/json", "user-agent": "cyberdyne-mcp" },
+        signal: AbortSignal.timeout(15_000),
+    });
+    const json = (await res.json().catch(() => ({})));
+    if (!res.ok)
+        throw new BankrApiError(res.status, "/tokens/search", "search failed");
+    return Array.isArray(json) ? json : (json.tokens ?? []);
+}
+/** GET /wallet/portfolio — multi-chain balances/holdings (cheap treasury/earnings view). */
+export async function bankrPortfolio(opts = {}, key) {
+    const q = new URLSearchParams();
+    if (opts.chains?.length)
+        q.set("chains", opts.chains.join(","));
+    if (opts.showLowValueTokens)
+        q.set("showLowValueTokens", "true");
+    const qs = q.toString();
+    return call("GET", `/wallet/portfolio${qs ? `?${qs}` : ""}`, { key });
+}
+/**
+ * POST /wallet/x402-pay — pay any x402-priced URL custodially from the Bankr wallet,
+ * Bankr handling the 402 handshake server-side, capped by `maxPaymentUsd`. Useful for an
+ * agent to call a paid discovery/quote endpoint (e.g. CYBERDYNE's x402 Cloud front door)
+ * with one authenticated POST instead of a client-side wallet signature.
+ */
+export async function bankrX402Pay(params, key) {
+    return call("POST", "/wallet/x402-pay", {
+        key,
+        body: { url: params.url, method: params.method ?? "GET", body: params.body, maxPaymentUsd: params.maxPaymentUsd },
+    });
+}
+/**
+ * Headless `bankr login --siwe`: mint a `bk_` key by signing a SIWE message with the
+ * agent's own wallet — zero-browser, no email OTP. Flow (verified against @bankr/cli):
+ *   GET /cli/siwe/nonce → build the SIWE message → personal_sign → POST /cli/siwe/verify.
+ * Mints with Wallet API enabled (so /wallet/* works); Agent API + Token-Launch API stay
+ * OFF (Agent API is separately gated at bankr.bot/api; we never launch tokens). The
+ * private key never leaves this process and is never logged. Defaults the signer to the
+ * onboarded wallet (CYBERDYNE_EVM_PRIVATE_KEY / ~/.cyberdyne config).
+ */
+export async function bankrSiweProvision(opts = {}) {
+    const pk = (opts.privateKey ?? process.env.CYBERDYNE_EVM_PRIVATE_KEY?.trim() ?? readSavedWalletKey() ?? "").trim();
+    if (!pk) {
+        throw new Error("no signing wallet — pass a private key, set CYBERDYNE_EVM_PRIVATE_KEY, or run `cyberdyne-mcp onboard` first");
+    }
+    const { privateKeyToAccount } = await import("viem/accounts");
+    const account = privateKeyToAccount((pk.startsWith("0x") ? pk : `0x${pk}`));
+    const host = new URL(BANKR_API_URL).host;
+    const nonceRes = await fetch(`${BANKR_API_URL}/cli/siwe/nonce`, {
+        headers: { accept: "application/json", "user-agent": "cyberdyne-mcp" },
+        signal: AbortSignal.timeout(20_000),
+    });
+    if (!nonceRes.ok)
+        throw new BankrApiError(nonceRes.status, "/cli/siwe/nonce", "nonce request failed");
+    // The nonce endpoint sets AWS load-balancer stickiness cookies (AWSALB…); the nonce is
+    // instance-local, so /cli/siwe/verify MUST carry them to reach the same backend — without
+    // this it intermittently fails "Nonce expired or already used" depending on LB routing.
+    const cookie = (typeof nonceRes.headers.getSetCookie === "function" ? nonceRes.headers.getSetCookie() : [])
+        .map((c) => c.split(";")[0])
+        .filter(Boolean)
+        .join("; ");
+    const { nonce } = (await nonceRes.json());
+    if (!nonce)
+        throw new BankrApiError(200, "/cli/siwe/nonce", "no nonce in response");
+    const message = [
+        `${host} wants you to sign in with your Ethereum account:`,
+        account.address,
+        "",
+        "Sign in to Bankr",
+        "",
+        `URI: ${BANKR_API_URL}/cli/siwe/verify`,
+        "Version: 1",
+        // Bankr's SIWE verifier expects "Chain ID: 1" — this is the LOGIN signature, not a
+        // transaction; CYBERDYNE settles on Base (8453). Matches @bankr/cli's siwe flow.
+        "Chain ID: 1",
+        `Nonce: ${nonce}`,
+        `Issued At: ${new Date().toISOString()}`,
+    ].join("\n");
+    const signature = await account.signMessage({ message });
+    const verifyRes = await fetch(`${BANKR_API_URL}/cli/siwe/verify`, {
+        method: "POST",
+        headers: {
+            "content-type": "application/json",
+            accept: "application/json",
+            "user-agent": "cyberdyne-mcp",
+            ...(cookie ? { cookie } : {}),
+        },
+        body: JSON.stringify({
+            message,
+            signature,
+            partnerApiKey: opts.partnerKey ?? process.env.CYBERDYNE_BANKR_PARTNER_KEY?.trim(),
+            keyName: opts.keyName ?? `cyberdyne-${new Date().toISOString().slice(0, 10)}`,
+            readOnly: false,
+            walletApiEnabled: opts.walletApiEnabled ?? true,
+            agentApiEnabled: false,
+            tokenLaunchApiEnabled: false,
+            allowedRecipients: opts.allowedRecipients,
+        }),
+        signal: AbortSignal.timeout(30_000),
+    });
+    const j = (await verifyRes.json().catch(() => ({})));
+    if (!verifyRes.ok || !j.apiKey) {
+        throw new BankrApiError(verifyRes.status, "/cli/siwe/verify", String(j.message ?? j.error ?? "verify failed"));
+    }
+    return { apiKey: j.apiKey, walletAddress: j.walletAddress ?? account.address, readOnly: j.readOnly };
+}

package/dist/cli.js

@@ -39,6 +39,10 @@ export function parseFlags(argv) {
     }
     return out;
 }
+/** A flag is "set" when present and not explicitly disabled (bare `--flag` ⇒ "true"). */
+function isFlagSet(v) {
+    return v != null && v !== "false" && v !== "0";
+}
 function client() {
     return new CyberdyneClient(readConfig());
 }
@@ -46,11 +50,6 @@ function hasKey() {
     return !!readConfig().token;
 }
 const NO_KEY = "No CYBERDYNE key saved. Run:  npx -y cyberdyne-mcp onboard";
-/** Format a USD-ish numeric value (handles string/number/null) to 2dp. */
-function usd(v) {
-    const n = typeof v === "number" ? v : Number(v);
-    return Number.isFinite(n) ? `$${n.toFixed(2)}` : "—";
-}
 function fail(msg) {
     console.error(`✗ ${msg}`);
     process.exit(1);
@@ -124,23 +123,47 @@ export async function runPost(argv) {
             console.error(`\n✓ Task ${taskId} is open. Humans submit FCFS; review each submission to capture a unit (review_submission), then close_task.`);
             process.exit(0);
         }
-        // POOL rail — the autonomous `bankr launch` path. Sign the budget with the saved
-        // wallet, pay the separate deploy fee, then authorize. Reuses evm-signer (the
-        // exact logic the authorize_task MCP tool uses).
-        const { hasEvmKey, signAuthCapture, payDeployFee } = await import("./evm-signer.js");
-        if (!hasEvmKey()) {
-            fail("pool rail needs a signing wallet, but none is saved. Run `npx -y cyberdyne-mcp onboard` " +
-                `(the task ${taskId} is posted but not yet funded).`);
-        }
+        // POOL rail — the autonomous `bankr launch` path. Sign the budget, pay the separate
+        // deploy fee, then authorize. Two signers:
+        //   default      — the saved/local wallet (evm-signer.ts, the certified path).
+        //   --bankr-wallet (or env CYBERDYNE_SIGNER=bankr / CYBERDYNE_BANKR_WALLET=1) — fund
+        //     from the agent's Bankr custodial wallet, no key export (bankr-signer.ts, BETA).
+        const bankrMode = isFlagSet(f["bankr-wallet"]) ||
+            /^(1|true|bankr)$/i.test(process.env.CYBERDYNE_SIGNER ?? "") ||
+            process.env.CYBERDYNE_BANKR_WALLET === "1";
         const requirements = res.authIntent.requirements ?? res.authIntent;
-        console.error("→ signing the budget authorization…");
-        const signedPayment = await signAuthCapture(requirements);
         const fee = res.deployFee;
         // `fee.amount` is in the FEE TOKEN's own units; for non-USDC tokens `fee.usd` is the
         // token amount (no oracle), so DON'T render it as a "$" — just show the token amount.
-        console.error(`→ paying the deploy fee (${fee.amount} of ${String(fee.token).slice(0, 10)}…) from your wallet…`);
-        const feeTx = await payDeployFee({ amount: fee.amount, decimals: fee.decimals, recipient: fee.recipient, token: fee.token });
-        console.error(`  ✓ fee paid — ${feeTx}`);
+        const feeLabel = `${fee.amount} of ${String(fee.token).slice(0, 10)}…`;
+        let signedPayment;
+        let feeTx;
+        if (bankrMode) {
+            const { hasBankrSigner, bankrSignAuthCapture, bankrPayDeployFee, bankrSignerAddress } = await import("./bankr-signer.js");
+            if (!hasBankrSigner()) {
+                fail("--bankr-wallet needs a Bankr key. Set CYBERDYNE_BANKR_KEY or BANKR_API_KEY (a bk_… Agent " +
+                    `API key), or put it in ~/.bankr/config.json (the task ${taskId} is posted but not yet funded).`);
+            }
+            const addr = await bankrSignerAddress();
+            console.error(`→ funding from your Bankr wallet ${addr} (no key export)…`);
+            console.error("→ signing the budget authorization via Bankr (/wallet/sign)…");
+            signedPayment = await bankrSignAuthCapture(requirements);
+            console.error(`→ paying the deploy fee (${feeLabel}) via Bankr (/wallet/transfer)…`);
+            feeTx = await bankrPayDeployFee({ amount: fee.amount, recipient: fee.recipient, token: fee.token });
+            console.error(`  ✓ fee paid — ${feeTx}`);
+        }
+        else {
+            const { hasEvmKey, signAuthCapture, payDeployFee } = await import("./evm-signer.js");
+            if (!hasEvmKey()) {
+                fail("pool rail needs a signing wallet, but none is saved. Run `npx -y cyberdyne-mcp onboard` " +
+                    `(the task ${taskId} is posted but not yet funded). Or fund from your Bankr wallet with --bankr-wallet.`);
+            }
+            console.error("→ signing the budget authorization…");
+            signedPayment = await signAuthCapture(requirements);
+            console.error(`→ paying the deploy fee (${feeLabel}) from your wallet…`);
+            feeTx = await payDeployFee({ amount: fee.amount, decimals: fee.decimals, recipient: fee.recipient, token: fee.token });
+            console.error(`  ✓ fee paid — ${feeTx}`);
+        }
         console.error("→ freezing the budget (authorize)…");
         const authed = await c.rest("POST", `/api/tasks/${encodeURIComponent(taskId)}/authorize`, { body: { signedPayment, fee_tx_hash: feeTx } });
         const escrow = authed.task?.escrow_status ?? "held";
@@ -152,6 +175,26 @@ export async function runPost(argv) {
         fail(describe(e));
     }
 }
+// ── launch-and-fund (community loop) ─────────────────────────────────────────
+// Orchestrate the Bankr launch → grow loop: fund an engagement quest IN your own
+// Bankr-launched community token, paid to verified humans. CYBERDYNE NEVER launches a
+// token — you launch yours on Bankr first (e.g. Clanker via the Bankr app/agent), then
+// pass its contract address here. Funds from your Bankr wallet by default (no key export);
+// otherwise identical to `post`. Reuses runPost end-to-end.
+export async function runLaunchAndFund(argv) {
+    const f = parseFlags(argv);
+    const tok = (f.token ?? "").trim();
+    if (!tok) {
+        fail("launch-and-fund needs --token <0xADDRESS | SYMBOL> — the Bankr-launched token to fund the quest in.\n" +
+            "  Launch your community token on Bankr first (e.g. Clanker via the Bankr app/agent), then pass its\n" +
+            "  contract address here. CYBERDYNE never launches a token; it orchestrates funding quests in YOURS.");
+    }
+    console.error("launch-and-fund — funding an engagement quest in your Bankr-launched token, paid to verified humans.");
+    console.error("  (CYBERDYNE does not launch tokens. Launch yours on Bankr first; this funds quests in it.)");
+    // Default to the Bankr-wallet signer (no key export); honor an explicit --bankr-wallet=false.
+    const next = "bankr-wallet" in f ? argv : [...argv, "--bankr-wallet"];
+    await runPost(next);
+}
 // ── tasks ─────────────────────────────────────────────────────────────────
 // List the agent's own posted tasks (GET /api/tasks?mine=posted — works with the
 // agent key). Short: id, title, token, qty, filled/remaining, status.
@@ -187,3 +230,34 @@ export async function runTasks() {
         fail(describe(e));
     }
 }
+// ── bankr-login (headless SIWE → mint a bk_ key) ─────────────────────────────
+// Zero-browser, no email OTP: sign a SIWE message with your onboarded wallet to mint a
+// Bankr `bk_` key (Wallet API enabled), so `post --bankr-wallet` can fund from your Bankr
+// custodial wallet. The key is printed ONCE to stderr (never stored by CYBERDYNE) — set it
+// as CYBERDYNE_BANKR_KEY / BANKR_API_KEY. Agent API access (the /agent/* surface) may still
+// need enabling at bankr.bot/api; Wallet API (/wallet/*) is on by default.
+//   --private-key <0x…>   signer (defaults to the onboarded wallet / CYBERDYNE_EVM_PRIVATE_KEY)
+//   --partner-key <key>   optional X-Partner-Key fee attribution
+//   --key-name <name>     optional label for the minted key
+export async function runBankrLogin(argv) {
+    const f = parseFlags(argv);
+    try {
+        const { bankrSiweProvision } = await import("./bankr.js");
+        console.error("→ minting a Bankr key via headless SIWE (signing with your wallet)…");
+        const r = await bankrSiweProvision({
+            privateKey: isFlagSet(f["private-key"]) ? f["private-key"] : undefined,
+            partnerKey: isFlagSet(f["partner-key"]) ? f["partner-key"] : undefined,
+            keyName: isFlagSet(f["key-name"]) ? f["key-name"] : undefined,
+        });
+        console.error(`✓ Bankr key minted for wallet ${r.walletAddress}${r.readOnly ? " (read-only)" : ""}.\n` +
+            `\n  bk_ key : ${r.apiKey}    ← shown once; CYBERDYNE does NOT store it\n` +
+            "\nSet it so `post --bankr-wallet` / launch-and-fund can use it:\n" +
+            `  export CYBERDYNE_BANKR_KEY=${r.apiKey}\n` +
+            "\nNote: Wallet API (/wallet/*) is enabled by default. If /wallet/* calls 401/403, enable\n" +
+            "Agent/Wallet API access for this key at https://bankr.bot/api (may require Bankr Club).");
+        process.exit(0);
+    }
+    catch (e) {
+        fail(describe(e));
+    }
+}