chitin-openclaw-plugin 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -5,7 +5,7 @@
  * 1. Wallet tools — check balance, claim faucet, deposit to table
  * 2. Game tools — discover, lobby, create table, register, send action
  * 3. WebSocket connection — persistent connection to poker table, your_turn events
- *    injected into agent session via hooks
+ *    injected into agent session via openclaw agent --message
  */
 declare const plugin: {
     id: string;

package/dist/index.js

@@ -12,6 +12,12 @@ import { privateKeyToAccount } from "viem/accounts";
 import { baseSepolia } from "viem/chains";
 import WebSocket from "ws";
 import { execFile } from "child_process";
+import { trace, SpanStatusCode } from "@opentelemetry/api";
+import { NodeTracerProvider } from "@opentelemetry/sdk-trace-node";
+import { BatchSpanProcessor } from "@opentelemetry/sdk-trace-node";
+import { OTLPTraceExporter } from "@opentelemetry/exporter-trace-otlp-http";
+import { Resource } from "@opentelemetry/resources";
+import { ATTR_SERVICE_NAME } from "@opentelemetry/semantic-conventions";
 var ERC20_ABI = parseAbi([
   "function balanceOf(address) view returns (uint256)",
   "function transferAndCall(address to, uint256 amount, bytes data) returns (bool)",
@@ -32,43 +38,42 @@ function connectToTable(gameServerUrl, roomCode, playerId, name, walletAddress,
   function connect() {
     if (aborted) return;
     const wsUrl = gameServerUrl.replace(/^http/, "ws") + `/parties/poker/${roomCode}`;
-    logger.info(`[chitin] Connecting WebSocket to ${wsUrl}`);
+    logger.info(`[chitin] WS connecting to ${wsUrl}`);
     ws = new WebSocket(wsUrl);
     ws.on("open", () => {
-      logger.info(`[chitin] WebSocket connected to table ${roomCode}`);
+      logger.info(`[chitin] WS connected to ${roomCode}`);
       wsStore.set(roomCode, ws);
-      ws.send(JSON.stringify({
-        type: "enter",
-        playerId,
-        name,
-        walletAddress
-      }));
+      const enterMsg = { type: "enter", playerId, name, walletAddress };
+      logger.info(`[chitin] WS sending enter: ${JSON.stringify(enterMsg)}`);
+      ws.send(JSON.stringify(enterMsg));
     });
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
         handleMessage(msg, roomCode, logger);
       } catch (err) {
-        logger.warn(`[chitin] Failed to parse message: ${err.message}`);
+        logger.warn(`[chitin] WS parse error: ${err.message}`);
       }
     });
-    ws.on("close", () => {
+    ws.on("close", (code) => {
       if (aborted) return;
-      logger.info(`[chitin] WebSocket closed for table ${roomCode}, reconnecting in 3s...`);
+      logger.info(`[chitin] WS closed (code ${code}), reconnecting in 3s...`);
       setTimeout(connect, 3e3);
     });
     ws.on("error", (err) => {
-      logger.warn(`[chitin] WebSocket error: ${err.message}`);
+      logger.error(`[chitin] WS error: ${err.message}`);
     });
   }
   const latestState = /* @__PURE__ */ new Map();
   function handleMessage(msg, roomCode2, logger2) {
     if (msg.type === "game_state") {
       latestState.set(roomCode2, msg);
+      logger2.info(`[chitin] game_state: players=${msg.players?.length || 0} hand=${msg.isHandInProgress ? "yes" : "no"}`);
     } else if (msg.type === "your_turn") {
       const state = latestState.get(roomCode2);
       const legalActions = msg.legalActions?.join(", ") || "";
       const chipRange = msg.chipRange ? `${msg.chipRange.min}-${msg.chipRange.max}` : "";
+      logger2.info(`[chitin] YOUR TURN: actions=[${legalActions}] range=${chipRange}`);
       const parts = [`POKER: It's your turn at table ${roomCode2}.`];
       if (state?.holeCards) {
         const cards = state.holeCards.map((c) => `${c.rank}${c.suit[0]}`).join(" ");
@@ -92,25 +97,30 @@ function connectToTable(gameServerUrl, roomCode, playerId, name, walletAddress,
     } else if (msg.type === "hand_result") {
       const winners = msg.result?.winners?.flat() || [];
       const winnerNames = winners.map((w) => `${w.playerId}(${w.amount})`).join(", ");
+      logger2.info(`[chitin] HAND RESULT: winners=${winnerNames} rake=${msg.result?.rake || 0}`);
       const text = `POKER HAND RESULT at table ${roomCode2}: Winners: ${winnerNames}. Rake: ${msg.result?.rake || 0}.`;
       promptAgent(text, logger2);
+    } else {
+      logger2.info(`[chitin] WS msg: type=${msg.type}`);
     }
   }
   function promptAgent(text, logger2) {
-    execFile("openclaw", ["agent", "--local", "--message", text], (err, _stdout, stderr) => {
+    logger2.info(`[chitin] Prompting agent: ${text.slice(0, 100)}...`);
+    const child = execFile("openclaw", ["agent", "--local", "--message", text], {
+      timeout: 12e4,
+      env: process.env
+      // Inherit HOME pointing to workspace
+    }, (err, stdout, stderr) => {
       if (err) {
-        logger2.error(`[chitin] Failed to prompt agent: ${err.message}`);
+        logger2.error(`[chitin] Agent prompt failed: ${err.message}`);
+        if (stderr) logger2.error(`[chitin] Agent stderr: ${stderr.slice(0, 500)}`);
         return;
       }
-      if (stderr) logger2.warn(`[chitin] Agent stderr: ${stderr}`);
-      logger2.info(`[chitin] Agent prompted successfully`);
+      if (stdout) logger2.info(`[chitin] Agent response: ${stdout.slice(0, 300)}`);
+      if (stderr) logger2.warn(`[chitin] Agent stderr: ${stderr.slice(0, 300)}`);
+      logger2.info(`[chitin] Agent prompted ok`);
     });
   }
-  const sendAction = (action) => {
-    if (ws?.readyState === WebSocket.OPEN) {
-      ws.send(JSON.stringify({ type: "action", action }));
-    }
-  };
   connect();
   return () => {
     aborted = true;
@@ -123,29 +133,57 @@ var plugin = {
   description: "Play poker at Chitin Casino \u2014 wallet management and real-time game connection",
   configSchema: {
     type: "object",
-    additionalProperties: false,
+    additionalProperties: true,
     properties: {}
   },
   register(api) {
     api.logger.info("[chitin] Chitin Casino plugin loaded");
+    let tracer = trace.getTracer("chitin-plugin");
+    try {
+      const endpoint = process.env.OTEL_EXPORTER_OTLP_ENDPOINT;
+      const headers = process.env.OTEL_EXPORTER_OTLP_HEADERS;
+      if (endpoint) {
+        const headerObj = {};
+        if (headers) {
+          for (const pair of headers.split(",")) {
+            const [k, ...v] = pair.split("=");
+            if (k) headerObj[k.trim()] = v.join("=").trim();
+          }
+        }
+        const provider = new NodeTracerProvider({
+          resource: new Resource({ [ATTR_SERVICE_NAME]: "chitin-plugin" }),
+          spanProcessors: [
+            new BatchSpanProcessor(new OTLPTraceExporter({
+              url: `${endpoint}/v1/traces`,
+              headers: headerObj
+            }))
+          ]
+        });
+        provider.register();
+        tracer = trace.getTracer("chitin-plugin");
+        api.logger.info(`[chitin] OTel initialized \u2014 endpoint=${endpoint}`);
+        const span = tracer.startSpan("plugin.loaded");
+        span.setAttributes({ "plugin.name": "chitin-openclaw-plugin" });
+        span.setStatus({ code: SpanStatusCode.OK });
+        span.end();
+        api.logger.info("[chitin] OTel test span emitted: plugin.loaded");
+      } else {
+        api.logger.info("[chitin] OTel skipped \u2014 no OTEL_EXPORTER_OTLP_ENDPOINT");
+      }
+    } catch (err) {
+      api.logger.warn(`[chitin] OTel init failed (non-fatal): ${err.message}`);
+    }
     const gameServerUrl = process.env.GAME_SERVER_URL || "http://localhost:3665";
+    const adminServerUrl = process.env.ADMIN_SERVER_URL || "http://localhost:3667";
     const activeConnections = /* @__PURE__ */ new Map();
     const wsInstances = /* @__PURE__ */ new Map();
-    api.registerTool({
-      name: "chitin_test",
-      label: "Chitin Test",
-      description: "A test tool that returns hello world",
-      parameters: { type: "object", properties: {} },
-      execute: async (_toolCallId) => {
-        return { message: "Hello from Chitin Casino plugin!" };
-      }
-    });
     api.registerTool({
       name: "chitin_wallet_address",
       description: "Get your Chitin Casino wallet address",
       parameters: {},
-      execute: async (_toolCallId) => {
+      execute: async () => {
         const { account } = getWalletClients();
+        api.logger.info(`[chitin] wallet_address: ${account.address}`);
         return { address: account.address };
       }
     });
@@ -160,7 +198,9 @@ var plugin = {
       },
       execute: async (_toolCallId, params) => {
         const { account, publicClient } = getWalletClients();
+        api.logger.info(`[chitin] wallet_balance: checking ${account.address}`);
         const ethBalance = await publicClient.getBalance({ address: account.address });
+        api.logger.info(`[chitin] wallet_balance: ETH=${formatEther(ethBalance)}`);
         let tokenBalance = BigInt(0);
         let tokenAddr = params.tokenAddress;
         if (!tokenAddr) {
@@ -168,7 +208,9 @@ var plugin = {
             const res = await fetch(`${gameServerUrl}/contracts`);
             const data = await res.json();
             tokenAddr = data.token;
-          } catch {
+            api.logger.info(`[chitin] wallet_balance: token=${tokenAddr}`);
+          } catch (err) {
+            api.logger.error(`[chitin] wallet_balance: failed to fetch token address: ${err.message}`);
           }
         }
         if (tokenAddr) {
@@ -178,6 +220,7 @@ var plugin = {
             functionName: "balanceOf",
             args: [account.address]
           });
+          api.logger.info(`[chitin] wallet_balance: NUMERO=${formatEther(tokenBalance)}`);
         }
         return {
           address: account.address,
@@ -188,21 +231,18 @@ var plugin = {
     });
     api.registerTool({
       name: "chitin_faucet_claim",
-      description: "Claim NUMERO tokens from the faucet. This is a free server-side operation \u2014 no gas needed.",
+      description: "Claim NUMERO tokens from the faucet. Free \u2014 no gas needed.",
       parameters: {},
-      execute: async (_toolCallId) => {
+      execute: async () => {
         const { account } = getWalletClients();
-        const adminServerUrl = process.env.ADMIN_SERVER_URL || "http://localhost:3667";
-        const serviceKey = process.env.SERVICE_KEY || "";
+        api.logger.info(`[chitin] faucet_claim: wallet=${account.address} server=${adminServerUrl}`);
         const res = await fetch(`${adminServerUrl}/faucet/claim`, {
           method: "POST",
-          headers: {
-            "Content-Type": "application/json",
-            "x-service-key": serviceKey
-          },
+          headers: { "Content-Type": "application/json" },
           body: JSON.stringify({ walletAddress: account.address })
         });
         const data = await res.json();
+        api.logger.info(`[chitin] faucet_claim: status=${res.status} response=${JSON.stringify(data)}`);
         if (!res.ok) throw new Error(data.error || "Faucet claim failed");
         return data;
       }
@@ -220,21 +260,27 @@ var plugin = {
         required: ["amount", "tableId", "gameId"]
       },
       execute: async (_toolCallId, params) => {
+        api.logger.info(`[chitin] deposit: amount=${params.amount} tableId=${params.tableId} gameId=${params.gameId}`);
         const { publicClient, walletClient } = getWalletClients();
+        api.logger.info(`[chitin] deposit: fetching contracts from ${gameServerUrl}/contracts`);
         const res = await fetch(`${gameServerUrl}/contracts`);
         const contracts = await res.json();
+        api.logger.info(`[chitin] deposit: token=${contracts.token} diamond=${contracts.diamond}`);
         const amountWei = parseEther(params.amount);
         const data = encodeAbiParameters(
           [{ type: "bytes32" }, { type: "bytes32" }],
           [params.tableId, params.gameId]
         );
+        api.logger.info(`[chitin] deposit: sending transferAndCall amount=${amountWei} to=${contracts.diamond}`);
         const hash = await walletClient.writeContract({
           address: contracts.token,
           abi: ERC20_ABI,
           functionName: "transferAndCall",
           args: [contracts.diamond, amountWei, data]
         });
+        api.logger.info(`[chitin] deposit: tx sent hash=${hash}`);
         const receipt = await publicClient.waitForTransactionReceipt({ hash });
+        api.logger.info(`[chitin] deposit: confirmed block=${receipt.blockNumber} status=${receipt.status}`);
         return { txHash: hash, blockNumber: Number(receipt.blockNumber) };
       }
     });
@@ -242,18 +288,24 @@ var plugin = {
       name: "chitin_discover",
       description: "Discover Chitin Casino \u2014 games, contracts, faucet info",
       parameters: {},
-      execute: async (_toolCallId) => {
+      execute: async () => {
+        api.logger.info(`[chitin] discover: ${gameServerUrl}/discover`);
         const res = await fetch(`${gameServerUrl}/discover`);
-        return await res.json();
+        const data = await res.json();
+        api.logger.info(`[chitin] discover: status=${res.status}`);
+        return data;
       }
     });
     api.registerTool({
       name: "chitin_lobby",
       description: "List poker tables with open seats",
       parameters: {},
-      execute: async (_toolCallId) => {
+      execute: async () => {
+        api.logger.info(`[chitin] lobby: ${gameServerUrl}/parties/pokerlobby/main/tables`);
         const res = await fetch(`${gameServerUrl}/parties/pokerlobby/main/tables`);
-        return await res.json();
+        const data = await res.json();
+        api.logger.info(`[chitin] lobby: status=${res.status} tables=${Array.isArray(data) ? data.length : "?"}`);
+        return data;
       }
     });
     api.registerTool({
@@ -269,19 +321,21 @@ var plugin = {
         }
       },
       execute: async (_toolCallId, params) => {
+        const settings = {
+          smallBlind: params.smallBlind || 1,
+          bigBlind: params.bigBlind || 2,
+          minBuyIn: params.minBuyIn || 50,
+          maxBuyIn: params.maxBuyIn || 200
+        };
+        api.logger.info(`[chitin] create_table: ${JSON.stringify(settings)}`);
         const res = await fetch(`${gameServerUrl}/parties/poker/create`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            settings: {
-              smallBlind: params.smallBlind || 1,
-              bigBlind: params.bigBlind || 2,
-              minBuyIn: params.minBuyIn || 50,
-              maxBuyIn: params.maxBuyIn || 200
-            }
-          })
+          body: JSON.stringify({ settings })
         });
-        return await res.json();
+        const data = await res.json();
+        api.logger.info(`[chitin] create_table: status=${res.status} response=${JSON.stringify(data)}`);
+        return data;
       }
     });
     api.registerTool({
@@ -299,6 +353,7 @@ var plugin = {
       execute: async (_toolCallId, params) => {
         const { account } = getWalletClients();
         const botName = params.name || "ClawBot";
+        api.logger.info(`[chitin] register: room=${params.roomCode} name=${botName} buyIn=${params.buyIn || 200} wallet=${account.address}`);
         const res = await fetch(`${gameServerUrl}/parties/poker/${params.roomCode}/register`, {
           method: "POST",
           headers: { "Content-Type": "application/json" },
@@ -309,6 +364,7 @@ var plugin = {
           })
         });
         const result = await res.json();
+        api.logger.info(`[chitin] register: status=${res.status} response=${JSON.stringify(result)}`);
         if (!res.ok) return result;
         const cleanup = connectToTable(
           gameServerUrl,
@@ -319,8 +375,7 @@ var plugin = {
           api.logger,
           wsInstances
         );
-        activeConnections.set(params.roomCode, { cleanup, ws: null });
-        api.logger.info(`[chitin] Registered at ${params.roomCode}, WebSocket connected`);
+        activeConnections.set(params.roomCode, { cleanup });
         return { ...result, wsConnected: true };
       }
     });
@@ -337,13 +392,16 @@ var plugin = {
         required: ["roomCode", "action"]
       },
       execute: async (_toolCallId, params) => {
+        api.logger.info(`[chitin] poker_action: room=${params.roomCode} action=${params.action} amount=${params.amount ?? "n/a"}`);
         const ws = wsInstances.get(params.roomCode);
         if (!ws || ws.readyState !== WebSocket.OPEN) {
+          api.logger.error(`[chitin] poker_action: NOT CONNECTED to ${params.roomCode} (ws=${ws ? "exists" : "null"} state=${ws?.readyState})`);
           return { error: "Not connected to table. Call chitin_register first." };
         }
         const action = { type: params.action };
         if (params.amount !== void 0) action.amount = params.amount;
         ws.send(JSON.stringify({ type: "action", action }));
+        api.logger.info(`[chitin] poker_action: sent ${JSON.stringify(action)}`);
         return { ok: true, sent: action };
       }
     });
@@ -359,22 +417,27 @@ var plugin = {
         required: ["roomCode", "token"]
       },
       execute: async (_toolCallId, params) => {
+        api.logger.info(`[chitin] leave_table: room=${params.roomCode}`);
+        const ws = wsInstances.get(params.roomCode);
+        if (ws?.readyState === WebSocket.OPEN) {
+          ws.send(JSON.stringify({ type: "leave" }));
+          api.logger.info(`[chitin] leave_table: sent leave via WS`);
+        }
         const conn = activeConnections.get(params.roomCode);
         if (conn) {
           conn.cleanup();
           activeConnections.delete(params.roomCode);
         }
         wsInstances.delete(params.roomCode);
-        const ws = wsInstances.get(params.roomCode);
-        if (ws?.readyState === WebSocket.OPEN) {
-          ws.send(JSON.stringify({ type: "leave" }));
-          return { ok: true };
+        if (!ws || ws.readyState !== WebSocket.OPEN) {
+          api.logger.info(`[chitin] leave_table: fallback to HTTP leave`);
+          const res = await fetch(`${gameServerUrl}/parties/poker/${params.roomCode}/leave`, {
+            method: "POST",
+            headers: { "Authorization": `Bearer ${params.token}` }
+          });
+          return await res.json();
         }
-        const res = await fetch(`${gameServerUrl}/parties/poker/${params.roomCode}/leave`, {
-          method: "POST",
-          headers: { "Authorization": `Bearer ${params.token}` }
-        });
-        return await res.json();
+        return { ok: true };
       }
     });
   }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "chitin-openclaw-plugin",
   "name": "Chitin Casino",
-  "version": "0.1.0",
+  "version": "0.2.2",
   "description": "Play poker at Chitin Casino — wallet management and real-time game connection",
   "author": "Chitin Casino",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chitin-openclaw-plugin",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "OpenClaw plugin for Chitin Casino — wallet management and poker game connection",
   "type": "module",
   "main": "./dist/index.js",
@@ -30,6 +30,11 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "@opentelemetry/api": "^1.9.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.57.0",
+    "@opentelemetry/resources": "^1.30.0",
+    "@opentelemetry/sdk-trace-node": "^1.30.0",
+    "@opentelemetry/semantic-conventions": "^1.28.0",
     "viem": "^2.0.0",
     "ws": "^8.0.0"
   },