dorkfuncli 0.0.1

package/src/commands/agent.ts

@@ -0,0 +1,175 @@
+import { Command } from "commander";
+import { parseEther, formatEther } from "ethers";
+import { DorkAgent, Strategy, GameContext, Action, EscrowInfo } from "@dorkfun/agent-sdk";
+import { initConfig, getConfig } from "../config/index.js";
+import { getAddress, signMessage, sendEscrowDeposit } from "../wallet/signer.js";
+
+function formatBoard(board: (string | null)[]): string {
+  if (!board || board.length !== 9) return "";
+  const rows: string[] = [];
+  for (let r = 0; r < 3; r++) {
+    rows.push(
+      board
+        .slice(r * 3, r * 3 + 3)
+        .map((c) => c || ".")
+        .join(" ")
+    );
+  }
+  return rows.join(" | ");
+}
+
+function log(tag: string, message: string): void {
+  const ts = new Date().toISOString().slice(11, 19);
+  console.log(`${ts} [${tag.padEnd(5)}] ${message}`);
+}
+
+class RandomStrategy implements Strategy {
+  private delay: number;
+  private gameId: string;
+
+  constructor(gameId: string, delay: number) {
+    this.delay = delay;
+    this.gameId = gameId;
+  }
+
+  chooseAction(ctx: GameContext): Action {
+    const idx = Math.floor(Math.random() * ctx.legalActions.length);
+    return ctx.legalActions[idx];
+  }
+
+  onStateUpdate(ctx: GameContext): void {
+    const pub = ctx.observation.publicData as Record<string, unknown>;
+    const board = pub.board as (string | null)[] | undefined;
+    const turnLabel = ctx.yourTurn ? "Your turn" : "Opponent's turn";
+
+    if (board) {
+      log("state", `Turn ${ctx.turnNumber} | ${turnLabel} | ${formatBoard(board)}`);
+    } else {
+      log("state", `Turn ${ctx.turnNumber} | ${turnLabel}`);
+    }
+  }
+}
+
+export function registerAgentCommand(program: Command): void {
+  program
+    .command("agent")
+    .description("Play games headlessly with a built-in random agent")
+    .option("-g, --game <gameId>", "Game to play", "tictactoe")
+    .option("-n, --count <N>", "Number of games to play", "1")
+    .option("--delay <ms>", "Delay between moves in ms", "0")
+    .option("--stake <ETH>", "Stake amount in ETH (e.g. 0.01 for 0.01 ETH, 1 for 1 ETH)")
+    .option("--private", "Create a private match")
+    .option("--invite <code>", "Join a private match by invite code")
+    .action(async (opts) => {
+      await initConfig();
+
+      const config = getConfig();
+      const address = getAddress();
+      const count = parseInt(opts.count, 10) || 1;
+      const delay = parseInt(opts.delay, 10) || 0;
+
+      // Convert ETH input to wei for the protocol
+      let stakeWei: string | undefined;
+      if (opts.stake) {
+        try {
+          stakeWei = parseEther(opts.stake).toString();
+        } catch {
+          log("error", `Invalid stake amount: "${opts.stake}". Use a decimal ETH value (e.g. 0.01, 1.5)`);
+          process.exit(1);
+        }
+      }
+
+      log("init", `Player: ${address}`);
+      log("init", `Server: ${config.serverUrl}`);
+      log("init", `Game: ${opts.game} | Count: ${count} | Delay: ${delay}ms`);
+      if (stakeWei) {
+        log("init", `Stake: ${opts.stake} ETH (${stakeWei} wei)`);
+      }
+
+      const agent = new DorkAgent({
+        serverUrl: config.serverUrl,
+        wsUrl: config.wsUrl,
+        playerId: address,
+        signMessage,
+      });
+
+      // Clean shutdown on Ctrl+C
+      process.on("SIGINT", () => {
+        log("exit", "Shutting down...");
+        agent.close();
+        process.exit(0);
+      });
+
+      let wins = 0;
+      let losses = 0;
+      let draws = 0;
+
+      for (let i = 0; i < count; i++) {
+        if (count > 1) {
+          log("match", `--- Game ${i + 1} of ${count} ---`);
+        }
+
+        const strategy = new RandomStrategy(opts.game, delay);
+
+        try {
+          // Check for active match to reconnect to before starting a new one
+          const reconnected = await agent.reconnect(strategy, {
+            moveDelay: delay,
+            onLog: log,
+          });
+          if (reconnected) {
+            if (reconnected.draw) draws++;
+            else if (reconnected.didWin) wins++;
+            else losses++;
+            continue;
+          }
+
+          // Build deposit handler for staked matches
+          const depositHandler = stakeWei
+            ? async (escrow: EscrowInfo) => {
+                log("stake", `Depositing ${formatEther(escrow.stakeWei)} ETH to escrow ${escrow.address}...`);
+                return sendEscrowDeposit(escrow);
+              }
+            : undefined;
+
+          let result;
+          if (opts.invite) {
+            result = await agent.playPrivate(opts.game, strategy, {
+              inviteCode: opts.invite,
+              moveDelay: delay,
+              onLog: log,
+              stakeWei,
+              sendDeposit: depositHandler,
+            });
+          } else if (opts.private) {
+            result = await agent.playPrivate(opts.game, strategy, {
+              moveDelay: delay,
+              onLog: log,
+              stakeWei,
+              sendDeposit: depositHandler,
+            });
+          } else {
+            result = await agent.play(opts.game, strategy, {
+              moveDelay: delay,
+              onLog: log,
+              stakeWei,
+              sendDeposit: depositHandler,
+            });
+          }
+
+          if (result.draw) draws++;
+          else if (result.didWin) wins++;
+          else losses++;
+        } catch (err: any) {
+          log("error", err.message);
+          break;
+        }
+      }
+
+      if (count > 1) {
+        log("done", `Results: ${wins}W / ${losses}L / ${draws}D (${count} games)`);
+      }
+
+      process.exit(0);
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,162 @@
+import { Command } from "commander";
+import { createInterface, Interface as RLInterface } from "node:readline";
+import { randomBytes } from "node:crypto";
+import {
+  resolveConfig,
+  readConfigFile,
+  updateConfigFile,
+  writeConfigFile,
+  getConfigPath,
+  CONFIG_KEYS,
+  DEFAULTS,
+  ENV_MAP,
+  ConfigData,
+} from "../config/index.js";
+
+function createPrompter() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  let closed = false;
+  rl.once("close", () => {
+    closed = true;
+  });
+
+  return {
+    ask(prompt: string): Promise<string> {
+      if (closed) return Promise.resolve("");
+      return new Promise((resolve) => {
+        rl.question(prompt, (answer) => resolve(answer));
+        rl.once("close", () => resolve(""));
+      });
+    },
+    close() {
+      if (!closed) rl.close();
+    },
+  };
+}
+
+export function registerConfigCommand(program: Command): void {
+  const configCmd = program
+    .command("config")
+    .description("Manage CLI configuration (~/.dork/config.json)");
+
+  configCmd.action(async () => {
+    await runWizard();
+  });
+
+  configCmd
+    .command("set <key> <value>")
+    .description("Set a config value")
+    .action(async (key: string, value: string) => {
+      if (!isValidKey(key)) {
+        console.error(
+          `Unknown config key: "${key}". Valid keys: ${CONFIG_KEYS.join(", ")}`,
+        );
+        process.exit(1);
+      }
+      await updateConfigFile(key as keyof ConfigData, value);
+      const display = key === "privateKey" ? maskKey(value) : value;
+      console.log(`Set ${key} = ${display}`);
+    });
+
+  configCmd
+    .command("get <key>")
+    .description("Get a config value")
+    .action(async (key: string) => {
+      if (!isValidKey(key)) {
+        console.error(
+          `Unknown config key: "${key}". Valid keys: ${CONFIG_KEYS.join(", ")}`,
+        );
+        process.exit(1);
+      }
+      const resolved = await resolveConfig();
+      console.log(resolved[key as keyof ConfigData]);
+    });
+
+  configCmd
+    .command("list")
+    .description("List all config values with sources")
+    .action(async () => {
+      await printConfigList();
+    });
+}
+
+export async function runWizard(): Promise<void> {
+  const existing = await readConfigFile();
+  const prompter = createPrompter();
+
+  console.log("\nDork CLI Configuration");
+  console.log("──────────────────────\n");
+
+  try {
+    const serverUrl = await prompter.ask(
+      `Server URL [${existing.serverUrl || DEFAULTS.serverUrl}]: `,
+    );
+    const wsUrl = await prompter.ask(
+      `WebSocket URL [${existing.wsUrl || DEFAULTS.wsUrl}]: `,
+    );
+    const privateKeyInput = await prompter.ask(
+      `Private key [enter to generate new]: `,
+    );
+
+    const data: Partial<ConfigData> = {
+      ...existing,
+      serverUrl: serverUrl.trim() || existing.serverUrl || DEFAULTS.serverUrl,
+      wsUrl: wsUrl.trim() || existing.wsUrl || DEFAULTS.wsUrl,
+    };
+
+    if (privateKeyInput.trim()) {
+      data.privateKey = privateKeyInput.trim();
+    } else if (!existing.privateKey) {
+      data.privateKey = "0x" + randomBytes(32).toString("hex");
+      console.log(`\nGenerated new private key: ${maskKey(data.privateKey)}`);
+    }
+
+    await writeConfigFile(data);
+    console.log(`\nConfig saved to ${getConfigPath()}\n`);
+
+    const resolved = await resolveConfig();
+    for (const key of CONFIG_KEYS) {
+      const value =
+        key === "privateKey" ? maskKey(resolved[key]) : resolved[key];
+      console.log(`  ${key}: ${value}`);
+    }
+    console.log("");
+  } finally {
+    prompter.close();
+  }
+}
+
+async function printConfigList(): Promise<void> {
+  const resolved = await resolveConfig();
+  const fileData = await readConfigFile();
+
+  console.log(`\nConfig file: ${getConfigPath()}`);
+  console.log("──────────────────────────────────────");
+
+  for (const key of CONFIG_KEYS) {
+    const value =
+      key === "privateKey" ? maskKey(resolved[key]) : resolved[key];
+    const source = getSource(key, fileData);
+    console.log(`  ${key}: ${value}  (${source})`);
+  }
+  console.log("");
+}
+
+function isValidKey(key: string): key is keyof ConfigData {
+  return CONFIG_KEYS.includes(key as keyof ConfigData);
+}
+
+function maskKey(key: string): string {
+  if (!key || key.length < 10) return key ? "****" : "(not set)";
+  return key.slice(0, 6) + "..." + key.slice(-4);
+}
+
+function getSource(
+  key: keyof ConfigData,
+  fileData: Partial<ConfigData>,
+): string {
+  const envVal = process.env[ENV_MAP[key]];
+  if (envVal !== undefined && envVal !== "") return `env: ${ENV_MAP[key]}`;
+  if (fileData[key] !== undefined && fileData[key] !== "") return "config file";
+  return "default";
+}

package/src/config/configFile.ts

@@ -0,0 +1,55 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { ConfigData } from "./defaults.js";
+
+const CONFIG_DIR = join(homedir(), ".dork");
+const CONFIG_PATH = join(CONFIG_DIR, "config.json");
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getConfigPath(): string {
+  return CONFIG_PATH;
+}
+
+export async function readConfigFile(): Promise<Partial<ConfigData>> {
+  try {
+    const raw = await readFile(CONFIG_PATH, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return {};
+    }
+    return parsed as Partial<ConfigData>;
+  } catch (err: any) {
+    if (err.code === "ENOENT") {
+      return {};
+    }
+    if (err instanceof SyntaxError) {
+      console.error(
+        `Warning: ${CONFIG_PATH} is malformed and was ignored. ` +
+          `Run "dork config" to recreate it.`,
+      );
+      return {};
+    }
+    throw err;
+  }
+}
+
+export async function writeConfigFile(
+  data: Partial<ConfigData>,
+): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_PATH, JSON.stringify(data, null, 2) + "\n", "utf-8");
+}
+
+export async function updateConfigFile(
+  key: keyof ConfigData,
+  value: string,
+): Promise<Partial<ConfigData>> {
+  const existing = await readConfigFile();
+  existing[key] = value;
+  await writeConfigFile(existing);
+  return existing;
+}

