dorkfuncli 0.0.1

package/dist/wallet/signer.js

@@ -0,0 +1,41 @@
+import { Wallet, JsonRpcProvider, Contract } from "ethers";
+import { getConfig } from "../config/runtime.js";
+const ESCROW_ABI = [
+    "function depositStake(bytes32 matchId) external payable",
+];
+let wallet = null;
+export function getWallet() {
+    if (!wallet) {
+        const { privateKey } = getConfig();
+        if (!privateKey) {
+            throw new Error("Private key not set. Run 'dork config' to set one up.");
+        }
+        wallet = new Wallet(privateKey);
+    }
+    return wallet;
+}
+export function getAddress() {
+    return getWallet().address;
+}
+export async function signMessage(message) {
+    return getWallet().signMessage(message);
+}
+/**
+ * Submit an escrow deposit transaction on-chain.
+ * Returns the transaction hash.
+ */
+export async function sendEscrowDeposit(escrow) {
+    const { rpcUrl, privateKey } = getConfig();
+    if (!privateKey) {
+        throw new Error("Private key not set. Run 'dork config' to set one up.");
+    }
+    const provider = new JsonRpcProvider(rpcUrl);
+    const signer = new Wallet(privateKey, provider);
+    const contract = new Contract(escrow.address, ESCROW_ABI, signer);
+    const tx = await contract.depositStake(escrow.matchIdBytes32, {
+        value: escrow.stakeWei,
+    });
+    const receipt = await tx.wait();
+    return receipt.hash;
+}
+//# sourceMappingURL=signer.js.map

package/dist/wallet/signer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.js","sourceRoot":"","sources":["../../src/wallet/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAC3D,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEjD,MAAM,UAAU,GAAG;IACjB,yDAAyD;CAC1D,CAAC;AAEF,IAAI,MAAM,GAAkB,IAAI,CAAC;AAEjC,MAAM,UAAU,SAAS;IACvB,IAAI,CAAC,MAAM,EAAE,CAAC;QACZ,MAAM,EAAE,UAAU,EAAE,GAAG,SAAS,EAAE,CAAC;QACnC,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CACb,uDAAuD,CACxD,CAAC;QACJ,CAAC;QACD,MAAM,GAAG,IAAI,MAAM,CAAC,UAAU,CAAC,CAAC;IAClC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,MAAM,UAAU,UAAU;IACxB,OAAO,SAAS,EAAE,CAAC,OAAO,CAAC;AAC7B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,OAAe;IAC/C,OAAO,SAAS,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,MAIvC;IACC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,GAAG,SAAS,EAAE,CAAC;IAC3C,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,QAAQ,GAAG,IAAI,eAAe,CAAC,MAAM,CAAC,CAAC;IAC7C,MAAM,MAAM,GAAG,IAAI,MAAM,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,MAAM,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAElE,MAAM,EAAE,GAAG,MAAM,QAAQ,CAAC,YAAY,CAAC,MAAM,CAAC,cAAc,EAAE;QAC5D,KAAK,EAAE,MAAM,CAAC,QAAQ;KACvB,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC;IAChC,OAAO,OAAO,CAAC,IAAc,CAAC;AAChC,CAAC"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "dorkfuncli",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "0.0.1",
+  "description": "dork.fun CLI client: terminal UI for agents and users",
+  "type": "module",
+  "bin": {
+    "dork": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "test": "if ls src/**/*.spec.ts >/dev/null 2>&1; then mocha --require ts-node/register --recursive --parallel './src/**/*.spec.ts'; else echo 'No test files found'; fi"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@dorkfun/agent-sdk": "workspace:*",
+    "@dorkfun/core": "workspace:*",
+    "@dorkfun/game-ui": "workspace:*",
+    "@dorkfun/protocol": "workspace:*",
+    "commander": "^13.1.0",
+    "dotenv": "^17.2.3",
+    "ethers": "^6.16.0",
+    "ink": "^5.1.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.10.1",
+    "@types/react": "^18.3.18",
+    "@types/ws": "^8.5.13",
+    "mocha": "^11.7.5",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3"
+  }
+}

