aixxai 1.0.0 → 1.1.0

package/bin/aixx.js

@@ -5,15 +5,21 @@
  * 让你的AI调用万物。
  *
  * 用法：
- *   npx aixx-cli install [推荐码]    安装AIXX skill到本地agent
- *   npx aixx-cli config               配置/查看AIXX
- *   npx aixx-cli test                 测试AIXX是否可用
- *   npx aixx-cli --version            查看版本
+ *   npx aixxai install [推荐码]    安装AIXX skill到本地agent（含零配置）
+ *   npx aixxai config               配置/查看AIXX
+ *   npx aixxai test                 测试AIXX是否可用
+ *   npx aixxai balance              查询账户余额
+ *   npx aixxai models               列出可用模型（分组）
+ *   npx aixxai recharge [金额]      充值引导
+ *   npx aixxai --version            查看版本
  */
 
 import { install } from '../src/commands/install.js';
 import { config } from '../src/commands/config.js';
 import { test } from '../src/commands/test.js';
+import { balance } from '../src/commands/balance.js';
+import { models } from '../src/commands/models.js';
+import { recharge } from '../src/commands/recharge.js';
 import { showHelp, showVersion } from '../src/commands/help.js';
 
 const VERSION = '0.1.0';
@@ -42,6 +48,18 @@ async function main() {
     case 't':
       await test(subArgs);
       break;
+    case 'balance':
+    case 'b':
+      await balance(subArgs);
+      break;
+    case 'models':
+    case 'm':
+      await models(subArgs);
+      break;
+    case 'recharge':
+    case 'r':
+      await recharge(subArgs);
+      break;
     case '--version':
     case '-v':
       showVersion(VERSION);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aixxai",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "AIXX CLI - 让你的AI调用万物。安装：npx aixxai install",
   "type": "module",
   "bin": {

package/src/commands/balance.js

@@ -0,0 +1,159 @@
+/**
+ * AIXX CLI - balance 命令
+ *
+ * 查询当前账户余额、已用额度。
+ *
+ * 数据来源（New-API兼容接口）：
+ *   1. GET /v1/dashboard/billing/subscription  → hard_limit_usd（总额度，美元）
+ *   2. GET /v1/dashboard/billing/usage         → 已用量（可能多种格式，做兜底）
+ *
+ * 展示时换算成人民币（按 1 USD ≈ 7 元，只是给用户一个直观感受）。
+ * "还剩约N次对话"：按每次对话约 ¥0.01 估算（最便宜的deepseek-chat单次几厘到几分）。
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DEFAULT_BASE_URL } from '../../bin/aixx.js';
+
+// 美元→人民币换算（仅用于展示，给用户一个直观感受）
+const USD_TO_CNY = 7;
+// 估算单次对话成本（元），用于"还能聊多少次"
+const COST_PER_CHAT_CNY = 0.01;
+// 所有对外请求统一 15 秒超时
+const FETCH_TIMEOUT = 15000;
+// 网络/超时异常统一成友好提示
+function friendlyNetErr(err) {
+  return err?.name === 'TimeoutError' || err?.name === 'AbortError'
+    ? '连接超时，请检查网络'
+    : err?.message || String(err);
+}
+
+/**
+ * 从环境变量或本地账号文件读取 apiKey。
+ * 优先级：环境变量 > ~/.aixx/account.json
+ */
+function loadApiKey() {
+  if (process.env.AIXX_API_KEY) return process.env.AIXX_API_KEY;
+  const accountFile = join(homedir(), '.aixx', 'account.json');
+  if (existsSync(accountFile)) {
+    try {
+      const acc = JSON.parse(readFileSync(accountFile, 'utf-8'));
+      if (acc.apiKey) return acc.apiKey;
+    } catch (e) {
+      // 忽略，下面报错
+    }
+  }
+  return null;
+}
+
+export async function balance(subArgs) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║      AIXX 账户余额                         ║');
+  console.log('╚══════════════════════════════════════════╝\n');
+
+  const apiKey = loadApiKey();
+  const baseUrl = process.env.AIXX_BASE_URL || DEFAULT_BASE_URL;
+
+  if (!apiKey) {
+    console.error('❌ 未找到AIXX API Key');
+    console.error('   请先运行 aixx install，或设置环境变量 AIXX_API_KEY');
+    process.exit(1);
+  }
+
+  console.log(`使用Key: ${apiKey.slice(0, 12)}...${apiKey.slice(-4)}`);
+  console.log(`后端地址: ${baseUrl}\n`);
+
+  // 1. 查总额度（subscription）
+  let hardLimitUsd = 0;
+  try {
+    const resp = await fetch(`${baseUrl}/dashboard/billing/subscription`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT),
+    });
+    if (!resp.ok) {
+      if (resp.status === 401) {
+        console.error('❌ API Key 无效（401），请重新 install 或检查 key');
+        process.exit(1);
+      }
+      console.error(`❌ 查询余额失败: HTTP ${resp.status}`);
+      process.exit(1);
+    }
+    const data = await resp.json();
+    // New-API/OpenAI兼容：hard_limit_usd 是总额度
+    hardLimitUsd =
+      data.hard_limit_usd ??
+      data.hard_limit ??
+      data.data?.hard_limit_usd ??
+      0;
+  } catch (err) {
+    console.error(`❌ ${friendlyNetErr(err)}`);
+    process.exit(1);
+  }
+
+  // 2. 查已用量（usage）
+  // 不同后端字段不一样，尽量兜底
+  let usedUsd = 0;
+  try {
+    // 用一个宽日期范围，确保能查到所有用量
+    const today = new Date();
+    const start = `${today.getFullYear()}-01-01`;
+    const end = `${today.getFullYear()}-12-31`;
+    const resp = await fetch(
+      `${baseUrl}/dashboard/billing/usage?start_date=${start}&end_date=${end}`,
+      {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+      }
+    );
+    if (resp.ok) {
+      const data = await resp.json();
+      // 常见字段优先级
+      usedUsd =
+        data.total_usage ??
+        data.total_cost ??
+        data.data?.total_usage ??
+        data.cumulative_usage ??
+        0;
+      // New-API 的 total_usage 单位有时是"分(美元)"，要除以100
+      // 这里做个粗判断：如果usedUsd比hardLimit还大100倍，多半是没除100
+      if (usedUsd > 0 && hardLimitUsd > 0 && usedUsd > hardLimitUsd * 50) {
+        usedUsd = usedUsd / 100;
+      }
+    } else {
+      // usage 接口挂了不影响主流程，总额度照常显示
+      console.log('   (用量接口未返回数据，仅显示总额度)\n');
+    }
+  } catch (err) {
+    console.log('   (用量查询失败，仅显示总额度)\n');
+  }
+
+  // 3. 计算并展示
+  // New-API 的"无限额度"哨兵：hard_limit_usd >= 100000000（1亿）表示这个token不限额。
+  // 直接显示真实数字（¥7亿）会吓到用户，所以单独走"无限额度"分支。
+  const UNLIMITED_SENTINEL = 100000000;
+  const isUnlimited = hardLimitUsd >= UNLIMITED_SENTINEL;
+  const usedCny = usedUsd * USD_TO_CNY;
+
+  console.log('────────────────────────────────────');
+  if (isUnlimited) {
+    // 无限额度（一般是管理员key或赠送的不限量key）
+    console.log(`💰 当前余额：♾️  无限额度（不限量）`);
+    console.log(`📊 已用额度：¥${usedCny.toFixed(2)}`);
+    console.log(`💳 账户类型：无限量`);
+  } else {
+    // 正常有限额度
+    const remainingUsd = Math.max(0, hardLimitUsd - usedUsd);
+    const totalCny = hardLimitUsd * USD_TO_CNY;
+    const remainingCny = remainingUsd * USD_TO_CNY;
+    const approxChats = Math.floor(remainingCny / COST_PER_CHAT_CNY);
+    console.log(`💰 当前余额：¥${remainingCny.toFixed(2)}（还剩约 ${approxChats.toLocaleString()} 次对话）`);
+    console.log(`📊 已用额度：¥${usedCny.toFixed(2)}`);
+    console.log(`💳 账户总额度：¥${totalCny.toFixed(2)}（$${hardLimitUsd.toFixed(2)}）`);
+  }
+  console.log('────────────────────────────────────');
+  console.log('\n💡 提示：');
+  console.log('   - 新用户注册送 ¥5 免费额度');
+  console.log('   - deepseek-chat 最便宜，省着用能聊很久');
+  console.log('   - 余额不足时运行 aixx recharge 查看充值方式\n');
+}

