@leafarcade/cli 0.1.0-alpha.4 → 0.1.1

package/README.md

@@ -2,19 +2,19 @@
 
 Let your own agent play a private board-game room while you use the browser board. The CLI reads positions and submits moves; it does not call a model, collect model credentials or implement its own opponent.
 
-**Alpha scope:** all 43 multiplayer games in private, unclocked, unrated rooms. Nine games expose complete local legal-action lists; the others expose player-visible state and game-specific JSON action formats, validated by the game service. OAuth login, seat-scoped pairing and automatic waking of a stopped agent are not implemented. Anyone with an invite can currently occupy an open seat under the existing private-room rules. Use private invites you trust.
+**Scope of 0.1.1:** all 47 multiplayer games in private, unclocked, unrated rooms. Nine games expose complete local legal-action lists; the others expose player-visible state and game-specific JSON action formats, validated by the game service. OAuth login, seat-scoped pairing and automatic waking of a stopped agent are not implemented. Anyone with an invite can currently occupy an open seat under the existing private-room rules. Use private invites you trust.
 
 ## Start a game from your agent
 
 ```sh
-npx @leafarcade/cli@alpha game create --game connect-four --name "My agent" --open
+npx @leafarcade/cli@0.1.1 game create --game connect-four --name "My agent" --open
 ```
 
 This creates a private, unrated room with the CLI agent as host, saves its session, and opens the human's browser invitation. The human joins with their own name and session. Once the requested players are present, the agent reads status and starts with the latest revision:
 
 ```sh
-npx @leafarcade/cli@alpha game status --room ROOMCODE
-npx @leafarcade/cli@alpha game start --room ROOMCODE --revision R
+npx @leafarcade/cli@0.1.1 game status --room ROOMCODE
+npx @leafarcade/cli@0.1.1 game start --room ROOMCODE --revision R
 ```
 
 Omit `--open` on a remote or headless machine and share the returned URL. If launching the browser fails, the room is still valid: open that URL manually or use `leafarcade game open --room ROOMCODE`. No agent credential is placed in the URL. `--capacity N` selects a supported seat count (default: the game's minimum); Go also supports `--go-size 9|13|19`. For a custom service, provide both `--server` and its matching browser frontend `--site`.
@@ -24,27 +24,27 @@ The CLI stores a persistent creator identity so creating another room does not r
 ## Install the agent skill
 
 ```sh
-npx @leafarcade/cli@alpha skill show
-npx @leafarcade/cli@alpha skill install --agent codex
+npx @leafarcade/cli@0.1.1 skill show
+npx @leafarcade/cli@0.1.1 skill install --agent codex
 # Or:
-npx @leafarcade/cli@alpha skill install --agent claude
+npx @leafarcade/cli@0.1.1 skill install --agent claude
 ```
 
 The skill is bundled in the npm package and works without a separate download. Installation is explicit; there is no npm postinstall hook. Codex installs into `$CODEX_HOME/skills/leafarcade` (default `~/.codex/skills/leafarcade`); Claude uses `~/.claude/skills/leafarcade`. Existing customized skills are preserved. Refresh your agent's skills and ask it to play Leaf Arcade. The [public skill repository](https://github.com/leafarcade/skills) contains usage instructions; the CLI source repository remains private. The npm JavaScript executable is publicly downloadable.
 
 ## Install
 
-Requires Node.js 24 or later. Release 0.1.0-alpha.4 adds room creation, browser opening, host start and bundled skill installation:
+Requires Node.js 24 or later. Release 0.1.1 includes room creation, browser opening, host start and bundled skill installation:
 
 ```sh
-npm install --global @leafarcade/cli@alpha
+npm install --global @leafarcade/cli@0.1.1
 leafarcade --help
 leafarcade help games
 leafarcade help chess
 leafarcade game play --help --game chess
 ```
 
-Without a global install, use `npx @leafarcade/cli@alpha ...` in place of `leafarcade ...`. From the repository, run `npm run build --prefix packages/cli` and replace `leafarcade` with `node packages/cli/dist/cli.mjs`. The installed package has no runtime dependencies or install scripts.
+Without a global install, use `npx @leafarcade/cli@0.1.1 ...` in place of `leafarcade ...`. From the repository, run `npm run build --prefix packages/cli` and replace `leafarcade` with `node packages/cli/dist/cli.mjs`. The installed package has no runtime dependencies or install scripts.
 
 ## First game
 
@@ -100,7 +100,7 @@ Wire indexes are zero-based. The server validates the phase, ownership and legal
 leafarcade game status --room ABCDEFGHJK
 ```
 
-Use `game pause --room CODE --revision R` to explicitly take a break. The pause persists and blocks moves until the player who paused runs `game resume` or resumes in the browser. A finished result includes `terminal_reason`; do not infer resignation from silence. The private local session survives terminal exits. No process needs to run between moves. Current rooms expire seven days after the last move, and guest credentials have a separate 30-day lease. This alpha does not extend those limits or silently enable a clock. A `waiting` result is normal: end this agent turn and resume later. Do not loop a 25-second wait all day. For an actively running agent that can hold a command open, a bounded wait of up to 3,600 seconds is supported; disconnecting or closing the terminal does not wake an agent later.
+Use `game pause --room CODE --revision R` to explicitly take a break. The pause persists and blocks moves until the player who paused runs `game resume` or resumes in the browser. A finished result includes `terminal_reason`; do not infer resignation from silence. The private local session survives terminal exits. No process needs to run between moves. Current rooms expire seven days after the last move, and guest credentials have a separate 30-day lease. This release does not extend those limits or silently enable a clock. A `waiting` result is normal: end this agent turn and resume later. Do not loop a 25-second wait all day. For an actively running agent that can hold a command open, a bounded wait of up to 3,600 seconds is supported; disconnecting or closing the terminal does not wake an agent later.
 
 ## Commands
 
@@ -124,7 +124,7 @@ Local credentials are stored under `~/.config/leafarcade/`, in separate service/
 
 `--server https://...` selects a service. HTTP is permitted only on localhost for development. Credentials are bound to the selected origin; redirects are refused. The default is the existing Leaf Arcade multiplayer Worker. No backend or inference service is hosted by this package, but room traffic still consumes the multiplayer provider's budget and your agent's model use follows its own plan.
 
-If you accidentally join an unsupported room, the service may already have reserved your seat before the CLI can inspect its game. Use `game leave` with the current revision shown by the browser host, or create a fresh room; do not discard a session needed to leave. This limitation is one reason the package is an alpha, not the finished pairing product.
+If you accidentally join an unsupported room, the service may already have reserved your seat before the CLI can inspect its game. Use `game leave` with the current revision shown by the browser host, or create a fresh room; do not discard a session needed to leave. The current CLI keeps the existing invitation rules; seat-scoped pairing remains future work.
 
 ## Suggested instruction for your agent
 
@@ -133,3 +133,32 @@ If you accidentally join an unsupported room, the service may already have reser
 This uses your agent's normal command tools. It does not turn a ChatGPT/Claude subscription into an API key or access their credential stores. Check your client/workspace permissions before use.
 
 MIT license covers this CLI package. Bundled chess.js is BSD-2-Clause; its full notice is included in THIRD_PARTY_NOTICES.txt. No game artwork, proprietary resource pack, account secret or third-party engine binary is included.
+
+## Public tables (next local release)
+
+Find public seats that admit external agents:
+
+```sh
+leafarcade game tables --game chess
+leafarcade join ROOMCODE --name "My agent"
+leafarcade game create --game chess --access public --name "My agent"
+```
+
+`--access invite` is the default: unlisted, accessible by link/code. `--access
+private` requires host approval for new players and spectators. Public tables are
+listed for discovery. New CLI-created tables allow spectators; use
+`--no-spectators` to disable watching. The browser's Watch action never occupies a
+seat and hides all private player information.
+
+A pending private join returns `access_requested`; repeat `join` after approval,
+using the saved identity. Hosts inspect `access_requests` in `game status` and
+approve or decline the requested person and role:
+
+```sh
+leafarcade game approve --room ROOMCODE --revision R --request REQUEST_ID
+leafarcade game decline --room ROOMCODE --revision R --request REQUEST_ID
+```
+
+Discovery does not automatically join, play, poll or wake an agent. These local
+commands require the matching upcoming service release; the currently published
+npm version is not changed by this source work.

package/dist/cli.mjs

@@ -3576,6 +3576,10 @@ import { randomUUID } from "node:crypto";
 
 // lib/multiplayer/ids.ts
 var multiplayerIds = [
+  "categories",
+  "cheat",
+  "president",
+  "rummy",
   "tic-tac-toe",
   "connect-four",
   "dots-boxes",
@@ -3621,6 +3625,9 @@ var multiplayerIds = [
   "baska"
 ];
 function seatLimits(id) {
+  if (id === "categories") return [2, 8];
+  if (id === "cheat" || id === "president") return [3, 6];
+  if (id === "rummy") return [2, 4];
   if (id === "draw-guess") return [2, 20];
   if (id === "three-five-eight") return [3, 3];
   if (id === "bridge" || id === "binokel" || id === "baska") return [4, 4];
@@ -3732,6 +3739,10 @@ function owareMoves(s) {
 
 // lib/multiplayer/catalog.ts
 var multiplayerGames = [
+  { "id": "categories", "name": "Categories", "symbol": "A\u2013Z", "players": "2\u20138 players", "description": "One letter. Six categories. Race your friends to a unique answer.", "rules": "Five English-language rounds with Country, City, Animal, Food, Occupation and Object. The host reveals a new random letter and starts a two-minute round, or chooses untimed play. Submit one locked answer sheet; blank answers are allowed. A complete sheet can call Stop once, shortening a timed round to ten seconds. After everyone submits or a player reveals an expired round, all answers are shown. Unsubmitted answers are blank. Each player casts one ballot marking invalid answers from other players; an answer needs a strict majority of the other players to accept it (a voting tie rejects it). Valid unique answers score 10, matching valid answers 5, blanks or rejected answers 0. Highest total after five rounds wins; equal totals draw. Private groups judge answers themselves; there is no automated dictionary or AI judge. Local play uses untimed private handoffs." },
+  { "id": "cheat", "name": "Cheat", "symbol": "?!", "players": "3\u20136 players", "description": "Play face down. Tell a convincing story. Call the bluff.", "rules": "Deal all 52 cards clockwise. Player 1 claims aces, then claims cycle through 2 to king and back to ace. On your turn place one to four cards face down, claiming the required rank; bluffing is allowed. Before the next play, any other player may challenge, or the next player may accept. A challenge reveals only the latest cards: if any is the wrong rank the claimant takes the whole pile; otherwise the challenger takes it. Accepted cards stay hidden. The next clockwise player then takes their turn with the next required rank. An empty hand wins only after its final claim is accepted or survives a challenge. This table uses an explicit challenge window without a reaction timer." },
+  { "id": "president", "name": "President", "symbol": "3\u21922", "players": "3\u20136 players", "description": "Beat the group. Pass at the right moment. Finish first.", "rules": "A single deal with a standard 52-card deck, all cards dealt clockwise. Ranks rise from 3 through ace, with 2 highest. The holder of 3 of clubs opens with a group containing it. Lead one to four equal-rank cards; following plays must contain the same number of cards at a strictly higher rank. You may pass, but cannot re-enter until that pile clears. When all other active players pass, the last player to play leads again; if they have finished, the next active player leads. Finishers leave play and receive places in order. Play continues until one player remains; the first finisher is President. No jokers, suit tie-breaks, special twos, revolution or between-deal tribute." },
+  { "id": "rummy", "name": "Classic Rummy", "symbol": "777", "players": "2\u20134 players", "description": "Draw a card. Build sets and runs. Empty your hand.", "rules": "One deal, no jokers. Two players receive ten cards each; three or four receive seven. Aces are low only. Draw one card from the stock or take the top discard. Then optionally meld sets of three or four equal ranks, or runs of three or more consecutive cards of one suit. You may add held cards to either end of any public run or complete a public set. Keep at least one card and end your turn by discarding; a taken upcard cannot be discarded immediately. First to discard their last card wins and scores the total value of cards held by opponents: ace 1, faces 10, other cards face value. Recycle discards beneath the top card when stock runs out. If stock and recyclable discards are both empty and the next player chooses stock, the deal ends; lowest remaining card value wins, with ties drawn. No initial meld threshold, knock or Rummy 500 scoring." },
   { id: "tic-tac-toe", name: "Tic-tac-toe", symbol: "XO", players: "2 players", description: "Nine squares. Three in a row. Your next quick match.", rules: "X starts on a 3 by 3 board. Take turns placing your mark on an empty square. Three marks in a horizontal, vertical or diagonal line wins. A full board without a winner draws." },
   { id: "international-draughts", name: "International Draughts", symbol: "\u265B", players: "2 players", description: "Twenty pieces. Flying kings. Capture the longest chain.", rules: "White starts on a 10\xD710 board with twenty pieces per side. Men move one diagonal square forward and capture in either direction. Kings slide diagonally and land on any empty square beyond a captured piece. Captures are compulsory: choose a sequence taking the greatest number of pieces. Captured pieces remain as blockers until the entire sequence ends. A man becomes a king only if its final square is on the promotion row. No pieces or no legal move loses. Threefold repetition, twenty-five successive king moves per player without captures or man moves, and the official sixteen/five-move king endgame limits draw automatically." },
   { id: "atomic-chess", name: "Atomic Chess", symbol: "\u265C", players: "2 players", description: "Every capture explodes. Protect your king from the blast.", rules: "Standard chess setup and moves, with explosive captures: the capturing piece, captured piece and adjacent non-pawns disappear. Adjacent pawns survive. En passant explodes at the capturing pawn\u2019s destination. A move that explodes your own king is illegal. Kings cannot capture, but may stand next to one another. Explode the opposing king or deliver checkmate to win. Stalemate, insufficient material, threefold repetition or fifty moves without a pawn move or capture draws. Castling and all four promotions are supported." },
@@ -4285,11 +4296,39 @@ var action_catalog_default = {
   ],
   "brazilian-checkers": [
     "move"
+  ],
+  categories: [
+    "begin",
+    "submit",
+    "stop",
+    "expire",
+    "vote",
+    "next"
+  ],
+  cheat: [
+    "play",
+    "accept",
+    "challenge"
+  ],
+  president: [
+    "play",
+    "pass"
+  ],
+  rummy: [
+    "stock",
+    "upcard",
+    "meld",
+    "layoff",
+    "discard"
   ]
 };
 
 // lib/agents/action-help.ts
 var help = {
+  categories: "begin: host starts a timed round; promotion:'untimed' disables the timer. submit/stop: text is a JSON array of six English answers in category order; stop needs a complete sheet. expire reveals a timed-out round. vote: cards is rejected cell IDs (owner seat * 6 + category index), excluding your own row; an empty array accepts all other answers. next: host advances. Answers and ballots lock once submitted. Include at: the visible zero-based round and scoreKey: the visible roundKey on submit/stop/vote/expire to allow independent same-round actions arriving on the same revision.",
+  cheat: "play: cards is one to four card IDs from your hand, claiming the displayed rank. During challenge phase any other seat may challenge; only the next player may accept. Final-card claims must resolve before a win.",
+  president: "play: cards is one to four equal-rank card IDs. Match pile size and beat its rank; 2 is high. Opening group includes 3 of clubs. pass sits out until the pile clears. Finished seats leave play; order gives final places.",
+  rummy: "stock/upcard: draw first. meld: cards is a set or run of held card IDs. layoff: at is a public meld index, cards is held card IDs to add. discard: at is a held card ID. Aces low; keep one final discard; do not immediately discard the upcard you took.",
   "connect-four": "place: at is a zero-based column (0\u20136). Convenience: --column 1\u20137.",
   "tic-tac-toe": "place: at is a zero-based row-major square (0\u20138).",
   chess: "move: from/to are algebraic squares; promotion is q/r/b/n.",
@@ -4395,6 +4434,8 @@ function agentPosition(room) {
     game: room.game,
     revision: room.revision,
     phase: room.phase,
+    access: room.access ?? "invite",
+    ...room.requests ? { access_requests: room.requests } : {},
     you: { seat: room.seat, piece: !complete ? `seat-${room.seat + 1}` : room.game === "chess" ? room.seat === 0 ? "white" : "black" : room.seat === 0 ? "X" : "O", left: room.players[room.seat].left },
     turn: match && room.phase === "playing" ? { seat: turn, yours } : null,
     players: room.players.map((p, seat) => ({ seat, name: p.name, left: p.left, ...p.agent ? { agent: true } : {}, ...p.paused ? { paused: true } : {} })),
@@ -4548,7 +4589,7 @@ async function rpc(session, method, payload = {}, query = false, signal) {
       redirect: "error",
       credentials: "omit",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ type: query ? "query" : "mutation", path: `multiplayer:${method}`, args: { token: session.token, ...["register", "create"].includes(method) ? {} : { code: session.room }, ...payload } }),
+      body: JSON.stringify({ type: query ? "query" : "mutation", path: `multiplayer:${method}`, args: { token: session.token, ...["register", "create", "list"].includes(method) ? {} : { code: session.room }, ...payload } }),
       signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15e3)]) : AbortSignal.timeout(15e3)
     });
   } catch {
@@ -4665,12 +4706,12 @@ async function createRoom(options, signal) {
   const pendingPath = sessionPath(options.server, "creating");
   let pending = await loadSession(pendingPath);
   if (pending) {
-    if (pending.server !== options.server || pending.token !== creator.token || !pending.creation || pending.creation.game !== options.game || pending.creation.capacity !== capacity || pending.creation.goSize !== options.goSize) throw Error("An unfinished creation is saved. Resume it with the original game/capacity/board size before creating another room.");
+    if (pending.server !== options.server || pending.token !== creator.token || !pending.creation || pending.creation.game !== options.game || pending.creation.capacity !== capacity || pending.creation.goSize !== options.goSize || (pending.creation.access ?? "invite") !== (options.access ?? "invite") || (pending.creation.allowSpectators ?? true) !== (options.allowSpectators ?? true)) throw Error("An unfinished creation is saved. Resume it with the original game/capacity/board size before creating another room.");
   } else {
-    pending = await storeSession(pendingPath, { ...creator, name: name.trim(), creation: { requestId: randomUUID(), game: options.game, capacity, goSize: options.goSize } });
+    pending = await storeSession(pendingPath, { ...creator, name: name.trim(), creation: { requestId: randomUUID(), game: options.game, capacity, goSize: options.goSize, access: options.access ?? "invite", allowSpectators: options.allowSpectators ?? true } });
   }
   await rpc(pending, "register", { name: pending.name }, false, signal);
-  const reply = await rpc(pending, "create", pending.creation, false, signal);
+  const reply = await rpc(pending, "create", { ...pending.creation, agent: true }, false, signal);
   if (typeof reply?.code !== "string") throw Error("The room service returned an invalid room code. Your saved creation is retained.");
   const code = roomCode(reply.code);
   const path = sessionPath(options.server, code);
@@ -4732,9 +4773,9 @@ async function installSkill(agent = "codex") {
 // packages/cli/package.json
 var package_default = {
   name: "@leafarcade/cli",
-  version: "0.1.0-alpha.4",
+  version: "0.1.1",
   private: false,
-  description: "Create private browser board games and play with your AI agent. Includes 43 games and an installable Codex/Claude skill.",
+  description: "Create private browser board games and play with your AI agent. Includes 47 games and an installable Codex/Claude skill.",
   type: "module",
   bin: {
     leafarcade: "dist/cli.mjs"
@@ -4757,7 +4798,7 @@ var package_default = {
   publishConfig: {
     access: "public",
     registry: "https://registry.npmjs.org/",
-    tag: "alpha"
+    tag: "latest"
   },
   keywords: [
     "leafarcade",
@@ -4779,7 +4820,10 @@ var package_default = {
 // packages/cli/src/help.ts
 var agentCliVersion = package_default.version;
 var commands = {
-  create: { usage: 'game create --game connect-four --name "My agent" [--open] [--capacity N]', description: "Create a private room as the agent host and return the human browser link. --open launches the browser. Saved creator identity preserves limits across rooms; uncertain creation can be resumed." },
+  approve: { usage: "game approve --room CODE --revision R --request ID", description: "As host, approve a player or spectator access request shown by status. Approve only the requested participant." },
+  decline: { usage: "game decline --room CODE --revision R --request ID", description: "As host, decline a pending access request." },
+  tables: { usage: "game tables [--game GAME_ID]", description: "Find public tables with an open seat that accept AI agents. No automatic joining or polling." },
+  create: { usage: 'game create --game connect-four --name "My agent" [--open] [--capacity N]', description: "Create a table as the agent host (--access public|invite|private; default invite) and return the human browser link. --open launches the browser. Saved creator identity preserves limits across rooms; uncertain creation can be resumed." },
   open: { usage: "game open --room ROOMCODE", description: "Reopen the human browser link for a saved room. Does not create another game or share the agent credential." },
   start: { usage: "game start --room ROOMCODE --revision R", description: "Start a room you host once the requested players have joined. Other seats cannot start it." },
   skill: { usage: "skill install --agent codex|claude", description: "Install the bundled Leaf Arcade skill into your chosen agent user directory. Explicit command only; never runs during npm install. Existing customized skills are preserved. Use skill show to inspect it first." },
@@ -4797,6 +4841,10 @@ var commands = {
   forget: { usage: "forget --room ROOMCODE", description: "Delete local access only. Does not resign or revoke a credential copied elsewhere. Use game leave to leave the room." }
 };
 var examples = {
+  categories: '{"type":"begin","promotion":"untimed"}',
+  cheat: '{"type":"play","cards":[0]}',
+  president: '{"type":"play","cards":[1]}',
+  rummy: '{"type":"stock"}',
   "connect-four": "--column 4",
   chess: "--from e2 --to e4",
   checkers: "--from b6 --to a5",
@@ -4859,7 +4907,7 @@ Usage
   leafarcade ${entry.usage}
 ` : `
 Your agent plays through the terminal; you play in the browser.
-No model API key is collected. Private, unrated, unclocked rooms only.
+No model API key is collected. Unrated, unclocked tables that admit AI agents.
 
 Usage
   leafarcade COMMAND [OPTIONS]
@@ -4925,7 +4973,9 @@ Shared options
   --capacity N            Supported seat capacity (default: game minimum)
   --go-size N             Go board size: 9, 13 or 19
   --agent codex|claude     Skill installation target
-  --room CODE             Private room code
+  --access TYPE           public, invite (default), or private with host approval
+  --no-spectators          Disable observation when creating a table
+  --room CODE             Room code
   --revision R            Exact latest revision for mutations
   --server URL            Service origin; HTTPS, or localhost HTTP
   --json                  JSON is already the default for commands
@@ -4964,6 +5014,9 @@ process.once("SIGINT", () => controller.abort());
 process.once("SIGTERM", () => controller.abort());
 try {
   const { values, positionals } = parseArgs({ allowPositionals: true, options: {
+    request: { type: "string" },
+    access: { type: "string" },
+    "no-spectators": { type: "boolean" },
     open: { type: "boolean" },
     site: { type: "string" },
     capacity: { type: "string" },
@@ -4997,19 +5050,27 @@ try {
     process.stdout.write(agentCliVersion2 + "\n");
   } else {
     const command = positionals[0] === "game" ? positionals[1] : positionals[0];
-    if (!["create", "open", "start", "skill", "join", "rules", "status", "legal-actions", "play", "wait", "leave", "resign", "rematch", "pause", "resume", "forget"].includes(command)) throw Error("Unknown command. Run leafarcade --help.");
+    if (!["approve", "decline", "tables", "create", "open", "start", "skill", "join", "rules", "status", "legal-actions", "play", "wait", "leave", "resign", "rematch", "pause", "resume", "forget"].includes(command)) throw Error("Unknown command. Run leafarcade --help.");
     if (positionals.length > (positionals[0] === "game" || command === "join" || command === "skill" ? 2 : 1)) throw Error("Unexpected positional arguments.");
     let result;
     if (command === "skill") {
       if (positionals[1] === "install") result = await installSkill(values.agent);
       else if (positionals[1] === "show") result = { name: "leafarcade", files: await bundledSkill() };
       else throw Error("Use leafarcade skill install --agent codex|claude, or leafarcade skill show.");
+    } else if (command === "tables") {
+      const server = serviceUrl(values.server ?? "https://leafarcade-multiplayer.slawomir-radzyminski.workers.dev");
+      if (values.game && !supportsAgent(values.game)) throw Error("Unknown game ID.");
+      const creatorPath = sessionPath(server, "creator");
+      const session = await loadSession(creatorPath) ?? await createSession(creatorPath, server, "", "CLI Agent");
+      const tables = await rpc(session, "list", values.game ? { game: values.game } : {}, true, controller.signal);
+      result = { event: "tables", tables: tables.filter((table) => table.allowAgents && !table.timeControl && table.phase === "waiting" && table.players.length < table.capacity), next: "Choose a table, then leafarcade join ROOMCODE --name NAME. Availability is checked atomically on join." };
     } else if (command === "create") {
+      if (values.access && !["public", "invite", "private"].includes(values.access)) throw Error("Choose --access public, invite or private.");
       const server = serviceUrl(values.server ?? "https://leafarcade-multiplayer.slawomir-radzyminski.workers.dev");
       if (values.server && server !== "https://leafarcade-multiplayer.slawomir-radzyminski.workers.dev" && !values.site) throw Error("Provide --site for your custom server's browser frontend.");
       const goSize = integer(values["go-size"] ?? "9", "go-size", 9, 19);
       if (goSize !== 9 && goSize !== 13 && goSize !== 19) throw Error("go-size must be 9, 13 or 19.");
-      result = await createRoom({ server, site: values.site ?? "https://leafarcade.com", game: values.game ?? "connect-four", name: values.name, capacity: values.capacity === void 0 ? void 0 : integer(values.capacity, "capacity", 2, 8), goSize, open: values.open }, controller.signal);
+      result = await createRoom({ server, site: values.site ?? "https://leafarcade.com", game: values.game ?? "connect-four", name: values.name, capacity: values.capacity === void 0 ? void 0 : integer(values.capacity, "capacity", 2, 8), goSize, open: values.open, access: values.access, allowSpectators: !values["no-spectators"] }, controller.signal);
     } else if (command === "rules") result = agentRules(values.game);
     else {
       const server = serviceUrl(values.server ?? "https://leafarcade-multiplayer.slawomir-radzyminski.workers.dev");
@@ -5022,7 +5083,8 @@ try {
         if (name.length > 24 || /[\u0000-\u001f\u007f]/.test(name)) throw Error("Choose a display name of 1\u201324 characters without control characters.");
         session ??= await createSession(path, server, room, name);
         await rpc(session, "register", { name: session.name }, false, controller.signal);
-        await rpc(session, "join", { agent: true }, false, controller.signal);
+        const admission = await rpc(session, "join", { agent: true }, false, controller.signal);
+        if (admission?.pending) output({ event: "access_requested", room, next: "Ask the host to approve your player request, then repeat join using this saved session." });
         result = { event: "joined", position: agentPosition(await readRoom(session, controller.signal)) };
       } else {
         if (!session) throw Error("No local session for this room. Run leafarcade join ROOMCODE first.");
@@ -5033,7 +5095,11 @@ try {
           result = await waitForRoom(session, integer(values["after-revision"], "after-revision", 0, Number.MAX_SAFE_INTEGER), integer(values.timeout ?? "25", "timeout", 1, 3600), controller.signal);
         } else {
           const view = await readRoom(session, controller.signal);
-          if (command === "open") {
+          if (command === "approve" || command === "decline") {
+            if (!values.request) throw Error("Provide --request ID from the host status access_requests.");
+            await rpc(session, "approve", { revision: integer(values.revision, "revision", 0, Number.MAX_SAFE_INTEGER), id: values.request, accept: command === "approve" }, false, controller.signal);
+            result = { event: command === "approve" ? "access_approved" : "access_declined", position: agentPosition(await readRoom(session, controller.signal)) };
+          } else if (command === "open") {
             if (values.server && server !== "https://leafarcade-multiplayer.slawomir-radzyminski.workers.dev" && !values.site) throw Error("Provide --site for your custom server\u2019s browser frontend.");
             const url = roomUrl(values.site ?? "https://leafarcade.com", view.game, room);
             result = { event: "browser_requested", room, url, browser: await openBrowser(url) };

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@leafarcade/cli",
-  "version": "0.1.0-alpha.4",
+  "version": "0.1.1",
   "private": false,
-  "description": "Create private browser board games and play with your AI agent. Includes 43 games and an installable Codex/Claude skill.",
+  "description": "Create private browser board games and play with your AI agent. Includes 47 games and an installable Codex/Claude skill.",
   "type": "module",
   "bin": {
     "leafarcade": "dist/cli.mjs"
@@ -25,7 +25,7 @@
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/",
-    "tag": "alpha"
+    "tag": "latest"
   },
   "keywords": [
     "leafarcade",