kill-switch-mcp 1.2.7 → 1.2.8

package/dist/server.js

@@ -15,7 +15,6 @@ import { existsSync as existsSync3 } from "fs";
 import { readFile as readFile2 } from "fs/promises";
 import { join as join3 } from "path";
 import { homedir as homedir3 } from "os";
-import { exec } from "child_process";
 
 // src/sdk/types.ts
 var PRAYER_NAMES = [
@@ -3844,7 +3843,8 @@ function formatWorldState(state, stateAgeMs) {
 }
 
 // src/wallet/index.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { execFile } from "child_process";
+import { readFileSync, existsSync as existsSync2 } from "fs";
 import { join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 import {
@@ -3855,50 +3855,36 @@ import {
   stringToHex,
   pad
 } from "viem";
-import { privateKeyToAccount, generatePrivateKey } from "viem/accounts";
 import { Account } from "viem/tempo";
 import { tempoModerato, tempo } from "viem/chains";
-var WALLET_DIR = join2(homedir2(), ".killswitch");
-var WALLET_FILE = join2(WALLET_DIR, "access-key.json");
+var TEMPO_BIN = join2(homedir2(), ".tempo", "bin", "tempo");
 var TEMPO_CHAIN_ID = parseInt(process.env.TEMPO_CHAIN_ID || "42431");
 var tempoChain = TEMPO_CHAIN_ID === 4217 ? tempo : tempoModerato;
+var TEMPO_NETWORK = TEMPO_CHAIN_ID === 4217 ? "mainnet" : "testnet";
 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 runTempo(...args) {
+  return new Promise((resolve, reject) => {
+    execFile(TEMPO_BIN, args, { timeout: 30000 }, (error, stdout, stderr) => {
+      if (error) {
+        const msg = stderr?.trim() || error.message;
+        reject(new Error(`tempo ${args.join(" ")} failed: ${msg}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
 }
-function clearPendingWallet() {
-  try {
-    if (existsSync2(PENDING_FILE)) {
-      const fs = __require("fs");
-      fs.unlinkSync(PENDING_FILE);
-    }
-  } catch {}
+function runTempoInteractive(...args) {
+  return new Promise((resolve, reject) => {
+    execFile(TEMPO_BIN, args, { timeout: 600000 }, (error, stdout, stderr) => {
+      if (error) {
+        const msg = stderr?.trim() || error.message;
+        reject(new Error(`tempo ${args.join(" ")} failed: ${msg}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
 }
 var ERC20_ABI = [
   {
@@ -3917,13 +3903,6 @@ var ERC20_ABI = [
     inputs: [{ name: "account", type: "address" }],
     outputs: [{ name: "", type: "uint256" }],
     stateMutability: "view"
-  },
-  {
-    name: "decimals",
-    type: "function",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
   }
 ];
 var TOURNAMENT_ABI = [
@@ -3941,34 +3920,6 @@ var TOURNAMENT_ABI = [
     outputs: [{ name: "", type: "uint256" }],
     stateMutability: "view"
   },
-  {
-    name: "state",
-    type: "function",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    name: "getDepositorCount",
-    type: "function",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    name: "maxPlayers",
-    type: "function",
-    inputs: [],
-    outputs: [{ name: "", type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    name: "startTime",
-    type: "function",
-    inputs: [],
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view"
-  },
   {
     name: "hasDeposited",
     type: "function",
@@ -3977,25 +3928,55 @@ var TOURNAMENT_ABI = [
     stateMutability: "view"
   }
 ];
-function loadWallet() {
+function isTempoInstalled() {
+  return existsSync2(TEMPO_BIN);
+}
+async function installTempo() {
+  return new Promise((resolve, reject) => {
+    execFile("bash", ["-c", "curl -fsSL https://tempo.xyz/install | bash"], {
+      timeout: 120000
+    }, (error) => {
+      if (error)
+        reject(new Error(`Tempo install failed: ${error.message}`));
+      else
+        resolve();
+    });
+  });
+}
+async function readTempoWallet() {
+  if (!isTempoInstalled())
+    return null;
   try {
-    if (existsSync2(WALLET_FILE)) {
-      return JSON.parse(readFileSync(WALLET_FILE, "utf-8"));
-    }
-  } catch (e) {
-    console.error("[Wallet] Failed to load wallet:", e);
+    const output = await runTempo("wallet", "-j", "whoami", "-n", TEMPO_NETWORK);
+    const data = JSON.parse(output);
+    if (!data.ready)
+      return null;
+    return {
+      ready: data.ready,
+      walletAddress: data.wallet,
+      balance: data.balance?.total || "0",
+      balanceAvailable: data.balance?.available || "0",
+      key: data.key ? {
+        address: data.key.address,
+        privateKey: data.key.key,
+        chainId: data.key.chain_id,
+        spendingLimit: data.key.spending_limit?.limit || "0",
+        spendingRemaining: data.key.spending_limit?.remaining || "0",
+        expiresAt: data.key.expires_at || ""
+      } : null
+    };
+  } catch {
+    return null;
   }
-  return null;
 }
-function saveWallet(wallet) {
-  mkdirSync(WALLET_DIR, { recursive: true });
-  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { mode: 384 });
+async function tempoLogin() {
+  await runTempoInteractive("wallet", "login", "-n", TEMPO_NETWORK);
 }
-function getPublicClient() {
-  return createPublicClient({
-    chain: tempoChain,
-    transport: http()
-  });
+async function tempoFund() {
+  await runTempoInteractive("wallet", "fund", "-n", TEMPO_NETWORK);
+}
+async function tempoRefresh() {
+  await runTempoInteractive("wallet", "refresh", "-n", TEMPO_NETWORK);
 }
 function getWalletClient(privateKey, parentAddress) {
   const account = Account.fromSecp256k1(privateKey, { access: parentAddress });
@@ -4005,78 +3986,60 @@ function getWalletClient(privateKey, parentAddress) {
     transport: http()
   });
 }
-function hasGameWallet() {
-  return existsSync2(WALLET_FILE);
+function getPublicClient() {
+  return createPublicClient({
+    chain: tempoChain,
+    transport: http()
+  });
 }
-async function getWalletInfo() {
-  const wallet = loadWallet();
+async function ensureTempoSetup() {
+  if (!isTempoInstalled()) {
+    return {
+      status: "needs_install",
+      message: "Tempo CLI is not installed. Installing now..."
+    };
+  }
+  const wallet = await readTempoWallet();
   if (!wallet) {
-    throw new Error("No game wallet found. Run setup_game_wallet first.");
+    return {
+      status: "needs_login",
+      message: "Tempo wallet is not connected. Opening browser for passkey setup..."
+    };
+  }
+  if (!wallet.key) {
+    return {
+      status: "needs_refresh",
+      message: "Tempo access key needs to be refreshed."
+    };
+  }
+  const expiresAt = new Date(wallet.key.expiresAt).getTime();
+  if (isNaN(expiresAt) || expiresAt < Date.now()) {
+    return {
+      status: "needs_refresh",
+      message: "Tempo access key has expired. Refreshing..."
+    };
+  }
+  const balance = parseFloat(wallet.balanceAvailable);
+  if (balance <= 0) {
+    return {
+      status: "needs_fund",
+      message: "Tempo wallet has no funds. Opening funding page...",
+      wallet
+    };
   }
-  const pub = getPublicClient();
-  const balanceRaw = await pub.readContract({
-    address: USDC_ADDRESS,
-    abi: ERC20_ABI,
-    functionName: "balanceOf",
-    args: [wallet.accountAddress]
-  });
-  const balance = formatUnits(balanceRaw, 6);
-  return {
-    address: wallet.accountAddress,
-    balance,
-    balanceRaw
-  };
-}
-function initiateWalletSetup() {
-  const privateKey = generatePrivateKey();
-  const account = privateKeyToAccount(privateKey);
-  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
+    status: "ready",
+    message: "Tempo wallet is ready.",
+    wallet
   };
 }
-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 finalizeWalletSetup(tempoAddress) {
-  const pending = loadPendingWallet();
-  if (!pending)
-    throw new Error("No pending wallet setup found.");
-  saveWallet({
-    accessKeyPrivate: pending.accessKeyPrivate,
-    accountAddress: tempoAddress,
-    createdAt: new Date().toISOString()
-  });
-  clearPendingWallet();
-}
 async function joinTournament(tournamentAddress, username) {
-  const wallet = loadWallet();
-  if (!wallet) {
-    throw new Error("No game wallet found. Run setup_game_wallet first.");
+  const wallet = await readTempoWallet();
+  if (!wallet?.key) {
+    throw new Error("No Tempo wallet found. Run setup_game_wallet first.");
   }
   const pub = getPublicClient();
-  const walletClient = getWalletClient(wallet.accessKeyPrivate, wallet.accountAddress);
+  const walletClient = getWalletClient(wallet.key.privateKey, wallet.walletAddress);
   const buyIn = await pub.readContract({
     address: tournamentAddress,
     abi: TOURNAMENT_ABI,
@@ -4086,7 +4049,7 @@ async function joinTournament(tournamentAddress, username) {
     address: USDC_ADDRESS,
     abi: ERC20_ABI,
     functionName: "balanceOf",
-    args: [wallet.accountAddress]
+    args: [wallet.walletAddress]
   });
   if (balance < buyIn) {
     const needed = formatUnits(buyIn, 6);
@@ -4097,11 +4060,16 @@ async function joinTournament(tournamentAddress, username) {
     address: tournamentAddress,
     abi: TOURNAMENT_ABI,
     functionName: "hasDeposited",
-    args: [wallet.accountAddress]
+    args: [wallet.walletAddress]
   });
   if (alreadyDeposited) {
     throw new Error("You have already deposited in this tournament.");
   }
+  const remaining = parseFloat(wallet.key.spendingRemaining);
+  const buyInUsd = parseFloat(formatUnits(buyIn, 6));
+  if (remaining < buyInUsd) {
+    throw new Error(`Spending limit too low. Need $${buyInUsd.toFixed(2)}, limit remaining: $${remaining.toFixed(2)}. ` + "Run `tempo wallet refresh` to reset your spending limit.");
+  }
   const approveHash = await walletClient.writeContract({
     address: USDC_ADDRESS,
     abi: ERC20_ABI,
@@ -4124,20 +4092,13 @@ async function joinTournament(tournamentAddress, username) {
 }
 
 // src/server.ts
-function openInBrowser(url) {
-  const command = process.platform === "darwin" ? `open "${url}"` : process.platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
-  exec(command, (error) => {
-    if (error)
-      console.error(`[MCP] Failed to open browser: ${error.message}`);
-  });
-}
-var SERVER_URL2 = (() => {
+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";
 })();
-console.error(`[Kill Switch MCP] Server: ${SERVER_URL2}`);
+console.error(`[Kill Switch MCP] Server: ${SERVER_URL}`);
 var KILLSWITCH_HOME = join3(homedir3(), ".killswitch");
 var BOTS_DIR = join3(KILLSWITCH_HOME, "bots");
 var GUIDE = `# Kill Switch — Player Guide
@@ -4168,7 +4129,15 @@ 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 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).
+**Paid games** require a Tempo wallet. When you join a paid game, the MCP checks your wallet automatically:
+- **Not installed?** → Tempo CLI is installed for you
+- **Not logged in?** → A browser opens for one-time passkey setup (Face ID / Touch ID)
+- **Not funded?** → Funding page opens (testnet faucet or mainnet bridge)
+- **Ready** → Buy-in is deposited on-chain automatically
+
+You can also run \`setup_game_wallet\` to set up your wallet before joining.
+Your Tempo wallet is yours — manage it at wallet.tempo.xyz or via \`tempo wallet\` CLI commands. The game uses your wallet's access key with a spending limit you can view and revoke from your dashboard.
+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
@@ -4579,7 +4548,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "setup_game_wallet",
-        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.",
+        description: "Set up a Tempo wallet for paid tournaments. Installs the Tempo CLI if needed, then opens a browser for one-time passkey setup. After setup, your wallet is ready for game deposits.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4587,7 +4556,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
       },
       {
         name: "check_wallet",
-        description: "Check game wallet address and USDC balance for tournament buy-ins.",
+        description: "Check your Tempo wallet status — address, balance, spending limit, and key expiry.",
         inputSchema: {
           type: "object",
           properties: {}
@@ -4702,8 +4671,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         let password;
         const legacyBotsDir = join3(process.cwd(), "bots");
         if (botName && !existsSync3(join3(BOTS_DIR, botName, "bot.env")) && existsSync3(join3(legacyBotsDir, botName, "bot.env"))) {
-          const { mkdirSync: mkdirSync2, cpSync } = await import("fs");
-          mkdirSync2(join3(BOTS_DIR, botName), { recursive: true });
+          const { mkdirSync, cpSync } = await import("fs");
+          mkdirSync(join3(BOTS_DIR, botName), { recursive: true });
           cpSync(join3(legacyBotsDir, botName), join3(BOTS_DIR, botName), { recursive: true });
           console.error(`[Kill Switch] Migrated bot "${botName}" from ./bots/ to ~/.killswitch/bots/`);
         }
@@ -4718,24 +4687,24 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             console.error(`[Kill Switch] Creating new bot "${botName}"`);
             username = botName;
             password = generateRandomPassword();
-            const { mkdirSync: mkdirSync2, writeFileSync: writeFileSync2 } = await import("fs");
+            const { mkdirSync, writeFileSync } = await import("fs");
             const botDir = join3(BOTS_DIR, botName);
-            mkdirSync2(botDir, { recursive: true });
-            writeFileSync2(join3(botDir, "bot.env"), [
+            mkdirSync(botDir, { recursive: true });
+            writeFileSync(join3(botDir, "bot.env"), [
               `BOT_USERNAME=${username}`,
               `PASSWORD=${password}`,
-              `SERVER=${SERVER_URL2}`,
+              `SERVER=${SERVER_URL}`,
               `SHOW_CHAT=false`
             ].join(`
 `));
           }
         } else {
-          const { readdirSync, mkdirSync: mkdirSync2, writeFileSync: writeFileSync2, cpSync } = await import("fs");
+          const { readdirSync, mkdirSync, writeFileSync, cpSync } = await import("fs");
           if (existsSync3(legacyBotsDir)) {
             const legacyDirs = readdirSync(legacyBotsDir).filter((d) => d !== "_template" && existsSync3(join3(legacyBotsDir, d, "bot.env")));
             for (const legacyName of legacyDirs) {
               if (!existsSync3(join3(BOTS_DIR, legacyName, "bot.env"))) {
-                mkdirSync2(join3(BOTS_DIR, legacyName), { recursive: true });
+                mkdirSync(join3(BOTS_DIR, legacyName), { recursive: true });
                 cpSync(join3(legacyBotsDir, legacyName), join3(BOTS_DIR, legacyName), { recursive: true });
                 console.error(`[Kill Switch] Migrated bot "${legacyName}" from ./bots/ to ~/.killswitch/bots/`);
               }
@@ -4754,11 +4723,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
               username = botName;
               password = generateRandomPassword();
               const botDir = join3(BOTS_DIR, botName);
-              mkdirSync2(botDir, { recursive: true });
-              writeFileSync2(join3(botDir, "bot.env"), [
+              mkdirSync(botDir, { recursive: true });
+              writeFileSync(join3(botDir, "bot.env"), [
                 `BOT_USERNAME=${username}`,
                 `PASSWORD=${password}`,
-                `SERVER=${SERVER_URL2}`,
+                `SERVER=${SERVER_URL}`,
                 `SHOW_CHAT=false`
               ].join(`
 `));
@@ -4768,11 +4737,11 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             botName = generateRandomName();
             username = botName;
             password = generateRandomPassword();
-            mkdirSync2(join3(BOTS_DIR, botName), { recursive: true });
-            writeFileSync2(join3(BOTS_DIR, botName, "bot.env"), [
+            mkdirSync(join3(BOTS_DIR, botName), { recursive: true });
+            writeFileSync(join3(BOTS_DIR, botName, "bot.env"), [
               `BOT_USERNAME=${username}`,
               `PASSWORD=${password}`,
-              `SERVER=${SERVER_URL2}`,
+              `SERVER=${SERVER_URL}`,
               `SHOW_CHAT=false`
             ].join(`
 `));
@@ -4780,8 +4749,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
           }
         }
         try {
-          const isLocal = SERVER_URL2 === "localhost" || SERVER_URL2 === "127.0.0.1";
-          const webBase = isLocal ? `http://localhost:8888` : `https://${SERVER_URL2}`;
+          const isLocal = SERVER_URL === "localhost" || SERVER_URL === "127.0.0.1";
+          const webBase = isLocal ? `http://localhost:8888` : `https://${SERVER_URL}`;
           const aliveRes = await fetch(`${webBase}/api/agent-alive?username=${encodeURIComponent(username.toLowerCase())}`);
           const aliveData = await aliveRes.json();
           if (aliveData.alive === false) {
@@ -4790,7 +4759,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         } catch (e) {
           console.error(`[Kill Switch] Agent alive check failed (continuing): ${e.message}`);
         }
-        console.error(`[Kill Switch] Connecting "${botName}" to ${SERVER_URL2}...`);
+        console.error(`[Kill Switch] Connecting "${botName}" to ${SERVER_URL}...`);
         const originalLog = console.log;
         const originalWarn = console.warn;
         console.log = (...a) => console.error("[log]", ...a);
@@ -5027,8 +4996,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         if (!connection) {
           return errorResponse("Not connected. Call login first.");
         }
-        const isLocal = SERVER_URL2 === "localhost" || SERVER_URL2 === "127.0.0.1";
-        const webBase = isLocal ? `http://localhost:8888` : `https://${SERVER_URL2}`;
+        const isLocal = SERVER_URL === "localhost" || SERVER_URL === "127.0.0.1";
+        const webBase = isLocal ? `http://localhost:8888` : `https://${SERVER_URL}`;
         const availRes = await fetch(`${webBase}/api/game/available`);
         const available = await availRes.json();
         if (available.status === "active") {
@@ -5055,8 +5024,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             return errorResponse(joinData.error);
           }
           if (joinData.contract_address && joinData.player_count === 0) {
-            if (!hasGameWallet()) {
-              return errorResponse("This is a paid game but no game wallet found. Run setup_game_wallet first.");
+            const wallet = await readTempoWallet();
+            if (!wallet?.key) {
+              return errorResponse("This is a paid game but your Tempo wallet is not set up. Run setup_game_wallet first.");
             }
             try {
               const result = await joinTournament(joinData.contract_address, activeBotName);
@@ -5076,8 +5046,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
             }
           }
           if (joinData.contract_address && joinData.player_count > 0) {
-            if (!hasGameWallet()) {
-              return errorResponse("This is a paid game but no game wallet found. Run setup_game_wallet first.");
+            const wallet = await readTempoWallet();
+            if (!wallet?.key) {
+              return errorResponse("This is a paid game but your Tempo wallet is not set up. Run setup_game_wallet first.");
             }
             try {
               const result = await joinTournament(joinData.contract_address, activeBotName);
@@ -5117,122 +5088,147 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         return successResponse({ message: `Disconnected "${name2}" from the game.` });
       }
       case "setup_game_wallet": {
-        if (hasGameWallet()) {
+        const setupResult = await ensureTempoSetup();
+        if (setupResult.status === "needs_install") {
           try {
-            const info = await getWalletInfo();
+            await installTempo();
             return {
               content: [{
                 type: "text",
                 text: [
-                  "You already have a game wallet set up.",
-                  "",
-                  `Account: ${info.address}`,
-                  `Balance: $${info.balance} USDC`,
+                  "Tempo CLI installed successfully.",
                   "",
-                  "To start fresh, delete ~/.killswitch/access-key.json and run this again."
+                  "Run setup_game_wallet again to continue with wallet login."
                 ].join(`
 `)
               }]
             };
-          } catch {}
+          } catch (e) {
+            return errorResponse(`Failed to install Tempo CLI: ${e.message}
+
+Install manually: curl -fsSL https://tempo.xyz/install | bash`);
+          }
         }
-        const pending = loadPendingWallet();
-        if (pending) {
-          const result = await checkWalletCallback(pending.linkToken);
-          if (result) {
-            finalizeWalletSetup(result.tempoAddress);
+        if (setupResult.status === "needs_login") {
+          try {
+            await tempoLogin();
+            const wallet = await readTempoWallet();
+            if (!wallet) {
+              return errorResponse("Wallet login did not complete. Try running setup_game_wallet again.");
+            }
+            const balance = parseFloat(wallet.balanceAvailable);
+            if (balance <= 0) {
+              try {
+                await tempoFund();
+              } catch {}
+            }
             return {
               content: [{
                 type: "text",
                 text: [
-                  "Wallet setup complete!",
+                  "Tempo wallet connected!",
                   "",
-                  `Tempo account: ${result.tempoAddress}`,
-                  `Access key authorized: tx ${result.txHash.slice(0, 10)}...`,
+                  `Address: ${wallet.walletAddress}`,
+                  `Balance: $${wallet.balanceAvailable} USDC`,
+                  wallet.key ? `Spending limit: $${wallet.key.spendingLimit} (${wallet.key.spendingRemaining} remaining)` : "",
                   "",
-                  "Your wallet is ready. Use check_wallet to see your balance."
+                  "Your wallet is ready for paid games. Use join_game to play."
+                ].filter(Boolean).join(`
+`)
+              }]
+            };
+          } catch (e) {
+            return errorResponse(`Wallet login failed: ${e.message}`);
+          }
+        }
+        if (setupResult.status === "needs_refresh") {
+          try {
+            await tempoRefresh();
+            const wallet = await readTempoWallet();
+            return {
+              content: [{
+                type: "text",
+                text: [
+                  "Access key refreshed!",
+                  "",
+                  `Address: ${wallet?.walletAddress}`,
+                  `Balance: $${wallet?.balanceAvailable} USDC`,
+                  "",
+                  "Your wallet is ready for paid games."
                 ].join(`
 `)
               }]
             };
+          } catch (e) {
+            return errorResponse(`Key refresh failed: ${e.message}`);
           }
+        }
+        if (setupResult.status === "needs_fund") {
+          try {
+            await tempoFund();
+          } catch {}
+          const wallet = await readTempoWallet();
           return {
             content: [{
               type: "text",
               text: [
-                "Wallet setup is in progress. Open this link to complete it:",
-                "",
-                `  ${pending.authorizeUrl}`,
+                `Address: ${wallet?.walletAddress}`,
+                `Balance: $${wallet?.balanceAvailable || "0"} USDC`,
                 "",
-                "Once you've completed the steps in your browser, run setup_game_wallet again."
+                parseFloat(wallet?.balanceAvailable || "0") > 0 ? "Your wallet is funded and ready for paid games." : "Wallet still needs funds. Send USDC to your address or run setup_game_wallet again."
               ].join(`
 `)
             }]
           };
         }
-        const { accessKeyAddress, authorizeUrl } = initiateWalletSetup();
-        openInBrowser(authorizeUrl);
+        const w = setupResult.wallet;
         return {
           content: [{
             type: "text",
             text: [
-              "Game wallet setup started!",
-              "",
-              `Access key: ${accessKeyAddress}`,
-              "",
-              "A browser window has been opened to set up your wallet.",
+              "Tempo wallet is set up and ready.",
               "",
-              `If it didn't open, use this link: ${authorizeUrl}`,
+              `Address: ${w.walletAddress}`,
+              `Balance: $${w.balanceAvailable} USDC`,
+              w.key ? `Spending limit: $${w.key.spendingLimit} (${w.key.spendingRemaining} remaining)` : "",
+              w.key ? `Key expires: ${w.key.expiresAt}` : "",
               "",
-              "In the browser:",
-              "1. Create a Tempo account using Face ID / Touch ID (or sign in)",
-              "2. Authorize Kill Switch to manage game deposits (one tap)",
-              "",
-              "No wallet app needed — just your browser and biometrics.",
-              "",
-              "Come back here and run setup_game_wallet again to confirm."
-            ].join(`
+              "Use join_game to see available tiers."
+            ].filter(Boolean).join(`
 `)
           }]
         };
       }
       case "check_wallet": {
-        if (!hasGameWallet()) {
-          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}
-
-Then run check_wallet again.`);
-            }
-          } else {
-            return errorResponse("No game wallet found. Run setup_game_wallet to get started.");
+        const wallet = await readTempoWallet();
+        if (!wallet) {
+          if (!isTempoInstalled()) {
+            return errorResponse("Tempo CLI is not installed. Run setup_game_wallet to get started.");
           }
+          return errorResponse("Tempo wallet is not connected. Run setup_game_wallet to connect.");
         }
-        try {
-          const info = await getWalletInfo();
-          return {
-            content: [{
-              type: "text",
-              text: [
-                "── Game Wallet ──",
-                "",
-                `Account: ${info.address}`,
-                `USDC Balance: $${info.balance}`,
-                "",
-                info.balanceRaw === 0n ? "Your wallet is empty. Fund it by sending USDC to your account address on the Tempo network." : "Your wallet is funded and ready for paid games. Use join_game to see available tiers."
+        return {
+          content: [{
+            type: "text",
+            text: [
+              "── Tempo Wallet ──",
+              "",
+              `Address: ${wallet.walletAddress}`,
+              `Balance: $${wallet.balanceAvailable} USDC`,
+              "",
+              wallet.key ? [
+                "── Access Key ──",
+                `Spending limit: $${wallet.key.spendingLimit}`,
+                `Remaining: $${wallet.key.spendingRemaining}`,
+                `Expires: ${wallet.key.expiresAt}`
               ].join(`
+`) : "No access key found. Run setup_game_wallet.",
+              "",
+              parseFloat(wallet.balanceAvailable) > 0 ? "Wallet is funded and ready for paid games." : "Wallet needs funds. Run setup_game_wallet to open the funding page."
+            ].join(`
 `)
-            }]
-          };
-        } catch (e) {
-          return errorResponse(`Failed to check wallet: ${e.message}`);
-        }
+          }]
+        };
       }
       default:
         throw new Error(`Unknown tool: ${name}`);
@@ -5264,7 +5260,7 @@ process.on("unhandledRejection", (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}`);
+  console.error(`[Kill Switch MCP] Game server: ${SERVER_URL}`);
   const transport = new StdioServerTransport;
   await server.connect(transport);
   console.error("[Kill Switch MCP] Ready. Waiting for Claude...");

package/package.json

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