@mclawnet/agent 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,4 +1,5 @@
 // src/hub-connection.ts
+import { hostname as osHostname } from "os";
 import WebSocket from "ws";
 var DEFAULT_HEARTBEAT_MS = 3e4;
 var DEFAULT_RECONNECT_MS = 1e3;
@@ -9,22 +10,32 @@ var HubConnection = class {
   reconnectTimer = null;
   reconnectDelay;
   destroyed = false;
+  authState = "pending";
+  proxySessions = /* @__PURE__ */ new Map();
   hubUrl;
   token;
+  hostname;
+  gatewayPort;
+  gatewayToken;
   heartbeatInterval;
   maxReconnectDelay;
+  /** Agent ID assigned by Hub after successful auth */
+  agentId = null;
   onMessage;
-  onConnect;
+  onConnectCb;
   onDisconnect;
   onError;
   constructor(opts) {
     this.hubUrl = opts.hubUrl;
     this.token = opts.token;
+    this.hostname = opts.hostname ?? osHostname();
+    this.gatewayPort = opts.gatewayPort ?? 18789;
+    this.gatewayToken = opts.gatewayToken ?? "";
     this.heartbeatInterval = opts.heartbeatInterval ?? DEFAULT_HEARTBEAT_MS;
     this.reconnectDelay = opts.reconnectDelay ?? DEFAULT_RECONNECT_MS;
     this.maxReconnectDelay = opts.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_MS;
     this.onMessage = opts.onMessage;
-    this.onConnect = opts.onConnect;
+    this.onConnectCb = opts.onConnect;
     this.onDisconnect = opts.onDisconnect;
     this.onError = opts.onError;
   }
@@ -33,31 +44,53 @@ var HubConnection = class {
     return this.ws?.readyState ?? WebSocket.CLOSED;
   }
   get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return this.ws?.readyState === WebSocket.OPEN && this.authState === "authenticated";
   }
