botschat 0.1.10 → 0.1.13

package/scripts/dev.sh

@@ -1,24 +1,44 @@
 #!/usr/bin/env bash
 # BotsChat local dev startup script
 # Usage:
-#   ./scripts/dev.sh          — build web + migrate + start server
-#   ./scripts/dev.sh reset    — nuke local DB, re-migrate, then start
+#   ./scripts/dev.sh          — full dev env: build + migrate + server + mock AI + open browser
+#   ./scripts/dev.sh reset    — nuke local DB, re-migrate, then start full dev env
+#   ./scripts/dev.sh server   — only start wrangler dev server (no mock, no browser)
 #   ./scripts/dev.sh migrate  — only run D1 migrations (no server)
 #   ./scripts/dev.sh build    — only build web frontend (no server)
 #   ./scripts/dev.sh sync     — sync plugin to mini.local + rebuild + restart gateway
 #   ./scripts/dev.sh logs     — tail gateway logs on mini.local
+#   ./scripts/dev.sh mock     — start mock OpenClaw standalone (foreground)
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
 ROOT="$(pwd)"
 
+# ── Auto-set DEV_AUTH_SECRET ──────────────────────────────────────────
+# For local dev, any string works. Use a fixed default so new developers
+# can run `./scripts/dev.sh` without setting env vars first.
+if [[ -z "${DEV_AUTH_SECRET:-}" ]]; then
+  DEV_AUTH_SECRET="botschat-local-dev-secret"
+  export DEV_AUTH_SECRET
+fi
+
 # ── Colours ──────────────────────────────────────────────────────────
-RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[0;33m'; CYAN='\033[0;36m'; NC='\033[0m'
+RED='\033[0;31m'; GREEN='\033[0;32m'; YELLOW='\033[0;33m'; CYAN='\033[0;36m'; DIM='\033[2m'; NC='\033[0m'
 info()  { echo -e "${CYAN}▸${NC} $*"; }
 ok()    { echo -e "${GREEN}✔${NC} $*"; }
 warn()  { echo -e "${YELLOW}▲${NC} $*"; }
 fail()  { echo -e "${RED}✖${NC} $*"; exit 1; }
 
+# ── Process tracking ─────────────────────────────────────────────────
+WRANGLER_PID=""
+MOCK_PID=""
+
+cleanup() {
+  [[ -n "$MOCK_PID" ]] && kill "$MOCK_PID" 2>/dev/null || true
+  [[ -n "$WRANGLER_PID" ]] && kill "$WRANGLER_PID" 2>/dev/null || true
+  wait 2>/dev/null || true
+}
+
 # ── Helpers ──────────────────────────────────────────────────────────
 
 kill_port() {
@@ -32,6 +52,55 @@ kill_port() {
   fi
 }
 
+wait_for_server() {
+  info "Waiting for server…"
+  local max=60 i=0
+  while ! curl -sf --max-time 1 -o /dev/null http://localhost:8787/ 2>/dev/null; do
+    sleep 1
+    i=$((i + 1))
+    if [[ $i -ge $max ]]; then
+      fail "Server didn't start within ${max}s"
+    fi
+  done
+}
+
+get_mock_token() {
+  local BASE_URL="http://localhost:8787"
+  local TOKEN_JSON AUTH_TOKEN PAT_JSON PAT
+
+  TOKEN_JSON=$(curl -sf -X POST "$BASE_URL/api/dev-auth/login" \
+    -H 'Content-Type: application/json' \
+    -d "{\"secret\":\"$DEV_AUTH_SECRET\",\"userId\":\"dev-test-user\"}" 2>&1) || {
+    fail "Cannot reach $BASE_URL — is the server running?"
+  }
+  AUTH_TOKEN=$(echo "$TOKEN_JSON" | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])" 2>/dev/null) || {
+    fail "Failed to parse auth token: $TOKEN_JSON"
+  }
+
+  PAT_JSON=$(curl -sf -X POST "$BASE_URL/api/pairing-tokens" \
+    -H "Authorization: Bearer $AUTH_TOKEN" \
+    -H 'Content-Type: application/json' \
+    -d '{"label":"mock-openclaw"}' 2>&1) || {
+    fail "Failed to create pairing token"
+  }
+  PAT=$(echo "$PAT_JSON" | python3 -c "import sys,json; print(json.load(sys.stdin)['token'])" 2>/dev/null) || {
+    fail "Failed to parse pairing token: $PAT_JSON"
+  }
+
+  echo "$PAT"
+}
+
+open_browser() {
+  local url="http://localhost:8787/?dev_token=${DEV_AUTH_SECRET}"
+  if command -v open &>/dev/null; then
+    open "$url"
+  elif command -v xdg-open &>/dev/null; then
+    xdg-open "$url"
+  else
+    warn "Open in browser: $url"
+  fi
+}
+
 do_migrate() {
   info "Applying D1 migrations (local)…"
   npx wrangler d1 migrations apply botschat-db --local
@@ -51,44 +120,98 @@ do_build_web() {
   ok "Web build complete (packages/web/dist)"
 }
 
+# ── Server-only start (foreground, no mock/browser) ──────────────────
+
 do_start() {
   kill_port 8787
   info "Starting wrangler dev on 0.0.0.0:8787…"
-  exec npx wrangler dev --config wrangler.toml --ip 0.0.0.0 --var ENVIRONMENT:development
+  exec npx wrangler dev --config wrangler.toml --ip 0.0.0.0 --var ENVIRONMENT:development --var DEV_AUTH_SECRET:"$DEV_AUTH_SECRET"
+}
+
+# ── Full dev environment (server + mock + browser) ───────────────────
+
+do_start_full() {
+  kill_port 8787
+  trap cleanup EXIT INT TERM
+
+  info "Starting wrangler dev on 0.0.0.0:8787…"
+  npx wrangler dev --config wrangler.toml --ip 0.0.0.0 \
+    --var ENVIRONMENT:development \
+    --var DEV_AUTH_SECRET:"$DEV_AUTH_SECRET" &
+  WRANGLER_PID=$!
+
+  wait_for_server
+  ok "Server ready on http://localhost:8787"
+
+  info "Starting Mock OpenClaw…"
+  local PAT
+  PAT=$(get_mock_token)
+  mkdir -p "$ROOT/.wrangler"
+  node "$ROOT/scripts/mock-openclaw.mjs" --token "$PAT" > "$ROOT/.wrangler/mock-openclaw.log" 2>&1 &
+  MOCK_PID=$!
+  ok "Mock OpenClaw connected (pid=$MOCK_PID)"
+
+  open_browser
+
+  echo ""
+  echo -e "${CYAN}╭──────────────────────────────────────────────────╮${NC}"
+  echo -e "${CYAN}│${NC}  ${GREEN}BotsChat Dev Environment Ready${NC}                  ${CYAN}│${NC}"
+  echo -e "${CYAN}│${NC}                                                  ${CYAN}│${NC}"
+  echo -e "${CYAN}│${NC}  Server:   http://localhost:8787                 ${CYAN}│${NC}"
+  echo -e "${CYAN}│${NC}  Mock AI:  running ${DIM}(log: .wrangler/mock-openclaw.log)${NC}"
+  echo -e "${CYAN}│${NC}  Auth:     auto-login enabled                   ${CYAN}│${NC}"
+  echo -e "${CYAN}│${NC}                                                  ${CYAN}│${NC}"
+  echo -e "${CYAN}│${NC}  Press ${YELLOW}Ctrl+C${NC} to stop all services              ${CYAN}│${NC}"
+  echo -e "${CYAN}╰──────────────────────────────────────────────────╯${NC}"
+  echo ""
+
+  wait $WRANGLER_PID 2>/dev/null || true
+}
+
+# ── Standalone mock (foreground) ─────────────────────────────────────
+
+do_mock() {
+  info "Getting auth token via dev-auth…"
+  local PAT
+  PAT=$(get_mock_token)
+  ok "Pairing token: ${PAT:0:16}***"
+  info "Starting Mock OpenClaw…"
+  exec node "$ROOT/scripts/mock-openclaw.mjs" --token "$PAT" "$@"
 }
 
+# ── Sync plugin to mini.local ────────────────────────────────────────
+
 do_sync_plugin() {
-  local REMOTE_USER="mini.local"
-  local REMOTE_DIR="~/Projects/botsChat/packages/plugin"
+  local REMOTE="mini.local"
+  local DEV_DIR="~/Projects/botschat-app/botsChat/packages/plugin"
+  local EXT_DIR="~/.openclaw/extensions/botschat"
 
-  info "Syncing plugin to mini.local…"
+  info "Syncing plugin source to mini.local dev repo…"
   rsync -avz --exclude node_modules --exclude .git --exclude dist --exclude .wrangler \
-    packages/plugin/ "$REMOTE_USER:$REMOTE_DIR/"
-  ok "Plugin files synced"
+    packages/plugin/ "$REMOTE:$DEV_DIR/"
+  ok "Plugin source synced → $DEV_DIR"
 
-  info "Building plugin, deploying to extensions, restarting gateway on mini.local…"
-  ssh "$REMOTE_USER" 'export PATH="/opt/homebrew/bin:$PATH"
-cd ~/Projects/botsChat/packages/plugin
+  info "Building plugin in dev repo, deploying to extensions, restarting gateway…"
+  ssh "$REMOTE" "export PATH=\"/opt/homebrew/bin:\$PATH\"
+cd $DEV_DIR
 npm run build
-EXT_DIR=~/.openclaw/extensions/botschat
-rsync -av --delete dist/ "$EXT_DIR/dist/"
-rsync -av bin/ "$EXT_DIR/bin/" 2>/dev/null || true
-cp -f package.json openclaw.plugin.json "$EXT_DIR/" 2>/dev/null || true
-echo "--- Deployed to $EXT_DIR ---"
-pkill -9 -f openclaw-gateway 2>/dev/null || true
-sleep 3
-nohup openclaw gateway run --bind loopback --port 18789 --force > /tmp/openclaw-gateway.log 2>&1 &
-echo "Gateway restarted (PID=$!)"'
-  ok "Plugin synced, deployed to extensions, gateway restarted"
+echo '--- Deploying built artifacts to $EXT_DIR ---'
+rsync -av --delete dist/ $EXT_DIR/dist/
+rsync -av bin/ $EXT_DIR/bin/ 2>/dev/null || true
+cp -f package.json openclaw.plugin.json $EXT_DIR/ 2>/dev/null || true
+echo '--- Restarting gateway via launchctl ---'
+launchctl kickstart -k gui/\$(id -u)/ai.openclaw.gateway
+echo 'Gateway restarted'"
+  ok "Plugin deployed to extensions, gateway restarted"
 
   sleep 4
   info "Checking connection…"
-  ssh "$REMOTE_USER" 'tail -5 /tmp/openclaw-gateway.log | grep -i "authenticated\|error\|Task scan"'
+  ssh "$REMOTE" 'tail -10 ~/.openclaw/logs/gateway.log | grep -i "authenticated\|error\|Task scan\|botschat"'
 }
 
 do_logs() {
   info "Tailing gateway logs on mini.local…"
-  ssh mini.local 'tail -f /tmp/openclaw-gateway.log'
+  ssh mini.local 'tail -f ~/.openclaw/logs/gateway.log'
 }
 
 # ── Main ─────────────────────────────────────────────────────────────
@@ -99,6 +222,11 @@ case "$cmd" in
   reset)
     do_reset
     do_build_web
+    do_start_full
+    ;;
+  server)
+    do_build_web
+    do_migrate
     do_start
     ;;
   migrate)
