@rethinkingstudio/clawpilot 2.0.0-beta.0 → 2.0.0

package/src/relay/relay-manager.ts

@@ -1,328 +0,0 @@
-import { WebSocket } from "ws";
-import { OpenClawGatewayClient } from "./gateway-client.js";
-import { handleLocalCommand } from "../commands/local-handlers.js";
-import { handleProviderCommand } from "../commands/provider-handlers.js";
-import { getServicePlatform } from "../platform/service-manager.js";
-import { uploadAssistantAttachments } from "../media/assistant-attachments.js";
-import { homedir } from "os";
-import { extname, join } from "path";
-import { mkdir, writeFile } from "fs/promises";
-import { randomUUID } from "crypto";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const OUTBOUND_DIR = join(homedir(), ".openclaw", "media", "outbound");
-
-function isSuspiciousShortReply(text: string | null | undefined): boolean {
-  const normalized = (text ?? "").replace(/\s+/g, " ").trim().toLowerCase();
-  if (!normalized) return true;
-  return normalized.length <= 4 || ["no", "ok", "nope", "n/a", "no_reply"].includes(normalized);
-}
-
-function extensionFromMimeType(mimeType: string): string {
-  const map: Record<string, string> = {
-    "image/jpeg": ".jpg",
-    "image/png": ".png",
-    "image/gif": ".gif",
-    "image/webp": ".webp",
-    "video/mp4": ".mp4",
-    "video/quicktime": ".mov",
-    "audio/mpeg": ".mp3",
-    "audio/mp4": ".m4a",
-    "audio/wav": ".wav",
-    "audio/x-wav": ".wav",
-    "audio/aac": ".aac",
-    "application/pdf": ".pdf",
-    "text/plain": ".txt",
-    "text/markdown": ".md",
-    "application/json": ".json",
-  };
-  return map[mimeType] ?? ".bin";
-}
-
-// ---------------------------------------------------------------------------
-// Messages: relay client ↔ relay server
-// ---------------------------------------------------------------------------
-
-/** Messages the relay client sends to the relay server. */
-type ToServer =
-  | { type: "relay_hello"; platform: "macos" | "linux" | "windows" | "unsupported" }
-  | { type: "gateway_connected" }
-  | { type: "gateway_disconnected"; reason: string }
-  | { type: "event"; event: string; payload: unknown }
-  | { type: "res"; id: string; ok: boolean; payload?: unknown; error?: { message?: string } };
-
-/** Messages the relay server sends to the relay client. */
-interface FromServer {
-  type: "cmd";
-  id?: string;
-  method: string;
-  params: unknown;
-}
-
-// ---------------------------------------------------------------------------
-// Options
-// ---------------------------------------------------------------------------
-
-export interface RelayManagerOptions {
-  relayServerUrl: string;
-  gatewayId: string;
-  relaySecret: string;
-  gatewayUrl: string;
-  gatewayToken?: string;
-  gatewayPassword?: string;
-  onConnected?: () => void;
-  onDisconnected?: () => void;
-}
-
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-
-/**
- * Connects to the cloud relay server and the local OpenClaw Gateway,
- * then bridges messages between them indefinitely.
- *
- * The gateway client runs for as long as this relay connection is alive.
- * Returns a Promise that resolves `true` (retry) when the relay server
- * connection closes.
- */
-export async function runRelayManager(opts: RelayManagerOptions): Promise<boolean> {
-  const wsUrl = buildRelayUrl(opts.relayServerUrl, opts.gatewayId, opts.relaySecret);
-
-  return new Promise<boolean>((resolve) => {
-    let relayWs: WebSocket;
-    try {
-      relayWs = new WebSocket(wsUrl);
-    } catch (err) {
-      console.error("Failed to create relay WebSocket:", err);
-      resolve(true);
-      return;
-    }
-
-    let gatewayClient: OpenClawGatewayClient | null = null;
-
-    function send(msg: ToServer): void {
-      if (relayWs.readyState === WebSocket.OPEN) {
-        relayWs.send(JSON.stringify(msg));
-      }
-    }
-
-    relayWs.on("open", () => {
-      console.log(`Connected to relay server (gatewayId=${opts.gatewayId})`);
-      send({ type: "relay_hello", platform: getServicePlatform() });
-      opts.onConnected?.();
-
-      // Start the persistent gateway connection as soon as we're connected
-      // to the relay server. Its lifetime is tied to this relay session.
-      gatewayClient = new OpenClawGatewayClient({
-        url: opts.gatewayUrl,
-        token: opts.gatewayToken,
-        password: opts.gatewayPassword,
-
-        onConnected: () => {
-          console.log("Gateway connected.");
-          send({ type: "gateway_connected" });
-        },
-
-        onDisconnected: (reason) => {
-          console.log(`Gateway disconnected: ${reason}`);
-          send({ type: "gateway_disconnected", reason });
-        },
-
-        onEvent: (event, payload) => {
-          // On chat final, fetch history to get actual content + extract media attachments.
-          // OpenClaw 2026.3.2+ no longer includes message content in chat final payload.
-          if (event === "chat") {
-            const p = payload as { state?: string; sessionKey?: string; runId?: string; message?: unknown };
-            if (p?.state === "final" && p?.sessionKey) {
-              const sessionKey = p.sessionKey;
-              const runId = p.runId;
-              type ContentBlock = { type: string; text?: string; source?: { type?: string; media_type?: string; data?: string; path?: string } };
-              type HistoryResponse = { messages?: Array<{ role: string; content?: ContentBlock[] }> };
-              const fetchHistory = () =>
-                gatewayClient!.request<HistoryResponse>("chat.history", { sessionKey, limit: 10 });
-              const extractText = (h: HistoryResponse | undefined) => {
-                const msgs = h?.messages ?? [];
-                const last = [...msgs].reverse().find((m) => m.role === "assistant");
-                return last?.content?.find((b) => b.type === "text")?.text;
-              };
-              fetchHistory()
-                .then(async (history) => {
-                  let text = extractText(history);
-                  // Retry once after 600ms if OpenClaw hasn't committed the message yet
-                  if (!text) {
-                    await new Promise((resolve) => setTimeout(resolve, 600));
-                    const retryHistory = await fetchHistory();
-                    text = extractText(retryHistory);
-                    history = retryHistory;
-                  }
-                  if (text) {
-                    (p as Record<string, unknown>).message = { content: [{ type: "text", text }] };
-                  }
-                  if (isSuspiciousShortReply(text)) {
-                    console.warn(
-                      `[relay] suspicious chat final history text runId=${runId} sessionKey=${sessionKey} text=${JSON.stringify(text ?? "")}`
-                    );
-                  }
-
-                  // Upload any media blocks found in the history
-                  try {
-                    const attachments = await uploadAssistantAttachments(
-                      history ?? {},
-                      opts.relayServerUrl,
-                      opts.gatewayId,
-                      opts.relaySecret
-                    );
-                    if (attachments.length > 0) {
-                      (p as Record<string, unknown>).attachments = attachments;
-                      console.log(`[relay] chat final: injected ${attachments.length} attachment(s) runId=${runId}`);
-                    }
-                  } catch (mediaErr) {
-                    console.error(`[relay] media upload error (non-fatal): ${mediaErr}`);
-                  }
-
-                  console.log(`[relay] chat final (history fetched): runId=${runId} textLength=${text?.length ?? 0}`);
-                  send({ type: "event", event, payload });
-                })
-                .catch((err) => {
-                  console.error(`[relay] chat.history fetch failed: ${err}`);
-                  console.warn(
-                    `[relay] suspicious chat final history fetch failure runId=${runId} sessionKey=${sessionKey}`
-                  );
-                  send({ type: "event", event, payload });
-                });
-              return; // will send after history fetch + media upload
-            }
-          }
-          send({ type: "event", event, payload });
-        },
-      });
-
-      gatewayClient.start();
-    });
-
-    relayWs.on("message", async (raw) => {
-      let msg: FromServer;
-      try {
-        msg = JSON.parse(raw.toString()) as FromServer;
-      } catch {
-        return;
-      }
-
-      if (msg.type !== "cmd" || !msg.method) return;
-
-      const requestId = msg.id;
-      console.log(`[relay] cmd received method=${msg.method} id=${requestId ?? "(no-id)"}`);
-
-      // Handle clawpilot.provider.* commands locally (async)
-      const providerPromise = handleProviderCommand(msg.method, msg.params);
-      if (providerPromise !== null) {
-        const result = await providerPromise;
-        if (requestId) {
-          send({
-            type: "res",
-            id: requestId,
-            ok: result.ok,
-            ...(result.ok
-              ? { payload: result.payload }
-              : { error: { message: result.error } }),
-          });
-        }
-        return;
-      }
-
-      // Handle clawpilot.* commands locally without forwarding to the gateway
-      const localResult = handleLocalCommand(msg.method, msg.params);
-      if (localResult !== null) {
-        if (requestId) {
-          if (localResult.ok) {
-            send({ type: "res", id: requestId, ok: true, payload: localResult.payload });
-          } else {
-            send({ type: "res", id: requestId, ok: false, error: { message: localResult.error } });
-          }
-        }
-        return;
-      }
-
-      // Handle chat.send with attachments - save to disk and add path reference
-      if (msg.method === "chat.send") {
-        const params = msg.params as any;
-        // Always set deliver:false so OpenClaw responds via WebSocket (not external channel)
-        params.deliver = false;
-        if (params.attachments && params.attachments.length > 0) {
-          const fileReferences: string[] = [];
-
-          // Ensure outbound directory exists
-          await mkdir(OUTBOUND_DIR, { recursive: true });
-
-          // Save each attachment to disk and create path reference
-          for (const att of params.attachments) {
-            try {
-              // Decode base64 to buffer
-              const buffer = Buffer.from(att.content, "base64");
-              const ext = extname(att.fileName ?? "") || extensionFromMimeType(att.mimeType);
-              const stagedFileName = `${randomUUID()}${ext}`;
-              const stagedPath = join(OUTBOUND_DIR, stagedFileName);
-
-              // Write to disk
-              await writeFile(stagedPath, buffer);
-              console.log(`[relay] Saved attachment to: ${stagedPath}`);
-
-              // Create path reference (same format as ClawX)
-              fileReferences.push(
-                `[media attached: ${stagedPath} (${att.mimeType}) | ${stagedPath}]`
-              );
-            } catch (err) {
-              console.error(`[relay] Failed to save attachment: ${err}`);
-            }
-          }
-
-          // Append file references to message
-          if (fileReferences.length > 0) {
-            const refs = fileReferences.join("\n");
-            params.message = params.message ? `${params.message}\n\n${refs}` : refs;
-            console.log(`[relay] Added file references to message`);
-          }
-        }
-      }
-
-      gatewayClient
-        ?.request(msg.method, msg.params)
-        .then((result) => {
-          console.log(`[relay] cmd ok method=${msg.method} id=${requestId ?? "(no-id)"}`);
-          if (requestId) {
-            send({ type: "res", id: requestId, ok: true, payload: result });
-          }
-        })
-        .catch((err: unknown) => {
-          console.error(`[relay] cmd failed method=${msg.method} id=${requestId ?? "(no-id)"}: ${String(err)}`);
-          if (requestId) {
-            send({ type: "res", id: requestId, ok: false, error: { message: String(err) } });
-          }
-        });
-    });
-
-    relayWs.on("close", (code, reason) => {
-      console.log(`Relay connection closed: ${code} ${reason.toString()}`);
-      opts.onDisconnected?.();
-      gatewayClient?.stop();
-      gatewayClient = null;
-      // Code 4000 = server kicked us because another relay client took over.
-      // Stop retrying so the two instances don't bounce each other forever.
-      resolve(code !== 4000);
-    });
-
-    relayWs.on("error", (err) => {
-      console.error("Relay WebSocket error:", err.message);
-      // close event will follow
-    });
-  });
-}
-
-function buildRelayUrl(serverUrl: string, gatewayId: string, relaySecret: string): string {
-  const base = serverUrl.replace(/\/+$/, "").replace(/^http/, "ws");
-  return `${base}/relay/${gatewayId}?secret=${encodeURIComponent(relaySecret)}`;
-}

