dorkfuncli 0.0.1

package/src/index.ts

@@ -0,0 +1,237 @@
+#!/usr/bin/env node
+import dotenv from "dotenv";
+dotenv.config({ quiet: true });
+
+import { program } from "commander";
+import { parseEther } from "ethers";
+import { formatAddress } from "@dorkfun/core";
+import React from "react";
+import { render } from "ink";
+import { App } from "./tui/App.js";
+import { getAddress } from "./wallet/signer.js";
+import * as api from "./transport/httpClient.js";
+import { initConfig, getConfig, setCliOverride } from "./config/index.js";
+import { registerConfigCommand } from "./commands/config.js";
+import { runWizard } from "./commands/config.js";
+import { registerAgentCommand } from "./commands/agent.js";
+
+program
+  .name("dork")
+  .description("dork.fun - Play games with AI agents and humans")
+  .version("0.1.0", "-v, --version");
+
+registerConfigCommand(program);
+registerAgentCommand(program);
+
+program
+  .command("play")
+  .description("Connect to the server and play a game")
+  .option("-g, --game <gameId>", "Game to play", "tictactoe")
+  .option("-k, --key <privateKey>", "Ethereum private key")
+  .option("--stake <ETH>", "Stake amount in ETH (e.g. 0.01 for 0.01 ETH, 1 for 1 ETH)")
+  .action(async (opts) => {
+    if (opts.key) {
+      setCliOverride("privateKey", opts.key);
+    }
+
+    let config = await initConfig();
+
+    // Auto-run setup wizard if no private key is configured
+    if (!config.privateKey) {
+      console.log("No private key configured. Let's set things up.\n");
+      await runWizard();
+      config = await initConfig();
+    }
+
+    // Convert ETH input to wei for the protocol
+    let stakeWei: string | undefined;
+    if (opts.stake) {
+      try {
+        stakeWei = parseEther(opts.stake).toString();
+      } catch {
+        console.error(`Invalid stake amount: "${opts.stake}". Use a decimal ETH value (e.g. 0.01, 1.5)`);
+        process.exit(1);
+      }
+    }
+
+    try {
+      const address = getAddress();
+      console.log(`Connected as ${address}`);
+      console.log(`Server: ${config.serverUrl}`);
+      if (stakeWei) {
+        console.log(`Stake: ${opts.stake} ETH`);
+      }
+      console.log("");
+
+      render(React.createElement(App, { playerId: address, stakeWei }));
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+
+program
+  .command("games")
+  .description("List available games")
+  .action(async () => {
+    await initConfig();
+    try {
+      const result = await api.listGames();
+      console.log("\nAvailable Games:");
+      console.log("────────────────");
+      for (const game of result.games) {
+        console.log(`  ${game.name} (${game.id})`);
+        console.log(`    ${game.description}`);
+        console.log(`    Players: ${game.minPlayers}-${game.maxPlayers}`);
+        console.log("");
+      }
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+
+program
+  .command("matches")
+  .description("List active matches")
+  .action(async () => {
+    await initConfig();
+    try {
+      const result = await api.listMatches();
+      console.log("\nActive Matches:");
+      console.log("───────────────");
+      if (result.matches.length === 0) {
+        console.log("  No active matches");
+      }
+      const pn = result.matches[0]?.playerNames || {};
+      for (const match of result.matches) {
+        console.log(`  ${match.matchId.slice(0, 8)}  ${match.gameId}  ${match.status}`);
+        console.log(`    Players: ${match.players.map((p: string) => formatAddress(p, pn[p], "medium")).join(", ")}`);
+        console.log("");
+      }
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+
+program
+  .command("queue")
+  .description("Show players waiting in game queues")
+  .action(async () => {
+    await initConfig();
+    try {
+      const result = await api.listQueues();
+      console.log("\nQueue Status:");
+      console.log("─────────────");
+      let totalWaiting = 0;
+      for (const q of result.queues) {
+        const count = q.entries.length;
+        totalWaiting += count;
+        console.log(`  ${q.gameName} (${q.gameId}): ${count} waiting`);
+        const qn = result.playerNames || {};
+        for (const entry of q.entries) {
+          const name = qn[entry.playerId] || entry.displayName;
+          console.log(`    - ${name} (${entry.playerId.slice(0, 10)}...)`);
+        }
+        if (count === 0) {
+          console.log("    (empty)");
+        }
+        console.log("");
+      }
+      if (totalWaiting === 0) {
+        console.log("  No players waiting in any queue");
+      }
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+
+program
+  .command("archive")
+  .description("List completed/archived matches")
+  .option("-g, --game <gameId>", "Filter by game")
+  .option("-l, --limit <count>", "Number of matches to show", "20")
+  .action(async (opts) => {
+    await initConfig();
+    try {
+      const limit = parseInt(opts.limit) || 20;
+      const result = await api.listArchive(opts.game, limit, 0);
+      console.log("\nMatch Archive:");
+      console.log("──────────────");
+      if (result.matches.length === 0) {
+        console.log("  No archived matches found");
+      }
+      const archiveNames = result.playerNames || {};
+      for (const match of result.matches) {
+        const outcome = match.winner
+          ? `Winner: ${formatAddress(match.winner, archiveNames[match.winner], "medium")}`
+          : "Draw";
+        const date = match.completedAt
+          ? new Date(match.completedAt).toLocaleString()
+          : "-";
+        console.log(`  ${match.matchId.slice(0, 8)}  ${match.gameId}  ${match.status}`);
+        console.log(`    Players: ${match.players.map((p: string) => formatAddress(p, archiveNames[p], "medium")).join(" vs ")}`);
+        console.log(`    Outcome: ${outcome}`);
+        console.log(`    Ended:   ${date}`);
+        console.log("");
+      }
+      console.log(`  Showing ${result.matches.length} of ${result.total} total`);
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+
+program
+  .command("watch")
+  .description("Watch a live or archived game")
+  .argument("[matchId]", "Match ID to watch")
+  .action(async (matchId?: string) => {
+    await initConfig();
+    if (!matchId) {
+      const result = await api.listMatches();
+      if (result.matches.length === 0) {
+        console.log("No active matches to watch");
+        return;
+      }
+      console.log("\nActive matches:");
+      for (const match of result.matches) {
+        console.log(`  ${match.matchId}  (${match.gameId})`);
+      }
+      return;
+    }
+
+    try {
+      const match = await api.getMatch(matchId);
+      console.log(`\nWatching: ${match.matchId}`);
+      console.log(`Game: ${match.gameId}`);
+      console.log(`Status: ${match.status}`);
+      const watchNames = match.playerNames || {};
+      console.log(`Players: ${match.players.map((p: string) => formatAddress(p, watchNames[p], "medium")).join(" vs ")}`);
+      if (match.observation) {
+        const board = (match.observation.publicData as any)?.board;
+        if (board) {
+          console.log("\nBoard:");
+          for (let r = 0; r < 3; r++) {
+            const row = board.slice(r * 3, r * 3 + 3).map((c: string) => c || ".").join(" | ");
+            console.log(`  ${row}`);
+            if (r < 2) console.log("  ──┼───┼──");
+          }
+        }
+      }
+      if (["completed", "settled", "disputed"].includes(match.status)) {
+        const outcome = match.winner
+          ? `Winner: ${formatAddress(match.winner, watchNames[match.winner], "medium")}`
+          : "Draw";
+        console.log(`\nResult: ${outcome}`);
+        if (match.completedAt) {
+          console.log(`Ended: ${new Date(match.completedAt).toLocaleString()}`);
+        }
+        if (match.transcript) {
+          console.log(`Moves: ${match.transcript.length}`);
+        }
+      }
+    } catch (err: any) {
+      console.error(`Error: ${err.message}`);
+    }
+  });
+
+program.parse();

package/src/transport/httpClient.ts

@@ -0,0 +1,104 @@
+import { buildAuthMessage } from "@dorkfun/core";
+import { getConfig } from "../config/runtime.js";
+import { signMessage } from "../wallet/signer.js";
+
+async function request(path: string, opts?: RequestInit): Promise<any> {
+  const base = getConfig().serverUrl;
+  const res = await fetch(`${base}${path}`, {
+    ...opts,
+    headers: { "Content-Type": "application/json", ...opts?.headers },
+  });
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error || `HTTP ${res.status}`);
+  }
+  return res.json();
+}
+
+/**
+ * Build the authentication payload for endpoints that require proof of
+ * EVM address ownership: { playerId, signature, timestamp }.
+ */
+async function buildAuth(playerId: string) {
+  const timestamp = Date.now();
+  const message = buildAuthMessage(playerId, timestamp);
+  const signature = await signMessage(message);
+  return { playerId, signature, timestamp };
+}
+
+export async function listGames() {
+  return request("/api/games");
+}
+
+export async function listMatches() {
+  return request("/api/matches");
+}
+
+export async function getMatch(matchId: string) {
+  return request(`/api/matches/${matchId}`);
+}
+
+export async function joinQueue(playerId: string, gameId: string, ticket?: string, stakeWei?: string) {
+  const auth = await buildAuth(playerId);
+  return request("/api/matchmaking/join", {
+    method: "POST",
+    body: JSON.stringify({ ...auth, gameId, ticket, stakeWei }),
+  });
+}
+
+export async function leaveQueue(ticket: string) {
+  return request("/api/matchmaking/leave", {
+    method: "POST",
+    body: JSON.stringify({ ticket }),
+  });
+}
+
+export async function createPrivateMatch(playerId: string, gameId: string, stakeWei?: string) {
+  const auth = await buildAuth(playerId);
+  return request("/api/matches/private", {
+    method: "POST",
+    body: JSON.stringify({ ...auth, gameId, stakeWei }),
+  });
+}
+
+export async function acceptPrivateMatch(playerId: string, inviteCode: string) {
+  const auth = await buildAuth(playerId);
+  return request("/api/matches/accept", {
+    method: "POST",
+    body: JSON.stringify({ ...auth, inviteCode }),
+  });
+}
+
+export async function checkActiveMatch(playerId: string) {
+  const auth = await buildAuth(playerId);
+  return request("/api/matches/active", {
+    method: "POST",
+    body: JSON.stringify(auth),
+  });
+}
+
+export async function listQueues() {
+  return request("/api/queues");
+}
+
+export async function listArchive(gameId?: string, limit = 50, offset = 0) {
+  const params = new URLSearchParams({ limit: String(limit), offset: String(offset) });
+  if (gameId) params.set("gameId", gameId);
+  return request(`/api/archive?${params}`);
+}
+
+export async function getLeaderboard(limit = 50, offset = 0, sort: "rating" | "earnings" = "rating") {
+  return request(`/api/leaderboard?limit=${limit}&offset=${offset}&sort=${sort}`);
+}
+
+export async function getGameLeaderboard(gameId: string, limit = 50, offset = 0, sort: "rating" | "earnings" = "rating") {
+  return request(`/api/leaderboard/${gameId}?limit=${limit}&offset=${offset}&sort=${sort}`);
+}
+
+export async function resolveEns(addresses: string[]): Promise<Record<string, string | null>> {
+  const result = await request("/api/ens/resolve", {
+    method: "POST",
+    body: JSON.stringify({ addresses }),
+  });
+  return result.names;
+}

package/src/transport/wsClient.ts

@@ -0,0 +1,214 @@
+import WebSocket from "ws";
+import { WsMessage, buildAuthMessage } from "@dorkfun/core";
+import { getConfig } from "../config/runtime.js";
+import { signMessage } from "../wallet/signer.js";
+
+export type MessageHandler = (msg: WsMessage) => void;
+
+const MAX_RECONNECT_ATTEMPTS = 5;
+const RECONNECT_DELAY_MS = 2000;
+
+export class GameWebSocket {
+  private ws: WebSocket | null = null;
+  private handlers: Map<string, MessageHandler[]> = new Map();
+  private matchId: string = "";
+  private reconnectAttempts = 0;
+  private closed = false;
+  private helloToken: string = "";
+  private helloPlayerId: string = "";
+  private wsPath: string = "game";
+
+  connect(matchId: string, path: string = "game"): Promise<void> {
+    this.matchId = matchId;
+    this.wsPath = path;
+    this.closed = false;
+    return this.doConnect();
+  }
+
+  private doConnect(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const url = `${getConfig().wsUrl}/ws/${this.wsPath}/${this.matchId}`;
+      this.ws = new WebSocket(url);
+
+      this.ws.on("open", async () => {
+        this.reconnectAttempts = 0;
+
+        // Re-authenticate on reconnect
+        if (this.helloPlayerId) {
+          if (this.helloToken) {
+            // First connection — use the one-time token
+            this.sendHello(this.helloToken, this.helloPlayerId);
+          } else {
+            // Reconnection — generate a fresh signature
+            try {
+              const timestamp = Date.now();
+              const message = buildAuthMessage(this.helloPlayerId, timestamp);
+              const signature = await signMessage(message);
+              this.sendHelloWithSignature(this.helloPlayerId, signature, timestamp);
+            } catch {
+              // Signing failed — can't reconnect
+            }
+          }
+        }
+        resolve();
+      });
+
+      this.ws.on("error", (err) => {
+        if (this.reconnectAttempts === 0 && !this.closed) {
+          reject(err);
+        }
+      });
+
+      this.ws.on("message", (raw) => {
+        try {
+          const msg = JSON.parse(raw.toString()) as WsMessage;
+          this.emit(msg.type, msg);
+          this.emit("*", msg);
+        } catch {
+          // Ignore parse errors
+        }
+      });
+
+      this.ws.on("close", () => {
+        if (this.closed) return;
+        this.tryReconnect();
+      });
+    });
+  }
+
+  private tryReconnect(): void {
+    if (this.closed) return;
+    if (this.reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
+      this.emit("close", {
+        type: "ERROR",
+        matchId: this.matchId,
+        payload: { error: "Connection lost after max retries" },
+        sequence: 0,
+        prevHash: "",
+        timestamp: Date.now(),
+      } as WsMessage);
+      return;
+    }
+
+    this.reconnectAttempts++;
+    this.emit("reconnecting", {
+      type: "ERROR",
+      matchId: this.matchId,
+      payload: { error: `Reconnecting... (attempt ${this.reconnectAttempts})` },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    } as WsMessage);
+
+    setTimeout(() => {
+      if (this.closed) return;
+      this.doConnect().catch(() => {
+        this.tryReconnect();
+      });
+    }, RECONNECT_DELAY_MS);
+  }
+
+  on(type: string, handler: MessageHandler): void {
+    if (!this.handlers.has(type)) {
+      this.handlers.set(type, []);
+    }
+    this.handlers.get(type)!.push(handler);
+  }
+
+  private emit(type: string, msg: WsMessage): void {
+    const handlers = this.handlers.get(type) || [];
+    for (const handler of handlers) {
+      handler(msg);
+    }
+  }
+
+  sendHello(token: string, playerId: string): void {
+    this.helloToken = token;
+    this.helloPlayerId = playerId;
+    this.send({
+      type: "HELLO",
+      matchId: "",
+      payload: { token, playerId },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  /** Send a HELLO with signature-based auth (used for reconnection). */
+  sendHelloWithSignature(playerId: string, signature: string, timestamp: number): void {
+    this.helloPlayerId = playerId;
+    // Clear token so future reconnects use signature path
+    this.helloToken = "";
+    this.send({
+      type: "HELLO",
+      matchId: "",
+      payload: { playerId, signature, timestamp },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  sendAction(matchId: string, action: { type: string; data: Record<string, unknown> }): void {
+    this.send({
+      type: "ACTION_COMMIT",
+      matchId,
+      payload: { action },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  sendSpectateJoin(matchId: string, displayName: string): void {
+    this.send({
+      type: "SPECTATE_JOIN",
+      matchId,
+      payload: { displayName },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  sendSyncRequest(matchId: string, clientIsMyTurn: boolean): void {
+    this.send({
+      type: "SYNC_REQUEST",
+      matchId,
+      payload: { clientIsMyTurn },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  sendChat(matchId: string, message: string): void {
+    this.send({
+      type: "CHAT",
+      matchId,
+      payload: { message },
+      sequence: 0,
+      prevHash: "",
+      timestamp: Date.now(),
+    });
+  }
+
+  private send(msg: WsMessage): void {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  close(): void {
+    this.closed = true;
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  get isConnected(): boolean {
+    return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+  }
+}

package/src/tui/App.tsx

@@ -0,0 +1,130 @@
+import React, { useState, useEffect } from "react";
+import { Box, useInput, useApp } from "ink";
+import { StatusBar } from "./components/StatusBar.js";
+import { Lobby } from "./screens/Lobby.js";
+import { Matchmaking } from "./screens/Matchmaking.js";
+import { GameBoard } from "./screens/GameBoard.js";
+import { GameOver } from "./screens/GameOver.js";
+import { WatchList } from "./screens/WatchList.js";
+import { WatchGame } from "./screens/WatchGame.js";
+import { Leaderboard } from "./screens/Leaderboard.js";
+import { getConfig } from "../config/runtime.js";
+import * as api from "../transport/httpClient.js";
+
+type Screen =
+  | { type: "lobby" }
+  | { type: "leaderboard" }
+  | { type: "matchmaking"; gameId: string; stakeWei?: string }
+  | { type: "game"; matchId: string; wsToken: string; gameId: string; stakeWei?: string }
+  | { type: "gameover"; winner: string | null; reason: string; stakeWei?: string }
+  | { type: "watchlist" }
+  | { type: "watching"; matchId: string; gameId: string };
+
+interface AppProps {
+  playerId: string;
+  stakeWei?: string;
+}
+
+export function App({ playerId, stakeWei: initialStakeWei }: AppProps) {
+  const { exit } = useApp();
+  const [screen, setScreen] = useState<Screen>({ type: "lobby" });
+
+  // On startup, check if the player has an active match to reconnect to
+  useEffect(() => {
+    api.checkActiveMatch(playerId).then((res: any) => {
+      if (res.hasActiveMatch && res.matchId && res.wsToken) {
+        setScreen({
+          type: "game",
+          matchId: res.matchId,
+          wsToken: res.wsToken,
+          gameId: res.gameId || "unknown",
+          stakeWei: res.stakeWei && res.stakeWei !== "0" ? res.stakeWei : undefined,
+        });
+      }
+    }).catch(() => {
+      // Ignore — server might not be reachable yet
+    });
+  }, [playerId]);
+
+  useInput((input) => {
+    if (input === "q" && screen.type === "lobby") {
+      exit();
+    }
+  });
+
+  return (
+    <Box flexDirection="column">
+      <StatusBar
+        playerAddress={playerId}
+        serverUrl={getConfig().serverUrl}
+        connected={true}
+      />
+
+      {screen.type === "lobby" && (
+        <Lobby
+          defaultStakeWei={initialStakeWei}
+          onPlay={(gameId, stakeWei) => setScreen({ type: "matchmaking", gameId, stakeWei })}
+          onWatch={() => setScreen({ type: "watchlist" })}
+          onLeaderboard={() => setScreen({ type: "leaderboard" })}
+        />
+      )}
+
+      {screen.type === "leaderboard" && (
+        <Leaderboard onBack={() => setScreen({ type: "lobby" })} />
+      )}
+
+      {screen.type === "matchmaking" && (
+        <Matchmaking
+          playerId={playerId}
+          gameId={screen.gameId}
+          stakeWei={screen.stakeWei}
+          onMatched={(matchId, wsToken, _opponent) =>
+            setScreen({ type: "game", matchId, wsToken, gameId: screen.gameId, stakeWei: screen.stakeWei })
+          }
+          onCancel={() => setScreen({ type: "lobby" })}
+        />
+      )}
+
+      {screen.type === "game" && (
+        <GameBoard
+          matchId={screen.matchId}
+          wsToken={screen.wsToken}
+          playerId={playerId}
+          gameId={screen.gameId}
+          stakeWei={screen.stakeWei}
+          onGameOver={(winner, reason) =>
+            setScreen({ type: "gameover", winner, reason, stakeWei: screen.stakeWei })
+          }
+        />
+      )}
+
+      {screen.type === "gameover" && (
+        <GameOver
+          winner={screen.winner}
+          reason={screen.reason}
+          playerId={playerId}
+          stakeWei={screen.stakeWei}
+          onRematch={() => setScreen({ type: "lobby" })}
+          onQuit={() => setScreen({ type: "lobby" })}
+        />
+      )}
+
+      {screen.type === "watchlist" && (
+        <WatchList
+          onSelect={(matchId, gameId) =>
+            setScreen({ type: "watching", matchId, gameId })
+          }
+          onBack={() => setScreen({ type: "lobby" })}
+        />
+      )}
+
+      {screen.type === "watching" && (
+        <WatchGame
+          matchId={screen.matchId}
+          gameId={screen.gameId}
+          onBack={() => setScreen({ type: "watchlist" })}
+        />
+      )}
+    </Box>
+  );
+}