schess 1.0.0

package/bin/schess.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,584 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/network/Server.ts
+import { WebSocketServer, WebSocket } from "ws";
+import chalk3 from "chalk";
+import ora from "ora";
+
+// src/network/NetworkUtils.ts
+import { networkInterfaces } from "os";
+function getLanIp() {
+  const interfaces = networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    const nets = interfaces[name];
+    if (!nets) continue;
+    for (const net of nets) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return null;
+}
+function getRandomPort() {
+  return Math.floor(Math.random() * 5e4) + 1e4;
+}
+
+// src/network/Protocol.ts
+function serializeMessage(msg) {
+  return JSON.stringify(msg);
+}
+function parseMessage(data) {
+  try {
+    return JSON.parse(data);
+  } catch {
+    return null;
+  }
+}
+
+// src/ui/GameScreen.ts
+import chalk2 from "chalk";
+
+// src/game/ChessGame.ts
+import { Chess } from "chess.js";
+var ChessGame = class {
+  chess;
+  constructor(fen) {
+    this.chess = new Chess(fen);
+  }
+  getPiece(square) {
+    return this.chess.get(square);
+  }
+  getValidMoves(square) {
+    const moves = this.chess.moves({ square, verbose: true });
+    return moves.map((m) => m.to);
+  }
+  makeMove(from, to) {
+    try {
+      return this.chess.move({ from, to, promotion: "q" });
+    } catch {
+      return null;
+    }
+  }
+  loadMove(from, to) {
+    try {
+      this.chess.move({ from, to, promotion: "q" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  getCurrentTurn() {
+    return this.chess.turn();
+  }
+  isCheck() {
+    return this.chess.isCheck();
+  }
+  isCheckmate() {
+    return this.chess.isCheckmate();
+  }
+  isStalemate() {
+    return this.chess.isStalemate();
+  }
+  isDraw() {
+    return this.chess.isDraw();
+  }
+  isGameOver() {
+    return this.chess.isGameOver();
+  }
+  getGameOverReason() {
+    if (this.isCheckmate()) return "Checkmate";
+    if (this.isStalemate()) return "Stalemate";
+    if (this.chess.isThreefoldRepetition()) return "Draw by repetition";
+    if (this.chess.isInsufficientMaterial()) return "Draw by insufficient material";
+    if (this.chess.isDraw()) return "Draw";
+    return null;
+  }
+  getFen() {
+    return this.chess.fen();
+  }
+  loadFen(fen) {
+    this.chess.load(fen);
+  }
+  reset() {
+    this.chess.reset();
+  }
+};
+
+// src/ui/Board.ts
+import chalk from "chalk";
+
+// src/game/constants.ts
+var PIECES = {
+  w: {
+    k: "\u2654",
+    q: "\u2655",
+    r: "\u2656",
+    b: "\u2657",
+    n: "\u2658",
+    p: "\u2659"
+  },
+  b: {
+    k: "\u265A",
+    q: "\u265B",
+    r: "\u265C",
+    b: "\u265D",
+    n: "\u265E",
+    p: "\u265F"
+  }
+};
+var FILES = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var RANKS = ["8", "7", "6", "5", "4", "3", "2", "1"];
+
+// src/ui/Board.ts
+function positionToSquare(pos) {
+  return `${FILES[pos.col]}${RANKS[pos.row]}`;
+}
+function renderBoard(game, state) {
+  const lines = [];
+  const { cursor, selectedSquare, validMoves, lastMove, playerColor } = state;
+  const fileLabels = playerColor === "w" ? "     a   b   c   d   e   f   g   h" : "     h   g   f   e   d   c   b   a";
+  lines.push(chalk.gray(fileLabels));
+  lines.push(chalk.gray("   \u2554\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2564\u2550\u2550\u2550\u2557"));
+  const rowOrder = playerColor === "w" ? [0, 1, 2, 3, 4, 5, 6, 7] : [7, 6, 5, 4, 3, 2, 1, 0];
+  const colOrder = playerColor === "w" ? [0, 1, 2, 3, 4, 5, 6, 7] : [7, 6, 5, 4, 3, 2, 1, 0];
+  for (let i = 0; i < 8; i++) {
+    const row = rowOrder[i];
+    const rank = RANKS[row];
+    let line = chalk.gray(` ${rank} \u2551`);
+    for (let j = 0; j < 8; j++) {
+      const col = colOrder[j];
+      const square = positionToSquare({ row, col });
+      const piece = game.getPiece(square);
+      let cellContent = "   ";
+      if (piece) {
+        const pieceChar = PIECES[piece.color][piece.type];
+        cellContent = ` ${pieceChar} `;
+      }
+      const isCursor = cursor.row === row && cursor.col === col;
+      const isSelected = selectedSquare === square;
+      const isValidMove = validMoves.includes(square);
+      const isLastMoveFrom = lastMove?.from === square;
+      const isLastMoveTo = lastMove?.to === square;
+      if (isCursor) {
+        cellContent = chalk.bgYellow.black(cellContent);
+      } else if (isSelected) {
+        cellContent = chalk.bgRgb(255, 140, 0).black(cellContent);
+      } else if (isValidMove) {
+        cellContent = chalk.bgGreen.black(cellContent);
+      } else if (isLastMoveFrom || isLastMoveTo) {
+        cellContent = chalk.bgBlue.white(cellContent);
+      }
+      line += cellContent;
+      line += j < 7 ? chalk.gray("\u2502") : chalk.gray("\u2551");
+    }
+    lines.push(line);
+    if (i < 7) {
+      lines.push(chalk.gray("   \u255F\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2562"));
+    } else {
+      lines.push(chalk.gray("   \u255A\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u2567\u2550\u2550\u2550\u255D"));
+    }
+  }
+  return lines.join("\n");
+}
+function renderStatus(game, state) {
+  const turn = game.getCurrentTurn();
+  const turnText = turn === "w" ? "White" : "Black";
+  const yourTurn = state.isMyTurn ? chalk.green("Your turn") : chalk.yellow("Opponent's turn");
+  let status = `  ${turnText} to move | ${yourTurn}`;
+  if (game.isCheck()) {
+    status += chalk.red(" | CHECK!");
+  }
+  if (state.gameOver) {
+    status = chalk.bold.red(`  Game Over: ${state.gameOverReason}`);
+    const winner = state.gameOverReason === "Checkmate" ? turn === "w" ? "Black wins!" : "White wins!" : "";
+    if (winner) {
+      status += chalk.bold.yellow(` ${winner}`);
+    }
+  }
+  return status;
+}
+function renderControls() {
+  return chalk.gray("  \u2191\u2193\u2190\u2192: Move | Enter: Select | Esc: Cancel | Q: Quit");
+}
+
+// src/ui/Keyboard.ts
+import * as readline from "readline";
+function createKeyboardHandler(onKey) {
+  let isRunning = false;
+  const handleKeypress = (_str, key) => {
+    if (!isRunning) return;
+    let action = "unknown";
+    if (key.name === "up") action = "up";
+    else if (key.name === "down") action = "down";
+    else if (key.name === "left") action = "left";
+    else if (key.name === "right") action = "right";
+    else if (key.name === "return") action = "enter";
+    else if (key.name === "escape") action = "escape";
+    else if (key.name === "q" || key.ctrl && key.name === "c") action = "quit";
+    if (action !== "unknown") {
+      onKey(action);
+    }
+  };
+  return {
+    onKey,
+    start: () => {
+      if (isRunning) return;
+      isRunning = true;
+      if (process.stdin.isTTY) {
+        readline.emitKeypressEvents(process.stdin);
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("keypress", handleKeypress);
+      }
+    },
+    stop: () => {
+      if (!isRunning) return;
+      isRunning = false;
+      if (process.stdin.isTTY) {
+        process.stdin.setRawMode(false);
+        process.stdin.removeListener("keypress", handleKeypress);
+        process.stdin.pause();
+      }
+    }
+  };
+}
+
+// src/ui/GameScreen.ts
+var GameScreen = class {
+  game;
+  state;
+  keyboard;
+  networkCallbacks;
+  constructor(playerColor, callbacks) {
+    this.game = new ChessGame();
+    this.networkCallbacks = callbacks;
+    const startRow = playerColor === "w" ? 6 : 1;
+    this.state = {
+      cursor: { row: startRow, col: 4 },
+      selectedSquare: null,
+      validMoves: [],
+      lastMove: null,
+      isMyTurn: playerColor === "w",
+      // White goes first
+      playerColor,
+      gameOver: false,
+      gameOverReason: null
+    };
+    this.keyboard = createKeyboardHandler(this.handleKey.bind(this));
+  }
+  handleKey(action) {
+    if (this.state.gameOver) {
+      if (action === "quit" || action === "enter") {
+        this.stop();
+        process.exit(0);
+      }
+      return;
+    }
+    switch (action) {
+      case "up":
+        this.moveCursor(-1, 0);
+        break;
+      case "down":
+        this.moveCursor(1, 0);
+        break;
+      case "left":
+        this.moveCursor(0, -1);
+        break;
+      case "right":
+        this.moveCursor(0, 1);
+        break;
+      case "enter":
+        this.handleSelect();
+        break;
+      case "escape":
+        this.cancelSelection();
+        break;
+      case "quit":
+        this.networkCallbacks.onResign();
+        this.stop();
+        console.log(chalk2.yellow("\nYou resigned. Game over."));
+        process.exit(0);
+        break;
+    }
+    this.render();
+  }
+  moveCursor(dRow, dCol) {
+    const actualDRow = this.state.playerColor === "w" ? dRow : -dRow;
+    const actualDCol = this.state.playerColor === "w" ? dCol : -dCol;
+    const newRow = Math.max(0, Math.min(7, this.state.cursor.row + actualDRow));
+    const newCol = Math.max(0, Math.min(7, this.state.cursor.col + actualDCol));
+    this.state.cursor = { row: newRow, col: newCol };
+  }
+  handleSelect() {
+    if (!this.state.isMyTurn) return;
+    const cursorSquare = positionToSquare(this.state.cursor);
+    if (this.state.selectedSquare) {
+      if (this.state.validMoves.includes(cursorSquare)) {
+        const move = this.game.makeMove(this.state.selectedSquare, cursorSquare);
+        if (move) {
+          this.state.lastMove = { from: this.state.selectedSquare, to: cursorSquare };
+          this.networkCallbacks.onMove(this.state.selectedSquare, cursorSquare);
+          this.state.isMyTurn = false;
+          if (this.game.isGameOver()) {
+            this.state.gameOver = true;
+            this.state.gameOverReason = this.game.getGameOverReason();
+          }
+        }
+        this.cancelSelection();
+      } else {
+        const piece = this.game.getPiece(cursorSquare);
+        if (piece && piece.color === this.state.playerColor) {
+          this.selectPiece(cursorSquare);
+        } else {
+          this.cancelSelection();
+        }
+      }
+    } else {
+      const piece = this.game.getPiece(cursorSquare);
+      if (piece && piece.color === this.state.playerColor) {
+        this.selectPiece(cursorSquare);
+      }
+    }
+  }
+  selectPiece(square) {
+    this.state.selectedSquare = square;
+    this.state.validMoves = this.game.getValidMoves(square);
+  }
+  cancelSelection() {
+    this.state.selectedSquare = null;
+    this.state.validMoves = [];
+  }
+  // Called when opponent makes a move
+  receiveMove(from, to) {
+    this.game.loadMove(from, to);
+    this.state.lastMove = { from, to };
+    this.state.isMyTurn = true;
+    if (this.game.isGameOver()) {
+      this.state.gameOver = true;
+      this.state.gameOverReason = this.game.getGameOverReason();
+    }
+    this.render();
+  }
+  // Called when opponent resigns
+  opponentResigned() {
+    this.state.gameOver = true;
+    this.state.gameOverReason = "Opponent resigned";
+    this.render();
+  }
+  render() {
+    console.clear();
+    console.log(chalk2.bold.cyan("\n  \u2654 SCHESS - Chess over LAN \u265A\n"));
+    console.log(renderBoard(this.game, this.state));
+    console.log();
+    console.log(renderStatus(this.game, this.state));
+    console.log(renderControls());
+    console.log();
+  }
+  start() {
+    this.keyboard.start();
+    this.render();
+  }
+  stop() {
+    this.keyboard.stop();
+  }
+};
+
+// src/network/Server.ts
+async function startServer() {
+  const port = getRandomPort();
+  const ip = getLanIp() || "localhost";
+  const wss = new WebSocketServer({ port });
+  let opponent = null;
+  let gameScreen = null;
+  console.log(chalk3.bold.cyan("\n  \u2654 SCHESS - Chess over LAN \u265A\n"));
+  console.log(chalk3.green("  Game created! You are playing as White.\n"));
+  console.log(chalk3.white("  Share this command with your opponent:\n"));
+  console.log(chalk3.yellow.bold(`    schess join ${ip}:${port}
+`));
+  const spinner = ora("Waiting for opponent to join...").start();
+  wss.on("connection", (ws) => {
+    if (opponent) {
+      ws.send(serializeMessage({ type: "error", message: "Game is full" }));
+      ws.close();
+      return;
+    }
+    opponent = ws;
+    spinner.succeed("Opponent connected!");
+    ws.send(serializeMessage({ type: "start", color: "b" }));
+    gameScreen = new GameScreen("w", {
+      onMove: (from, to) => {
+        if (opponent && opponent.readyState === WebSocket.OPEN) {
+          opponent.send(serializeMessage({ type: "move", from, to }));
+        }
+      },
+      onResign: () => {
+        if (opponent && opponent.readyState === WebSocket.OPEN) {
+          opponent.send(serializeMessage({ type: "resign" }));
+        }
+        cleanup();
+      }
+    });
+    setTimeout(() => {
+      gameScreen?.start();
+    }, 500);
+    ws.on("message", (data) => {
+      const msg = parseMessage(data.toString());
+      if (!msg) return;
+      handleMessage(msg);
+    });
+    ws.on("close", () => {
+      if (gameScreen) {
+        gameScreen.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3e3);
+      }
+    });
+    ws.on("error", (err) => {
+      console.error(chalk3.red("Connection error:"), err.message);
+    });
+  });
+  function handleMessage(msg) {
+    switch (msg.type) {
+      case "move":
+        gameScreen?.receiveMove(msg.from, msg.to);
+        break;
+      case "resign":
+        gameScreen?.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3e3);
+        break;
+    }
+  }
+  function cleanup() {
+    gameScreen?.stop();
+    wss.close();
+  }
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+
+// src/commands/init.ts
+async function initCommand() {
+  await startServer();
+}
+
+// src/network/Client.ts
+import WebSocket2 from "ws";
+import chalk4 from "chalk";
+import ora2 from "ora";
+async function connectToServer(address) {
+  const [host, portStr] = address.split(":");
+  if (!host || !portStr) {
+    console.error(chalk4.red("Invalid address format. Use: schess join <ip:port>"));
+    process.exit(1);
+  }
+  const port = parseInt(portStr, 10);
+  if (isNaN(port)) {
+    console.error(chalk4.red("Invalid port number"));
+    process.exit(1);
+  }
+  console.log(chalk4.bold.cyan("\n  \u2654 SCHESS - Chess over LAN \u265A\n"));
+  const spinner = ora2(`Connecting to ${host}:${port}...`).start();
+  const ws = new WebSocket2(`ws://${host}:${port}`);
+  let gameScreen = null;
+  ws.on("open", () => {
+    spinner.succeed("Connected to game!");
+    ws.send(serializeMessage({ type: "join" }));
+  });
+  ws.on("message", (data) => {
+    const msg = parseMessage(data.toString());
+    if (!msg) return;
+    handleMessage(msg);
+  });
+  ws.on("close", () => {
+    if (gameScreen) {
+      gameScreen.opponentResigned();
+      setTimeout(() => {
+        cleanup();
+        process.exit(0);
+      }, 3e3);
+    } else {
+      spinner.fail("Disconnected from server");
+      process.exit(1);
+    }
+  });
+  ws.on("error", (err) => {
+    spinner.fail(`Connection failed: ${err.message}`);
+    process.exit(1);
+  });
+  function handleMessage(msg) {
+    switch (msg.type) {
+      case "start": {
+        const color = msg.color;
+        console.log(chalk4.green(`  You are playing as ${color === "w" ? "White" : "Black"}.
+`));
+        gameScreen = new GameScreen(color, {
+          onMove: (from, to) => {
+            if (ws.readyState === WebSocket2.OPEN) {
+              ws.send(serializeMessage({ type: "move", from, to }));
+            }
+          },
+          onResign: () => {
+            if (ws.readyState === WebSocket2.OPEN) {
+              ws.send(serializeMessage({ type: "resign" }));
+            }
+            cleanup();
+          }
+        });
+        setTimeout(() => {
+          gameScreen?.start();
+        }, 500);
+        break;
+      }
+      case "move":
+        gameScreen?.receiveMove(msg.from, msg.to);
+        break;
+      case "resign":
+        gameScreen?.opponentResigned();
+        setTimeout(() => {
+          cleanup();
+          process.exit(0);
+        }, 3e3);
+        break;
+      case "error":
+        console.error(chalk4.red(`Server error: ${msg.message}`));
+        cleanup();
+        process.exit(1);
+        break;
+    }
+  }
+  function cleanup() {
+    gameScreen?.stop();
+    ws.close();
+  }
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(0);
+  });
+}
+
+// src/commands/join.ts
+async function joinCommand(address) {
+  await connectToServer(address);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("schess").description("CLI Chess game over LAN").version("1.0.0");
+program.command("init").description("Host a new chess game").action(async () => {
+  await initCommand();
+});
+program.command("join <address>").description("Join a chess game (e.g., schess join 192.168.1.100:12345)").action(async (address) => {
+  await joinCommand(address);
+});
+program.parse();

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "schess",
+  "version": "1.0.0",
+  "description": "CLI Chess game over LAN",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "schess": "./bin/schess.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "schess": "node ./bin/schess.js"
+  },
+  "keywords": [
+    "chess",
+    "cli",
+    "lan",
+    "multiplayer",
+    "game"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "chess.js": "^1.0.0-beta.8",
+    "commander": "^12.0.0",
+    "ora": "^8.0.1",
+    "ws": "^8.16.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/ws": "^8.5.10",
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/commands/init.ts

@@ -0,0 +1,5 @@
+import { startServer } from '../network/Server.js';
+
+export async function initCommand(): Promise<void> {
+  await startServer();
+}

package/src/commands/join.ts

@@ -0,0 +1,5 @@
+import { connectToServer } from '../network/Client.js';
+
+export async function joinCommand(address: string): Promise<void> {
+  await connectToServer(address);
+}