kill-switch-mcp 1.2.4 → 1.2.5

package/dist/server.js

@@ -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"}` };
         }
@@ -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}`,
               "",
-              "── NEXT STEP ──",
+              "━━━ OPEN THIS LINK ━━━",
               "",
-              "You need to authorize this access key on your Tempo account.",
-              "This requires your passkey (biometric confirmation).",
+              `  ${authorizeUrl}`,
               "",
-              instructions,
+              "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)",
               "",
-              "── AFTER AUTHORIZATION ──",
+              "No wallet app needed — just your browser and biometrics.",
               "",
-              "Once authorized, your game wallet is ready. Check it with check_wallet.",
-              "Fund your Tempo account with USDC to start joining paid tournaments."
+              "━━━ AFTER YOU'RE DONE ━━━",
+              "",
+              "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:
 
-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`);
+  ${pendingCheck.authorizeUrl}
+
+Then run check_wallet again.`);
+            }
+          } else {
+            return errorResponse("No game wallet found. Run setup_game_wallet to get started.");
+          }
         }
         try {
           const info = await getWalletInfo();

package/package.json

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