openclawapi 1.0.0

package/lib/config-manager.js

@@ -0,0 +1,356 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+class ConfigManager {
+  constructor(configPaths) {
+    this.openclawConfigPath = configPaths.openclawConfig;
+    this.authProfilesPath = configPaths.authProfiles;
+  }
+
+  // 检查配置文件是否存在
+  async checkConfigExists() {
+    return {
+      openclaw: await fs.pathExists(this.openclawConfigPath),
+      auth: await fs.pathExists(this.authProfilesPath)
+    };
+  }
+
+  // 读取 openclaw.json
+  async readOpenclawConfig() {
+    try {
+      return await fs.readJson(this.openclawConfigPath);
+    } catch (error) {
+      throw new Error(`读取配置文件失败: ${error.message}`);
+    }
+  }
+
+  // 写入 openclaw.json
+  async writeOpenclawConfig(config) {
+    try {
+      await fs.writeJson(this.openclawConfigPath, config, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`写入配置文件失败: ${error.message}`);
+    }
+  }
+
+  // 读取 auth-profiles.json
+  async readAuthProfiles() {
+    try {
+      if (await fs.pathExists(this.authProfilesPath)) {
+        return await fs.readJson(this.authProfilesPath);
+      }
+      return {};
+    } catch (error) {
+      throw new Error(`读取认证文件失败: ${error.message}`);
+    }
+  }
+
+  // 写入 auth-profiles.json
+  async writeAuthProfiles(profiles) {
+    try {
+      await fs.ensureDir(path.dirname(this.authProfilesPath));
+      await fs.writeJson(this.authProfilesPath, profiles, { spaces: 2 });
+    } catch (error) {
+      throw new Error(`写入认证文件失败: ${error.message}`);
+    }
+  }
+
+  // 添加中转站
+  async addRelay(relayConfig) {
+    const config = await this.readOpenclawConfig();
+
+    const providerName = relayConfig.name;
+    const profileKey = `${providerName}:default`;
+
+    // 添加到 models.providers
+    if (!config.models) config.models = {};
+    if (!config.models.providers) config.models.providers = {};
+
+    config.models.providers[providerName] = {
+      baseUrl: relayConfig.baseUrl,
+      auth: 'api-key',
+      api: 'openai-completions',
+      models: [
+        {
+          id: relayConfig.model.id,
+          name: relayConfig.model.name,
+          reasoning: false,
+          input: ['text', 'image'],
+          cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0
+          },
+          contextWindow: relayConfig.model.contextWindow,
+          maxTokens: relayConfig.model.maxTokens
+        }
+      ]
+    };
+
+    // 添加到 auth.profiles
+    if (!config.auth) config.auth = {};
+    if (!config.auth.profiles) config.auth.profiles = {};
+
+    config.auth.profiles[profileKey] = {
+      provider: providerName,
+      mode: 'api_key'
+    };
+
+    await this.writeOpenclawConfig(config);
+  }
+
+  // 列出所有中转站
+  async listRelays() {
+    const config = await this.readOpenclawConfig();
+    const relays = [];
+
+    if (config.models && config.models.providers) {
+      for (const [name, provider] of Object.entries(config.models.providers)) {
+        if (provider.models && provider.models.length > 0) {
+          const model = provider.models[0];
+          relays.push({
+            name,
+            baseUrl: provider.baseUrl,
+            modelId: model.id,
+            modelName: model.name,
+            contextWindow: model.contextWindow,
+            maxTokens: model.maxTokens
+          });
+        }
+      }
+    }
+
+    return relays;
+  }
+
+  // 更新中转站
+  async updateRelay(relayName, updates) {
+    const config = await this.readOpenclawConfig();
+
+    if (!config.models?.providers?.[relayName]) {
+      throw new Error(`中转站 "${relayName}" 不存在`);
+    }
+
+    const provider = config.models.providers[relayName];
+
+    if (updates.baseUrl) {
+      provider.baseUrl = updates.baseUrl;
+    }
+
+    if (provider.models && provider.models.length > 0) {
+      if (updates.contextWindow) {
+        provider.models[0].contextWindow = updates.contextWindow;
+      }
+      if (updates.maxTokens) {
+        provider.models[0].maxTokens = updates.maxTokens;
+      }
+    }
+
+    await this.writeOpenclawConfig(config);
+  }
+
+  // 删除中转站
+  async deleteRelay(relayName) {
+    const config = await this.readOpenclawConfig();
+
+    // 删除 provider
+    if (config.models?.providers?.[relayName]) {
+      delete config.models.providers[relayName];
+    }
+
+    // 删除 auth profile
+    const profileKey = `${relayName}:default`;
+    if (config.auth?.profiles?.[profileKey]) {
+      delete config.auth.profiles[profileKey];
+    }
+
+    // 从 agents.defaults.models 中删除
+    if (config.agents?.defaults?.models) {
+      for (const key of Object.keys(config.agents.defaults.models)) {
+        if (key.startsWith(`${relayName}/`)) {
+          delete config.agents.defaults.models[key];
+        }
+      }
+    }
+
+    // 如果是主模型，需要切换到其他模型
+    if (config.agents?.defaults?.model?.primary?.startsWith(`${relayName}/`)) {
+      const remainingRelays = await this.listRelays();
+      if (remainingRelays.length > 0) {
+        const firstRelay = remainingRelays[0];
+        config.agents.defaults.model.primary = `${firstRelay.name}/${firstRelay.modelId}`;
+      }
+    }
+
+    // 从 fallbacks 中删除
+    if (config.agents?.defaults?.model?.fallbacks) {
+      config.agents.defaults.model.fallbacks = config.agents.defaults.model.fallbacks.filter(
+        f => !f.startsWith(`${relayName}/`)
+      );
+    }
+
+    await this.writeOpenclawConfig(config);
+
+    // 删除 API Key
+    const authProfiles = await this.readAuthProfiles();
+    if (authProfiles[profileKey]) {
+      delete authProfiles[profileKey];
+      await this.writeAuthProfiles(authProfiles);
+    }
+  }
+
+  // 获取主模型
+  async getPrimaryModel() {
+    const config = await this.readOpenclawConfig();
+    const primary = config.agents?.defaults?.model?.primary || '';
+    const [provider, modelId] = primary.split('/');
+    return { provider, modelId, full: primary };
+  }
+
+  // 设置主模型
+  async setPrimaryModel(relayName) {
+    const config = await this.readOpenclawConfig();
+    const relays = await this.listRelays();
+    const relay = relays.find(r => r.name === relayName);
+
+    if (!relay) {
+      throw new Error(`中转站 "${relayName}" 不存在`);
+    }
+
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+    if (!config.agents.defaults.model) config.agents.defaults.model = {};
+
+    config.agents.defaults.model.primary = `${relayName}/${relay.modelId}`;
+
+    // 确保在 models 中注册
+    if (!config.agents.defaults.models) config.agents.defaults.models = {};
+    const modelKey = `${relayName}/${relay.modelId}`;
+    if (!config.agents.defaults.models[modelKey]) {
+      config.agents.defaults.models[modelKey] = {
+        alias: relayName
+      };
+    }
+
+    await this.writeOpenclawConfig(config);
+  }
+
+  // 获取备用模型
+  async getFallbackModels() {
+    const config = await this.readOpenclawConfig();
+    return config.agents?.defaults?.model?.fallbacks || [];
+  }
+
+  // 设置备用模型
+  async setFallbackModels(models) {
+    const config = await this.readOpenclawConfig();
+
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+    if (!config.agents.defaults.model) config.agents.defaults.model = {};
+
+    config.agents.defaults.model.fallbacks = models;
+
+    // 确保所有模型都在 models 中注册
+    if (!config.agents.defaults.models) config.agents.defaults.models = {};
+    for (const modelKey of models) {
+      if (!config.agents.defaults.models[modelKey]) {
+        const [provider] = modelKey.split('/');
+        config.agents.defaults.models[modelKey] = {
+          alias: provider
+        };
+      }
+    }
+
+    await this.writeOpenclawConfig(config);
+  }
+
+  // 设置 API Key
+  async setApiKey(relayName, apiKey) {
+    const authProfiles = await this.readAuthProfiles();
+    const profileKey = `${relayName}:default`;
+
+    authProfiles[profileKey] = {
+      apiKey: apiKey
+    };
+
+    await this.writeAuthProfiles(authProfiles);
+  }
+
+  // 列出所有 API Keys
+  async listApiKeys() {
+    const authProfiles = await this.readAuthProfiles();
+    const keys = [];
+
+    for (const [profile, data] of Object.entries(authProfiles)) {
+      keys.push({
+        provider: profile,
+        key: data.apiKey || null
+      });
+    }
+
+    return keys;
+  }
+
+  // 删除 API Key
+  async deleteApiKey(provider) {
+    const authProfiles = await this.readAuthProfiles();
+
+    if (authProfiles[provider]) {
+      delete authProfiles[provider];
+      await this.writeAuthProfiles(authProfiles);
+    }
+  }
+
+  // 获取高级设置
+  async getAdvancedSettings() {
+    const config = await this.readOpenclawConfig();
+    return {
+      maxConcurrent: config.agents?.defaults?.maxConcurrent || 4,
+      subagentMaxConcurrent: config.agents?.defaults?.subagents?.maxConcurrent || 8,
+      workspace: config.agents?.defaults?.workspace || ''
+    };
+  }
+
+  // 设置高级设置
+  async setAdvancedSettings(settings) {
+    const config = await this.readOpenclawConfig();
+
+    if (!config.agents) config.agents = {};
+    if (!config.agents.defaults) config.agents.defaults = {};
+
+    if (settings.maxConcurrent !== undefined) {
+      config.agents.defaults.maxConcurrent = settings.maxConcurrent;
+    }
+
+    if (settings.subagentMaxConcurrent !== undefined) {
+      if (!config.agents.defaults.subagents) config.agents.defaults.subagents = {};
+      config.agents.defaults.subagents.maxConcurrent = settings.subagentMaxConcurrent;
+    }
+
+    if (settings.workspace) {
+      config.agents.defaults.workspace = settings.workspace;
+    }
+
+    await this.writeOpenclawConfig(config);
+  }
+
+  // 获取当前完整配置
+  async getCurrentConfig() {
+    const config = await this.readOpenclawConfig();
+    const relays = await this.listRelays();
+    const primary = await this.getPrimaryModel();
+    const fallbacks = await this.getFallbackModels();
+    const advanced = await this.getAdvancedSettings();
+
+    return {
+      primary: primary.full,
+      fallbacks,
+      relays,
+      advanced
+    };
+  }
+}
+
+module.exports = { ConfigManager };

