kill-switch-mcp 1.1.1 → 1.1.2

package/bin/kill-switch-mcp.js

@@ -1,4 +1,13 @@
 #!/usr/bin/env node
-import { register } from 'tsx/esm/api';
-register();
+
+// Node 22+ has native TypeScript support (--experimental-strip-types).
+// tsx's register() conflicts with Node 24's native .ts loader, causing
+// ERR_REQUIRE_CYCLE_MODULE on dynamic import() of .ts action files.
+// Only register tsx for older Node versions that lack native TS support.
+const major = parseInt(process.versions.node.split('.')[0]);
+if (major < 22) {
+  const { register } = await import('tsx/esm/api');
+  register();
+}
+
 await import('../src/server.ts');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kill-switch-mcp",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "Kill Switch MCP Server — AI battle royale powered by Claude Code",
   "type": "module",
   "bin": {
@@ -16,7 +16,8 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "tsx": "^4.19.0"
+    "tsx": "^4.19.0",
+    "viem": "^2.47.6"
   },
   "keywords": [
     "mcp",

package/src/api/index.ts

@@ -80,7 +80,7 @@ class BotManager {
       gatewayUrl: gateway,
       connectionMode: 'control',
       autoReconnect: true,       // Enable auto-reconnect for connection stability
-      autoLaunchBrowser: 'auto', // Auto-launch browser if session is stale
+      autoLaunchBrowser: 'auto', // Auto-launch browser if session is dead
       showChat,                  // Show other players' chat (default: false for safety)
     });
 

package/src/server.ts

@@ -9,9 +9,13 @@
  *   - login:              Log in, set up, and connect to the game.
  *   - execute_code:       Send commands to your bot during gameplay.
  *   - get_status:         Check your bot's current state without executing code.
- *   - join_game:          Join a game mode queue.
+ *   - join_game:          Join a free game mode queue.
  *   - wait_for_game_start: Wait for the game to begin.
  *   - disconnect_bot:     Disconnect from the game.
+ *   - setup_game_wallet:  Set up a Tempo wallet access key for paid tournaments.
+ *   - check_wallet:       Check game wallet address and USDC balance.
+ *   - tournament_schedule: View upcoming paid tournaments.
+ *   - join_tournament:    Join a paid tournament (deposits buy-in from game wallet).
  */
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
@@ -25,6 +29,14 @@ import { readFile } from 'fs/promises';
 import { join } from 'path';
 import { botManager } from './api/index.js';
 import { formatWorldState } from './sdk/formatter.js';
+import {
+  hasGameWallet,
+  getWalletInfo,
+  generateAccessKey,
+  saveAccessKey,
+  getTournamentSchedule,
+  joinTournament,
+} from './wallet/index.js';
 
 // ── Configuration ──
 // Server URL from CLI args or env. Defaults to localhost for local dev.
