openclaw-config-web 1.0.0

package/server.js

@@ -0,0 +1,382 @@
+const express = require('express');
+const fs = require('fs');
+const path = require('path');
+const { exec } = require('child_process');
+const crypto = require('crypto');
+
+function createServer(options = {}) {
+  const app = express();
+  const PORT = options.port || process.env.OPENCLAW_WEB_PORT || 3888;
+  const CONFIG_PATH = options.configPath || path.join(process.env.HOME, '.openclaw', 'openclaw.json');
+  let csrfToken = crypto.randomBytes(32).toString('hex');
+
+  function authenticate(req, res, next) {
+    next();
+  }
+
+  function validateCsrf(req, res, next) {
+    next();
+  }
+
+  app.get('/api/csrf-token', (req, res) => {
+    res.json({ success: true, token: csrfToken });
+  });
+
+  app.use(express.json());
+  
+  const publicPath = path.join(__dirname, 'public');
+  app.use(express.static(publicPath));
+
+  function readConfig() {
+    const content = fs.readFileSync(CONFIG_PATH, 'utf-8');
+    return JSON.parse(content);
+  }
+
+  function writeConfig(config) {
+    const backupPath = CONFIG_PATH + '.bak.' + Date.now();
+    fs.copyFileSync(CONFIG_PATH, backupPath);
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 'utf-8');
+    const backups = fs.readdirSync(path.dirname(CONFIG_PATH))
+      .filter(f => f.startsWith('openclaw.json.bak.'))
+      .sort()
+      .reverse();
+    backups.slice(5).forEach(f => {
+      fs.unlinkSync(path.join(path.dirname(CONFIG_PATH), f));
+    });
+  }
+
+  app.get('/api/config', authenticate, (req, res) => {
+    try {
+      const config = readConfig();
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/config', authenticate, validateCsrf, (req, res) => {
+    try {
+      const config = req.body;
+      if (!config || typeof config !== 'object') {
+        return res.status(400).json({ success: false, error: 'Invalid config format' });
+      }
+      writeConfig(config);
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/switch-model', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { modelId, keepFallback } = req.body;
+      const config = readConfig();
+      const oldFallbacks = config.agents?.defaults?.model?.fallbacks || [];
+      
+      config.agents.defaults.model.primary = modelId;
+      
+      const modelsConfig = { [modelId]: {} };
+      
+      if (keepFallback && oldFallbacks.length > 0) {
+        oldFallbacks.forEach(fb => {
+          if (fb !== modelId) modelsConfig[fb] = {};
+        });
+        config.agents.defaults.model.fallbacks = oldFallbacks.filter(fb => fb !== modelId);
+      } else {
+        config.agents.defaults.model.fallbacks = [];
+      }
+      
+      config.agents.defaults.models = modelsConfig;
+      
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/set-fallback', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { modelId } = req.body;
+      const config = readConfig();
+      const primary = config.agents?.defaults?.model?.primary;
+      
+      if (modelId === primary) {
+        return res.status(400).json({ success: false, error: 'Fallback cannot be same as primary' });
+      }
+      
+      let fallbacks = config.agents?.defaults?.model?.fallbacks || [];
+      if (fallbacks.includes(modelId)) {
+        fallbacks = fallbacks.filter(f => f !== modelId);
+      } else {
+        fallbacks.push(modelId);
+      }
+      
+      config.agents.defaults.model.fallbacks = fallbacks;
+      
+      const modelsConfig = { [primary]: {} };
+      fallbacks.forEach(fb => { modelsConfig[fb] = {}; });
+      config.agents.defaults.models = modelsConfig;
+      
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/add-provider', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { provider } = req.body;
+      const config = readConfig();
+      const providerName = provider.name || `custom_${Date.now()}`;
+      delete provider.name;
+      config.models.providers[providerName] = provider;
+      writeConfig(config);
+      res.json({ success: true, providerName, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/update-provider', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { providerName, provider } = req.body;
+      const config = readConfig();
+      if (!config.models.providers[providerName]) {
+        return res.status(404).json({ success: false, error: 'Provider not found' });
+      }
+      const existing = config.models.providers[providerName];
+      config.models.providers[providerName] = {
+        ...existing,
+        baseUrl: provider.baseUrl || existing.baseUrl,
+        apiKey: provider.apiKey || existing.apiKey,
+        api: provider.api || existing.api,
+        models: existing.models || []
+      };
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/update-model', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { providerName, modelIndex, model } = req.body;
+      const config = readConfig();
+      if (!config.models.providers[providerName]) {
+        return res.status(404).json({ success: false, error: 'Provider not found' });
+      }
+      if (!config.models.providers[providerName].models[modelIndex]) {
+        return res.status(404).json({ success: false, error: 'Model not found' });
+      }
+      const existing = config.models.providers[providerName].models[modelIndex];
+      config.models.providers[providerName].models[modelIndex] = {
+        ...existing,
+        id: model.id || existing.id,
+        name: model.name || existing.name,
+        contextWindow: model.contextWindow ?? existing.contextWindow,
+        maxTokens: model.maxTokens ?? existing.maxTokens,
+        reasoning: model.reasoning ?? existing.reasoning,
+        input: model.input || existing.input,
+        cost: model.cost || existing.cost
+      };
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/add-model', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { providerName, model } = req.body;
+      const config = readConfig();
+      if (!config.models.providers[providerName]) {
+        return res.status(404).json({ success: false, error: 'Provider not found' });
+      }
+      if (!config.models.providers[providerName].models) {
+        config.models.providers[providerName].models = [];
+      }
+      config.models.providers[providerName].models.push(model);
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/delete-model', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { providerName, modelIndex } = req.body;
+      const config = readConfig();
+      if (!config.models.providers[providerName]) {
+        return res.status(404).json({ success: false, error: 'Provider not found' });
+      }
+      config.models.providers[providerName].models.splice(modelIndex, 1);
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/delete-provider', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { providerName } = req.body;
+      const config = readConfig();
+      if (!config.models.providers[providerName]) {
+        return res.status(404).json({ success: false, error: 'Provider not found' });
+      }
+      delete config.models.providers[providerName];
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  function runSystemctl(cmd) {
+    return new Promise((resolve, reject) => {
+      exec(`systemctl --user ${cmd} openclaw-gateway 2>&1`, (error, stdout, stderr) => {
+        if (error && !stdout.includes('Inactive')) {
+          reject(new Error(stdout || stderr || error.message));
+        } else {
+          resolve(stdout);
+        }
+      });
+    });
+  }
+
+  function getServiceStatus() {
+    return new Promise((resolve) => {
+      exec('systemctl --user show openclaw-gateway --property=ActiveState,SubState,MainPID 2>&1', (error, stdout) => {
+        if (error) {
+          resolve({ state: 'unknown', subState: 'unknown', pid: null });
+          return;
+        }
+        const lines = stdout.split('\n');
+        const result = { state: 'unknown', subState: 'unknown', pid: null };
+        for (const line of lines) {
+          if (line.startsWith('ActiveState=')) result.state = line.split('=')[1].trim().toLowerCase();
+          if (line.startsWith('SubState=')) result.subState = line.split('=')[1].trim().toLowerCase();
+          if (line.startsWith('MainPID=')) result.pid = parseInt(line.split('=')[1].trim()) || null;
+        }
+        resolve(result);
+      });
+    });
+  }
+
+  app.get('/api/service/status', authenticate, async (req, res) => {
+    try {
+      const status = await getServiceStatus();
+      res.json({ success: true, data: status });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/update-channels', authenticate, validateCsrf, (req, res) => {
+    try {
+      const { channel, config: channelConfig } = req.body;
+      const config = readConfig();
+      
+      if (!config.channels) {
+        config.channels = {};
+      }
+      
+      config.channels[channel] = {
+        ...config.channels[channel],
+        ...channelConfig
+      };
+      
+      writeConfig(config);
+      res.json({ success: true, data: config });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.get('/api/channels', authenticate, (req, res) => {
+    try {
+      const config = readConfig();
+      res.json({ success: true, data: config.channels || {} });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/service/start', authenticate, validateCsrf, async (req, res) => {
+    try {
+      await runSystemctl('start');
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/service/stop', authenticate, validateCsrf, async (req, res) => {
+    try {
+      await runSystemctl('stop');
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/service/restart', authenticate, validateCsrf, async (req, res) => {
+    try {
+      await runSystemctl('restart');
+      res.json({ success: true });
+    } catch (err) {
+      res.status(500).json({ success: false, error: err.message });
+    }
+  });
+
+  app.post('/api/run-command', authenticate, validateCsrf, (req, res) => {
+    const { command } = req.body;
+    if (!command) {
+      return res.status(400).json({ success: false, error: 'Command is required' });
+    }
+    
+    const safeCommands = [
+      'doctor', 'status', 'configure', 'dashboard', 'tui', 
+      'models list', 'channels', 'logs', 'health',
+      'models', 'skills', 'devices', 'cron', 'update'
+    ];
+    
+    const cmdName = command.split(' ')[0];
+    if (!safeCommands.includes(cmdName) && !safeCommands.some(c => command.startsWith(c))) {
+      return res.status(403).json({ success: false, error: 'Command not allowed' });
+    }
+    
+    exec(`openclaw ${command} 2>&1`, { timeout: 30000 }, (error, stdout, stderr) => {
+      if (error) {
+        res.json({ success: true, output: stderr || error.message });
+      } else {
+        res.json({ success: true, output: stdout });
+      }
+    });
+  });
+
+  return { app, PORT };
+}
+
+function start(options = {}) {
+  const { app, PORT } = createServer(options);
+  return app.listen(PORT, '0.0.0.0', () => {
+    console.log(`OpenClaw 配置管理界面运行在: http://localhost:${PORT}`);
+    const os = require('os');
+    const interfaces = os.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+      for (const iface of interfaces[name]) {
+        if (iface.family === 'IPv4' && !iface.internal) {
+          console.log(`  局域网访问: http://${iface.address}:${PORT}`);
+        }
+      }
+    }
+  });
+}
+
+module.exports = { createServer, start };