-  /** Open the connection to the hub */
+  /** Open the connection to the hub (no token in URL) */
   connect() {
     if (this.destroyed) return;
     this.cleanup();
-    const url = new URL(this.hubUrl);
-    url.searchParams.set("token", this.token);
-    this.ws = new WebSocket(url.toString());
+    this.authState = "pending";
+    this.ws = new WebSocket(this.hubUrl);
     this.ws.on("open", () => {
       this.reconnectDelay = DEFAULT_RECONNECT_MS;
-      this.startHeartbeat();
-      this.onConnect?.();
     });
     this.ws.on("message", (raw) => {
+      let data;
       try {
-        const data = JSON.parse(raw.toString());
-        this.onMessage?.(data);
+        data = JSON.parse(raw.toString());
       } catch {
-        this.onMessage?.(raw.toString());
+        return;
+      }
+      if (this.authState === "pending" && data.type === "auth_required") {
+        this.authState = "authenticating";
+        this.ws.send(JSON.stringify({
+          type: "auth",
+          token: this.token,
+          hostname: this.hostname
+        }));
+        return;
+      }
+      if (this.authState === "authenticating" && data.type === "registered") {
+        this.authState = "authenticated";
+        this.agentId = data.agentId ?? null;
+        this.startHeartbeat();
+        this.onConnectCb?.(this.agentId);
+        return;
+      }
+      if (this.authState === "authenticated") {
+        if (this.handleProxyMessage(data)) return;
+        this.onMessage?.(data);
       }
     });
     this.ws.on("close", (code, reason) => {
       this.stopHeartbeat();
+      this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
+      if (code === 4002) {
+        console.error("[clawnet] Auth failed \u2014 not reconnecting. Check your token.");
+        return;
+      }
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
@@ -66,7 +99,7 @@ var HubConnection = class {
   }
   /** Send a JSON message to the hub */
   send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.authState !== "authenticated") return false;
     this.ws.send(JSON.stringify(data));
     return true;
   }
@@ -96,6 +129,7 @@ var HubConnection = class {
   }
   cleanup() {
     this.stopHeartbeat();
+    this.closeAllProxySessions();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -108,6 +142,96 @@ var HubConnection = class {
       this.ws = null;
     }
   }
+  // ── Proxy session management ──────────────────────────────────────
+  /**
+   * Handle proxy protocol messages from the Hub.
+   * Returns true if the message was handled.
+   */
+  handleProxyMessage(msg) {
+    if (msg.type === "proxy.open" && msg.sessionId) {
+      this.openLocalGateway(msg.sessionId, msg.gatewayPort ?? this.gatewayPort);
+      return true;
+    }
+    if (msg.type === "proxy.data" && msg.sessionId) {
+      const session = this.proxySessions.get(msg.sessionId);
+      if (session && session.localWs.readyState === WebSocket.OPEN && msg.data) {
+        const patched = this.patchBrowserConnect(msg.data, session);
+        session.localWs.send(patched);
+      }
+      return true;
+    }
+    if (msg.type === "proxy.close" && msg.sessionId) {
+      this.closeProxySession(msg.sessionId);
+      return true;
+    }
+    return false;
+  }
+  openLocalGateway(sessionId, port) {
+    const localWs = new WebSocket(`ws://127.0.0.1:${port}/`, {
+      headers: { Origin: `http://127.0.0.1:${port}` }
+    });
+    const session = {
+      sessionId,
+      localWs,
+      gatewayNonce: null
+    };
+    this.proxySessions.set(sessionId, session);
+    localWs.on("open", () => {
+      this.send({ type: "proxy.opened", sessionId });
+    });
+    localWs.on("message", (raw) => {
+      const text = raw.toString();
+      try {
+        const frame = JSON.parse(text);
+        if (frame.type === "evt" && frame.event === "connect.challenge" && frame.payload?.nonce) {
+          session.gatewayNonce = frame.payload.nonce;
+        }
+      } catch {
+      }
+      this.send({ type: "proxy.data", sessionId, data: text });
+    });
+    localWs.on("close", () => {
+      this.proxySessions.delete(sessionId);
+      this.send({ type: "proxy.close", sessionId });
+    });
+    localWs.on("error", () => {
+      this.proxySessions.delete(sessionId);
+      this.send({ type: "proxy.close", sessionId });
+    });
+  }
+  /**
+   * Intercept browser's "connect" request and patch it for the local gateway:
+   * - Inject gateway auth token
+   * - Remove `device` object (browser's device identity/signature doesn't apply
+   *   through the proxy; the gateway will use token-only auth)
+   */
+  patchBrowserConnect(raw, session) {
+    if (!this.gatewayToken) return raw;
+    try {
+      const frame = JSON.parse(raw);
+      if (frame.type === "req" && frame.method === "connect" && frame.params) {
+        if (!frame.params.auth) frame.params.auth = {};
+        frame.params.auth.token = this.gatewayToken;
+        delete frame.params.device;
+        return JSON.stringify(frame);
+      }
+    } catch {
+    }
+    return raw;
+  }
+  closeProxySession(sessionId) {
+    const session = this.proxySessions.get(sessionId);
+    if (!session) return;
+    this.proxySessions.delete(sessionId);
+    if (session.localWs.readyState === WebSocket.OPEN || session.localWs.readyState === WebSocket.CONNECTING) {
+      session.localWs.close();
+    }
+  }
+  closeAllProxySessions() {
+    for (const [sessionId] of this.proxySessions) {
+      this.closeProxySession(sessionId);
+    }
+  }
 };
 
 // src/config.ts
@@ -272,6 +396,15 @@ function ensureGatewayToken() {
     config.gateway.mode = "local";
     dirty = true;
   }