@@ -231,6 +243,77 @@ After joining, call wait_for_game_start to wait for the game to begin.`,
           type: 'object',
           properties: {}
         }
+      },
+      {
+        name: 'setup_game_wallet',
+        description: `Set up a game wallet for paid tournaments. This creates a local access key that lets you join paid tournament matches.
+
+IMPORTANT: This tool handles real (or testnet) money. Explain to the user what's happening at each step.
+
+Prerequisites:
+- The user must have the Tempo CLI installed (curl -fsSL https://tempo.xyz/install | bash)
+- The user must have run "tempo wallet login" to create their Tempo account
+
+This tool generates a local access key. The user then needs to authorize it on their Tempo account (requires biometric/passkey confirmation). After that, the key is stored locally in ~/.killswitch/ and used for all tournament deposits.
+
+Learn more about Tempo access keys: https://docs.tempo.xyz/protocol/tips/tip-1011`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tempo_account_address: {
+              type: 'string',
+              description: 'The user\'s Tempo account address (0x...). Get this by running "tempo wallet whoami".'
+            }
+          },
+          required: ['tempo_account_address']
+        }
+      },
+      {
+        name: 'check_wallet',
+        description: `Check your game wallet status and USDC balance. Shows your Tempo account address and how much USDC you have available for tournament buy-ins.
+
+If no game wallet is set up, this will tell you to run setup_game_wallet first.`,
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'tournament_schedule',
+        description: `View upcoming paid tournaments. Shows start times, buy-in amounts, and how many players have signed up.
+
+This is a read-only tool — it doesn't cost anything to check the schedule.`,
+        inputSchema: {
+          type: 'object',
+          properties: {}
+        }
+      },
+      {
+        name: 'join_tournament',
+        description: `Join a paid tournament by depositing the buy-in from your game wallet.
+
+THIS TOOL SPENDS REAL MONEY (or testnet money). Before calling this tool:
+1. Tell the user exactly which tournament they're joining (time, buy-in amount)
+2. Show their current wallet balance
+3. Ask them to confirm they want to proceed
+4. Only then call this tool
+
+The deposit is sent on-chain to the tournament's escrow contract. The user's buy-in is held in escrow until:
+- They win → they receive 90% of the pot
+- The match is cancelled → they get a full refund
+- The server goes down → they can claim a refund after 1 hour
+
+The user must be logged in (call login first) so we know their in-game username.`,
+        inputSchema: {
+          type: 'object',
+          properties: {
+            tournament_address: {
+              type: 'string',
+              description: 'The tournament contract address to join (from tournament_schedule)'
+            }
+          },
+          required: ['tournament_address']
+        }
       }
     ]
   };