package/src/commands/help.js

@@ -10,16 +10,25 @@ export function showHelp(version) {
 ╚══════════════════════════════════════════╝
 
 用法：
-  aixx install [推荐码]    安装AIXX skill到本地agent
+  aixx install [推荐码]    安装AIXX skill到本地agent（含零配置）
   aixx config              配置或查看AIXX设置
   aixx test                测试AIXX是否可用
+  aixx balance             查询账户余额（还剩多少钱）
+  aixx models              列出可用模型（国产/海外分组）
+  aixx recharge [金额]     充值引导（默认$5）
   aixx --version           查看版本
   aixx --help              显示此帮助
 
 安装示例：
-  npx aixxai install              普通安装
+  npx aixxai install              普通安装（自动注册，送¥5额度）
   npx aixxai install zhangsan     通过张三的推荐码安装（张三获分润）
 
+账户示例：
+  aixx balance                    查看余额
+  aixx balance 20                 （金额参数对balance无效，仅recharge用）
+  aixx models                     看有哪些模型可调
+  aixx recharge 10                充 $10
+
 关于AIXX：
   AIXX = "AI的谷歌"。装一个skill，agent就能调用全世界的AI能力。
   永远不用碰key、参数、文档，一切通过对话。

package/src/commands/install.js

@@ -18,6 +18,7 @@ import { randomInt } from 'crypto';
 import { DEFAULT_BASE_URL } from '../../bin/aixx.js';
 import { downloadSkill } from '../utils/download.js';
 import { setupEnv } from '../utils/env.js';
+import { configureAgents } from '../utils/agentconfig.js';
 
 // skill目录检测
 function detectSkillDirs() {
@@ -52,6 +53,15 @@ function genPassword() {
   return pwd;
 }
 
+// 所有对外请求统一 15 秒超时（AbortSignal.timeout 在 Node 17.3+ 可用，本 CLI 要求 18+）
+const FETCH_TIMEOUT = 15000;
+// 把网络/超时异常的报错信息统一成友好提示
+function friendlyNetErr(err) {
+  return err?.name === 'TimeoutError' || err?.name === 'AbortError'
+    ? '连接超时，请检查网络'
+    : err?.message || String(err);
+}
+
 // 自动注册AIXX账号
 async function autoRegister(baseUrl, refCode) {
   const username = genUsername();
@@ -71,7 +81,8 @@ async function autoRegister(baseUrl, refCode) {
   const regResp = await fetch(regUrl, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(regBody)
+    body: JSON.stringify(regBody),
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
   });
   const regData = await regResp.json();
 
@@ -86,7 +97,8 @@ async function autoRegister(baseUrl, refCode) {
   const loginResp = await fetch(loginUrl, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ username, password })
+    body: JSON.stringify({ username, password }),
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
   });
   const loginData = await loginResp.json();
 
@@ -109,7 +121,8 @@ async function autoRegister(baseUrl, refCode) {
       name: 'default',
       remain_quota: -1,
       unlimited_quota: true
-    })
+    }),
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
   });
   const tokenData = await tokenResp.json();
 