package/src/config/defaults.ts

@@ -0,0 +1,28 @@
+export interface ConfigData {
+  serverUrl: string;
+  wsUrl: string;
+  privateKey: string;
+  /** RPC URL for on-chain deposit transactions */
+  rpcUrl: string;
+}
+
+export const CONFIG_KEYS: (keyof ConfigData)[] = [
+  "serverUrl",
+  "wsUrl",
+  "privateKey",
+  "rpcUrl",
+];
+
+export const DEFAULTS: ConfigData = {
+  serverUrl: "https://engine.dork.fun",
+  wsUrl: "wss://engine.dork.fun",
+  privateKey: "",
+  rpcUrl: "https://eth.llamarpc.com",
+};
+
+export const ENV_MAP: Record<keyof ConfigData, string> = {
+  serverUrl: "SERVER_URL",
+  wsUrl: "SERVER_WS_URL",
+  privateKey: "PRIVATE_KEY",
+  rpcUrl: "RPC_URL",
+};

package/src/config/index.ts

@@ -0,0 +1,15 @@
+export {
+  ConfigData,
+  CONFIG_KEYS,
+  DEFAULTS,
+  ENV_MAP,
+} from "./defaults.js";
+export {
+  readConfigFile,
+  writeConfigFile,
+  updateConfigFile,
+  getConfigDir,
+  getConfigPath,
+} from "./configFile.js";
+export { resolveConfig, setCliOverride } from "./resolve.js";
+export { initConfig, getConfig } from "./runtime.js";

