clawhq-bridge 1.0.0

package/README.md

@@ -0,0 +1,52 @@
+# ClawHQ Bridge
+
+Connect your local [OpenClaw](https://docs.openclaw.ai) agent to [ClawHQ](https://clawhq.dev) — chat with your AI from the ClawHQ iOS app or web dashboard.
+
+## Quick Start
+
+```bash
+npx clawhq-bridge --setup YOUR_SETUP_CODE
+```
+
+Get your setup code from **Agent Settings** in the ClawHQ app after creating a Connector agent.
+
+## Usage
+
+```bash
+# First-time setup (auto-detects OpenClaw)
+npx clawhq-bridge --setup <SETUP_CODE>
+
+# Run bridge (after setup)
+npx clawhq-bridge
+
+# Check status
+npx clawhq-bridge --status
+```
+
+## How It Works
+
+1. You create a **Connector** agent in ClawHQ
+2. Run the setup command — it exchanges your code for credentials and detects your OpenClaw installation
+3. The bridge connects to ClawHQ via Socket.io and forwards messages to your local OpenClaw gateway
+4. Chat with your agent from anywhere — iOS, web, or desktop
+
+## Requirements
+
+- [Node.js](https://nodejs.org) 16+
+- [OpenClaw](https://docs.openclaw.ai) running locally
+
+## Options
+
+| Flag | Description |
+|------|-------------|
+| `--setup <code>` | First-time setup with code from ClawHQ |
+| `--session <key>` | OpenClaw session key (default: `clawhq:app`) |
+| `--port <port>` | OpenClaw gateway port (default: `18789`) |
+| `--status` | Show bridge config and status |
+| `--help` | Show help |
+
+## Links
+
+- [ClawHQ](https://clawhq.dev) — AI Agent Platform
+- [OpenClaw](https://docs.openclaw.ai) — Open-source AI agent framework
+- [Support](https://clawhq.dev/support)

package/bin/clawhq-bridge.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const http = require('http');
+const { execSync } = require('child_process');
+
+const CLAWHQ_API = 'https://clawhq-api-production-f6d7.up.railway.app';
+const BRIDGE_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '.', 'ClawHQ', 'bridge');
+
+// ─── Parse CLI args ───
+const args = process.argv.slice(2);
+const flags = {};
+for (let i = 0; i < args.length; i++) {
+  if (args[i].startsWith('--')) {
+    const key = args[i].replace(/^--/, '');
+    flags[key] = args[i + 1] && !args[i + 1].startsWith('--') ? args[++i] : true;
+  }
+}
+
+if (flags.help || args.includes('-h')) {
+  console.log(`
+  ClawHQ Bridge — Connect your local OpenClaw to ClawHQ
+
+  Usage:
+    npx clawhq-bridge --setup <SETUP_CODE>    First-time setup + run
+    npx clawhq-bridge                          Run with existing config
+    npx clawhq-bridge --status                 Check bridge status
+
+  Options:
+    --setup <code>   Setup code from ClawHQ agent settings
+    --session <key>  OpenClaw session key (default: clawhq:app)
+    --port <port>    OpenClaw gateway port (default: 18789)
+    --status         Check if bridge is configured
+    --help, -h       Show this help
+  `);
+  process.exit(0);
+}
+
+// ─── Setup mode ───
+if (flags.setup) {
+  setup(flags.setup).catch(err => {
+    console.error(`\n❌ Setup failed: ${err.message}`);
+    process.exit(1);
+  });
+} else if (flags.status) {
+  showStatus();
+} else {
+  // Run mode — load config and start
+  run().catch(err => {
+    console.error(`\n❌ ${err.message}`);
+    process.exit(1);
+  });
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Setup — Exchange code, detect OpenClaw, write config, run
+// ═══════════════════════════════════════════════════════════
+
+async function setup(setupCode) {
+  console.log('');
+  console.log('╔══════════════════════════════════════════════════╗');
+  console.log('║        🦞 ClawHQ Bridge — Setup                 ║');
+  console.log('╚══════════════════════════════════════════════════╝');
+  console.log('');
+
+  // 1. Exchange setup code
+  console.log('⏳ Exchanging setup code...');
+  const creds = await exchangeSetupCode(setupCode);
+  console.log(`✅ Agent: ${creds.agentName} (${creds.agentId})`);
+
+  // 2. Detect OpenClaw
+  console.log('');
+  console.log('⏳ Detecting OpenClaw gateway...');
+  const ocConfig = detectOpenClaw();
+  if (ocConfig) {
+    console.log(`✅ Found OpenClaw at port ${ocConfig.port}`);
+    console.log(`   Token: ${ocConfig.token.substring(0, 8)}...`);
+  } else {
+    console.log('⚠️  OpenClaw not detected. Install it from https://docs.openclaw.ai');
+    console.log('   You can still configure the bridge and start OpenClaw later.');
+  }
+
+  // 3. Write config
+  console.log('');
+  console.log(`⏳ Writing config to ${BRIDGE_DIR}/.env`);
+  fs.mkdirSync(BRIDGE_DIR, { recursive: true });
+
+  const sessionKey = flags.session || 'clawhq:app';
+  const port = flags.port || (ocConfig ? ocConfig.port : 18789);
+
+  const envContent = [
+    `# ClawHQ Bridge Config — Auto-generated`,
+    `# Agent: ${creds.agentName}`,
+    `CLAWHQ_URL=${CLAWHQ_API}`,
+    `ACCESS_TOKEN=${creds.accessToken}`,
+    `AGENT_ID=${creds.agentId}`,
+    `OPENCLAW_PORT=${port}`,
+    `OPENCLAW_TOKEN=${ocConfig ? ocConfig.token : 'PASTE_YOUR_TOKEN_HERE'}`,
+    `OPENCLAW_SESSION_KEY=${sessionKey}`,
+  ].join('\n');
+
+  fs.writeFileSync(path.join(BRIDGE_DIR, '.env'), envContent);
+  console.log('✅ Config saved');
+
+  // 4. Start bridge
+  console.log('');
+  console.log('🚀 Starting bridge...');
+  console.log('');
+  await startBridge();
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Run — Load config and start bridge
+// ═══════════════════════════════════════════════════════════
+
+async function run() {
+  const envPath = path.join(BRIDGE_DIR, '.env');
+  if (!fs.existsSync(envPath)) {
+    throw new Error(
+      'Bridge not configured. Run: npx clawhq-bridge --setup <SETUP_CODE>\n' +
+      'Get your setup code from Agent Settings in ClawHQ.'
+    );
+  }
+  loadEnv(envPath);
+  await startBridge();
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Bridge Core — Socket.io ↔ OpenClaw
+// ═══════════════════════════════════════════════════════════
+
+async function startBridge() {
+  const CLAWHQ_URL = process.env.CLAWHQ_URL || CLAWHQ_API;
+  const ACCESS_TOKEN = process.env.ACCESS_TOKEN || '';
+  const AGENT_ID = process.env.AGENT_ID || '';
+  const OPENCLAW_PORT = parseInt(process.env.OPENCLAW_PORT || '18789', 10);
+  const OPENCLAW_TOKEN = process.env.OPENCLAW_TOKEN || '';
+  const SESSION_KEY = process.env.OPENCLAW_SESSION_KEY || 'clawhq:app';
+
+  if (!ACCESS_TOKEN || !AGENT_ID) {
+    throw new Error('Missing credentials. Re-run setup: npx clawhq-bridge --setup <CODE>');
+  }
+
+  console.log('[ClawHQ Bridge] Starting...');
+  console.log(`  ClawHQ:   ${CLAWHQ_URL}`);
+  console.log(`  Agent:    ${AGENT_ID}`);
+  console.log(`  OpenClaw: http://127.0.0.1:${OPENCLAW_PORT}`);
+  console.log(`  Session:  ${SESSION_KEY}`);
+  console.log('');
+
+  const ioClient = require('socket.io-client');
+
+  function sendToOpenClaw(message) {
+    return new Promise((resolve, reject) => {
+      const body = JSON.stringify({
+        model: 'openclaw',
+        messages: [{ role: 'user', content: message }],
+        stream: false,
+      });
+
+      const req = http.request({
+        hostname: '127.0.0.1',
+        port: OPENCLAW_PORT,
+        path: '/v1/chat/completions',
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${OPENCLAW_TOKEN}`,
+          'x-openclaw-session-key': SESSION_KEY,
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: 300000,
+      }, (res) => {
+        let data = '';
+        res.on('data', (chunk) => data += chunk);
+        res.on('end', () => {
+          if (res.statusCode !== 200) {
+            reject(new Error(`OpenClaw ${res.statusCode}: ${data.substring(0, 200)}`));
+            return;
+          }
+          try {
+            const json = JSON.parse(data);
+            const content = json.choices?.[0]?.message?.content || 'No response';
+            resolve(content);
+          } catch (e) {
+            reject(new Error(`Parse error: ${data.substring(0, 200)}`));
+          }
+        });
+      });
+
+      req.on('timeout', () => { req.destroy(); reject(new Error('OpenClaw timeout (5 min)')); });
+      req.on('error', (err) => {
+        if (err.code === 'ECONNREFUSED') {
+          reject(new Error(`OpenClaw not running on port ${OPENCLAW_PORT}. Start it with: openclaw gateway start`));
+        } else {
+          reject(err);
+        }
+      });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  const socket = ioClient(CLAWHQ_URL, {
+    auth: { token: ACCESS_TOKEN },
+    reconnection: true,
+    reconnectionDelay: 5000,
+    reconnectionAttempts: Infinity,
+    transports: ['polling', 'websocket'],
+  });
+
+  socket.on('connect', () => {
+    console.log(`[ClawHQ] Connected (${socket.id})`);
+    socket.emit('bridge:register', { agentId: AGENT_ID });
+  });
+
+  socket.on('bridge:registered', () => {
+    console.log('[ClawHQ] ✅ Bridge registered');
+    console.log('');
+    console.log('╔══════════════════════════════════════════════════╗');
+    console.log('║  ✅ Bridge is running!                           ║');
+    console.log('║  Chat with your agent in the ClawHQ app now.    ║');
+    console.log('║                                                  ║');
+    console.log('║  Press Ctrl+C to stop.                          ║');
+    console.log('╚══════════════════════════════════════════════════╝');
+    console.log('');
+  });
+
+  socket.on('bridge:message', async (data) => {
+    const userMessage = data.content || '';
+    console.log(`[Bridge] → "${userMessage.substring(0, 60)}"`);
+
+    try {
+      const response = await sendToOpenClaw(userMessage);
+      console.log(`[Bridge] ← "${response.substring(0, 80)}"`);
+      socket.emit('bridge:response', {
+        agentId: AGENT_ID,
+        messageId: data.messageId,
+        content: response,
+      });
+    } catch (err) {
+      console.error(`[Bridge] Error:`, err.message);
+      socket.emit('bridge:response', {
+        agentId: AGENT_ID,
+        messageId: data.messageId,
+        content: `❌ ${err.message}`,
+      });
+    }
+  });
+
+  socket.on('bridge:error', (data) => console.error(`[ClawHQ] Error: ${data.message}`));
+  socket.on('disconnect', (reason) => console.log(`[ClawHQ] Disconnected: ${reason}`));
+  socket.on('connect_error', (err) => console.error(`[ClawHQ] Connection error: ${err.message}`));
+
+  // Keep alive
+  process.on('SIGINT', () => {
+    console.log('\n[Bridge] Shutting down...');
+    socket.disconnect();
+    process.exit(0);
+  });
+}
+
+// ═══════════════════════════════════════════════════════════
+//  Helpers
+// ═══════════════════════════════════════════════════════════
+
+function exchangeSetupCode(code) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ setupCode: code });
+    const url = new URL(`${CLAWHQ_API}/api/agents/bridge/exchange`);
+
+    const req = https.request({
+      hostname: url.hostname,
+      port: 443,
+      path: url.pathname,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let data = '';
+      res.on('data', (chunk) => data += chunk);
+      res.on('end', () => {
+        if (res.statusCode !== 200) {
+          try {
+            const err = JSON.parse(data);
+            reject(new Error(err.error || `HTTP ${res.statusCode}`));
+          } catch {
+            reject(new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`));
+          }
+          return;
+        }
+        try {
+          resolve(JSON.parse(data));
+        } catch {
+          reject(new Error('Invalid response from server'));
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.write(body);
+    req.end();
+  });
+}
+
+function detectOpenClaw() {
+  try {
+    const configPaths = [
+      path.join(process.env.HOME || '', '.openclaw', 'openclaw.json'),
+      path.join(process.env.USERPROFILE || '', '.openclaw', 'openclaw.json'),
+    ];
+
+    for (const p of configPaths) {
+      if (fs.existsSync(p)) {
+        const config = JSON.parse(fs.readFileSync(p, 'utf-8'));
+        const port = config.gateway?.port || 18789;
+        const token = config.gateway?.auth?.token || config.gateway?.token || '';
+        if (token) return { port, token };
+      }
+    }
+  } catch {}
+  return null;
+}
+
+function loadEnv(envPath) {
+  fs.readFileSync(envPath, 'utf-8').split('\n').forEach(line => {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) return;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) return;
+    const key = trimmed.substring(0, eqIdx).trim();
+    const val = trimmed.substring(eqIdx + 1).trim();
+    if (key) process.env[key] = val;
+  });
+}
+
+function showStatus() {
+  const envPath = path.join(BRIDGE_DIR, '.env');
+  if (!fs.existsSync(envPath)) {
+    console.log('❌ Bridge not configured.');
+    console.log('   Run: npx clawhq-bridge --setup <SETUP_CODE>');
+    process.exit(1);
+  }
+  loadEnv(envPath);
+  console.log('');
+  console.log('ClawHQ Bridge Status');
+  console.log('────────────────────');
+  console.log(`  Config:   ${envPath}`);
+  console.log(`  Agent:    ${process.env.AGENT_ID || 'not set'}`);
+  console.log(`  Session:  ${process.env.OPENCLAW_SESSION_KEY || 'clawhq:app'}`);
+  console.log(`  OC Port:  ${process.env.OPENCLAW_PORT || '18789'}`);
+  console.log(`  OC Token: ${(process.env.OPENCLAW_TOKEN || '').substring(0, 8)}...`);
+  console.log('');
+
+  // Check OpenClaw
+  const oc = detectOpenClaw();
+  console.log(`  OpenClaw: ${oc ? `✅ Detected (port ${oc.port})` : '❌ Not found'}`);
+  console.log('');
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "clawhq-bridge",
+  "version": "1.0.0",
+  "description": "ClawHQ Bridge — Connect your local OpenClaw agent to ClawHQ",
+  "bin": {
+    "clawhq-bridge": "./bin/clawhq-bridge.js"
+  },
+  "keywords": ["clawhq", "openclaw", "ai", "agent", "bridge"],
+  "author": "ClawHQ <support@clawhq.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Malchiior/clawhq"
+  },
+  "homepage": "https://clawhq.dev",
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "socket.io-client": "^4.7.0"
+  }
+}