@tokenaut/opentoken 1.3.5 → 1.4.0

package/src/config.js

@@ -1,8 +1,8 @@
 'use strict';
 
 const fs = require('fs');
-const os = require('os');
 const path = require('path');
+const os = require('os');
 
 const SETTINGS_PATH = path.join(os.homedir(), '.claude', 'settings.json');
 
@@ -25,21 +25,15 @@ function readClaudeSettings() {
     if (!fs.existsSync(SETTINGS_PATH)) {
       return {};
     }
-
     const raw = fs.readFileSync(SETTINGS_PATH, 'utf-8');
     const parsed = JSON.parse(raw);
-
     if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
       throw new Error('settings.json 内容格式不合法');
     }
-
     return parsed;
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      return {};
-    }
-
-    throw error;
+  } catch (e) {
+    if (e.code === 'ENOENT') return {};
+    throw e;
   }
 }
 
@@ -48,43 +42,50 @@ function writeClaudeSettings(settings) {
   if (!fs.existsSync(dir)) {
     fs.mkdirSync(dir, { recursive: true });
   }
-
   fs.writeFileSync(SETTINGS_PATH, JSON.stringify(settings, null, 2), 'utf-8');
 }
 
-function applyConfig(patch) {
+function getCurrentConfig() {
   const settings = readClaudeSettings();
+  const env = settings.env || {};
+  const apiKey =
+    env['ANTHROPIC_AUTH_TOKEN'] ||
+    env['ANTHROPIC_API_KEY'] ||
+    '';
+  return {
+    apiKey,
+    baseUrl: env['ANTHROPIC_BASE_URL'] || '',
+    model: env['ANTHROPIC_MODEL'] || '',
+  };
+}
 
-  if (!settings.env || typeof settings.env !== 'object' || Array.isArray(settings.env)) {
-    settings.env = {};
-  }
-
-  if (patch.apiKey !== undefined) {
-    settings.env.ANTHROPIC_AUTH_TOKEN = patch.apiKey;
-    settings.env.ANTHROPIC_API_KEY = '';
-  }
+function applyConfig({ apiKey, baseUrl, model }) {
+  const settings = readClaudeSettings();
 
-  if (patch.baseUrl !== undefined) {
-    settings.env.ANTHROPIC_BASE_URL = patch.baseUrl;
+  if (!settings.env) {
+    settings.env = {};
   }
 
-  if (patch.model !== undefined) {
-    settings.env.ANTHROPIC_MODEL = patch.model;
+  if (apiKey !== undefined) {
+    settings.env['ANTHROPIC_AUTH_TOKEN'] = apiKey;
+    settings.env['ANTHROPIC_API_KEY'] = '';
   }
 
-  if (patch.sonnetModel !== undefined) {
-    settings.env.ANTHROPIC_DEFAULT_SONNET_MODEL = patch.sonnetModel;
+  if (baseUrl !== undefined) {
+    settings.env['ANTHROPIC_BASE_URL'] = baseUrl;
   }
 
-  if (patch.haikuModel !== undefined) {
-    settings.env.ANTHROPIC_DEFAULT_HAIKU_MODEL = patch.haikuModel;
+  if (model !== undefined) {
+    settings.env['ANTHROPIC_MODEL'] = model;
   }
 
   mergeDefaultClaudeAuxEnv(settings.env);
+
   writeClaudeSettings(settings);
 }
 
 module.exports = {
   SETTINGS_PATH,
+  getCurrentConfig,
   applyConfig,
 };

package/src/fetch-models.js

@@ -0,0 +1,228 @@
+'use strict';
+
+const http = require('http');
+const https = require('https');
+const { URL } = require('url');
+
+const DEFAULT_TIMEOUT_MS = 20000;
+const MAX_REDIRECTS = 5;
+
+const MODEL_LIST_PATHS = ['/v1/models', '/models'];
+
+function joinUrl(baseUrl, path) {
+  const base = String(baseUrl || '').replace(/\/+$/, '');
+  const p = path.startsWith('/') ? path : '/' + path;
+  return base + p;
+}
+
+function buildHeaders(token, baseUrl) {
+  const headers = {
+    Accept: 'application/json',
+    'Accept-Language': 'zh-CN,zh;q=0.9',
+    'Cache-Control': 'no-cache',
+    Pragma: 'no-cache',
+    'User-Agent': 'opentoken-cli/1.0',
+  };
+
+  if (baseUrl) {
+    try {
+      const u = new URL(baseUrl);
+      headers.Origin = `${u.protocol}//${u.host}`;
+    } catch (_) {
+      /* ignore */
+    }
+  }
+
+  if (token && String(token).trim()) {
+    headers.Authorization = `Bearer ${String(token).trim()}`;
+  }
+
+  return headers;
+}
+
+function requestOnce(urlStr, headers, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let u;
+    try {
+      u = new URL(urlStr);
+    } catch (e) {
+      return reject(new Error('无效的 Base URL'));
+    }
+
+    const lib = u.protocol === 'https:' ? https : http;
+    const port = u.port || (u.protocol === 'https:' ? 443 : 80);
+
+    const req = lib.request(
+      {
+        hostname: u.hostname,
+        port,
+        path: u.pathname + u.search,
+        method: 'GET',
+        headers,
+        timeout: timeoutMs || DEFAULT_TIMEOUT_MS,
+      },
+      (res) => {
+        const chunks = [];
+        res.on('data', (c) => chunks.push(c));
+        res.on('end', () => {
+          const body = Buffer.concat(chunks).toString('utf8');
+          resolve({ statusCode: res.statusCode || 0, headers: res.headers, body });
+        });
+      }
+    );
+
+    req.on('timeout', () => {
+      req.destroy();
+      reject(new Error('请求超时'));
+    });
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function requestWithRedirects(urlStr, headers, redirectCount) {
+  const { statusCode, headers: resHeaders, body } = await requestOnce(
+    urlStr,
+    headers,
+    DEFAULT_TIMEOUT_MS
+  );
+
+  if (statusCode >= 300 && statusCode < 400 && resHeaders.location) {
+    if (redirectCount >= MAX_REDIRECTS) {
+      throw new Error('重定向次数过多');
+    }
+    const next = new URL(resHeaders.location, urlStr).href;
+    return requestWithRedirects(next, headers, redirectCount + 1);
+  }
+
+  return { statusCode, body };
+}
+
+function extractRawList(json) {
+  if (json == null) return [];
+  if (Array.isArray(json)) return json;
+  if (Array.isArray(json.data)) return json.data;
+  if (Array.isArray(json.models)) return json.models;
+  if (Array.isArray(json.result)) return json.result;
+  if (Array.isArray(json.list)) return json.list;
+  if (Array.isArray(json.items)) return json.items;
+  return [];
+}
+
+function normalizeModelId(entry) {
+  if (typeof entry === 'string') {
+    const s = entry.trim();
+    return s || null;
+  }
+  if (entry && typeof entry === 'object') {
+    const id =
+      entry.id ||
+      entry.model ||
+      entry.name ||
+      entry.model_id ||
+      entry.modelId ||
+      entry.value;
+    if (typeof id === 'string' && id.trim()) return id.trim();
+  }
+  return null;
+}
+
+function normalizeEndpointTypes(types) {
+  if (Array.isArray(types)) {
+    return types.map((t) => String(t).trim().toLowerCase()).filter(Boolean);
+  }
+  if (typeof types === 'string' && types.trim()) {
+    const s = types.trim();
+    if (s.startsWith('[') && s.endsWith(']')) {
+      try {
+        return normalizeEndpointTypes(JSON.parse(s));
+      } catch (_) {
+        // fall through to comma-separated parsing
+      }
+    }
+    return s.split(',').map((t) => t.trim().toLowerCase()).filter(Boolean);
+  }
+  return [];
+}
+
+function getSupportedEndpointTypes(entry) {
+  if (!entry || typeof entry !== 'object') return [];
+  return normalizeEndpointTypes(
+    entry.supported_endpoint_types ||
+      entry.supportedEndpointTypes ||
+      entry.endpoint_types ||
+      entry.endpointTypes,
+  );
+}
+
+function isEndpointCompatible(entry, endpointType, allowMissingTypes) {
+  if (typeof entry === 'string') return allowMissingTypes;
+  if (!entry || typeof entry !== 'object') return false;
+
+  const types = getSupportedEndpointTypes(entry);
+  if (types.length === 0) return allowMissingTypes;
+  return types.includes(String(endpointType || '').trim().toLowerCase());
+}
+
+function parseModelsFromBody(body, options = {}) {
+  const {
+    filterAnthropicCompatible = false,
+    requiredEndpointType = '',
+    allowMissingEndpointTypes,
+  } = options;
+  const trimmed = String(body || '').trim();
+  if (!trimmed) return [];
+  let json;
+  try {
+    json = JSON.parse(trimmed);
+  } catch {
+    return [];
+  }
+  const raw = extractRawList(json);
+  let list = raw;
+  if (filterAnthropicCompatible) {
+    list = list.filter((entry) => isEndpointCompatible(entry, 'anthropic', true));
+  } else if (requiredEndpointType) {
+    const allowMissing =
+      allowMissingEndpointTypes === undefined ? false : Boolean(allowMissingEndpointTypes);
+    list = list.filter((entry) => isEndpointCompatible(entry, requiredEndpointType, allowMissing));
+  }
+  const ids = list.map(normalizeModelId).filter(Boolean);
+  return [...new Set(ids)];
+}
+
+async function fetchModelsForBaseUrl(baseUrl, token, options = {}) {
+  const base = String(baseUrl || '').trim();
+  if (!base) {
+    return { ok: false, models: [], error: '未配置 Base URL' };
+  }
+
+  const headers = buildHeaders(token, base);
+  let lastErr = '';
+
+  for (const p of MODEL_LIST_PATHS) {
+    const url = joinUrl(base, p);
+    try {
+      const { statusCode, body } = await requestWithRedirects(url, headers, 0);
+      if (statusCode !== 200) {
+        lastErr = `HTTP ${statusCode} (${url})`;
+        continue;
+      }
+      const models = parseModelsFromBody(body, options);
+      if (models.length > 0) {
+        return { ok: true, models, endpoint: url };
+      }
+      lastErr = `响应中无模型列表 (${url})`;
+    } catch (e) {
+      lastErr = e.message || String(e);
+    }
+  }
+
+  return { ok: false, models: [], error: lastErr || '无法获取模型列表' };
+}
+
+module.exports = {
+  fetchModelsForBaseUrl,
+  joinUrl,
+  MODEL_LIST_PATHS,
+};

package/src/hermes-config.js

@@ -0,0 +1,157 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const yaml = require('js-yaml');
+const {
+  HERMES_OPENTOKEN_BASE_URL,
+  HERMES_DEFAULT_MODEL,
+} = require('./models');
+
+const HERMES_DIR = path.join(os.homedir(), '.hermes');
+const CONFIG_YAML_PATH = path.join(HERMES_DIR, 'config.yaml');
+const ENV_PATH = path.join(HERMES_DIR, '.env');
+
+function readEnvFile(envPath) {
+  if (!fs.existsSync(envPath)) {
+    return {};
+  }
+  const raw = fs.readFileSync(envPath, 'utf-8');
+  const out = {};
+  for (const line of raw.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eq = trimmed.indexOf('=');
+    if (eq <= 0) continue;
+    const k = trimmed.slice(0, eq).trim();
+    let v = trimmed.slice(eq + 1).trim();
+    if (
+      (v.startsWith('"') && v.endsWith('"')) ||
+      (v.startsWith("'") && v.endsWith("'"))
+    ) {
+      v = v.slice(1, -1);
+    }
+    out[k] = v;
+  }
+  return out;
+}
+
+function mergeEnvKey(raw, key, value) {
+  const lines = String(raw || '').split(/\r?\n/);
+  const assignment = `${key}=${value}`;
+  let found = false;
+  const next = lines.map((line) => {
+    const t = line.trim();
+    if (!t || t.startsWith('#')) return line;
+    const eq = t.indexOf('=');
+    if (eq <= 0) return line;
+    const k = t.slice(0, eq).trim();
+    if (k === key) {
+      found = true;
+      return assignment;
+    }
+    return line;
+  });
+  if (!found) {
+    if (!String(raw || '').trim()) {
+      return assignment + '\n';
+    }
+    if (next.length && next[next.length - 1] !== '') {
+      next.push('');
+    }
+    next.push(assignment);
+  }
+  const body = next.join('\n');
+  return body.endsWith('\n') ? body : body + '\n';
+}
+
+function readYamlRoot() {
+  if (!fs.existsSync(CONFIG_YAML_PATH)) {
+    return {};
+  }
+  const raw = fs.readFileSync(CONFIG_YAML_PATH, 'utf-8');
+  if (!String(raw).trim()) {
+    return {};
+  }
+  const data = yaml.load(raw);
+  if (data === null || typeof data !== 'object' || Array.isArray(data)) {
+    throw new Error('config.yaml 根节点必须是映射（YAML mapping）');
+  }
+  return data;
+}
+
+function getCurrentHermesConfig() {
+  let modelId = '';
+  let baseUrl = '';
+  let provider = '';
+  try {
+    const data = readYamlRoot();
+    const m = data.model;
+    if (m && typeof m === 'object' && !Array.isArray(m)) {
+      if (m.default != null) modelId = String(m.default);
+      if (m.base_url != null) baseUrl = String(m.base_url);
+      if (m.provider != null) provider = String(m.provider);
+    }
+  } catch (_) {
+    /* 损坏时由 getCurrent 返回空，apply 时再报错 */
+  }
+  const envMap = readEnvFile(ENV_PATH);
+  const apiKey = envMap['OPENTOKEN_API_KEY'] || '';
+  return { apiKey, model: modelId, baseUrl, provider };
+}
+
+function applyHermesConfig(patch) {
+  const { apiKey, model } = patch || {};
+
+  let data;
+  try {
+    data = readYamlRoot();
+  } catch (e) {
+    throw new Error(
+      '现有 config.yaml 无法解析，请先备份后手动修复：' + e.message,
+    );
+  }
+
+  if (!data.model || typeof data.model !== 'object' || Array.isArray(data.model)) {
+    data.model = {};
+  }
+
+  data.model.provider = 'custom';
+  data.model.base_url = HERMES_OPENTOKEN_BASE_URL;
+
+  if (model !== undefined) {
+    data.model.default = model;
+  } else if (data.model.default == null || data.model.default === '') {
+    data.model.default = HERMES_DEFAULT_MODEL;
+  }
+
+  if (!fs.existsSync(HERMES_DIR)) {
+    fs.mkdirSync(HERMES_DIR, { recursive: true });
+  }
+
+  const yamlOut = yaml.dump(data, {
+    indent: 2,
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+  });
+  fs.writeFileSync(CONFIG_YAML_PATH, yamlOut, 'utf-8');
+
+  if (apiKey !== undefined) {
+    let prev = '';
+    if (fs.existsSync(ENV_PATH)) {
+      prev = fs.readFileSync(ENV_PATH, 'utf-8');
+    }
+    const merged = mergeEnvKey(prev, 'OPENTOKEN_API_KEY', apiKey);
+    fs.writeFileSync(ENV_PATH, merged, 'utf-8');
+  }
+}
+
+module.exports = {
+  HERMES_DIR,
+  CONFIG_YAML_PATH,
+  ENV_PATH,
+  getCurrentHermesConfig,
+  applyHermesConfig,
+};

package/src/logo.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const chalk = require('chalk');
+const stringWidth = require('string-width');
+
+const LOGO_LINES = [
+  '  ████████╗ ██████╗ ██╗  ██╗███████╗███╗  ██╗  ',
+  '     ██║   ██╔═══██╗██║ ██╔╝██╔════╝████╗ ██║  ',
+  '     ██║   ██║   ██║█████╔╝ █████╗  ██╔██╗██║  ',
+  '     ██║   ██║   ██║██╔═██╗ ██╔══╝  ██║╚████║  ',
+  '     ██║   ╚██████╔╝██║  ██╗███████╗██║ ╚███║  ',
+  '     ╚═╝    ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚══╝  ',
+];
+
+function padToDisplayWidth(str, targetCols) {
+  let s = str;
+  while (stringWidth(s) < targetCols) {
+    s += ' ';
+  }
+  return s;
+}
+
+function splitAtDisplayHalf(str, totalDisplayWidth) {
+  const half = totalDisplayWidth / 2;
+  let acc = 0;
+  let i = 0;
+  while (i < str.length) {
+    const cp = str.codePointAt(i);
+    const ch = String.fromCodePoint(cp);
+    const w = stringWidth(ch);
+    if (acc + w > half) break;
+    acc += w;
+    i += ch.length;
+  }
+  return { left: str.slice(0, i), right: str.slice(i) };
+}
+
+function printLogo() {
+  const logoDisplayWidths = LOGO_LINES.map((l) => stringWidth(l));
+  const innerWidth = Math.max(...logoDisplayWidths);
+
+  const border = '═'.repeat(innerWidth);
+
+  console.log('');
+  console.log(chalk.cyan('╔' + border + '╗'));
+
+  for (const line of LOGO_LINES) {
+    const padded = padToDisplayWidth(line, innerWidth);
+    const { left, right } = splitAtDisplayHalf(padded, innerWidth);
+    console.log(
+      chalk.cyan('║') +
+        chalk.bold(chalk.hex('#c084fc')(left)) +
+        chalk.bold(chalk.white(right)) +
+        chalk.cyan('║')
+    );
+  }
+
+  console.log(chalk.cyan('╚' + border + '╝'));
+  console.log('');
+}
+
+module.exports = { printLogo };

package/src/models.js

@@ -0,0 +1,61 @@
+'use strict';
+
+const DEFAULT_BASE_URL = 'https://gw.opentoken.io';
+
+const ATOMCODE_OPENTOKEN_BASE_URL = 'https://gw.opentoken.io/v1';
+
+const ATOMCODE_CONTEXT_WINDOW = 200000;
+
+const HERMES_OPENTOKEN_BASE_URL = 'https://gw.opentoken.io/v1';
+
+const HERMES_DEFAULT_MODEL = 'claude-sonnet-4-5-20250929';
+
+const OPENCLAW_OPENTOKEN_BASE_URL = 'https://gw.opentoken.io/v1';
+
+const OPENCLAW_PROVIDER_KEY = 'opentoken';
+
+const OPENCLAW_DEFAULT_MODEL = HERMES_DEFAULT_MODEL;
+
+const OPENCODE_OPENTOKEN_BASE_URL = 'https://gw.opentoken.io/v1';
+
+const OPENCODE_PROVIDER_KEY = 'opentoken';
+
+const OPENCODE_DEFAULT_MODEL = HERMES_DEFAULT_MODEL;
+
+const CODEX_OPENTOKEN_BASE_URL = 'https://gw.opentoken.io/v1';
+
+const CODEX_PROVIDER_KEY = 'opentoken';
+
+const CODEX_AUTH_KEY = 'OPENAI_API_KEY';
+
+const CODEX_DEFAULT_MODEL = 'gpt-5.4';
+
+const API_NODES = [
+  {
+    name: 'opentoken 默认节点 - https://gw.opentoken.io',
+    value: 'https://gw.opentoken.io',
+  },
+  {
+    name: '自定义 Base URL...',
+    value: '__custom__',
+  },
+];
+
+module.exports = {
+  API_NODES,
+  DEFAULT_BASE_URL,
+  ATOMCODE_OPENTOKEN_BASE_URL,
+  ATOMCODE_CONTEXT_WINDOW,
+  HERMES_OPENTOKEN_BASE_URL,
+  HERMES_DEFAULT_MODEL,
+  OPENCLAW_OPENTOKEN_BASE_URL,
+  OPENCLAW_PROVIDER_KEY,
+  OPENCLAW_DEFAULT_MODEL,
+  OPENCODE_OPENTOKEN_BASE_URL,
+  OPENCODE_PROVIDER_KEY,
+  OPENCODE_DEFAULT_MODEL,
+  CODEX_OPENTOKEN_BASE_URL,
+  CODEX_PROVIDER_KEY,
+  CODEX_AUTH_KEY,
+  CODEX_DEFAULT_MODEL,
+};