package/src/config/resolve.ts

@@ -0,0 +1,33 @@
+import { ConfigData, DEFAULTS, ENV_MAP, CONFIG_KEYS } from "./defaults.js";
+import { readConfigFile } from "./configFile.js";
+
+const cliOverrides: Partial<ConfigData> = {};
+
+export function setCliOverride<K extends keyof ConfigData>(
+  key: K,
+  value: ConfigData[K],
+): void {
+  cliOverrides[key] = value;
+}
+
+export async function resolveConfig(): Promise<ConfigData> {
+  const fileConfig = await readConfigFile();
+  const resolved: ConfigData = { ...DEFAULTS };
+
+  for (const key of CONFIG_KEYS) {
+    if (fileConfig[key] !== undefined && fileConfig[key] !== "") {
+      resolved[key] = fileConfig[key]!;
+    }
+
+    const envVal = process.env[ENV_MAP[key]];
+    if (envVal !== undefined && envVal !== "") {
+      resolved[key] = envVal;
+    }
+
+    if (cliOverrides[key] !== undefined && cliOverrides[key] !== "") {
+      resolved[key] = cliOverrides[key]!;
+    }
+  }
+
+  return resolved;
+}

package/src/config/runtime.ts

@@ -0,0 +1,18 @@
+import { ConfigData } from "./defaults.js";
+import { resolveConfig } from "./resolve.js";
+
+let _config: ConfigData | null = null;
+
+export async function initConfig(): Promise<ConfigData> {
+  _config = await resolveConfig();
+  return _config;
+}
+
+export function getConfig(): ConfigData {
+  if (!_config) {
+    throw new Error(
+      "Config not initialized. Call initConfig() before accessing config.",
+    );
+  }
+  return _config;
+}