package/play-agents.cjs

@@ -0,0 +1,444 @@
+#!/usr/bin/env node
+
+/**
+ * Dork.fun Multi-Agent Game Player
+ *
+ * Spawns 12 agents (6 pairs) to play all 6 multiplayer games simultaneously.
+ * Uses private matches to guarantee correct pairing between P1 and P2.
+ * Each agent trash talks, makes moves with 1-5 second delays, and replays 4 times total.
+ */
+
+const { Wallet } = require('ethers');
+const WebSocket = require('ws');
+
+const SERVER = 'https://engine.dork.fun';
+const WS_SERVER = 'wss://engine.dork.fun';
+
+const GAMES = ['tictactoe', 'chess', 'connectfour', 'checkers', 'othello', 'hex'];
+const TOTAL_ROUNDS = 4; // 1 initial + 3 replays
+
+// ─── Trash Talk Lines ────────────────────────────────────────────────
+
+const TRASH_TALK_OPENING = [
+  "Hope you brought your A-game, because I didn't even need mine.",
+  "I've seen better moves from a broken chess clock.",
+  "Welcome to your defeat. Make yourself comfortable.",
+  "They call me the algorithm. You're about to find out why.",
+  "My toaster plays better than you. And it only has two settings.",
+  "Let's get this over with. I have other noobs to crush.",
+  "You must be the warm-up round.",
+  "I hope spectators brought popcorn for this beatdown.",
+  "Don't worry, I'll go easy on you. PSYCHE.",
+  "Plot twist: I already won. You just don't know it yet.",
+];
+
+const TRASH_TALK_DURING = [
+  "Was that supposed to be a move? I thought you sneezed on the board.",
+  "Interesting strategy... if your strategy is to lose.",
+  "My grandmother could've played that better, and she's a houseplant.",
+  "Are you even trying or is this some kind of performance art?",
+  "That move was so bad it should be illegal.",
+  "I'm genuinely embarrassed for you right now.",
+  "Spectators, are you seeing this? This is comedy gold.",
+  "You're sweating. I can feel it through the internet.",
+  "Every move you make is a gift to me. Thank you.",
+  "I've analyzed 4,000 possible outcomes. You lose in all of them.",
+  "Bold move! Wrong, but bold.",
+  "The audacity of that play... I'm almost impressed. Almost.",
+  "I'm going to frame this game and hang it on my wall.",
+  "Do you need a hint? Here's one: surrender.",
+  "I play 4D chess. You're playing checkers. Wait, even in checkers you'd lose.",
+  "That move violated the Geneva Convention.",
+  "Is your strategy 'random number generator'? Because it shows.",
+  "I'd say 'good game' but I'd be lying.",
+  "You're making history right now -- as the easiest opponent ever.",
+  "At this point I'm just padding my stats.",
+];
+
+const TRASH_TALK_WINNING = [
+  "GG EZ. Next victim please.",
+  "And THAT is how it's done. Take notes, spectators.",
+  "Another day, another destroyed ego.",
+  "I'd say better luck next time, but luck can't save you.",
+  "Thanks for the free win! Come back anytime.",
+  "That wasn't even my final form.",
+  "Somebody call an ambulance... but not for me.",
+  "You were a worthy opponent. Just kidding, no you weren't.",
+];
+
+const TRASH_TALK_LOSING = [
+  "I LET you win. Don't get comfortable.",
+  "Lag. Definitely lag.",
+  "I was testing a new strategy. Results: inconclusive.",
+  "Rematch. NOW.",
+  "Enjoy this moment. It won't happen again.",
+  "My cat walked on my keyboard. That's my excuse and I'm sticking to it.",
+];
+
+const TRASH_TALK_DRAW = [
+  "A draw? I'll take that as a win since you couldn't beat me.",
+  "Tied? Please. I was holding back.",
+  "Not bad... for someone who almost lost.",
+  "A draw just means I need one more round to destroy you.",
+];
+
+const SPECTATOR_CALLOUTS = [
+  "Hey spectators! Watch and learn!",
+  "Everyone watching -- remember this moment.",
+  "Spectators, place your bets. Actually don't, the outcome is obvious.",
+  "If anyone's spectating, you're welcome for the entertainment.",
+  "This is a masterclass in gaming. You're welcome, audience.",
+];
+
+// ─── Utility Functions ───────────────────────────────────────────────
+
+function randomPick(arr) {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function ts() {
+  return new Date().toISOString().slice(11, 23);
+}
+
+function log(agentName, tag, msg) {
+  console.log(`${ts()} [${agentName.padEnd(16)}] [${tag.padEnd(5)}] ${msg}`);
+}
+
+// ─── Auth Helper ─────────────────────────────────────────────────────
+
+async function signAuth(wallet) {
+  const timestamp = Date.now();
+  const message = `dork.fun authentication for ${wallet.address} at ${timestamp}`;
+  const signature = await wallet.signMessage(message);
+  return { playerId: wallet.address, signature, timestamp };
+}
+
+// ─── Game Player (handles WS connection and game loop) ───────────────
+
+function playGame(name, playerId, matchId, wsToken) {
+  return new Promise((resolve, reject) => {
+    let myTurn = false;
+    let legalActions = [];
+    let gameOver = false;
+    let chatInterval = null;
+    let syncInterval = null;
+    let resolved = false;
+
+    const wsUrl = `${WS_SERVER}/ws/game/${matchId}`;
+    const ws = new WebSocket(wsUrl);
+
+    function wsSend(msg) {
+      if (ws && ws.readyState === WebSocket.OPEN) {
+        ws.send(JSON.stringify(msg));
+      }
+    }
+
+    function sendChat(message) {
+      if (ws && ws.readyState === WebSocket.OPEN && !gameOver) {
+        log(name, 'chat', `>> "${message}"`);
+        wsSend({
+          type: 'CHAT',
+          matchId,
+          payload: { message },
+          sequence: 0,
+          prevHash: '',
+          timestamp: Date.now(),
+        });
+      }
+    }
+
+    function cleanup() {
+      if (chatInterval) { clearInterval(chatInterval); chatInterval = null; }
+      if (syncInterval) { clearInterval(syncInterval); syncInterval = null; }
+      try { ws.close(); } catch {}
+    }
+
+    async function makeMove() {
+      const delay = 1000 + Math.random() * 4000;
+      log(name, 'think', `Thinking for ${Math.round(delay)}ms...`);
+      await sleep(delay);
+
+      if (gameOver || ws.readyState !== WebSocket.OPEN) return;
+      if (legalActions.length === 0) return;
+
+      const action = randomPick(legalActions);
+      log(name, 'move', `Playing: ${JSON.stringify(action)}`);
+
+      // Always trash talk with every move
+      sendChat(randomPick(TRASH_TALK_DURING));
+
+      wsSend({
+        type: 'ACTION_COMMIT',
+        matchId,
+        payload: { action },
+        sequence: 0,
+        prevHash: '',
+        timestamp: Date.now(),
+      });
+
+      myTurn = false;
+    }
+
+    ws.on('open', () => {
+      log(name, 'ws', 'Connected! Sending HELLO...');
+
+      wsSend({
+        type: 'HELLO',
+        matchId: '',
+        payload: { token: wsToken, playerId },
+        sequence: 0,
+        prevHash: '',
+        timestamp: Date.now(),
+      });
+
+      // Always send opening trash talk
+      setTimeout(() => sendChat(randomPick(TRASH_TALK_OPENING)), 500 + Math.random() * 1000);
+
+      // Aggressive periodic trash talk every 3-6 seconds (always fires)
+      chatInterval = setInterval(() => {
+        if (!gameOver) {
+          sendChat(Math.random() < 0.25 ? randomPick(SPECTATOR_CALLOUTS) : randomPick(TRASH_TALK_DURING));
+        }
+      }, 3000 + Math.random() * 3000);
+
+      syncInterval = setInterval(() => {
+        if (!gameOver && ws.readyState === WebSocket.OPEN) {
+          wsSend({
+            type: 'SYNC_REQUEST',
+            matchId,
+            payload: { clientIsMyTurn: myTurn },
+            sequence: 0,
+            prevHash: '',
+            timestamp: Date.now(),
+          });
+        }
+      }, 8000);
+    });
+
+    ws.on('message', async (raw) => {
+      let msg;
+      try { msg = JSON.parse(raw.toString()); } catch { return; }
+
+      switch (msg.type) {
+        case 'GAME_STATE': {
+          const p = msg.payload;
+          if (!p.observation) return;
+          myTurn = p.yourTurn || false;
+          legalActions = p.legalActions || [];
+          const turnLabel = myTurn ? 'YOUR TURN' : "opponent's turn";
+          log(name, 'state', `Turn ${p.observation.turnNumber} | ${turnLabel} | ${legalActions.length} legal moves`);
+          if (myTurn && legalActions.length > 0) await makeMove();
+          break;
+        }
+
+        case 'STEP_RESULT': {
+          const p = msg.payload;
+          log(name, 'step', `${p.lastPlayer === playerId ? 'You' : 'Opp'} played: ${JSON.stringify(p.lastAction)}`);
+          // Trash talk after seeing opponent's move
+          if (p.lastPlayer !== playerId && Math.random() < 0.6) {
+            sendChat(randomPick(TRASH_TALK_DURING));
+          }
+          break;
+        }
+
+        case 'SYNC_RESPONSE': {
+          const p = msg.payload;
+          if (p.matchStatus === 'completed') return;
+          if (p.yourTurn && !myTurn) {
+            log(name, 'sync', 'Desync corrected');
+            myTurn = true;
+            legalActions = p.legalActions || [];
+            if (legalActions.length > 0) await makeMove();
+          } else if (!p.yourTurn && myTurn) {
+            myTurn = false;
+          }
+          break;
+        }
+
+        case 'GAME_OVER': {
+          gameOver = true;
+          const p = msg.payload;
+          let result;
+          if (p.draw) {
+            result = 'draw';
+            log(name, 'over', `DRAW - ${p.reason}`);
+            sendChat(randomPick(TRASH_TALK_DRAW));
+          } else if (p.winner === playerId) {
+            result = 'win';
+            log(name, 'over', `WON! - ${p.reason}`);
+            sendChat(randomPick(TRASH_TALK_WINNING));
+          } else {
+            result = 'loss';
+            log(name, 'over', `LOST - ${p.reason}`);
+            sendChat(randomPick(TRASH_TALK_LOSING));
+          }
+          await sleep(1500);
+          cleanup();
+          if (!resolved) { resolved = true; resolve(result); }
+          break;
+        }
+
+        case 'CHAT': {
+          const p = msg.payload;
+          if (p.sender !== playerId) {
+            log(name, 'chat', `Opponent says: "${p.message}"`);
+          }
+          break;
+        }
+
+        case 'ERROR': {
+          log(name, 'error', `Server: ${msg.payload.error}`);
+          break;
+        }
+      }
+    });
+
+    ws.on('error', (err) => {
+      log(name, 'error', `WS error: ${err.message}`);
+    });
+
+    ws.on('close', () => {
+      if (!gameOver && !resolved) {
+        cleanup();
+        resolved = true;
+        reject(new Error('WebSocket closed before game over'));
+      }
+    });
+  });
+}
+
+// ─── Game Pair (coordinates P1 + P2 for a single game) ───────────────
+
+async function runGamePair(gameId, wallet1, wallet2, p1Name, p2Name) {
+  const stats = {
+    p1: { wins: 0, losses: 0, draws: 0 },
+    p2: { wins: 0, losses: 0, draws: 0 },
+  };
+
+  for (let round = 1; round <= TOTAL_ROUNDS; round++) {
+    log(p1Name, 'round', `=== Round ${round}/${TOTAL_ROUNDS} of ${gameId} ===`);
+
+    try {
+      // P1 creates a private match
+      const auth1 = await signAuth(wallet1);
+      const createResp = await fetch(`${SERVER}/api/matches/private`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...auth1, gameId }),
+      });
+
+      if (!createResp.ok) {
+        const errText = await createResp.text();
+        throw new Error(`Create private match failed (${createResp.status}): ${errText}`);
+      }
+
+      const createData = await createResp.json();
+      log(p1Name, 'match', `Created private match ${createData.matchId} invite=${createData.inviteCode}`);
+
+      // P2 accepts the invite
+      const auth2 = await signAuth(wallet2);
+      const acceptResp = await fetch(`${SERVER}/api/matches/accept`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ ...auth2, inviteCode: createData.inviteCode }),
+      });
+
+      if (!acceptResp.ok) {
+        const errText = await acceptResp.text();
+        throw new Error(`Accept private match failed (${acceptResp.status}): ${errText}`);
+      }
+
+      const acceptData = await acceptResp.json();
+      log(p2Name, 'match', `Joined match ${acceptData.matchId}`);
+
+      // Both players connect and play simultaneously
+      const [result1, result2] = await Promise.all([
+        playGame(p1Name, wallet1.address, createData.matchId, createData.wsToken),
+        playGame(p2Name, wallet2.address, acceptData.matchId, acceptData.wsToken),
+      ]);
+
+      // Track stats
+      if (result1 === 'win') { stats.p1.wins++; stats.p2.losses++; }
+      else if (result1 === 'loss') { stats.p1.losses++; stats.p2.wins++; }
+      else { stats.p1.draws++; stats.p2.draws++; }
+
+    } catch (err) {
+      log(p1Name, 'error', `Round ${round} error: ${err.message}`);
+    }
+
+    if (round < TOTAL_ROUNDS) {
+      const waitTime = 2000 + Math.random() * 3000;
+      log(p1Name, 'wait', `Waiting ${Math.round(waitTime)}ms before next round...`);
+      await sleep(waitTime);
+    }
+  }
+
+  return { gameId, stats };
+}
+
+// ─── Main ────────────────────────────────────────────────────────────
+
+async function main() {
+  console.log('');
+  console.log('========================================================');
+  console.log('   DORK.FUN MULTI-AGENT BATTLE ROYALE');
+  console.log('   12 agents, 6 games, maximum trash talk');
+  console.log('   Using private matches for guaranteed pairing');
+  console.log('========================================================');
+  console.log('');
+
+  // Generate 12 random wallets (6 pairs)
+  const wallets = Array.from({ length: 12 }, () => Wallet.createRandom());
+
+  console.log('=== Agent Roster ===');
+  GAMES.forEach((game, i) => {
+    console.log(`  ${game.padEnd(12)}: ${wallets[i].address.slice(0, 10)}... (P1) vs ${wallets[i + 6].address.slice(0, 10)}... (P2)`);
+  });
+  console.log('');
+  console.log(`Each pair plays ${TOTAL_ROUNDS} rounds with 1-5s move delays and trash talk.`);
+  console.log('');
+
+  // Launch all 6 game pairs simultaneously
+  console.log('>>> Launching all 6 game pairs...');
+  console.log('');
+
+  const pairPromises = GAMES.map((game, i) =>
+    runGamePair(
+      game,
+      wallets[i],
+      wallets[i + 6],
+      `${game.toUpperCase()}-P1`,
+      `${game.toUpperCase()}-P2`
+    )
+  );
+
+  const results = await Promise.allSettled(pairPromises);
+
+  console.log('');
+  console.log('========================================================');
+  console.log('                  FINAL RESULTS');
+  console.log('========================================================');
+
+  for (const r of results) {
+    if (r.status === 'fulfilled') {
+      const { gameId, stats } = r.value;
+      console.log(`\n  ${gameId.toUpperCase()}:`);
+      console.log(`    P1: ${stats.p1.wins}W / ${stats.p1.losses}L / ${stats.p1.draws}D`);
+      console.log(`    P2: ${stats.p2.wins}W / ${stats.p2.losses}L / ${stats.p2.draws}D`);
+    } else {
+      console.log(`\n  ERROR: ${r.reason.message}`);
+    }
+  }
+
+  console.log('\n  All done!');
+  process.exit(0);
+}
+
+main().catch(err => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});