playclaw 1.0.0 → 1.0.2

package/index.js

@@ -11,10 +11,8 @@
  * What it does:
  *   1. Reads your OpenClaw gateway token (auto-detects or you provide it)
  *   2. Connects to your local OpenClaw gateway (localhost:18789)
- *   3. Subscribes to PlayClaw's Supabase Realtime channel (bridge:<token>)
+ *   3. Opens a private bridge channel to PlayClaw's cloud
  *   4. Relays messages between the PlayClaw playground and your agent
- *
- * No separate bridge server needed — everything runs through Supabase.
  */
 
 "use strict";
@@ -26,7 +24,7 @@ const path = require("path");
 const os = require("os");
 const http = require("http");
 
-// ─── Parse args ───────────────────────────────────────────────────────────────
+// ─── Parse args ────────────────────────────────────────────────────────────────
 
 const args = process.argv.slice(2);
 
@@ -37,12 +35,11 @@ if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
 
 const playclawToken = args[0];
 if (!playclawToken.startsWith("PC-")) {
-  console.error("❌ Invalid PlayClaw token. It should start with PC-");
-  console.error("   Get your token from: https://playclaw.info/connect");
+  console.error("\n  ✗  Invalid PlayClaw token — it should start with PC-");
+  console.error("     Get your token at: https://playclaw.info/connect\n");
   process.exit(1);
 }
 
