@autotask/atools-tool 0.1.2 → 0.1.3

package/README.md

@@ -15,20 +15,39 @@ atools-tool <command>
 Available command:
 
 ```bash
-atools-tool config-openclaw
+atools-tool openclaw
 ```
 
 Interactive flow:
 
-1. Select default model: `gpt-5.2` / `gpt-5.3-codex` / `gpt-5.4`
-2. Configure reasoning: `off` / `on`
-3. Configure thinking strength: `off|minimal|low|medium|high|xhigh`
-4. Input API key (leave empty to keep current key)
+1. Check local proxy status (`127.0.0.1:18888`); if not running, ask whether to start it first
+2. Select default model: `gpt-5.2` / `gpt-5.3-codex` / `gpt-5.4`
+3. Configure reasoning: `off` / `on`
+4. Configure thinking strength: `off|minimal|low|medium|high|xhigh`
+5. Input API key (leave empty to keep current key)
+
+Selection UX:
+
+- TTY terminal: use `↑/↓` and `Enter`
+- Non-TTY: falls back to number input
+
+Rollback to codex-compatible defaults:
+
+```bash
+atools-tool openclaw
+```
+
+Recommended selections:
+
+1. `gpt-5.3-codex`
+2. `off`
+3. `low`
+4. Input your sub2api-compatible key
 
 ## Install (npm)
 
 ```bash
-npm i -g atools-tool
+npm i -g @autotask/atools-tool
 ```
 
 Optional installer command:
@@ -37,6 +56,12 @@ Optional installer command:
 atools-tool-install --help
 ```
 
+`atools-tool-install` service behavior by platform:
+
+- Linux: systemd user service
+- macOS: launchd user agent (`~/Library/LaunchAgents`)
+- Windows: Task Scheduler user task (ONLOGON + start now)
+
 ## Proxy Command
 
 ```bash
@@ -62,8 +87,11 @@ curl -fsSL https://raw.githubusercontent.com/aak1247/sub2api-openclaw-proxy/main
 - patches `~/.openclaw/openclaw.json`
 - patches `~/.openclaw/agents/main/agent/models.json`
 - patches `~/.openclaw/agents/main/agent/auth-profiles.json` (if API key is available)
