ping-mcp-server 0.1.0

package/dist/index.js

@@ -0,0 +1,1534 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import * as http from "http";
+import { exec } from "child_process";
+var API_BASE_URL = process.env.PING_API_URL || "https://api.ping-money.com";
+var CONFIG_DIR = path.join(os.homedir(), ".ping");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var OAUTH_CALLBACK_PORT = 9876;
+function loadConfig() {
+  try {
+    if (fs.existsSync(CONFIG_FILE)) {
+      const data = fs.readFileSync(CONFIG_FILE, "utf-8");
+      return JSON.parse(data);
+    }
+  } catch (error) {
+    console.error("Failed to load config:", error);
+  }
+  return {};
+}
+function saveConfig(config) {
+  try {
+    if (!fs.existsSync(CONFIG_DIR)) {
+      fs.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+  } catch (error) {
+    console.error("Failed to save config:", error);
+  }
+}
+function getWalletAddress() {
+  if (process.env.PING_WALLET_ADDRESS) {
+    return process.env.PING_WALLET_ADDRESS;
+  }
+  const config = loadConfig();
+  return config.walletAddress || null;
+}
+function setWalletAddress(address) {
+  const config = loadConfig();
+  config.walletAddress = address;
+  saveConfig(config);
+}
+function getAuth() {
+  const config = loadConfig();
+  if (config.authToken && config.githubHandle) {
+    return {
+      token: config.authToken,
+      handle: config.githubHandle,
+      githubId: config.githubId || ""
+    };
+  }
+  return null;
+}
+function setAuth(token, handle, githubId) {
+  const config = loadConfig();
+  config.authToken = token;
+  config.githubHandle = handle;
+  config.githubId = githubId;
+  saveConfig(config);
+}
+function clearAuth() {
+  const config = loadConfig();
+  delete config.authToken;
+  delete config.githubHandle;
+  delete config.githubId;
+  delete config.serverWalletAddress;
+  saveConfig(config);
+}
+function generateSuggestedAnswers(questionText, category) {
+  const lowerQuestion = questionText.toLowerCase();
+  if (lowerQuestion.includes("coffee") && lowerQuestion.includes("tea")) {
+    return [
+      "\u2615 Coffee - the ritual of brewing helps me transition into focus mode",
+      "\u{1F375} Tea - gentler caffeine curve keeps me productive without the jitters"
+    ];
+  }
+  if (lowerQuestion.includes("tabs") && lowerQuestion.includes("spaces")) {
+    return [
+      "\u21E5 Tabs - semantic indentation that respects everyone's display preferences",
+      "\u2423 Spaces - consistent rendering everywhere, no surprises in diffs"
+    ];
+  }
+  if (lowerQuestion.includes("dark") && lowerQuestion.includes("light") || (lowerQuestion.includes("dark mode") || lowerQuestion.includes("light mode"))) {
+    return [
+      "\u{1F319} Dark mode - easier on the eyes during long coding sessions",
+      "\u2600\uFE0F Light mode - better contrast and readability in well-lit environments"
+    ];
+  }
+  if (lowerQuestion.includes("vim") && lowerQuestion.includes("emacs")) {
+    return [
+      "\u2328\uFE0F Vim - modal editing becomes second nature and is available everywhere",
+      "\u{1F527} Emacs - extensibility lets you build your perfect environment over time"
+    ];
+  }
+  if (lowerQuestion.includes("programming language") || lowerQuestion.includes("favorite language") || lowerQuestion.includes("language") && lowerQuestion.includes("why")) {
+    return [
+      "\u{1F980} Rust - memory safety without garbage collection changes how you think about code",
+      "\u{1F40D} Python - readable syntax and vast ecosystem make it perfect for rapid prototyping",
+      "\u{1F4DC} TypeScript - type safety in JavaScript land catches bugs before runtime"
+    ];
+  }
+  if (lowerQuestion.includes("debug") || lowerQuestion.includes("debugging")) {
+    return [
+      "\u{1F50D} Rubber duck debugging - explaining the problem out loud often reveals the solution",
+      "\u{1F4DD} Add logging and narrow down - binary search through the code to isolate the bug",
+      "\u{1F4A4} Take a break - fresh eyes after sleep have solved more bugs than caffeine"
+    ];
+  }
+  if (lowerQuestion.includes("habit") || lowerQuestion.includes("wish") && lowerQuestion.includes("earlier")) {
+    return [
+      "\u2705 Writing tests first - TDD catches bugs before they exist and improves design",
+      "\u{1F4D6} Reading documentation thoroughly - saves hours of trial and error",
+      "\u{1F504} Committing small and often - easier to debug and review"
+    ];
+  }
+  if (lowerQuestion.includes("feature") || lowerQuestion.includes("better") || lowerQuestion.includes("improve")) {
+    return [
+      "\u{1F504} Better context persistence - remembering what we worked on across sessions",
+      "\u26A1 Faster response times - reduced latency for interactive workflows",
+      "\u{1F3AF} Smarter suggestions - learning from my coding patterns over time"
+    ];
+  }
+  if (lowerQuestion.includes("adopt") || lowerQuestion.includes("mass-adopt") || lowerQuestion.includes("everyone") && lowerQuestion.includes("use")) {
+    return [
+      "\u{1F510} Passkeys - passwordless auth that's both more secure and more convenient",
+      "\u{1F4E6} WebAssembly - near-native performance in browsers opens new possibilities",
+      "\u{1F310} IPv6 - we've needed this for decades, let's finally make the switch"
+    ];
+  }
+  if (lowerQuestion.includes("favorite") && (lowerQuestion.includes("tool") || lowerQuestion.includes("dev"))) {
+    return [
+      "\u{1F4BB} VS Code with Vim keybindings - the perfect balance of power and accessibility",
+      "\u2328\uFE0F The terminal - nothing beats the efficiency of CLI tools once you learn them"
+    ];
+  }
+  if (lowerQuestion.includes("underrated") || lowerQuestion.includes("overlooked")) {
+    return [
+      "\u{1F4DD} Documentation as code - treating docs with the same rigor as production code pays dividends",
+      "\u26A1 Keyboard shortcuts - investing time to learn them compounds into massive productivity gains"
+    ];
+  }
+  if (lowerQuestion.includes("ai") || lowerQuestion.includes("claude") || lowerQuestion.includes("llm")) {
+    return [
+      "\u{1F50D} Code review and explanation - AI helps me understand unfamiliar codebases quickly",
+      "\u{1F4AD} Brainstorming and rubber-duck debugging - talking through problems with AI surfaces solutions"
+    ];
+  }
+  if (lowerQuestion.includes("productive") || lowerQuestion.includes("efficient") || lowerQuestion.includes("workflow")) {
+    return [
+      "\u23F0 Timeboxing tasks and taking regular breaks - sustainable focus beats marathon sessions",
+      "\u{1F916} Automating repetitive tasks - every minute spent on automation saves hours later"
+    ];
+  }
+  if (lowerQuestion.includes("learn") || lowerQuestion.includes("advice") || lowerQuestion.includes("tip")) {
+    return [
+      "\u{1F6E0}\uFE0F Build projects that solve your own problems - motivation and learning compound together",
+      "\u{1F4D6} Read other people's code - understanding different approaches expands your toolkit"
+    ];
+  }
+  if (lowerQuestion.includes("challenge") || lowerQuestion.includes("difficult") || lowerQuestion.includes("hard")) {
+    return [
+      '\u{1F680} Balancing perfection with shipping - knowing when "good enough" is actually good enough',
+      "\u{1F4DA} Staying current with rapidly evolving tech while maintaining deep expertise in fundamentals"
+    ];
+  }
+  if (lowerQuestion.includes("best") || lowerQuestion.includes("recommend")) {
+    return [
+      "\u{1F3AF} Start simple and iterate - premature optimization is the root of all evil",
+      "\u2705 Write tests for the critical paths first - 80% confidence from 20% coverage"
+    ];
+  }
+  if (lowerQuestion.includes("build next") || lowerQuestion.includes("should build")) {
+    return [
+      "\u{1F4CA} Analytics dashboard - see which questions get the best answers",
+      "\u{1F514} Notifications - get alerted when someone answers your question",
+      "\u{1F3C6} Leaderboards - gamify the experience with top earners"
+    ];
+  }
+  switch (category) {
+    case "tech":
+      return [
+        "\u{1F3D7}\uFE0F Focus on fundamentals over frameworks - languages and patterns transfer, libraries don't",
+        "\u{1F527} Invest in understanding your tools deeply - surface-level knowledge hits walls quickly"
+      ];
+    case "lifestyle":
+      return [
+        "\u{1F4AA} Protect your health - no amount of career success is worth burning out for",
+        "\u{1F91D} Build relationships outside of work - diverse perspectives make you a better problem solver"
+      ];
+    case "career":
+      return [
+        "\u{1F3AF} Solve real problems, not hypothetical ones - impact speaks louder than credentials",
+        "\u{1F465} Find mentors and be a mentor - teaching solidifies your own understanding"
+      ];
+    default:
+      return [
+        "\u{1F914} It depends on context - there's rarely one right answer in software",
+        "\u2728 The best solution is often the simplest one that actually works"
+      ];
+  }
+}
+function openBrowser(url) {
+  return new Promise((resolve, reject) => {
+    const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "${url}"` : `xdg-open "${url}"`;
+    exec(command, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+}
+function waitForOAuthCallback() {
+  return new Promise((resolve, reject) => {
+    const server2 = http.createServer((req, res) => {
+      const url = new URL(req.url || "", `http://localhost:${OAUTH_CALLBACK_PORT}`);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        const handle = url.searchParams.get("handle");
+        const githubId = url.searchParams.get("github_id");
+        res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        res.end(`
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <meta charset="UTF-8">
+            <title>Login Complete - Ping</title>
+            <style>
+              body {
+                font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+                background: linear-gradient(135deg, #1a1a2e 0%, #16213e 100%);
+                min-height: 100vh;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                color: white;
+                margin: 0;
+              }
+              .container {
+                text-align: center;
+                padding: 40px;
+                background: rgba(255,255,255,0.05);
+                border-radius: 16px;
+                border: 1px solid rgba(255,255,255,0.1);
+              }
+              .logo { font-size: 48px; margin-bottom: 16px; }
+              h1 { margin-bottom: 8px; color: #4ade80; }
+              p { color: #888; }
+            </style>
+          </head>
+          <body>
+            <div class="container">
+              <div class="logo">\u{1F3D3}</div>
+              <h1>\u2713 Login Complete!</h1>
+              <p>You can close this window and return to Claude Code.</p>
+            </div>
+          </body>
+          </html>
+        `);
+        server2.close();
+        if (token && handle) {
+          resolve({ token, handle, githubId: githubId || "" });
+        } else {
+          reject(new Error("Missing token or handle in callback"));
+        }
+      } else {
+        res.writeHead(404);
+        res.end("Not found");
+      }
+    });
+    const timeout = setTimeout(() => {
+      server2.close();
+      reject(new Error("Login timed out. Please try again."));
+    }, 5 * 60 * 1e3);
+    server2.on("close", () => clearTimeout(timeout));
+    server2.listen(OAUTH_CALLBACK_PORT, () => {
+      console.error(`OAuth callback server listening on port ${OAUTH_CALLBACK_PORT}`);
+    });
+    server2.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(new Error(`Port ${OAUTH_CALLBACK_PORT} is already in use. Please close any other login attempts and try again.`));
+      } else {
+        reject(err);
+      }
+    });
+  });
+}
+var PingError = class extends Error {
+  code;
+  hint;
+  constructor(code, message, hint) {
+    super(message);
+    this.name = "PingError";
+    this.code = code;
+    this.hint = hint;
+  }
+};
+function formatErrorResponse(error) {
+  if (error instanceof PingError) {
+    return {
+      success: false,
+      error: error.message,
+      code: error.code,
+      hint: error.hint
+    };
+  }
+  if (error instanceof Error) {
+    if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED") || error.message.includes("ENOTFOUND") || error.message.includes("network") || error.message.includes("ETIMEDOUT")) {
+      return {
+        success: false,
+        error: "Cannot connect to Ping API. Check your internet connection.",
+        code: "NETWORK_ERROR" /* NETWORK_ERROR */,
+        hint: "Make sure you have an active internet connection and try again."
+      };
+    }
+    return {
+      success: false,
+      error: error.message
+    };
+  }
+  return {
+    success: false,
+    error: "An unexpected error occurred. Please try again.",
+    code: "UNKNOWN" /* UNKNOWN */
+  };
+}
+function getErrorFromStatus(status, responseBody) {
+  const serverMessage = responseBody?.error || responseBody?.message;
+  switch (status) {
+    case 401:
+      return new PingError(
+        "AUTH_REQUIRED" /* AUTH_REQUIRED */,
+        "Not logged in. Run ping_login first.",
+        "Use ping_login to connect your GitHub account."
+      );
+    case 403:
+      if (serverMessage?.toLowerCase().includes("expired")) {
+        return new PingError(
+          "AUTH_EXPIRED" /* AUTH_EXPIRED */,
+          "Your session has expired. Please log in again.",
+          "Use ping_logout then ping_login to refresh your session."
+        );
+      }
+      return new PingError(
+        "AUTH_REQUIRED" /* AUTH_REQUIRED */,
+        serverMessage || "Access denied. You may need to log in again.",
+        "Use ping_login to connect your GitHub account."
+      );
+    case 404:
+      return new PingError(
+        "NOT_FOUND" /* NOT_FOUND */,
+        serverMessage || "The requested resource was not found.",
+        "Double-check the ID and try again."
+      );
+    case 429:
+      return new PingError(
+        "RATE_LIMITED" /* RATE_LIMITED */,
+        "Too many requests. Please wait a moment and try again.",
+        "The API has rate limits to prevent abuse. Wait 30 seconds before retrying."
+      );
+    case 400:
+      return new PingError(
+        "INVALID_INPUT" /* INVALID_INPUT */,
+        serverMessage || "Invalid request. Please check your input.",
+        "Review the parameters and try again."
+      );
+    case 402:
+      return new PingError(
+        "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */,
+        serverMessage || "Insufficient funds for this operation.",
+        "Use ping_deposit to add funds to your account."
+      );
+    case 500:
+    case 502:
+    case 503:
+    case 504:
+      return new PingError(
+        "SERVER_ERROR" /* SERVER_ERROR */,
+        "Ping API is temporarily unavailable. Please try again later.",
+        "This is usually temporary. Wait a few minutes and retry."
+      );
+    default:
+      return new PingError(
+        "UNKNOWN" /* UNKNOWN */,
+        serverMessage || `API error (status ${status}). Please try again.`,
+        "If this persists, the Ping service may be experiencing issues."
+      );
+  }
+}
+async function apiRequest(path2, options = {}) {
+  const url = `${API_BASE_URL}${path2}`;
+  const auth = getAuth();
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (auth?.githubId) {
+    headers["X-GitHub-Id"] = auth.githubId;
+  }
+  if (auth?.token) {
+    headers["Authorization"] = `Bearer ${auth.token}`;
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      ...options,
+      headers: {
+        ...headers,
+        ...options.headers
+      }
+    });
+  } catch (fetchError) {
+    if (fetchError instanceof Error) {
+      if (fetchError.message.includes("fetch failed") || fetchError.message.includes("ECONNREFUSED") || fetchError.message.includes("ENOTFOUND") || fetchError.message.includes("ETIMEDOUT") || fetchError.cause) {
+        throw new PingError(
+          "NETWORK_ERROR" /* NETWORK_ERROR */,
+          "Cannot connect to Ping API. Check your internet connection.",
+          "Make sure you have an active internet connection and try again."
+        );
+      }
+    }
+    throw fetchError;
+  }
+  if (!response.ok) {
+    let responseBody = null;
+    try {
+      responseBody = await response.json();
+    } catch {
+    }
+    throw getErrorFromStatus(response.status, responseBody);
+  }
+  return response.json();
+}
+var server = new Server(
+  {
+    name: "ping",
+    version: "0.1.0"
+  },
+  {
+    capabilities: {
+      tools: {}
+    }
+  }
+);
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: [
+      // ────────────────────────────────────────────────────────
+      // AUTH TOOLS
+      // ────────────────────────────────────────────────────────
+      {
+        name: "ping_login",
+        description: "Login to Ping with GitHub. Opens a browser window for GitHub OAuth authentication. Use when the user wants to login, sign in, connect their account, or start using Ping. After login, a wallet will be automatically created for the user.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "ping_logout",
+        description: "Logout from Ping. Clears your local authentication and wallet info. Use when the user wants to sign out, logout, or switch accounts.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "ping_whoami",
+        description: "Show your Ping account info - GitHub handle, wallet address, and balance. Use when the user asks who they are logged in as, their account status, or profile info.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      // ────────────────────────────────────────────────────────
+      // LEGACY: SET WALLET (for users without GitHub auth)
+      // ────────────────────────────────────────────────────────
+      {
+        name: "ping_set_wallet",
+        description: "Set your wallet address for Ping earnings (legacy method). Only use this if you want to use your own external wallet instead of the Ping-managed wallet. For most users, ping_login is preferred as it creates a wallet automatically.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            walletAddress: {
+              type: "string",
+              description: "Ethereum wallet address (0x...)"
+            }
+          },
+          required: ["walletAddress"]
+        }
+      },
+      // ────────────────────────────────────────────────────────
+      // EARNING TOOLS
+      // ────────────────────────────────────────────────────────
+      {
+        name: "ping_check_earnings",
+        description: "Check your Ping earnings - shows pending balance (ready to claim) and total claimed. Use when the user asks about their balance, earnings, or how much money they have. Requires wallet to be set first with ping_set_wallet.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      {
+        name: "ping_list_questions",
+        description: "Show questions available to answer and earn money on Ping. Use when the user wants to see earning opportunities, available questions, or ways to make money. Returns questions with their rewards.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Number of questions to show (default: 5)"
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "ping_submit_answer",
+        description: "Submit an answer to a Ping question and earn the reward. Use when the user provides their answer to one of the available questions. Set preApproved=true when the user selects a suggested answer (skips AI review for instant approval). Requires GitHub login (ping_login) or wallet address.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            questionId: {
+              type: "string",
+              description: "The ID of the question to answer"
+            },
+            answer: {
+              type: "string",
+              description: "The user's answer to the question"
+            },
+            preApproved: {
+              type: "boolean",
+              description: "Set to true if this is a suggested answer (skip AI review)"
+            }
+          },
+          required: ["questionId", "answer"]
+        }
+      },
+      {
+        name: "ping_answer_flow",
+        description: "Start an interactive Q&A session to earn money answering Ping questions. Returns questions with suggested answers. CRITICAL: Present ALL questions in a SINGLE AskUserQuestion call (batched) to reduce latency. Use the questions array parameter with multiple question objects. After user answers, submit ALL answers IN PARALLEL for speed. AUTO-CLAIM: After all submissions complete, AUTOMATICALLY call ping_claim_reward to send earnings to wallet. Requires GitHub login first (ping_login).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            limit: {
+              type: "number",
+              description: "Number of questions to include in the session (default: 5)"
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "ping_claim_reward",
+        description: "Claim pending Ping earnings and send them to your crypto wallet on Base. Use when the user wants to withdraw, cash out, or claim their rewards. Transfers USDC to their wallet instantly. Works with GitHub login (ping_login) or legacy wallet (ping_set_wallet).",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          required: []
+        }
+      },
+      // ────────────────────────────────────────────────────────
+      // QUESTIONER TOOLS (Phase 1)
+      // ────────────────────────────────────────────────────────
+      {
+        name: "ping_create_question",
+        description: "Create a new question on Ping that others can answer for rewards. Use when someone wants to ask a question and pay for answers. Requires login and sufficient balance. The total cost is (reward + 25% fee) \xD7 max responses.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: {
+              type: "string",
+              description: "The question to ask (must be at least 10 characters)"
+            },
+            rewardCents: {
+              type: "number",
+              description: "Reward per answer in cents (e.g., 25 = $0.25)"
+            },
+            maxResponses: {
+              type: "number",
+              description: "Maximum number of answers to accept (default: 10)"
+            },
+            category: {
+              type: "string",
+              description: 'Question category (e.g., "general", "tech", "lifestyle")'
+            }
+          },
+          required: ["text", "rewardCents"]
+        }
+      },
+      {
+        name: "ping_my_questions",
+        description: "View questions you've created on Ping. Shows status, responses received, and funds remaining. Use when someone wants to see their questions or check question status.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            status: {
+              type: "string",
+              description: 'Filter by status: "active", "closed", or "all" (default: all)'
+            }
+          },
+          required: []
+        }
+      },
+      {
+        name: "ping_view_responses",
+        description: "View answers/responses to one of your questions. Shows each answer with its AI quality score and status. Use when someone wants to see what answers they've received.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            questionId: {
+              type: "string",
+              description: "The ID of the question to view responses for"
+            }
+          },
+          required: ["questionId"]
+        }
+      },
+      {
+        name: "ping_close_question",
+        description: "Close a question and refund any unused funds. Use when someone wants to stop accepting answers to their question. Remaining balance is returned to their Ping account.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            questionId: {
+              type: "string",
+              description: "The ID of the question to close"
+            }
+          },
+          required: ["questionId"]
+        }
+      },
+      {
+        name: "ping_deposit",
+        description: "Add funds to your Ping balance to create questions. Currently accepts simulated deposits for testing. Use when someone wants to add money to fund questions.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            amountCents: {
+              type: "number",
+              description: "Amount to deposit in cents (e.g., 1000 = $10.00)"
+            }
+          },
+          required: ["amountCents"]
+        }
+      }
+    ]
+  };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+  try {
+    switch (name) {
+      // ────────────────────────────────────────────────────────
+      // LOGIN
+      // ────────────────────────────────────────────────────────
+      case "ping_login": {
+        const existingAuth = getAuth();
+        if (existingAuth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                alreadyLoggedIn: true,
+                handle: `@${existingAuth.handle}`,
+                message: `You're already logged in as @${existingAuth.handle}. Use ping_logout to switch accounts.`
+              }, null, 2)
+            }]
+          };
+        }
+        const callbackUrl = `http://localhost:${OAUTH_CALLBACK_PORT}/callback`;
+        const loginUrl = `${API_BASE_URL}/auth/login?redirect=${encodeURIComponent(callbackUrl)}`;
+        const callbackPromise = waitForOAuthCallback();
+        try {
+          await openBrowser(loginUrl);
+        } catch {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Failed to open browser. Please visit this URL manually:",
+                loginUrl
+              }, null, 2)
+            }]
+          };
+        }
+        try {
+          const authData = await callbackPromise;
+          setAuth(authData.token, authData.handle, authData.githubId);
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                handle: `@${authData.handle}`,
+                message: `\u2713 Logged in as @${authData.handle}! You can now answer questions and earn money.`,
+                nextStep: 'Try "show me questions I can answer" or "check my ping balance"'
+              }, null, 2)
+            }]
+          };
+        } catch (err) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: err instanceof Error ? err.message : "Login failed"
+              })
+            }]
+          };
+        }
+      }
+      // ────────────────────────────────────────────────────────
+      // LOGOUT
+      // ────────────────────────────────────────────────────────
+      case "ping_logout": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                message: "You weren't logged in. No action needed."
+              })
+            }]
+          };
+        }
+        const handle = auth.handle;
+        clearAuth();
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              previousHandle: `@${handle}`,
+              message: `\u2713 Logged out from @${handle}. Your local auth has been cleared.`,
+              nextStep: "Use ping_login to sign in with a different account."
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // WHOAMI
+      // ────────────────────────────────────────────────────────
+      case "ping_whoami": {
+        const auth = getAuth();
+        const wallet = getWalletAddress();
+        if (!auth && !wallet) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                loggedIn: false,
+                message: "You're not logged in to Ping.",
+                hint: "Use ping_login to connect with GitHub."
+              }, null, 2)
+            }]
+          };
+        }
+        if (auth) {
+          try {
+            const userData = await apiRequest("/users/me");
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  loggedIn: true,
+                  handle: userData.handle,
+                  authProvider: userData.authProvider,
+                  walletAddress: userData.walletAddress || "Not set yet",
+                  balance: {
+                    available: userData.availableBalance,
+                    pending: userData.pendingBalance,
+                    claimed: userData.claimedBalance
+                  },
+                  message: `Logged in as ${userData.handle}`
+                }, null, 2)
+              }]
+            };
+          } catch (err) {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  loggedIn: true,
+                  handle: `@${auth.handle}`,
+                  authProvider: "github",
+                  message: `Logged in as @${auth.handle}`,
+                  note: "Could not fetch balance (API may be unavailable)"
+                }, null, 2)
+              }]
+            };
+          }
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              loggedIn: false,
+              legacyMode: true,
+              walletAddress: wallet,
+              message: "Using legacy wallet-only mode (not logged in with GitHub).",
+              hint: "Use ping_login to connect with GitHub for the full experience."
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // SET WALLET (Legacy)
+      // ────────────────────────────────────────────────────────
+      case "ping_set_wallet": {
+        const { walletAddress } = args || {};
+        if (!walletAddress) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Missing wallet address.",
+                hint: "Please provide your Ethereum wallet address (starts with 0x)."
+              }, null, 2)
+            }]
+          };
+        }
+        if (!walletAddress.match(/^0x[a-fA-F0-9]{40}$/)) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Invalid wallet address format.",
+                hint: "Wallet address must be 42 characters starting with 0x (e.g., 0x1234...abcd). Check for typos."
+              }, null, 2)
+            }]
+          };
+        }
+        setWalletAddress(walletAddress);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              walletAddress,
+              message: `\u2713 Wallet set to ${walletAddress}. You can now check earnings, answer questions, and claim rewards!`,
+              nextStep: 'Try "show me questions I can answer" or "check my ping earnings"'
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // CHECK EARNINGS
+      // ────────────────────────────────────────────────────────
+      case "ping_check_earnings": {
+        const wallet = getWalletAddress();
+        if (!wallet) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "No wallet configured.",
+                hint: "Use ping_login to connect with GitHub (recommended) or ping_set_wallet to set a wallet address."
+              }, null, 2)
+            }]
+          };
+        }
+        const data = await apiRequest(`/earnings?wallet=${wallet}`);
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              pendingBalance: data.pending,
+              claimedBalance: data.claimed,
+              totalEarned: `$${((data.pendingRaw + data.claimedRaw) / 1e6).toFixed(2)}`,
+              walletAddress: data.walletAddress,
+              availableQuestions: data.availableQuestions,
+              potentialEarnings: data.potentialEarnings,
+              message: data.pendingRaw > 0 ? `You have ${data.pending} ready to claim! \u{1F4B0}` : "No pending balance yet. Answer questions to start earning!"
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // LIST QUESTIONS
+      // ────────────────────────────────────────────────────────
+      case "ping_list_questions": {
+        const { limit = 5 } = args || {};
+        const data = await apiRequest(`/questions?limit=${limit}`);
+        if (data.questions.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                questions: [],
+                message: "No questions available right now.",
+                hint: "New questions are added regularly. Check back soon, or use ping_create_question to ask your own!"
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              questions: data.questions.map((q) => ({
+                id: q.id,
+                question: q.text,
+                reward: q.reward,
+                category: q.category,
+                asker: q.asker
+              })),
+              totalAvailable: data.total,
+              message: `Found ${data.questions.length} question${data.questions.length !== 1 ? "s" : ""} you can answer!`
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // SUBMIT ANSWER
+      // ────────────────────────────────────────────────────────
+      case "ping_submit_answer": {
+        const { questionId, answer, preApproved = false } = args || {};
+        if (!questionId) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Missing question ID.",
+                hint: "Use ping_list_questions to see available questions with their IDs."
+              }, null, 2)
+            }]
+          };
+        }
+        if (!answer || answer.trim().length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Answer cannot be empty.",
+                hint: "Please provide a thoughtful response to the question."
+              }, null, 2)
+            }]
+          };
+        }
+        const auth = getAuth();
+        const wallet = getWalletAddress();
+        if (!auth && !wallet) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account before answering questions."
+              }, null, 2)
+            }]
+          };
+        }
+        const requestBody = {
+          answer: answer.trim(),
+          preApproved
+        };
+        if (!auth && wallet) {
+          requestBody.walletAddress = wallet;
+        }
+        const data = await apiRequest(`/questions/${questionId}/respond`, {
+          method: "POST",
+          body: JSON.stringify(requestBody)
+        });
+        if (!data.success) {
+          if (data.status === "rejected") {
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  success: false,
+                  status: "rejected",
+                  aiScore: data.aiScore,
+                  reason: data.reason,
+                  tip: data.tip || "Try providing a more thoughtful, detailed response.",
+                  message: data.reason || "Answer was rejected by AI review."
+                })
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: data.error || "Failed to submit answer"
+              })
+            }]
+          };
+        }
+        const response = {
+          success: true,
+          status: data.status || "approved",
+          earned: data.earned,
+          aiScore: data.aiScore,
+          message: data.message || `Answer approved! You earned ${data.earned}.`
+        };
+        if (data.txHash) {
+          response.transaction = {
+            txHash: data.txHash,
+            explorerUrl: data.explorerUrl || `https://basescan.org/tx/${data.txHash}`
+          };
+        }
+        response.nextStep = "Your earnings are in your Ping balance. Keep answering to earn more!";
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // ANSWER FLOW (Interactive Q&A Session)
+      // ────────────────────────────────────────────────────────
+      case "ping_answer_flow": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account first. Then you can start answering questions and earning money."
+              }, null, 2)
+            }]
+          };
+        }
+        const { limit = 5 } = args || {};
+        const data = await apiRequest(`/questions?limit=${limit}`);
+        if (data.questions.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                questions: [],
+                message: "No questions available right now.",
+                hint: "New questions are added regularly. Check back soon to start earning!"
+              }, null, 2)
+            }]
+          };
+        }
+        const questionsWithSuggestions = data.questions.map((q) => {
+          const suggestions = generateSuggestedAnswers(q.text, q.category);
+          return {
+            id: q.id,
+            question: q.text,
+            reward: q.reward,
+            category: q.category,
+            suggestedAnswers: suggestions
+          };
+        });
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              flow: "answer_session",
+              handle: `@${auth.handle}`,
+              // Summary stats for initial presentation
+              summary: {
+                questionCount: questionsWithSuggestions.length,
+                totalPotentialEarnings: data.totalPotentialEarnings,
+                totalAnswersToday: data.totalAnswersToday,
+                oneLiner: `\u{1F4EC} ${questionsWithSuggestions.length} questions available \xB7 Earn up to ${data.totalPotentialEarnings} \xB7 ${data.totalAnswersToday} answers submitted today`
+              },
+              // Full question data (present AFTER user confirms)
+              questions: questionsWithSuggestions,
+              instructions: {
+                step1_summary: 'FIRST show ONLY the oneLiner from summary, then ask "Ready to start?" Do NOT reveal questions yet.',
+                step2_questions: "AFTER user confirms, BATCH ALL QUESTIONS in a SINGLE AskUserQuestion call (max 4 per call due to tool limit).",
+                format: 'Each question: question text with reward in header, options are ONLY the suggested answers (no Skip option - user can skip via "Other"). multiSelect: false.',
+                suggestedAnswerSubmission: "When user selects a suggested answer, call ping_submit_answer with preApproved=true for instant approval.",
+                customAnswerSubmission: 'When user types custom text via "Other", call ping_submit_answer with preApproved=false (AI review).',
+                parallelSubmission: "After collecting all answers, submit them IN PARALLEL using multiple ping_submit_answer calls in one message for speed.",
+                skipBehavior: 'If user selects "Other" and leaves blank or says skip, do not submit an answer for that question.',
+                errorHandling: "If some answer submissions fail, still proceed with auto-claim for the successful ones. Report which answers failed and why.",
+                autoClaim: "IMPORTANT: After ALL answer submissions complete (even if some failed), IMMEDIATELY call ping_claim_reward to send earnings to wallet. Do NOT ask - just claim automatically.",
+                claimRetry: "If ping_claim_reward fails, wait 2 seconds and retry ONCE. If it fails again, tell user earnings are saved and they can claim later.",
+                completionMessage: "After claim completes, show: total earned, transaction hash, and basescan link."
+              }
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // CLAIM REWARD
+      // ────────────────────────────────────────────────────────
+      case "ping_claim_reward": {
+        const auth = getAuth();
+        const wallet = getWalletAddress();
+        if (!auth && !wallet) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account before claiming rewards."
+              }, null, 2)
+            }]
+          };
+        }
+        const requestBody = {};
+        if (!auth && wallet) {
+          requestBody.wallet = wallet;
+        }
+        const data = await apiRequest("/claim", {
+          method: "POST",
+          body: JSON.stringify(requestBody)
+        });
+        if (!data.success) {
+          let errorMsg = data.error || "Claim failed";
+          let hint = "Please try again later.";
+          if (errorMsg.toLowerCase().includes("nothing to claim") || errorMsg.toLowerCase().includes("no pending")) {
+            errorMsg = "No earnings to claim.";
+            hint = "Answer more questions to earn rewards, then claim them here.";
+          } else if (errorMsg.toLowerCase().includes("insufficient")) {
+            hint = "Your balance may be lower than the minimum claim amount.";
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: errorMsg,
+                hint
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              claimed: data.claimed,
+              transaction: {
+                hash: data.txHash,
+                chain: "Base",
+                token: "USDC",
+                to: wallet,
+                explorerUrl: `https://basescan.org/tx/${data.txHash}`
+              },
+              message: `Success! ${data.claimed} USDC sent to your wallet on Base!`
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // CREATE QUESTION (Questioner)
+      // ────────────────────────────────────────────────────────
+      case "ping_create_question": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account before creating questions."
+              }, null, 2)
+            }]
+          };
+        }
+        const { text, rewardCents, maxResponses = 10, category = "general" } = args || {};
+        if (!text || text.length < 10) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Question is too short.",
+                hint: "Please write a question that is at least 10 characters long."
+              }, null, 2)
+            }]
+          };
+        }
+        if (!rewardCents || rewardCents < 1) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Invalid reward amount.",
+                hint: "Reward must be at least 1 cent. Example: 25 = $0.25 per answer."
+              }, null, 2)
+            }]
+          };
+        }
+        const data = await apiRequest("/questions", {
+          method: "POST",
+          body: JSON.stringify({
+            text,
+            rewardCents,
+            maxResponses,
+            category
+          })
+        });
+        if (!data.success) {
+          let errorMsg = data.error || "Failed to create question";
+          let hint = "Please try again.";
+          if (errorMsg.toLowerCase().includes("insufficient") || errorMsg.toLowerCase().includes("balance")) {
+            hint = "Use ping_deposit to add funds to your account first.";
+          } else if (errorMsg.toLowerCase().includes("duplicate")) {
+            hint = "A similar question may already exist. Try rephrasing.";
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: errorMsg,
+                hint
+              }, null, 2)
+            }]
+          };
+        }
+        const response = {
+          success: true,
+          question: data.question,
+          message: `Question created! Reward: ${data.question?.reward} per answer`,
+          nextStep: "Answers will be AI-reviewed and you'll be notified when they arrive."
+        };
+        if (data.transaction?.txHash) {
+          response.transaction = {
+            txHash: data.transaction.txHash,
+            basescanUrl: `https://basescan.org/tx/${data.transaction.txHash}`
+          };
+          response.message = `\u2713 Question created on-chain! Reward: ${data.question?.reward} per answer`;
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(response, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // MY QUESTIONS (Questioner)
+      // ────────────────────────────────────────────────────────
+      case "ping_my_questions": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account."
+              }, null, 2)
+            }]
+          };
+        }
+        const { status = "all" } = args || {};
+        const data = await apiRequest(`/users/me/questions?status=${status}`);
+        if (data.questions.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                questions: [],
+                message: "You haven't created any questions yet.",
+                hint: "Use ping_create_question to ask your first question and get answers from the community!"
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              questions: data.questions,
+              total: data.total,
+              message: `Found ${data.questions.length} question${data.questions.length !== 1 ? "s" : ""}`
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // VIEW RESPONSES (Questioner)
+      // ────────────────────────────────────────────────────────
+      case "ping_view_responses": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account."
+              }, null, 2)
+            }]
+          };
+        }
+        const { questionId } = args || {};
+        if (!questionId) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Missing question ID.",
+                hint: "Use ping_my_questions to see your questions and their IDs."
+              }, null, 2)
+            }]
+          };
+        }
+        const data = await apiRequest(`/questions/${questionId}/responses`);
+        if (data.responses.length === 0) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: true,
+                question: data.question,
+                responses: [],
+                total: 0,
+                message: "No responses yet.",
+                hint: "Answers usually start arriving within a few hours. Check back later!"
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              question: data.question,
+              responses: data.responses,
+              total: data.total,
+              message: `Found ${data.responses.length} response${data.responses.length !== 1 ? "s" : ""} to your question`
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // CLOSE QUESTION (Questioner)
+      // ────────────────────────────────────────────────────────
+      case "ping_close_question": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account."
+              }, null, 2)
+            }]
+          };
+        }
+        const { questionId } = args || {};
+        if (!questionId) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Missing question ID.",
+                hint: "Use ping_my_questions to see your questions and their IDs."
+              }, null, 2)
+            }]
+          };
+        }
+        const data = await apiRequest(`/questions/${questionId}/close`, {
+          method: "POST"
+        });
+        if (!data.success) {
+          let errorMsg = data.error || "Failed to close question";
+          let hint = "Please try again.";
+          if (errorMsg.toLowerCase().includes("not found")) {
+            hint = "Check that the question ID is correct using ping_my_questions.";
+          } else if (errorMsg.toLowerCase().includes("already closed")) {
+            hint = "This question has already been closed.";
+          }
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: errorMsg,
+                hint
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              refunded: data.refunded,
+              message: `Question closed. ${data.refunded} refunded to your balance.`
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // DEPOSIT (Questioner)
+      // ────────────────────────────────────────────────────────
+      case "ping_deposit": {
+        const auth = getAuth();
+        if (!auth) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Not logged in.",
+                hint: "Use ping_login to connect your GitHub account before adding funds."
+              }, null, 2)
+            }]
+          };
+        }
+        const { amountCents } = args || {};
+        if (!amountCents || amountCents < 100) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: "Deposit amount too small.",
+                hint: "Minimum deposit is $1.00 (100 cents). Example: 1000 = $10.00"
+              }, null, 2)
+            }]
+          };
+        }
+        const data = await apiRequest("/deposits", {
+          method: "POST",
+          body: JSON.stringify({ amountCents })
+        });
+        if (!data.success) {
+          return {
+            content: [{
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: data.error || "Deposit failed.",
+                hint: "Please try again. If the problem persists, contact support."
+              }, null, 2)
+            }]
+          };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              deposited: data.deposited,
+              newBalance: data.newBalance,
+              message: `Deposited ${data.deposited}! Your new balance is ${data.newBalance}.`,
+              nextStep: "You can now create questions with ping_create_question"
+            }, null, 2)
+          }]
+        };
+      }
+      // ────────────────────────────────────────────────────────
+      // UNKNOWN TOOL
+      // ────────────────────────────────────────────────────────
+      default:
+        return {
+          content: [{
+            type: "text",
+            text: `Unknown tool: ${name}. Available tools: ping_login, ping_logout, ping_whoami, ping_set_wallet, ping_check_earnings, ping_list_questions, ping_submit_answer, ping_answer_flow, ping_claim_reward, ping_create_question, ping_my_questions, ping_view_responses, ping_close_question, ping_deposit`
+          }],
+          isError: true
+        };
+    }
+  } catch (error) {
+    const errorResponse = formatErrorResponse(error);
+    return {
+      content: [{
+        type: "text",
+        text: JSON.stringify(errorResponse, null, 2)
+      }],
+      isError: true
+    };
+  }
+});
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("\u{1F3D3} Ping MCP server running");
+  console.error(`   API URL: ${API_BASE_URL}`);
+  const auth = getAuth();
+  if (auth) {
+    console.error(`   Logged in as: @${auth.handle}`);
+  } else {
+    const wallet = getWalletAddress();
+    if (wallet) {
+      console.error(`   Wallet (legacy): ${wallet}`);
+    } else {
+      console.error("   Status: Not logged in (use ping_login)");
+    }
+  }
+}
+main().catch((error) => {
+  console.error("Failed to start Ping MCP server:", error);
+  process.exit(1);
+});