+  if (!config.gateway.controlUi) config.gateway.controlUi = {};
+  if (!config.gateway.controlUi.allowedOrigins) {
+    config.gateway.controlUi.allowedOrigins = ["*"];
+    dirty = true;
+  }
+  if (config.gateway.controlUi.allowInsecureAuth === void 0) {
+    config.gateway.controlUi.allowInsecureAuth = true;
+    dirty = true;
+  }
   if (dirty) {
     writeFileSync2(file, JSON.stringify(config, null, 2) + "\n");
   }
@@ -548,6 +681,8 @@ async function startAgent(opts) {
   const hubConnection = new HubConnection({
     hubUrl: config.hubUrl,
     token: config.token,
+    gatewayPort: config.port,
+    gatewayToken,
     onConnect: () => {
       console.log("[clawnet] Connected to Hub");
     },

package/dist/start.d.ts

@@ -3,11 +3,14 @@ import { ChildProcess } from 'node:child_process';
 interface HubConnectionOptions {
     hubUrl: string;
     token: string;
+    hostname?: string;
+    gatewayPort?: number;
+    gatewayToken?: string;
     heartbeatInterval?: number;
     reconnectDelay?: number;
     maxReconnectDelay?: number;
     onMessage?: (data: unknown) => void;
-    onConnect?: () => void;
+    onConnect?: (agentId: string) => void;
     onDisconnect?: (code: number, reason: string) => void;
     onError?: (err: Error) => void;
 }
@@ -17,19 +20,26 @@ declare class HubConnection {
     private reconnectTimer;
     private reconnectDelay;
     private destroyed;
+    private authState;
+    private proxySessions;
     readonly hubUrl: string;
     readonly token: string;
+    readonly hostname: string;
+    readonly gatewayPort: number;
+    readonly gatewayToken: string;
     readonly heartbeatInterval: number;
     readonly maxReconnectDelay: number;
+    /** Agent ID assigned by Hub after successful auth */
+    agentId: string | null;
     private onMessage?;
-    private onConnect?;
+    private onConnectCb?;
     private onDisconnect?;
     private onError?;
     constructor(opts: HubConnectionOptions);
     /** Current WebSocket readyState (or CLOSED if no socket) */
     get readyState(): number;
     get isConnected(): boolean;
-    /** Open the connection to the hub */
+    /** Open the connection to the hub (no token in URL) */
     connect(): void;
     /** Send a JSON message to the hub */
     send(data: unknown): boolean;
@@ -39,6 +49,21 @@ declare class HubConnection {
     private stopHeartbeat;
     private scheduleReconnect;
     private cleanup;
+    /**
+     * Handle proxy protocol messages from the Hub.
+     * Returns true if the message was handled.
+     */
+    private handleProxyMessage;
+    private openLocalGateway;
+    /**
+     * Intercept browser's "connect" request and patch it for the local gateway:
+     * - Inject gateway auth token
+     * - Remove `device` object (browser's device identity/signature doesn't apply
+     *   through the proxy; the gateway will use token-only auth)
+     */
+    private patchBrowserConnect;
+    private closeProxySession;
+    private closeAllProxySessions;
 }
 
 interface AgentConfig {

package/dist/start.js

@@ -148,6 +148,15 @@ function ensureGatewayToken() {
     config.gateway.mode = "local";
     dirty = true;
   }
+  if (!config.gateway.controlUi) config.gateway.controlUi = {};
+  if (!config.gateway.controlUi.allowedOrigins) {
+    config.gateway.controlUi.allowedOrigins = ["*"];
+    dirty = true;
+  }
+  if (config.gateway.controlUi.allowInsecureAuth === void 0) {
+    config.gateway.controlUi.allowInsecureAuth = true;
+    dirty = true;
+  }
   if (dirty) {
     writeFileSync2(file, JSON.stringify(config, null, 2) + "\n");
   }
@@ -382,6 +391,7 @@ function promptChoice(max) {
 }
 
 // src/hub-connection.ts
+import { hostname as osHostname } from "os";
 import WebSocket from "ws";
 var DEFAULT_HEARTBEAT_MS = 3e4;
 var DEFAULT_RECONNECT_MS = 1e3;
@@ -392,22 +402,32 @@ var HubConnection = class {
   reconnectTimer = null;
   reconnectDelay;
   destroyed = false;
+  authState = "pending";
+  proxySessions = /* @__PURE__ */ new Map();
   hubUrl;
   token;
+  hostname;
+  gatewayPort;
+  gatewayToken;
   heartbeatInterval;
   maxReconnectDelay;
+  /** Agent ID assigned by Hub after successful auth */
+  agentId = null;
   onMessage;
-  onConnect;
+  onConnectCb;
   onDisconnect;
   onError;
   constructor(opts) {
     this.hubUrl = opts.hubUrl;
     this.token = opts.token;
+    this.hostname = opts.hostname ?? osHostname();
+    this.gatewayPort = opts.gatewayPort ?? 18789;
+    this.gatewayToken = opts.gatewayToken ?? "";
     this.heartbeatInterval = opts.heartbeatInterval ?? DEFAULT_HEARTBEAT_MS;
     this.reconnectDelay = opts.reconnectDelay ?? DEFAULT_RECONNECT_MS;
     this.maxReconnectDelay = opts.maxReconnectDelay ?? DEFAULT_MAX_RECONNECT_MS;
     this.onMessage = opts.onMessage;
-    this.onConnect = opts.onConnect;
+    this.onConnectCb = opts.onConnect;
     this.onDisconnect = opts.onDisconnect;
     this.onError = opts.onError;
   }
@@ -416,31 +436,53 @@ var HubConnection = class {
     return this.ws?.readyState ?? WebSocket.CLOSED;
   }
   get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return this.ws?.readyState === WebSocket.OPEN && this.authState === "authenticated";
   }
-  /** Open the connection to the hub */
+  /** Open the connection to the hub (no token in URL) */
   connect() {
     if (this.destroyed) return;
     this.cleanup();
-    const url = new URL(this.hubUrl);
-    url.searchParams.set("token", this.token);
-    this.ws = new WebSocket(url.toString());
+    this.authState = "pending";
+    this.ws = new WebSocket(this.hubUrl);
     this.ws.on("open", () => {
       this.reconnectDelay = DEFAULT_RECONNECT_MS;
-      this.startHeartbeat();
-      this.onConnect?.();
     });
     this.ws.on("message", (raw) => {
+      let data;
       try {
-        const data = JSON.parse(raw.toString());
-        this.onMessage?.(data);
+        data = JSON.parse(raw.toString());
       } catch {
-        this.onMessage?.(raw.toString());
+        return;
+      }
+      if (this.authState === "pending" && data.type === "auth_required") {
+        this.authState = "authenticating";
+        this.ws.send(JSON.stringify({
+          type: "auth",
+          token: this.token,
+          hostname: this.hostname
+        }));
+        return;
+      }
+      if (this.authState === "authenticating" && data.type === "registered") {
+        this.authState = "authenticated";
+        this.agentId = data.agentId ?? null;
+        this.startHeartbeat();
+        this.onConnectCb?.(this.agentId);
+        return;
+      }
+      if (this.authState === "authenticated") {
+        if (this.handleProxyMessage(data)) return;
+        this.onMessage?.(data);
       }
     });
     this.ws.on("close", (code, reason) => {
       this.stopHeartbeat();
+      this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
+      if (code === 4002) {
+        console.error("[clawnet] Auth failed \u2014 not reconnecting. Check your token.");
+        return;
+      }
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
@@ -449,7 +491,7 @@ var HubConnection = class {
   }
   /** Send a JSON message to the hub */
   send(data) {
-    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return false;
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN || this.authState !== "authenticated") return false;
     this.ws.send(JSON.stringify(data));
     return true;
   }
@@ -479,6 +521,7 @@ var HubConnection = class {
   }
   cleanup() {
     this.stopHeartbeat();
+    this.closeAllProxySessions();
     if (this.reconnectTimer) {
       clearTimeout(this.reconnectTimer);
       this.reconnectTimer = null;
@@ -491,6 +534,96 @@ var HubConnection = class {
       this.ws = null;
     }
   }
+  // ── Proxy session management ──────────────────────────────────────
+  /**
+   * Handle proxy protocol messages from the Hub.
+   * Returns true if the message was handled.
+   */
+  handleProxyMessage(msg) {
+    if (msg.type === "proxy.open" && msg.sessionId) {
+      this.openLocalGateway(msg.sessionId, msg.gatewayPort ?? this.gatewayPort);
+      return true;
+    }
+    if (msg.type === "proxy.data" && msg.sessionId) {
+      const session = this.proxySessions.get(msg.sessionId);
+      if (session && session.localWs.readyState === WebSocket.OPEN && msg.data) {
+        const patched = this.patchBrowserConnect(msg.data, session);
+        session.localWs.send(patched);
+      }
+      return true;
+    }
+    if (msg.type === "proxy.close" && msg.sessionId) {
+      this.closeProxySession(msg.sessionId);
+      return true;
+    }
+    return false;
+  }
+  openLocalGateway(sessionId, port) {
+    const localWs = new WebSocket(`ws://127.0.0.1:${port}/`, {
+      headers: { Origin: `http://127.0.0.1:${port}` }
+    });
+    const session = {
+      sessionId,
+      localWs,
+      gatewayNonce: null
+    };
+    this.proxySessions.set(sessionId, session);
+    localWs.on("open", () => {
+      this.send({ type: "proxy.opened", sessionId });
+    });
+    localWs.on("message", (raw) => {
+      const text = raw.toString();
+      try {
+        const frame = JSON.parse(text);
+        if (frame.type === "evt" && frame.event === "connect.challenge" && frame.payload?.nonce) {
+          session.gatewayNonce = frame.payload.nonce;
+        }
+      } catch {
+      }
+      this.send({ type: "proxy.data", sessionId, data: text });
+    });
+    localWs.on("close", () => {
+      this.proxySessions.delete(sessionId);
+      this.send({ type: "proxy.close", sessionId });
+    });
+    localWs.on("error", () => {
+      this.proxySessions.delete(sessionId);
+      this.send({ type: "proxy.close", sessionId });
+    });
+  }
+  /**
+   * Intercept browser's "connect" request and patch it for the local gateway:
+   * - Inject gateway auth token
+   * - Remove `device` object (browser's device identity/signature doesn't apply
+   *   through the proxy; the gateway will use token-only auth)
+   */
+  patchBrowserConnect(raw, session) {
+    if (!this.gatewayToken) return raw;
+    try {
+      const frame = JSON.parse(raw);
+      if (frame.type === "req" && frame.method === "connect" && frame.params) {
+        if (!frame.params.auth) frame.params.auth = {};
+        frame.params.auth.token = this.gatewayToken;
+        delete frame.params.device;
+        return JSON.stringify(frame);
+      }
+    } catch {
+    }
+    return raw;
+  }
+  closeProxySession(sessionId) {
+    const session = this.proxySessions.get(sessionId);
+    if (!session) return;
+    this.proxySessions.delete(sessionId);
+    if (session.localWs.readyState === WebSocket.OPEN || session.localWs.readyState === WebSocket.CONNECTING) {
+      session.localWs.close();
+    }
+  }
+  closeAllProxySessions() {
+    for (const [sessionId] of this.proxySessions) {
+      this.closeProxySession(sessionId);
+    }
+  }
 };
 
 // src/start.ts
@@ -536,6 +669,8 @@ async function startAgent(opts) {
   const hubConnection = new HubConnection({
     hubUrl: config.hubUrl,
     token: config.token,
+    gatewayPort: config.port,
+    gatewayToken,
     onConnect: () => {
       console.log("[clawnet] Connected to Hub");
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mclawnet/agent",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "ClawNet Agent — Run OpenClaw with Hub connectivity",
   "license": "MIT",
   "type": "module",