@autotask/atools-tool 0.1.8 → 0.1.10

package/README.md

@@ -31,6 +31,8 @@ Selection UX:
 - TTY terminal: use `↑/↓` and `Enter`
 - Non-TTY: falls back to number input
 
+If proxy startup fails during `atools-tool openclaw`, the CLI now prints environment-aware troubleshooting hints (systemd user bus, permissions, port readiness) and does not silently fail.
+
 Rollback to codex-compatible defaults:
 
 ```bash
@@ -42,7 +44,7 @@ Recommended selections:
 1. `gpt-5.3-codex`
 2. `off`
 3. `low`
-4. Input your sub2api-compatible key
+4. Input your ATools key (same as ATOOLS_OAI_KEY)
 
 ## Install (npm)
 
@@ -53,18 +55,18 @@ npm i -g @autotask/atools-tool
 Default full install (recommended):
 
 ```bash
-npm i -g @autotask/atools-tool && atools-tool-install && atools-tool openclaw
+npm i -g @autotask/atools-tool && atools-tool install-proxy && atools-tool openclaw
 ```
 
 Optional installer command:
 
 ```bash
-atools-tool-install --help
+atools-tool install-proxy --help
 ```
 
-`atools-tool-install` service behavior by platform:
+`atools-tool install-proxy` service behavior by platform (legacy alias: `atools-tool-install`):
 
-- Linux: systemd user service
+- Linux: systemd user service (fallback to detached process if `systemctl --user` is unavailable)
 - macOS: launchd user agent (`~/Library/LaunchAgents`)
 - Windows: Task Scheduler user task (ONLOGON + start now)
 
@@ -98,6 +100,7 @@ curl -fsSL https://raw.githubusercontent.com/aak1247/sub2api-openclaw-proxy/main
 - patches `~/.openclaw/agents/main/agent/auth-profiles.json` (if API key is available)
 - service install by platform:
   - Linux: creates/enables `~/.config/systemd/user/openclaw-atools-proxy.service`
+    - if user bus/systemd is unavailable (for example container/root without login bus), installer auto-falls back to detached proxy process
   - macOS: creates/enables `~/Library/LaunchAgents/openclaw-atools-proxy.plist`
   - Windows: creates/updates scheduled task `openclaw-atools-proxy`
 - restarts `openclaw-gateway.service` only on Linux (unless `--no-restart`)

package/bin/cli.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 import { createProxyServer } from '../lib/proxy-server.mjs';
 import { runConfigOpenclaw } from '../lib/config-openclaw.mjs';
+import { runConfigCodex } from '../lib/config-codex.mjs';
+import { runInstall } from '../lib/install.mjs';
 
 function parseArgs(argv) {
   const out = {
@@ -47,6 +49,8 @@ Commands:
   serve            Run proxy service
   openclaw         Interactive OpenClaw setup (sub2api proxy check + model/reasoning/thinking/key)
   config-openclaw  Alias of 'openclaw'
+  install-proxy    Install background proxy service for OpenClaw
+  codex            Auto-configure Codex CLI to use sub2api (direct upstream)
 
 Options:
   --openclaw-home <path> OpenClaw home dir (default: ~/.openclaw)
@@ -62,13 +66,25 @@ Options:
 }
 
 async function main() {
-  const args = parseArgs(process.argv.slice(2));
+  const argv = process.argv.slice(2);
+
+  if (argv[0] === 'install-proxy') {
+    await runInstall(argv.slice(1));
+    return;
+  }
+
+  const args = parseArgs(argv);
 
   if (args.help) {
     printHelp();
     return;
   }
 
+  if (args.cmd === 'codex') {
+    await runConfigCodex();
+    return;
+  }
+
   if (args.cmd === 'config-openclaw' || args.cmd === 'openclaw') {
     await runConfigOpenclaw({ openclawHome: args.openclawHome });
     return;

package/lib/config-codex.mjs

@@ -0,0 +1,429 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import readlinePromises from 'node:readline/promises';
+import readline from 'node:readline';
+import { spawnSync } from 'node:child_process';
+
+const PROVIDER = 'atools';
+const MODEL_OPTIONS = ['gpt-5.2', 'gpt-5.3-codex', 'gpt-5.4'];
+const DEFAULT_MODEL_ID = 'gpt-5.3-codex';
+const UPSTREAM_BASE_URL = 'https://sub2api.atools.live/v1';
+const ENV_KEY = 'ATOOLS_OAI_KEY';
+
+const USE_COLOR = Boolean(process.stdout.isTTY && process.env.NO_COLOR !== '1');
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m'
+};
+
+function withColor(text, ...codes) {
+  if (!USE_COLOR || !codes.length) return text;
+  const prefix = codes.join('');
+  return `${prefix}${text}${ANSI.reset}`;
+}
+
+function sectionTitle(text) {
+  return withColor(text, ANSI.cyan, ANSI.bold);
+}
+
+function ok(text) {
+  return withColor(text, ANSI.green);
+}
+
+function warn(text) {
+  return withColor(text, ANSI.yellow);
+}
+
+function bold(text) {
+  return withColor(text, ANSI.bold);
+}
+
+function nowStamp() {
+  const d = new Date();
+  const p = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+
+function backup(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const dest = `${filePath}.bak.${nowStamp()}`;
+  fs.copyFileSync(filePath, dest);
+  return dest;
+}
+
+function ensureDir(dirPath) {
+  fs.mkdirSync(dirPath, { recursive: true });
+}
+
+function patchCodexConfigText(original, { modelId } = {}) {
+  const provider = PROVIDER;
+  const model = modelId || DEFAULT_MODEL_ID;
+  const baseUrl = UPSTREAM_BASE_URL;
+
+  if (!original || !original.trim()) {
+    return [
+      '# Codex config generated by atools-tool',
+      `model_provider = "${provider}"`,
+      `model = "${model}"`,
+      '',
+      `[model_providers.${provider}]`,
+      'name = "ATools"',
+      `base_url = "${baseUrl}"`,
+      'wire_api = "responses"',
+      'requires_openai_auth = false',
+      `env_key = "${ENV_KEY}"`,
+      ''
+    ].join('\n');
+  }
+
+  const lines = original.replace(/\r\n/g, '\n').split('\n');
+  let currentSection = '';
+  let inProviderSection = false;
+  let sawProviderSection = false;
+  let sawModelProviderTop = false;
+  let sawModelTop = false;
+
+  const updated = [];
+
+  for (const rawLine of lines) {
+    let line = rawLine;
+    const trimmed = rawLine.trim();
+
+    const sectionMatch = trimmed.match(/^\[(.+?)\]\s*$/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      inProviderSection = currentSection === `model_providers.${provider}`;
+      if (inProviderSection) sawProviderSection = true;
+      updated.push(line);
+      continue;
+    }
+
+    if (!currentSection) {
+      if (/^model_provider\s*=/.test(trimmed)) {
+        line = `model_provider = "${provider}"`;
+        sawModelProviderTop = true;
+      } else if (/^model\s*=/.test(trimmed)) {
+        line = `model = "${model}"`;
+        sawModelTop = true;
+      }
+      updated.push(line);
+      continue;
+    }
+
+    if (inProviderSection) {
+      if (/^name\s*=/.test(trimmed)) {
+        line = 'name = "ATools"';
+      } else if (/^base_url\s*=/.test(trimmed)) {
+        line = `base_url = "${baseUrl}"`;
+      } else if (/^wire_api\s*=/.test(trimmed)) {
+        line = 'wire_api = "responses"';
+      } else if (/^requires_openai_auth\s*=/.test(trimmed)) {
+        line = 'requires_openai_auth = false';
+      } else if (/^env_key\s*=/.test(trimmed)) {
+        line = `env_key = "${ENV_KEY}"`;
+      }
+    }
+
+    updated.push(line);
+  }
+
+  let resultLines = updated;
+
+  const topInsert = [];
+  if (!sawModelProviderTop) topInsert.push(`model_provider = "${provider}"`);
+  if (!sawModelTop) topInsert.push(`model = "${model}"`);
+
+  if (topInsert.length > 0) {
+    const withTop = [];
+    let inserted = false;
+    for (let i = 0; i < resultLines.length; i += 1) {
+      if (!inserted && resultLines[i].trim() && !resultLines[i].trim().startsWith('#')) {
+        withTop.push(...topInsert, '');
+        inserted = true;
+      }
+      withTop.push(resultLines[i]);
+    }
+    if (!inserted) {
+      resultLines = [...topInsert, '', ...resultLines];
+    } else {
+      resultLines = withTop;
+    }
+  }
+
+  if (!sawProviderSection) {
+    if (resultLines.length && resultLines[resultLines.length - 1].trim() !== '') {
+      resultLines.push('');
+    }
+    resultLines.push(`[model_providers.${provider}]`);
+    resultLines.push('name = "ATools"');
+    resultLines.push(`base_url = "${baseUrl}"`);
+    resultLines.push('wire_api = "responses"');
+    resultLines.push('requires_openai_auth = false');
+    resultLines.push(`env_key = "${ENV_KEY}"`);
+    resultLines.push('');
+  }
+
+  return resultLines.join('\n');
+}
+
+function upsertExportLine(content, key, value) {
+  const line = `export ${key}=${value}`;
+  const re = new RegExp(`^\s*export\s+${key}=.*$`, 'm');
+  if (re.test(content)) {
+    return content.replace(re, line);
+  }
+  if (!content || !content.trim()) {
+    return `${line}\n`;
+  }
+  return `${content.replace(/\s*$/, '')}\n${line}\n`;
+}
+
+function detectPosixProfile() {
+  const shell = process.env.SHELL || '';
+  const home = os.homedir();
+  if (shell.includes('zsh')) return path.join(home, '.zshrc');
+  if (shell.includes('bash')) return path.join(home, '.bashrc');
+  return path.join(home, '.bashrc');
+}
+
+function persistEnvVar(key, value) {
+  if (!value) {
+    return { changed: false, reason: 'empty', type: '' };
+  }
+
+  if (process.platform === 'win32') {
+    try {
+      const out = spawnSync('setx', [key, value], { encoding: 'utf8' });
+      if (out.status !== 0) {
+        return {
+          changed: false,
+          type: 'windows',
+          reason: String(out.stderr || out.stdout || 'setx failed')
+        };
+      }
+      return { changed: true, type: 'windows', reason: '' };
+    } catch (err) {
+      return { changed: false, type: 'windows', reason: String(err) };
+    }
+  }
+
+  const profilePath = detectPosixProfile();
+  let content = '';
+  if (fs.existsSync(profilePath)) {
+    content = fs.readFileSync(profilePath, 'utf8');
+  }
+  const next = upsertExportLine(content, key, value);
+  if (next === content) {
+    return { changed: false, type: 'posix', path: profilePath };
+  }
+
+  if (content) {
+    backup(profilePath);
+  }
+  ensureDir(path.dirname(profilePath));
+  fs.writeFileSync(profilePath, next, 'utf8');
+  return { changed: true, type: 'posix', path: profilePath };
+}
+
+function canUseArrowMenu() {
+  return Boolean(
+    process.stdin.isTTY
+    && process.stdout.isTTY
+    && typeof process.stdin.setRawMode === 'function'
+  );
+}
+
+function askChoiceArrow(question, options, defaultIndex = 0) {
+  return new Promise((resolve, reject) => {
+    let index = defaultIndex;
+
+    const draw = () => {
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      const label = `${index + 1}. ${options[index]}`;
+      const line = withColor(`> ${label}`, ANSI.cyan, ANSI.bold);
+      process.stdout.write(`${line}   (↑/↓, Enter; 数字直接跳转)`);
+    };
+
+    const cleanup = () => {
+      process.stdin.off('keypress', onKeyPress);
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+        process.stdin.setRawMode(false);
+      }
+    };
+
+    const onKeyPress = (str, key = {}) => {
+      if (key.ctrl && key.name === 'c') {
+        cleanup();
+        reject(new Error('aborted by user'));
+        return;
+      }
+      if (key.name === 'up') {
+        index = (index - 1 + options.length) % options.length;
+        draw();
+        return;
+      }
+      if (key.name === 'down') {
+        index = (index + 1) % options.length;
+        draw();
+        return;
+      }
+      if (key.name === 'return' || key.name === 'enter') {
+        cleanup();
+        readline.clearLine(process.stdout, 0);
+        readline.cursorTo(process.stdout, 0);
+        process.stdout.write(`已选择: ${options[index]}\n`);
+        resolve(options[index]);
+        return;
+      }
+      const n = Number(str);
+      if (Number.isInteger(n) && n >= 1 && n <= options.length) {
+        index = n - 1;
+        draw();
+      }
+    };
+
+    try {
+      process.stdout.write(`\n${question}\n`);
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on('keypress', onKeyPress);
+      draw();
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+
+async function askModel(rl, currentModel = DEFAULT_MODEL_ID) {
+  const defaultIndex = Math.max(0, MODEL_OPTIONS.indexOf(currentModel));
+  if (canUseArrowMenu()) {
+    return askChoiceArrow('1) 选择默认模型', MODEL_OPTIONS, defaultIndex);
+  }
+
+  while (true) {
+    process.stdout.write('\n1) 选择默认模型\n');
+    MODEL_OPTIONS.forEach((m, idx) => {
+      const mark = idx === defaultIndex ? ' (default)' : '';
+      process.stdout.write(`  ${idx + 1}. ${m}${mark}\n`);
+    });
+    const input = (await rl.question('请选择编号: ')).trim();
+    if (!input) return MODEL_OPTIONS[defaultIndex];
+    const n = Number(input);
+    if (Number.isInteger(n) && n >= 1 && n <= MODEL_OPTIONS.length) {
+      return MODEL_OPTIONS[n - 1];
+    }
+    process.stdout.write('输入无效，请重新输入。\n');
+  }
+}
+
+async function askKey(rl, currentKey) {
+  const masked = currentKey ? `${currentKey.slice(0, 6)}...${currentKey.slice(-4)}` : '未设置';
+  process.stdout.write(`\n2) 输入 ATools API Key（当前: ${masked}）\n`);
+  process.stdout.write('留空表示保持当前 key\n');
+  const input = (await rl.question('请输入 key: ')).trim();
+  return input || currentKey || '';
+}
+
+async function askKeyWithGuard(rl, currentKey) {
+  let selectedKey = await askKey(rl, currentKey);
+  while (/^sk-or-v1-/i.test(selectedKey)) {
+    process.stdout.write(`\n${warn('检测到你输入的是 OpenRouter key（sk-or-v1- 开头），这不适用于 ATools /v1 模式。')}\n`);
+    const choice = (await rl.question('是否重新输入 ATools key? [Y/n]: ')).trim().toLowerCase();
+    if (choice === 'n') break;
+    selectedKey = await askKey(rl, selectedKey);
+  }
+  return selectedKey;
+}
+
+export async function runConfigCodex({ codexHome } = {}) {
+  const home = codexHome || process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const configPath = path.join(home, 'config.toml');
+
+  const existing = fs.existsSync(configPath) ? fs.readFileSync(configPath, 'utf8') : '';
+
+  process.stdout.write(`${sectionTitle('Codex 配置')}:\n`);
+  process.stdout.write(`- Home: ${bold(home)}\n`);
+  process.stdout.write(`- Provider: ${bold(PROVIDER)}\n`);
+  process.stdout.write(`- Upstream Base URL: ${bold(UPSTREAM_BASE_URL)}\n`);
+  process.stdout.write(`- Env Var: ${bold(ENV_KEY)}\n`);
+
+  const initialKey = process.env[ENV_KEY] || process.env.SUB_OAI_KEY || '';
+
+  let selectedModel = DEFAULT_MODEL_ID;
+  let selectedKey = initialKey;
+
+  const rl = readlinePromises.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  try {
+    selectedModel = await askModel(rl, DEFAULT_MODEL_ID);
+    selectedKey = await askKeyWithGuard(rl, initialKey);
+  } finally {
+    rl.close();
+  }
+
+  const next = patchCodexConfigText(existing, { modelId: selectedModel });
+
+  ensureDir(path.dirname(configPath));
+  if (existing && next !== existing) {
+    const bak = backup(configPath);
+    if (bak) {
+      process.stdout.write(`${ok(`[atools-tool] backup created: ${bak}`)}\n`);
+    }
+  }
+
+  if (next !== existing) {
+    fs.writeFileSync(configPath, `${next.trimEnd()}\n`, 'utf8');
+  }
+
+  let envResult = { changed: false, type: '', reason: '' };
+  if (selectedKey) {
+    envResult = persistEnvVar(ENV_KEY, selectedKey);
+  }
+
+  process.stdout.write(`\n${sectionTitle('[atools-tool] Codex 配置结果')}:\n`);
+  process.stdout.write(`- Config: ${bold(configPath)}\n`);
+  process.stdout.write(`- model_provider = "${PROVIDER}"\n`);
+  process.stdout.write(`- model = "${selectedModel}"\n`);
+  process.stdout.write(`- base_url = "${UPSTREAM_BASE_URL}"\n`);
+
+  process.stdout.write(`\n${sectionTitle('Environment (持久化)')}:\n`);
+  if (!selectedKey) {
+    process.stdout.write(`${warn('- ATools key 未提供，未更新环境变量。')}\n`);
+  } else if (envResult.type === 'windows') {
+    if (envResult.changed) {
+      process.stdout.write(`${ok(`- Persisted ${ENV_KEY} to Windows user env (setx).`)}\n`);
+      process.stdout.write('- 请重新打开终端，使新的环境变量生效。\n');
+    } else {
+      process.stdout.write(`${warn(`- Failed to persist ${ENV_KEY} via setx: ${envResult.reason}`)}\n`);
+    }
+  } else if (envResult.type === 'posix') {
+    if (envResult.changed) {
+      process.stdout.write(`${ok(`- Persisted ${ENV_KEY} to shell profile: ${envResult.path}`)}\n`);
+      process.stdout.write('- 请重新打开终端，或手动 source 该文件以生效。\n');
+    } else {
+      process.stdout.write(`- ${ENV_KEY} 已在 profile 中存在（${envResult.path}），未做修改。\n`);
+    }
+  } else {
+    process.stdout.write(`- Env var not persisted (reason: ${envResult.reason || 'unknown'}).\n`);
+  }
+
+  if (selectedKey) {
+    process.stdout.write(`\n${sectionTitle('Environment (当前会话手动生效命令)')}:\n`);
+    if (process.platform === 'win32') {
+      process.stdout.write(`- CMD: ${bold(`set ${ENV_KEY}=${selectedKey}`)}\n`);
+      process.stdout.write(`- PowerShell: ${bold(`$env:${ENV_KEY}="${selectedKey}"`)}\n`);
+    } else {
+      process.stdout.write(`- bash/zsh: ${bold(`export ${ENV_KEY}=${selectedKey}`)}\n`);
+    }
+  }
+}

package/lib/config-openclaw.mjs

@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import readlinePromises from 'node:readline/promises';
 import readline from 'node:readline';
 
-const PROVIDER = 'sub2api';
+const PROVIDER = 'atools';
 const MODEL_OPTIONS = ['gpt-5.2', 'gpt-5.3-codex', 'gpt-5.4'];
 const THINKING_OPTIONS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
 
@@ -19,6 +19,38 @@ const PROXY_UPSTREAM = 'https://sub2api.atools.live';
 const PROXY_LOG_FILE = path.join(os.tmpdir(), 'openclaw', 'atools-compat-proxy.log');
 const PROXY_SERVICE = 'openclaw-atools-proxy.service';
 
+const USE_COLOR = Boolean(process.stdout.isTTY && process.env.NO_COLOR !== '1');
+const ANSI = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m'
+};
+
+function withColor(text, ...codes) {
+  if (!USE_COLOR || !codes.length) return text;
+  const prefix = codes.join("");
+  return prefix + text + ANSI.reset;
+}
+
+function sectionTitle(text) {
+  return withColor(text, ANSI.cyan, ANSI.bold);
+}
+
+function ok(text) {
+  return withColor(text, ANSI.green);
+}
+
+function warn(text) {
+  return withColor(text, ANSI.yellow);
+}
+
+function bold(text) {
+  return withColor(text, ANSI.bold);
+}
+
+
 function readJson(filePath) {
   if (!fs.existsSync(filePath)) {
     throw new Error(`missing file: ${filePath}`);
@@ -71,59 +103,64 @@ async function askChoiceNumber(rl, question, options, defaultIndex = 0) {
 async function askChoiceArrow(question, options, defaultIndex = 0) {
   return new Promise((resolve, reject) => {
     let index = defaultIndex;
-    process.stdout.write(`\n${question}\n`);
-
+    process.stdout.write("\n" + question + "\n");
+    let firstDraw = true;
     const draw = () => {
-      readline.clearLine(process.stdout, 0);
-      readline.cursorTo(process.stdout, 0);
-      process.stdout.write(`> ${options[index]}   (↑/↓, Enter)`);
+      if (!firstDraw) {
+        readline.moveCursor(process.stdout, 0, -options.length);
+      } else {
+        firstDraw = false;
+      }
+      for (let i = 0; i < options.length; i += 1) {
+        readline.clearLine(process.stdout, 0);
+        const prefix = i === index ? '> ' : '  ';
+        const label = String(i + 1) + ". " + String(options[i]);
+        let line = prefix + label;
+        if (i === index) {
+          line = withColor(line, ANSI.cyan, ANSI.bold) + '   (↑/↓, Enter; 数字直接跳转)';
+        }
+        process.stdout.write(line + "\n");
+      }
     };
-
     const cleanup = () => {
-      process.stdin.off('keypress', onKeyPress);
-      if (process.stdin.isTTY && typeof process.stdin.setRawMode === 'function') {
+      process.stdin.off("keypress", onKeyPress);
+      if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
         process.stdin.setRawMode(false);
       }
     };
-
     const onKeyPress = (str, key = {}) => {
-      if (key.ctrl && key.name === 'c') {
+      if (key.ctrl && key.name === "c") {
         cleanup();
-        reject(new Error('aborted by user'));
+        reject(new Error("aborted by user"));
         return;
       }
-
-      if (key.name === 'up') {
+      if (key.name === "up") {
         index = (index - 1 + options.length) % options.length;
         draw();
         return;
       }
-      if (key.name === 'down') {
+      if (key.name === "down") {
         index = (index + 1) % options.length;
         draw();
         return;
       }
-      if (key.name === 'return' || key.name === 'enter') {
+      if (key.name === "return" || key.name === "enter") {
         cleanup();
-        readline.clearLine(process.stdout, 0);
-        readline.cursorTo(process.stdout, 0);
-        process.stdout.write(`已选择: ${options[index]}\n`);
+        process.stdout.write("已选择: " + String(options[index]) + "\n");
         resolve(options[index]);
         return;
       }
-
       const n = Number(str);
       if (Number.isInteger(n) && n >= 1 && n <= options.length) {
         index = n - 1;
         draw();
       }
     };
-
     try {
       readline.emitKeypressEvents(process.stdin);
       process.stdin.setRawMode(true);
       process.stdin.resume();
-      process.stdin.on('keypress', onKeyPress);
+      process.stdin.on("keypress", onKeyPress);
       draw();
     } catch (err) {
       cleanup();
@@ -207,7 +244,7 @@ async function askKey(rl, currentKey) {
 async function askKeyWithGuard(rl, currentKey) {
   let selectedKey = await askKey(rl, currentKey);
   while (/^sk-or-v1-/i.test(selectedKey)) {
-    process.stdout.write('\n检测到你输入的是 OpenRouter key（sk-or-v1- 开头），这不适用于 sub2api /v1 代理模式。\n');
+    process.stdout.write('\n' + warn('检测到你输入的是 OpenRouter key（sk-or-v1- 开头），这不适用于 ATools /v1 模式。') + '\n');
     const choice = await askChoice(rl, '是否重新输入 key?', ['重新输入 key（推荐）', '继续使用当前 key'], 0);
     if (choice === '继续使用当前 key') break;
     selectedKey = await askKey(rl, selectedKey);
@@ -296,9 +333,22 @@ function isLinuxProxyServiceActive() {
 
 function startLinuxProxyService() {
   const reload = runSystemctl(['daemon-reload']);
-  if (reload.status !== 0) return false;
+  if (reload.status !== 0) {
+    return {
+      ok: false,
+      step: 'daemon-reload',
+      detail: String(reload.stderr || reload.stdout || '').trim()
+    };
+  }
   const start = runSystemctl(['enable', '--now', PROXY_SERVICE]);
-  return start.status === 0;
+  if (start.status !== 0) {
+    return {
+      ok: false,
+      step: 'enable-start',
+      detail: String(start.stderr || start.stdout || '').trim()
+    };
+  }
+  return { ok: true, step: 'enable-start', detail: '' };
 }
 
 function startDetachedProxy() {
@@ -350,6 +400,31 @@ async function isPortOpen(host, port, timeoutMs = 900) {
   });
 }
 
+function buildProxyTroubleshootingHints({ linuxSystemdError } = {}) {
+  const hints = [];
+  const err = String(linuxSystemdError || '');
+
+  if (/Failed to connect to bus|No medium found/i.test(err)) {
+    hints.push('当前环境没有可用的 systemd 用户会话（常见于容器、root、无登录会话）。');
+    hints.push('建议：直接重新执行 `atools-tool install-proxy`（或兼容别名 `atools-tool-install`），新版会自动降级到非-systemd进程模式。');
+    hints.push('如果是容器环境，请确保进程管理策略允许后台常驻进程。');
+    return hints;
+  }
+
+  if (/permission denied|access denied/i.test(err)) {
+    hints.push('权限不足，无法通过 systemd --user 启动服务。');
+    hints.push('建议：使用普通登录用户执行安装与配置，不要混用 root 与普通用户的 OpenClaw 目录。');
+    return hints;
+  }
+
+  if (err) {
+    hints.push(`systemd 启动失败：${err}`);
+  }
+  hints.push('建议：检查 OpenClaw Home 路径与 Node 可执行路径是否存在且可访问。');
+  hints.push(`建议：确认端口 ${PROXY_PORT} 未被防火墙或策略阻断。`);
+  return hints;
+}
+
 async function ensureProxyReady() {
   if (process.platform === 'linux') {
     const service = configureLinuxProxyService();
@@ -360,13 +435,13 @@ async function ensureProxyReady() {
     }
   }
 
-  if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return true;
+  if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return { ok: true, mode: 'already-running' };
 
   // Linux retry: service may exist but not running.
   if (process.platform === 'linux') {
     const service = configureLinuxProxyService();
     if (service.exists && isLinuxProxyServiceActive()) {
-      if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return true;
+      if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return { ok: true, mode: 'already-running' };
     }
   }
 
@@ -388,26 +463,45 @@ async function ensureProxyReady() {
   }
 
   if (action === '取消并退出') {
-    return false;
+    return { ok: false, reason: 'user-cancelled', hints: [] };
   }
 
   let started = false;
+  let linuxSystemdError = '';
   if (process.platform === 'linux') {
-    started = startLinuxProxyService();
+    const systemdStart = startLinuxProxyService();
+    started = systemdStart.ok;
+    linuxSystemdError = systemdStart.detail || '';
   }
+  let mode = 'systemd';
   if (!started) {
     started = startDetachedProxy();
+    mode = 'detached';
   }
 
-  if (!started) return false;
+  if (!started) {
+    return {
+      ok: false,
+      reason: 'start-failed',
+      hints: buildProxyTroubleshootingHints({ linuxSystemdError })
+    };
+  }
 
   for (let i = 0; i < 5; i += 1) {
     await sleep(500);
     if (await isPortOpen(PROXY_HOST, PROXY_PORT)) {
-      return true;
+      return { ok: true, mode };
     }
   }
-  return false;
+  return {
+    ok: false,
+    reason: 'port-not-open',
+    hints: [
+      '代理进程启动后端口仍未就绪。',
+      `请检查日志：${PROXY_LOG_FILE}`,
+      '如为受限环境（容器/最小系统），请确认允许本地监听 127.0.0.1。'
+    ]
+  };
 }
 
 function printRestartHint() {
@@ -438,15 +532,23 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
   let rl = null;
 
   try {
-    process.stdout.write(`OpenClaw Home: ${home}\n`);
-    process.stdout.write(`固定代理目标: ${PROXY_UPSTREAM}\n`);
-    process.stdout.write(`固定 Provider Base URL: ${PROXY_BASE_URL}\n`);
-
-    const proxyReady = await ensureProxyReady();
-    if (!proxyReady) {
-      process.stdout.write('\n已取消：本地代理未就绪，未修改 OpenClaw 模型配置。\n');
+    process.stdout.write(sectionTitle('OpenClaw / ATools 配置') + ':\n');
+    process.stdout.write('- OpenClaw Home: ' + bold(home) + '\n');
+    process.stdout.write('- 固定代理目标: ' + bold(PROXY_UPSTREAM) + '\n');
+    process.stdout.write('- 固定 Provider Base URL: ' + bold(PROXY_BASE_URL) + '\n');
+
+    const proxyStatus = await ensureProxyReady();
+    if (!proxyStatus.ok) {
+      process.stdout.write('\n本地代理未就绪，未修改 OpenClaw 模型配置。\n');
+      if (Array.isArray(proxyStatus.hints) && proxyStatus.hints.length > 0) {
+        process.stdout.write('可行解决方案:\n');
+        proxyStatus.hints.forEach((hint) => process.stdout.write(`- ${hint}\n`));
+      }
       return;
     }
+    if (proxyStatus.mode === 'detached') {
+      process.stdout.write('\n已通过非-systemd模式启动代理（兼容无 user bus 环境）。\n');
+    }
     rl = readlinePromises.createInterface({
       input: process.stdin,
       output: process.stdout
@@ -457,10 +559,13 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     const selectedThinking = await askChoice(rl, '3) 思考强度', THINKING_OPTIONS, 2);
     const reasoning = reasoningSwitch === 'on';
     const currentKey =
-      openclawCfg?.models?.providers?.[PROVIDER]?.apiKey ||
-      modelsCfg?.providers?.[PROVIDER]?.apiKey ||
-      authCfg?.profiles?.[`${PROVIDER}:default`]?.key ||
-      '';
+      openclawCfg?.models?.providers?.[PROVIDER]?.apiKey
+      || openclawCfg?.models?.providers?.sub2api?.apiKey
+      || modelsCfg?.providers?.[PROVIDER]?.apiKey
+      || modelsCfg?.providers?.sub2api?.apiKey
+      || authCfg?.profiles?.[`${PROVIDER}:default`]?.key
+      || authCfg?.profiles?.['sub2api:default']?.key
+      || '';
     const selectedKey = await askKeyWithGuard(rl, currentKey);
 
     openclawCfg.models = openclawCfg.models || {};
@@ -489,8 +594,10 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     if (Array.isArray(openclawCfg.agents.list)) {
       openclawCfg.agents.list = openclawCfg.agents.list.map((agent) => {
         if (!agent || typeof agent !== 'object') return agent;
-        if (typeof agent.model === 'string' && agent.model.startsWith(`${PROVIDER}/`)) {
-          return { ...agent, model: `${PROVIDER}/${selectedModel}` };
+        if (typeof agent.model === 'string') {
+          if (agent.model.startsWith(`${PROVIDER}/`) || agent.model.startsWith('sub2api/')) {
+            return { ...agent, model: `${PROVIDER}/${selectedModel}` };
+          }
         }
         return agent;
       });

package/lib/install.mjs

@@ -1,10 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 
-const DEFAULT_PROVIDER = 'sub2api';
+const DEFAULT_PROVIDER = 'atools';
 const DEFAULT_MODEL = 'gpt-5.3-codex';
 const DEFAULT_FORCE_MODEL = '';
 const DEFAULT_PORT = 18888;
@@ -95,7 +95,7 @@ function parseArgs(argv) {
     maxReqBytes: 68000,
     logFile: DEFAULT_LOG_FILE,
     serviceName: DEFAULT_SERVICE_NAME,
-    apiKey: process.env.SUB_OAI_KEY || '',
+    apiKey: process.env.ATOOLS_OAI_KEY || process.env.SUB_OAI_KEY || '',
     dryRun: false,
     noRestart: false
   };
@@ -193,7 +193,7 @@ function detectApiKey(openclawHome, explicitKey) {
   if (explicitKey) return explicitKey;
   const authPath = path.join(openclawHome, 'agents/main/agent/auth-profiles.json');
   const auth = readJsonIfExists(authPath);
-  return auth?.profiles?.['sub2api:default']?.key || '';
+  return (auth?.profiles?.['atools:default']?.key || auth?.profiles?.['sub2api:default']?.key || '');
 }
 
 function patchOpenclawConfig(openclawHome, provider, model, port, dryRun) {
@@ -350,7 +350,56 @@ function runSystemctl(args, { dryRun } = {}) {
   execFileSync('systemctl', ['--user', ...args], { stdio: 'inherit' });
 }
 
-function installLinuxService({ serviceName, content, dryRun }) {
+function printSystemdFallbackHints(detail) {
+  const text = String(detail || '');
+  if (/Failed to connect to bus|No medium found/i.test(text)) {
+    info('detected: no systemd user bus in current environment');
+    info('hint: this is common in containers/root/non-login sessions');
+    info('hint: installer will continue with detached process mode');
+    return;
+  }
+  if (/permission denied|access denied/i.test(text)) {
+    info('detected: permission issue for systemd --user');
+    info('hint: run install under the same normal user as OpenClaw');
+    info('hint: installer will continue with detached process mode');
+    return;
+  }
+  info('detected: systemd --user is not usable in current environment');
+  info('hint: installer will continue with detached process mode');
+}
+
+function startDetachedProxyProcess({ nodeBin, cliPath, serveArgs, dryRun }) {
+  if (dryRun) {
+    info(`dry-run: detached start ${[nodeBin, cliPath, ...serveArgs].join(' ')}`);
+    return true;
+  }
+  try {
+    const child = spawn(nodeBin, [cliPath, ...serveArgs], {
+      detached: true,
+      stdio: 'ignore',
+      cwd: os.homedir(),
+      env: {
+        ...process.env,
+        HOME: process.env.HOME || os.homedir(),
+        TMPDIR: process.env.TMPDIR || '/tmp',
+        SUB2API_COMPAT_USER_AGENT: 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal'
+      }
+    });
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function installLinuxService({
+  serviceName,
+  content,
+  nodeBin,
+  cliPath,
+  serveArgs,
+  dryRun
+}) {
   const serviceDir = path.join(os.homedir(), '.config/systemd/user');
   const servicePath = path.join(serviceDir, serviceName);
   ensureDir(serviceDir);
@@ -366,8 +415,22 @@ function installLinuxService({ serviceName, content, dryRun }) {
     info(`wrote: ${servicePath}`);
   }
 
-  runSystemctl(['daemon-reload'], { dryRun });
-  runSystemctl(['enable', '--now', serviceName], { dryRun });
+  try {
+    runSystemctl(['daemon-reload'], { dryRun });
+    runSystemctl(['enable', '--now', serviceName], { dryRun });
+    info(`service started with systemd --user: ${serviceName}`);
+    return;
+  } catch (err) {
+    const detail = String(err?.message || err);
+    info(`systemd --user unavailable, fallback to detached process (${detail})`);
+    printSystemdFallbackHints(detail);
+  }
+
+  const started = startDetachedProxyProcess({ nodeBin, cliPath, serveArgs, dryRun });
+  if (!started) {
+    throw new Error(`failed to start proxy with both systemd --user and detached mode`);
+  }
+  info('proxy started in detached mode (non-systemd fallback)');
 }
 
 function runLaunchctl(args, { dryRun, allowFailure = false } = {}) {
@@ -444,7 +507,14 @@ function installService({
   dryRun
 }) {
   if (process.platform === 'linux') {
-    installLinuxService({ serviceName, content: linuxServiceContent, dryRun });
+    installLinuxService({
+      serviceName,
+      content: linuxServiceContent,
+      nodeBin,
+      cliPath,
+      serveArgs,
+      dryRun
+    });
     return;
   }
   if (process.platform === 'darwin') {
@@ -477,14 +547,14 @@ function restartOpenclawGateway({ noRestart, dryRun }) {
 }
 
 function printHelp() {
-  process.stdout.write(`atools-tool-install
+  process.stdout.write(`atools-tool install-proxy
 
 Usage:
-  atools-tool-install [options]
+  atools-tool install-proxy [options]
 
 Options:
   --openclaw-home <path>   Default: ~/.openclaw
-  --provider <name>        Default: sub2api
+  --provider <name>        Default: atools
   --model <id>             Default: gpt-5.3-codex
   --force-model <id>       Default: disabled (optional hard rewrite)
   --port <number>          Default: 18888
@@ -492,7 +562,7 @@ Options:
   --max-req-bytes <number> Default: 68000
   --log-file <path>        Default: <tmp>/openclaw/atools-compat-proxy.log
   --service-name <name>    Linux: *.service; macOS/Windows: service id/task name
-  --api-key <key>          Prefer explicit key; otherwise use SUB_OAI_KEY or auth-profiles
+  --api-key <key>          Prefer explicit key; otherwise use ATOOLS_OAI_KEY (or legacy SUB_OAI_KEY) or auth-profiles
   --no-restart             Do not restart openclaw-gateway.service
   --dry-run                Print actions without changing files
   -h, --help               Show help

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autotask/atools-tool",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "ATools CLI for OpenClaw proxy compatibility and interactive model configuration",
   "type": "module",
   "license": "MIT",