package/test-chat.mjs

@@ -1,64 +0,0 @@
-import { WebSocket } from "ws";
-import { randomUUID } from "crypto";
-import { readFileSync } from "fs";
-
-const token = readFileSync("/tmp/test_token.txt", "utf8").trim();
-const url = `ws://localhost:3000/gw/295c6252c69746124af48ebbe7001f11?token=${token}`;
-
-const ws = new WebSocket(url);
-
-ws.on("open", () => {
-  console.log("[ios] connected to relay server");
-
-  ws.send(JSON.stringify({ method: "sessions.reset", params: { key: "main" } }));
-  console.log("[ios] → sessions.reset { key: 'main' }");
-
-  setTimeout(() => {
-    ws.send(JSON.stringify({
-      method: "chat.send",
-      params: {
-        sessionKey: "main",
-        message: "hello, please reply with just one short sentence",
-        idempotencyKey: randomUUID(),
-      },
-    }));
-    console.log("[ios] → chat.send");
-  }, 800);
-});
-
-let lastText = "";
-ws.on("message", (raw) => {
-  const msg = JSON.parse(raw.toString());
-  if (msg.type === "connected") { console.log("[ios] ← gateway online"); return; }
-  if (msg.type === "disconnected") { console.log("[gateway] ← disconnected:", msg.reason); return; }
-  if (msg.type === "event" && msg.event === "chat") {
-    const p = msg.payload;
-    if (p.state === "delta") {
-      const text = p.message?.content?.[0]?.text ?? "";
-      if (text !== lastText) {
-        process.stdout.write("\r[delta] " + text.slice(-80).padEnd(80));
-        lastText = text;
-      }
-    } else if (p.state === "final") {
-      const text = p.message?.content?.[0]?.text ?? "(no text)";
-      console.log("\n\n[FINAL RESPONSE]\n" + text);
-      ws.close();
-      process.exit(0);
-    } else if (p.state === "error") {
-      console.log("\n[ERROR]", p.errorMessage);
-      ws.close();
-      process.exit(1);
-    }
-    return;
-  }
-  if (msg.event !== "health" && msg.event !== "presence") {
-    console.log("[event]", JSON.stringify(msg).slice(0, 120));
-  }
-});
-
-ws.on("error", (e) => console.error("[ws error]", e.message));
-setTimeout(() => {
-  console.log("\n[timeout after 60s]");
-  ws.close();
-  process.exit(1);
-}, 60000);