package/lib/speed-test.js

@@ -0,0 +1,88 @@
+const https = require('https');
+const http = require('http');
+
+// 测试 URL 的响应时间
+async function testSpeed(url) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    const urlObj = new URL(url);
+    const protocol = urlObj.protocol === 'https:' ? https : http;
+
+    const timeout = 5000; // 5秒超时
+
+    const req = protocol.get(url, { timeout }, (res) => {
+      const endTime = Date.now();
+      const latency = endTime - startTime;
+
+      // 读取响应数据（避免连接挂起）
+      res.on('data', () => {});
+      res.on('end', () => {
+        resolve({
+          success: true,
+          latency,
+          statusCode: res.statusCode
+        });
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy();
+      resolve({
+        success: false,
+        latency: timeout,
+        error: '超时'
+      });
+    });
+
+    req.on('error', (error) => {
+      const endTime = Date.now();
+      resolve({
+        success: false,
+        latency: endTime - startTime,
+        error: error.message
+      });
+    });
+  });
+}
+
+// 测试多个中转站的速度
+async function testMultipleRelays(relays) {
+  const results = [];
+
+  for (const relay of relays) {
+    // 构建测试 URL（去掉 /v1 后缀，只测试基础域名）
+    const baseUrl = relay.baseUrl.replace(/\/v1$/, '');
+    const testUrl = baseUrl;
+
+    const result = await testSpeed(testUrl);
+    results.push({
+      name: relay.name,
+      url: relay.baseUrl,
+      ...result
+    });
+  }
+
+  return results;
+}
+
+// 根据速度排序中转站
+function sortBySpeed(results) {
+  return results
+    .filter(r => r.success)
+    .sort((a, b) => a.latency - b.latency);
+}
+
+// 格式化延迟显示
+function formatLatency(latency) {
+  if (latency < 100) return 'excellent';
+  if (latency < 300) return 'good';
+  if (latency < 1000) return 'fair';
+  return 'poor';
+}
+
+module.exports = {
+  testSpeed,
+  testMultipleRelays,
+  sortBySpeed,
+  formatLatency
+};

