kill-switch-mcp 1.2.3 → 1.2.5

package/dist/server.js

@@ -150,7 +150,7 @@ class BotSDK {
         const status = await this.checkBotStatus();
         const shouldLaunch = this.shouldLaunchBrowser(status);
         if (shouldLaunch) {
-          console.log(`[BotSDK] Launching browser...`);
+          console.error(`[BotSDK] Launching browser...`);
           this.browserLaunched = true;
           await this.launchBrowser();
           await this.waitForBotConnection();
@@ -212,7 +212,7 @@ class BotSDK {
               this.browserLaunched = false;
             }
             this.waitForReady(15000).then(() => {
-              console.log("[BotSDK] Connected and game state ready");
+              console.error("[BotSDK] Connected and game state ready");
               resolve();
             }).catch((error) => {
               console.warn("[BotSDK] Connected but game state not ready:", error.message);
@@ -246,21 +246,21 @@ class BotSDK {
   }
   scheduleReconnect() {
     if (this.reconnectAttempt >= this.config.reconnectMaxRetries) {
-      console.log(`[BotSDK] Max reconnection attempts (${this.config.reconnectMaxRetries}) reached, giving up`);
+      console.error(`[BotSDK] Max reconnection attempts (${this.config.reconnectMaxRetries}) reached, giving up`);
       this.setConnectionState("disconnected");
       return;
     }
     this.reconnectAttempt++;
     this.setConnectionState("reconnecting", this.reconnectAttempt);
     const delay = Math.min(this.config.reconnectBaseDelay * Math.pow(2, this.reconnectAttempt - 1), this.config.reconnectMaxDelay);
-    console.log(`[BotSDK] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
+    console.error(`[BotSDK] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempt})`);
     this.reconnectTimer = setTimeout(async () => {
       this.reconnectTimer = null;
       try {
         await this.connect();
-        console.log(`[BotSDK] Reconnected successfully after ${this.reconnectAttempt} attempt(s)`);
+        console.error(`[BotSDK] Reconnected successfully after ${this.reconnectAttempt} attempt(s)`);
       } catch (e) {
-        console.log(`[BotSDK] Reconnection attempt ${this.reconnectAttempt} failed`);
+        console.error(`[BotSDK] Reconnection attempt ${this.reconnectAttempt} failed`);
       }
     }, delay);
   }
@@ -304,17 +304,17 @@ class BotSDK {
   async checkBotStatus() {
     const statusUrl = this.getStatusUrl();
     try {
-      console.log(`[BotSDK] Checking bot status via URL: ${statusUrl}`);
+      console.error(`[BotSDK] Checking bot status via URL: ${statusUrl}`);
       const response = await fetch(statusUrl);
       if (!response.ok) {
-        console.log(`[BotSDK] Status check HTTP error: ${response.status} ${response.statusText} (URL: ${statusUrl})`);
+        console.error(`[BotSDK] Status check HTTP error: ${response.status} ${response.statusText} (URL: ${statusUrl})`);
         throw new Error(`Status check failed: ${response.status}`);
       }
       const data = await response.json();
       return data;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      console.log(`[BotSDK] Status check failed: ${errorMsg} (URL: ${statusUrl})`);
+      console.error(`[BotSDK] Status check failed: ${errorMsg} (URL: ${statusUrl})`);
       return {
         status: "dead",
         inGame: false,
@@ -334,15 +334,15 @@ class BotSDK {
       return false;
     }
     if (status.status === "dead") {
-      console.log(`[BotSDK] Bot not connected`);
+      console.error(`[BotSDK] Bot not connected`);
       return true;
     }
-    console.log(`[BotSDK] Active client detected, skipping browser launch`);
+    console.error(`[BotSDK] Active client detected, skipping browser launch`);
     return false;
   }
   async launchBrowser() {
     const url = this.buildClientUrl();
-    console.log(`[BotSDK] Opening browser: ${url}`);
+    console.error(`[BotSDK] Opening browser: ${url}`);
     const { exec } = await import("child_process");
     const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
     return new Promise((resolve, reject) => {
@@ -360,14 +360,14 @@ class BotSDK {
     const startTime = Date.now();
     const pollInterval = 500;
     let attemptCount = 0;
-    console.log(`[BotSDK] Waiting for bot to connect and load game (timeout: ${timeoutMs}ms)...`);
+    console.error(`[BotSDK] Waiting for bot to connect and load game (timeout: ${timeoutMs}ms)...`);
     while (Date.now() - startTime < timeoutMs) {
       attemptCount++;
       const elapsed = Date.now() - startTime;
       const status = await this.checkBotStatus();
-      console.log(`[BotSDK] Poll attempt ${attemptCount} (${elapsed}ms): status="${status.status}", inGame=${status.inGame}, controllers=${status.controllers.length}, observers=${status.observers.length}`);
+      console.error(`[BotSDK] Poll attempt ${attemptCount} (${elapsed}ms): status="${status.status}", inGame=${status.inGame}, controllers=${status.controllers.length}, observers=${status.observers.length}`);
       if (status.status !== "dead" && status.inGame) {
-        console.log(`[BotSDK] Bot connected and in-game!`);
+        console.error(`[BotSDK] Bot connected and in-game!`);
         return;
       }
       await new Promise((resolve) => setTimeout(resolve, pollInterval));
@@ -402,7 +402,7 @@ class BotSDK {
       username: this.config.botUsername,
       password: this.config.password
     }));
-    console.log(`[BotSDK] Sent login command for ${this.config.botUsername} through gateway`);
+    console.error(`[BotSDK] Sent login command for ${this.config.botUsername} through gateway`);
   }
   async waitForConnection(timeout = 60000) {
     if (this.isConnected()) {
@@ -573,7 +573,7 @@ class BotSDK {
   }
   async sendAction(action) {
     if (this.connectionState === "reconnecting") {
-      console.log(`[BotSDK] Waiting for reconnection before sending action: ${action.type}`);
+      console.error(`[BotSDK] Waiting for reconnection before sending action: ${action.type}`);
       await this.waitForConnection();
     }
     if (!this.isConnected()) {
@@ -723,7 +723,7 @@ class BotSDK {
   }
   async sendScreenshot(timeout = 1e4) {
     if (this.connectionState === "reconnecting") {
-      console.log(`[BotSDK] Waiting for reconnection before requesting screenshot`);
+      console.error(`[BotSDK] Waiting for reconnection before requesting screenshot`);
       await this.waitForConnection();
     }
     if (!this.isConnected()) {
@@ -765,22 +765,22 @@ class BotSDK {
     return this.findPath(destX, destZ, maxWaypoints);
   }
   async waitForReady(timeout = 15000) {
-    console.log("[BotSDK] Waiting for game state to be ready...");
+    console.error("[BotSDK] Waiting for game state to be ready...");
     try {
       const state = await this.waitForCondition((s) => {
         const validPosition = !!(s.player && s.player.worldX !== 0 && s.player.worldZ !== 0);
         const inGame = s.inGame;
         const hasEntities = s.nearbyNpcs.length > 0 || s.nearbyLocs.length > 0 || s.groundItems.length > 0;
         if (!validPosition) {
-          console.log(`[BotSDK] Waiting - invalid position: (${s.player?.worldX}, ${s.player?.worldZ})`);
+          console.error(`[BotSDK] Waiting - invalid position: (${s.player?.worldX}, ${s.player?.worldZ})`);
         } else if (!inGame) {
-          console.log("[BotSDK] Waiting - not in game");
+          console.error("[BotSDK] Waiting - not in game");
         } else if (!hasEntities) {
-          console.log("[BotSDK] Waiting - no entities loaded yet");
+          console.error("[BotSDK] Waiting - no entities loaded yet");
         }
         return inGame && validPosition && hasEntities;
       }, timeout);
-      console.log("[BotSDK] Game state ready!");
+      console.error("[BotSDK] Game state ready!");
       return state;
     } catch (error) {
       console.error("[BotSDK] Timeout waiting for game state to be ready");
@@ -1721,7 +1721,7 @@ class BotActions {
         if (!blockedDoors.has(key)) {
           blockedDoors.add(key);
           blockDoor(level, nearest.x, nearest.z);
-          console.log(`[walkTo] Blocked impassable door at (${nearest.x}, ${nearest.z}) — re-routing`);
+          console.error(`[walkTo] Blocked impassable door at (${nearest.x}, ${nearest.z}) — re-routing`);
         }
       }
       return false;
@@ -1732,6 +1732,9 @@ class BotActions {
         await this.sdk.waitForTicks(1);
         path = await this.sdk.sendFindPath(x, z, 500);
         if (!path.success || !path.waypoints?.length) {
+          if (path.error?.includes("zone not allocated")) {
+            return this._walkToServerSide(x, z, tolerance);
+          }
           console.error(`[walkTo] PATHFINDING FAILED: ${path.error ?? "no waypoints"} - from (${pos.x}, ${pos.z}) to (${x}, ${z})`);
           return { success: false, message: `No path to (${x}, ${z}) from (${pos.x}, ${pos.z}): ${path.error ?? "no waypoints"}` };
         }
@@ -1761,7 +1764,7 @@ class BotActions {
                     blockedDoors.add(doorKey);
                     blockDoor(door.level, door.x, door.z);
                     requiredDoorKeys.delete(doorKey);
-                    console.log(`[walkTo] Blocked impassable door at (${door.x}, ${door.z}) — re-routing`);
+                    console.error(`[walkTo] Blocked impassable door at (${door.x}, ${door.z}) — re-routing`);
                     break;
                   }
                   break;
@@ -1795,6 +1798,45 @@ class BotActions {
     }
     return { success: false, message: `Could not reach (${x}, ${z}) - stopped at (${pos.x}, ${pos.z})` };
   }
+  async _walkToServerSide(x, z, tolerance) {
+    const distTo = (px, pz) => this.helpers.distance(px, pz, x, z);
+    const MAX_ATTEMPTS = 20;
+    let stuckCount = 0;
+    for (let i = 0;i < MAX_ATTEMPTS; i++) {
+      const state = this.sdk.getState();
+      if (!state?.player)
+        return { success: false, message: "No player state" };
+      const { worldX: px, worldZ: pz } = state.player;
+      if (distTo(px, pz) <= tolerance) {
+        return { success: true, message: "Arrived" };
+      }
+      await this.sdk.sendWalk(x, z);
+      const prevX = px;
+      const prevZ = pz;
+      await this.sdk.waitForTicks(3);
+      const after = this.sdk.getState();
+      if (after?.player) {
+        const movedDist = this.helpers.distance(prevX, prevZ, after.player.worldX, after.player.worldZ);
+        if (movedDist < 1) {
+          stuckCount++;
+          if (stuckCount >= 3) {
+            return { success: false, message: `Stuck at (${after.player.worldX}, ${after.player.worldZ}) trying to reach (${x}, ${z})` };
+          }
+          await this.helpers.tryOpenBlockingDoor();
+          await this.sdk.waitForTicks(1);
+        } else {
+          stuckCount = 0;
+        }
+      }
+    }
+    const final = this.sdk.getState();
+    const fx = final?.player?.worldX ?? 0;
+    const fz = final?.player?.worldZ ?? 0;
+    if (distTo(fx, fz) <= tolerance) {
+      return { success: true, message: "Arrived" };
+    }
+    return { success: false, message: `Could not reach (${x}, ${z}) - stopped at (${fx}, ${fz})` };
+  }
   async closeShop(timeout = 5000) {
     const state = this.sdk.getState();
     if (!state?.shop.isOpen && !state?.interface?.isOpen) {
@@ -3828,12 +3870,42 @@ var tempoChain = defineChain({
 });
 var USDC_ADDRESS = process.env.USDC_ADDRESS || "0x20c0000000000000000000000000000000000000";
 var FACTORY_ADDRESS = process.env.FACTORY_ADDRESS;
+var PENDING_FILE = join2(WALLET_DIR, "pending-wallet.json");
 var SERVER_URL = (() => {
   const idx = process.argv.indexOf("--server");
   if (idx !== -1 && process.argv[idx + 1])
     return process.argv[idx + 1];
   return process.env.KILL_SWITCH_SERVER || "localhost";
 })();
+function getWebBase() {
+  const isLocal = SERVER_URL === "localhost" || SERVER_URL === "127.0.0.1";
+  return isLocal ? "http://localhost:8888" : `https://${SERVER_URL}`;
+}
+function generateLinkToken() {
+  const bytes = new Uint8Array(16);
+  crypto.getRandomValues(bytes);
+  return Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function savePendingWallet(pending) {
+  mkdirSync(WALLET_DIR, { recursive: true });
+  writeFileSync(PENDING_FILE, JSON.stringify(pending, null, 2), { mode: 384 });
+}
+function loadPendingWallet() {
+  try {
+    if (existsSync2(PENDING_FILE)) {
+      return JSON.parse(readFileSync(PENDING_FILE, "utf-8"));
+    }
+  } catch {}
+  return null;
+}
+function clearPendingWallet() {
+  try {
+    if (existsSync2(PENDING_FILE)) {
+      const fs = __require("fs");
+      fs.unlinkSync(PENDING_FILE);
+    }
+  } catch {}
+}
 var ERC20_ABI = [
   {
     name: "approve",
@@ -3961,40 +4033,48 @@ async function getWalletInfo() {
     balanceRaw
   };
 }
-function generateAccessKey() {
+function initiateWalletSetup() {
   const privateKey = generatePrivateKey();
   const account = privateKeyToAccount(privateKey);
-  const instructions = [
-    "A new game access key has been generated.",
-    "",
-    `Access Key Address: ${account.address}`,
-    "",
-    "To authorize this key on your Tempo account, you need to call the",
-    "Account Keychain precompile. This requires your passkey (biometric).",
-    "",
-    "You can do this via the Tempo wallet web interface or by running:",
-    "",
-    `  cast send 0xAAAAAAAA00000000000000000000000000000000 \\`,
-    `    "authorizeKey(address,uint8,uint64,bool,(address,uint256)[])" \\`,
-    `    ${account.address} 0 ${Math.floor(Date.now() / 1000) + 90 * 86400} true \\`,
-    `    "[(${USDC_ADDRESS},1000000000)]" \\`,
-    `    --rpc-url ${TEMPO_RPC}`,
-    "",
-    "This authorizes the key to spend up to 1000 USDC on game transactions,",
-    "expiring in 90 days. You can revoke it anytime from your Tempo account.",
-    "",
-    "Learn more about Tempo access keys:",
-    "https://docs.tempo.xyz/protocol/tips/tip-1011"
-  ].join(`
-`);
-  return { accessKeyAddress: account.address, privateKey, instructions };
+  const linkToken = generateLinkToken();
+  const chain = TEMPO_CHAIN_ID === 4217 ? "mainnet" : "testnet";
+  const webBase = getWebBase();
+  const authorizeUrl = `${webBase}/authorize?key=${account.address}&t=${linkToken}&chain=${chain}`;
+  const pending = {
+    accessKeyPrivate: privateKey,
+    accessKeyAddress: account.address,
+    linkToken,
+    authorizeUrl,
+    createdAt: new Date().toISOString()
+  };
+  savePendingWallet(pending);
+  return {
+    accessKeyAddress: account.address,
+    linkToken,
+    authorizeUrl
+  };
+}
+async function checkWalletCallback(linkToken) {
+  try {
+    const webBase = getWebBase();
+    const response = await fetch(`${webBase}/api/wallet-callback?t=${linkToken}`);
+    const data = await response.json();
+    if (data.status === "complete" && data.tempoAddress) {
+      return { tempoAddress: data.tempoAddress, txHash: data.txHash };
+    }
+  } catch {}
+  return null;
 }
-function saveAccessKey(privateKey, accountAddress) {
+function finalizeWalletSetup(tempoAddress) {
+  const pending = loadPendingWallet();
+  if (!pending)
+    throw new Error("No pending wallet setup found.");
   saveWallet({
-    accessKeyPrivate: privateKey,
-    accountAddress,
+    accessKeyPrivate: pending.accessKeyPrivate,
+    accountAddress: tempoAddress,
     createdAt: new Date().toISOString()
   });
+  clearPendingWallet();
 }
 async function joinTournament(tournamentAddress, username) {
   const wallet = loadWallet();
@@ -4087,7 +4167,7 @@ Call \`join_game\` with no arguments to see what's available:
 - **If no game is queued**: You'll see all available buy-in tiers (Free, $5, $15, $50, $100, $1000). Call \`join_game\` with a \`tier_id\` to start a new game.
 - **If a game is active**: You must wait for it to finish.
 
-**Paid games** require a Tempo wallet (\`setup_game_wallet\`). Your buy-in is deposited on-chain when you join. No refunds once deposited — the only refund path is if the game is cancelled (not enough players).
+**Paid games** require a game wallet. Run \`setup_game_wallet\` and open the link in your browser — create a Tempo account with Face ID/Touch ID (no wallet app needed), authorize Kill Switch with one tap, and you're ready. Testnet accounts are auto-funded. Your buy-in is deposited on-chain when you join. No refunds once deposited — the only refund path is if the game is cancelled (not enough players).
 
 **Game start triggers:**
 - 12 players join → starts immediately
@@ -4498,16 +4578,10 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "setup_game_wallet",
-        description: 'Set up a Tempo wallet access key for paid tournaments. Requires Tempo CLI installed and "tempo wallet login" completed. Handles real money — explain each step to user.',
+        description: "Set up a game wallet for paid tournaments. Opens a browser page where the user creates a Tempo account with Face ID/Touch ID and authorizes Kill Switch. No wallet app needed.",
         inputSchema: {
           type: "object",
-          properties: {
-            tempo_account_address: {
-              type: "string",
-              description: `The user's Tempo account address (0x...). Get via "tempo wallet whoami".`
-            }
-          },
-          required: ["tempo_account_address"]
+          properties: {}
         }
       },
       {
@@ -5042,10 +5116,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         return successResponse({ message: `Disconnected "${name2}" from the game.` });
       }
       case "setup_game_wallet": {
-        const tempoAddress = args?.tempo_account_address;
-        if (!tempoAddress || !tempoAddress.startsWith("0x")) {
-          return errorResponse('A valid Tempo account address (0x...) is required. Run "tempo wallet whoami" to get yours.');
-        }
         if (hasGameWallet()) {
           try {
             const info = await getWalletInfo();
@@ -5065,28 +5135,62 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             };
           } catch {}
         }
-        const { accessKeyAddress, privateKey, instructions } = generateAccessKey();
-        saveAccessKey(privateKey, tempoAddress);
+        const pending = loadPendingWallet();
+        if (pending) {
+          const result = await checkWalletCallback(pending.linkToken);
+          if (result) {
+            finalizeWalletSetup(result.tempoAddress);
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  "Wallet setup complete!",
+                  "",
+                  `Tempo account: ${result.tempoAddress}`,
+                  `Access key authorized: tx ${result.txHash.slice(0, 10)}...`,
+                  "",
+                  "Your wallet is ready. Use check_wallet to see your balance."
+                ].join(`
+`)
+              }]
+            };
+          }
+          return {
+            content: [{
+              type: "text",
+              text: [
+                "Wallet setup is in progress. Open this link to complete it:",
+                "",
+                `  ${pending.authorizeUrl}`,
+                "",
+                "Once you've completed the steps in your browser, run setup_game_wallet again."
+              ].join(`
+`)
+            }]
+          };
+        }
+        const { accessKeyAddress, authorizeUrl } = initiateWalletSetup();
         return {
           content: [{
             type: "text",
             text: [
               "Game wallet setup started!",
               "",
-              `Your Tempo account: ${tempoAddress}`,
-              `Generated access key: ${accessKeyAddress}`,
+              `Access key: ${accessKeyAddress}`,
+              "",
+              "━━━ OPEN THIS LINK ━━━",
               "",
-              "── NEXT STEP ──",
+              `  ${authorizeUrl}`,
               "",
-              "You need to authorize this access key on your Tempo account.",
-              "This requires your passkey (biometric confirmation).",
+              "This will open a page where you:",
+              "1. Create a Tempo account using Face ID / Touch ID (or sign in)",
+              "2. Authorize Kill Switch to manage game deposits (one tap)",
               "",
-              instructions,
+              "No wallet app needed — just your browser and biometrics.",
               "",
-              "── AFTER AUTHORIZATION ──",
+              "━━━ AFTER YOU'RE DONE ━━━",
               "",
-              "Once authorized, your game wallet is ready. Check it with check_wallet.",
-              "Fund your Tempo account with USDC to start joining paid tournaments."
+              "Come back here and run setup_game_wallet again to confirm."
             ].join(`
 `)
           }]
@@ -5094,13 +5198,21 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
       }
       case "check_wallet": {
         if (!hasGameWallet()) {
-          return errorResponse(`No game wallet found. Run setup_game_wallet first.
+          const pendingCheck = loadPendingWallet();
+          if (pendingCheck) {
+            const callbackResult = await checkWalletCallback(pendingCheck.linkToken);
+            if (callbackResult) {
+              finalizeWalletSetup(callbackResult.tempoAddress);
+            } else {
+              return errorResponse(`Wallet setup is in progress. Complete it in your browser:
+
+  ${pendingCheck.authorizeUrl}
 
-Prerequisites:
-1. Install Tempo CLI: curl -fsSL https://tempo.xyz/install | bash
-2. Create account: tempo wallet login
-3. Get your address: tempo wallet whoami
-4. Then call setup_game_wallet with your address`);
+Then run check_wallet again.`);
+            }
+          } else {
+            return errorResponse("No game wallet found. Run setup_game_wallet to get started.");
+          }
         }
         try {
           const info = await getWalletInfo();
@@ -5147,6 +5259,9 @@ function errorResponse(message) {
     isError: true
   };
 }
+process.on("unhandledRejection", (reason) => {
+  console.error("[Kill Switch MCP] Unhandled rejection (suppressed):", reason instanceof Error ? reason.message : reason);
+});
 async function main() {
   console.error("[Kill Switch MCP] Starting Kill Switch MCP server v3.0...");
   console.error(`[Kill Switch MCP] Game server: ${SERVER_URL2}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kill-switch-mcp",
-  "version": "1.2.3",
+  "version": "1.2.5",
   "description": "Kill Switch MCP Server — AI battle royale powered by Claude Code",
   "type": "module",
   "bin": {