ubuntu_website_deployment

Instructions

Implementation Reference

• src/ubuntu-website-tools.ts:256-418 (handler)

  Main handler function for the 'ubuntu_website_deployment' tool. Handles website deployment, backup, and restore operations on Ubuntu servers via SSH. Supports deploying files/directories, creating tar.gz backups, and restoring from backups.

  async ubuntu_website_deployment(params) {
    const { 
      connectionId, 
      action, 
      localPath, 
      remotePath = '/var/www/html', 
      backupPath = '/var/backups/websites',
      createBackup = true,
      sudo = true 
    } = params;
    
    try {
      const conn = getConnection(connectionMap, connectionId);
      const sudoPrefix = sudo ? 'sudo ' : '';
      
      // Validate action
      const validActions = ['deploy', 'backup', 'restore'];
      if (!validActions.includes(action)) {
        throw new Error(`Invalid action: ${action}. Valid actions are: ${validActions.join(', ')}`);
      }
      
      // Create backup directory if it doesn't exist
      await executeSSHCommand(conn, `${sudoPrefix}mkdir -p ${backupPath}`);
      
      // Generate timestamp for backups
      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
      const backupFileName = `website-backup-${timestamp}.tar.gz`;
      const fullBackupPath = `${backupPath}/${backupFileName}`;
      
      let output = '';
      
      if (action === 'deploy') {
        // Check if localPath is provided
        if (!localPath) {
          throw new Error('Local path is required for deployment');
        }
        
        // Create backup before deployment if requested
        if (createBackup) {
          const backupCmd = `${sudoPrefix}tar -czf ${fullBackupPath} -C ${path.dirname(remotePath)} ${path.basename(remotePath)}`;
          const backupResult = await executeSSHCommand(conn, backupCmd);
          output += `Backup created: ${fullBackupPath}\n`;
          
          if (backupResult.code !== 0) {
            output += `Warning: Backup may have issues: ${backupResult.stderr}\n`;
          }
        }
        
        // Expand tilde if present in the local path
        const expandedLocalPath = localPath.replace(/^~/, os.homedir());
        
        // Check if localPath exists
        if (!fs.existsSync(expandedLocalPath)) {
          throw new Error(`Local path does not exist: ${expandedLocalPath}`);
        }
        
        // Get SFTP client for file upload
        const sftp: any = await new Promise((resolve, reject) => {
          conn.sftp((err: Error | undefined, sftp: any) => {
            if (err) {
              reject(new Error(`Failed to initialize SFTP: ${err.message}`));
            } else {
              resolve(sftp);
            }
          });
        });
        
        // Check if localPath is a directory or a single file
        const stats = fs.statSync(expandedLocalPath);
        
        if (stats.isDirectory()) {
          // For directories, we need to zip, upload, and extract
          const tempZipFile = path.join(os.tmpdir(), `deployment-${timestamp}.zip`);
          
          // Create a zip of the directory
          await executeSSHCommand(conn, `zip -r ${tempZipFile} ${expandedLocalPath}`);
          
          // Upload the zip file
          await new Promise((resolve, reject) => {
            sftp.fastPut(tempZipFile, `/tmp/deployment-${timestamp}.zip`, (err: Error | undefined) => {
              if (err) {
                reject(new Error(`Failed to upload deployment file: ${err.message}`));
              } else {
                resolve(true);
              }
            });
          });
          
          // Extract the zip file to the destination
          await executeSSHCommand(conn, `${sudoPrefix}unzip -o /tmp/deployment-${timestamp}.zip -d ${remotePath}`);
          
          // Clean up temporary files
          fs.unlinkSync(tempZipFile);
          await executeSSHCommand(conn, `${sudoPrefix}rm /tmp/deployment-${timestamp}.zip`);
          
          output += `Deployed directory ${expandedLocalPath} to ${remotePath}`;
        } else {
          // For a single file, upload directly
          const remoteFilePath = path.join(remotePath, path.basename(expandedLocalPath));
          
          await new Promise((resolve, reject) => {
            sftp.fastPut(expandedLocalPath, remoteFilePath, (err: Error | undefined) => {
              if (err) {
                reject(new Error(`Failed to upload file: ${err.message}`));
              } else {
                resolve(true);
              }
            });
          });
          
          // Fix permissions
          await executeSSHCommand(conn, `${sudoPrefix}chown www-data:www-data ${remoteFilePath}`);
          
          output += `Deployed file ${expandedLocalPath} to ${remoteFilePath}`;
        }
      } else if (action === 'backup') {
        // Create backup
        const backupCmd = `${sudoPrefix}tar -czf ${fullBackupPath} -C ${path.dirname(remotePath)} ${path.basename(remotePath)}`;
        const backupResult = await executeSSHCommand(conn, backupCmd);
        
        if (backupResult.code === 0) {
          output += `Backup created: ${fullBackupPath}`;
        } else {
          throw new Error(`Backup failed: ${backupResult.stderr}`);
        }
      } else if (action === 'restore') {
        // List available backups
        const listResult = await executeSSHCommand(conn, `ls -la ${backupPath}`);
        
        // Return list if no specific backup file was provided
        if (!localPath) {
          return {
            content: [{
              type: 'text',
              text: `Available backups:\n\n${listResult.stdout}`
            }]
          };
        }
        
        // Restore from specific backup
        const restoreCmd = `${sudoPrefix}tar -xzf ${localPath} -C ${path.dirname(remotePath)}`;
        const restoreResult = await executeSSHCommand(conn, restoreCmd);
        
        if (restoreResult.code === 0) {
          output += `Restored from backup: ${localPath} to ${remotePath}`;
        } else {
          throw new Error(`Restore failed: ${restoreResult.stderr}`);
        }
      }
      
      return {
        content: [{
          type: 'text',
          text: output
        }]
      };
    } catch (error: any) {
      return {
        content: [{ type: 'text', text: `Website deployment error: ${error.message}` }],
        isError: true
      };
    }
  },