package/lib/ui.js

@@ -0,0 +1,38 @@
+const chalk = require('chalk');
+
+// 显示菜单
+function displayMenu(title, options) {
+  console.log(chalk.cyan.bold(`\n${title}\n`));
+  options.forEach((opt, index) => {
+    console.log(`  ${chalk.yellow(index + 1)}. ${opt}`);
+  });
+  console.log();
+}
+
+// 显示成功消息
+function displaySuccess(message) {
+  console.log(chalk.green(`\n${message}\n`));
+}
+
+// 显示错误消息
+function displayError(message) {
+  console.log(chalk.red(`\n❌ ${message}\n`));
+}
+
+// 显示信息消息
+function displayInfo(message) {
+  console.log(chalk.blue(`\nℹ️  ${message}\n`));
+}
+
+// 显示警告消息
+function displayWarning(message) {
+  console.log(chalk.yellow(`\n⚠️  ${message}\n`));
+}
+
+module.exports = {
+  displayMenu,
+  displaySuccess,
+  displayError,
+  displayInfo,
+  displayWarning
+};

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "openclawapi",
+  "version": "1.0.0",
+  "description": "跨平台 OpenClaw/Clawdbot 配置管理工具 - 管理中转地址、模型切换、API Keys、测速优化",
+  "main": "cli.js",
+  "bin": {
+    "openclawapi": "./cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js",
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "openclaw",
+    "clawdbot",
+    "config",
+    "cli",
+    "api-relay",
+    "model-management",
+    "speed-test"
+  ],
+  "author": "OpenClaw Community",
+  "license": "MIT",
+  "files": [
+    "cli.js",
+    "lib/",
+    "README.md"
+  ],
+  "dependencies": {
+    "inquirer": "^8.2.5",
+    "chalk": "^4.1.2",
+    "fs-extra": "^11.1.1"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "preferGlobal": true
+}