-- creates/enables `~/.config/systemd/user/openclaw-atools-proxy.service`
-- restarts `openclaw-gateway.service` (unless `--no-restart`)
+- service install by platform:
+  - Linux: creates/enables `~/.config/systemd/user/openclaw-atools-proxy.service`
+  - 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`)
 
 Default proxy log:
 

package/bin/cli.mjs

@@ -47,7 +47,8 @@ Usage:
 
 Commands:
   serve            Run proxy service
-  config-openclaw  Interactive OpenClaw model/reasoning/thinking/key setup
+  openclaw         Interactive OpenClaw setup (sub2api proxy check + model/reasoning/thinking/key)
+  config-openclaw  Alias of 'openclaw'
 
 Options:
   --openclaw-home <path> OpenClaw home dir (default: ~/.openclaw)
@@ -71,7 +72,7 @@ async function main() {
     return;
   }
 
-  if (args.cmd === 'config-openclaw') {
+  if (args.cmd === 'config-openclaw' || args.cmd === 'openclaw') {
     await runConfigOpenclaw({ openclawHome: args.openclawHome });
     return;
   }

package/lib/config-openclaw.mjs

@@ -2,12 +2,23 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 import process from 'node:process';
-import readline from 'node:readline/promises';
+import net from 'node:net';
+import { spawn, spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import readlinePromises from 'node:readline/promises';
+import readline from 'node:readline';
 
 const PROVIDER = 'sub2api';
 const MODEL_OPTIONS = ['gpt-5.2', 'gpt-5.3-codex', 'gpt-5.4'];
 const THINKING_OPTIONS = ['off', 'minimal', 'low', 'medium', 'high', 'xhigh'];
 
+const PROXY_HOST = '127.0.0.1';
+const PROXY_PORT = 18888;
+const PROXY_BASE_URL = `http://${PROXY_HOST}:${PROXY_PORT}/v1`;
+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';
+
 function readJson(filePath) {
   if (!fs.existsSync(filePath)) {
     throw new Error(`missing file: ${filePath}`);
@@ -28,7 +39,19 @@ function backup(filePath) {
   fs.copyFileSync(filePath, `${filePath}.bak.${stamp}`);
 }
 
-async function askChoice(rl, question, options, defaultIndex = 0) {
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function canUseArrowMenu() {
+  return Boolean(
+    process.stdin.isTTY
+    && process.stdout.isTTY
+    && typeof process.stdin.setRawMode === 'function'
+  );
+}
+
+async function askChoiceNumber(rl, question, options, defaultIndex = 0) {
   while (true) {
     process.stdout.write(`\n${question}\n`);
     options.forEach((item, idx) => {
@@ -45,14 +68,153 @@ async function askChoice(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`);
+
+    const draw = () => {
+      readline.clearLine(process.stdout, 0);
+      readline.cursorTo(process.stdout, 0);
+      process.stdout.write(`> ${options[index]}   (↑/↓, 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 {
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on('keypress', onKeyPress);
+      draw();
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+
+async function askChoice(rl, question, options, defaultIndex = 0) {
+  if (!canUseArrowMenu()) {
+    return askChoiceNumber(rl, question, options, defaultIndex);
+  }
+  return askChoiceArrow(question, options, defaultIndex);
+}
+
+async function askInputArrow(defaultValue = '') {
+  return new Promise((resolve, reject) => {
+    let value = '';
+    process.stdout.write('请输入 key: ');
+
+    const draw = () => {
+      readline.clearLine(process.stdout, 1);
+      readline.cursorTo(process.stdout, 10);
+      process.stdout.write(value);
+    };
+
+    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 === 'return' || key.name === 'enter') {
+        cleanup();
+        process.stdout.write('\n');
+        resolve(value.trim() || defaultValue || '');
+        return;
+      }
+      if (key.name === 'backspace') {
+        value = value.slice(0, -1);
+        draw();
+        return;
+      }
+      if (!key.ctrl && !key.meta && typeof str === 'string' && str.length > 0) {
+        value += str;
+        draw();
+      }
+    };
+
+    try {
+      readline.emitKeypressEvents(process.stdin);
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on('keypress', onKeyPress);
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+
 async function askKey(rl, currentKey) {
   const masked = currentKey ? `${currentKey.slice(0, 6)}...${currentKey.slice(-4)}` : '未设置';
-  process.stdout.write(`\n4) 输入 API Key（当前: ${masked}）\n`);
+  const question = `4) 输入 API Key（当前: ${masked}）`;
+  process.stdout.write(`\n${question}\n`);
   process.stdout.write('留空表示保持当前 key\n');
+  if (canUseArrowMenu()) {
+    return askInputArrow(currentKey);
+  }
   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检测到你输入的是 OpenRouter key（sk-or-v1- 开头），这不适用于 sub2api /v1 代理模式。\n');
+    const choice = await askChoice(rl, '是否重新输入 key?', ['重新输入 key（推荐）', '继续使用当前 key'], 0);
+    if (choice === '继续使用当前 key') break;
+    selectedKey = await askKey(rl, selectedKey);
+  }
+  return selectedKey;
+}
+
 function ensureModel(providerObj, modelId, reasoning) {
   providerObj.models = providerObj.models || [];
   let model = providerObj.models.find((m) => m && m.id === modelId);
@@ -75,6 +237,190 @@ function ensureModel(providerObj, modelId, reasoning) {
   model.api = model.api || 'openai-responses';
 }
 
+function escapeRegExp(text) {
+  return String(text).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function upsertEnvLine(content, key, value) {
+  const line = `Environment=${key}=${value}`;
+  const re = new RegExp(`^Environment=${escapeRegExp(key)}=.*$`, 'm');
+  if (re.test(content)) {
+    return content.replace(re, line);
+  }
+  const serviceIdx = content.indexOf('[Service]');
+  if (serviceIdx === -1) {
+    return `${content.trimEnd()}\n${line}\n`;
+  }
+  const afterServiceHeader = content.indexOf('\n', serviceIdx);
+  if (afterServiceHeader < 0) {
+    return `${content}\n${line}\n`;
+  }
+  return `${content.slice(0, afterServiceHeader + 1)}${line}\n${content.slice(afterServiceHeader + 1)}`;
+}
+
+function configureLinuxProxyService() {
+  const servicePath = path.join(os.homedir(), '.config/systemd/user', PROXY_SERVICE);
+  if (!fs.existsSync(servicePath)) {
+    return { exists: false, changed: false, servicePath };
+  }
+  const original = fs.readFileSync(servicePath, 'utf8');
+  let next = original;
+  next = upsertEnvLine(next, 'SUB2API_UPSTREAM', PROXY_UPSTREAM);
+  next = upsertEnvLine(next, 'SUB2API_FALLBACK_UPSTREAM', '');
+  next = upsertEnvLine(next, 'SUB2API_FALLBACK_API_KEY', '');
+  next = upsertEnvLine(next, 'SUB2API_COMPAT_DROP_TOOLS_ON_COMPACT', '0');
+  next = upsertEnvLine(next, 'SUB2API_COMPAT_PORT', String(PROXY_PORT));
+  next = upsertEnvLine(next, 'SUB2API_COMPAT_LOG', PROXY_LOG_FILE);
+
+  if (next === original) {
+    return { exists: true, changed: false, servicePath };
+  }
+  backup(servicePath);
+  fs.writeFileSync(servicePath, next, 'utf8');
+  return { exists: true, changed: true, servicePath };
+}
+
+function runSystemctl(args) {
+  const out = spawnSync('systemctl', ['--user', ...args], { encoding: 'utf8' });
+  return out;
+}
+
+function isLinuxProxyServiceActive() {
+  const out = runSystemctl(['is-active', PROXY_SERVICE]);
+  return out.status === 0 && String(out.stdout || '').trim() === 'active';
+}
+
+function startLinuxProxyService() {
+  const reload = runSystemctl(['daemon-reload']);
+  if (reload.status !== 0) return false;
+  const start = runSystemctl(['enable', '--now', PROXY_SERVICE]);
+  return start.status === 0;
+}
+
+function startDetachedProxy() {
+  try {
+    const cliPath = fileURLToPath(new URL('../bin/cli.mjs', import.meta.url));
+    const child = spawn(
+      process.execPath,
+      [
+        cliPath,
+        'serve',
+        '--port',
+        String(PROXY_PORT),
+        '--upstream',
+        PROXY_UPSTREAM,
+        '--log-file',
+        PROXY_LOG_FILE
+      ],
+      {
+        detached: true,
+        stdio: 'ignore',
+        env: {
+          ...process.env,
+          SUB2API_UPSTREAM: PROXY_UPSTREAM,
+          SUB2API_FALLBACK_UPSTREAM: '',
+          SUB2API_FALLBACK_API_KEY: ''
+        }
+      }
+    );
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function isPortOpen(host, port, timeoutMs = 900) {
+  return new Promise((resolve) => {
+    const socket = net.createConnection({ host, port });
+    let done = false;
+
+    const finish = (ok) => {
+      if (done) return;
+      done = true;
+      socket.destroy();
+      resolve(ok);
+    };
+
+    socket.on('connect', () => finish(true));
+    socket.on('error', () => finish(false));
+    socket.setTimeout(timeoutMs, () => finish(false));
+  });
+}
+
+async function ensureProxyReady() {
+  if (process.platform === 'linux') {
+    const service = configureLinuxProxyService();
+    if (service.exists && service.changed) {
+      // Service file changed: reload + restart so it points back to sub2api.atools.live.
+      startLinuxProxyService();
+      await sleep(400);
+    }
+  }
+
+  if (await isPortOpen(PROXY_HOST, PROXY_PORT)) return true;
+
+  // Linux fallback: 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;
+    }
+  }
+
+  process.stdout.write('\n检测到本地代理未运行（127.0.0.1:18888）。\n');
+  const promptRl = readlinePromises.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  let action = '';
+  try {
+    action = await askChoice(
+      promptRl,
+      'atools 模型依赖本地代理，是否现在启动代理？',
+      ['启动代理（推荐）', '取消并退出'],
+      0
+    );
+  } finally {
+    promptRl.close();
+  }
+
+  if (action === '取消并退出') {
+    return false;
+  }
+
+  let started = false;
+  if (process.platform === 'linux') {
+    started = startLinuxProxyService();
+  }
+  if (!started) {
+    started = startDetachedProxy();
+  }
+
+  if (!started) return false;
+
+  for (let i = 0; i < 5; i += 1) {
+    await sleep(500);
+    if (await isPortOpen(PROXY_HOST, PROXY_PORT)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function printRestartHint() {
+  process.stdout.write('\n后续建议:\n');
+  if (process.platform === 'linux') {
+    process.stdout.write('- Linux(systemd): systemctl --user restart openclaw-gateway.service\n');
+  } else if (process.platform === 'darwin') {
+    process.stdout.write('- macOS: 重启 OpenClaw 进程，或重新执行你本地的 openclaw 启动命令\n');
+  } else if (process.platform === 'win32') {
+    process.stdout.write('- Windows: 重启 OpenClaw 进程或服务（若以服务方式运行）\n');
+  } else {
+    process.stdout.write('- 请重启 OpenClaw 进程，使新配置生效\n');
+  }
+}
+
 export async function runConfigOpenclaw({ openclawHome } = {}) {
   const home = openclawHome || process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw');
   const openclawJsonPath = path.join(home, 'openclaw.json');
@@ -83,17 +429,26 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
 
   const openclawCfg = readJson(openclawJsonPath);
   const modelsCfg = readJson(modelsJsonPath);
-  let authCfg = fs.existsSync(authProfilesPath)
+  const authCfg = fs.existsSync(authProfilesPath)
     ? readJson(authProfilesPath)
     : { version: 1, profiles: {}, lastGood: {}, usageStats: {} };
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
+  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');
+      return;
+    }
+    rl = readlinePromises.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
 
     const selectedModel = await askChoice(rl, '1) 选择默认模型', MODEL_OPTIONS, 1);
     const reasoningSwitch = await askChoice(rl, '2) 配置推理开关', ['off', 'on'], 0);
@@ -104,13 +459,17 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
       modelsCfg?.providers?.[PROVIDER]?.apiKey ||
       authCfg?.profiles?.[`${PROVIDER}:default`]?.key ||
       '';
-    const selectedKey = await askKey(rl, currentKey);
+    const selectedKey = await askKeyWithGuard(rl, currentKey);
 
     openclawCfg.models = openclawCfg.models || {};
     openclawCfg.models.providers = openclawCfg.models.providers || {};
     openclawCfg.models.providers[PROVIDER] = openclawCfg.models.providers[PROVIDER] || {};
+    openclawCfg.models.providers[PROVIDER].baseUrl = PROXY_BASE_URL;
     openclawCfg.models.providers[PROVIDER].api = 'openai-responses';
     openclawCfg.models.providers[PROVIDER].authHeader = true;
+    openclawCfg.models.providers[PROVIDER].headers = openclawCfg.models.providers[PROVIDER].headers || {};
+    openclawCfg.models.providers[PROVIDER].headers['User-Agent'] = 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal';
+    openclawCfg.models.providers[PROVIDER].headers.Accept = 'application/json';
     if (selectedKey) {
       openclawCfg.models.providers[PROVIDER].apiKey = selectedKey;
       openclawCfg.models.providers[PROVIDER].auth = 'api-key';
@@ -125,11 +484,24 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     openclawCfg.agents.defaults.models = openclawCfg.agents.defaults.models || {};
     openclawCfg.agents.defaults.models[`${PROVIDER}/${selectedModel}`] =
       openclawCfg.agents.defaults.models[`${PROVIDER}/${selectedModel}`] || { alias: `ATools ${selectedModel}` };
+    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}` };
+        }
+        return agent;
+      });
+    }
 
     modelsCfg.providers = modelsCfg.providers || {};
     modelsCfg.providers[PROVIDER] = modelsCfg.providers[PROVIDER] || {};
+    modelsCfg.providers[PROVIDER].baseUrl = PROXY_BASE_URL;
     modelsCfg.providers[PROVIDER].api = 'openai-responses';
     modelsCfg.providers[PROVIDER].authHeader = true;
+    modelsCfg.providers[PROVIDER].headers = modelsCfg.providers[PROVIDER].headers || {};
+    modelsCfg.providers[PROVIDER].headers['User-Agent'] = 'codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal';
+    modelsCfg.providers[PROVIDER].headers.Accept = 'application/json';
     if (selectedKey) {
       modelsCfg.providers[PROVIDER].apiKey = selectedKey;
       modelsCfg.providers[PROVIDER].auth = 'api-key';
@@ -161,6 +533,8 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     writeJson(authProfilesPath, authCfg);
 
     process.stdout.write('\n配置已更新:\n');
+    process.stdout.write(`- Proxy Upstream: ${PROXY_UPSTREAM}\n`);
+    process.stdout.write(`- Provider Base URL: ${PROXY_BASE_URL}\n`);
     process.stdout.write(`- 默认模型: ${PROVIDER}/${selectedModel}\n`);
     process.stdout.write(`- 推理开关: ${reasoning ? 'on' : 'off'}\n`);
     process.stdout.write(`- 思考强度: ${selectedThinking}\n`);
@@ -168,7 +542,8 @@ export async function runConfigOpenclaw({ openclawHome } = {}) {
     process.stdout.write(`- 已写入: ${openclawJsonPath}\n`);
     process.stdout.write(`- 已写入: ${modelsJsonPath}\n`);
     process.stdout.write(`- 已写入: ${authProfilesPath}\n`);
+    printRestartHint();
   } finally {
-    rl.close();
+    if (rl) rl.close();
   }
 }

package/lib/install.mjs

@@ -8,8 +8,8 @@ const DEFAULT_PROVIDER = 'sub2api';
 const DEFAULT_MODEL = 'gpt-5.3-codex';
 const DEFAULT_PORT = 18888;
 const DEFAULT_UPSTREAM = 'https://sub2api.atools.live';
-const DEFAULT_FALLBACK_UPSTREAM = 'https://gmn.chuangzuoli.com/v1';
-const DEFAULT_LOG_FILE = '/tmp/openclaw/atools-compat-proxy.log';
+const DEFAULT_FALLBACK_UPSTREAM = '';
+const DEFAULT_LOG_FILE = path.join(os.tmpdir(), 'openclaw', 'atools-compat-proxy.log');
 const DEFAULT_SERVICE_NAME = 'openclaw-atools-proxy.service';
 const OPENCLAW_GATEWAY_SERVICE = 'openclaw-gateway.service';
 
@@ -47,6 +47,46 @@ function ensureDir(dir) {
   fs.mkdirSync(dir, { recursive: true });
 }
 
+function defaultServiceId(name = DEFAULT_SERVICE_NAME) {
+  return String(name || DEFAULT_SERVICE_NAME).replace(/\.service$/i, '');
+}
+
+function buildProxyServeArgs({ port, upstream, fallbackUpstream, fallbackApiKey, maxReqBytes, logFile }) {
+  const args = [
+    'serve',
+    '--port',
+    String(port),
+    '--upstream',
+    String(upstream),
+    '--log-file',
+    String(logFile),
+    '--max-req-bytes',
+    String(maxReqBytes)
+  ];
+  if (fallbackUpstream) {
+    args.push('--fallback-upstream', String(fallbackUpstream));
+  }
+  if (fallbackApiKey) {
+    args.push('--fallback-api-key', String(fallbackApiKey));
+  }
+  return args;
+}
+
+function escapeXml(text) {
+  return String(text)
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}
+
+function quoteWindowsArg(arg) {
+  const s = String(arg ?? '');
+  if (!/[\s"]/g.test(s)) return s;
+  return `"${s.replace(/"/g, '\\"')}"`;
+}
+
 function parseArgs(argv) {
   const out = {
     openclawHome: process.env.OPENCLAW_HOME || path.join(os.homedir(), '.openclaw'),
@@ -95,34 +135,27 @@ function parseArgs(argv) {
 }
 
 function renderSystemdService({
-  serviceName,
   nodeBin,
   cliPath,
-  port,
-  upstream,
+  serveArgs,
   fallbackUpstream,
-  maxReqBytes,
-  fallbackApiKey,
-  logFile
+  fallbackApiKey
 }) {
   const fallbackEnv = fallbackUpstream
     ? `Environment=SUB2API_FALLBACK_UPSTREAM=${fallbackUpstream}\nEnvironment=SUB2API_FALLBACK_API_KEY=${fallbackApiKey || ''}\n`
     : '';
+  const execArgs = [nodeBin, cliPath, ...serveArgs].join(' ');
   return `[Unit]
 Description=OpenClaw ATools Compatibility Proxy
 After=network-online.target
 Wants=network-online.target
 
 [Service]
-ExecStart=${nodeBin} ${cliPath} serve --port ${port} --upstream ${upstream} --log-file ${logFile}
+ExecStart=${execArgs}
 Restart=always
 RestartSec=2
 Environment=HOME=${os.homedir()}
 Environment=TMPDIR=/tmp
-Environment=SUB2API_COMPAT_PORT=${port}
-Environment=SUB2API_UPSTREAM=${upstream}
-Environment=SUB2API_COMPAT_LOG=${logFile}
-Environment=SUB2API_COMPAT_MAX_REQ_BYTES=${maxReqBytes}
 Environment="SUB2API_COMPAT_USER_AGENT=codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal"
 ${fallbackEnv}
 
@@ -131,6 +164,42 @@ WantedBy=default.target
 `;
 }
 
+function renderLaunchdPlist({ label, nodeBin, cliPath, serveArgs, logFile }) {
+  const args = [nodeBin, cliPath, ...serveArgs];
+  const argsXml = args.map((arg) => `    <string>${escapeXml(arg)}</string>`).join('\n');
+  const launchLog = `${logFile}.launchd.log`;
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${escapeXml(label)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${argsXml}
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>WorkingDirectory</key>
+  <string>${escapeXml(os.homedir())}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>HOME</key>
+    <string>${escapeXml(os.homedir())}</string>
+    <key>SUB2API_COMPAT_USER_AGENT</key>
+    <string>codex_cli_rs/0.101.0 (Ubuntu 24.4.0; x86_64) WindowsTerminal</string>
+  </dict>
+  <key>StandardOutPath</key>
+  <string>${escapeXml(launchLog)}</string>
+  <key>StandardErrorPath</key>
+  <string>${escapeXml(launchLog)}</string>
+</dict>
+</plist>
+`;
+}
+
 function detectApiKey(openclawHome, explicitKey) {
   if (explicitKey) return explicitKey;
   const authPath = path.join(openclawHome, 'agents/main/agent/auth-profiles.json');
@@ -297,7 +366,7 @@ function runSystemctl(args, { dryRun } = {}) {
   execFileSync('systemctl', ['--user', ...args], { stdio: 'inherit' });
 }
 
-function installService({ serviceName, content, dryRun }) {
+function installLinuxService({ serviceName, content, dryRun }) {
   const serviceDir = path.join(os.homedir(), '.config/systemd/user');
   const servicePath = path.join(serviceDir, serviceName);
   ensureDir(serviceDir);
@@ -317,12 +386,105 @@ function installService({ serviceName, content, dryRun }) {
   runSystemctl(['enable', '--now', serviceName], { dryRun });
 }
 
+function runLaunchctl(args, { dryRun, allowFailure = false } = {}) {
+  if (dryRun) {
+    info(`dry-run: launchctl ${args.join(' ')}`);
+    return;
+  }
+  try {
+    execFileSync('launchctl', args, { stdio: 'inherit' });
+  } catch (err) {
+    if (allowFailure) return;
+    throw err;
+  }
+}
+
+function installMacService({ serviceName, content, dryRun }) {
+  const serviceId = defaultServiceId(serviceName);
+  const launchAgentDir = path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(launchAgentDir, `${serviceId}.plist`);
+  const uid = typeof process.getuid === 'function' ? process.getuid() : null;
+  if (uid == null) {
+    throw new Error('failed to resolve current uid for launchctl');
+  }
+
+  ensureDir(launchAgentDir);
+  if (dryRun) {
+    info(`dry-run: would write ${plistPath}`);
+  } else {
+    if (fs.existsSync(plistPath)) {
+      const bak = backup(plistPath);
+      if (bak) info(`backup created: ${bak}`);
+    }
+    fs.writeFileSync(plistPath, content, 'utf8');
+    info(`wrote: ${plistPath}`);
+  }
+
+  const target = `gui/${uid}/${serviceId}`;
+  runLaunchctl(['bootout', target], { dryRun, allowFailure: true });
+  runLaunchctl(['bootstrap', `gui/${uid}`, plistPath], { dryRun });
+  runLaunchctl(['enable', target], { dryRun, allowFailure: true });
+  runLaunchctl(['kickstart', '-k', target], { dryRun, allowFailure: true });
+}
+
+function runSchtasks(args, { dryRun, allowFailure = false } = {}) {
+  if (dryRun) {
+    info(`dry-run: schtasks ${args.join(' ')}`);
+    return;
+  }
+  try {
+    execFileSync('schtasks', args, { stdio: 'inherit' });
+  } catch (err) {
+    if (allowFailure) return;
+    throw err;
+  }
+}
+
+function installWindowsService({ serviceName, nodeBin, cliPath, serveArgs, dryRun }) {
+  const taskName = defaultServiceId(serviceName);
+  const command = [nodeBin, cliPath, ...serveArgs].map(quoteWindowsArg).join(' ');
+  runSchtasks(
+    ['/Create', '/F', '/SC', 'ONLOGON', '/RL', 'LIMITED', '/TN', taskName, '/TR', command],
+    { dryRun }
+  );
+  runSchtasks(['/Run', '/TN', taskName], { dryRun, allowFailure: true });
+}
+
+function installService({
+  serviceName,
+  linuxServiceContent,
+  macPlistContent,
+  nodeBin,
+  cliPath,
+  serveArgs,
+  dryRun
+}) {
+  if (process.platform === 'linux') {
+    installLinuxService({ serviceName, content: linuxServiceContent, dryRun });
+    return;
+  }
+  if (process.platform === 'darwin') {
+    installMacService({ serviceName, content: macPlistContent, dryRun });
+    return;
+  }
+  if (process.platform === 'win32') {
+    installWindowsService({ serviceName, nodeBin, cliPath, serveArgs, dryRun });
+    return;
+  }
+  throw new Error(`unsupported platform for service install: ${process.platform}`);
+}
+
 function restartOpenclawGateway({ noRestart, dryRun }) {
   if (noRestart) {
     info('skip gateway restart (--no-restart)');
     return;
   }
 
+  if (process.platform !== 'linux') {
+    info(`skip gateway restart on ${process.platform} (please restart OpenClaw manually)`);
+    return;
+  }
+
   try {
     runSystemctl(['restart', OPENCLAW_GATEWAY_SERVICE], { dryRun });
   } catch {
@@ -342,10 +504,10 @@ Options:
   --model <id>             Default: gpt-5.3-codex
   --port <number>          Default: 18888
   --upstream <url>         Default: https://sub2api.atools.live
-  --fallback-upstream <url> Default: https://gmn.chuangzuoli.com/v1
+  --fallback-upstream <url> Default: empty (disabled)
   --max-req-bytes <number> Default: 68000
-  --log-file <path>        Default: /tmp/openclaw/atools-compat-proxy.log
-  --service-name <name>    Default: openclaw-atools-proxy.service
+  --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; fallback env SUB_OAI_KEY then auth-profiles
   --fallback-api-key <key> Prefer explicit key; fallback env FALLBACK_OAI_KEY then openclaw gmn key
   --no-restart             Do not restart openclaw-gateway.service
@@ -366,8 +528,17 @@ export async function runInstall(rawArgs = process.argv.slice(2)) {
   const cliPath = fileURLToPath(new URL('../bin/cli.mjs', import.meta.url));
   const apiKey = detectApiKey(args.openclawHome, args.apiKey);
   const fallbackApiKey = detectFallbackApiKey(args.openclawHome, args.fallbackApiKey);
+  const serveArgs = buildProxyServeArgs({
+    port: args.port,
+    upstream: args.upstream,
+    fallbackUpstream: args.fallbackUpstream,
+    fallbackApiKey,
+    maxReqBytes: args.maxReqBytes,
+    logFile: args.logFile
+  });
 
   info(`openclawHome=${args.openclawHome}`);
+  info(`platform=${process.platform}`);
   info(`provider/model=${args.provider}/${args.model}`);
   info(`proxy=http://127.0.0.1:${args.port}/v1 -> ${args.upstream}`);
   if (args.fallbackUpstream) {
@@ -378,19 +549,30 @@ export async function runInstall(rawArgs = process.argv.slice(2)) {
   patchAgentModels(args.openclawHome, args.provider, args.model, args.port, apiKey, args.dryRun);
   patchAuthProfiles(args.openclawHome, args.provider, apiKey, args.dryRun);
 
-  const serviceContent = renderSystemdService({
-    serviceName: args.serviceName,
+  const linuxServiceContent = renderSystemdService({
     nodeBin,
     cliPath,
-    port: args.port,
-    upstream: args.upstream,
+    serveArgs,
     fallbackUpstream: args.fallbackUpstream,
-    maxReqBytes: args.maxReqBytes,
-    fallbackApiKey,
+    fallbackApiKey
+  });
+  const macPlistContent = renderLaunchdPlist({
+    label: defaultServiceId(args.serviceName),
+    nodeBin,
+    cliPath,
+    serveArgs,
     logFile: args.logFile
   });
 
-  installService({ serviceName: args.serviceName, content: serviceContent, dryRun: args.dryRun });
+  installService({
+    serviceName: args.serviceName,
+    linuxServiceContent,
+    macPlistContent,
+    nodeBin,
+    cliPath,
+    serveArgs,
+    dryRun: args.dryRun
+  });
   restartOpenclawGateway({ noRestart: args.noRestart, dryRun: args.dryRun });
 
   info('done');

package/lib/proxy-server.mjs

@@ -1,5 +1,6 @@
 import http from 'node:http';
 import fs from 'node:fs';
+import path from 'node:path';
 
 const DEFAULT_PORT = 18888;
 const DEFAULT_UPSTREAM = 'https://sub2api.atools.live';
@@ -9,9 +10,10 @@ const DEFAULT_FALLBACK_UPSTREAM = '';
 const DEFAULT_FALLBACK_API_KEY = '';
 const DEFAULT_MAX_REQ_BYTES = 68000;
 const DEFAULT_DROP_TOOLS_ON_COMPACT = false;
+const DEFAULT_STRIP_PREVIOUS_RESPONSE_ID = false;
 
 function ensureParentDir(filePath) {
-  const dir = filePath.replace(/\/[^/]*$/, '');
+  const dir = path.dirname(filePath);
   if (dir) {
     fs.mkdirSync(dir, { recursive: true });
   }
@@ -54,12 +56,13 @@ function normalizeContent(content) {
   return [toInputText('')];
 }
 
-function normalizeResponsesPayload(payload) {
+function normalizeResponsesPayload(payload, { stripPreviousResponseId = DEFAULT_STRIP_PREVIOUS_RESPONSE_ID } = {}) {
   if (!payload || typeof payload !== 'object') return payload;
   const out = { ...payload };
 
-  // Some upstream gateways reject/unstable with this field.
-  if ('previous_response_id' in out) delete out.previous_response_id;
+  if (stripPreviousResponseId && 'previous_response_id' in out) {
+    delete out.previous_response_id;
+  }
 
   if (typeof out.input === 'string') {
     out.input = [{ role: 'user', content: normalizeContent(out.input) }];
@@ -84,7 +87,28 @@ function trimTextPart(part, maxChars) {
   return { ...part, text: text.length > maxChars ? text.slice(0, maxChars) : text };
 }
 
-function compactResponsesPayload(payload, { dropToolsOnCompact = DEFAULT_DROP_TOOLS_ON_COMPACT } = {}) {
+function compactInputMessages(messages, maxRecentMessages = 8) {
+  if (!Array.isArray(messages)) return messages;
+  const recent = messages.slice(-Math.max(1, maxRecentMessages));
+  let latestSystem = null;
+  for (let i = messages.length - 1; i >= 0; i -= 1) {
+    const msg = messages[i];
+    if (!msg || typeof msg !== 'object') continue;
+    if (msg.role === 'system' || msg.role === 'developer') {
+      latestSystem = msg;
+      break;
+    }
+  }
+  if (latestSystem && !recent.includes(latestSystem)) {
+    return [latestSystem, ...recent];
+  }
+  return recent;
+}
+
+function compactResponsesPayload(payload, {
+  dropToolsOnCompact = DEFAULT_DROP_TOOLS_ON_COMPACT,
+  maxRecentMessages
+} = {}) {
   if (!payload || typeof payload !== 'object') return payload;
   const out = { ...payload };
 
@@ -104,13 +128,11 @@ function compactResponsesPayload(payload, { dropToolsOnCompact = DEFAULT_DROP_TO
       }
       return item;
     });
-    const systemMsgs = normalized.filter((m) => m && typeof m === 'object' && (m.role === 'system' || m.role === 'developer')).slice(-1);
-    const userMsgs = normalized.filter((m) => m && typeof m === 'object' && m.role === 'user').slice(-2);
-    const merged = [...systemMsgs, ...userMsgs];
-    out.input = merged.length > 0 ? merged : normalized.slice(-1);
+    const resolvedMaxRecentMessages = Number.isInteger(maxRecentMessages)
+      ? Math.max(1, maxRecentMessages)
+      : (('previous_response_id' in out) ? 14 : 8);
+    out.input = compactInputMessages(normalized, resolvedMaxRecentMessages);
   }
-
-  if ('previous_response_id' in out) delete out.previous_response_id;
   return out;
 }
 
@@ -149,6 +171,8 @@ export async function createProxyServer(options = {}) {
   const maxReqBytes = Number(options.maxReqBytes ?? process.env.SUB2API_COMPAT_MAX_REQ_BYTES ?? DEFAULT_MAX_REQ_BYTES);
   const dropToolsOnCompact = options.dropToolsOnCompact
     ?? ['1', 'true', 'yes', 'on'].includes(String(process.env.SUB2API_COMPAT_DROP_TOOLS_ON_COMPACT || '').toLowerCase());
+  const stripPreviousResponseId = options.stripPreviousResponseId
+    ?? ['1', 'true', 'yes', 'on'].includes(String(process.env.SUB2API_COMPAT_STRIP_PREVIOUS_RESPONSE_ID || '').toLowerCase());
 
   const server = http.createServer(async (req, res) => {
     const startAt = Date.now();
@@ -167,34 +191,74 @@ export async function createProxyServer(options = {}) {
       const isResponsesPath = req.method === 'POST' && url.pathname.endsWith('/responses');
       let body = rawBody;
       let compactBody = null;
+      let aggressiveBody = null;
+      let minimalBody = null;
 
       if (isResponsesPath && rawBody.length > 0) {
         try {
           const parsed = JSON.parse(rawBody.toString('utf8'));
-          const normalized = normalizeResponsesPayload(parsed);
+          const normalized = normalizeResponsesPayload(parsed, { stripPreviousResponseId });
           body = Buffer.from(JSON.stringify(normalized));
-          const compacted = compactResponsesPayload(normalized, { dropToolsOnCompact });
-          const compactBuf = Buffer.from(JSON.stringify(compacted));
-          if (compactBuf.length + 512 < body.length) {
-            compactBody = compactBuf;
+          if (body.length > maxReqBytes) {
+            const compacted = compactResponsesPayload(normalized, { dropToolsOnCompact });
+            const compactBuf = Buffer.from(JSON.stringify(compacted));
+            if (compactBuf.length + 512 < body.length) {
+              compactBody = compactBuf;
+            }
+            const aggressive = compactResponsesPayload(normalized, {
+              dropToolsOnCompact,
+              maxRecentMessages: 3
+            });
+            const aggressiveBuf = Buffer.from(JSON.stringify(aggressive));
+            if (aggressiveBuf.length + 256 < body.length) {
+              aggressiveBody = aggressiveBuf;
+            }
+            const minimal = compactResponsesPayload(normalized, {
+              dropToolsOnCompact,
+              maxRecentMessages: 1
+            });
+            const minimalBuf = Buffer.from(JSON.stringify(minimal));
+            if (minimalBuf.length + 128 < body.length) {
+              minimalBody = minimalBuf;
+            }
           }
         } catch {
           // Keep original body if parse fails.
         }
       }
 
+      const requestBodies = [body];
+      if (compactBody && !compactBody.equals(body)) {
+        requestBodies.push(compactBody);
+      }
+      if (aggressiveBody && !aggressiveBody.equals(body) && !(compactBody && aggressiveBody.equals(compactBody))) {
+        requestBodies.push(aggressiveBody);
+      }
+      if (
+        minimalBody
+        && !minimalBody.equals(body)
+        && !(compactBody && minimalBody.equals(compactBody))
+        && !(aggressiveBody && minimalBody.equals(aggressiveBody))
+      ) {
+        requestBodies.push(minimalBody);
+      }
+
       let resp;
       let attempts = 0;
       let via = 'primary';
       let primaryStatus = null;
       let fallbackStatus = null;
       let compacted = false;
+      let strategy = 'full';
       const maxAttempts = isResponsesPath ? retryMax : 1;
       while (attempts < maxAttempts) {
         attempts += 1;
-        const shouldCompactNow = Boolean(compactBody && (attempts > 1 || body.length > maxReqBytes));
-        const requestBody = shouldCompactNow ? compactBody : body;
-        compacted = shouldCompactNow;
+        const strategyIndex = Math.min(requestBodies.length - 1, attempts - 1);
+        const requestBody = requestBodies[strategyIndex];
+        compacted = strategyIndex > 0;
+        strategy = strategyIndex === 0
+          ? 'full'
+          : (strategyIndex === 1 ? 'compact' : (strategyIndex === 2 ? 'aggressive' : 'minimal'));
         const primaryHeaders = isResponsesPath ? buildHeaders(baseHeaders, requestBody.length) : baseHeaders;
         const fallbackHeaders = isResponsesPath
           ? buildHeaders(baseHeaders, requestBody.length, fallbackApiKey)
@@ -244,8 +308,9 @@ export async function createProxyServer(options = {}) {
         primaryStatus,
         fallbackStatus,
         compacted,
+        strategy,
         reqBytes: rawBody.length,
-        upstreamReqBytes: compactBody && compacted ? compactBody.length : body.length,
+        upstreamReqBytes: requestBodies[Math.min(requestBodies.length - 1, attempts - 1)].length,
         respBytes: outBuffer.length,
         durationMs: Date.now() - startAt
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autotask/atools-tool",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "ATools CLI for OpenClaw proxy compatibility and interactive model configuration",
   "type": "module",
   "license": "MIT",
@@ -33,7 +33,7 @@
   },
   "scripts": {
     "start": "node ./bin/cli.mjs serve",
-    "config:openclaw": "node ./bin/cli.mjs config-openclaw",
+    "config:openclaw": "node ./bin/cli.mjs openclaw",
     "install:local": "node ./bin/install.mjs",
     "pack:check": "npm pack"
   },