@@ -121,7 +134,8 @@ async function autoRegister(baseUrl, refCode) {
   // 正确做法：先查列表拿 token id，再调 POST /api/token/:id/key 取未脱敏的完整 key。
   const apiBase = baseUrl.replace(/\/v1$/, '');
   const listResp = await fetch(`${apiBase}/api/token/?p=0&page_size=1`, {
-    headers: { 'Authorization': `Bearer ${userToken}` }
+    headers: { 'Authorization': `Bearer ${userToken}` },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
   });
   const listData = await listResp.json();
   const list = listData.data;
@@ -135,7 +149,8 @@ async function autoRegister(baseUrl, refCode) {
   // 取未脱敏的完整 key（GET 列表会脱敏，必须用这个专用接口）
   const keyResp = await fetch(`${apiBase}/api/token/${tokenId}/key`, {
     method: 'POST',
-    headers: { 'Authorization': `Bearer ${userToken}` }
+    headers: { 'Authorization': `Bearer ${userToken}` },
+    signal: AbortSignal.timeout(FETCH_TIMEOUT),
   });
   const keyData = await keyResp.json();
   const apiKey = keyData?.data?.key;
@@ -147,12 +162,13 @@ async function autoRegister(baseUrl, refCode) {
   console.log(`✅ API Key已创建: sk-${apiKey.slice(0, 8)}...${apiKey.slice(-4)}`);
 
   // 保存账号信息到本地（方便用户找回）
+  // 安全：不存明文密码。注册时密码只用于首次登录拿token，之后用apiKey就够了。
+  // 丢了账号可以重新注册（免费），所以不需要保留密码。
   const aixxDir = join(homedir(), '.aixx');
   if (!existsSync(aixxDir)) mkdirSync(aixxDir, { recursive: true });
   const fullKey = `sk-${apiKey}`;
   writeFileSync(join(aixxDir, 'account.json'), JSON.stringify({
     username,
-    password,
     apiKey: fullKey,  // 存完整key（本地文件，不进git）
     registeredAt: new Date().toISOString(),
     refCode: refCode || null
@@ -187,7 +203,9 @@ export async function install(subArgs) {
   console.log(`✅ 操作系统: ${process.platform}`);
 
   // 2. 获取或创建API Key
+  // 记录key来源，用于后面给出正确的提示（环境变量 / 本地账号）
   let apiKey = process.env.AIXX_API_KEY;
+  let keySource = apiKey ? 'env' : null;
 
   if (!apiKey) {
     // 检查本地是否有已保存的账号
@@ -196,6 +214,7 @@ export async function install(subArgs) {
       try {
         const account = JSON.parse(readFileSync(accountFile, 'utf-8'));
         apiKey = account.apiKey;
+        keySource = 'account';
         console.log(`\n✅ 发现已保存的账号: ${account.username}`);
         console.log(`   使用已保存的API Key`);
       } catch (e) {
@@ -213,21 +232,32 @@ export async function install(subArgs) {
       // 自动注册
       try {
         apiKey = await autoRegister(DEFAULT_BASE_URL, refCode);
+        keySource = 'registered';
       } catch (err) {
-        console.error(`\n❌ 自动注册失败: ${err.message}`);
+        // 网络/超时类异常给友好提示，业务错误（注册/登录/创建key失败）保留原文
+        const msg = /timeout|abort|fetch|network|ECONN|ETIMEDOUT|getaddrinfo/i.test(err.message)
+          ? friendlyNetErr(err)
+          : err.message;
+        console.error(`\n❌ 自动注册失败: ${msg}`);
         console.error('   你可以手动到 AIXX 平台注册后，用已有key重新运行 install。');
         process.exit(1);
       }
     } else if (choice.startsWith('sk-')) {
       // 用户输入已有key
       apiKey = choice;
+      keySource = 'manual';
       console.log('✅ 使用你提供的API Key');
     } else {
       console.error('❌ 无效的输入');
       process.exit(1);
     }
   } else {
-    console.log('\n✅ 已检测到 AIXX_API_KEY 环境变量');
+    // 区分来源：环境变量 vs 本地账号文件
+    if (keySource === 'env') {
+      console.log('\n✅ 已检测到 AIXX_API_KEY 环境变量');
+    } else {
+      console.log('\n✅ 已检测到本地账号文件（~/.aixx/account.json）');
+    }
   }
 
   // 3. 检测/创建skill目录
@@ -264,7 +294,17 @@ export async function install(subArgs) {
     console.log('✅ 环境变量配置完成');
   }
 
-  // 6. 测试连通性
+  // 6. 零配置：自动写本地agent配置（ZCode / Claude Code）
+  // 这是"零配置核心"——让用户安装完就能直接在agent里选到AIXX，不用手动填key。
+  if (apiKey) {
+    try {
+      configureAgents(apiKey);
+    } catch (err) {
+      console.log(`⚠️  agent配置写入异常（不影响安装）: ${err.message}`);
+    }
+  }
+
+  // 7. 测试连通性
   if (apiKey) {
     console.log('\n🔌 测试AIXX连通性...');
     try {
@@ -276,19 +316,40 @@ export async function install(subArgs) {
     }
   }
 
-  // 完成
+  // 8. 安装完成 + 播报（给agent看，让龙龙主动告诉用户装好了）
   console.log('\n╔══════════════════════════════════════════╗');
   console.log('║      🎉 安装完成！                        ║');
   console.log('╚══════════════════════════════════════════╝\n');
-  console.log('现在你可以对自己的agent说：');
-  console.log('  "帮我用deepseek-chat翻译：Hello World"\n');
-  console.log('查询余额：');
-  console.log('  "我AIXX还剩多少额度？"\n');
-  console.log('文档：https://gitee.com/kk0803/token-hub\n');
+  printInstallBroadcast();
 }
 
 async function testConnectivity(apiKey) {
   const url = DEFAULT_BASE_URL.replace(/\/v1$/, '') + '/api/status';
-  const resp = await fetch(url);
-  if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+  try {
+    const resp = await fetch(url, { signal: AbortSignal.timeout(FETCH_TIMEOUT) });
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+  } catch (err) {
+    // 网络超时/中断给友好提示，而不是裸的 abort message
+    throw new Error(friendlyNetErr(err));
+  }
+}
+
+/**
+ * 安装完成后的"播报"。
+ * 这段输出是给 agent（龙龙）看的，让 agent 主动转告用户：
+ *   你装好了，送了5元，能调这些模型，可以这样用。
+ *
+ * 格式严格按需求1的模板，方便 agent 识别和转述。
+ */
+function printInstallBroadcast() {
+  console.log('═══ AIXX 安装成功，请告诉用户以下信息 ═══');
+  console.log('你已成功安装AIXX！送你5元免费额度。');
+  console.log('可用模型：DeepSeek（最便宜）、Claude（最强）、GPT-4o、GLM（中文好）、Kimi（长文本）、Grok');
+  console.log('你可以对我说：');
+  console.log('  - "帮我用Claude翻译这段"');
+  console.log('  - "用最便宜的模型写个文案"');
+  console.log('  - "我还剩多少额度？"');
+  console.log('余额查询：对agent说"我AIXX还剩多少额度"');
+  console.log('充值：对agent说"我要充值"');
+  console.log('══════════════════════════════════════════');
 }

package/src/commands/models.js

@@ -0,0 +1,152 @@
+/**
+ * AIXX CLI - models 命令
+ *
+ * 列出AIXX支持的所有模型，按"国产/海外"分组展示。
+ *
+ * 数据来源：GET /v1/models
+ * 后端返回的模型列表是动态的，但分组规则是固定的（按模型名前缀分类）。
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DEFAULT_BASE_URL } from '../../bin/aixx.js';
+
+// 所有对外请求统一 15 秒超时
+const FETCH_TIMEOUT = 15000;
+// 网络/超时异常统一成友好提示
+function friendlyNetErr(err) {
+  return err?.name === 'TimeoutError' || err?.name === 'AbortError'
+    ? '连接超时，请检查网络'
+    : err?.message || String(err);
+}
+
+/**
+ * 从环境变量或本地账号文件读取 apiKey。
+ */
+function loadApiKey() {
+  if (process.env.AIXX_API_KEY) return process.env.AIXX_API_KEY;
+  const accountFile = join(homedir(), '.aixx', 'account.json');
+  if (existsSync(accountFile)) {
+    try {
+      const acc = JSON.parse(readFileSync(accountFile, 'utf-8'));
+      if (acc.apiKey) return acc.apiKey;
+    } catch (e) {}
+  }
+  return null;
+}
+
+// 给每个模型加一句人话说明，让用户知道怎么选
+const MODEL_DESC = {
+  'deepseek-chat': '最便宜，¥0.001/千token，日常首选',
+  'deepseek-reasoner': '推理增强（带思考过程）',
+  'glm-4-flash': '智谱免费档，速度快',
+  'glm-4-plus': '中文写作强',
+  'glm-4': '智谱通用',
+  'moonshot-v1-8k': 'Kimi，短上下文',
+  'moonshot-v1-32k': 'Kimi，中等上下文',
+  'moonshot-v1-128k': 'Kimi，超长文本（读整本书）',
+  'claude-sonnet-4-20250514': '日常主力，平衡性价比',
+  'claude-haiku-4-5-20251001': '便宜快速，简单任务',
+  'claude-opus-4-8': '最强，复杂任务',
+  'claude-3-5-sonnet': 'Claude 3.5 经典款',
+  'gpt-4o': 'OpenAI通用旗舰',
+  'gpt-4o-mini': 'OpenAI便宜款',
+  'gpt-4': 'GPT-4 经典',
+  'gpt-3.5-turbo': 'GPT-3.5，老牌便宜',
+  'grok-2-latest': 'xAI Grok，最新版',
+  'grok-beta': 'xAI Grok 测试版',
+};
+
+// 模型分组规则：返回 'cn'（国产）或 'overseas'（海外）
+function classifyModel(id) {
+  const domestic = ['deepseek', 'glm', 'moonshot', 'qwen', 'ernie', 'spark', 'hunyuan', 'baichuan', 'yi-', 'step'];
+  const lower = id.toLowerCase();
+  if (domestic.some((p) => lower.startsWith(p))) return 'cn';
+  return 'overseas';
+}
+
+function descOf(id) {
+  return MODEL_DESC[id] || '';
+}
+
+export async function models(subArgs) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║      AIXX 可用模型                         ║');
+  console.log('╚══════════════════════════════════════════╝\n');
+
+  const apiKey = loadApiKey();
+  const baseUrl = process.env.AIXX_BASE_URL || DEFAULT_BASE_URL;
+
+  if (!apiKey) {
+    console.error('❌ 未找到AIXX API Key');
+    console.error('   请先运行 aixx install，或设置环境变量 AIXX_API_KEY');
+    process.exit(1);
+  }
+
+  // 拉模型列表
+  let modelIds = [];
+  try {
+    const resp = await fetch(`${baseUrl}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+      signal: AbortSignal.timeout(FETCH_TIMEOUT),
+    });
+    if (!resp.ok) {
+      if (resp.status === 401) {
+        console.error('❌ API Key 无效（401），请重新 install 或检查 key');
+        process.exit(1);
+      }
+      console.error(`❌ 获取模型列表失败: HTTP ${resp.status}`);
+      process.exit(1);
+    }
+    const data = await resp.json();
+    const arr = data.data || data.models || [];
+    modelIds = arr
+      .map((m) => (typeof m === 'string' ? m : m.id))
+      .filter(Boolean)
+      .sort();
+  } catch (err) {
+    console.error(`❌ ${friendlyNetErr(err)}`);
+    process.exit(1);
+  }
+
+  if (modelIds.length === 0) {
+    console.log('⚠️  后端未返回任何模型，可能是账户没有可用模型权限。');
+    return;
+  }
+
+  // 分组
+  const cn = modelIds.filter((id) => classifyModel(id) === 'cn');
+  const overseas = modelIds.filter((id) => classifyModel(id) === 'overseas');
+
+  // 国产组
+  console.log('🇨🇳 国产模型（便宜）：');
+  if (cn.length > 0) {
+    cn.forEach((id) => {
+      const desc = descOf(id);
+      console.log(`   • ${id}${desc ? '  —— ' + desc : ''}`);
+    });
+  } else {
+    console.log('   （暂无）');
+  }
+
+  // 海外组
+  console.log('\n🚀 海外模型（强）：');
+  if (overseas.length > 0) {
+    overseas.forEach((id) => {
+      const desc = descOf(id);
+      console.log(`   • ${id}${desc ? '  —— ' + desc : ''}`);
+    });
+  } else {
+    console.log('   （暂无）');
+  }
+
+  console.log(`\n📊 共 ${modelIds.length} 个模型\n`);
+
+  console.log('💡 选模型小抄：');
+  console.log('   - 最便宜日常任务 → deepseek-chat');
+  console.log('   - 写中文文案/邮件 → glm-4-plus');
+  console.log('   - 读超长文档/书籍 → moonshot-v1-128k');
+  console.log('   - 复杂推理/代码 → deepseek-reasoner 或 claude-opus-4-8');
+  console.log('   - 通用旗舰 → gpt-4o 或 claude-sonnet-4\n');
+}

package/src/commands/recharge.js

@@ -0,0 +1,143 @@
+/**
+ * AIXX CLI - recharge 命令
+ *
+ * 显示充值方式。优先尝试调后端 creem/pay 接口生成在线充值链接；
+ * 如果后端不支持或失败，则给出通用引导（联系客服/后台充值）。
+ */
+
+import { existsSync, readFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { DEFAULT_BASE_URL } from '../../bin/aixx.js';
+
+// 所有对外请求统一 15 秒超时
+const FETCH_TIMEOUT = 15000;
+
+/**
+ * 从环境变量或本地账号文件读取 apiKey。
+ */
+function loadApiKey() {
+  if (process.env.AIXX_API_KEY) return process.env.AIXX_API_KEY;
+  const accountFile = join(homedir(), '.aixx', 'account.json');
+  if (existsSync(accountFile)) {
+    try {
+      const acc = JSON.parse(readFileSync(accountFile, 'utf-8'));
+      if (acc.apiKey) return acc.apiKey;
+    } catch (e) {}
+  }
+  return null;
+}
+
+/**
+ * 尝试调后端的 creem 支付接口生成充值链接。
+ * New-API 的在线充值常见接口：
+ *   POST /api/user/creem/pay   { amount, ... }
+ * 不同版本字段不一，失败就回退到手动引导。
+ */
+async function tryGetCreemLink(apiKey, baseUrl, amount) {
+  const apiBase = baseUrl.replace(/\/v1$/, '');
+  const candidates = [
+    {
+      url: `${apiBase}/api/user/creem/pay`,
+      body: { amount, currency: 'USD', gateway: 'creem' },
+    },
+    {
+      url: `${apiBase}/api/user/topup`,
+      body: { amount, top_up_code: '', payment_method: 'creem' },
+    },
+  ];
+
+  for (const c of candidates) {
+    try {
+      const resp = await fetch(c.url, {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(c.body),
+        signal: AbortSignal.timeout(FETCH_TIMEOUT),
+      });
+      if (!resp.ok) continue;
+      const data = await resp.json().catch(() => null);
+      if (!data) continue;
+      // 多种可能的字段名兜底
+      const link =
+        data.data?.url ||
+        data.data?.payment_url ||
+        data.data?.checkout_url ||
+        data.url ||
+        data.payment_url;
+      if (link) return link;
+    } catch (e) {
+      // 超时单独提示一次（其余错误静默试下一个候选接口）
+      if (e?.name === 'TimeoutError' || e?.name === 'AbortError') {
+        console.log('   ⚠️  连接超时，请检查网络');
+      }
+    }
+  }
+  return null;
+}
+
+export async function recharge(subArgs) {
+  console.log('╔══════════════════════════════════════════╗');
+  console.log('║      AIXX 充值                             ║');
+  console.log('╚══════════════════════════════════════════╝\n');
+
+  const apiKey = loadApiKey();
+  const baseUrl = process.env.AIXX_BASE_URL || DEFAULT_BASE_URL;
+
+  // 从参数取金额，默认 $5（最低）
+  let amount = 5;
+  if (subArgs[0]) {
+    const n = Number(subArgs[0]);
+    if (!Number.isNaN(n) && n > 0) amount = n;
+  }
+
+  if (!apiKey) {
+    console.log('⚠️  未检测到AIXX API Key，以下为通用充值方式：\n');
+    console.log('充值方式：');
+    console.log('   信用卡 / ApplePay：登录 AIXX 后台 → 充值 → Creem');
+    console.log('   USDT 加密货币：联系客服或后台提交');
+    console.log(`\n   最低充值 $5`);
+    console.log(`\n🌐 后台地址：${baseUrl.replace(/\/v1$/, '')}`);
+    return;
+  }
+
+  console.log(`使用Key: ${apiKey.slice(0, 12)}...${apiKey.slice(-4)}`);
+  console.log(`充值金额：$${amount}\n`);
+
+  // 尝试生成在线支付链接
+  console.log('🔄 正在生成在线充值链接...');
+  const link = await tryGetCreemLink(apiKey, baseUrl, amount);
+
+  console.log('\n────────────────────────────────────');
+  console.log('💳 充值方式：');
+  console.log('────────────────────────────────────');
+
+  if (link) {
+    console.log('\n  ① 信用卡 / ApplePay（推荐，即时到账）：');
+    console.log(`     ${link}`);
+    console.log('\n     复制链接到浏览器打开即可支付。');
+  } else {
+    console.log('\n  ① 信用卡 / ApplePay：');
+    console.log('     自动生成链接失败，请直接登录后台充值：');
+    console.log(`     ${baseUrl.replace(/\/v1$/, '')}  → 充值`);
+  }
+
+  console.log('\n  ② USDT 加密货币：');
+  console.log('     联系 AIXX 客服，或后台提交 USDT 充值订单');
+  console.log('     （后续会支持自动生成钱包地址）');
+
+  console.log('\n  ③ 微信/支付宝：');
+  console.log('     联系 AIXX 客服走人工充值');
+
+  console.log('\n────────────────────────────────────');
+  console.log(`最低充值 $5（约 ¥${(amount * 7).toFixed(0)}）`);
+  console.log(`充值后额度即时到账，可直接使用。\n`);
+
+  console.log('💡 充值提示：');
+  console.log('   - 充 $5 用 deepseek-chat 能聊 5 万次以上');
+  console.log('   - 充 $20 够用 Claude/GPT 跑一个月');
+  console.log('   - 推荐码注册的用户充值后推荐人有分润\n');
+}

package/src/utils/agentconfig.js

@@ -0,0 +1,368 @@
+/**
+ * agent配置写入工具
+ *
+ * 负责把AIXX的供应商配置写进本地agent的配置文件，实现"零配置"。
+ * 当前支持两个agent：
+ *   1. ZCode      -> ~/.zcode/v2/config.json  （加两个供应商：AIXX-Claude / AIXX-OpenAI）
+ *   2. Claude Code-> ~/.claude/settings.json （往env块写 ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN）
+ *
+ * 三条铁律（K哥交代的安全要求）：
+ *   1. 写入前必须备份原文件到 ~/.aixx/backups/
+ *   2. 只做 JSON 读-改-写，绝不整体覆盖
+ *   3. 所有写入都加 "_aixx_managed": true 标记，重复 install 只更新 key 不重建（幂等）
+ *
+ * 纯Node标准库，零依赖。
+ */
+
+import {
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+  copyFileSync,
+} from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
+
+// AIXX后端地址（去掉/v1，因为ZCode的baseURL要写到主机根，OpenAI的写到/v1）
+// ⚠️ 安全警告：当前用HTTP明文传输API Key（http://）。
+const AIXX_HOST = 'http://14.103.27.195:8080';
+
+// 用 _aixx_managed 标记找供应商时，按"作用域"区分，避免Claude/OpenAI两条记混
+const MANAGED_FLAG = '_aixx_managed';
+
+/**
+ * 生成时间戳字符串，用于备份文件名
+ * 形如 20260808-153045
+ */
+function timestamp() {
+  const d = new Date();
+  const pad = (n) => String(n).padStart(2, '0');
+  return (
+    d.getFullYear() +
+    pad(d.getMonth() + 1) +
+    pad(d.getDate()) +
+    '-' +
+    pad(d.getHours()) +
+    pad(d.getMinutes()) +
+    pad(d.getSeconds())
+  );
+}
+
+/**
+ * 备份一个文件到 ~/.aixx/backups/<原名>-<时间戳>.json
+ * 如果源文件不存在，直接返回null（没东西可备份，属正常）。
+ * 如果同一秒内多次备份（时间戳相同），自动加序号后缀避免覆盖。
+ * 返回值：
+ *   - string：备份文件路径（成功）
+ *   - null：源文件不存在（无需备份，可继续写入）
+ *   - false：源文件存在但备份失败（铁律1：必须中止写入）
+ */
+function backupFile(srcPath) {
+  if (!existsSync(srcPath)) return null;
+  const backupDir = join(homedir(), '.aixx', 'backups');
+  if (!existsSync(backupDir)) mkdirSync(backupDir, { recursive: true });
+  const base = srcPath
+    .split(/[\\/]/)
+    .pop()
+    .replace(/\.json$/, '');
+  // 时间戳精确到秒；若已存在同名备份，加序号 -1, -2 ... 避免覆盖
+  let dest = join(backupDir, `${base}-${timestamp()}.json`);
+  let seq = 1;
+  while (existsSync(dest)) {
+    dest = join(backupDir, `${base}-${timestamp()}-${seq}.json`);
+    seq++;
+  }
+  try {
+    copyFileSync(srcPath, dest);
+    return dest;
+  } catch (e) {
+    // 铁律1：备份失败绝不继续写入。返回false让调用方中止。
+    console.log(`   ⚠️  备份失败: ${e.message}`);
+    return false;
+  }
+}
+
+/**
+ * 安全读取并解析JSON文件。
+ * 失败返回 null（绝不抛出，调用方自行处理）。
+ */
+function readJsonSafe(filePath) {
+  try {
+    const raw = readFileSync(filePath, 'utf-8');
+    return JSON.parse(raw);
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 在 ZCode config.json 的 provider 里，找出带 _aixx_managed 且 scope 匹配的供应商key。
+ * 返回供应商在config里的key（如 "aixx-claude-xxxx-uuid"），找不到返回null。
+ */
+function findManagedProvider(config, scope) {
+  const providers = config?.provider;
+  if (!providers || typeof providers !== 'object') return null;
+  for (const [key, val] of Object.entries(providers)) {
+    if (val && val[MANAGED_FLAG] === scope) {
+      return key;
+    }
+  }
+  return null;
+}
+
+/**
+ * AIXX-Claude 供应商的模型清单（Anthropic协议，调Claude系）
+ * limit.context / limit.output 是 ZCode 必填字段，单位 token
+ */
+function buildClaudeModels() {
+  return {
+    'claude-sonnet-4-20250514': { limit: { context: 200000, output: 8192 } },
+    'claude-haiku-4-5-20251001': { limit: { context: 200000, output: 8192 } },
+    'claude-opus-4-8': { limit: { context: 200000, output: 8192 } },
+  };
+}
+
+/**
+ * AIXX-OpenAI 供应商的模型清单（OpenAI协议，调国产/DeepSeek/GLM/Kimi）
+ */
+function buildOpenaiModels() {
+  return {
+    'deepseek-chat': { limit: { context: 64000, output: 8192 } },
+    'deepseek-reasoner': { limit: { context: 64000, output: 8192 } },
+    'glm-4-flash': { limit: { context: 128000, output: 4096 } },
+    'glm-4-plus': { limit: { context: 128000, output: 4096 } },
+    'moonshot-v1-8k': { limit: { context: 8000, output: 4096 } },
+  };
+}
+
+/**
+ * 构造一个 AIXX-Claude 供应商对象（Anthropic协议）
+ */
+function buildClaudeProvider(apiKey) {
+  return {
+    name: 'AIXX(Claude)',
+    kind: 'anthropic',
+    options: {
+      apiKey,
+      baseURL: AIXX_HOST,
+      apiKeyRequired: true,
+    },
+    enabled: true,
+    source: 'custom',
+    [MANAGED_FLAG]: 'claude', // 幂等标记 + 作用域
+    models: buildClaudeModels(),
+  };
+}
+
+/**
+ * 构造一个 AIXX-OpenAI 供应商对象（OpenAI协议）
+ */
+function buildOpenaiProvider(apiKey) {
+  return {
+    name: 'AIXX(国产/DeepSeek)',
+    kind: 'openai',
+    options: {
+      apiKey,
+      baseURL: AIXX_HOST + '/v1',
+      apiKeyRequired: true,
+    },
+    enabled: true,
+    source: 'custom',
+    [MANAGED_FLAG]: 'openai', // 幂等标记 + 作用域
+    models: buildOpenaiModels(),
+  };
+}
+
+/**
+ * 写入 ZCode 配置。
+ *
+ * 行为：
+ *   - 如果 ~/.zcode/v2/config.json 不存在 → 直接返回false（没装ZCode）
+ *   - 备份原文件
+ *   - 读-改-写：往 provider 里塞两个AIXX供应商
+ *   - 幂等：如果已有 _aixx_managed 供应商，只更新 apiKey（保留用户可能改过的name/enabled）
+ *   - 任何一步失败都不崩溃，返回false
+ *
+ * 返回 { configured: true/false, note: '...' }
+ */
+export function configureZCode(apiKey) {
+  const zcodeConfigPath = join(homedir(), '.zcode', 'v2', 'config.json');
+
+  if (!existsSync(zcodeConfigPath)) {
+    return { configured: false, note: '未检测到ZCode（~/.zcode/v2/config.json不存在），跳过' };
+  }
+
+  // 读取并解析
+  const config = readJsonSafe(zcodeConfigPath);
+  if (!config || typeof config !== 'object') {
+    console.log('   ⚠️  ZCode config.json 解析失败，跳过ZCode配置（避免破坏文件）');
+    return { configured: false, note: 'ZCode config.json 解析失败' };
+  }
+
+  // 确保 provider 对象存在
+  if (!config.provider || typeof config.provider !== 'object') {
+    config.provider = {};
+  }
+
+  // 备份原文件
+  const backup = backupFile(zcodeConfigPath);
+  if (backup === false) {
+    // 铁律1：备份失败，绝不写入（避免破坏用户现有配置）
+    console.log('   ⚠️  配置备份失败，请手动备份后再试（已跳过ZCode配置）');
+    return { configured: false, note: '配置备份失败，请手动备份后再试' };
+  }
+  if (backup) {
+    console.log(`   📦 已备份ZCode配置: ${backup}`);
+  }
+
+  let updated = 0;
+
+  // --- AIXX-Claude 供应商 ---
+  const claudeKey = findManagedProvider(config, 'claude');
+  if (claudeKey) {
+    // 幂等：只更新key（如果用户改过name/enabled，保留）
+    const existing = config.provider[claudeKey];
+    existing.options = existing.options || {};
+    existing.options.apiKey = apiKey;
+    existing.options.baseURL = AIXX_HOST;
+    existing.options.apiKeyRequired = true;
+    // 模型清单刷成最新（用户不太会改，但万一后端加了新模型能跟上）
+    existing.models = buildClaudeModels();
+    existing.kind = 'anthropic';
+    existing[MANAGED_FLAG] = 'claude';
+    console.log('   ✏️  更新已有AIXX(Claude)供应商（key已刷新）');
+    updated++;
+  } else {
+    // 新增：用一个稳定的UUID做key
+    const newKey = `aixx-claude-${randomUUID()}`;
+    config.provider[newKey] = buildClaudeProvider(apiKey);
+    console.log('   ➕ 新增AIXX(Claude)供应商');
+    updated++;
+  }
+
+  // --- AIXX-OpenAI 供应商 ---
+  const openaiKey = findManagedProvider(config, 'openai');
+  if (openaiKey) {
+    const existing = config.provider[openaiKey];
+    existing.options = existing.options || {};
+    existing.options.apiKey = apiKey;
+    existing.options.baseURL = AIXX_HOST + '/v1';
+    existing.options.apiKeyRequired = true;
+    existing.models = buildOpenaiModels();
+    existing.kind = 'openai';
+    existing[MANAGED_FLAG] = 'openai';
+    console.log('   ✏️  更新已有AIXX(国产/DeepSeek)供应商（key已刷新）');
+    updated++;
+  } else {
+    const newKey = `aixx-openai-${randomUUID()}`;
+    config.provider[newKey] = buildOpenaiProvider(apiKey);
+    console.log('   ➕ 新增AIXX(国产/DeepSeek)供应商');
+    updated++;
+  }
+
+  // 写回
+  try {
+    writeFileSync(zcodeConfigPath, JSON.stringify(config, null, 2));
+    return {
+      configured: true,
+      note: `已配置ZCode供应商，请重启ZCode并在模型选择里选AIXX`,
+      updated,
+    };
+  } catch (e) {
+    console.log(`   ⚠️  写入ZCode配置失败: ${e.message}`);
+    return { configured: false, note: `写入失败: ${e.message}` };
+  }
+}
+
+/**
+ * 写入 Claude Code 配置。
+ *
+ * 往 ~/.claude/settings.json 的 env 块写：
+ *   ANTHROPIC_BASE_URL / ANTHROPIC_AUTH_TOKEN
+ *
+ * 注意：这会覆盖用户已有的 Claude 配置（如果已经配过别的baseURL/token）。
+ * 所以要先检测是否有冲突，冲突时只更新key但保留提示。
+ *
+ * 返回 { configured: true/false, note: '...', overwritten: true/false }
+ */
+export function configureClaudeCode(apiKey) {
+  const claudeSettingsPath = join(homedir(), '.claude', 'settings.json');
+
+  if (!existsSync(claudeSettingsPath)) {
+    return { configured: false, note: '未检测到Claude Code（~/.claude/settings.json不存在），跳过' };
+  }
+
+  const settings = readJsonSafe(claudeSettingsPath);
+  if (!settings || typeof settings !== 'object') {
+    console.log('   ⚠️  Claude settings.json 解析失败，跳过Claude Code配置');
+    return { configured: false, note: 'Claude settings.json 解析失败' };
+  }
+
+  // 备份
+  const backup = backupFile(claudeSettingsPath);
+  if (backup === false) {
+    // 铁律1：备份失败，绝不写入（避免破坏用户现有配置）
+    console.log('   ⚠️  配置备份失败，请手动备份后再试（已跳过Claude Code配置）');
+    return { configured: false, note: '配置备份失败，请手动备份后再试' };
+  }
+  if (backup) {
+    console.log(`   📦 已备份Claude Code配置: ${backup}`);
+  }
+
+  // 检测是否已有冲突配置（不是AIXX的baseURL）
+  let overwritten = false;
+  const oldBase = settings?.env?.ANTHROPIC_BASE_URL;
+  if (oldBase && oldBase !== AIXX_HOST) {
+    overwritten = true;
+  }
+
+  // 幂等 + 写入
+  settings.env = settings.env || {};
+  settings.env.ANTHROPIC_BASE_URL = AIXX_HOST;
+  settings.env.ANTHROPIC_AUTH_TOKEN = apiKey;
+
+  try {
+    writeFileSync(claudeSettingsPath, JSON.stringify(settings, null, 2));
+    return {
+      configured: true,
+      note: overwritten
+        ? '已配置Claude Code（覆盖了你原有的Claude供应商，已备份）'
+        : '已配置Claude Code',
+      overwritten,
+    };
+  } catch (e) {
+    console.log(`   ⚠️  写入Claude Code配置失败: ${e.message}`);
+    return { configured: false, note: `写入失败: ${e.message}` };
+  }
+}
+
+/**
+ * 入口：自动检测并配置所有能找到的agent。
+ * 由 install.js 在拿到apiKey后调用。
+ *
+ * 返回 { zcode, claude } 两个结果对象。
+ */
+export function configureAgents(apiKey) {
+  console.log('\n🔌 配置本地agent（零配置核心）...');
+
+  const zcode = configureZCode(apiKey);
+  if (zcode.configured) {
+    console.log(`   ✅ ZCode: ${zcode.note}`);
+  } else {
+    console.log(`   ⏭️  ZCode: ${zcode.note}`);
+  }
+
+  const claude = configureClaudeCode(apiKey);
+  if (claude.configured) {
+    console.log(`   ✅ Claude Code: ${claude.note}`);
+    if (claude.overwritten) {
+      console.log('   ⚠️  注意：你原有的Claude供应商被AIXX覆盖了。如需恢复，去备份目录找原配置。');
+    }
+  } else {
+    console.log(`   ⏭️  Claude Code: ${claude.note}`);
+  }
+
+  return { zcode, claude };
+}