Upload 2 files

server.js

@@ -1,16 +1,136 @@
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
+const WebSocket = require('ws');
 
 const PORT = 7860;
-const API_BASE = process.env.BASE_URL || '';
-const API_KEY = process.env.API_KEY || '';
+const GATEWAY_PORT = 18789;
 
-// Serve the chat UI
-const indexHtml = fs.readFileSync(path.join(__dirname, 'public', 'index.html'), 'utf8');
+let gatewayWs = null;
+const sessions = new Map();
 
+// Connect to local OpenClaw gateway (no pairing needed for loopback)
+function connectToGateway() {
+    return new Promise((resolve, reject) => {
+        console.log('🔌 Connecting to OpenClaw Gateway (localhost)...');
+        
+        const ws = new WebSocket(`ws://127.0.0.1:${GATEWAY_PORT}/`);
+        
+        ws.on('open', () => {
+            console.log('✅ Connected to OpenClaw Gateway');
+            gatewayWs = ws;
+            resolve();
+        });
+        
+        ws.on('message', (data) => {
+            try {
+                const msg = JSON.parse(data.toString());
+                console.log('📥 OpenClaw response:', JSON.stringify(msg).substring(0, 150));
+                handleGatewayMessage(msg);
+            } catch (e) {
+                console.log('📥 Raw:', data.toString().substring(0, 150));
+            }
+        });
+        
+        ws.on('error', (err) => {
+            console.error('❌ Gateway connection error:', err.message);
+            gatewayWs = null;
+        });
+        
+        ws.on('close', () => {
+            console.log('Gateway connection closed');
+            gatewayWs = null;
+            // Reconnect after delay
+            setTimeout(() => {
+                if (!gatewayWs) connectToGateway().catch(() => {});
+            }, 3000);
+        });
+    });
+}
+
+// Handle messages from OpenClaw gateway
+function handleGatewayMessage(msg) {
+    // Extract session key
+    const sessionKey = msg.sessionKey;
+    if (!sessionKey) return;
+    
+    const session = sessions.get(sessionKey);
+    if (session && session.pendingResolve) {
+        // Extract reply from various message formats
+        let reply = null;
+        
+        if (msg.type === 'text' || msg.type === 'chunk') {
+            reply = msg.content || msg.text;
+        } else if (msg.choices && msg.choices[0]?.message?.content) {
+            reply = msg.choices[0].message.content;
+        } else if (msg.content) {
+            reply = msg.content;
+        } else if (msg.message) {
+            reply = msg.message;
+        }
+        
+        if (reply) {
+            // Accumulate chunks
+            if (!session.reply) session.reply = '';
+            session.reply += reply;
+            
+            // If done or complete message, resolve
+            if (msg.type === 'done' || msg.type === 'text' || msg.complete) {
+                session.pendingResolve({ reply: session.reply });
+                session.pendingResolve = null;
+                session.reply = '';
+            }
+        }
+    }
+}
+
+// Send message through OpenClaw
+function sendToOpenClaw(message, sessionId) {
+    return new Promise((resolve, reject) => {
+        if (!gatewayWs || gatewayWs.readyState !== WebSocket.OPEN) {
+            reject(new Error('Gateway not connected'));
+            return;
+        }
+        
+        const sessionKey = `webchat:direct:${sessionId}`;
+        
+        // Track session
+        if (!sessions.has(sessionKey)) {
+            sessions.set(sessionKey, { messages: [], reply: '' });
+        }
+        const session = sessions.get(sessionKey);
+        session.pendingResolve = resolve;
+        
+        // Send to OpenClaw gateway
+        const payload = {
+            type: 'message',
+            content: message,
+            sessionKey: sessionKey,
+            channel: 'webchat',
+            chatType: 'direct',
+            from: { id: sessionId, name: 'Web User' }
+        };
+        
+        console.log('📤 To OpenClaw:', message.substring(0, 50));
+        gatewayWs.send(JSON.stringify(payload));
+        
+        // Timeout after 2 minutes
+        setTimeout(() => {
+            if (session.pendingResolve === resolve) {
+                session.pendingResolve = null;
+                if (session.reply) {
+                    resolve({ reply: session.reply });
+                    session.reply = '';
+                } else {
+                    reject(new Error('Response timeout'));
+                }
+            }
+        }, 120000);
+    });
+}
+
+// HTTP Server - serves UI and proxies to OpenClaw
 const server = http.createServer(async (req, res) => {
-    // CORS headers
     res.setHeader('Access-Control-Allow-Origin', '*');
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
     res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
@@ -23,89 +143,27 @@ const server = http.createServer(async (req, res) => {
     
     // Serve UI
     if (req.url === '/' || req.url === '/index.html') {
+        const html = fs.readFileSync(path.join(__dirname, 'public', 'index.html'), 'utf8');
         res.writeHead(200, { 'Content-Type': 'text/html' });
-        res.end(indexHtml);
+        res.end(html);
         return;
     }
     
-    // Chat API endpoint
+    // Chat endpoint - goes through OpenClaw
     if (req.url === '/chat' && req.method === 'POST') {
         let body = '';
         req.on('data', chunk => body += chunk);
         req.on('end', async () => {
             try {
-                const { message } = JSON.parse(body);
-                
-                if (!API_BASE || !API_KEY) {
-                    res.writeHead(500, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ error: 'API not configured. Set BASE_URL and API_KEY secrets.' }));
-                    return;
-                }
-                
-                console.log(`📤 Sending to API: ${message.substring(0, 50)}...`);
+                const { message, sessionId } = JSON.parse(body);
+                const sid = sessionId || `web-${Date.now()}`;
                 
-                // Call the AI API
-                const apiRes = await fetch(API_BASE + '/chat/completions', {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        'Authorization': `Bearer ${API_KEY}`
-                    },
-                    body: JSON.stringify({
-                        model: process.env.MODEL_ID || 'Multiple-models',
-                        messages: [
-                            { role: 'user', content: message }
-                        ]
-                    })
-                });
-                
-                console.log(`📥 API response status: ${apiRes.status}`);
-                
-                // Get raw text first
-                const rawText = await apiRes.text();
-                
-                // Log response around the error position
-                console.log(`📥 Response length: ${rawText.length}`);
-                if (rawText.length > 1500) {
-                    console.log(`📥 Around position 1500-1700: "${rawText.substring(1500, 1700)}"`);
-                }
-                
-                // Try to extract content using regex (avoid full JSON parse)
-                const contentMatch = rawText.match(/"content"\s*:\s*"([^"]*(?:\\.[^"]*)*)"/s);
-                if (contentMatch) {
-                    let reply = contentMatch[1];
-                    // Unescape common JSON escapes
-                    reply = reply.replace(/\\n/g, '\n')
-                                 .replace(/\\"/g, '"')
-                                 .replace(/\\\\/g, '\\');
-                    console.log(`✅ Extracted reply (${reply.length} chars)`);
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ reply }));
-                    return;
-                }
-                
-                // Fallback: Try JSON parse
-                let data;
-                try {
-                    data = JSON.parse(rawText);
-                } catch (parseErr) {
-                    console.error('❌ JSON parse error:', parseErr.message);
-                    // Return a truncated raw response
-                    res.writeHead(200, { 'Content-Type': 'application/json' });
-                    res.end(JSON.stringify({ reply: rawText.substring(0, 500) + '...(truncated)' }));
-                    return;
-                }
-                
-                const reply = data.choices?.[0]?.message?.content || 
-                              data.message || 
-                              data.response ||
-                              JSON.stringify(data);
-                
-                console.log(`✅ Parsed reply (${reply.length} chars)`);
+                // Send through OpenClaw gateway
+                const response = await sendToOpenClaw(message, sid);
                 res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify({ reply }));
+                res.end(JSON.stringify(response));
             } catch (err) {
-                console.error('❌ Error:', err);
+                console.error('❌ Chat error:', err.message);
                 res.writeHead(500, { 'Content-Type': 'application/json' });
                 res.end(JSON.stringify({ error: err.message }));
             }
@@ -117,8 +175,33 @@ const server = http.createServer(async (req, res) => {
     res.end('Not found');
 });
 
-server.listen(PORT, '0.0.0.0', () => {
-    console.log(`🌐 OpenClaw Web Chat running on port ${PORT}`);
-    console.log(`🔗 Open your Space URL to access the chat`);
-    console.log(`📡 API URL: ${API_BASE || 'not set'}`);
-});
+// Main
+async function main() {
+    try {
+        // Wait for gateway to be ready, then connect
+        let retries = 30;
+        while (retries > 0) {
+            try {
+                await connectToGateway();
+                break;
+            } catch (e) {
+                retries--;
+                await new Promise(r => setTimeout(r, 1000));
+            }
+        }
+        
+        if (!gatewayWs) {
+            throw new Error('Could not connect to OpenClaw Gateway');
+        }
+        
+        server.listen(PORT, '0.0.0.0', () => {
+            console.log(`\n🌐 OpenClaw Web Interface running on port ${PORT}`);
+            console.log(`🔗 Open your Space URL to chat with Zero!\n`);
+        });
+    } catch (err) {
+        console.error('❌ Startup failed:', err);
+        process.exit(1);
+    }
+}
+
+main();

start.sh

@@ -1,8 +1,11 @@
 #!/bin/bash
 
-# Hugging Face Spaces startup script
+# Hugging Face Spaces startup script for OpenClaw
 
-echo "🦞 Starting OpenClaw Web Chat..."
+echo "🦞 Starting OpenClaw on Hugging Face Spaces..."
+
+# Create config directory
+mkdir -p /root/.openclaw/workspace
 
 # Check required env vars
 if [ -z "$API_KEY" ] || [ -z "$BASE_URL" ]; then
@@ -12,16 +15,72 @@ fi
 # Set defaults
 BASE_URL=${BASE_URL:-"http://127.0.0.1:20128/v1"}
 MODEL_ID=${MODEL_ID:-"Multiple-models"}
+PROVIDER_NAME=${PROVIDER_NAME:-"custom"}
 
-export BASE_URL
-export API_KEY
-export MODEL_ID
+# Create OpenClaw config - bind to loopback only (no pairing needed for local)
+cat > /root/.openclaw/openclaw.json << EOF
+{
+  "meta": {
+    "lastTouchedVersion": "2026.2.19-2"
+  },
+  "models": {
+    "providers": {
+      "${PROVIDER_NAME}": {
+        "baseUrl": "${BASE_URL}",
+        "apiKey": "${API_KEY}",
+        "api": "openai-completions",
+        "models": [
+          { "id": "${MODEL_ID}", "name": "${MODEL_ID}" }
+        ]
+      }
+    }
+  },
+  "agents": {
+    "defaults": {
+      "model": { "primary": "${PROVIDER_NAME}/${MODEL_ID}" },
+      "workspace": "/root/.openclaw/workspace"
+    }
+  },
+  "commands": { "native": "auto", "nativeSkills": "auto", "restart": false },
+  "hooks": {
+    "internal": {
+      "enabled": true,
+      "entries": {
+        "boot-md": { "enabled": true },
+        "command-logger": { "enabled": true },
+        "session-memory": { "enabled": true }
+      }
+    }
+  },
+  "session": { "dmScope": "per-channel-peer" },
+  "gateway": {
+    "port": 18789,
+    "mode": "local",
+    "bind": "loopback",
+    "auth": { "mode": "none" },
+    "tailscale": { "mode": "off" }
+  },
+  "skills": { "install": { "nodeManager": "npm" } },
+  "plugins": { "entries": {} }
+}
+EOF
 
-echo "✅ Configured"
-echo "📡 API URL: ${BASE_URL}"
+echo "✅ Config created (loopback mode - no pairing)"
+echo "📡 API: ${BASE_URL}"
 echo "🤖 Model: ${MODEL_ID}"
 
-# Start the simple web server
-echo "🌐 Starting web server on port 7860..."
+# Start OpenClaw gateway
+echo "🚀 Starting OpenClaw Gateway..."
+openclaw gateway &
+GATEWAY_PID=$!
+
+# Wait for gateway
+sleep 5
+
+# Start web proxy server
+echo "🌐 Starting Web Proxy..."
 cd /app
-exec node server.js
+node server.js
+
+# Cleanup
+kill $GATEWAY_PID 2>/dev/null