• src/ubuntu-website-tools.ts:600-635 (schema)

  Input schema definition for the ubuntu_website_deployment tool, specifying parameters and validation rules.

  ubuntu_website_deployment: {
    description: 'Deploy website files and create backups on Ubuntu',
    inputSchema: {
      type: 'object',
      properties: {
        connectionId: {
          type: 'string',
          description: 'ID of an active SSH connection'
        },
        action: {
          type: 'string',
          description: 'Action to perform (deploy, backup, restore)'
        },
        localPath: {
          type: 'string',
          description: 'Local path to the website files for deployment'
        },
        remotePath: {
          type: 'string',
          description: 'Remote path where the website is located (default: /var/www/html)'
        },
        backupPath: {
          type: 'string',
          description: 'Path to store backups (default: /var/backups/websites)'
        },
        createBackup: {
          type: 'boolean',
          description: 'Whether to create a backup before deployment (default: true)'
        },
        sudo: {
          type: 'boolean',
          description: 'Whether to run the command with sudo (default: true)'
        }
      },
      required: ['connectionId', 'action']
    }

• src/index.ts:270-299 (registration)

  Registration and dispatch logic in the main CallToolRequestSchema handler. Checks if tool name starts with 'ubuntu_' and invokes the corresponding handler from ubuntuToolHandlers.

  this.server.setRequestHandler(CallToolRequestSchema, async (request: any) => {
    const toolName = request.params.name;
    
    // Handle core SSH tools directly
    if (toolName.startsWith('ssh_')) {
      switch (toolName) {
        case 'ssh_connect':
          return this.handleSSHConnect(request.params.arguments);
        case 'ssh_exec':
          return this.handleSSHExec(request.params.arguments);
        case 'ssh_upload_file':
          return this.handleSSHUpload(request.params.arguments);
        case 'ssh_download_file':
          return this.handleSSHDownload(request.params.arguments);
        case 'ssh_list_files':
          return this.handleSSHListFiles(request.params.arguments);
        case 'ssh_disconnect':
          return this.handleSSHDisconnect(request.params.arguments);
        default:
          throw new Error(`Unknown SSH tool: ${toolName}`);
      }
    }
    
    // Handle Ubuntu tools directly
    if (toolName.startsWith('ubuntu_') && ubuntuToolHandlers[toolName]) {
      return ubuntuToolHandlers[toolName](request.params.arguments);
    }
    
    throw new Error(`Unknown tool: ${toolName}`);
  });

• src/index.ts:179-179 (registration)

  Call to addUbuntuTools which overrides ListToolsRequestSchema to include the ubuntu_website_deployment tool in the tool list.

  addUbuntuTools(this.server, this.connections);

• src/ubuntu-website-tools.ts:18-58 (helper)

  Utility function used by ubuntu_website_deployment to execute SSH commands with timeout and error handling.

  async function executeSSHCommand(conn: Client, command: string, timeout = 60000): Promise<{
    code: number;
    signal: string;
    stdout: string;
    stderr: string;
  }> {
    return new Promise((resolve, reject) => {
      // Set up timeout
      const timeoutId = setTimeout(() => {
        reject(new Error(`Command execution timed out after ${timeout}ms`));
      }, timeout);
      
      conn.exec(command, {}, (err: Error | undefined, stream: any) => {
        if (err) {
          clearTimeout(timeoutId);
          return reject(new Error(`Failed to execute command: ${err.message}`));
        }
        
        let stdout = '';
        let stderr = '';
        
        stream.on('close', (code: number, signal: string) => {
          clearTimeout(timeoutId);
          resolve({
            code,
            signal,
            stdout: stdout.trim(),
            stderr: stderr.trim()
          });
        });
        
        stream.on('data', (data: Buffer) => {
          stdout += data.toString();
        });
        
        stream.stderr.on('data', (data: Buffer) => {
          stderr += data.toString();
        });
      });
    });
  }