-// Optional flags
 const flagIndex = (flag) => args.findIndex((a) => a === flag);
 const flagValue = (flag) => {
   const i = flagIndex(flag);
@@ -52,13 +49,11 @@ const flagValue = (flag) => {
 const gatewayPortArg = parseInt(flagValue("--port") || flagValue("-p")) || null;
 const gatewayTokenArg = flagValue("--gateway-token") || flagValue("-g");
 
-// ─── Config ───────────────────────────────────────────────────────────────────
+// ─── Config ────────────────────────────────────────────────────────────────────
 
-// PlayClaw's Supabase public credentials — safe to embed (anon key is public)
-// These are overridable via env vars for local development / self-hosting.
-const SUPABASE_URL =
+const CLOUD_URL =
   process.env.PLAYCLAW_SUPABASE_URL || "https://bbplxuprwmbkbslvwjfv.supabase.co";
-const SUPABASE_ANON_KEY =
+const CLOUD_KEY =
   process.env.PLAYCLAW_SUPABASE_ANON_KEY ||
   "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImJicGx4dXByd21ia2JzbHZ3amZ2Iiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzIzMjY2OTIsImV4cCI6MjA4NzkwMjY5Mn0.Y_R6ozJmyCiu_oCKJYJ7Bt17xbztRlZEk7eAI2D81fM";
 
@@ -67,25 +62,20 @@ const OPENCLAW_PORT =
   parseInt(process.env.OPENCLAW_PORT || "") ||
   18789;
 
-// ─── Auto-detect OpenClaw gateway token ─────────────────────────────────────
+// ─── Auto-detect OpenClaw gateway token ────────────────────────────────────────
 
 function detectGatewayToken() {
-  // 1. CLI flag
   if (gatewayTokenArg) return gatewayTokenArg;
-
-  // 2. Environment variable
   if (process.env.OPENCLAW_GATEWAY_TOKEN) return process.env.OPENCLAW_GATEWAY_TOKEN;
 
-  // 3. Auto-detect from ~/.openclaw/openclaw.json
   const configPath = path.join(os.homedir(), ".openclaw", "openclaw.json");
   try {
     if (!fs.existsSync(configPath)) return null;
-    // openclaw.json supports JSON5 (comments + trailing commas) — strip them
     const raw = fs.readFileSync(configPath, "utf-8");
     const cleaned = raw
-      .replace(/\/\/[^\n]*/g, "")       // strip // comments
-      .replace(/\/\*[\s\S]*?\*\//g, "") // strip /* */ comments
-      .replace(/,\s*([}\]])/g, "$1");   // strip trailing commas
+      .replace(/\/\/[^\n]*/g, "")
+      .replace(/\/\*[\s\S]*?\*\//g, "")
+      .replace(/,\s*([}\]])/g, "$1");
     const config = JSON.parse(cleaned);
     return config?.gateway?.auth?.token || null;
   } catch {
@@ -96,23 +86,18 @@ function detectGatewayToken() {
 const gatewayToken = detectGatewayToken();
 
 if (!gatewayToken) {
-  console.error("");
-  console.error("❌ Could not find your OpenClaw gateway token.");
-  console.error("");
-  console.error("   Option A — provide it directly:");
-  console.error(`     npx playclaw ${playclawToken} --gateway-token <your-token>`);
-  console.error("");
-  console.error("   Option B — set an env var:");
-  console.error(`     OPENCLAW_GATEWAY_TOKEN=<token> npx playclaw ${playclawToken}`);
-  console.error("");
-  console.error("   Option C — find it in your OpenClaw config:");
-  console.error("     openclaw config get gateway.auth.token");
-  console.error("     or look in: ~/.openclaw/openclaw.json → gateway.auth.token");
-  console.error("");
+  console.error("\n  ✗  Could not find your OpenClaw gateway token.\n");
+  console.error("     Option A — provide it directly:");
+  console.error(`       npx playclaw ${playclawToken} --gateway-token <your-token>\n`);
+  console.error("     Option B — set an env var:");
+  console.error(`       OPENCLAW_GATEWAY_TOKEN=<token> npx playclaw ${playclawToken}\n`);
+  console.error("     Option C — auto-detect from config:");
+  console.error("       openclaw config get gateway.auth.token");
+  console.error("       (~/.openclaw/openclaw.json → gateway.auth.token)\n");
   process.exit(1);
 }
 
-// ─── Logging ─────────────────────────────────────────────────────────────────
+// ─── Colors ────────────────────────────────────────────────────────────────────
 
 const c = {
   reset:   "\x1b[0m",
@@ -123,117 +108,201 @@ const c = {
   red:     "\x1b[31m",
   cyan:    "\x1b[36m",
   magenta: "\x1b[35m",
+  gray:    "\x1b[90m",
 };
 
+// ─── Spinner ───────────────────────────────────────────────────────────────────
+
+class Spinner {
+  constructor() {
+    this.frames = ["⠋","⠙","⠹","⠸","⠼","⠴","⠦","⠧","⠇","⠏"];
+    this.i = 0;
+    this._iv = null;
+    this._active = false;
+  }
+
+  start(text) {
+    this._active = true;
+    this.i = 0;
+    process.stdout.write("\n");
+    this._iv = setInterval(() => {
+      if (!this._active) return;
+      const f = this.frames[this.i++ % this.frames.length];
+      process.stdout.write(`\r  ${c.cyan}${f}${c.reset}  ${c.dim}${text}${c.reset}    `);
+    }, 80);
+    return this;
+  }
+
+  success(text) {
+    this._active = false;
+    clearInterval(this._iv);
+    process.stdout.write(`\r  ${c.green}✓${c.reset}  ${text}${" ".repeat(10)}\n`);
+  }
+
+  fail(text) {
+    this._active = false;
+    clearInterval(this._iv);
+    process.stdout.write(`\r  ${c.red}✗${c.reset}  ${c.red}${text}${c.reset}${" ".repeat(10)}\n\n`);
+  }
+}
+
+const spinner = new Spinner();
+
+// ─── Logging ───────────────────────────────────────────────────────────────────
+
 function log(icon, msg, color = c.reset) {
   const time = new Date().toLocaleTimeString("en-US", { hour12: false });
-  console.log(`${c.dim}${time}${c.reset} ${icon} ${color}${msg}${c.reset}`);
+  console.log(`  ${c.gray}${time}${c.reset}  ${icon}  ${color}${msg}${c.reset}`);
 }
 
-// ─── State ────────────────────────────────────────────────────────────────────
+// ─── State ─────────────────────────────────────────────────────────────────────
 
-let openclawWs    = null;
-let bridgeChannel = null;
-let openclawReady = false;
-let pendingMessages = []; // queued while OpenClaw reconnects
+let openclawWs      = null;
+let bridgeChannel   = null;
+let openclawReady   = false;
+let pendingMessages = [];
 let reconnectTimer  = null;
+let gatewayConnected = false;
+let bridgeConnected  = false;
 
-// ─── Supabase client ─────────────────────────────────────────────────────────
+// ─── Cloud bridge client ───────────────────────────────────────────────────────
 
-const supabase = createClient(SUPABASE_URL, SUPABASE_ANON_KEY, {
+const cloud = createClient(CLOUD_URL, CLOUD_KEY, {
   realtime: { params: { eventsPerSecond: 10 } },
 });
 
-// ─── OpenClaw Gateway connection ─────────────────────────────────────────────
+// ─── OpenClaw Gateway connection ───────────────────────────────────────────────
 
 function connectToOpenClaw() {
   openclawReady = false;
 
+  if (!gatewayConnected) {
+    spinner.start("Connecting to agent gateway...");
+  }
+
   openclawWs = new WebSocket(`ws://localhost:${OPENCLAW_PORT}`, {
     headers: { Authorization: `Bearer ${gatewayToken}` },
   });
 
+  // OpenClaw uses a challenge-response handshake:
+  // 1. Server emits connect.challenge with a nonce
+  // 2. Client replies with connect req (correct params schema)
   openclawWs.on("open", () => {
-    // Send OpenClaw handshake — identifies us as an "operator" client
-    openclawWs.send(
-      JSON.stringify({
-        type:   "req",
-        id:     `playclaw-${Date.now()}`,
-        method: "connect",
-        params: {
-          role:    "operator",
-          token:   gatewayToken,
-          client:  "playclaw",
-          version: "1.0.0",
-        },
-      })
-    );
+    if (process.env.DEBUG) log("·", "[DEBUG] WS open — waiting for challenge", c.dim);
   });
 
   openclawWs.on("message", (raw) => {
     let msg;
     try { msg = JSON.parse(raw.toString()); } catch { return; }
 
-    // Handshake accepted — we're in
+    // Step 1 — challenge received, send connect request
+    if (msg.type === "event" && msg.event === "connect.challenge") {
+      if (process.env.DEBUG) log("·", `[DEBUG] Challenge: nonce=${msg.payload?.nonce}`, c.dim);
+
+      openclawWs.send(JSON.stringify({
+        type:   "req",
+        id:     `playclaw-${Date.now()}`,
+        method: "connect",
+        params: {
+          minProtocol: 3,
+          maxProtocol: 3,
+          client: {
+            id:       "cli",
+            version:  "1.0.2",
+            platform: process.platform,
+            mode:     "operator",
+          },
+          role:        "operator",
+          scopes:      ["operator.read", "operator.write"],
+          caps:        [],
+          commands:    [],
+          permissions: {},
+          auth:        { token: gatewayToken },
+          locale:      "en-US",
+          userAgent:   "playclaw/1.0.2",
+        },
+      }));
+      return;
+    }
+
+    // Step 2 — handshake accepted
     if (msg.type === "res" && msg.ok && !openclawReady) {
       openclawReady = true;
-      log("✅", `OpenClaw gateway connected (port ${OPENCLAW_PORT})`, c.green);
 
-      // Flush messages that arrived while we were reconnecting
-      while (pendingMessages.length > 0) {
-        const queued = pendingMessages.shift();
-        sendToOpenClaw(queued.content, queued.sessionId);
+      if (!gatewayConnected) {
+        gatewayConnected = true;
+        spinner.success(`Agent gateway connected  ${c.gray}·  port ${OPENCLAW_PORT}${c.reset}`);
+        if (!bridgeChannel) connectToBridge();
+      } else {
+        log("✓", "Gateway reconnected", c.green);
+        while (pendingMessages.length > 0) {
+          const q = pendingMessages.shift();
+          sendToOpenClaw(q.content, q.sessionId);
+        }
       }
-
-      // Connect to PlayClaw via Supabase Realtime (only once)
-      if (!bridgeChannel) connectToBridge();
       return;
     }
 
-    // Auth failure — stop immediately
+    // Handshake rejected
     if (msg.type === "res" && !msg.ok) {
-      log("❌", `OpenClaw auth failed: ${msg.error?.message || "Unknown error"}`, c.red);
-      log("   ", "Check your gateway token and try again.", c.yellow);
-      process.exit(1);
+      const reason = msg.error?.message || "invalid credentials";
+      if (!gatewayConnected) {
+        spinner.fail(`Gateway auth failed — ${reason}`);
+        process.exit(1);
+      } else {
+        log("✗", `Gateway auth error — ${reason}`, c.red);
+      }
+      return;
     }
 
-    // Agent response events
+    // Agent events
     if (msg.type === "event") {
       handleOpenClawEvent(msg);
     }
   });
 
   openclawWs.on("error", (err) => {
-    if (err.code === "ECONNREFUSED") {
-      log("⚠️ ", `OpenClaw not found on port ${OPENCLAW_PORT}. Is it running?`, c.yellow);
-      log("   ", "Start it with: openclaw gateway run", c.dim);
+    if (!gatewayConnected) {
+      if (err.code === "ECONNREFUSED") {
+        spinner.fail(`Gateway not found on port ${OPENCLAW_PORT} — is OpenClaw running?`);
+      } else {
+        spinner.fail(`Gateway error: ${err.message}`);
+      }
+      process.exit(1);
     } else {
-      log("❌", `OpenClaw error: ${err.message}`, c.red);
+      if (err.code === "ECONNREFUSED") {
+        log("⚠", `Gateway offline (port ${OPENCLAW_PORT}) — retrying in 5s`, c.yellow);
+      } else {
+        log("⚠", `Gateway error: ${err.message}`, c.yellow);
+      }
     }
   });
 
   openclawWs.on("close", () => {
     openclawReady = false;
-    log("⚠️ ", "OpenClaw disconnected. Reconnecting in 5s...", c.yellow);
-    clearTimeout(reconnectTimer);
-    reconnectTimer = setTimeout(connectToOpenClaw, 5000);
+    if (gatewayConnected) {
+      log("⟳", "Gateway disconnected — reconnecting in 5s...", c.gray);
+      clearTimeout(reconnectTimer);
+      reconnectTimer = setTimeout(connectToOpenClaw, 5000);
+    }
   });
 }
 
-// ─── Handle events from OpenClaw ─────────────────────────────────────────────
+// ─── Handle events from OpenClaw ───────────────────────────────────────────────
 
 function handleOpenClawEvent(msg) {
   const eventName = msg.event || "";
 
-  // We listen for several possible response event names.
-  // OpenClaw's exact event depends on version — DEBUG=1 logs all events.
+  if (process.env.DEBUG) {
+    log("·", `[DEBUG] Gateway event: ${eventName}`, c.dim);
+    if (process.env.DEBUG === "2") {
+      console.log("        payload:", JSON.stringify(msg.payload, null, 2));
+    }
+  }
+
   const responseEvents = [
-    "agent.response",
-    "message.sent",
-    "turn.complete",
-    "reply.sent",
-    "assistant.message",
-    "output.complete",
+    "agent.response", "message.sent", "turn.complete",
+    "reply.sent", "assistant.message", "output.complete",
   ];
 
   if (responseEvents.some((e) => eventName.includes(e))) {
@@ -246,18 +315,14 @@ function handleOpenClawEvent(msg) {
       JSON.stringify(msg.payload);
 
     if (content) {
-      log("📨", `Agent responded: "${String(content).substring(0, 80)}..."`, c.cyan);
+      const preview = String(content);
+      log("←", `Agent: "${preview.length > 80 ? preview.substring(0, 80) + "…" : preview}"`, c.cyan);
       forwardResponseToPlayClaw(String(content));
     }
-  } else if (process.env.DEBUG) {
-    log("🔍", `[DEBUG] OpenClaw event: ${eventName}`, c.dim);
-    if (process.env.DEBUG === "2") {
-      console.log("        payload:", JSON.stringify(msg.payload, null, 2));
-    }
   }
 }
 
-// ─── Send message to OpenClaw ─────────────────────────────────────────────────
+// ─── Send message to OpenClaw ──────────────────────────────────────────────────
 
 function sendToOpenClaw(content, sessionId) {
   if (!openclawReady) {
@@ -265,8 +330,6 @@ function sendToOpenClaw(content, sessionId) {
     return;
   }
 
-  // POST to /hooks/agent — OpenClaw's async webhook endpoint (returns 202)
-  // The agent processes it and emits an event back on the WebSocket.
   const body = JSON.stringify({
     message:        content,
     agentId:        "hooks",
@@ -291,65 +354,74 @@ function sendToOpenClaw(content, sessionId) {
     },
     (res) => {
       if (res.statusCode === 202) {
-        log("📤", `Message sent to agent (session: ${sessionId || "default"})`, c.magenta);
+        log("→", `Forwarded to agent  ${c.gray}(session: ${sessionId || "default"})${c.reset}`, c.reset);
       } else if (res.statusCode === 401) {
-        log("❌", "OpenClaw auth failed — check your gateway token", c.red);
+        log("✗", "Gateway rejected — check your token", c.red);
       } else {
-        log("⚠️ ", `Unexpected status from OpenClaw: ${res.statusCode}`, c.yellow);
+        log("⚠", `Unexpected gateway response: ${res.statusCode}`, c.yellow);
       }
     }
   );
 
   req.on("error", (err) => {
-    log("❌", `Failed to reach OpenClaw: ${err.message}`, c.red);
-    forwardErrorToPlayClaw("Could not reach OpenClaw gateway. Is it running?");
+    log("✗", `Could not reach gateway: ${err.message}`, c.red);
+    forwardErrorToPlayClaw("Agent gateway unreachable. Is OpenClaw running?");
   });
 
   req.write(body);
   req.end();
 }
 
-// ─── PlayClaw Bridge via Supabase Realtime ────────────────────────────────────
+// ─── PlayClaw Bridge ───────────────────────────────────────────────────────────
 
 function connectToBridge() {
-  // Channel name = PC token → acts as a shared secret between CLI and playground
-  bridgeChannel = supabase.channel(`bridge:${playclawToken}`, {
+  if (!bridgeConnected) {
+    spinner.start("Opening PlayClaw bridge...");
+  }
+
+  bridgeChannel = cloud.channel(`bridge:${playclawToken}`, {
     config: {
-      broadcast: { ack: false },   // fire-and-forget is fine for low-latency relay
-      presence:  { key: "cli" },   // track CLI presence so playground knows we're live
+      broadcast: { ack: false },
+      presence:  { key: "cli" },
     },
   });
 
   bridgeChannel
-    // Listen for messages from the playground
     .on("broadcast", { event: "playground:message" }, ({ payload }) => {
-      log("💬", `From playground: "${payload.content?.substring(0, 60)}"`, c.cyan);
+      const preview = payload.content || "";
+      log("↓", `Playground: "${preview.length > 60 ? preview.substring(0, 60) + "…" : preview}"`, c.magenta);
       sendToOpenClaw(payload.content, payload.session_id);
     })
     .subscribe(async (status) => {
       if (status === "SUBSCRIBED") {
-        // Signal that the CLI is online (playground reads this via presence)
         await bridgeChannel.track({
           online_at: new Date().toISOString(),
           token:     playclawToken,
         });
 
-        log("✅", "PlayClaw Bridge connected (Supabase Realtime)", c.green);
-        log("🎮", "Agent is ready to be tested!", c.bold);
-        log("   ", "Open https://playclaw.info/playground to start.", c.dim);
-        console.log("");
+        if (!bridgeConnected) {
+          bridgeConnected = true;
+          spinner.success("PlayClaw bridge established");
+          printReady();
+        } else {
+          log("✓", "Bridge reconnected", c.green);
+        }
 
       } else if (status === "CHANNEL_ERROR") {
-        log("❌", "Bridge connection failed. Check your PC token.", c.red);
+        if (!bridgeConnected) {
+          spinner.fail("Bridge failed — check your PC token at playclaw.info/connect");
+        } else {
+          log("✗", "Bridge error — check your PC token", c.red);
+        }
 
       } else if (status === "TIMED_OUT") {
-        log("⚠️ ", "Bridge timed out. Reconnecting in 5s...", c.yellow);
-        supabase.removeChannel(bridgeChannel);
+        log("⟳", "Bridge timed out — reconnecting in 5s...", c.gray);
+        cloud.removeChannel(bridgeChannel);
         bridgeChannel = null;
         setTimeout(connectToBridge, 5000);
 
       } else if (status === "CLOSED") {
-        log("⚠️ ", "Bridge disconnected. Reconnecting in 5s...", c.yellow);
+        log("⟳", "Bridge closed — reconnecting in 5s...", c.gray);
         bridgeChannel = null;
         setTimeout(connectToBridge, 5000);
       }
@@ -358,7 +430,7 @@ function connectToBridge() {
 
 function forwardResponseToPlayClaw(content, sessionId) {
   if (!bridgeChannel) {
-    log("⚠️ ", "Bridge not ready — response dropped", c.yellow);
+    log("⚠", "Bridge not ready — response dropped", c.yellow);
     return;
   }
   bridgeChannel.send({
@@ -377,52 +449,74 @@ function forwardErrorToPlayClaw(message) {
   });
 }
 
-// ─── Startup banner ───────────────────────────────────────────────────────────
+// ─── Startup banner ────────────────────────────────────────────────────────────
 
 function printBanner() {
+  const g = c.gray, r = c.reset, b = c.bold, m = c.magenta, d = c.dim, cy = c.cyan;
+
+  // OSC 8 hyperlink — clickable in Windows Terminal, iTerm2, GNOME Terminal, etc.
+  const twitterLink = `\x1b]8;;https://x.com/uxKero\x1b\\${b}@KeroClow${r}\x1b]8;;\x1b\\`;
+
   console.log("");
-  console.log(`${c.bold}${c.magenta}   🦞 PlayClaw Bridge${c.reset}`);
-  console.log(`${c.dim}   https://playclaw.info${c.reset}`);
+  console.log(`  🦞  ${b}${m}P L A Y C L A W${r}`);
+  console.log(`  ${d}Agent Testing Playground  ·  playclaw.info${r}`);
+  console.log(`  ${d}by ${r}${twitterLink}${g}  ·  ${d}x.com/uxKero${r}`);
+  console.log(`  ${g}${"─".repeat(43)}${r}`);
   console.log("");
-  console.log(`${c.dim}   PC Token:${c.reset}  ${playclawToken}`);
-  console.log(`${c.dim}   Gateway:${c.reset}   localhost:${OPENCLAW_PORT}`);
-  console.log(`${c.dim}   Relay:${c.reset}     Supabase Realtime`);
+  console.log(`  ${g}Token  ${r}  ${b}${playclawToken}${r}`);
+  console.log(`  ${g}Gateway${r}  localhost:${OPENCLAW_PORT}`);
+}
+
+// ─── Ready message ─────────────────────────────────────────────────────────────
+
+function printReady() {
+  const line = `  ${c.gray}${"─".repeat(43)}${c.reset}`;
+  console.log("");
+  console.log(line);
+  console.log(`  🎮  ${c.bold}Your agent is live and ready!${c.reset}`);
+  console.log(`  ${c.gray}     playclaw.info/playground${c.reset}`);
+  console.log(line);
   console.log("");
 }
 
+// ─── Help ──────────────────────────────────────────────────────────────────────
+
 function printHelp() {
   console.log("");
-  console.log("  Usage: npx playclaw <PC-TOKEN> [options]");
+  console.log("  🦞  PlayClaw  —  Agent Testing Playground");
+  console.log("  playclaw.info  ·  by @KeroClow");
+  console.log("");
+  console.log("  Usage:");
+  console.log("    npx playclaw <PC-TOKEN> [options]");
   console.log("");
   console.log("  Arguments:");
-  console.log("    PC-TOKEN       Your PlayClaw connection token (from playclaw.info/connect)");
+  console.log("    PC-TOKEN         Your PlayClaw token (from playclaw.info/connect)");
   console.log("");
   console.log("  Options:");
   console.log("    --gateway-token, -g <token>   OpenClaw gateway bearer token");
-  console.log("    --port, -p <port>              OpenClaw gateway port (default: 18789)");
+  console.log("    --port, -p <port>              Gateway port (default: 18789)");
   console.log("    --help, -h                     Show this help");
   console.log("");
   console.log("  Examples:");
   console.log("    npx playclaw PC-XXXX-XXXX-XXXX");
-  console.log("    npx playclaw PC-XXXX-XXXX-XXXX --gateway-token my-secret-token");
+  console.log("    npx playclaw PC-XXXX-XXXX-XXXX --gateway-token my-token");
   console.log("    OPENCLAW_GATEWAY_TOKEN=mytoken npx playclaw PC-XXXX-XXXX-XXXX");
   console.log("");
   console.log("  Auto-detection:");
-  console.log("    The gateway token is auto-read from ~/.openclaw/openclaw.json");
-  console.log("    if not provided. Run `openclaw config get gateway.auth.token`");
-  console.log("    to find yours.");
+  console.log("    Gateway token is auto-read from ~/.openclaw/openclaw.json");
+  console.log("    Run `openclaw config get gateway.auth.token` to find yours.");
   console.log("");
 }
 
-// ─── Graceful shutdown ────────────────────────────────────────────────────────
+// ─── Graceful shutdown ─────────────────────────────────────────────────────────
 
 async function shutdown() {
   console.log("");
-  log("👋", "Shutting down PlayClaw bridge...", c.dim);
+  log("·", "Shutting down...", c.gray);
 
   if (bridgeChannel) {
     await bridgeChannel.untrack().catch(() => {});
-    await supabase.removeChannel(bridgeChannel).catch(() => {});
+    await cloud.removeChannel(bridgeChannel).catch(() => {});
   }
 
   openclawWs?.close();
@@ -432,7 +526,7 @@ async function shutdown() {
 process.on("SIGINT",  shutdown);
 process.on("SIGTERM", shutdown);
 
-// ─── Main ─────────────────────────────────────────────────────────────────────
+// ─── Main ──────────────────────────────────────────────────────────────────────
 
 printBanner();
 connectToOpenClaw();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playclaw",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Connect your OpenClaw agent to PlayClaw — the professional testing playground",
   "main": "index.js",
   "bin": {