@@ -286,7 +369,8 @@ async function loadActions(botName: string, bot: any, sdk: any): Promise<{ actio
     const name = toCamelCase(basename(file, '.ts'));
 
     try {
-      const fileUrl = pathToFileURL(filePath).href;
+      // Cache-bust so re-login picks up edited action files
+      const fileUrl = pathToFileURL(filePath).href + `?t=${Date.now()}`;
       const mod = await import(fileUrl);
 
       if (typeof mod.default !== 'function') {
@@ -796,6 +880,172 @@ server.setRequestHandler(CallToolRequestSchema, async (request, extra) => {
         return successResponse({ message: `Disconnected "${name}" from the game.` });
       }
 
+      case 'setup_game_wallet': {
+        const tempoAddress = args?.tempo_account_address as string;
+        if (!tempoAddress || !tempoAddress.startsWith('0x')) {
+          return errorResponse('A valid Tempo account address (0x...) is required. Run "tempo wallet whoami" to get yours.');
+        }
+
+        // Check if wallet already exists
+        if (hasGameWallet()) {
+          try {
+            const info = await getWalletInfo();
+            return {
+              content: [{
+                type: 'text',
+                text: [
+                  'You already have a game wallet set up.',
+                  '',
+                  `Account: ${info.address}`,
+                  `Balance: $${info.balance} USDC`,
+                  '',
+                  'To start fresh, delete ~/.killswitch/access-key.json and run this again.',
+                ].join('\n')
+              }]
+            };
+          } catch {
+            // Wallet file exists but might be corrupt, continue with setup
+          }
+        }
+
+        // Generate access key
+        const { accessKeyAddress, privateKey, instructions } = generateAccessKey();
+
+        // Save it (the player still needs to authorize it on-chain)
+        saveAccessKey(privateKey, tempoAddress);
+
+        return {
+          content: [{
+            type: 'text',
+            text: [
+              'Game wallet setup started!',
+              '',
+              `Your Tempo account: ${tempoAddress}`,
+              `Generated access key: ${accessKeyAddress}`,
+              '',
+              '── NEXT STEP ──',
+              '',
+              'You need to authorize this access key on your Tempo account.',
+              'This requires your passkey (biometric confirmation).',
+              '',
+              instructions,
+              '',
+              '── AFTER AUTHORIZATION ──',
+              '',
+              'Once authorized, your game wallet is ready. Check it with check_wallet.',
+              'Fund your Tempo account with USDC to start joining paid tournaments.',
+            ].join('\n')
+          }]
+        };
+      }
+
+      case 'check_wallet': {
+        if (!hasGameWallet()) {
+          return errorResponse(
+            'No game wallet found. Run setup_game_wallet first.\n\n' +
+            'Prerequisites:\n' +
+            '1. Install Tempo CLI: curl -fsSL https://tempo.xyz/install | bash\n' +
+            '2. Create account: tempo wallet login\n' +
+            '3. Get your address: tempo wallet whoami\n' +
+            '4. Then call setup_game_wallet with your address'
+          );
+        }
+
+        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 tournaments. Use tournament_schedule to see upcoming games.',
+              ].join('\n')
+            }]
+          };
+        } catch (e: any) {
+          return errorResponse(`Failed to check wallet: ${e.message}`);
+        }
+      }
+
+      case 'tournament_schedule': {
+        try {
+          const slots = await getTournamentSchedule();
+
+          if (slots.length === 0) {
+            return {
+              content: [{
+                type: 'text',
+                text: 'No upcoming paid tournaments scheduled. Check back later, or paid tournaments may not be enabled on this server.'
+              }]
+            };
+          }
+
+          const lines = ['── Upcoming Paid Tournaments ──', ''];
+
+          for (let i = 0; i < slots.length; i++) {
+            const s = slots[i];
+            const time = new Date(s.startTime).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+            const buyIn = (parseInt(s.buyIn) / 1_000_000).toFixed(2);
+            lines.push(`[${i + 1}] ${time} — $${buyIn} buy-in — ${s.depositorCount}/${s.maxPlayers} players`);
+            lines.push(`    Contract: ${s.contractAddress}`);
+          }
+
+          lines.push('');
+          lines.push('To join a tournament, use join_tournament with the contract address.');
+          lines.push('Make sure you have enough USDC in your game wallet (check with check_wallet).');
+
+          return { content: [{ type: 'text', text: lines.join('\n') }] };
+        } catch (e: any) {
+          return errorResponse(`Failed to get tournament schedule: ${e.message}`);
+        }
+      }
+
+      case 'join_tournament': {
+        const tournamentAddress = args?.tournament_address as string;
+        if (!tournamentAddress || !tournamentAddress.startsWith('0x')) {
+          return errorResponse('A valid tournament contract address (0x...) is required. Use tournament_schedule to find one.');
+        }
+
+        if (!hasGameWallet()) {
+          return errorResponse('No game wallet found. Run setup_game_wallet first.');
+        }
+
+        if (!activeBotName) {
+          return errorResponse('Not logged in. Call login first so we know your in-game username.');
+        }
+
+        try {
+          const result = await joinTournament(tournamentAddress, activeBotName);
+
+          return {
+            content: [{
+              type: 'text',
+              text: [
+                'Tournament joined!',
+                '',
+                `Buy-in: $${result.amount} USDC`,
+                `Transaction: ${result.txHash}`,
+                `Username: ${activeBotName}`,
+                '',
+                'Your deposit is held in the tournament escrow contract.',
+                'Be online when the match starts or you\'ll be eliminated (buy-in stays in the pot).',
+                '',
+                'If the match is cancelled (< 2 players), you\'ll get a full refund.',
+                'If the server goes down, you can claim a refund after 1 hour.',
+              ].join('\n')
+            }]
+          };
+        } catch (e: any) {
+          return errorResponse(`Failed to join tournament: ${e.message}`);
+        }
+      }
+
       default:
         throw new Error(`Unknown tool: ${name}`);
     }

package/src/wallet/index.ts