package/test-direct.mjs

@@ -1,171 +0,0 @@
-/**
- * Direct test: connect to OpenClaw Gateway and send chat.send
- * Uses same logic as gateway-client.ts
- */
-import { WebSocket } from "ws";
-import { randomUUID, generateKeyPairSync, createPrivateKey, sign, createPublicKey, createHash } from "node:crypto";
-import { readFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { homedir } from "node:os";
-
-const IDENTITY_PATH = join(homedir(), ".clawai", "device-identity.json");
-const ED25519_SPKI_PREFIX = Buffer.from("302a300506032b6570032100", "hex");
-
-function base64UrlEncode(buf) {
-  return buf.toString("base64").replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/g, "");
-}
-
-function rawPublicKeyBytes(publicKeyPem) {
-  const key = createPublicKey(publicKeyPem);
-  const spki = key.export({ type: "spki", format: "der" });
-  if (spki.length === ED25519_SPKI_PREFIX.length + 32 && spki.subarray(0, ED25519_SPKI_PREFIX.length).equals(ED25519_SPKI_PREFIX)) {
-    return spki.subarray(ED25519_SPKI_PREFIX.length);
-  }
-  return spki;
-}
-
-const stored = JSON.parse(readFileSync(IDENTITY_PATH, "utf8"));
-const identity = { deviceId: stored.deviceId, publicKeyPem: stored.publicKeyPem, privateKeyPem: stored.privateKeyPem };
-
-const openclawCfg = JSON.parse(readFileSync(join(homedir(), ".openclaw", "openclaw.json"), "utf8"));
-const authToken = openclawCfg?.gateway?.auth?.token;
-const port = openclawCfg?.gateway?.port ?? 18789;
-
-console.log("Device ID:", identity.deviceId);
-console.log("Auth token:", authToken ? authToken.slice(0, 8) + "..." : "(none)");
-console.log("Connecting to ws://localhost:" + port);
-
-const ws = new WebSocket("ws://localhost:" + port, { maxPayload: 25 * 1024 * 1024 });
-const pending = new Map();
-let connectNonce = null;
-let connectSent = false;
-let connected = false;
-
-function sendFrame(obj) {
-  ws.send(JSON.stringify(obj));
-}
-
-function request(method, params) {
-  const id = randomUUID();
-  return new Promise((resolve, reject) => {
-    pending.set(id, { resolve, reject });
-    sendFrame({ type: "req", id, method, params });
-    console.log(`→ req [${id.slice(0, 8)}] ${method}`);
-  });
-}
-
-function sendConnect(nonce) {
-  if (connectSent) return;
-  connectSent = true;
-  const role = "operator";
-  const scopes = ["operator.admin"];
-  const clientId = "gateway-client";
-  const clientMode = "backend";
-  const signedAtMs = Date.now();
-
-  const version = nonce ? "v2" : "v1";
-  const payload = [version, identity.deviceId, clientId, clientMode, role, scopes.join(","), String(signedAtMs), authToken ?? "", ...(nonce ? [nonce] : [])].join("|");
-  const key = createPrivateKey(identity.privateKeyPem);
-  const signature = base64UrlEncode(sign(null, Buffer.from(payload, "utf8"), key));
-  const device = {
-    id: identity.deviceId,
-    publicKey: base64UrlEncode(rawPublicKeyBytes(identity.publicKeyPem)),
-    signature,
-    signedAt: signedAtMs,
-    nonce,
-  };
-
-  const params = {
-    minProtocol: 3, maxProtocol: 3,
-    role, scopes, caps: [], commands: [],
-    client: { id: clientId, displayName: "ClawAI Direct Test", version: "1.0.0", platform: process.platform, mode: clientMode },
-    device,
-    auth: authToken ? { token: authToken } : undefined,
-  };
-
-  request("connect", params)
-    .then((res) => {
-      console.log("✓ connect OK:", JSON.stringify(res).slice(0, 100));
-      connected = true;
-      runTest();
-    })
-    .catch((err) => {
-      console.error("✗ connect FAILED:", err.message);
-      process.exit(1);
-    });
-}
-
-async function runTest() {
-  console.log("\n--- Running test ---");
-  try {
-    const r1 = await request("sessions.reset", { key: "main" });
-    console.log("✓ sessions.reset:", JSON.stringify(r1));
-
-    const r2 = await request("chat.send", {
-      sessionKey: "main",
-      message: "hello, please reply with just one short sentence",
-      idempotencyKey: randomUUID(),
-    });
-    console.log("✓ chat.send:", JSON.stringify(r2));
-    console.log("\nWaiting for chat events...");
-  } catch (err) {
-    console.error("✗ command failed:", err.message);
-    process.exit(1);
-  }
-}
-
-ws.on("open", () => {
-  console.log("WebSocket open, waiting for challenge...");
-  setTimeout(() => { if (!connectSent) { console.log("(no challenge, sending connect now)"); sendConnect(null); } }, 1000);
-});
-
-ws.on("message", (raw) => {
-  const msg = JSON.parse(raw.toString());
-  if (msg.type === "event") {
-    if (msg.event === "connect.challenge") {
-      const nonce = msg.payload?.nonce;
-      console.log("← challenge nonce:", nonce);
-      sendConnect(nonce ?? null);
-      return;
-    }
-    if (msg.event === "chat") {
-      const p = msg.payload;
-      if (p.state === "delta") {
-        process.stdout.write("\r[delta] " + (p.message?.content?.[0]?.text ?? "").slice(-80).padEnd(80));
-      } else if (p.state === "final") {
-        console.log("\n\n[FINAL] " + (p.message?.content?.[0]?.text ?? "(no text)"));
-        ws.close();
-        process.exit(0);
-      } else if (p.state === "error") {
-        console.log("\n[ERROR]", p.errorMessage);
-        ws.close();
-        process.exit(1);
-      }
-    } else if (msg.event !== "health" && msg.event !== "presence" && msg.event !== "tick") {
-      console.log("\n← event:", msg.event, JSON.stringify(msg.payload ?? {}).slice(0, 80));
-    }
-    return;
-  }
-  if (msg.type === "res") {
-    const p = pending.get(msg.id);
-    if (p) {
-      pending.delete(msg.id);
-      console.log(`← res [${msg.id.slice(0, 8)}] ok=${msg.ok}` + (msg.error ? " error=" + msg.error.message : ""));
-      if (msg.ok) p.resolve(msg.payload);
-      else p.reject(new Error(msg.error?.message ?? "gateway error"));
-    }
-  }
-});
-
-ws.on("close", (code, reason) => {
-  console.log("\n← close", code, reason.toString() || "(no reason)");
-  process.exit(code === 1000 ? 0 : 1);
-});
-
-ws.on("error", (err) => console.error("WS error:", err.message));
-
-setTimeout(() => {
-  console.log("\n[timeout 60s]");
-  ws.close();
-  process.exit(1);
-}, 60000);

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "outDir": "dist",
-    "rootDir": "src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "sourceMap": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}