@@ -113,10 +241,14 @@ case "$cmd" in
   logs)
     do_logs
     ;;
+  mock)
+    shift
+    do_mock "$@"
+    ;;
   *)
-    # Default: build + migrate + start
+    # Default: full dev experience — build + migrate + server + mock + browser
     do_build_web
     do_migrate
-    do_start
+    do_start_full
     ;;
 esac

package/scripts/mock-openclaw.mjs

@@ -0,0 +1,382 @@
+#!/usr/bin/env node
+/**
+ * Mock OpenClaw — a lightweight WebSocket client that simulates an OpenClaw
+ * plugin for local BotsChat development. No OpenClaw dependency required.
+ *
+ * Usage:
+ *   node scripts/mock-openclaw.mjs --token bc_pat_xxx
+ *   node scripts/mock-openclaw.mjs --token bc_pat_xxx --delay 500 --stream
+ *
+ * Options:
+ *   --token <pat>      Pairing token (required)
+ *   --url <url>        Server URL (default: http://localhost:8787)
+ *   --agents <list>    Comma-separated agent IDs (default: main)
+ *   --delay <ms>       Reply delay in ms (default: 300)
+ *   --stream           Enable streaming replies (chunk by chunk)
+ *   --model <name>     Default model name (default: mock/echo-1.0)
+ */
+
+import { randomUUID } from "node:crypto";
+import { parseArgs } from "node:util";
+
+// ── CLI args ─────────────────────────────────────────────────────────
+
+const { values: args } = parseArgs({
+  options: {
+    token:  { type: "string" },
+    url:    { type: "string", default: "http://localhost:8787" },
+    agents: { type: "string", default: "main" },
+    delay:  { type: "string", default: "300" },
+    stream: { type: "boolean", default: false },
+    model:  { type: "string", default: "mock/echo-1.0" },
+    help:   { type: "boolean", short: "h", default: false },
+  },
+  strict: true,
+});
+
+if (args.help || !args.token) {
+  console.log(`Mock OpenClaw — simulate an OpenClaw plugin for local testing
+
+Usage:
+  node scripts/mock-openclaw.mjs --token <pairing-token> [options]
+
+Options:
+  --token <pat>      Pairing token (required)
+  --url <url>        Server URL (default: http://localhost:8787)
+  --agents <list>    Comma-separated agent IDs (default: main)
+  --delay <ms>       Reply delay in ms (default: 300)
+  --stream           Enable streaming replies
+  --model <name>     Default model name (default: mock/echo-1.0)
+  -h, --help         Show this help`);
+  process.exit(args.help ? 0 : 1);
+}
+
+const TOKEN      = args.token;
+const SERVER_URL = args.url;
+const AGENTS     = args.agents.split(",").map((s) => s.trim());
+const DELAY_MS   = parseInt(args.delay, 10);
+const STREAMING  = args.stream;
+const MODEL      = args.model;
+
+// ── Colours ──────────────────────────────────────────────────────────
+
+const c = {
+  reset: "\x1b[0m",
+  dim:   "\x1b[2m",
+  cyan:  "\x1b[36m",
+  green: "\x1b[32m",
+  yellow:"\x1b[33m",
+  red:   "\x1b[31m",
+  magenta:"\x1b[35m",
+};
+
+function log(icon, msg) {
+  const ts = new Date().toISOString().slice(11, 23);
+  console.log(`${c.dim}${ts}${c.reset} ${icon} ${msg}`);
+}
+const logInfo  = (msg) => log(`${c.cyan}▸${c.reset}`, msg);
+const logOk    = (msg) => log(`${c.green}✔${c.reset}`, msg);
+const logWarn  = (msg) => log(`${c.yellow}▲${c.reset}`, msg);
+const logErr   = (msg) => log(`${c.red}✖${c.reset}`, msg);
+const logRecv  = (msg) => log(`${c.magenta}◂${c.reset}`, msg);
+const logSend  = (msg) => log(`${c.cyan}▸${c.reset}`, msg);
+
+// ── Mock models ──────────────────────────────────────────────────────
+
+const MOCK_MODELS = [
+  { id: "mock/echo-1.0",       name: "Echo 1.0",       provider: "mock" },
+  { id: "mock/echo-streaming",  name: "Echo Streaming",  provider: "mock" },
+  { id: "anthropic/claude-sonnet-4-20250514", name: "Claude Sonnet 4", provider: "anthropic" },
+  { id: "openai/gpt-4o",       name: "GPT-4o",          provider: "openai" },
+];
+
+// ── WebSocket connection ─────────────────────────────────────────────
+
+const MIN_BACKOFF = 1_000;
+const MAX_BACKOFF = 30_000;
+let backoff = MIN_BACKOFF;
+let ws = null;
+let pingTimer = null;
+let intentionalClose = false;
+let userId = null;
+
+function buildWsUrl() {
+  let host = SERVER_URL.replace(/^https?:\/\//, "");
+  const isPlainHttp = SERVER_URL.startsWith("http://");
+  const scheme = isPlainHttp ? "ws" : "wss";
+  return `${scheme}://${host}/api/gateway/mock?token=${encodeURIComponent(TOKEN)}`;
+}
+
+function connect() {
+  const url = buildWsUrl();
+  logInfo(`Connecting to ${url.replace(/token=.*/, "token=***")}`);
+
+  ws = new WebSocket(url);
+
+  ws.addEventListener("open", () => {
+    logInfo("Connected, sending auth…");
+    send({ type: "auth", token: TOKEN, agents: AGENTS, model: MODEL });
+  });
+
+  ws.addEventListener("message", (event) => {
+    const data = typeof event.data === "string" ? event.data : event.data.toString();
+    let msg;
+    try {
+      msg = JSON.parse(data);
+    } catch {
+      logErr(`Bad JSON: ${data.slice(0, 100)}`);
+      return;
+    }
+    handleMessage(msg);
+  });
+
+  ws.addEventListener("close", (event) => {
+    logWarn(`Disconnected: code=${event.code} reason=${event.reason || "?"}`);
+    stopPing();
+    if (!intentionalClose) scheduleReconnect();
+  });
+
+  ws.addEventListener("error", (event) => {
+    logErr(`WebSocket error: ${event.message || "unknown"}`);
+  });
+}
+
+function send(msg) {
+  if (!ws || ws.readyState !== WebSocket.OPEN) return;
+  ws.send(JSON.stringify(msg));
+}
+
+function scheduleReconnect() {
+  logInfo(`Reconnecting in ${backoff}ms…`);
+  setTimeout(() => {
+    backoff = Math.min(backoff * 2, MAX_BACKOFF);
+    connect();
+  }, backoff);
+}
+
+function startPing() {
+  stopPing();
+  pingTimer = setInterval(() => {
+    send({ type: "status", connected: true, agents: AGENTS, model: MODEL });
+  }, 25_000);
+}
+
+function stopPing() {
+  if (pingTimer) { clearInterval(pingTimer); pingTimer = null; }
+}
+
+// ── Message handlers ─────────────────────────────────────────────────
+
+function handleMessage(msg) {
+  switch (msg.type) {
+    case "auth.ok":
+      userId = msg.userId;
+      backoff = MIN_BACKOFF;
+      logOk(`Authenticated (userId=${userId})`);
+      startPing();
+      break;
+
+    case "auth.fail":
+      logErr(`Auth failed: ${msg.reason}`);
+      intentionalClose = true;
+      ws?.close(4001, "auth failed");
+      break;
+
+    case "ping":
+      send({ type: "pong" });
+      break;
+
+    case "user.message":
+      logRecv(`[user.message] sessionKey=${msg.sessionKey} text="${truncate(msg.text, 80)}"`);
+      handleUserMessage(msg);
+      break;
+
+    case "user.media":
+      logRecv(`[user.media] sessionKey=${msg.sessionKey} url=${msg.mediaUrl}`);
+      setTimeout(() => {
+        send({
+          type: "agent.text",
+          sessionKey: msg.sessionKey,
+          text: `📎 Received media: ${msg.mediaUrl}`,
+          messageId: randomUUID(),
+        });
+        logSend("[agent.text] media acknowledgement");
+      }, DELAY_MS);
+      break;
+
+    case "user.command":
+      logRecv(`[user.command] command=${msg.command} args=${msg.args || ""}`);
+      setTimeout(() => {
+        send({
+          type: "agent.text",
+          sessionKey: msg.sessionKey,
+          text: `Command received: /${msg.command} ${msg.args || ""}`.trim(),
+          messageId: randomUUID(),
+        });
+      }, DELAY_MS);
+      break;
+
+    case "user.action":
+      logRecv(`[user.action] action=${msg.action} params=${JSON.stringify(msg.params)}`);
+      setTimeout(() => {
+        send({
+          type: "agent.text",
+          sessionKey: msg.sessionKey,
+          text: `Action received: ${msg.action}`,
+          messageId: randomUUID(),
+        });
+      }, DELAY_MS);
+      break;
+
+    case "task.scan.request":
+      logRecv("[task.scan.request]");
+      send({ type: "task.scan.result", tasks: [] });
+      logSend("[task.scan.result] empty tasks");
+      break;
+
+    case "models.request":
+      logRecv("[models.request]");
+      send({ type: "models.list", models: MOCK_MODELS });
+      logSend(`[models.list] ${MOCK_MODELS.length} models`);
+      break;
+
+    case "task.schedule":
+      logRecv(`[task.schedule] cronJobId=${msg.cronJobId} schedule=${msg.schedule}`);
+      send({
+        type: "task.schedule.ack",
+        cronJobId: msg.cronJobId || `mock_cron_${Date.now()}`,
+        taskId: msg.taskId,
+        ok: true,
+      });
+      logSend("[task.schedule.ack] ok");
+      break;
+
+    case "task.delete":
+      logRecv(`[task.delete] cronJobId=${msg.cronJobId}`);
+      break;
+
+    case "task.run":
+      logRecv(`[task.run] cronJobId=${msg.cronJobId}`);
+      handleTaskRun(msg);
+      break;
+
+    case "settings.defaultModel":
+      logRecv(`[settings.defaultModel] model=${msg.defaultModel}`);
+      send({ type: "defaultModel.updated", model: msg.defaultModel });
+      logSend(`[defaultModel.updated] ${msg.defaultModel}`);
+      break;
+
+    default:
+      logWarn(`Unhandled message type: ${msg.type}`);
+  }
+}
+
+// ── User message reply ───────────────────────────────────────────────
+
+async function handleUserMessage(msg) {
+  const replyText = `Mock reply: ${msg.text}`;
+
+  await sleep(DELAY_MS);
+
+  if (STREAMING) {
+    const runId = randomUUID();
+    send({ type: "agent.stream.start", sessionKey: msg.sessionKey, runId });
+
+    const words = replyText.split(" ");
+    for (let i = 0; i < words.length; i++) {
+      await sleep(50);
+      const chunk = (i === 0 ? "" : " ") + words[i];
+      send({ type: "agent.stream.chunk", sessionKey: msg.sessionKey, runId, text: chunk });
+    }
+
+    send({ type: "agent.stream.end", sessionKey: msg.sessionKey, runId });
+    logSend(`[agent.stream] ${words.length} chunks`);
+
+    send({
+      type: "agent.text",
+      sessionKey: msg.sessionKey,
+      text: replyText,
+      messageId: randomUUID(),
+    });
+  } else {
+    send({
+      type: "agent.text",
+      sessionKey: msg.sessionKey,
+      text: replyText,
+      messageId: randomUUID(),
+    });
+    logSend(`[agent.text] "${truncate(replyText, 60)}"`);
+  }
+}
+
+// ── Task run simulation ──────────────────────────────────────────────
+
+async function handleTaskRun(msg) {
+  const jobId = `mock_job_${Date.now()}`;
+  const sessionKey = `agent:${msg.agentId || "main"}:botschat:${userId}:task:mock`;
+  const startedAt = Math.floor(Date.now() / 1000);
+
+  send({
+    type: "job.update",
+    cronJobId: msg.cronJobId,
+    jobId,
+    sessionKey,
+    status: "running",
+    startedAt,
+  });
+  logSend(`[job.update] running jobId=${jobId}`);
+
+  send({ type: "job.output", cronJobId: msg.cronJobId, jobId, text: "Mock job started…\n" });
+  await sleep(1000);
+  send({ type: "job.output", cronJobId: msg.cronJobId, jobId, text: "Mock job processing…\n" });
+  await sleep(1000);
+  send({ type: "job.output", cronJobId: msg.cronJobId, jobId, text: "Mock job complete.\n" });
+
+  const finishedAt = Math.floor(Date.now() / 1000);
+  send({
+    type: "job.update",
+    cronJobId: msg.cronJobId,
+    jobId,
+    sessionKey,
+    status: "ok",
+    summary: "Mock task executed successfully",
+    startedAt,
+    finishedAt,
+    durationMs: (finishedAt - startedAt) * 1000,
+  });
+  logSend(`[job.update] ok (${finishedAt - startedAt}s)`);
+}
+
+// ── Utilities ────────────────────────────────────────────────────────
+
+function sleep(ms) { return new Promise((r) => setTimeout(r, ms)); }
+function truncate(s, n) { return s && s.length > n ? s.slice(0, n) + "…" : s; }
+
+// ── Graceful shutdown ────────────────────────────────────────────────
+
+function shutdown() {
+  logInfo("Shutting down…");
+  intentionalClose = true;
+  stopPing();
+  ws?.close(1000, "shutdown");
+  process.exit(0);
+}
+process.on("SIGINT", shutdown);
+process.on("SIGTERM", shutdown);
+
+// ── Start ────────────────────────────────────────────────────────────
+
+console.log(`
+${c.cyan}╭──────────────────────────────────────╮
+│        Mock OpenClaw v1.0            │
+│   Local testing without deployment   │
+╰──────────────────────────────────────╯${c.reset}
+  Server:    ${SERVER_URL}
+  Token:     ${TOKEN.slice(0, 12)}***
+  Agents:    ${AGENTS.join(", ")}
+  Model:     ${MODEL}
+  Delay:     ${DELAY_MS}ms
+  Streaming: ${STREAMING}
+`);
+
+connect();

package/scripts/test-e2e-chat.ts

@@ -1,14 +1,14 @@
 import WebSocket from "ws";
 import { deriveKey, encryptText, decryptText, toBase64, fromBase64 } from "../packages/e2e-crypto/e2e-crypto.js";
 
-const E2E_PWD = "botschat123";
+const E2E_PWD = process.env.TEST_E2E_PASSWORD || "";
 
 async function main() {
   // Login
   const res = await fetch("http://localhost:8787/api/auth/login", {
     method: "POST",
     headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ email: "tong@mini.local", password: "botschat123" }),
+    body: JSON.stringify({ email: "tong@mini.local", password: process.env.TEST_PASSWORD || "" }),
   });
   if (!res.ok) { console.log("Login failed:", res.status); process.exit(1); }
   const login = await res.json() as { id: string; token: string };

