ai-account-switch 1.11.0 → 1.12.0

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;

package/src/config/project-config.js

@@ -0,0 +1,255 @@
+/**
+ * Project Configuration Manager
+ * Handles project-specific configuration operations
+ */
+const fs = require('fs');
+const path = require('path');
+
+class ProjectConfigManager {
+  constructor(globalConfig) {
+    this.globalConfig = globalConfig;
+    this.projectConfigFilename = '.ais-project-config';
+  }
+
+  /**
+   * Get project configuration file path
+   */
+  getProjectConfigPath(projectRoot = process.cwd()) {
+    return path.join(projectRoot, this.projectConfigFilename);
+  }
+
+  /**
+   * Read project configuration
+   */
+  read(projectRoot = process.cwd()) {
+    const projectConfigFile = this.getProjectConfigPath(projectRoot);
+    if (!fs.existsSync(projectConfigFile)) {
+      return null;
+    }
+
+    try {
+      const data = fs.readFileSync(projectConfigFile, 'utf8');
+      return JSON.parse(data);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  /**
+   * Save project configuration
+   */
+  save(projectConfig, projectRoot = process.cwd()) {
+    const projectConfigFile = this.getProjectConfigPath(projectRoot);
+    fs.writeFileSync(projectConfigFile, JSON.stringify(projectConfig, null, 2), 'utf8');
+  }
+
+  /**
+   * Set current project's active account
+   */
+  setAccount(accountName, projectRoot = process.cwd()) {
+    const projectConfigFile = this.getProjectConfigPath(projectRoot);
+
+    // Read existing project config to preserve enabledMcpServers
+    let existingConfig = {};
+    if (fs.existsSync(projectConfigFile)) {
+      try {
+        const data = fs.readFileSync(projectConfigFile, 'utf8');
+        existingConfig = JSON.parse(data);
+      } catch (error) {
+        // If parsing fails, start fresh
+      }
+    }
+
+    const projectConfig = {
+      activeAccount: accountName,
+      projectPath: projectRoot,
+      setAt: new Date().toISOString(),
+      enabledMcpServers: existingConfig.enabledMcpServers || []
+    };
+
+    this.save(projectConfig, projectRoot);
+    return true;
+  }
+
+  /**
+   * Get current project's active account with full details
+   */
+  getAccount(projectRoot = process.cwd()) {
+    try {
+      const projectConfig = this.read(projectRoot);
+      if (!projectConfig) {
+        return null;
+      }
+
+      // Get the full account details from global config
+      const account = this.globalConfig.getAccount(projectConfig.activeAccount);
+      if (account) {
+        return {
+          name: projectConfig.activeAccount,
+          ...account,
+          setAt: projectConfig.setAt,
+          projectRoot: projectRoot
+        };
+      }
+      return null;
+    } catch (error) {
+      return null;
+    }
+  }
+
+  // MCP Server methods for project
+
+  /**
+   * Get project's enabled MCP servers
+   */
+  getMcpServers(projectRoot = process.cwd()) {
+    try {
+      const projectConfig = this.read(projectRoot);
+      if (!projectConfig) {
+        return [];
+      }
+      return projectConfig.enabledMcpServers || [];
+    } catch (error) {
+      return [];
+    }
+  }
+
+  /**
+   * Check if MCP server is enabled in current project
+   */
+  isMcpServerEnabled(serverName, projectRoot = process.cwd()) {
+    try {
+      const projectConfig = this.read(projectRoot);
+      if (!projectConfig) {
+        return false;
+      }
+
+      return projectConfig.enabledMcpServers &&
+             projectConfig.enabledMcpServers.includes(serverName);
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Enable MCP server for current project with scope
+   */
+  enableMcpServer(serverName, scope, projectRoot = process.cwd()) {
+    const projectConfigFile = this.getProjectConfigPath(projectRoot);
+    if (!fs.existsSync(projectConfigFile)) {
+      throw new Error('Project not configured. Run "ais use" first.');
+    }
+
+    const data = fs.readFileSync(projectConfigFile, 'utf8');
+    const projectConfig = JSON.parse(data);
+
+    // Update server scope in global config
+    const globalConfig = this.globalConfig.read();
+    if (globalConfig.mcpServers[serverName]) {
+      globalConfig.mcpServers[serverName].scope = scope;
+      this.globalConfig.save(globalConfig);
+    }
+
+    // Handle different scopes
+    const { MCP_SCOPES } = require('../constants');
+    if (scope === MCP_SCOPES.LOCAL) {
+      if (!projectConfig.enabledMcpServers) projectConfig.enabledMcpServers = [];
+      if (!projectConfig.enabledMcpServers.includes(serverName)) {
+        projectConfig.enabledMcpServers.push(serverName);
+      }
+    } else if (scope === MCP_SCOPES.PROJECT) {
+      if (!projectConfig.projectMcpServers) projectConfig.projectMcpServers = {};
+      const server = this.globalConfig.getMcpServer(serverName);
+      projectConfig.projectMcpServers[serverName] = {
+        ...server,
+        scope: MCP_SCOPES.PROJECT
+      };
+
+      if (!projectConfig.enabledMcpServers) projectConfig.enabledMcpServers = [];
+      if (!projectConfig.enabledMcpServers.includes(serverName)) {
+        projectConfig.enabledMcpServers.push(serverName);
+      }
+    } else if (scope === MCP_SCOPES.USER) {
+      if (!projectConfig.enabledMcpServers) projectConfig.enabledMcpServers = [];
+      if (!projectConfig.enabledMcpServers.includes(serverName)) {
+        projectConfig.enabledMcpServers.push(serverName);
+      }
+    }
+
+    this.save(projectConfig, projectRoot);
+    return true;
+  }
+
+  /**
+   * Disable MCP server for current project
+   */
+  disableMcpServer(serverName, projectRoot = process.cwd()) {
+    const projectConfig = this.read(projectRoot);
+    if (!projectConfig) {
+      throw new Error('Project not configured. Run "ais use" first.');
+    }
+
+    if (!projectConfig.enabledMcpServers) return false;
+
+    const index = projectConfig.enabledMcpServers.indexOf(serverName);
+    if (index > -1) {
+      projectConfig.enabledMcpServers.splice(index, 1);
+      this.save(projectConfig, projectRoot);
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Remove MCP server from current project's enabled list
+   */
+  removeMcpServer(serverName, projectRoot = process.cwd()) {
+    try {
+      const projectConfig = this.read(projectRoot);
+      if (!projectConfig) {
+        return false;
+      }
+
+      if (!projectConfig.enabledMcpServers) return false;
+
+      const index = projectConfig.enabledMcpServers.indexOf(serverName);
+      if (index > -1) {
+        projectConfig.enabledMcpServers.splice(index, 1);
+        this.save(projectConfig, projectRoot);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      return false;
+    }
+  }
+
+  /**
+   * Get all available MCP servers including project-scoped ones
+   */
+  getAllMcpServers(projectRoot = process.cwd()) {
+    const globalServers = this.globalConfig.getAllMcpServers();
+
+    try {
+      const projectConfig = this.read(projectRoot);
+      if (!projectConfig) {
+        return globalServers;
+      }
+
+      // Merge global and project servers
+      const allServers = { ...globalServers };
+
+      if (projectConfig.projectMcpServers) {
+        Object.entries(projectConfig.projectMcpServers).forEach(([name, server]) => {
+          allServers[name] = server;
+        });
+      }
+
+      return allServers;
+    } catch (error) {
+      return globalServers;
+    }
+  }
+}
+
+module.exports = ProjectConfigManager;