stigmergy 1.2.13 → 1.3.2-beta.0

package/src/core/coordination/nodejs/generators/index.js

@@ -0,0 +1,12 @@
+// Generators Module Index
+// 导出所有生成器模块
+
+const ResumeSessionGenerator = require('./ResumeSessionGenerator');
+const SkillsIntegrationGenerator = require('./SkillsIntegrationGenerator');
+const CLIAdapterGenerator = require('./CLIAdapterGenerator');
+
+module.exports = {
+  ResumeSessionGenerator,
+  SkillsIntegrationGenerator,
+  CLIAdapterGenerator
+};

package/src/core/enhanced_cli_installer.js

@@ -219,34 +219,67 @@ class EnhancedCLIInstaller {
    * Setup Unix elevated context
    */
   async setupUnixElevatedContext() {
-    this.log('info', 'Unix: Checking sudo availability...');
+    this.log('info', 'Unix: Checking privilege escalation methods...');
+
+    // List of privilege escalation tools to check (in order of preference)
+    const privilegeEscalationTools = [
+      { name: 'sudo', testCmd: 'sudo', testArgs: ['-n', 'true'] },
+      { name: 'doas', testCmd: 'doas', testArgs: ['-n', 'true'] },
+      { name: 'run0', testCmd: 'run0', testArgs: ['-n', 'true'] },
+      { name: 'pkexec', testCmd: 'pkexec', testArgs: ['--help'] },
+    ];
 
-    try {
-      const result = spawnSync('sudo', ['-n', 'true'], {
-        stdio: 'pipe',
-        timeout: 5000
-      });
+    let availableTool = null;
+    let requiresPassword = false;
 
-      // If sudo is available and configured for passwordless use
-      if (result.status === 0) {
-        return {
-          success: true,
-          platform: 'unix',
-          sudo: 'passwordless'
-        };
-      } else {
-        return {
-          success: true,
-          platform: 'unix',
-          sudo: 'password_required',
-          note: 'Will prompt for password per installation'
-        };
+    for (const tool of privilegeEscalationTools) {
+      try {
+        const result = spawnSync(tool.testCmd, tool.testArgs, {
+          stdio: 'pipe',
+          timeout: 5000
+        });
+
+        // Tool exists
+        if (result.status === 0 || (result.status !== null && result.error?.code !== 'ENOENT')) {
+          // Check if it's passwordless
+          if (result.status === 0) {
+            availableTool = tool.name;
+            requiresPassword = false;
+            this.log('success', `Found ${tool.name} (passwordless)`);
+            break;
+          } else if (result.error?.code !== 'ENOENT') {
+            // Tool exists but requires password
+            availableTool = tool.name;
+            requiresPassword = true;
+            this.log('info', `Found ${tool.name} (requires password)`);
+            break;
+          }
+        }
+      } catch (error) {
+        // Tool doesn't exist, continue to next
+        continue;
       }
-    } catch (error) {
+    }
+
+    if (availableTool) {
       return {
-        success: false,
+        success: true,
+        platform: 'unix',
+        privilegeTool: availableTool,
+        requiresPassword: requiresPassword,
+        note: requiresPassword ? 'Will prompt for password per installation' : 'Passwordless access available'
+      };
+    } else {
+      // No privilege escalation tool found
+      this.log('warn', 'No privilege escalation tool found (sudo, doas, run0, pkexec)');
+      this.log('info', 'Will attempt user-space installation without privileges');
+      return {
+        success: true,
         platform: 'unix',
-        error: error.message
+        privilegeTool: null,
+        requiresPassword: false,
+        userSpaceOnly: true,
+        note: 'Installation will be performed in user directory without privileges'
       };
     }
   }
@@ -255,6 +288,12 @@ class EnhancedCLIInstaller {
    * Install a tool using the pre-configured permission mode
    */
   async installTool(toolName, toolInfo, retryCount = 0) {
+    // Check if install command exists
+    if (!toolInfo.install) {
+      this.log('warn', `Tool ${toolName} has no install command, skipping...`);
+      return false;
+    }
+
     // Ensure permissions are configured first
     if (!this.permissionConfigured) {
       await this.setupPermissions();
@@ -338,6 +377,14 @@ class EnhancedCLIInstaller {
    */
   async executeStandardInstallation(toolInfo) {
     try {
+      // Check if install command exists
+      if (!toolInfo.install) {
+        return {
+          success: false,
+          error: `No install command specified for ${toolInfo.name || 'unknown tool'}`
+        };
+      }
+
       const [command, ...args] = toolInfo.install.split(' ');
 
       this.log('debug', `Executing: ${toolInfo.install}`);
@@ -438,10 +485,19 @@ class EnhancedCLIInstaller {
    * Execute Unix elevated installation
    */
   async executeUnixElevatedInstallation(toolInfo) {
-    const command = `sudo ${toolInfo.install}`;
+    const permissionSetup = await this.setupPermissions();
+
+    // If no privilege escalation tool is available, use user-space installation
+    if (permissionSetup.userSpaceOnly) {
+      return await this.executeUserSpaceInstallation(toolInfo);
+    }
+
+    // Use the detected privilege escalation tool
+    const privilegeTool = permissionSetup.privilegeTool || 'sudo';
+    const command = `${privilegeTool} ${toolInfo.install}`;
 
     try {
-      this.log('info', `Using sudo for elevated installation of: ${toolInfo.name}`);
+      this.log('info', `Using ${privilegeTool} for elevated installation of: ${toolInfo.name}`);
 
       const result = spawnSync('bash', ['-c', command], {
         stdio: this.options.verbose ? 'inherit' : 'pipe',
@@ -453,19 +509,137 @@ class EnhancedCLIInstaller {
         return { success: true, error: null };
       } else {
         const errorMessage = result.stderr || result.stdout || `Exit code ${result.status}`;
-        return { success: false, error: errorMessage };
+        // If privilege escalation failed, try user-space installation as fallback
+        this.log('warn', `Privilege escalation failed, trying user-space installation...`);
+        return await this.executeUserSpaceInstallation(toolInfo);
+      }
+    } catch (error) {
+      this.log('warn', `Privilege escalation error: ${error.message}, trying user-space installation...`);
+      return await this.executeUserSpaceInstallation(toolInfo);
+    }
+  }
+
+  /**
+   * Execute user-space installation (no privileges required)
+   */
+  async executeUserSpaceInstallation(toolInfo) {
+    try {
+      // Install to user directory using --prefix flag
+      const os = require('os');
+      const path = require('path');
+
+      // Get user's npm global directory
+      let userNpmDir = process.env.NPM_CONFIG_PREFIX ||
+                        path.join(os.homedir(), '.npm-global');
+
+      // Ensure directory exists
+      const fs = require('fs');
+      if (!fs.existsSync(userNpmDir)) {
+        fs.mkdirSync(userNpmDir, { recursive: true, mode: 0o755 });
+      }
+
+      // Extract package name from install command
+      // Format: "npm install -g @package/tool" or "npm install -g tool"
+      const installMatch = toolInfo.install.match(/npm\s+(?:install|upgrade)\s+(?:-g\s+)?(.+)/);
+      if (!installMatch) {
+        throw new Error('Cannot parse install command');
+      }
+
+      const packageName = installMatch[1].trim();
+
+      // Create user-space install command
+      const userCommand = `npm install -g --prefix "${userNpmDir}" ${packageName}`;
+
+      this.log('info', `Installing ${toolInfo.name} to user directory: ${userNpmDir}`);
+      this.log('info', `Command: ${userCommand}`);
+
+      // Set PATH to include user npm directory
+      const env = {
+        ...process.env,
+        PATH: `${path.join(userNpmDir, 'bin')}:${process.env.PATH}`
+      };
+
+      const result = spawnSync('bash', ['-c', userCommand], {
+        stdio: this.options.verbose ? 'inherit' : 'pipe',
+        timeout: this.options.timeout * 3, // Longer timeout for user-space install
+        encoding: 'utf8',
+        env: env
+      });
+
+      if (result.status === 0) {
+        this.log('success', `Successfully installed ${toolInfo.name} to user directory`);
+
+        // Provide PATH setup instructions
+        const binDir = path.join(userNpmDir, 'bin');
+        this.log('info', '⚠️  Make sure to add the bin directory to your PATH:');
+        this.log('info', `   export PATH="${binDir}:$PATH"`);
+
+        // Add to shell config files automatically
+        await this.addPathToShellConfig(binDir);
+
+        return { success: true, error: null, userSpace: true, binDir };
+      } else {
+        const errorMessage = result.stderr || result.stdout || `Exit code ${result.status}`;
+        return { success: false, error: `User-space installation failed: ${errorMessage}` };
       }
     } catch (error) {
       return { success: false, error: error.message };
     }
   }
 
+  /**
+   * Add PATH to shell configuration files
+   */
+  async addPathToShellConfig(binDir) {
+    const os = require('os');
+    const path = require('path');
+    const fs = require('fs/promises');
+
+    const shellConfigs = [
+      { file: path.join(os.homedir(), '.bashrc'), marker: '# Stigmergy CLI PATH' },
+      { file: path.join(os.homedir(), '.zshrc'), marker: '# Stigmergy CLI PATH' },
+      { file: path.join(os.homedir(), '.profile'), marker: '# Stigmergy CLI PATH' },
+    ];
+
+    const pathLine = `export PATH="${binDir}:$PATH"\n`;
+
+    for (const config of shellConfigs) {
+      try {
+        let content = '';
+        try {
+          content = await fs.readFile(config.file, 'utf8');
+        } catch (err) {
+          // File doesn't exist, will create it
+        }
+
+        // Check if PATH is already configured
+        if (content.includes(config.marker)) {
+          continue; // Already configured
+        }
+
+        // Append PATH configuration
+        await fs.appendFile(config.file, `\n${config.marker}\n${pathLine}`);
+        this.log('info', `Added PATH to ${path.basename(config.file)}`);
+      } catch (error) {
+        // Ignore errors for config files
+      }
+    }
+  }
+
   /**
    * Fallback installation method
    */
   async executeFallbackInstallation(toolInfo) {
     this.log('warn', 'Attempting fallback installation method...');
 
+    // Check if install command exists
+    if (!toolInfo.install) {
+      return {
+        success: false,
+        error: `No install command specified for ${toolInfo.name || 'unknown tool'}`
+      };
+    }
+
     // Try without some npm flags that might cause permission issues
     const [command, ...args] = toolInfo.install.split(' ');
     const fallbackArgs = args.filter(arg => !arg.startsWith('--'));
@@ -531,6 +705,12 @@ class EnhancedCLIInstaller {
       const toolInfo = toolInfos[toolName];
       if (!toolInfo) continue;
 
+      // Skip tools without install command (internal functions)
+      if (!toolInfo.install) {
+        this.log('debug', `Tool ${toolName} has no install command, skipping...`);
+        continue;
+      }
+
       this.results.installations[toolName] = {
         startTime: Date.now(),
         ...this.results.installations[toolName]
@@ -572,14 +752,24 @@ class EnhancedCLIInstaller {
     this.log('info', `Upgrading ${totalCount} CLI tools in ${this.permissionMode} mode...`);
 
     for (const toolName of toolNames) {
+      const originalInfo = toolInfos[toolName];
+      if (!originalInfo) {
+        this.log('warn', `Tool ${toolName} not found in toolInfos, skipping...`);
+        continue;
+      }
+
+      // Skip tools without install command (internal functions)
+      if (!originalInfo.install) {
+        this.log('debug', `Tool ${toolName} has no install command, skipping upgrade...`);
+        continue;
+      }
+
       const toolInfo = {
-        ...toolInfos[toolName],
+        ...originalInfo,
         install: `npm upgrade -g ${toolName}`,
-        name: `${toolInfo.name} (Upgrade)`
+        name: `${originalInfo.name} (Upgrade)`
       };
 
-      if (!toolInfo) continue;
-
       const success = await this.installTool(toolName, toolInfo);
       if (success) {
         successCount++;