package/scripts/test-e2e-live.ts

@@ -21,7 +21,7 @@ import assert from "node:assert";
 const API_BASE = "http://localhost:8787";
 const E2E_PASSWORD = "e2e-test-2026";
 const TEST_EMAIL = "tong@mini.local";
-const TEST_PASS = "botschat123";
+const TEST_PASS = process.env.TEST_E2E_PASSWORD || "";
 const SECRET_TEXT = `E2E_TEST_SECRET_${Date.now()}`;
 
 async function login(): Promise<{ token: string; userId: string }> {

package/wrangler.toml

@@ -36,6 +36,9 @@ new_sqlite_classes = ["ConnectionDO"]
 ENVIRONMENT = "production"
 # Firebase project ID for Google/GitHub Sign-In token verification.
 FIREBASE_PROJECT_ID = "botschat-130ff"
+# Google OAuth Client IDs — used to verify native iOS/Android Google Sign-In tokens.
+GOOGLE_WEB_CLIENT_ID = "670756745871-1anrnjukhhu0a550j86blm771a2k3jou.apps.googleusercontent.com"
+GOOGLE_IOS_CLIENT_ID = "670756745871-ct1k370fk3h5oj3f3gdabqv1nq2b7r54.apps.googleusercontent.com"
 # IMPORTANT: For production, set JWT_SECRET via `wrangler secret put JWT_SECRET`.
 # The app will refuse to start in non-development mode without it.