mirror of
https://github.com/kiddin9/op-packages.git
synced 2026-11-18 22:43:00 +08:00
2151 lines
96 KiB
JavaScript
2151 lines
96 KiB
JavaScript
#!/usr/bin/env node
|
||
/**
|
||
* ============================================================================
|
||
* OpenClaw 配置工具 — 交互式菜单前端
|
||
* ============================================================================
|
||
*
|
||
* 功能特性:
|
||
* - 方向键 (↑↓) 导航菜单选项 (使用 oc-menu-engine 引擎)
|
||
* - 回车/空格 确认选择
|
||
* - 实时搜索过滤
|
||
* - 与 oc-config.sh 业务逻辑完全一致
|
||
* - 纯 Node.js 实现,零外部依赖
|
||
* - 完全兼容 xterm.js / Web PTY 环境
|
||
*/
|
||
|
||
const path = require('path');
|
||
const fs = require('fs');
|
||
const { spawn, spawnSync, execSync, execFileSync } = require('child_process');
|
||
const menu = require('./oc-menu-engine');
|
||
const { C, select, input, confirm, spinner, resetRenderCount } = menu;
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 配置路径 (与 oc-config.sh 保持一致)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const OC_BASE_PATH = process.env.OC_BASE_PATH || '/opt';
|
||
const OC_INSTALL_PATH = process.env.OC_INSTALL_PATH || `${OC_BASE_PATH}/openclaw`;
|
||
const NODE_BASE = process.env.NODE_BASE || `${OC_INSTALL_PATH}/node`;
|
||
const OC_GLOBAL = process.env.OC_GLOBAL || `${OC_INSTALL_PATH}/global`;
|
||
const OC_DATA = process.env.OC_DATA || `${OC_INSTALL_PATH}/data`;
|
||
const OC_STATE_DIR = process.env.OPENCLAW_STATE_DIR || `${OC_DATA}/.openclaw`;
|
||
const CONFIG_FILE = process.env.OPENCLAW_CONFIG_PATH || `${OC_STATE_DIR}/openclaw.json`;
|
||
const NODE_BIN = `${NODE_BASE}/bin/node`;
|
||
const PERMISSIONS_HELPER = '/usr/libexec/openclaw-permissions.sh';
|
||
|
||
// 写前备份的后缀。特意不用 .bak: OpenClaw 自身维护 openclaw.json.bak
|
||
// 及 .bak.1~.bak.4 轮转,占用同名文件会破坏上游备份链。
|
||
const CONFIG_BACKUP_SUFFIX = '.luci-pre-write';
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 辅助函数 (与 oc-config.sh 逻辑对应)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
/**
|
||
* 执行命令并返回结果
|
||
* options.interactive: 若为 true,使用 stdio: 'inherit' 直通终端(用于向导/全屏交互),保证 child.stdout.isTTY 为 true
|
||
* options.capture: 若为 true,静默收集 stdout/stderr 并返回,不输出到终端
|
||
*/
|
||
function runCommand(cmd, args = [], options = {}) {
|
||
return new Promise((resolve, reject) => {
|
||
const isInteractive = options.interactive === true || options.stdio === 'inherit';
|
||
const isCapture = options.capture === true;
|
||
|
||
// 交互模式下使用同步直通 (spawnSync inherit),使子进程独占控制终端 TTY,
|
||
// 避免父子进程竞争读取 stdin,执行完毕后排空残留按键并恢复终端模式
|
||
if (isInteractive) {
|
||
menu.setRawMode(false);
|
||
process.stdout.write(C.show);
|
||
if (process.stdin.pause) {
|
||
try { process.stdin.pause(); } catch {}
|
||
}
|
||
try {
|
||
const res = spawnSync(cmd, args, {
|
||
stdio: 'inherit',
|
||
shell: false,
|
||
cwd: options.cwd,
|
||
env: { ...process.env, ...options.env },
|
||
});
|
||
try {
|
||
if (process.stdin.isTTY) process.stdin.setRawMode(false);
|
||
while (process.stdin.read() !== null) {}
|
||
} catch {}
|
||
if (process.stdin.resume) {
|
||
try { process.stdin.resume(); } catch {}
|
||
}
|
||
if (res.error) {
|
||
return reject(res.error);
|
||
}
|
||
if (res.status === 0) {
|
||
return resolve({ stdout: '', stderr: '', code: 0 });
|
||
} else {
|
||
return reject(new Error(`Command failed with code ${res.status}: ${res.signal || ''}`));
|
||
}
|
||
} catch (err) {
|
||
return reject(err);
|
||
}
|
||
}
|
||
|
||
const child = spawn(cmd, args, {
|
||
stdio: isCapture ? ['ignore', 'pipe', 'pipe'] : ['ignore', 'pipe', 'pipe'],
|
||
shell: !options.noShell,
|
||
env: { ...process.env, ...options.env },
|
||
});
|
||
|
||
let stdout = '';
|
||
let stderr = '';
|
||
|
||
if (child.stdout) {
|
||
child.stdout.on('data', (data) => {
|
||
stdout += data;
|
||
if (!isCapture) process.stdout.write(data);
|
||
});
|
||
}
|
||
|
||
if (child.stderr) {
|
||
child.stderr.on('data', (data) => {
|
||
stderr += data;
|
||
if (!isCapture) process.stderr.write(data);
|
||
});
|
||
}
|
||
|
||
child.on('close', (code, signal) => {
|
||
if (code === 0) {
|
||
resolve({ stdout, stderr, code });
|
||
} else {
|
||
reject(new Error(`Command failed with code ${code ?? signal}: ${stderr}`));
|
||
}
|
||
});
|
||
|
||
child.on('error', (err) => {
|
||
reject(err);
|
||
});
|
||
});
|
||
}
|
||
|
||
/**
|
||
* 清理过时插件配置并启用有效认证插件 (与 oc-config.sh 的 enable_auth_plugins 对应)
|
||
*/
|
||
function enableAuthPlugins() {
|
||
if (!fs.existsSync(CONFIG_FILE)) return;
|
||
try {
|
||
const config = readConfig();
|
||
if (!config.plugins) config.plugins = {};
|
||
if (!config.plugins.entries) config.plugins.entries = {};
|
||
const e = config.plugins.entries;
|
||
['copilot-proxy'].forEach(p => {
|
||
if (!e[p]) e[p] = {};
|
||
e[p].enabled = true;
|
||
});
|
||
delete e['qwen-portal-auth'];
|
||
delete e['google-gemini-cli-auth'];
|
||
delete e['minimax-portal-auth'];
|
||
writeConfig(config);
|
||
} catch {}
|
||
}
|
||
|
||
/**
|
||
* 读取 JSON 配置文件
|
||
*/
|
||
function fixStatePermissions() {
|
||
try {
|
||
execFileSync(PERMISSIONS_HELPER, ['fix-state', OC_STATE_DIR], { stdio: 'ignore', timeout: 10000 });
|
||
} catch {
|
||
try {
|
||
execSync(`find "${OC_STATE_DIR}" -user root ! -path "*/archived-extensions*" ! -path "*/npm/projects*" -exec chown openclaw:openclaw {} + 2>/dev/null || true`, { stdio: 'ignore' });
|
||
execSync(`[ -d "${OC_STATE_DIR}/extensions" ] && chown -R openclaw:openclaw "${OC_STATE_DIR}/extensions" && chmod -R 755 "${OC_STATE_DIR}/extensions" 2>/dev/null || true`, { stdio: 'ignore' });
|
||
execSync(`[ -d "${OC_STATE_DIR}/archived-extensions" ] && chown -R root:root "${OC_STATE_DIR}/archived-extensions" && chmod -R 755 "${OC_STATE_DIR}/archived-extensions" 2>/dev/null || true`, { stdio: 'ignore' });
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 配置文件损坏时抛出的专用错误。
|
||
* 用于把“文件存在但内容不是合法 JSON 对象”与“文件不存在”区分开。
|
||
*/
|
||
class ConfigParseError extends Error {
|
||
constructor(message) {
|
||
super(message);
|
||
this.name = 'ConfigParseError';
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 配置损坏时给用户的恢复指引。
|
||
* 不直接自动改文件,避免在用户不知情的情况下丢配置。
|
||
*/
|
||
function configRecoveryHint() {
|
||
const lines = [
|
||
`${C.yellow}配置文件可能已损坏,为避免覆盖后丢失全部配置,本次操作已中止。${C.reset}`,
|
||
`${C.yellow}文件:${C.reset} ${CONFIG_FILE}`,
|
||
'',
|
||
`${C.cyan}可尝试的恢复方式:${C.reset}`,
|
||
` 1. 让 OpenClaw 自行修复: openclaw doctor --fix`,
|
||
` 2. 查看具体语法错误: openclaw config validate`,
|
||
];
|
||
const lastGood = `${CONFIG_FILE}.last-good`;
|
||
if (fs.existsSync(lastGood)) {
|
||
lines.push(` 3. 从上次正常配置恢复: cp ${lastGood} ${CONFIG_FILE}`);
|
||
}
|
||
const preWrite = `${CONFIG_FILE}${CONFIG_BACKUP_SUFFIX}`;
|
||
if (fs.existsSync(preWrite)) {
|
||
lines.push(` 4. 从上次修改前的副本恢复: cp ${preWrite} ${CONFIG_FILE}`);
|
||
}
|
||
return lines.join('\n');
|
||
}
|
||
|
||
/**
|
||
* 读取 JSON 配置文件。
|
||
*
|
||
* 语义 (与旧实现的关键差异):
|
||
* - 文件不存在 / 内容为空 → 返回 {} (首次安装属正常情况)
|
||
* - 文件存在但解析失败 → 抛出 ConfigParseError,绝不返回 {}
|
||
*
|
||
* 旧实现在解析失败时返回 {},调用方随后 writeConfig() 会把这个空对象
|
||
* 写回磁盘,导致 models.providers / apiKey / channels 等全部配置被静默清空。
|
||
* 因此这里必须 fail closed,让写入路径中止。
|
||
*/
|
||
function readConfig() {
|
||
if (!fs.existsSync(CONFIG_FILE)) return {};
|
||
|
||
let raw;
|
||
try {
|
||
raw = fs.readFileSync(CONFIG_FILE, 'utf8');
|
||
} catch (e) {
|
||
throw new ConfigParseError(`无法读取配置文件: ${e.message}`);
|
||
}
|
||
|
||
if (raw.trim() === '') return {};
|
||
|
||
let parsed;
|
||
try {
|
||
parsed = JSON.parse(raw);
|
||
} catch (e) {
|
||
throw new ConfigParseError(`配置文件不是合法 JSON: ${e.message}`);
|
||
}
|
||
|
||
if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
|
||
throw new ConfigParseError('配置根节点必须是 JSON 对象');
|
||
}
|
||
return parsed;
|
||
}
|
||
|
||
/**
|
||
* 只读场景下的安全读取: 配置损坏时返回 {} 而不抛错。
|
||
* 仅供“显示当前值”这类不会回写磁盘的路径使用 (如菜单标题里的当前配置)。
|
||
* 任何会写回磁盘的逻辑都必须用 readConfig()。
|
||
*/
|
||
function readConfigForDisplay() {
|
||
try {
|
||
return readConfig();
|
||
} catch (e) {
|
||
if (e instanceof ConfigParseError) return {};
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 写入 JSON 配置文件 (原子写 + 写前备份 + 写后校验)。
|
||
*
|
||
* 旧实现直接 fs.writeFileSync 覆盖目标文件,写入中断会留下截断的 JSON,
|
||
* 且没有任何备份可回退。这里改为:
|
||
* 1. 先把现有配置复制为 .luci-pre-write 备份
|
||
* 2. 写入同目录临时文件
|
||
* 3. 回读校验临时文件可被 JSON.parse
|
||
* 4. rename 原子替换目标文件
|
||
*
|
||
* 备份后缀特意不用 .bak: OpenClaw 自身维护 openclaw.json.bak 及 .bak.1~.bak.4
|
||
* 轮转,占用同名文件会破坏上游的备份链。
|
||
*/
|
||
function writeConfig(config) {
|
||
if (config === null || typeof config !== 'object' || Array.isArray(config)) {
|
||
throw new Error('拒绝写入非对象配置');
|
||
}
|
||
|
||
const dir = path.dirname(CONFIG_FILE);
|
||
if (!fs.existsSync(dir)) {
|
||
fs.mkdirSync(dir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${dir}"`, { stdio: "ignore" }); } catch {}
|
||
}
|
||
|
||
// 保留原文件权限位,避免 rename 后权限被临时文件的 0600 覆盖
|
||
let mode = 0o644;
|
||
if (fs.existsSync(CONFIG_FILE)) {
|
||
try { mode = fs.statSync(CONFIG_FILE).mode & 0o777; } catch {}
|
||
// 写前备份 (best effort: 备份失败不应阻止用户修改配置)
|
||
try { fs.copyFileSync(CONFIG_FILE, `${CONFIG_FILE}${CONFIG_BACKUP_SUFFIX}`); } catch {}
|
||
}
|
||
|
||
const payload = `${JSON.stringify(config, null, 2)}\n`;
|
||
const tmpFile = `${CONFIG_FILE}.tmp-${process.pid}`;
|
||
try {
|
||
fs.writeFileSync(tmpFile, payload, { mode: 0o600 });
|
||
// 回读校验: 确认落盘内容可解析,避免把坏内容 rename 成正式配置
|
||
JSON.parse(fs.readFileSync(tmpFile, 'utf8'));
|
||
try { fs.chmodSync(tmpFile, mode); } catch {}
|
||
fs.renameSync(tmpFile, CONFIG_FILE);
|
||
} catch (e) {
|
||
try { if (fs.existsSync(tmpFile)) fs.unlinkSync(tmpFile); } catch {}
|
||
throw new Error(`写入配置失败,原配置未被修改: ${e.message}`);
|
||
}
|
||
|
||
try {
|
||
execSync(`chown openclaw:openclaw "${CONFIG_FILE}"`, { stdio: 'ignore' });
|
||
fixStatePermissions();
|
||
} catch {}
|
||
}
|
||
|
||
/**
|
||
* 获取 JSON 配置值 (对应 json_get)
|
||
*
|
||
* 只读路径: 配置损坏时返回 null 而不抛错,保证菜单仍能打开并显示恢复提示。
|
||
* 需要回写磁盘的逻辑必须直接用 readConfig(),以便在损坏时中止写入。
|
||
*/
|
||
function jsonGet(keyPath) {
|
||
const config = readConfigForDisplay();
|
||
const keys = keyPath.split('.');
|
||
let value = config;
|
||
for (const key of keys) {
|
||
if (value && typeof value === 'object' && key in value) {
|
||
value = value[key];
|
||
} else {
|
||
return null;
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
/**
|
||
* 设置 JSON 配置值 (对应 json_set)
|
||
*/
|
||
function jsonSet(keyPath, value) {
|
||
const config = readConfig();
|
||
const keys = keyPath.split('.');
|
||
let obj = config;
|
||
for (let i = 0; i < keys.length - 1; i++) {
|
||
if (!obj[keys[i]]) obj[keys[i]] = {};
|
||
obj = obj[keys[i]];
|
||
}
|
||
obj[keys[keys.length - 1]] = value;
|
||
writeConfig(config);
|
||
}
|
||
|
||
/**
|
||
* 获取当前活跃模型
|
||
*/
|
||
function getCurrentModel() {
|
||
const primary = jsonGet('agents.defaults.model.primary');
|
||
if (primary) return primary;
|
||
// 只读路径: 与 jsonGet 保持一致,配置损坏时不抛错
|
||
const config = readConfigForDisplay();
|
||
if (config.models?.defaultModel) return config.models.defaultModel;
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 查找 OpenClaw 入口文件
|
||
*/
|
||
function findOpenClawEntry() {
|
||
const searchPaths = [
|
||
`${OC_GLOBAL}/lib/node_modules/openclaw/openclaw.mjs`,
|
||
`${OC_GLOBAL}/lib/node_modules/openclaw/dist/cli.js`,
|
||
`${OC_GLOBAL}/node_modules/openclaw/openclaw.mjs`,
|
||
`${OC_GLOBAL}/node_modules/openclaw/dist/cli.js`,
|
||
];
|
||
for (const p of searchPaths) {
|
||
if (fs.existsSync(p)) return p;
|
||
}
|
||
try {
|
||
const dirs = fs.readdirSync(OC_GLOBAL);
|
||
for (const dir of dirs) {
|
||
const p = `${OC_GLOBAL}/${dir}/node_modules/openclaw/openclaw.mjs`;
|
||
if (fs.existsSync(p)) return p;
|
||
}
|
||
} catch {}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* 执行 OpenClaw CLI 命令 (对应 oc_cmd)
|
||
* 交互式向导(configure / models auth login 等)以 interactive: true 运行,直通 stdio 保证 TTY 正常交互;
|
||
* 命令执行后在 finally 中自动修复状态文件属主。
|
||
*/
|
||
async function ocCmd(...args) {
|
||
const ocEntry = findOpenClawEntry();
|
||
if (!ocEntry) throw new Error('OpenClaw 未安装');
|
||
|
||
const isJson = args.includes('--json');
|
||
const isInteractive = !isJson && (
|
||
args[0] === 'configure' ||
|
||
(args[0] === 'models' && args[1] === 'auth')
|
||
);
|
||
|
||
try {
|
||
const res = await runCommand(NODE_BIN, [ocEntry, ...args], {
|
||
interactive: isInteractive,
|
||
capture: isJson,
|
||
env: {
|
||
OPENCLAW_HOME: OC_DATA,
|
||
OPENCLAW_CONFIG_PATH: CONFIG_FILE,
|
||
OPENCLAW_STATE_DIR: OC_STATE_DIR,
|
||
HOME: OC_DATA,
|
||
}
|
||
});
|
||
return res;
|
||
} finally {
|
||
try {
|
||
execSync(`chown openclaw:openclaw "${CONFIG_FILE}" 2>/dev/null || true`, { stdio: 'ignore' });
|
||
execSync(`chown openclaw:openclaw "${CONFIG_FILE}.bak" 2>/dev/null || true`, { stdio: 'ignore' });
|
||
fixStatePermissions();
|
||
} catch {}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 静默执行 OpenClaw CLI 并返回输出。
|
||
*
|
||
* ocCmd() 会把子进程输出直接透传到终端,适合交互式命令;
|
||
* 但解析 `pairing list --json` 这类结果时需要拿到纯输出且不污染界面,
|
||
* 因此单独提供同步捕获版本。
|
||
*
|
||
* 返回 { ok, stdout }: 命令不存在或非零退出时 ok=false,不抛异常。
|
||
*/
|
||
function ocCmdCapture(...args) {
|
||
const ocEntry = findOpenClawEntry();
|
||
if (!ocEntry) return { ok: false, stdout: '' };
|
||
try {
|
||
const stdout = execFileSync(NODE_BIN, [ocEntry, ...args], {
|
||
encoding: 'utf8',
|
||
timeout: 20000,
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
env: {
|
||
...process.env,
|
||
OPENCLAW_HOME: OC_DATA,
|
||
OPENCLAW_CONFIG_PATH: CONFIG_FILE,
|
||
OPENCLAW_STATE_DIR: OC_STATE_DIR,
|
||
HOME: OC_DATA,
|
||
},
|
||
});
|
||
return { ok: true, stdout: stdout || '' };
|
||
} catch (e) {
|
||
// 保留 stdout: 部分命令失败时仍会输出有用信息
|
||
return { ok: false, stdout: (e && (e.stdout || '')) ? String(e.stdout) : '' };
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从 `openclaw pairing list <channel> --json` 的输出中提取配对码。
|
||
* 优先按 JSON 解析;输出夹带非 JSON 前后缀时回退到正则扫描。
|
||
*/
|
||
function parsePairingCodes(raw) {
|
||
if (!raw || !raw.trim()) return [];
|
||
const codes = [];
|
||
const pushFrom = (node) => {
|
||
if (!node || typeof node !== 'object') return;
|
||
if (Array.isArray(node)) { node.forEach(pushFrom); return; }
|
||
if (typeof node.code === 'string' && node.code.trim()) codes.push(node.code.trim());
|
||
Object.keys(node).forEach((k) => pushFrom(node[k]));
|
||
};
|
||
try {
|
||
pushFrom(JSON.parse(raw));
|
||
} catch {
|
||
const re = /"code"\s*:\s*"([^"]+)"/g;
|
||
let m;
|
||
while ((m = re.exec(raw)) !== null) codes.push(m[1]);
|
||
}
|
||
return [...new Set(codes)];
|
||
}
|
||
|
||
/**
|
||
* 重启 Gateway
|
||
*/
|
||
async function restartGateway() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.yellow}正在重启 Gateway...${C.reset}`);
|
||
|
||
try {
|
||
await runCommand('/bin/sh', ['-c', [
|
||
"if [ \"$(uci -q get openclaw.main.enabled 2>/dev/null || echo 0)\" != \"1\" ]; then",
|
||
" uci -q set openclaw.main.enabled='1';",
|
||
" uci -q commit openclaw;",
|
||
" /etc/init.d/openclaw enable >/dev/null 2>&1 || true;",
|
||
'fi;',
|
||
'/etc/init.d/openclaw restart_gateway >/dev/null 2>&1 || true;',
|
||
'/etc/init.d/openclaw start >/dev/null 2>&1 || true'
|
||
].join(' ')]);
|
||
} catch {}
|
||
|
||
const spin = spinner({ text: 'Gateway 启动中,请稍候 (约 15-30 秒)...' });
|
||
spin.start();
|
||
|
||
const gwPort = jsonGet('gateway.port') || '18789';
|
||
let waited = 0;
|
||
const maxWait = 30;
|
||
|
||
while (waited < maxWait) {
|
||
await new Promise(r => setTimeout(r, 3000));
|
||
waited += 3;
|
||
try {
|
||
// 兼容 OpenWrt: 优先 ss,回退 netstat
|
||
let stdout = '';
|
||
try {
|
||
stdout = execSync('ss -tulnp 2>/dev/null', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
|
||
} catch {
|
||
// ss 不存在,使用 netstat
|
||
try {
|
||
stdout = execSync('netstat -tulnp 2>/dev/null', { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
|
||
} catch {}
|
||
}
|
||
if (stdout && stdout.includes(`:${gwPort} `)) {
|
||
spin.succeed(`Gateway 已重启成功 (${waited}秒)`);
|
||
return;
|
||
}
|
||
} catch {}
|
||
}
|
||
|
||
spin.stop(`${C.yellow}Gateway 仍在启动中,请稍后确认${C.reset}`);
|
||
console.log(`${C.cyan} 查看日志: logread -e openclaw${C.reset}\n`);
|
||
}
|
||
|
||
/**
|
||
* 询问是否重启
|
||
*/
|
||
async function askRestart() {
|
||
const ok = await confirm({ prompt: '是否立即重启服务以应用配置?', defaultYes: true });
|
||
if (ok) {
|
||
await restartGateway();
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 主菜单 (对应 main_menu)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showMainMenu() {
|
||
const currentModel = getCurrentModel();
|
||
const statusLine = currentModel
|
||
? `${C.green}当前模型: ${currentModel}${C.reset}`
|
||
: `${C.yellow}未配置模型${C.reset}`;
|
||
|
||
const result = await select({
|
||
title: 'OpenClaw AI Gateway — OpenWrt 配置管理',
|
||
header: statusLine,
|
||
showSearch: false,
|
||
items: [
|
||
{ label: `${C.dim}━━━ AI 模型配置 ━━━${C.reset}`, disabled: true },
|
||
{ key: '1', label: '配置 AI 模型和提供商', desc: '', value: 'model' },
|
||
{ key: '2', label: '设置活动模型', desc: '', value: 'set-active-model' },
|
||
|
||
{ label: `${C.dim}━━━ 消息渠道 ━━━${C.reset}`, disabled: true },
|
||
{ key: '3', label: '配置消息渠道', desc: '电报/QQ/飞书', value: 'channels' },
|
||
|
||
{ label: `${C.dim}━━━ 系统管理 ━━━${C.reset}`, disabled: true },
|
||
{ key: '4', label: '健康检查与状态', desc: '', value: 'health' },
|
||
{ key: '5', label: '查看日志', desc: '', value: 'logs' },
|
||
{ key: '6', label: '重启 Gateway', desc: '', value: 'restart' },
|
||
{ key: '7', label: '设备配对管理', desc: '审批 Control UI 浏览器配对', value: 'devices' },
|
||
|
||
{ label: `${C.dim}━━━ 高级选项 ━━━${C.reset}`, disabled: true },
|
||
{ key: '8', label: '高级配置', desc: '', value: 'advanced' },
|
||
{ key: '9', label: '重置配置', desc: '', value: 'reset' },
|
||
{ key: '10', label: '显示当前配置概览', desc: '', value: 'show-config' },
|
||
{ key: '11', label: '备份/还原配置', desc: '', value: 'backup' },
|
||
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '退出', desc: '', value: 'quit' },
|
||
],
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 消息渠道菜单 (对应 configure_channels)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showChannelsMenu() {
|
||
const result = await select({
|
||
title: '配置消息渠道',
|
||
showSearch: false,
|
||
items: [
|
||
{ label: `${C.dim}提示: 微信配置请使用 LuCI 界面「微信配置」菜单${C.reset}`, disabled: true },
|
||
{ label: '', disabled: true },
|
||
{ key: '1', label: 'QQ 机器人', desc: '腾讯QQ', value: 'qq' },
|
||
{ key: '2', label: 'Telegram', desc: `${C.green}最常用${C.reset} — 配置 Bot Token`, value: 'telegram' },
|
||
{ key: '3', label: 'Discord', desc: '', value: 'discord' },
|
||
{ key: '4', label: '飞书 (Feishu)', desc: '', value: 'feishu' },
|
||
{ key: '5', label: 'Slack', desc: '', value: 'slack' },
|
||
{ key: '6', label: 'WhatsApp', desc: '需通过 Web 控制台扫码', value: 'whatsapp' },
|
||
{ key: '7', label: 'Telegram 配对助手', desc: '审批用户配对请求 (需先配置 Token)', value: 'telegram-pairing' },
|
||
{ key: '8', label: '官方完整渠道配置向导', desc: '', value: 'wizard' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 高级配置菜单 (对应 advanced_menu)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showAdvancedMenu() {
|
||
const gwPort = jsonGet('gateway.port') || '18789';
|
||
const gwBind = jsonGet('gateway.bind') || 'lan';
|
||
const gwMode = jsonGet('gateway.mode') || 'local';
|
||
// 正确键是顶层 logging.level;gateway.logLevel 不在 OpenClaw schema 中
|
||
// (gateway.additionalProperties=false),仅为显示旧配置残留值做兼容读取。
|
||
const logLevel = jsonGet('logging.level') || jsonGet('gateway.logLevel') || '未设置';
|
||
const acpDispatch = jsonGet('acp.dispatch.enabled') || 'false';
|
||
|
||
const result = await select({
|
||
title: '高级配置',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: 'Gateway 端口', desc: `当前: ${gwPort}`, value: 'port' },
|
||
{ key: '2', label: 'Gateway 绑定地址', desc: `当前: ${gwBind}`, value: 'bind' },
|
||
{ key: '3', label: 'Gateway 运行模式', desc: `当前: ${gwMode}`, value: 'mode' },
|
||
{ key: '4', label: '日志级别', desc: `当前: ${logLevel}`, value: 'loglevel' },
|
||
{ key: '5', label: 'ACP Dispatch 设置', desc: `当前: ${acpDispatch}`, value: 'acp' },
|
||
{ key: '6', label: '官方完整配置向导', desc: 'oc configure', value: 'wizard' },
|
||
{ key: '7', label: '查看原始配置 JSON', desc: '', value: 'view-json' },
|
||
{ key: '8', label: '编辑配置文件', desc: 'vi / nano', value: 'edit' },
|
||
{ key: '9', label: '导出配置备份', desc: '', value: 'backup' },
|
||
{ key: '10', label: '导入配置', desc: '', value: 'import' },
|
||
{ key: '11', label: '设备配对管理', desc: '审批 Control UI 配对', value: 'devices' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 重置配置菜单 (对应 reset_to_defaults)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showResetMenu() {
|
||
const result = await select({
|
||
title: '恢复默认配置',
|
||
showSearch: false,
|
||
items: [
|
||
{ label: `${C.yellow}请选择恢复级别:${C.reset}`, disabled: true },
|
||
{ label: '', disabled: true },
|
||
{ key: '1', label: '仅重置网关设置', desc: '端口/绑定/模式恢复默认,保留模型和渠道', value: 'gateway' },
|
||
{ key: '2', label: '清除模型配置', desc: '移除所有 AI 模型和 API Key', value: 'models' },
|
||
{ key: '3', label: '清除渠道配置', desc: '移除所有消息渠道配置', value: 'channels' },
|
||
{ key: '4', label: '完全恢复出厂', desc: '删除所有配置,重新初始化', value: 'full' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 备份/还原菜单 (对应 backup_restore_menu)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function showBackupMenu() {
|
||
const result = await select({
|
||
title: '备份/还原配置',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: '创建配置备份', desc: '仅配置文件', value: 'create-config' },
|
||
{ key: '2', label: '创建完整备份', desc: '配置 + 状态数据', value: 'create-full' },
|
||
{ key: '3', label: '验证最新备份', desc: '', value: 'verify' },
|
||
{ key: '4', label: '查看备份列表', desc: '', value: 'list' },
|
||
{ key: '5', label: '从最新备份恢复配置', desc: '', value: 'restore' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
return result;
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// AI 模型配置 (对应 oc-config.sh 的 configure_model)
|
||
//
|
||
// 业务逻辑全部在 oc-providers.js,本文件只负责交互。Shell 菜单调用同一个
|
||
// 后端与同一份 provider-catalog.json,两边菜单项、按键与流程保持一致。
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
const providers = require('./oc-providers');
|
||
|
||
// 模型模块的菜单只用 Esc 返回: select() 默认把 'q' 也当退出键,且先于搜索处理,
|
||
// 会导致可搜索列表里无法输入 q (如搜索 qwen),也与「q 快速配置」快捷键冲突
|
||
function selectMenu(opts) {
|
||
return select({ exitKeys: ['escape'], ...opts });
|
||
}
|
||
|
||
function printResultNotes(r) {
|
||
for (const n of (r.notes || [])) console.log(`${C.dim} ${n}${C.reset}`);
|
||
}
|
||
|
||
function pause() {
|
||
return input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
|
||
function verificationHeader() {
|
||
try {
|
||
const v = providers.catalogVerification();
|
||
if (!v.installed) return `${C.yellow}OpenClaw 未安装${C.reset}`;
|
||
return v.verified
|
||
? `${C.dim}OpenClaw ${v.installed} — provider 目录已在此版本核实 (${v.verifiedAt})${C.reset}`
|
||
: `${C.yellow}OpenClaw ${v.installed} 不在 provider 目录核实范围 (${v.verifiedWith.join(' / ')}),配置项可能有出入${C.reset}`;
|
||
} catch (e) {
|
||
return `${C.red}provider 目录读取失败: ${e.message}${C.reset}`;
|
||
}
|
||
}
|
||
|
||
async function showModelMenu() {
|
||
const currentModel = getCurrentModel();
|
||
return selectMenu({
|
||
title: 'AI 模型配置',
|
||
header: `${currentModel ? `${C.green}当前默认模型: ${currentModel}${C.reset}` : `${C.yellow}尚未设置默认模型${C.reset}`}\n${verificationHeader()}`,
|
||
showSearch: false,
|
||
items: [
|
||
{ label: `${C.green}${C.bold}── 快速配置 ──${C.reset}`, disabled: true },
|
||
{ key: 'q', label: '常用 Provider 快速配置', desc: `${C.green}(推荐)${C.reset}`, value: 'quick' },
|
||
|
||
{ label: `${C.bold}── 按类别添加 ──${C.reset}`, disabled: true },
|
||
{ key: '1', label: '官方 API (按量付费)', desc: 'OpenAI / Claude / Gemini / DeepSeek / 千问 / 智谱 ...', value: 'group:official' },
|
||
{ key: '2', label: '订阅套餐 / Coding Plan / 账号登录', desc: '百炼 / GLM / Kimi Code / Copilot ...', value: 'group:plan' },
|
||
{ key: '3', label: '聚合平台 / 自定义 API', desc: 'OpenRouter / 硅基流动 / OpenAI 兼容 ...', value: 'group:aggregator' },
|
||
{ key: '4', label: '本地 / 局域网模型', desc: 'Ollama / vLLM / LM Studio', value: 'group:local' },
|
||
|
||
{ label: `${C.bold}── 模型管理 ──${C.reset}`, disabled: true },
|
||
{ key: '5', label: '查看模型与认证状态', desc: '', value: 'status' },
|
||
{ key: '6', label: '切换默认模型', desc: '', value: 'set-default' },
|
||
{ key: '7', label: '管理备用模型 (fallback)', desc: '', value: 'fallbacks' },
|
||
{ key: '8', label: '连通性测试', desc: '真实请求,验证账号能否调用', value: 'probe' },
|
||
{ key: '9', label: '删除凭据 / Provider', desc: '', value: 'remove' },
|
||
|
||
{ label: `${C.bold}── 其他 ──${C.reset}`, disabled: true },
|
||
{ key: 'w', label: '官方完整配置向导', desc: 'openclaw configure --section model', value: 'wizard' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
}
|
||
|
||
async function pickMethodFromGroup(groupId) {
|
||
const entries = providers.menuEntries().filter((e) => e.group === groupId);
|
||
if (!entries.length) return null;
|
||
const keys = 'abcdefghijklmnoprstuvwxyz'.split('');
|
||
const items = [];
|
||
let ki = 0;
|
||
for (const e of entries) {
|
||
for (const m of e.methods) {
|
||
const label = e.methods.length > 1 ? `${e.label} — ${m.label}` : e.label;
|
||
items.push({ key: keys[ki++], label, desc: e.plugin ? `${C.dim}需官方插件${C.reset}` : '', value: m.ref });
|
||
}
|
||
}
|
||
items.push({ label: '', disabled: true });
|
||
items.push({ key: '0', label: '返回', desc: '', value: 'back' });
|
||
const choice = await selectMenu({ title: entries[0].groupLabel, showSearch: true, items });
|
||
return choice && choice.value !== 'back' ? choice.value : null;
|
||
}
|
||
|
||
async function pickQuickMethod() {
|
||
const items = providers.quickEntries().map((q, i) => ({ key: String(i + 1), label: q.label, desc: '', value: q.ref }));
|
||
items.push({ label: '', disabled: true });
|
||
items.push({ key: '0', label: '返回', desc: '', value: 'back' });
|
||
const choice = await selectMenu({ title: '常用 Provider 快速配置', showSearch: false, items });
|
||
return choice && choice.value !== 'back' ? choice.value : null;
|
||
}
|
||
|
||
function printMethodIntro(f) {
|
||
const p = f.provider;
|
||
const m = f.method;
|
||
console.log(`\n${C.bold}${p.label}${p.methods.length > 1 ? ` — ${m.label}` : ''}${C.reset}`);
|
||
if (p.keyUrl) console.log(`${C.yellow}获取 Key: ${p.keyUrl}${C.reset}`);
|
||
const docs = providers.docsUrl(p);
|
||
if (docs) console.log(`${C.dim}文档: ${docs}${C.reset}`);
|
||
if (m.baseUrl) console.log(`${C.dim}Base URL: ${m.baseUrl}${C.reset}`);
|
||
if (p.note) console.log(`${C.cyan}说明: ${p.note}${C.reset}`);
|
||
if (m.note) console.log(`${C.cyan}说明: ${m.note}${C.reset}`);
|
||
if (m.keyHint) console.log(`${C.cyan}提示: ${m.keyHint}${C.reset}`);
|
||
if (m.unverified) console.log(`${C.yellow}未实测: ${m.unverified}${C.reset}`);
|
||
console.log('');
|
||
}
|
||
|
||
/** 插件缺失时征得同意后安装;返回 false 表示用户取消或安装失败 */
|
||
async function ensurePluginInteractive(f) {
|
||
const pkg = f.provider.plugin;
|
||
if (!pkg) return true;
|
||
console.log(`${C.cyan}检查官方插件 ${pkg}...${C.reset}`);
|
||
const st = providers.pluginStatus(pkg);
|
||
if (st.installed) return true;
|
||
if (st.error) console.log(`${C.yellow}插件状态查询失败: ${st.error}${C.reset}`);
|
||
console.log(`${C.yellow}该 Provider 需要 OpenClaw 官方插件 ${pkg},将通过 npm 下载安装 (版本与当前 OpenClaw 匹配)。${C.reset}`);
|
||
const ok = await confirm({ prompt: '是否安装该插件?', defaultYes: true });
|
||
if (!ok) return false;
|
||
console.log(`${C.cyan}正在安装 ${pkg} (可能需要 1~3 分钟)...${C.reset}`);
|
||
const r = providers.installPlugin(pkg);
|
||
if (!r.ok) {
|
||
console.log(`${C.red}插件安装失败: ${r.reason}${C.reset}\n`);
|
||
return false;
|
||
}
|
||
console.log(`${C.green}✅ 插件已安装${C.reset}`);
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 模型选择: 精选 + 动态发现 + 手动输入 + 保持当前默认。
|
||
* 返回 { model } / { keep: true } / null(取消)。
|
||
*/
|
||
async function pickModel(providerId, curated, opts = {}) {
|
||
let discovered = null;
|
||
const current = getCurrentModel();
|
||
while (true) {
|
||
const keys = 'abcdefghijkmnoprstuvwxy'.split('');
|
||
let ki = 0;
|
||
const items = [];
|
||
if (curated.length) {
|
||
items.push({ label: `${C.bold}── 精选模型 ──${C.reset}`, disabled: true });
|
||
for (const m of curated) items.push({ key: keys[ki++], label: m.id, desc: `${m.tier ? `[${m.tier}] ` : ''}${m.desc || ''}`, value: `m:${m.id}` });
|
||
}
|
||
if (discovered && discovered.models.length) {
|
||
const known = new Set(curated.map((m) => m.id));
|
||
const extra = discovered.models.filter((m) => !known.has(m.id));
|
||
if (extra.length) {
|
||
const title = discovered.source === 'cache' ? `OpenClaw 模型列表 (缓存 ${discovered.cachedAt || ''})` : 'OpenClaw 当前模型列表';
|
||
items.push({ label: `${C.bold}── ${title} ──${C.reset}`, disabled: true });
|
||
for (const m of extra) items.push({ key: keys[ki++], label: m.id, desc: m.name || '', value: `m:${m.id}` });
|
||
}
|
||
}
|
||
items.push({ label: '', disabled: true });
|
||
if (!discovered && providerId) items.push({ key: 'r', label: '从 OpenClaw 获取完整模型列表', desc: '动态发现', value: 'discover' });
|
||
items.push({ key: 'z', label: '手动输入模型 ID', desc: '', value: 'manual' });
|
||
if (opts.allowKeep && current) items.push({ key: 'k', label: '保持当前默认模型不变', desc: current, value: 'keep' });
|
||
items.push({ key: '0', label: '取消', desc: '', value: 'back' });
|
||
|
||
const choice = await selectMenu({ title: opts.title || '选择模型', showSearch: true, items });
|
||
if (!choice || choice.value === 'back') return null;
|
||
if (choice.value === 'keep') return { keep: true };
|
||
if (choice.value === 'manual') {
|
||
const v = await input({ prompt: '请输入模型 ID (不含 provider/ 前缀)', defaultValue: opts.defaultModel || '' });
|
||
const t = v ? String(v).trim() : '';
|
||
if (!t) continue;
|
||
return { model: t };
|
||
}
|
||
if (choice.value === 'discover') {
|
||
console.log(`\n${C.cyan}正在从 OpenClaw 获取模型列表 (路由器上可能需要 10~60 秒)...${C.reset}`);
|
||
discovered = providers.discoverModels(providerId);
|
||
if (discovered.source === 'none') {
|
||
console.log(`${C.yellow}未获取到模型列表${discovered.reason ? `: ${discovered.reason}` : ''},仍可使用精选列表或手动输入。${C.reset}`);
|
||
} else {
|
||
console.log(`${C.green}获取到 ${discovered.models.length} 个模型${discovered.source === 'cache' ? ' (来自缓存)' : ''}${C.reset}`);
|
||
}
|
||
if (discovered.hints.includes('auth-rejected')) {
|
||
console.log(`${C.yellow}⚠️ 上游报告该 Provider 的认证被拒绝: Key 可能无效或无权限。${C.reset}`);
|
||
}
|
||
console.log(`${C.dim}注意: 列表只代表上游登记的模型,不代表你的账号有权调用;请用「连通性测试」确认。${C.reset}\n`);
|
||
continue;
|
||
}
|
||
return { model: choice.value.slice(2) };
|
||
}
|
||
}
|
||
|
||
async function configureApiKeyMethod(f) {
|
||
if (!(await ensurePluginInteractive(f))) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const key = await input({ prompt: `请输入 ${f.provider.label} API Key`, hidden: true });
|
||
if (!key) { console.log(`\n${C.yellow}已取消${C.reset}\n`); return false; }
|
||
console.log(`\n${C.cyan}正在写入凭据 (通过 OpenClaw 官方命令,Key 保存在认证库,不写入 openclaw.json)...${C.reset}`);
|
||
const r = providers.applyApiKey(f.ref, key, { keepDefault: true, pluginConfirmed: true });
|
||
if (!r.ok) {
|
||
console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`);
|
||
return false;
|
||
}
|
||
console.log(`${C.green}✅ ${f.provider.label} 凭据已保存${C.reset}`);
|
||
printResultNotes(r);
|
||
await chooseDefaultAfterAuth(f.method.provider, providers.curatedModels(f.method), f.method.defaultModel);
|
||
return true;
|
||
}
|
||
|
||
async function chooseDefaultAfterAuth(providerId, curated, defaultModel) {
|
||
const pick = await pickModel(providerId, curated, { title: `将哪个 ${providerId} 模型设为默认?`, allowKeep: true, defaultModel });
|
||
if (!pick || pick.keep) {
|
||
console.log(`${C.dim}默认模型保持为 ${getCurrentModel() || '未设置'}${C.reset}\n`);
|
||
return;
|
||
}
|
||
const ref = `${providerId}/${pick.model}`;
|
||
const s = providers.setDefault(ref);
|
||
if (s.ok) console.log(`${C.green}✅ 默认模型已设为 ${ref}${C.reset}\n`);
|
||
else console.log(`${C.red}❌ 设置默认模型失败: ${s.reason}${C.reset}\n`);
|
||
}
|
||
|
||
async function configureCustomMethod(f) {
|
||
const m = f.method;
|
||
const id = await input({ prompt: 'Provider ID (小写字母/数字/连字符)', defaultValue: m.customProviderId || (m.compatibility === 'anthropic' ? 'custom-anthropic' : 'custom') });
|
||
if (!id) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const baseUrl = await input({ prompt: 'API Base URL', defaultValue: m.baseUrl || m.baseUrlDefault || '', placeholder: 'https://api.example.com/v1' });
|
||
if (!baseUrl) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const model = await input({ prompt: '模型 ID', defaultValue: '', placeholder: m.modelHint || '' });
|
||
if (!model) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const image = await confirm({ prompt: '该模型支持图片输入吗?', defaultYes: false });
|
||
const key = await input({ prompt: m.keyOptional ? 'API Key (可留空)' : 'API Key', hidden: true, defaultValue: '' });
|
||
if (key === null) { console.log(`\n${C.yellow}已取消${C.reset}\n`); return false; }
|
||
if (!key && !m.keyOptional) {
|
||
const cont = await confirm({ prompt: '\n未填写 API Key,若该 Provider 已存在将沿用原 Key,否则不带 Key 接入。继续?', defaultYes: false });
|
||
if (!cont) return false;
|
||
}
|
||
const setDef = await confirm({ prompt: '\n设为默认模型?', defaultYes: true });
|
||
console.log(`\n${C.cyan}正在写入...${C.reset}`);
|
||
const r = providers.applyCustom({ providerId: String(id).trim(), baseUrl, model: String(model).trim(), compatibility: m.compatibility, image, keyOptional: true }, key || '', { setDefault: setDef });
|
||
if (!r.ok) { console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`); return false; }
|
||
console.log(`${C.green}✅ ${r.appended ? '已向现有 Provider 追加模型' : '自定义 Provider 已添加'}: ${r.provider}/${String(model).trim()}${C.reset}`);
|
||
console.log(`${C.dim} 注意: 按上游设计,自定义 Provider 的 Key 明文保存在 openclaw.json${C.reset}`);
|
||
printResultNotes(r);
|
||
console.log(`${C.dim} 当前默认模型: ${r.primary || '未设置'}${C.reset}\n`);
|
||
return true;
|
||
}
|
||
|
||
async function configureOllamaMethod(f) {
|
||
const url = await input({ prompt: 'Ollama 地址', defaultValue: f.method.baseUrlDefault || 'http://127.0.0.1:11434' });
|
||
if (!url) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const base = /^https?:\/\//.test(url) ? url.replace(/\/+$/, '').replace(/\/v1$/, '') : `http://${url.replace(/\/+$/, '')}`;
|
||
let names = [];
|
||
try {
|
||
const out = execFileSync('curl', ['-sf', '--connect-timeout', '3', '--max-time', '6', `${base}/api/tags`], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
|
||
names = (JSON.parse(out).models || []).map((x) => x.name).filter(Boolean);
|
||
console.log(`${C.green}✅ Ollama 已连接,发现 ${names.length} 个本地模型${C.reset}`);
|
||
} catch {
|
||
console.log(`${C.yellow}⚠️ 无法连接 ${base},上游写入时也会检测,不可达将被拒绝${C.reset}`);
|
||
}
|
||
let model = '';
|
||
if (names.length) {
|
||
const items = names.map((n, i) => ({ key: String(i + 1), label: n, desc: '', value: n }));
|
||
items.push({ key: 'z', label: '手动输入模型名', desc: '', value: '__manual__' });
|
||
const c = await selectMenu({ title: 'Ollama 模型', showSearch: true, items });
|
||
if (!c) return false;
|
||
model = c.value === '__manual__' ? await input({ prompt: '模型名', defaultValue: '' }) : c.value;
|
||
} else {
|
||
model = await input({ prompt: '模型名', placeholder: 'qwen3:8b' });
|
||
}
|
||
if (!model) { console.log(`${C.yellow}已取消${C.reset}\n`); return false; }
|
||
const setDef = await confirm({ prompt: '设为默认模型?', defaultYes: true });
|
||
console.log(`\n${C.cyan}正在写入...${C.reset}`);
|
||
const r = providers.applyOllama(base, String(model).trim(), { setDefault: setDef });
|
||
if (!r.ok) { console.log(`${C.red}❌ 配置失败: ${r.reason}${C.reset}\n`); return false; }
|
||
console.log(`${C.green}✅ Ollama 已配置${C.reset}`);
|
||
printResultNotes(r);
|
||
console.log(`${C.dim} 当前默认模型: ${r.primary || '未设置'}${C.reset}\n`);
|
||
return true;
|
||
}
|
||
|
||
async function configureOAuthMethod(f) {
|
||
console.log(`${C.cyan}即将启动 OpenClaw 官方登录流程,请按屏幕提示在浏览器中完成授权。${C.reset}\n`);
|
||
const ok = await confirm({ prompt: '开始登录?', defaultYes: true });
|
||
if (!ok) return false;
|
||
const r = providers.login(f.ref);
|
||
if (!r.ok) { console.log(`\n${C.yellow}${r.reason}${C.reset}\n`); return false; }
|
||
console.log(`\n${C.green}✅ 登录完成${C.reset}`);
|
||
await chooseDefaultAfterAuth(f.method.provider, providers.curatedModels(f.method), '');
|
||
return true;
|
||
}
|
||
|
||
async function configureMethod(ref) {
|
||
resetRenderCount();
|
||
const f = providers.findMethod(ref);
|
||
if (!f) { console.log(`${C.red}未知的接入方式: ${ref}${C.reset}`); return false; }
|
||
printMethodIntro(f);
|
||
switch (f.method.type) {
|
||
case 'api-key': return configureApiKeyMethod(f);
|
||
case 'custom': return configureCustomMethod(f);
|
||
case 'local': return configureOllamaMethod(f);
|
||
case 'oauth': return configureOAuthMethod(f);
|
||
default:
|
||
console.log(`${C.red}不支持的接入类型: ${f.method.type}${C.reset}`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
async function handleModelStatus() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}正在读取模型与认证状态...${C.reset}`);
|
||
const s = providers.status();
|
||
if (!s.ok) console.log(`${C.red}读取失败: ${s.reason}${C.reset}`);
|
||
console.log(`\n${C.bold}默认模型:${C.reset} ${s.defaultModel ? C.green + s.defaultModel : C.yellow + '未设置'}${C.reset}`);
|
||
console.log(`${C.bold}备用模型:${C.reset} ${s.fallbacks.length ? s.fallbacks.join(', ') : C.dim + '无' + C.reset}`);
|
||
console.log(`\n${C.bold}已保存的凭据:${C.reset}`);
|
||
if (!s.profiles.length) console.log(` ${C.dim}无${C.reset}`);
|
||
for (const p of s.profiles) console.log(` • ${p.id} ${C.dim}(${p.provider}, ${p.type})${C.reset}`);
|
||
console.log(`\n${C.bold}Provider 配置:${C.reset}`);
|
||
if (!s.custom.length) console.log(` ${C.dim}无${C.reset}`);
|
||
for (const c of s.custom) {
|
||
console.log(` • ${c.id} ${C.dim}${c.baseUrl || ''} ${c.api || ''}${c.hasKey ? ' [配置内含 Key]' : ''}${C.reset}`);
|
||
if (c.models.length) console.log(` ${C.dim}模型: ${c.models.join(', ')}${C.reset}`);
|
||
}
|
||
if (s.issues.length) {
|
||
console.log(`\n${C.yellow}${C.bold}发现问题:${C.reset}`);
|
||
for (const i of s.issues) console.log(` ${C.yellow}• ${i}${C.reset}`);
|
||
}
|
||
console.log(`\n${C.dim}以上是本地凭据状态,不代表调用一定成功;请用「连通性测试」确认。${C.reset}\n`);
|
||
await pause();
|
||
}
|
||
|
||
async function pickConfiguredModel(title) {
|
||
const current = getCurrentModel();
|
||
const refs = providers.configuredModels();
|
||
const items = refs.map((r, i) => ({ key: i < 9 ? String(i + 1) : undefined, label: r, desc: r === current ? `${C.green}(当前默认)${C.reset}` : '', value: r }));
|
||
items.push({ label: '', disabled: true });
|
||
items.push({ key: 'z', label: '手动输入 provider/model', desc: '', value: '__manual__' });
|
||
items.push({ key: '0', label: '取消', desc: '', value: 'back' });
|
||
const c = await selectMenu({ title, showSearch: true, items });
|
||
if (!c || c.value === 'back') return null;
|
||
if (c.value === '__manual__') {
|
||
const v = await input({ prompt: '模型引用 (provider/model)', defaultValue: '' });
|
||
return v ? String(v).trim() : null;
|
||
}
|
||
return c.value;
|
||
}
|
||
|
||
async function handleSetDefaultModel() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.bold}切换默认模型${C.reset} 当前: ${C.green}${getCurrentModel() || '未设置'}${C.reset}\n`);
|
||
const ref = await pickConfiguredModel('选择默认模型');
|
||
if (!ref) return false;
|
||
const r = providers.setDefault(ref);
|
||
if (r.ok) { console.log(`\n${C.green}✅ 默认模型已切换为 ${ref}${C.reset}\n`); return true; }
|
||
console.log(`\n${C.red}❌ 切换失败: ${r.reason}${C.reset}\n`);
|
||
return false;
|
||
}
|
||
|
||
async function handleFallbacks() {
|
||
let changed = false;
|
||
while (true) {
|
||
resetRenderCount();
|
||
const l = providers.fallbacks('list');
|
||
const list = l.ok ? l.fallbacks : [];
|
||
if (!l.ok) console.log(`${C.red}读取备用模型失败: ${l.reason}${C.reset}`);
|
||
const c = await selectMenu({
|
||
title: '管理备用模型 (fallback)',
|
||
header: `${C.dim}默认模型不可用时按顺序尝试: ${list.length ? list.join(' → ') : '无'}${C.reset}`,
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: '添加备用模型', desc: '', value: 'add' },
|
||
{ key: '2', label: '移除备用模型', desc: '', value: 'remove' },
|
||
{ key: '3', label: '清空备用模型', desc: '', value: 'clear' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
if (!c || c.value === 'back') return changed;
|
||
let r = null;
|
||
if (c.value === 'add') {
|
||
const ref = await pickConfiguredModel('选择要添加的备用模型');
|
||
if (ref) r = providers.fallbacks('add', ref);
|
||
} else if (c.value === 'remove') {
|
||
if (!list.length) { console.log(`${C.yellow}没有备用模型${C.reset}`); continue; }
|
||
const p = await selectMenu({ title: '移除哪个?', showSearch: false, items: list.map((x, i) => ({ key: String(i + 1), label: x, value: x })) });
|
||
if (p) r = providers.fallbacks('remove', p.value);
|
||
} else if (c.value === 'clear') {
|
||
if (await confirm({ prompt: '确认清空所有备用模型?', defaultYes: false })) r = providers.fallbacks('clear');
|
||
}
|
||
if (r) {
|
||
if (r.ok) { console.log(`${C.green}✅ 已更新${C.reset}`); changed = true; }
|
||
else console.log(`${C.red}❌ 失败: ${r.reason}${C.reset}`);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function handleProbe() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}正在读取已配置的 Provider...${C.reset}`);
|
||
const s = providers.status();
|
||
const ids = [...new Set([...s.profiles.map((p) => p.provider), ...s.custom.map((c) => c.id)])].sort();
|
||
if (!ids.length) { console.log(`${C.yellow}尚未配置任何 Provider${C.reset}\n`); await pause(); return; }
|
||
const c = await selectMenu({ title: '测试哪个 Provider?', showSearch: true, items: ids.map((id, i) => ({ key: i < 9 ? String(i + 1) : undefined, label: id, value: id })) });
|
||
if (!c) return;
|
||
console.log(`\n${C.yellow}连通性测试会向 ${c.value} 发送真实请求 (每个模型约 8 个 token),可能产生少量费用或触发限流。${C.reset}`);
|
||
if (!(await confirm({ prompt: '继续?', defaultYes: true }))) return;
|
||
console.log(`${C.cyan}测试中 (约 5~60 秒)...${C.reset}`);
|
||
const r = providers.probe(c.value);
|
||
if (!r.ok) {
|
||
console.log(`${C.red}❌ 无法完成测试: ${r.reason}${C.reset}\n`);
|
||
} else {
|
||
for (const x of r.results) {
|
||
const color = x.status === 'ok' ? C.green : C.red;
|
||
console.log(` ${color}${x.status === 'ok' ? '✅' : '❌'} ${x.model || c.value} ${x.statusText}${x.latencyMs ? ` (${x.latencyMs} ms)` : ''}${C.reset}`);
|
||
if (x.error) console.log(` ${C.dim}${x.error}${C.reset}`);
|
||
}
|
||
console.log('');
|
||
}
|
||
await pause();
|
||
}
|
||
|
||
async function handleRemove() {
|
||
resetRenderCount();
|
||
const s = providers.status();
|
||
const items = [];
|
||
for (const p of s.profiles) items.push({ label: `删除凭据 ${p.id}`, desc: `${p.provider} / ${p.type}`, value: `auth:${p.id}` });
|
||
for (const c of s.custom) items.push({ label: `删除 Provider 配置 ${c.id}`, desc: c.baseUrl, value: `prov:${c.id}` });
|
||
if (!items.length) { console.log(`\n${C.yellow}没有可删除的凭据或 Provider${C.reset}\n`); await pause(); return false; }
|
||
items.forEach((it, i) => { if (i < 9) it.key = String(i + 1); });
|
||
items.push({ label: '', disabled: true });
|
||
items.push({ key: '0', label: '返回', desc: '', value: 'back' });
|
||
const c = await selectMenu({ title: '删除凭据 / Provider', showSearch: true, items });
|
||
if (!c || c.value === 'back') return false;
|
||
const [kind, id] = [c.value.slice(0, c.value.indexOf(':')), c.value.slice(c.value.indexOf(':') + 1)];
|
||
console.log(`\n${C.red}将删除 ${id}${kind === 'prov' ? ' 的 Provider 配置及其模型白名单 (默认模型使用中时会拒绝)' : ' 这条凭据'},此操作不可撤销。${C.reset}`);
|
||
if (!(await confirm({ prompt: '确认删除?', defaultYes: false }))) return false;
|
||
const r = kind === 'auth' ? providers.removeAuth(id) : providers.removeProvider(id);
|
||
if (r.ok) {
|
||
console.log(`${C.green}✅ 已删除${C.reset}`);
|
||
if (r.removedFallbacks && r.removedFallbacks.length) console.log(`${C.dim} 同时移除了备用模型: ${r.removedFallbacks.join(', ')}${C.reset}`);
|
||
console.log('');
|
||
return true;
|
||
}
|
||
console.log(`${C.red}❌ 删除失败: ${r.reason}${C.reset}\n`);
|
||
return false;
|
||
}
|
||
|
||
async function launchWizard() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}启动官方完整模型配置向导...${C.reset}\n`);
|
||
console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
|
||
try {
|
||
enableAuthPlugins();
|
||
await ocCmd('configure', '--section', 'model');
|
||
return true;
|
||
} catch (e) {
|
||
console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
async function handleModelConfig() {
|
||
while (true) {
|
||
const choice = await showModelMenu();
|
||
if (!choice || choice.value === 'back') break;
|
||
resetRenderCount();
|
||
let changed = false;
|
||
try {
|
||
if (choice.value === 'quick') {
|
||
const ref = await pickQuickMethod();
|
||
if (ref) changed = await configureMethod(ref);
|
||
} else if (choice.value.startsWith('group:')) {
|
||
const ref = await pickMethodFromGroup(choice.value.slice(6));
|
||
if (ref) changed = await configureMethod(ref);
|
||
} else if (choice.value === 'status') {
|
||
await handleModelStatus();
|
||
} else if (choice.value === 'set-default') {
|
||
changed = await handleSetDefaultModel();
|
||
} else if (choice.value === 'fallbacks') {
|
||
changed = await handleFallbacks();
|
||
} else if (choice.value === 'probe') {
|
||
await handleProbe();
|
||
} else if (choice.value === 'remove') {
|
||
changed = await handleRemove();
|
||
} else if (choice.value === 'wizard') {
|
||
changed = await launchWizard();
|
||
}
|
||
} catch (e) {
|
||
console.log(`${C.red}操作失败: ${e.message}${C.reset}\n`);
|
||
await pause();
|
||
}
|
||
if (changed) await askRestart();
|
||
}
|
||
}
|
||
|
||
// 主菜单「设置活动模型」入口与模型管理中的「切换默认模型」共用实现
|
||
async function handleSetActiveModel() {
|
||
if (await handleSetDefaultModel()) await askRestart();
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 消息渠道处理 (对应 configure_channels 等函数)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleChannels() {
|
||
while (true) {
|
||
const choice = await showChannelsMenu();
|
||
if (!choice || choice.value === 'back') break;
|
||
|
||
resetRenderCount();
|
||
|
||
switch (choice.value) {
|
||
case 'qq': {
|
||
console.log(`\n${C.bold}QQ 机器人配置${C.reset}\n`);
|
||
console.log(`${C.yellow}获取 App ID 和 App Secret:${C.reset}`);
|
||
console.log(` 1. 前往 ${C.cyan}https://q.qq.com/qqbot/openclaw/login.html${C.reset}`);
|
||
console.log(` 2. 用手机 QQ 扫码注册/登录`);
|
||
console.log(` 3. 创建机器人后复制 App ID 和 App Secret\n`);
|
||
|
||
const appId = await input({ prompt: '请输入 QQ 机器人 App ID', placeholder: '' });
|
||
if (!appId) { console.log(`${C.yellow}已取消${C.reset}`); break; }
|
||
|
||
const appSecret = await input({ prompt: '请输入 QQ 机器人 App Secret', placeholder: '' });
|
||
if (!appSecret) { console.log(`${C.yellow}已取消${C.reset}`); break; }
|
||
|
||
// 写入配置
|
||
const cfg = readConfig();
|
||
if (!cfg.channels) cfg.channels = {};
|
||
if (!cfg.channels.qqbot) cfg.channels.qqbot = {};
|
||
cfg.channels.qqbot.appId = appId;
|
||
cfg.channels.qqbot.clientSecret = appSecret;
|
||
cfg.channels.qqbot.enabled = true;
|
||
writeConfig(cfg);
|
||
|
||
console.log(`\n${C.green}✅ QQ 机器人配置已保存${C.reset}\n`);
|
||
await askRestart();
|
||
break;
|
||
}
|
||
case 'telegram': {
|
||
console.log(`\n${C.bold}Telegram Bot 配置${C.reset}\n`);
|
||
console.log(`${C.yellow}获取 Bot Token:${C.reset}`);
|
||
console.log(` 1. 打开 Telegram → 搜索 ${C.cyan}@BotFather${C.reset}`);
|
||
console.log(` 2. 发送 ${C.cyan}/newbot${C.reset} → 按提示创建`);
|
||
console.log(` 3. 复制生成的 Token\n`);
|
||
|
||
const token = await input({ prompt: '请输入 Telegram Bot Token', placeholder: '123456:ABC...' });
|
||
if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }
|
||
|
||
// 验证格式
|
||
if (!/^[0-9]+:[A-Za-z0-9_-]+$/.test(token)) {
|
||
console.log(`${C.red}✗ Token 格式错误${C.reset}`);
|
||
console.log(`${C.yellow}正确格式: 123456789:ABCdefGHIjklMNOpqr${C.reset}\n`);
|
||
break;
|
||
}
|
||
|
||
const cfg = readConfig();
|
||
if (!cfg.channels) cfg.channels = {};
|
||
if (!cfg.channels.telegram) cfg.channels.telegram = {};
|
||
cfg.channels.telegram.botToken = token;
|
||
writeConfig(cfg);
|
||
|
||
console.log(`\n${C.green}✅ Telegram Bot Token 已保存${C.reset}\n`);
|
||
await askRestart();
|
||
break;
|
||
}
|
||
case 'discord': {
|
||
console.log(`\n${C.bold}Discord Bot 配置${C.reset}\n`);
|
||
console.log(`${C.yellow}获取 Bot Token:${C.cyan} https://discord.com/developers/applications${C.reset}\n`);
|
||
|
||
const token = await input({ prompt: '请输入 Discord Bot Token', placeholder: '' });
|
||
if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }
|
||
|
||
const cfg = readConfig();
|
||
if (!cfg.channels) cfg.channels = {};
|
||
if (!cfg.channels.discord) cfg.channels.discord = {};
|
||
cfg.channels.discord.token = token;
|
||
delete cfg.channels.discord.botToken;
|
||
writeConfig(cfg);
|
||
|
||
console.log(`\n${C.green}✅ Discord Bot Token 已保存${C.reset}\n`);
|
||
await askRestart();
|
||
break;
|
||
}
|
||
case 'feishu': {
|
||
console.log(`\n${C.bold}飞书 Bot 配置${C.reset}\n`);
|
||
console.log(`${C.cyan}即将执行飞书官方安装向导...${C.reset}\n`);
|
||
|
||
const doInstall = await confirm({ prompt: '是否开始安装?', defaultYes: true });
|
||
if (!doInstall) break;
|
||
|
||
console.log(`\n${C.cyan}正在启动飞书安装向导...${C.reset}\n`);
|
||
try {
|
||
const npxBin = fs.existsSync(`${NODE_BASE}/bin/npx`) ? `${NODE_BASE}/bin/npx` : 'npx';
|
||
await runCommand(npxBin, ['-y', '@larksuite/openclaw-lark-tools', 'install'], {
|
||
interactive: true,
|
||
cwd: OC_DATA,
|
||
env: { HOME: OC_DATA, PATH: `${NODE_BASE}/bin:${process.env.PATH || ''}` }
|
||
});
|
||
} catch (e) {
|
||
console.log(`${C.yellow}安装向导已退出${C.reset}\n`);
|
||
}
|
||
break;
|
||
}
|
||
case 'slack': {
|
||
console.log(`\n${C.bold}Slack Bot 配置${C.reset}\n`);
|
||
console.log(`${C.yellow}获取 Bot Token:${C.cyan} https://api.slack.com/apps${C.reset}\n`);
|
||
|
||
const token = await input({ prompt: '请输入 Slack Bot Token (xoxb-...)', placeholder: '' });
|
||
if (!token) { console.log(`${C.yellow}已取消${C.reset}`); break; }
|
||
|
||
const cfg = readConfig();
|
||
if (!cfg.channels) cfg.channels = {};
|
||
if (!cfg.channels.slack) cfg.channels.slack = {};
|
||
cfg.channels.slack.botToken = token;
|
||
writeConfig(cfg);
|
||
|
||
console.log(`\n${C.green}✅ Slack Bot Token 已保存${C.reset}\n`);
|
||
await askRestart();
|
||
break;
|
||
}
|
||
case 'whatsapp': {
|
||
const gwToken = jsonGet('gateway.auth.token') || '';
|
||
const gwPort = jsonGet('gateway.port') || '18789';
|
||
console.log(`\n${C.yellow}WhatsApp 需要通过 Web 控制台扫码配对:${C.reset}`);
|
||
console.log(`${C.cyan}http://<你的路由器IP>:${gwPort}/?token=${gwToken}${C.reset}`);
|
||
console.log(`打开后进入 Channels → WhatsApp 扫码即可。\n`);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
case 'telegram-pairing': {
|
||
// 配对 (pairing) 与 Bot Token 配置是两件不同的事:
|
||
// - Token 配置 -> 上面的 'telegram' 分支 / channels add --bot-token
|
||
// - 用户配对 -> openclaw pairing list / pairing approve
|
||
// 旧实现调用的 `models auth login-telegram-bot` 在 2026.6+ 已不存在
|
||
// (实测报 Too many arguments for this command),这里改为对齐上游
|
||
// pairing 命令,与 oc-config.sh 的 telegram_pairing() 行为保持一致。
|
||
console.log(`\n${C.bold}🤝 Telegram 配对助手${C.reset}\n`);
|
||
|
||
const tgToken = jsonGet('channels.telegram.botToken');
|
||
if (!tgToken) {
|
||
console.log(`${C.yellow}未检测到 Telegram Bot Token,请先在「Telegram」中配置 Token。${C.reset}\n`);
|
||
await input({ prompt: '按回车返回', defaultValue: '' });
|
||
break;
|
||
}
|
||
|
||
// 先确认 Token 与网络可用,避免用户在配对环节盲等
|
||
console.log(`${C.cyan}诊断 Telegram API 连通性...${C.reset}`);
|
||
let botName = '';
|
||
try {
|
||
const probe = execSync(
|
||
`curl -s --connect-timeout 5 --max-time 10 "https://api.telegram.org/bot${tgToken}/getMe"`,
|
||
{ encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }
|
||
);
|
||
if (/"ok"\s*:\s*true/.test(probe)) {
|
||
const m = probe.match(/"username"\s*:\s*"([^"]+)"/);
|
||
botName = m ? m[1] : '';
|
||
console.log(`${C.green}✅ Telegram API 连通正常${botName ? ` — @${botName}` : ''}${C.reset}`);
|
||
} else {
|
||
console.log(`${C.red}❌ Telegram API 连通检测未通过${C.reset}`);
|
||
console.log(`${C.yellow} 可能原因: Token 不正确、网络不通 或 Telegram 被屏蔽${C.reset}`);
|
||
console.log(`${C.cyan} 建议: 重新配置 Token 或检查代理/网络设置${C.reset}\n`);
|
||
await input({ prompt: '按回车返回', defaultValue: '' });
|
||
break;
|
||
}
|
||
} catch {
|
||
console.log(`${C.yellow}⚠️ 无法完成连通性检测,继续尝试配对${C.reset}`);
|
||
}
|
||
|
||
console.log('');
|
||
console.log(`${C.green}请在 Telegram 中向 Bot 发送 /start,然后回到这里继续${C.reset}`);
|
||
console.log('');
|
||
const go = await input({ prompt: '发送 /start 后按回车继续 (输入 q 退出)', defaultValue: '' });
|
||
if (String(go).toLowerCase() === 'q') break;
|
||
|
||
const approveCode = (code) => {
|
||
const res = ocCmdCapture('pairing', 'approve', 'telegram', code);
|
||
return res.ok || /approved|success|ok/i.test(res.stdout);
|
||
};
|
||
|
||
let paired = false;
|
||
for (let attempt = 1; attempt <= 3 && !paired; attempt++) {
|
||
console.log(`${C.cyan}检测配对请求... (第 ${attempt}/3 轮)${C.reset}`);
|
||
const listed = ocCmdCapture('pairing', 'list', 'telegram', '--json');
|
||
const codes = parsePairingCodes(listed.stdout);
|
||
|
||
for (const code of codes) {
|
||
console.log(`${C.cyan}发现配对请求: ${code}${C.reset}`);
|
||
if (approveCode(code)) {
|
||
console.log(`\n${C.green}${C.bold}🎉 Telegram 配对成功!${C.reset}`);
|
||
paired = true;
|
||
} else {
|
||
console.log(`${C.yellow}配对码 ${code} 处理失败${C.reset}`);
|
||
}
|
||
}
|
||
|
||
if (!paired && attempt < 3) {
|
||
console.log(`${C.yellow}未检测到,等待 8 秒后重试...${C.reset}`);
|
||
await new Promise((r) => setTimeout(r, 8000));
|
||
}
|
||
}
|
||
|
||
if (!paired) {
|
||
console.log('');
|
||
console.log(`${C.yellow}未自动检测到配对请求。${C.reset}`);
|
||
console.log(`${C.cyan}如果 Bot 已回复配对码,可手动输入 (回车跳过):${C.reset}`);
|
||
const manual = await input({ prompt: '配对码', defaultValue: '' });
|
||
if (manual) {
|
||
if (approveCode(String(manual).trim())) {
|
||
console.log(`${C.green}${C.bold}🎉 Telegram 配对成功!${C.reset}`);
|
||
paired = true;
|
||
} else {
|
||
console.log(`${C.yellow}配对失败,请确认配对码是否正确或重新发送 /start${C.reset}`);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (paired) {
|
||
console.log(`\n${C.cyan}正在重启 Gateway 使配对生效...${C.reset}`);
|
||
await restartGateway();
|
||
console.log(`${C.green}✅ 现在可以在 Telegram 中与 Bot 对话了!${C.reset}\n`);
|
||
} else {
|
||
console.log('');
|
||
await input({ prompt: '按回车返回', defaultValue: '' });
|
||
}
|
||
break;
|
||
}
|
||
case 'wizard': {
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}启动官方渠道配置向导...${C.reset}\n`);
|
||
console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
|
||
let ok = false;
|
||
try {
|
||
enableAuthPlugins();
|
||
await ocCmd('configure', '--section', 'channels');
|
||
ok = true;
|
||
} catch (e) {
|
||
console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
|
||
}
|
||
if (ok) await askRestart();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 健康检查 (对应 health_check)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleHealthCheck() {
|
||
resetRenderCount();
|
||
console.log(`\n${C.bold}健康检查${C.reset}\n`);
|
||
|
||
// 验证配置文件
|
||
console.log(`${C.cyan}验证配置文件格式...${C.reset}`);
|
||
try {
|
||
const result = await ocCmd('config', 'validate', '--json');
|
||
const validateData = JSON.parse(result.stdout);
|
||
if (validateData.valid) {
|
||
console.log(`${C.green}✅ 配置文件格式有效${C.reset}\n`);
|
||
} else if (validateData.errors && validateData.errors.length > 0) {
|
||
console.log(`${C.red}❌ 配置文件存在错误:${C.reset}`);
|
||
validateData.errors.forEach(e => console.log(` ${C.yellow}• ${e.message}${C.reset}`));
|
||
console.log('');
|
||
}
|
||
} catch (e) {
|
||
console.log(`${C.yellow}⚠️ 无法验证配置文件${C.reset}\n`);
|
||
}
|
||
|
||
// 检查端口
|
||
console.log(`${C.cyan}检查服务状态...${C.reset}`);
|
||
try {
|
||
await runCommand('/etc/init.d/openclaw', ['status_service']);
|
||
} catch (e) {}
|
||
|
||
console.log(`\n${C.cyan}提示: 查看详细日志请运行 logread -e openclaw${C.reset}`);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 显示当前配置 (对应 show_current_config)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleShowConfig() {
|
||
resetRenderCount();
|
||
|
||
const gwPort = jsonGet('gateway.port') || '18789';
|
||
const gwBind = jsonGet('gateway.bind') || 'lan';
|
||
const gwMode = jsonGet('gateway.mode') || 'local';
|
||
const currentModel = getCurrentModel();
|
||
|
||
console.log(`\n${C.green}┌──────────────────────────────────────────────────────────┐${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} 📋 ${C.bold}当前配置概览${C.reset}`);
|
||
console.log(`${C.green}├──────────────────────────────────────────────────────────┤${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} 网关端口 ............ ${C.cyan}${gwPort}${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} 绑定模式 ............ ${C.cyan}${gwBind}${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} 运行模式 ............ ${C.cyan}${gwMode}${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} 活跃模型 ............ ${currentModel ? C.cyan + currentModel : C.yellow + '未配置'}${C.reset}`);
|
||
|
||
// 渠道状态
|
||
console.log(`${C.green}├──────────────────────────────────────────────────────────┤${C.reset}`);
|
||
console.log(`${C.green}│${C.reset} ${C.bold}渠道配置状态${C.reset}`);
|
||
|
||
const tgToken = jsonGet('channels.telegram.botToken');
|
||
const dcToken = jsonGet('channels.discord.token') || jsonGet('channels.discord.botToken');
|
||
const fsAppId = jsonGet('channels.feishu.appId');
|
||
const skToken = jsonGet('channels.slack.botToken');
|
||
const qqAppId = jsonGet('channels.qqbot.appId');
|
||
|
||
if (qqAppId) {
|
||
console.log(`${C.green}│${C.reset} QQ (qqbot) ......... ${C.green}✅ 已配置${C.reset} (AppID: ${qqAppId.slice(0, 8)}...)`);
|
||
} else {
|
||
console.log(`${C.green}│${C.reset} QQ (qqbot) ......... ${C.yellow}❌ 未配置${C.reset}`);
|
||
}
|
||
if (tgToken) {
|
||
console.log(`${C.green}│${C.reset} Telegram ........... ${C.green}✅ 已配置${C.reset} (${tgToken.slice(0, 12)}...)`);
|
||
} else {
|
||
console.log(`${C.green}│${C.reset} Telegram ........... ${C.yellow}❌ 未配置${C.reset}`);
|
||
}
|
||
if (dcToken) {
|
||
console.log(`${C.green}│${C.reset} Discord ............ ${C.green}✅ 已配置${C.reset}`);
|
||
} else {
|
||
console.log(`${C.green}│${C.reset} Discord ............ ${C.yellow}❌ 未配置${C.reset}`);
|
||
}
|
||
if (fsAppId) {
|
||
console.log(`${C.green}│${C.reset} 飞书 ............... ${C.green}✅ 已配置${C.reset} (AppID: ${fsAppId.slice(0, 6)}...)`);
|
||
} else {
|
||
console.log(`${C.green}│${C.reset} 飞书 ............... ${C.yellow}❌ 未配置${C.reset}`);
|
||
}
|
||
if (skToken) {
|
||
console.log(`${C.green}│${C.reset} Slack .............. ${C.green}✅ 已配置${C.reset}`);
|
||
} else {
|
||
console.log(`${C.green}│${C.reset} Slack .............. ${C.yellow}❌ 未配置${C.reset}`);
|
||
}
|
||
|
||
console.log(`${C.green}└──────────────────────────────────────────────────────────┘${C.reset}\n`);
|
||
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 设备配对管理 (Control UI / 浏览器配对审批)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function manageDevicePairing() {
|
||
while (true) {
|
||
resetRenderCount();
|
||
console.log(`\n${C.bold}📱 设备配对管理 (Control UI / 浏览器配对审批)${C.reset}\n`);
|
||
console.log(`${C.yellow}⚠️ 风险提示:${C.reset}`);
|
||
console.log(`${C.yellow} 批准设备配对后,该浏览器/客户端将获得 OpenClaw 网关的完全控制权限。${C.reset}`);
|
||
console.log(`${C.yellow} 请确保在受信任的局域网环境,并仅在您本人正在连接时批准!${C.reset}\n`);
|
||
|
||
const listed = ocCmdCapture('devices', 'list', '--json');
|
||
let pending = [];
|
||
let paired = [];
|
||
try {
|
||
const data = JSON.parse(listed.stdout);
|
||
if (Array.isArray(data.pending)) pending = data.pending;
|
||
if (Array.isArray(data.paired)) paired = data.paired;
|
||
} catch (e) {
|
||
const m = (listed.stdout || '').match(/(\{[\s\S]*"pending"[\s\S]*\})/);
|
||
if (m) {
|
||
try {
|
||
const d = JSON.parse(m[1]);
|
||
if (Array.isArray(d.pending)) pending = d.pending;
|
||
if (Array.isArray(d.paired)) paired = d.paired;
|
||
} catch (_) {}
|
||
}
|
||
}
|
||
|
||
function renderPairedDevices(list) {
|
||
console.log(`\n${C.bold}📋 已配对设备 (${list.length})${C.reset}\n`);
|
||
if (list.length === 0) {
|
||
console.log(` ${C.dim}暂无已配对设备记录${C.reset}`);
|
||
} else {
|
||
list.forEach((d, idx) => {
|
||
console.log(` ${C.cyan}[${idx + 1}]${C.reset} 设备 ID: ${d.deviceId || ''}`);
|
||
console.log(` 平台: ${d.platform || '未知'} | 客户端: ${d.clientId || ''} | IP: ${d.remoteIp || ''}`);
|
||
});
|
||
}
|
||
console.log('');
|
||
}
|
||
|
||
if (pending.length > 0) {
|
||
console.log(`${C.green}🔔 当前检测到 ${pending.length} 个待配对请求:${C.reset}\n`);
|
||
pending.forEach((item, idx) => {
|
||
const rid = item.requestId || '未知ID';
|
||
const ip = item.remoteIp || item.ip || '未知IP';
|
||
const client = item.clientId || item.clientMode || 'webchat';
|
||
const plat = item.platform || '';
|
||
const role = item.role || (item.roles && item.roles.join(',')) || 'operator';
|
||
console.log(` ${C.cyan}[${idx + 1}]${C.reset} 请求 ID: ${C.bold}${rid}${C.reset}`);
|
||
console.log(` 来源 IP: ${C.green}${ip}${C.reset} | 客户端: ${client}${plat ? ' (' + plat + ')' : ''} | 角色: ${role}`);
|
||
});
|
||
console.log('');
|
||
|
||
const choice = await select({
|
||
title: '请选择操作',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: '一键批准所有待配对请求', desc: `共 ${pending.length} 个待审批`, value: 'approve-all' },
|
||
{ key: '2', label: '选择指定请求批准', desc: '', value: 'approve-select' },
|
||
{ key: '3', label: '刷新待配对列表', desc: '', value: 'refresh' },
|
||
{ key: '4', label: '查看已配对设备列表', desc: `当前已配对 ${paired.length} 台设备`, value: 'view-paired' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回上级菜单', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
if (!choice || choice.value === 'back') break;
|
||
if (choice.value === 'refresh') continue;
|
||
if (choice.value === 'view-paired') {
|
||
renderPairedDevices(paired);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
continue;
|
||
}
|
||
|
||
if (choice.value === 'approve-all') {
|
||
const ok = await confirm({
|
||
message: `${C.yellow}确认一键批准全部 ${pending.length} 个设备配对请求吗?${C.reset}`,
|
||
defaultValue: true,
|
||
});
|
||
if (ok) {
|
||
console.log(`\n${C.cyan}正在批准设备配对...${C.reset}`);
|
||
let success = 0;
|
||
for (const item of pending) {
|
||
const res = ocCmdCapture('devices', 'approve', item.requestId);
|
||
if (res.ok || /approved|success/i.test(res.stdout)) {
|
||
console.log(`${C.green}✅ 已批准: ${item.requestId} (${item.remoteIp || ''})${C.reset}`);
|
||
success++;
|
||
} else {
|
||
console.log(`${C.red}❌ 批准失败: ${item.requestId} — ${res.stdout || res.stderr}${C.reset}`);
|
||
}
|
||
}
|
||
fixStatePermissions();
|
||
console.log(`\n${C.green}操作完成:成功 ${success}/${pending.length} 个${C.reset}`);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
} else if (choice.value === 'approve-select') {
|
||
const selectItems = pending.map((item, idx) => ({
|
||
key: String(idx + 1),
|
||
label: `批准: ${item.remoteIp || '设备'} (${(item.requestId || '').slice(0, 8)}...)`,
|
||
desc: `IP: ${item.remoteIp || ''} | ${item.platform || ''}`,
|
||
value: item.requestId,
|
||
}));
|
||
selectItems.push({ label: '', disabled: true });
|
||
selectItems.push({ key: '0', label: '取消', desc: '', value: 'cancel' });
|
||
|
||
const picked = await select({
|
||
title: '请选择要批准的设备请求',
|
||
showSearch: false,
|
||
items: selectItems,
|
||
});
|
||
|
||
if (picked && picked.value !== 'cancel') {
|
||
const res = ocCmdCapture('devices', 'approve', picked.value);
|
||
if (res.ok || /approved|success/i.test(res.stdout)) {
|
||
fixStatePermissions();
|
||
console.log(`\n${C.green}✅ 成功批准设备请求: ${picked.value}${C.reset}`);
|
||
} else {
|
||
console.log(`\n${C.red}❌ 批准失败: ${res.stdout || res.stderr}${C.reset}`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
}
|
||
} else {
|
||
console.log(`${C.dim}当前无待配对设备请求。${C.reset}`);
|
||
console.log(`${C.dim}(在浏览器访问 OpenClaw Web 控制台时若提示「需要设备配对」,在此处刷新即可发现)${C.reset}\n`);
|
||
|
||
const choice = await select({
|
||
title: '设备配对管理',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: '刷新待配对列表', desc: '', value: 'refresh' },
|
||
{ key: '2', label: '手动输入 Request ID 批准', desc: '', value: 'manual' },
|
||
{ key: '3', label: '查看已配对设备列表', desc: `当前已配对 ${paired.length} 台设备`, value: 'view-paired' },
|
||
{ label: '', disabled: true },
|
||
{ key: '0', label: '返回上级菜单', desc: '', value: 'back' },
|
||
],
|
||
});
|
||
|
||
if (!choice || choice.value === 'back') break;
|
||
if (choice.value === 'refresh') continue;
|
||
|
||
if (choice.value === 'manual') {
|
||
const reqId = await input({ prompt: '请输入待批准的 Request ID', defaultValue: '' });
|
||
if (reqId && reqId.trim()) {
|
||
const res = ocCmdCapture('devices', 'approve', reqId.trim());
|
||
if (res.ok || /approved|success/i.test(res.stdout)) {
|
||
fixStatePermissions();
|
||
console.log(`\n${C.green}✅ 成功批准设备请求: ${reqId.trim()}${C.reset}`);
|
||
} else {
|
||
console.log(`\n${C.red}❌ 批准失败: ${res.stdout || res.stderr}${C.reset}`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
} else if (choice.value === 'view-paired') {
|
||
renderPairedDevices(paired);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 高级配置处理 (对应 advanced_menu)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleAdvancedConfig() {
|
||
while (true) {
|
||
const choice = await showAdvancedMenu();
|
||
if (!choice || choice.value === 'back') break;
|
||
|
||
resetRenderCount();
|
||
|
||
switch (choice.value) {
|
||
case 'port': {
|
||
const newPort = await input({
|
||
prompt: '请输入 Gateway 端口',
|
||
defaultValue: String(jsonGet('gateway.port') || '18789'),
|
||
});
|
||
if (newPort) {
|
||
jsonSet('gateway.port', parseInt(newPort));
|
||
try { execSync(`uci set openclaw.main.port="${newPort}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}
|
||
console.log(`\n${C.green}✅ 端口已设置为 ${newPort}${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'bind': {
|
||
const bindChoice = await select({
|
||
title: '绑定地址选项',
|
||
showSearch: false,
|
||
items: [
|
||
// 取值必须与 schema 的 gateway.bind 枚举一致:
|
||
// auto/lan/loopback/custom/tailnet。旧选项 all 不被上游接受
|
||
// (实测: gateway.bind: Invalid input),监听所有接口用 custom。
|
||
{ key: '1', label: 'lan', desc: '仅 LAN 接口 (推荐)', value: 'lan' },
|
||
{ key: '2', label: 'loopback', desc: '仅本机访问', value: 'loopback' },
|
||
{ key: '3', label: 'auto', desc: '自动选择', value: 'auto' },
|
||
{ key: '4', label: 'custom', desc: '自定义地址 (0.0.0.0 = 所有接口)', value: 'custom' },
|
||
{ key: '5', label: 'tailnet', desc: 'Tailscale 网络', value: 'tailnet' },
|
||
],
|
||
});
|
||
if (bindChoice) {
|
||
if (bindChoice.value === 'custom') {
|
||
const host = await input({ prompt: '监听地址', defaultValue: jsonGet('gateway.customBindHost') || '0.0.0.0' });
|
||
if (host) jsonSet('gateway.customBindHost', host);
|
||
}
|
||
jsonSet('gateway.bind', bindChoice.value);
|
||
try { execSync(`uci set openclaw.main.bind="${bindChoice.value}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}
|
||
console.log(`\n${C.green}✅ 绑定地址已设置为 ${bindChoice.value}${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'mode': {
|
||
const modeChoice = await select({
|
||
title: '运行模式选项',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: 'local', desc: '本地模式 (推荐)', value: 'local' },
|
||
{ key: '2', label: 'remote', desc: '远程模式', value: 'remote' },
|
||
],
|
||
});
|
||
if (modeChoice) {
|
||
jsonSet('gateway.mode', modeChoice.value);
|
||
console.log(`\n${C.green}✅ 运行模式已设置为 ${modeChoice.value}${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'loglevel': {
|
||
const levelChoice = await select({
|
||
title: '日志级别选项',
|
||
showSearch: false,
|
||
items: [
|
||
// 取值与 schema 的 logging.level 枚举一致 (7 档)
|
||
{ key: '1', label: 'info', desc: '常规信息 (默认)', value: 'info' },
|
||
{ key: '2', label: 'warn', desc: '警告及以上', value: 'warn' },
|
||
{ key: '3', label: 'error', desc: '仅错误', value: 'error' },
|
||
{ key: '4', label: 'debug', desc: '详细调试', value: 'debug' },
|
||
{ key: '5', label: 'trace', desc: '最详细 (排障用)', value: 'trace' },
|
||
{ key: '6', label: 'fatal', desc: '仅致命错误', value: 'fatal' },
|
||
{ key: '7', label: 'silent', desc: '完全静默', value: 'silent' },
|
||
],
|
||
});
|
||
if (levelChoice) {
|
||
// 正确键是顶层 logging.level;gateway.logLevel 不在 schema 中,
|
||
// 写入会被上游忽略,表现为"显示已设置但从未生效"。
|
||
jsonSet('logging.level', levelChoice.value);
|
||
// 清理旧配置里可能残留的错误键,避免界面回显到失效值
|
||
try {
|
||
const cfg = readConfig();
|
||
if (cfg.gateway && Object.prototype.hasOwnProperty.call(cfg.gateway, 'logLevel')) {
|
||
delete cfg.gateway.logLevel;
|
||
writeConfig(cfg);
|
||
}
|
||
} catch {}
|
||
console.log(`\n${C.green}✅ 日志级别已设置为 ${levelChoice.value}${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'acp': {
|
||
const acpChoice = await select({
|
||
title: 'ACP Dispatch 选项',
|
||
showSearch: false,
|
||
items: [
|
||
{ key: '1', label: 'false', desc: '禁用 (推荐路由器使用)', value: 'false' },
|
||
{ key: '2', label: 'true', desc: '启用 (可能占用大量内存)', value: 'true' },
|
||
],
|
||
});
|
||
if (acpChoice) {
|
||
jsonSet('acp.dispatch.enabled', acpChoice.value === 'true');
|
||
console.log(`\n${C.green}✅ ACP Dispatch 已设置为 ${acpChoice.value}${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'wizard': {
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}启动官方配置向导...${C.reset}\n`);
|
||
console.log(`${C.yellow}提示: ↑↓ 移动, Tab/空格 选中, 回车 确认${C.reset}\n`);
|
||
let ok = false;
|
||
try {
|
||
enableAuthPlugins();
|
||
await ocCmd('configure');
|
||
ok = true;
|
||
} catch (e) {
|
||
console.log(`${C.yellow}配置向导已退出${C.reset}\n`);
|
||
}
|
||
if (ok) await askRestart();
|
||
break;
|
||
}
|
||
case 'view-json':
|
||
console.log(`\n${C.cyan}配置文件路径: ${CONFIG_FILE}${C.reset}\n`);
|
||
try {
|
||
const content = fs.readFileSync(CONFIG_FILE, 'utf8');
|
||
console.log(content);
|
||
} catch (e) {
|
||
console.log(`${C.red}无法读取配置文件${C.reset}`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
case 'edit':
|
||
console.log(`\n${C.yellow}请在 SSH 终端中手动编辑配置文件:${C.reset}`);
|
||
console.log(` vi ${CONFIG_FILE}\n`);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
case 'backup':
|
||
await handleBackup();
|
||
break;
|
||
case 'import': {
|
||
const importPath = await input({
|
||
prompt: '请输入备份文件路径',
|
||
defaultValue: '',
|
||
});
|
||
if (importPath && fs.existsSync(importPath)) {
|
||
try {
|
||
fs.copyFileSync(importPath, CONFIG_FILE);
|
||
execSync(`chown openclaw:openclaw "${CONFIG_FILE}" 2>/dev/null || true`, { stdio: 'ignore' });
|
||
fixStatePermissions();
|
||
console.log(`\n${C.green}✅ 配置已导入${C.reset}\n`);
|
||
await askRestart();
|
||
} catch (e) {
|
||
console.log(`${C.red}导入失败: ${e.message}${C.reset}\n`);
|
||
}
|
||
} else {
|
||
console.log(`${C.yellow}文件不存在${C.reset}\n`);
|
||
}
|
||
break;
|
||
}
|
||
case 'devices':
|
||
await manageDevicePairing();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 重置配置处理 (对应 reset_to_defaults)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleReset() {
|
||
while (true) {
|
||
const choice = await showResetMenu();
|
||
if (!choice || choice.value === 'back') break;
|
||
|
||
resetRenderCount();
|
||
|
||
switch (choice.value) {
|
||
case 'gateway': {
|
||
console.log(`\n${C.yellow}将重置: 网关端口→18789, 绑定→lan, 模式→local${C.reset}`);
|
||
console.log(`${C.yellow}保留: 认证令牌、模型配置、消息渠道${C.reset}\n`);
|
||
const ok = await confirm({ prompt: '确认恢复网关默认设置?', defaultYes: false });
|
||
if (ok) {
|
||
jsonSet('gateway.port', 18789);
|
||
jsonSet('gateway.bind', 'lan');
|
||
jsonSet('gateway.mode', 'local');
|
||
jsonSet('gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback', true);
|
||
jsonSet('gateway.tailscale.mode', 'off');
|
||
console.log(`\n${C.green}✅ 网关设置已恢复默认${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'models': {
|
||
console.log(`\n${C.red}⚠️ 将清除: 所有模型配置、API Key、活跃模型设置${C.reset}\n`);
|
||
const ok = await confirm({ prompt: '确认清除所有模型配置?', defaultYes: false });
|
||
if (ok) {
|
||
// 凭据保存在上游认证库 (state/openclaw.sqlite),通过官方 logout 逐条注销;
|
||
// auth-profiles.json 已在 2026.9.x 退役,不再读写
|
||
const failed = [];
|
||
for (const p of providers.status().profiles) {
|
||
const r = providers.removeAuth(p.id);
|
||
if (!r.ok) failed.push(`${p.id}: ${r.reason}`);
|
||
}
|
||
const cfg = readConfig();
|
||
delete cfg.models;
|
||
if (cfg.agents?.defaults?.model) delete cfg.agents.defaults.model;
|
||
if (cfg.agents?.defaults?.models) delete cfg.agents.defaults.models;
|
||
writeConfig(cfg);
|
||
if (failed.length) {
|
||
console.log(`\n${C.yellow}以下凭据未能注销:${C.reset}`);
|
||
failed.forEach((f) => console.log(` ${C.yellow}• ${f}${C.reset}`));
|
||
}
|
||
console.log(`\n${C.green}✅ 模型配置已清除${C.reset}`);
|
||
console.log(`${C.yellow}请通过菜单 [1] 重新配置 AI 模型${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'channels': {
|
||
console.log(`\n${C.red}⚠️ 将清除: 所有消息渠道配置 (Telegram/Discord/飞书等)${C.reset}\n`);
|
||
const ok = await confirm({ prompt: '确认清除所有渠道配置?', defaultYes: false });
|
||
if (ok) {
|
||
const cfg = readConfig();
|
||
delete cfg.channels;
|
||
writeConfig(cfg);
|
||
console.log(`\n${C.green}✅ 渠道配置已清除${C.reset}\n`);
|
||
await askRestart();
|
||
}
|
||
break;
|
||
}
|
||
case 'full': {
|
||
console.log(`\n${C.red}╔══════════════════════════════════════════════════════╗${C.reset}`);
|
||
console.log(`${C.red}║ ⚠️ 完全恢复出厂设置 ║${C.reset}`);
|
||
console.log(`${C.red}║ 此操作将删除所有配置并重新初始化 ║${C.reset}`);
|
||
console.log(`${C.red}╚══════════════════════════════════════════════════════╝${C.reset}\n`);
|
||
|
||
const confirmStr = await input({ prompt: '输入 RESET 确认恢复出厂设置', defaultValue: '' });
|
||
if (confirmStr !== 'RESET') {
|
||
console.log(`${C.cyan}已取消${C.reset}\n`);
|
||
break;
|
||
}
|
||
|
||
// 执行恢复
|
||
console.log(`\n${C.cyan}[1/5] 停止 Gateway...${C.reset}`);
|
||
try { await runCommand('/etc/init.d/openclaw', ['stop']); } catch {}
|
||
|
||
console.log(`${C.cyan}[2/5] 备份当前配置...${C.reset}`);
|
||
const backupDir = `${OC_STATE_DIR}/backups`;
|
||
const backupTs = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
|
||
try {
|
||
if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${backupDir}"`, { stdio: "ignore" }); } catch {}
|
||
fs.copyFileSync(CONFIG_FILE, `${backupDir}/openclaw_${backupTs}.json`);
|
||
console.log(`${C.green} 备份已保存: backups/openclaw_${backupTs}.json${C.reset}`);
|
||
} catch {}
|
||
|
||
console.log(`${C.cyan}[3/5] 重置配置...${C.reset}`);
|
||
writeConfig({});
|
||
|
||
console.log(`${C.cyan}[4/5] 重新初始化...${C.reset}`);
|
||
// 生成新 token
|
||
const crypto = require('crypto');
|
||
const newToken = crypto.randomBytes(24).toString('hex');
|
||
|
||
console.log(`${C.cyan}[5/5] 应用 OpenWrt 适配配置...${C.reset}`);
|
||
jsonSet('gateway.port', 18789);
|
||
jsonSet('gateway.bind', 'lan');
|
||
jsonSet('gateway.mode', 'local');
|
||
jsonSet('gateway.auth.mode', 'token');
|
||
jsonSet('gateway.auth.token', newToken);
|
||
jsonSet('gateway.controlUi.dangerouslyAllowHostHeaderOriginFallback', true);
|
||
jsonSet('gateway.tailscale.mode', 'off');
|
||
jsonSet('acp.dispatch.enabled', false);
|
||
jsonSet('tools.profile', 'coding');
|
||
|
||
try { execSync(`uci set openclaw.main.token="${newToken}" && uci commit openclaw`, { stdio: 'ignore' }); } catch {}
|
||
|
||
console.log(`\n${C.green}✅ 出厂设置已恢复!${C.reset}\n`);
|
||
console.log(`${C.cyan}新认证令牌: ${newToken}${C.reset}\n`);
|
||
|
||
await restartGateway();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 备份/还原处理 (对应 backup_restore_menu)
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function handleBackup() {
|
||
while (true) {
|
||
const choice = await showBackupMenu();
|
||
if (!choice || choice.value === 'back') break;
|
||
|
||
resetRenderCount();
|
||
const backupDir = `${OC_STATE_DIR}/backups`;
|
||
try { if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true }); try { execSync(`chown openclaw:openclaw "${backupDir}"`, { stdio: "ignore" }); } catch {} } catch {}
|
||
|
||
switch (choice.value) {
|
||
case 'create-config': {
|
||
console.log(`\n${C.cyan}正在创建配置备份...${C.reset}`);
|
||
try {
|
||
await ocCmd('backup', 'create', '--only-config', '--no-include-workspace');
|
||
console.log(`${C.green}✅ 配置备份已创建${C.reset}\n`);
|
||
} catch (e) {
|
||
console.log(`${C.yellow}⚠️ 备份功能需要 OpenClaw v2026.3.8+${C.reset}\n`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
case 'create-full': {
|
||
console.log(`\n${C.cyan}正在创建完整备份...${C.reset}`);
|
||
try {
|
||
await ocCmd('backup', 'create', '--no-include-workspace');
|
||
console.log(`${C.green}✅ 完整备份已创建${C.reset}\n`);
|
||
} catch (e) {
|
||
console.log(`${C.yellow}⚠️ 备份失败${C.reset}\n`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
case 'verify': {
|
||
const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.tar.gz')).sort().reverse();
|
||
if (files.length === 0) {
|
||
console.log(`${C.yellow}未找到备份文件${C.reset}\n`);
|
||
} else {
|
||
const latest = `${backupDir}/${files[0]}`;
|
||
console.log(`${C.cyan}验证备份: ${latest}${C.reset}`);
|
||
try {
|
||
await ocCmd('backup', 'verify', latest);
|
||
} catch {}
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
case 'list': {
|
||
const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.tar.gz') || f.endsWith('.json')).sort().reverse();
|
||
if (files.length === 0) {
|
||
console.log(`${C.yellow}暂无备份文件${C.reset}\n`);
|
||
} else {
|
||
console.log(`\n${C.bold}备份文件列表:${C.reset}`);
|
||
files.slice(0, 10).forEach(f => {
|
||
const stat = fs.statSync(`${backupDir}/${f}`);
|
||
console.log(` ${C.dim}${f} (${(stat.size / 1024).toFixed(1)} KB)${C.reset}`);
|
||
});
|
||
console.log(`${C.dim}\n备份目录: ${backupDir}${C.reset}\n`);
|
||
}
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
case 'restore': {
|
||
const files = fs.readdirSync(backupDir).filter(f => f.endsWith('.json')).sort().reverse();
|
||
if (files.length === 0) {
|
||
console.log(`${C.yellow}未找到配置备份文件${C.reset}\n`);
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
}
|
||
|
||
const fileChoice = await select({
|
||
title: '选择备份文件',
|
||
showSearch: false,
|
||
items: files.slice(0, 10).map((f, i) => ({
|
||
key: String(i + 1),
|
||
label: f,
|
||
desc: '',
|
||
value: f,
|
||
})),
|
||
});
|
||
|
||
if (!fileChoice) break;
|
||
|
||
const ok = await confirm({ prompt: '确认恢复此备份?', defaultYes: false });
|
||
if (ok) {
|
||
try {
|
||
fs.copyFileSync(`${backupDir}/${fileChoice.value}`, CONFIG_FILE);
|
||
console.log(`\n${C.green}✅ 配置已恢复${C.reset}\n`);
|
||
await askRestart();
|
||
} catch (e) {
|
||
console.log(`${C.red}恢复失败: ${e.message}${C.reset}\n`);
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
// 主函数
|
||
// ═══════════════════════════════════════════════════════════════════════════
|
||
|
||
async function main() {
|
||
const command = process.argv[2];
|
||
|
||
if (command === 'model') {
|
||
await handleModelConfig();
|
||
return;
|
||
}
|
||
|
||
if (command === 'status') {
|
||
await runCommand('/etc/init.d/openclaw', ['status_service']);
|
||
return;
|
||
}
|
||
|
||
if (command === 'restart') {
|
||
const ok = await confirm({ prompt: '确认重启 OpenClaw 服务?' });
|
||
if (ok) await runCommand('/etc/init.d/openclaw', ['restart']);
|
||
return;
|
||
}
|
||
|
||
// 交互式主菜单
|
||
while (true) {
|
||
const choice = await showMainMenu();
|
||
|
||
if (!choice || choice.value === 'quit') {
|
||
console.log(`\n${C.green}再见!${C.reset}\n`);
|
||
break;
|
||
}
|
||
|
||
switch (choice.value) {
|
||
case 'model':
|
||
await handleModelConfig();
|
||
break;
|
||
case 'set-active-model':
|
||
await handleSetActiveModel();
|
||
break;
|
||
case 'channels':
|
||
await handleChannels();
|
||
break;
|
||
case 'health':
|
||
await handleHealthCheck();
|
||
break;
|
||
case 'logs':
|
||
resetRenderCount();
|
||
console.log(`\n${C.cyan}=== OpenClaw 日志 ===${C.reset}\n`);
|
||
await runCommand('logread', ['-e', 'openclaw']);
|
||
console.log('');
|
||
await input({ prompt: '按回车继续', defaultValue: '' });
|
||
break;
|
||
case 'restart':
|
||
resetRenderCount();
|
||
await restartGateway();
|
||
break;
|
||
case 'devices':
|
||
await manageDevicePairing();
|
||
break;
|
||
case 'advanced':
|
||
await handleAdvancedConfig();
|
||
break;
|
||
case 'reset':
|
||
await handleReset();
|
||
break;
|
||
case 'show-config':
|
||
await handleShowConfig();
|
||
break;
|
||
case 'backup':
|
||
await handleBackup();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 菜单引擎读过 stdin 后它仍处于 flowing 状态,不暂停的话进程不会退出,Web 终端会停在「再见」
|
||
main().then(() => process.stdin.pause()).catch(e => {
|
||
if (e instanceof ConfigParseError) {
|
||
// 配置损坏: 给出可直接执行的恢复步骤,而不是丢一句解析错误了事
|
||
console.error(`\n${C.red}配置读取失败:${C.reset} ${e.message}\n`);
|
||
console.error(configRecoveryHint());
|
||
console.error('');
|
||
process.exit(2);
|
||
}
|
||
console.error(`${C.red}错误:${C.reset}`, e.message);
|
||
process.exit(1);
|
||
});
|