clawpad 0.4.1 → 0.4.3

package/bin/clawpad.js

@@ -354,15 +354,110 @@ async function startShare(shareArgs) {
   console.log(`  🔑 Token: ${token.slice(0, 8)}...`);
   console.log();
   
-  connectRelay(relayUrl, token, gateway.url, agentName);
+  connectRelay(relayUrl, token, gateway.url, gateway.token, agentName);
 }
 
-function connectRelay(relayUrl, token, gatewayWsUrl, agentName = "unknown") {
+// Handle local RPC methods for cloud UI
+async function handleLocalRpc(msg) {
+  const { id, method, params } = msg;
+  
+  try {
+    switch (method) {
+      case "files.list": {
+        const targetPath = resolvePath(params?.path || "~/.openclaw/pages");
+        const files = await listFilesRecursive(targetPath);
+        return { type: "res", id, ok: true, payload: { files } };
+      }
+      
+      case "files.read": {
+        const targetPath = resolvePath(params?.path);
+        if (!targetPath) {
+          return { type: "res", id, ok: false, error: { code: "INVALID_PATH", message: "Path required" } };
+        }
+        const content = fs.readFileSync(targetPath, "utf-8");
+        return { type: "res", id, ok: true, payload: { content } };
+      }
+      
+      case "files.write": {
+        const targetPath = resolvePath(params?.path);
+        if (!targetPath || !params?.content) {
+          return { type: "res", id, ok: false, error: { code: "INVALID_PARAMS", message: "Path and content required" } };
+        }
+        fs.writeFileSync(targetPath, params.content, "utf-8");
+        return { type: "res", id, ok: true, payload: { success: true } };
+      }
+      
+      default:
+        // Not a local method, let gateway handle it
+        return null;
+    }
+  } catch (err) {
+    return { 
+      type: "res", 
+      id, 
+      ok: false, 
+      error: { code: "ERROR", message: err.message || "Unknown error" } 
+    };
+  }
+}
+
+function resolvePath(p) {
+  if (!p) return null;
+  if (p.startsWith("~/")) {
+    return path.join(os.homedir(), p.slice(2));
+  }
+  return path.resolve(p);
+}
+
+async function listFilesRecursive(dirPath, basePath = dirPath) {
+  const items = [];
+  
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      // Skip hidden files and node_modules
+      if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+      
+      const fullPath = path.join(dirPath, entry.name);
+      const relativePath = path.relative(basePath, fullPath);
+      
+      if (entry.isDirectory()) {
+        const children = await listFilesRecursive(fullPath, basePath);
+        items.push({
+          name: entry.name,
+          path: relativePath,
+          type: "folder",
+          children,
+        });
+      } else if (entry.name.endsWith(".md") || entry.name.endsWith(".txt")) {
+        items.push({
+          name: entry.name,
+          path: relativePath,
+          type: "file",
+        });
+      }
+    }
+  } catch (err) {
+    console.error(`  ⚠️ Error listing ${dirPath}:`, err.message);
+  }
+  
+  // Sort: folders first, then files, alphabetically
+  items.sort((a, b) => {
+    if (a.type !== b.type) return a.type === "folder" ? -1 : 1;
+    return a.name.localeCompare(b.name);
+  });
+  
+  return items;
+}
+
+function connectRelay(relayUrl, token, gatewayWsUrl, gatewayToken, agentName = "unknown") {
   console.log(`  ☁️  Connecting to Relay...`);
 
   const tunnelUrl = `${relayUrl}?type=agent&token=${encodeURIComponent(token)}&name=${encodeURIComponent(agentName)}&version=${encodeURIComponent(CURRENT_VERSION)}&platform=${encodeURIComponent(process.platform)}`;
   const ws = new WebSocket(tunnelUrl);
   let gatewayWs = null;
+  let gatewayConnected = false;
   let reconnectTimer = null;
 
   const cleanup = () => {
@@ -370,29 +465,75 @@ function connectRelay(relayUrl, token, gatewayWsUrl, agentName = "unknown") {
       gatewayWs.terminate();
       gatewayWs = null;
     }
+    gatewayConnected = false;
     if (reconnectTimer) {
       clearTimeout(reconnectTimer);
       reconnectTimer = null;
     }
   };
 
-  ws.on("open", () => {
-    console.log("  ✅ Connected to Cloud Relay.");
-    console.log("     Your agent is now accessible via app.clawpad.io");
-    
-    // Connect to Local Gateway
+  const connectToGateway = () => {
     gatewayWs = new WebSocket(gatewayWsUrl);
     
     gatewayWs.on("open", () => {
-      console.log("  🔗 Connected to Local Gateway.");
+      // Gateway is open but we need to wait for connect.challenge
     });
 
     gatewayWs.on("message", (data) => {
-      // Forward Gateway -> Relay
-      // SECURITY: Here we could inspect 'data' if needed, but it's encrypted JSON-RPC usually.
-      // We rely on 'tools.allow' policy for security.
-      if (ws.readyState === WebSocket.OPEN) {
-        ws.send(data);
+      try {
+        const msg = JSON.parse(data.toString());
+        
+        // Handle gateway connect.challenge - authenticate before forwarding
+        if (msg.type === "event" && msg.event === "connect.challenge") {
+          const connectReq = {
+            type: "req",
+            id: `connect-${Date.now()}`,
+            method: "connect",
+            params: {
+              minProtocol: 3,
+              maxProtocol: 3,
+              client: {
+                id: "cli",
+                version: CURRENT_VERSION,
+                platform: process.platform,
+                mode: "cli"
+              },
+              role: "operator",
+              scopes: ["operator.read", "operator.write"],
+              caps: [],
+              commands: [],
+              permissions: {},
+              auth: gatewayToken ? { token: gatewayToken } : {},
+              locale: "en-US",
+              userAgent: `clawpad-relay/${CURRENT_VERSION}`
+            }
+          };
+          gatewayWs.send(JSON.stringify(connectReq));
+          return;
+        }
+        
+        // Handle connect response
+        if (msg.type === "res" && msg.ok && msg.payload?.type === "hello-ok") {
+          console.log("  🔗 Connected to Local Gateway.");
+          gatewayConnected = true;
+          return;
+        }
+        
+        // Handle connect error
+        if (msg.type === "res" && !msg.ok) {
+          console.error("  ❌ Gateway auth failed:", msg.error?.message || "unknown error");
+          return;
+        }
+        
+        // Forward other messages Gateway -> Relay
+        if (gatewayConnected && ws.readyState === WebSocket.OPEN) {
+          ws.send(data);
+        }
+      } catch {
+        // Non-JSON or parse error, forward anyway if connected
+        if (gatewayConnected && ws.readyState === WebSocket.OPEN) {
+          ws.send(data);
+        }
       }
     });
 
@@ -400,23 +541,52 @@ function connectRelay(relayUrl, token, gatewayWsUrl, agentName = "unknown") {
       console.error("  ⚠️ Local Gateway Error:", err.message);
     });
 
-    gatewayWs.on("close", () => {
-      console.log("  ⚠️ Local Gateway Disconnected. Reconnecting in 5s...");
-      setTimeout(() => {
-        if (ws.readyState === WebSocket.OPEN) {
-           // Re-establish local connection logic could go here or just let it fail until next message
-           // Ideally we close the tunnel or try to reconnect local
-           ws.close(); // Force full reconnect cycle
-        }
-      }, 5000);
+    gatewayWs.on("close", (code, reason) => {
+      console.log(`  ⚠️ Local Gateway Disconnected (${code}). Will reconnect on relay reconnect.`);
+      gatewayConnected = false;
+      // Don't reconnect gateway independently - let relay reconnect handle it
     });
+  };
+
+  ws.on("open", () => {
+    console.log("  ✅ Connected to Cloud Relay.");
+    console.log("     Your agent is now accessible via app.clawpad.io");
+    connectToGateway();
+    
+    // Keep connection alive with pings every 25s
+    const pingInterval = setInterval(() => {
+      if (ws.readyState === WebSocket.OPEN) {
+        ws.ping();
+      } else {
+        clearInterval(pingInterval);
+      }
+    }, 25000);
+    
+    ws.on("close", () => clearInterval(pingInterval));
   });
 
-  ws.on("message", (data) => {
-    // Forward Relay -> Gateway
-    // SECURITY: Intercept dangerous calls here if we parse JSON-RPC
-    if (gatewayWs && gatewayWs.readyState === WebSocket.OPEN) {
-      gatewayWs.send(data);
+  ws.on("message", async (data) => {
+    try {
+      const msg = JSON.parse(data.toString());
+      
+      // Handle local RPC methods (files, etc.)
+      if (msg.type === "req" && msg.method) {
+        const response = await handleLocalRpc(msg);
+        if (response) {
+          ws.send(JSON.stringify(response));
+          return;
+        }
+      }
+      
+      // Forward other messages Relay -> Gateway
+      if (gatewayWs && gatewayWs.readyState === WebSocket.OPEN && gatewayConnected) {
+        gatewayWs.send(data);
+      }
+    } catch {
+      // Non-JSON, forward to gateway
+      if (gatewayWs && gatewayWs.readyState === WebSocket.OPEN && gatewayConnected) {
+        gatewayWs.send(data);
+      }
     }
   });
 
@@ -427,7 +597,7 @@ function connectRelay(relayUrl, token, gatewayWsUrl, agentName = "unknown") {
   ws.on("close", () => {
     console.log("  ❌ Disconnected from Relay. Reconnecting in 5s...");
     cleanup();
-    reconnectTimer = setTimeout(() => connectRelay(relayUrl, token, gatewayWsUrl), 5000);
+    reconnectTimer = setTimeout(() => connectRelay(relayUrl, token, gatewayWsUrl, gatewayToken, agentName), 5000);
   });
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawpad",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "description": "A file-based, Notion-style document workspace for OpenClaw",
   "keywords": [
     "openclaw",