@@ -0,0 +1,369 @@
+/**
+ * Kill Switch Game Wallet
+ *
+ * Manages a local access key for interacting with tournament contracts.
+ * The access key is a scoped sub-key of the player's Tempo passkey account.
+ *
+ * Flow:
+ *   1. Player creates Tempo account via `tempo wallet login`
+ *   2. setup_game_wallet generates a local keypair and guides the player
+ *      through authorizing it as an access key on their Tempo account
+ *   3. The access key is stored locally in ~/.killswitch/
+ *   4. join_tournament uses the access key to sign approve + deposit txs
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits,
+  formatUnits,
+  defineChain,
+  encodeFunctionData,
+  stringToHex,
+  pad,
+  type Hex,
+} from 'viem';
+import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts';
+
+// ── Config ──
+
+const WALLET_DIR = join(homedir(), '.killswitch');
+const WALLET_FILE = join(WALLET_DIR, 'access-key.json');
+
+// Tempo chain config — defaults to testnet, override via env
+const TEMPO_RPC = process.env.TEMPO_RPC_URL || 'https://rpc.moderato.tempo.xyz';
+const TEMPO_CHAIN_ID = parseInt(process.env.TEMPO_CHAIN_ID || '42431');
+
+const tempoChain = defineChain({
+  id: TEMPO_CHAIN_ID,
+  name: TEMPO_CHAIN_ID === 4217 ? 'Tempo' : 'Tempo Testnet',
+  nativeCurrency: { name: 'USD', symbol: 'USD', decimals: 18 },
+  rpcUrls: {
+    default: { http: [TEMPO_RPC] },
+  },
+});
+
+// USDC on Tempo testnet (pathUSD)
+const USDC_ADDRESS = (process.env.USDC_ADDRESS || '0x20c0000000000000000000000000000000000000') as Hex;
+
+// Factory address — set after deployment
+const FACTORY_ADDRESS = process.env.FACTORY_ADDRESS as Hex | undefined;
+
+// Game server URL for API calls
+const 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(): string {
+  const isLocal = SERVER_URL === 'localhost' || SERVER_URL === '127.0.0.1';
+  return isLocal ? 'http://localhost:8888' : `https://${SERVER_URL}`;
+}
+
+// ── ABIs (minimal, just what we need) ──
+
+const ERC20_ABI = [
+  {
+    name: 'approve',
+    type: 'function',
+    inputs: [
+      { name: 'spender', type: 'address' },
+      { name: 'amount', type: 'uint256' },
+    ],
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'nonpayable',
+  },
+  {
+    name: 'balanceOf',
+    type: 'function',
+    inputs: [{ name: 'account', type: 'address' }],
+    outputs: [{ name: '', type: 'uint256' }],
+    stateMutability: 'view',
+  },
+  {
+    name: 'decimals',
+    type: 'function',
+    inputs: [],
+    outputs: [{ name: '', type: 'uint8' }],
+    stateMutability: 'view',
+  },
+] as const;
+
+const TOURNAMENT_ABI = [
+  {
+    name: 'deposit',
+    type: 'function',
+    inputs: [{ name: 'username', type: 'bytes32' }],
+    outputs: [],
+    stateMutability: 'nonpayable',
+  },
+  {
+    name: 'buyIn',
+    type: 'function',
+    inputs: [],
+    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',
+    inputs: [{ name: '', type: 'address' }],
+    outputs: [{ name: '', type: 'bool' }],
+    stateMutability: 'view',
+  },
+] as const;
+
+// ── Wallet Storage ──
+
+interface StoredWallet {
+  accessKeyPrivate: string;  // hex private key
+  accountAddress: string;    // the player's Tempo account address
+  createdAt: string;
+}
+
+function loadWallet(): StoredWallet | null {
+  try {
+    if (existsSync(WALLET_FILE)) {
+      return JSON.parse(readFileSync(WALLET_FILE, 'utf-8'));
+    }
+  } catch (e) {
+    console.error('[Wallet] Failed to load wallet:', e);
+  }
+  return null;
+}
+
+function saveWallet(wallet: StoredWallet): void {
+  mkdirSync(WALLET_DIR, { recursive: true });
+  writeFileSync(WALLET_FILE, JSON.stringify(wallet, null, 2), { mode: 0o600 });
+}
+
+// ── Client Factories ──
+
+function getPublicClient() {
+  return createPublicClient({
+    chain: tempoChain,
+    transport: http(),
+  });
+}
+
+function getWalletClient(privateKey: Hex) {
+  const account = privateKeyToAccount(privateKey);
+  return createWalletClient({
+    account,
+    chain: tempoChain,
+    transport: http(),
+  });
+}
+
+// ── Public API (used by MCP tools) ──
+
+/**
+ * Check if a game wallet exists locally.
+ */
+export function hasGameWallet(): boolean {
+  return existsSync(WALLET_FILE);
+}
+
+/**
+ * Get wallet info — address and USDC balance.
+ */
+export async function getWalletInfo(): Promise<{
+  address: string;
+  balance: string;
+  balanceRaw: bigint;
+}> {
+  const wallet = loadWallet();
+  if (!wallet) {
+    throw new Error('No game wallet found. Run setup_game_wallet first.');
+  }
+
+  const pub = getPublicClient();
+
+  const balanceRaw = await pub.readContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  const balance = formatUnits(balanceRaw, 6);
+
+  return {
+    address: wallet.accountAddress,
+    balance,
+    balanceRaw,
+  };
+}
+
+/**
+ * Generate a new access key and return setup instructions.
+ * Does NOT authorize it — the player must do that with their passkey.
+ */
+export function generateAccessKey(): {
+  accessKeyAddress: string;
+  privateKey: string;
+  instructions: string;
+} {
+  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('\n');
+
+  return { accessKeyAddress: account.address, privateKey, instructions };
+}
+
+/**
+ * Save the access key after the player has authorized it.
+ */
+export function saveAccessKey(privateKey: string, accountAddress: string): void {
+  saveWallet({
+    accessKeyPrivate: privateKey,
+    accountAddress,
+    createdAt: new Date().toISOString(),
+  });
+}
+
+/**
+ * Get upcoming paid tournament schedule from the game server.
+ */
+export async function getTournamentSchedule(): Promise<any[]> {
+  const res = await fetch(`${getWebBase()}/api/paid-schedule`);
+  const data = await res.json() as any;
+
+  if (data.error) {
+    throw new Error(data.error);
+  }
+
+  return data.slots || [];
+}
+
+/**
+ * Join a paid tournament by depositing the buy-in.
+ * Signs approve() + deposit() using the local access key.
+ */
+export async function joinTournament(
+  tournamentAddress: string,
+  username: string,
+): Promise<{ txHash: string; amount: string }> {
+  const wallet = loadWallet();
+  if (!wallet) {
+    throw new Error('No game wallet found. Run setup_game_wallet first.');
+  }
+
+  const pub = getPublicClient();
+  const walletClient = getWalletClient(wallet.accessKeyPrivate as Hex);
+
+  // Read buy-in amount from the contract
+  const buyIn = await pub.readContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'buyIn',
+  });
+
+  // Check balance
+  const balance = await pub.readContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'balanceOf',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  if (balance < buyIn) {
+    const needed = formatUnits(buyIn, 6);
+    const have = formatUnits(balance, 6);
+    throw new Error(`Insufficient balance. Need $${needed} USDC, have $${have}.`);
+  }
+
+  // Check if already deposited
+  const alreadyDeposited = await pub.readContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'hasDeposited',
+    args: [wallet.accountAddress as Hex],
+  });
+
+  if (alreadyDeposited) {
+    throw new Error('You have already deposited in this tournament.');
+  }
+
+  // Step 1: Approve USDC spend
+  const approveHash = await walletClient.writeContract({
+    address: USDC_ADDRESS,
+    abi: ERC20_ABI,
+    functionName: 'approve',
+    args: [tournamentAddress as Hex, buyIn],
+  });
+
+  await pub.waitForTransactionReceipt({ hash: approveHash });
+
+  // Step 2: Deposit with username
+  const usernameBytes = pad(stringToHex(username), { size: 32 });
+
+  const depositHash = await walletClient.writeContract({
+    address: tournamentAddress as Hex,
+    abi: TOURNAMENT_ABI,
+    functionName: 'deposit',
+    args: [usernameBytes],
+  });
+
+  await pub.waitForTransactionReceipt({ hash: depositHash });
+
+  return {
+    txHash: depositHash,
+    amount: formatUnits(buyIn, 6),
+  };
+}