ai-account-switch 1.9.0 → 1.12.0

package/src/commands/helpers.js

@@ -9,6 +9,37 @@ function maskApiKey(apiKey) {
   return `${apiKey.substring(0, 4)}****${apiKey.substring(apiKey.length - 4)}`;
 }
 
+/**
+ * Mask sensitive value for display
+ * Shows first 2 chars + fixed 6 stars + last 2 chars for sensitive variables
+ * 用于显示敏感环境变量值，前2字符+固定6星号+后2字符
+ * @param {string} key - Variable name to check if sensitive
+ * @param {string} value - Value to mask
+ * @returns {string} Masked value or original value if not sensitive
+ */
+function maskEnvValue(key, value) {
+  if (!key || !value) return value;
+
+  // Check if variable name contains sensitive keywords
+  const isSensitive = key.includes('KEY') || key.includes('TOKEN') || key.includes('SECRET') || key.includes('PASSWORD');
+
+  if (!isSensitive) {
+    return value;
+  }
+
+  // For sensitive values, show first 2 + fixed 6 stars + last 2
+  const strValue = String(value);
+  if (strValue.length <= 4) {
+    // If value is too short, show all stars
+    return '*'.repeat(strValue.length);
+  }
+
+  const firstTwo = strValue.substring(0, 2);
+  const lastTwo = strValue.substring(strValue.length - 2);
+
+  return firstTwo + '******' + lastTwo;
+}
+
 /**
  * Validate account by testing API key
  * 验证账号的 API key 是否有效
@@ -31,5 +62,6 @@ async function validateAccount(apiKey, apiUrl) {
 
 module.exports = {
   maskApiKey,
+  maskEnvValue,
   validateAccount
 };

package/src/commands/index.js

@@ -42,6 +42,17 @@ const {
   testMcpServer
 } = require('./mcp');
 
+const {
+  listEnv,
+  addEnv,
+  setEnv,
+  removeEnv,
+  unsetEnv,
+  showEnv,
+  clearEnv,
+  editEnv
+} = require('./env');
+
 module.exports = {
   // Account management commands
   addAccount,
@@ -74,5 +85,15 @@ module.exports = {
   disableMcpServer,
   showEnabledMcpServers,
   syncMcpConfig,
-  testMcpServer
+  testMcpServer,
+
+  // Environment variable management commands
+  listEnv,
+  addEnv,
+  setEnv,
+  removeEnv,
+  unsetEnv,
+  showEnv,
+  clearEnv,
+  editEnv
 };

package/src/commands/mcp.js

@@ -10,6 +10,8 @@ const config = new ConfigManager();
  */
 async function addMcpServer(name) {
   try {
+    const { MCP_SCOPES, DEFAULT_MCP_SCOPE } = require('../config');
+
     if (!name) {
       const { serverName } = await inquirer.prompt([{
         type: 'input',
@@ -79,8 +81,22 @@ async function addMcpServer(name) {
     const { description } = await inquirer.prompt([{ type: 'input', name: 'description', message: 'Enter description:', default: '' }]);
     serverData.description = description;
 
+    // Ask for default scope
+    const { scope } = await inquirer.prompt([{
+      type: 'list',
+      name: 'scope',
+      message: 'Select default scope (默认作用范围):',
+      choices: [
+        { name: 'local - Only current project (仅当前项目)', value: MCP_SCOPES.LOCAL },
+        { name: 'project - Share with project members (与项目成员共享)', value: MCP_SCOPES.PROJECT },
+        { name: 'user - All projects for current user (当前用户所有项目)', value: MCP_SCOPES.USER }
+      ],
+      default: DEFAULT_MCP_SCOPE
+    }]);
+    serverData.scope = scope;
+
     config.addMcpServer(name, serverData);
-    console.log(chalk.green(`✓ MCP server '${name}' added successfully!`));
+    console.log(chalk.green(`✓ MCP server '${name}' added successfully with scope: ${scope}!`));
 
     // Auto-test the server
     console.log(chalk.cyan('\nTesting server availability...'));
@@ -101,7 +117,7 @@ async function addMcpServer(name) {
  */
 async function listMcpServers() {
   try {
-    const servers = config.getAllMcpServers();
+    const servers = config.getAllAvailableMcpServers();
     const projectServers = config.getEnabledMcpServers();
 
     if (Object.keys(servers).length === 0) {
@@ -110,12 +126,16 @@ async function listMcpServers() {
     }
 
     console.log(chalk.bold.cyan('\n📋 Available MCP servers:\n'));
-    console.log('  Name         Type    Active   Description');
-    console.log('  ─────────────────────────────────────────────────────────────');
-
-    Object.values(servers).forEach(server => {
-      const isActive = projectServers.includes(server.name) ? chalk.green('✓') : ' ';
-      console.log(`  ${server.name.padEnd(12)} ${server.type.padEnd(7)} ${isActive}        ${server.description || ''}`);
+    console.log('  Name         Type    Active   Scope      Description');
+    console.log('  ───────────────────────────────────────────────────────────────────────');
+
+    Object.entries(servers).forEach(([key, server]) => {
+      const name = server.name || key;
+      const type = server.type || 'unknown';
+      const isActive = projectServers.includes(name) ? chalk.green('✓') : ' ';
+      const scope = server.scope || 'local';
+      const scopeDisplay = scope.padEnd(10);
+      console.log(`  ${name.padEnd(12)} ${type.padEnd(7)} ${isActive}        ${scopeDisplay} ${server.description || ''}`);
     });
 
     const activeCount = projectServers.length;
@@ -133,7 +153,7 @@ async function listMcpServers() {
 async function showMcpServer(name) {
   try {
     if (!name) {
-      const servers = config.getAllMcpServers();
+      const servers = config.getAllAvailableMcpServers();
       if (Object.keys(servers).length === 0) {
         console.log(chalk.yellow('No MCP servers configured'));
         return;
@@ -155,6 +175,7 @@ async function showMcpServer(name) {
 
     console.log(chalk.bold.cyan(`\n📋 MCP Server: ${name}\n`));
     console.log(chalk.bold('Type:'), server.type);
+    console.log(chalk.bold('Scope:'), server.scope || 'local');
     console.log(chalk.bold('Description:'), server.description || 'N/A');
 
     if (server.command) console.log(chalk.bold('Command:'), server.command);
@@ -322,8 +343,17 @@ async function removeMcpServer(name) {
 /**
  * Enable MCP server for current project
  */
-async function enableMcpServer(name) {
+async function enableMcpServer(name, options = {}) {
   try {
+    const { MCP_SCOPES, DEFAULT_MCP_SCOPE } = require('../config');
+    let scope = options.scope || DEFAULT_MCP_SCOPE;
+
+    // Validate scope
+    if (!Object.values(MCP_SCOPES).includes(scope)) {
+      console.log(chalk.red(`✗ Invalid scope '${scope}'. Valid scopes: local, project, user`));
+      return;
+    }
+
     if (!name) {
       const servers = config.getAllMcpServers();
       const enabled = config.getEnabledMcpServers();
@@ -341,12 +371,38 @@ async function enableMcpServer(name) {
         choices: available
       }]);
       name = serverName;
+
+      // Ask for scope if not provided
+      if (!options.scope) {
+        const { selectedScope } = await inquirer.prompt([{
+          type: 'list',
+          name: 'selectedScope',
+          message: 'Select scope (作用范围):',
+          choices: [
+            { name: 'local - Only current project (仅当前项目)', value: MCP_SCOPES.LOCAL },
+            { name: 'project - Share with project members via .mcp.json (通过 .mcp.json 与项目成员共享)', value: MCP_SCOPES.PROJECT },
+            { name: 'user - All projects for current user (当前用户所有项目)', value: MCP_SCOPES.USER }
+          ],
+          default: DEFAULT_MCP_SCOPE
+        }]);
+        scope = selectedScope;
+      }
     }
 
-    if (config.enableProjectMcpServer(name)) {
+    if (config.enableProjectMcpServer(name, scope)) {
       config.syncMcpConfig();
-      console.log(chalk.green(`✓ MCP server '${name}' activated for current project`));
+      console.log(chalk.green(`✓ MCP server '${name}' activated for current project with scope: ${scope}`));
       console.log(chalk.green('✓ Claude configuration updated'));
+
+      // Show scope-specific information
+      if (scope === MCP_SCOPES.LOCAL) {
+        console.log(chalk.cyan('  Scope: local - Only available in this project'));
+      } else if (scope === MCP_SCOPES.PROJECT) {
+        console.log(chalk.cyan('  Scope: project - Configuration stored in project, shared with team members'));
+        console.log(chalk.gray('  Note: Make sure to commit .ais-project-config to share with your team'));
+      } else if (scope === MCP_SCOPES.USER) {
+        console.log(chalk.cyan('  Scope: user - Available to all your projects'));
+      }
     } else {
       console.log(chalk.red(`✗ MCP server '${name}' not found`));
     }
@@ -408,7 +464,9 @@ async function showEnabledMcpServers() {
     enabled.forEach(name => {
       const server = servers[name];
       if (server) {
-        console.log(`  ${server.name.padEnd(12)} ${server.type.padEnd(7)} ${server.description || ''}`);
+        const serverName = server.name || name;
+        const type = server.type || 'unknown';
+        console.log(`  ${String(serverName).padEnd(12)} ${String(type).padEnd(7)} ${server.description || ''}`);
       }
     });
 

package/src/config/global-config.js

@@ -0,0 +1,266 @@
+/**
+ * Global Configuration Manager
+ * Handles global configuration operations (accounts, MCP servers in home directory)
+ */
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { CONFIG_FILES } = require('../constants');
+
+class GlobalConfigManager {
+  constructor() {
+    this.globalConfigDir = path.join(os.homedir(), CONFIG_FILES.GLOBAL_DIR);
+    this.globalConfigFile = path.join(this.globalConfigDir, CONFIG_FILES.GLOBAL_CONFIG);
+    this.projectConfigFilename = '.ais-project-config';
+    this.ensureConfigExists();
+  }
+
+  /**
+   * Ensure configuration directories and files exist
+   */
+  ensureConfigExists() {
+    if (!fs.existsSync(this.globalConfigDir)) {
+      fs.mkdirSync(this.globalConfigDir, { recursive: true });
+    }
+
+    if (!fs.existsSync(this.globalConfigFile)) {
+      this.save({ accounts: {}, mcpServers: {}, nextAccountId: 1 });
+    }
+
+    this.migrateAccountIds();
+  }
+
+  /**
+   * Find project root by searching upwards for .ais-project-config file
+   */
+  findProjectRoot(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    const rootDir = path.parse(currentDir).root;
+
+    while (currentDir !== rootDir) {
+      const configPath = path.join(currentDir, this.projectConfigFilename);
+      if (fs.existsSync(configPath)) {
+        return currentDir;
+      }
+      currentDir = path.dirname(currentDir);
+    }
+
+    const configPath = path.join(rootDir, this.projectConfigFilename);
+    if (fs.existsSync(configPath)) {
+      return rootDir;
+    }
+
+    return null;
+  }
+
+  /**
+   * Read global configuration
+   */
+  read() {
+    try {
+      const data = fs.readFileSync(this.globalConfigFile, 'utf8');
+      const config = JSON.parse(data);
+      if (!config.nextAccountId) {
+        config.nextAccountId = 1;
+      }
+      return config;
+    } catch (error) {
+      return { accounts: {}, mcpServers: {}, nextAccountId: 1 };
+    }
+  }
+
+  /**
+   * Save global configuration
+   */
+  save(config) {
+    fs.writeFileSync(this.globalConfigFile, JSON.stringify(config, null, 2), 'utf8');
+  }
+
+  /**
+   * Migrate existing accounts to have IDs
+   */
+  migrateAccountIds() {
+    const config = this.read();
+    let needsSave = false;
+
+    if (!config.nextAccountId) {
+      config.nextAccountId = 1;
+      needsSave = true;
+    }
+
+    Object.keys(config.accounts || {}).forEach(name => {
+      if (!config.accounts[name].id) {
+        config.accounts[name].id = config.nextAccountId;
+        config.nextAccountId++;
+        needsSave = true;
+      }
+    });
+
+    if (needsSave) {
+      this.save(config);
+    }
+  }
+
+  /**
+   * Get account by ID or name
+   */
+  getAccountByIdOrName(idOrName) {
+    const accounts = this.getAllAccounts();
+
+    const id = parseInt(idOrName, 10);
+    if (!isNaN(id)) {
+      for (const [name, account] of Object.entries(accounts)) {
+        if (account.id === id) {
+          return { name, ...account };
+        }
+      }
+    }
+
+    const account = accounts[idOrName];
+    if (account) {
+      return { name: idOrName, ...account };
+    }
+
+    return null;
+  }
+
+  /**
+   * Add or update an account
+   */
+  addAccount(name, accountData) {
+    const config = this.read();
+
+    const isNewAccount = !config.accounts[name];
+    const accountId = isNewAccount ? config.nextAccountId : config.accounts[name].id;
+
+    config.accounts[name] = {
+      ...accountData,
+      id: accountId,
+      createdAt: config.accounts[name]?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+
+    if (isNewAccount) {
+      config.nextAccountId++;
+    }
+
+    this.save(config);
+    return true;
+  }
+
+  /**
+   * Get all accounts
+   */
+  getAllAccounts() {
+    const config = this.read();
+    return config.accounts || {};
+  }
+
+  /**
+   * Get a specific account
+   */
+  getAccount(name) {
+    const accounts = this.getAllAccounts();
+    return accounts[name] || null;
+  }
+
+  /**
+   * Remove an account
+   */
+  removeAccount(name) {
+    const config = this.read();
+    if (config.accounts[name]) {
+      delete config.accounts[name];
+      this.save(config);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if an account exists
+   */
+  accountExists(name) {
+    const accounts = this.getAllAccounts();
+    return !!accounts[name];
+  }
+
+  // MCP Server methods
+
+  /**
+   * Add or update an MCP server
+   */
+  addMcpServer(name, serverData) {
+    const config = this.read();
+    if (!config.mcpServers) config.mcpServers = {};
+
+    const { DEFAULT_MCP_SCOPE } = require('../constants');
+    if (!serverData.scope) {
+      serverData.scope = DEFAULT_MCP_SCOPE;
+    }
+
+    config.mcpServers[name] = {
+      ...serverData,
+      createdAt: config.mcpServers[name]?.createdAt || new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+    this.save(config);
+    return true;
+  }
+
+  /**
+   * Get all MCP servers
+   */
+  getAllMcpServers() {
+    const config = this.read();
+    return config.mcpServers || {};
+  }
+
+  /**
+   * Get a specific MCP server
+   */
+  getMcpServer(name) {
+    const servers = this.getAllMcpServers();
+    return servers[name] || null;
+  }
+
+  /**
+   * Update an MCP server
+   */
+  updateMcpServer(name, serverData) {
+    const config = this.read();
+    if (!config.mcpServers || !config.mcpServers[name]) return false;
+    config.mcpServers[name] = {
+      ...serverData,
+      createdAt: config.mcpServers[name].createdAt,
+      updatedAt: new Date().toISOString()
+    };
+    this.save(config);
+    return true;
+  }
+
+  /**
+   * Remove an MCP server
+   */
+  removeMcpServer(name) {
+    const config = this.read();
+    if (config.mcpServers && config.mcpServers[name]) {
+      delete config.mcpServers[name];
+      this.save(config);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Get configuration file paths
+   */
+  getConfigPaths() {
+    return {
+      global: this.globalConfigFile,
+      globalDir: this.globalConfigDir
+    };
+  }
+}
+
+module.exports = GlobalConfigManager;