agenticbtc-mcp 1.0.7 → 1.0.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agenticbtc-mcp",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Privacy-intelligent payments for AI agents — your privacy, your choice. Universal payment router with Lightning, Strike, Coinbase, PayPal, Venmo support.",
   "keywords": [
     "bitcoin",

package/src/server.js

@@ -7,12 +7,62 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { z } from "zod";
+import crypto from "crypto";
 
 const API_URL = process.env.AGENTICBTC_API_URL || process.env.AGENTBTC_API_URL || "http://localhost:8000";
 const API_KEY = process.env.AGENTICBTC_API_KEY || process.env.AGENTBTC_API_KEY || "";
 const LND_HOST = process.env.AGENTBTC_LND_HOST || "";
 const LND_MACAROON = process.env.AGENTBTC_LND_MACAROON || "";
 
+// X (Twitter) credentials — optional, enables social posting tools
+const X_CONSUMER_KEY = process.env.TWITTER_CONSUMER_KEY || "";
+const X_CONSUMER_SECRET = process.env.TWITTER_CONSUMER_SECRET || "";
+const X_ACCESS_TOKEN = process.env.TWITTER_ACCESS_TOKEN || "";
+const X_ACCESS_SECRET = process.env.TWITTER_ACCESS_SECRET || "";
+const X_BEARER_TOKEN = process.env.TWITTER_BEARER_TOKEN || "";
+const X_USER_ID = X_ACCESS_TOKEN ? X_ACCESS_TOKEN.split("-")[0] : "";
+const X_ENABLED = !!(X_CONSUMER_KEY && X_ACCESS_TOKEN);
+
+// OAuth 1.0a helper for X write operations
+function buildXOAuthHeader(method, url) {
+  const timestamp = Math.floor(Date.now() / 1000).toString();
+  const nonce = crypto.randomBytes(16).toString("hex");
+  const oauthParams = {
+    oauth_consumer_key: X_CONSUMER_KEY,
+    oauth_nonce: nonce,
+    oauth_signature_method: "HMAC-SHA1",
+    oauth_timestamp: timestamp,
+    oauth_token: X_ACCESS_TOKEN,
+    oauth_version: "1.0",
+  };
+  const sorted = Object.entries(oauthParams).sort(([a], [b]) => a.localeCompare(b));
+  const paramStr = sorted.map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`).join("&");
+  const baseStr = `${method.toUpperCase()}&${encodeURIComponent(url)}&${encodeURIComponent(paramStr)}`;
+  const signingKey = `${encodeURIComponent(X_CONSUMER_SECRET)}&${encodeURIComponent(X_ACCESS_SECRET)}`;
+  const signature = crypto.createHmac("sha1", signingKey).update(baseStr).digest("base64");
+  return "OAuth " + Object.entries({ ...oauthParams, oauth_signature: signature })
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${encodeURIComponent(k)}="${encodeURIComponent(v)}"`)
+    .join(", ");
+}
+
+async function xPost(endpoint, body) {
+  const url = `https://api.x.com${endpoint}`;
+  const auth = buildXOAuthHeader("POST", url);
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { Authorization: auth, "Content-Type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  return { status: res.status, data: await res.json() };
+}
+
+async function xGet(endpoint) {
+  const url = `https://api.x.com${endpoint}`;
+  const res = await fetch(url, { headers: { Authorization: `Bearer ${X_BEARER_TOKEN}` } });
+  return { status: res.status, data: await res.json() };
+}
+
 // BK Block routing node — all payments route through this node as first hop
 // Routing fee: 0.5% (5000ppm) + 1 sat base
 const BK_BLOCK_NODE_PUBKEY = process.env.BK_BLOCK_NODE_PUBKEY || "031aef3a70c08a6e2d96ba1c78eec66092723cdc41d546329df3f065b0f200bd3b";
@@ -302,87 +352,42 @@ server.tool(
     fee_limit_sats: z.number().optional().default(100).describe("Max fee in sats"),
   },
   async ({ invoice, agent, fee_limit_sats }) => {
-    if (!LND_HOST) {
-      return { content: [{ type: "text", text: "Error: LND node not configured. Set AGENTBTC_LND_HOST environment variable." }] };
-    }
-
-    // Resolve agent for spending policy enforcement
-    let resolvedAgent = null;
-    if (agent) {
-      resolvedAgent = await resolveAgent(agent);
-      if (!resolvedAgent) {
-        return { content: [{ type: "text", text: `Error: Agent '${agent}' not found` }] };
-      }
-      if (!resolvedAgent.enabled) {
-        return { content: [{ type: "text", text: `Error: Agent '${resolvedAgent.name}' is disabled — payments blocked` }] };
-      }
-    }
-
-    // Auto-detect agent from API key auth level
-    if (!resolvedAgent) {
-      const auth = await getAuthLevel();
-      if (auth.agent_id) {
-        resolvedAgent = { id: auth.agent_id, name: auth.agent_name || auth.agent_id };
-      }
-    }
-
     try {
-      // Decode invoice first to get amount for policy check
-      const decodeRes = await fetch(`${LND_HOST}/v1/payreq/${invoice}`, {
-        headers: { "Grpc-Metadata-macaroon": LND_MACAROON },
-      });
-      const decoded = await decodeRes.json();
-      const amountSats = parseInt(decoded.num_satoshis || 0);
-
-      // Check spending policy if agent is identified
-      if (resolvedAgent && amountSats > 0) {
-        const policy = await checkSpendingPolicy(resolvedAgent.id, amountSats);
-        if (!policy.allowed) {
-          return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
-        }
-      }
-
-      // Pay invoice directly via LND REST API
-      const res = await fetch(`${LND_HOST}/v1/channels/transactions`, {
+      // Route through the AgenticBTC payment router (POST /api/v1/payments).
+      // The router enforces spending policy, collects the 0.5% router fee,
+      // performs privacy-aware rail selection, and provides multi-rail failover.
+      // Do NOT call LND directly here.
+      const { status, data } = await apiCall("/api/v1/payments", {
         method: "POST",
-        headers: {
-          "Grpc-Metadata-macaroon": LND_MACAROON,
-          "Content-Type": "application/json",
-        },
         body: JSON.stringify({
-          payment_request: invoice,
-          fee_limit: { fixed: fee_limit_sats },
+          invoice,
+          fee_limit_sats: fee_limit_sats ?? 100,
+          // Pass agent hint in metadata so the server can scope logging
+          ...(agent ? { agent_hint: agent } : {}),
         }),
       });
-      const data = await res.json();
-
-      if (res.ok && !data.payment_error) {
-        const paidAmount = parseInt(data.value || data.value_sat || amountSats || 0);
-        
-        // Log transaction against agent
-        if (resolvedAgent) {
-          await logTransaction(resolvedAgent.id, paidAmount, decoded.destination || "", decoded.description || "", "completed");
-        }
 
+      if (status === 200 && data.success) {
         return {
           content: [{
             type: "text",
             text: JSON.stringify({
               success: true,
-              payment_hash: data.payment_hash,
-              amount_sats: paidAmount,
-              fee_sats: parseInt(data.fee || data.fee_sat || 0),
-              agent: resolvedAgent?.name || null,
+              payment_hash: data.payment_hash || data.payment_id,
+              amount_sats: data.amount_sats,
+              fee_sats: data.fee_sats,
+              rail: data.rail,
               status: data.status || "SUCCEEDED",
-              message: `Paid ${paidAmount} sats ⚡`,
+              message: `Paid ${data.amount_sats} sats via router (${data.rail || "lightning"}) ⚡`,
             }, null, 2),
           }],
         };
       }
-      const errMsg = data.payment_error || data.message || JSON.stringify(data);
+
+      const errMsg = data?.detail || data?.error || data?.message || JSON.stringify(data);
       return { content: [{ type: "text", text: `Payment failed: ${errMsg}` }] };
     } catch (e) {
-      return { content: [{ type: "text", text: `LND connection error: ${e.message}` }] };
+      return { content: [{ type: "text", text: `Router connection error: ${e.message}` }] };
     }
   }
 );
@@ -425,14 +430,13 @@ server.tool(
     const macaroon = data.macaroon;
     const amount = data.amount || 0;
 
-    if (!invoice || !LND_HOST) {
+    if (!invoice) {
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
             success: false,
-            error: "Need LND node configured to pay invoice",
-            invoice,
+            error: "No invoice returned from L402 challenge — cannot pay",
             amount,
           }, null, 2),
         }],
@@ -442,31 +446,29 @@ server.tool(
     // Check routing status before paying
     const routingStatus = await checkRoutingStatus();
     if (routingStatus === "suspended") {
-      return { content: [{ type: "text", text: "⛔ Account suspended — routing verification failed. Contact support." }] };
+      return { content: [{ type: "text", text: "Account suspended — routing verification failed. Contact support." }] };
     }
 
-    // Force routing through BK Block node as first hop
-    const payRes = await fetch(`${LND_HOST}/v1/channels/transactions`, {
+    // Pay the L402 invoice via the AgenticBTC payment router (NOT directly via LND).
+    // The router collects the 0.5% fee, applies privacy-aware rail selection, and
+    // provides multi-rail failover.
+    const { status: payStatus, data: payData } = await apiCall("/api/v1/payments", {
       method: "POST",
-      headers: {
-        "Grpc-Metadata-macaroon": LND_MACAROON,
-        "Content-Type": "application/json",
-      },
       body: JSON.stringify({
-        payment_request: invoice,
-        outgoing_chan_id: "",  // LND will use available channels
-        fee_limit: { fixed: 5000 },  // Allow routing fees
+        invoice,
+        fee_limit_sats: 5000,
       }),
     });
-    const payData = await payRes.json();
 
-    if (payData.payment_error) {
-      return { content: [{ type: "text", text: `Lightning payment failed: ${payData.payment_error}` }] };
+    if (payStatus !== 200 || !payData.success) {
+      const errMsg = payData?.detail || payData?.error || payData?.payment_error || JSON.stringify(payData);
+      return { content: [{ type: "text", text: `Lightning payment failed: ${errMsg}` }] };
     }
 
-    const preimage = payData.payment_preimage;
+    const preimage = payData.preimage || payData.payment_preimage;
     if (!preimage) {
-      return { content: [{ type: "text", text: "No preimage returned from payment" }] };
+      // Payment succeeded at router level but no preimage returned — report best-effort
+      return { content: [{ type: "text", text: "Payment succeeded but no preimage returned from router. L402 access may require preimage — check router logs." }] };
     }
 
     // Step 3: Access with L402 token
@@ -479,22 +481,16 @@ server.tool(
 
     if (authRes.status === 200) {
       const authData = await authRes.json();
-      // Report L402 payment for routing verification
-      await reportPayment(
-        payData.payment_hash || "",
-        amount,
-        "",
-        [BK_BLOCK_NODE_PUBKEY]
-      );
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
             success: true,
             data: authData,
-            amount_paid_sats: amount,
+            amount_paid_sats: payData.amount_sats || amount,
             payment_preimage: preimage,
-            message: `Paid ${amount} sats ⚡ for ${endpoint} API access`,
+            rail: payData.rail,
+            message: `Paid ${payData.amount_sats || amount} sats via router for ${endpoint} API access`,
           }, null, 2),
         }],
       };
@@ -680,9 +676,9 @@ server.tool(
     comment: z.string().optional().default("").describe("Optional comment for the recipient"),
   },
   async ({ address, amount_sats, agent, comment }) => {
-    if (!LND_HOST) {
-      return { content: [{ type: "text", text: "Error: LND node not configured." }] };
-    }
+    // No LND_HOST check needed — payment routes through the AgenticBTC REST API router.
+    // LNURL resolution (steps 1 & 2 below) is external HTTP; only step 3 (the payment)
+    // has changed to go through POST /api/v1/payments instead of directly to LND.
 
     // Resolve agent for spending policy
     let resolvedAgent = null;
@@ -739,25 +735,18 @@ server.tool(
         return { content: [{ type: "text", text: `Error: No invoice returned from ${domain}` }] };
       }
 
-      // Step 3: Pay the invoice via LND
-      const payRes = await fetch(`${LND_HOST}/v1/channels/transactions`, {
+      // Step 3: Pay the invoice via the AgenticBTC payment router (NOT directly via LND).
+      // This ensures the 0.5% router fee is collected, privacy-aware rail selection is
+      // applied, and multi-rail failover is available.
+      const { status: payStatus, data: payData } = await apiCall("/api/v1/payments", {
         method: "POST",
-        headers: {
-          "Grpc-Metadata-macaroon": LND_MACAROON,
-          "Content-Type": "application/json",
-        },
         body: JSON.stringify({
-          payment_request: invoiceData.pr,
-          fee_limit: { fixed: Math.max(100, Math.floor(amount_sats * 0.01)) },
+          invoice: invoiceData.pr,
+          fee_limit_sats: Math.max(100, Math.floor(amount_sats * 0.01)),
         }),
       });
-      const payData = await payRes.json();
 
-      if (payRes.ok && !payData.payment_error) {
-        // Log transaction
-        if (resolvedAgent) {
-          await logTransaction(resolvedAgent.id, amount_sats, address, comment || `Lightning address payment to ${address}`, "completed");
-        }
+      if (payStatus === 200 && payData.success) {
         return {
           content: [{
             type: "text",
@@ -765,21 +754,124 @@ server.tool(
               success: true,
               recipient: address,
               amount_sats: amount_sats,
-              fee_sats: parseInt(payData.fee || payData.fee_sat || 0),
+              fee_sats: payData.fee_sats || 0,
+              rail: payData.rail,
               agent: resolvedAgent?.name || null,
-              payment_hash: payData.payment_hash,
-              message: `Sent ${amount_sats} sats to ${address} ⚡`,
+              payment_hash: payData.payment_hash || payData.payment_id,
+              message: `Sent ${amount_sats} sats to ${address} via router ⚡`,
             }, null, 2),
           }],
         };
       }
-      return { content: [{ type: "text", text: `Payment failed: ${payData.payment_error || JSON.stringify(payData)}` }] };
+      const errMsg = payData?.detail || payData?.error || payData?.payment_error || JSON.stringify(payData);
+      return { content: [{ type: "text", text: `Payment failed: ${errMsg}` }] };
     } catch (e) {
       return { content: [{ type: "text", text: `Error: ${e.message}` }] };
     }
   }
 );
 
+// Tool: Universal send_payment — auto-detects recipient type
+server.tool(
+  "send_payment",
+  "Send a payment to any recipient. Automatically detects recipient type: BOLT11 Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username). Routes through the optimal payment rail.",
+  {
+    recipient: z.string().describe("Where to send: Lightning invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username)"),
+    amount_sats: z.number().optional().describe("Amount in satoshis (required for Lightning address and Strike handle; optional for BOLT11 invoices which encode the amount)"),
+    amount_usd: z.number().optional().describe("Amount in USD (for Strike handle payments; alternative to amount_sats)"),
+    memo: z.string().optional().default("").describe("Optional payment memo or comment"),
+    agent: z.string().optional().describe("Agent wallet name or ID for spending policy enforcement"),
+  },
+  async ({ recipient, amount_sats, amount_usd, memo, agent }) => {
+    // Detect recipient type
+    const isBolt11 = /^lnbc|^lntb|^lnbcrt/i.test(recipient);
+    const isStrikeHandle = recipient.startsWith("$");
+    const isLightningAddress = !isBolt11 && !isStrikeHandle && recipient.includes("@");
+
+    // Resolve agent for spending policy
+    let resolvedAgent = null;
+    if (agent) {
+      resolvedAgent = await resolveAgent(agent);
+      if (!resolvedAgent) return { content: [{ type: "text", text: `Error: Agent '${agent}' not found` }] };
+      if (!resolvedAgent.enabled) return { content: [{ type: "text", text: `Error: Agent '${resolvedAgent.name}' is disabled` }] };
+    }
+    if (!resolvedAgent) {
+      const auth = await getAuthLevel();
+      if (auth.agent_id) resolvedAgent = { id: auth.agent_id, name: auth.agent_name || auth.agent_id };
+    }
+
+    if (isBolt11) {
+      // Delegate to router via pay_lightning_invoice logic
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats || 0);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: recipient, fee_limit_sats: 100 }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_invoice", amount_sats: data.amount_sats, fee_sats: data.fee_sats || 0, rail: data.rail, payment_hash: data.payment_hash }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isLightningAddress) {
+      if (!amount_sats) return { content: [{ type: "text", text: "Error: amount_sats required for Lightning address payments" }] };
+      if (resolvedAgent) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      // LNURL resolve → pay via router
+      const [user, domain] = recipient.split("@");
+      const lnurlRes = await fetch(`https://${domain}/.well-known/lnurlp/${user}`);
+      if (!lnurlRes.ok) return { content: [{ type: "text", text: `Error: Could not resolve Lightning address ${recipient}` }] };
+      const lnurlData = await lnurlRes.json();
+      const minSats = Math.ceil((lnurlData.minSendable || 1000) / 1000);
+      const maxSats = Math.floor((lnurlData.maxSendable || 100000000000) / 1000);
+      if (amount_sats < minSats || amount_sats > maxSats) {
+        return { content: [{ type: "text", text: `Error: Amount must be between ${minSats} and ${maxSats} sats for this address` }] };
+      }
+      let callbackUrl = `${lnurlData.callback}${lnurlData.callback.includes("?") ? "&" : "?"}amount=${amount_sats * 1000}`;
+      if (memo && lnurlData.commentAllowed) callbackUrl += `&comment=${encodeURIComponent(memo)}`;
+      const invoiceRes = await fetch(callbackUrl);
+      if (!invoiceRes.ok) return { content: [{ type: "text", text: `Error: Failed to get invoice from ${domain}` }] };
+      const invoiceData = await invoiceRes.json();
+      if (!invoiceData.pr) return { content: [{ type: "text", text: `Error: No invoice returned from ${domain}` }] };
+      const { status, data } = await apiCall("/api/v1/payments", {
+        method: "POST",
+        body: JSON.stringify({ invoice: invoiceData.pr, fee_limit_sats: Math.max(100, Math.floor(amount_sats * 0.01)) }),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "lightning_address", recipient, amount_sats, fee_sats: data.fee_sats || 0, payment_hash: data.payment_hash, message: `Sent ${amount_sats} sats to ${recipient} ⚡` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else if (isStrikeHandle) {
+      const handle = recipient.slice(1); // strip "$"
+      if (!amount_usd && !amount_sats) return { content: [{ type: "text", text: "Error: amount_usd or amount_sats required for Strike payments" }] };
+      if (resolvedAgent && amount_sats) {
+        const policy = await checkSpendingPolicy(resolvedAgent.id, amount_sats);
+        if (!policy.allowed) return { content: [{ type: "text", text: `Payment blocked: ${policy.reason}` }] };
+      }
+      const body = { handle, description: memo || `Payment to $${handle}` };
+      if (amount_usd) body.amount_usd = amount_usd;
+      if (amount_sats) body.amount_sats = amount_sats;
+      if (resolvedAgent) body.agent_id = resolvedAgent.id;
+      const { status, data } = await apiCall("/api/v1/strike/pay", {
+        method: "POST",
+        body: JSON.stringify(body),
+      });
+      if (status === 200 && data.success) {
+        return { content: [{ type: "text", text: JSON.stringify({ success: true, type: "strike_handle", recipient, amount_usd: data.amount_usd, fee_usd: data.fee_usd || 0, payment_id: data.payment_id, message: `Sent to ${recipient} via Strike 💸` }) }] };
+      }
+      return { content: [{ type: "text", text: `Payment failed: ${data?.detail || data?.error || JSON.stringify(data)}` }] };
+
+    } else {
+      return { content: [{ type: "text", text: `Error: Unrecognized recipient format. Use a BOLT11 invoice (lnbc.../lntb...), Lightning address (user@domain.com), or Strike handle ($username).` }] };
+    }
+  }
+);
+
 // Tool: Decode Lightning invoice
 server.tool(
   "decode_invoice",
@@ -788,43 +880,37 @@ server.tool(
     invoice: z.string().describe("BOLT11 Lightning invoice to decode"),
   },
   async ({ invoice }) => {
-    if (!LND_HOST) {
-      return { content: [{ type: "text", text: "Error: LND node not configured." }] };
-    }
+    // Route through the AgenticBTC REST API (POST /api/v1/decode) instead of calling
+    // LND directly, so the server-side LND credentials are used and no client-side
+    // LND config is required.
     try {
-      const res = await fetch(`${LND_HOST}/v1/payreq/${invoice}`, {
-        headers: { "Grpc-Metadata-macaroon": LND_MACAROON },
+      const { status, data } = await apiCall("/api/v1/decode", {
+        method: "POST",
+        body: JSON.stringify({ invoice }),
       });
-      const data = await res.json();
 
-      if (!res.ok) {
-        return { content: [{ type: "text", text: `Error decoding invoice: ${JSON.stringify(data)}` }] };
+      if (status !== 200 || !data.success) {
+        const errMsg = data?.detail || data?.error || JSON.stringify(data);
+        return { content: [{ type: "text", text: `Error decoding invoice: ${errMsg}` }] };
       }
 
-      const expiry = parseInt(data.expiry || 3600);
-      const timestamp = parseInt(data.timestamp || 0);
-      const expiresAt = new Date((timestamp + expiry) * 1000).toISOString();
-      const isExpired = Date.now() > (timestamp + expiry) * 1000;
-
       return {
         content: [{
           type: "text",
           text: JSON.stringify({
             success: true,
-            amount_sats: parseInt(data.num_satoshis || 0),
+            amount_sats: data.amount_sats,
             destination: data.destination,
             description: data.description || "",
             payment_hash: data.payment_hash,
-            timestamp: new Date(timestamp * 1000).toISOString(),
-            expires_at: expiresAt,
-            is_expired: isExpired,
-            cltv_expiry: parseInt(data.cltv_expiry || 0),
-            num_route_hints: (data.route_hints || []).length,
+            expires_at: data.expires_at ? new Date(data.expires_at * 1000).toISOString() : null,
+            is_expired: data.is_expired,
+            cltv_expiry: data.cltv_expiry,
           }, null, 2),
         }],
       };
     } catch (e) {
-      return { content: [{ type: "text", text: `LND error: ${e.message}` }] };
+      return { content: [{ type: "text", text: `Router error: ${e.message}` }] };
     }
   }
 );
@@ -1388,6 +1474,114 @@ server.tool(
   }
 );
 
+// ─── X (Twitter) Tools ────────────────────────────────────────────────────────
+
+server.tool(
+  "post_tweet",
+  "Post a tweet from @agentbtcio. Use for announcing launches, updates, or responding to relevant discussions. Keep under 280 chars.",
+  {
+    text: z.string().max(280).describe("Tweet text (max 280 characters)"),
+    reply_to_tweet_id: z.string().optional().describe("Tweet ID to reply to (optional)"),
+  },
+  async ({ text, reply_to_tweet_id }) => {
+    if (!X_ENABLED) {
+      return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "X credentials not configured. Set TWITTER_CONSUMER_KEY, TWITTER_CONSUMER_SECRET, TWITTER_ACCESS_TOKEN, TWITTER_ACCESS_SECRET in Claude Desktop config." }) }] };
+    }
+    const body = { text };
+    if (reply_to_tweet_id) body.reply = { in_reply_to_tweet_id: reply_to_tweet_id };
+    const { status, data } = await xPost("/2/tweets", body);
+    if (status === 201) {
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, tweet_id: data.data.id, url: `https://x.com/agentbtcio/status/${data.data.id}`, text }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ success: false, error: data.detail || data.title || "Post failed", status }) }] };
+  }
+);
+
+server.tool(
+  "get_mentions",
+  "Get recent @mentions and replies to @agentbtcio. Use to monitor engagement and find conversations to join.",
+  {
+    limit: z.number().int().min(1).max(20).default(10).describe("Number of recent mentions to fetch (max 20)"),
+  },
+  async ({ limit }) => {
+    if (!X_BEARER_TOKEN || !X_USER_ID) {
+      return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "X bearer token or user ID not configured." }) }] };
+    }
+    const { status, data } = await xGet(
+      `/2/users/${X_USER_ID}/mentions?max_results=${limit}&tweet.fields=created_at,author_id,conversation_id&expansions=author_id&user.fields=username`
+    );
+    if (status === 200) {
+      const users = Object.fromEntries((data.includes?.users || []).map(u => [u.id, u.username]));
+      const mentions = (data.data || []).map(t => ({
+        id: t.id,
+        text: t.text,
+        from: "@" + (users[t.author_id] || t.author_id),
+        created_at: t.created_at,
+        url: `https://x.com/i/status/${t.id}`,
+      }));
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, count: mentions.length, mentions }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ success: false, error: data.title || "Failed to fetch mentions", status }) }] };
+  }
+);
+
+server.tool(
+  "search_x",
+  "Search recent X posts by keyword. Use to find conversations about AI agents, Lightning Network, Bitcoin payments, or AgenticBTC.",
+  {
+    query: z.string().describe("Search query (e.g. 'AI agents Lightning payments', 'agenticbtc', 'MCP tools bitcoin')"),
+    limit: z.number().int().min(1).max(20).default(10).describe("Number of results (max 20)"),
+  },
+  async ({ query, limit }) => {
+    if (!X_BEARER_TOKEN) {
+      return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "X bearer token not configured." }) }] };
+    }
+    const params = new URLSearchParams({ query: `${query} -is:retweet lang:en`, max_results: limit, "tweet.fields": "created_at,author_id", expansions: "author_id", "user.fields": "username" });
+    const { status, data } = await xGet(`/2/tweets/search/recent?${params}`);
+    if (status === 200) {
+      const users = Object.fromEntries((data.includes?.users || []).map(u => [u.id, u.username]));
+      const tweets = (data.data || []).map(t => ({
+        id: t.id,
+        text: t.text,
+        from: "@" + (users[t.author_id] || t.author_id),
+        created_at: t.created_at,
+        url: `https://x.com/i/status/${t.id}`,
+      }));
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, query, count: tweets.length, tweets }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ success: false, error: data.title || "Search failed", status }) }] };
+  }
+);
+
+server.tool(
+  "get_own_timeline",
+  "Get recent tweets posted by @agentbtcio. Use to review posting history before drafting new content.",
+  {
+    limit: z.number().int().min(1).max(20).default(10).describe("Number of recent tweets to fetch"),
+  },
+  async ({ limit }) => {
+    if (!X_BEARER_TOKEN || !X_USER_ID) {
+      return { content: [{ type: "text", text: JSON.stringify({ success: false, error: "X credentials not configured." }) }] };
+    }
+    const { status, data } = await xGet(
+      `/2/users/${X_USER_ID}/tweets?max_results=${limit}&tweet.fields=created_at,public_metrics&exclude=retweets,replies`
+    );
+    if (status === 200) {
+      const tweets = (data.data || []).map(t => ({
+        id: t.id,
+        text: t.text,
+        created_at: t.created_at,
+        likes: t.public_metrics?.like_count || 0,
+        retweets: t.public_metrics?.retweet_count || 0,
+        replies: t.public_metrics?.reply_count || 0,
+        url: `https://x.com/agentbtcio/status/${t.id}`,
+      }));
+      return { content: [{ type: "text", text: JSON.stringify({ success: true, count: tweets.length, tweets }) }] };
+    }
+    return { content: [{ type: "text", text: JSON.stringify({ success: false, error: data.title || "Failed to fetch timeline", status }) }] };
+  }
+);
+
 // Start server
 const transport = new StdioServerTransport();
 await server.connect(transport);