mbai 0.1.0

package/bin/mbai.js

@@ -0,0 +1,335 @@
+#!/usr/bin/env node
+
+const { execSync, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const os = require('os');
+const crypto = require('crypto');
+
+const BINARY_BASE_URL = 'https://managedbyai.dev/bin';
+const RELAY_URL = 'wss://atlas-ws.managedbyai.dev';
+const CONFIG_DIR = '/etc/atlas';
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.yaml');
+const BINARY_PATH = '/usr/local/bin/atlas-agent';
+const SERVICE_NAME = 'atlas-agent';
+const TRIAL_DAYS = 30;
+
+function checkRoot() {
+  if (process.getuid() !== 0) {
+    console.error('Error: This command requires root privileges.');
+    console.error('Run with: sudo mbai <command>');
+    process.exit(1);
+  }
+}
+
+function getFingerprint() {
+  const parts = [];
+
+  // Machine ID
+  try {
+    const machineId = fs.readFileSync('/etc/machine-id', 'utf8').trim();
+    parts.push(machineId);
+  } catch (e) {}
+
+  // Hostname
+  parts.push(os.hostname());
+
+  // Combine and hash
+  const combined = parts.join('-');
+  const hash = crypto.createHash('sha256').update(combined).digest('hex').slice(0, 16);
+  return `atlas-${hash}`;
+}
+
+function getBinaryName() {
+  const platform = os.platform();
+  let arch = os.arch();
+
+  // Map architecture
+  if (arch === 'x64') arch = 'amd64';
+  if (arch === 'arm64' || arch === 'aarch64') arch = 'arm64';
+
+  if (platform === 'darwin') {
+    return `atlas-agent-darwin-${arch}`;
+  } else if (platform === 'linux') {
+    return `atlas-agent-linux-${arch}`;
+  } else {
+    throw new Error(`Unsupported platform: ${platform}/${arch}`);
+  }
+}
+
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https.get(url, (response) => {
+      if (response.statusCode === 301 || response.statusCode === 302) {
+        // Follow redirect
+        https.get(response.headers.location, (res) => {
+          res.pipe(file);
+          file.on('finish', () => {
+            file.close();
+            resolve();
+          });
+        }).on('error', reject);
+      } else {
+        response.pipe(file);
+        file.on('finish', () => {
+          file.close();
+          resolve();
+        });
+      }
+    }).on('error', reject);
+  });
+}
+
+async function cmdSetup() {
+  checkRoot();
+
+  console.log('='.repeat(50));
+  console.log('  ATLAS - AI-Powered Server Monitoring');
+  console.log('  30-day free trial. No credit card required.');
+  console.log('='.repeat(50));
+  console.log();
+
+  const fingerprint = getFingerprint();
+  console.log(`Server ID: ${fingerprint}`);
+
+  // Stop existing service if running
+  try {
+    const result = execSync('systemctl is-active atlas-agent 2>/dev/null', { encoding: 'utf8' }).trim();
+    if (result === 'active') {
+      console.log('\nStopping existing Atlas service...');
+      execSync('systemctl stop atlas-agent', { stdio: 'inherit' });
+    }
+  } catch (e) {}
+
+  // Create directories
+  console.log('\nCreating directories...');
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.mkdirSync('/var/atlas/snapshots', { recursive: true });
+  fs.mkdirSync('/usr/local/bin', { recursive: true });
+
+  // Download binary
+  const binaryName = getBinaryName();
+  const binaryUrl = `${BINARY_BASE_URL}/${binaryName}`;
+  console.log(`Downloading Atlas agent (${binaryName})...`);
+
+  try {
+    await downloadFile(binaryUrl, BINARY_PATH);
+    fs.chmodSync(BINARY_PATH, 0o755);
+    console.log(`  Installed: ${BINARY_PATH}`);
+  } catch (e) {
+    console.error(`Error downloading binary: ${e.message}`);
+    process.exit(1);
+  }
+
+  // Download auto-discover script
+  const discoverUrl = `${BINARY_BASE_URL}/auto-discover.sh`;
+  const discoverPath = '/usr/local/bin/atlas-discover';
+
+  try {
+    await downloadFile(discoverUrl, discoverPath);
+    fs.chmodSync(discoverPath, 0o755);
+    console.log(`  Installed: ${discoverPath}`);
+  } catch (e) {
+    console.log('  Warning: Could not download auto-discover script');
+  }
+
+  // Generate config
+  console.log('\nGenerating configuration...');
+
+  // Run auto-discovery if available
+  if (fs.existsSync(discoverPath)) {
+    console.log('Running service discovery...');
+    try {
+      execSync(`${discoverPath} ${CONFIG_FILE} "" "${RELAY_URL}"`, { stdio: 'inherit' });
+    } catch (e) {}
+  }
+
+  // Create basic config if discovery didn't create one
+  if (!fs.existsSync(CONFIG_FILE)) {
+    const config = `# Atlas Agent Configuration
+server_id: "${fingerprint}"
+relay_url: "${RELAY_URL}"
+trial_start: ${Math.floor(Date.now() / 1000)}
+trial_days: ${TRIAL_DAYS}
+hostname: "${os.hostname()}"
+
+metrics:
+  enabled: true
+  interval_seconds: 30
+
+log_watcher:
+  enabled: true
+  paths:
+    - /var/log/syslog
+    - /var/log/messages
+
+playbooks:
+  enabled: true
+`;
+    fs.writeFileSync(CONFIG_FILE, config);
+  }
+
+  console.log(`  Config: ${CONFIG_FILE}`);
+
+  // Create systemd service
+  console.log('\nCreating systemd service...');
+  const serviceContent = `[Unit]
+Description=Atlas Agent - AI-Powered Server Monitoring
+Documentation=https://managedbyai.dev
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+User=root
+Group=root
+ExecStart=${BINARY_PATH} daemon -c ${CONFIG_FILE}
+Restart=always
+RestartSec=10
+Environment=ATLAS_SNAPSHOT_DIR=/var/atlas/snapshots
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=atlas-agent
+LimitNOFILE=65536
+LimitNPROC=4096
+
+[Install]
+WantedBy=multi-user.target
+`;
+
+  fs.writeFileSync(`/etc/systemd/system/${SERVICE_NAME}.service`, serviceContent);
+  execSync('systemctl daemon-reload');
+  execSync(`systemctl enable ${SERVICE_NAME}`);
+
+  console.log();
+  console.log('='.repeat(50));
+  console.log('  SETUP COMPLETE');
+  console.log('='.repeat(50));
+  console.log();
+  console.log(`Server ID: ${fingerprint}`);
+  console.log();
+  console.log('Next steps:');
+  console.log('  1. Start monitoring:  sudo mbai start');
+  console.log('  2. Check status:      sudo mbai status');
+  console.log('  3. View logs:         sudo mbai logs');
+  console.log();
+  console.log(`Trial: ${TRIAL_DAYS} days free. Claim at https://managedbyai.dev/dashboard`);
+  console.log();
+}
+
+function cmdStart() {
+  checkRoot();
+
+  if (!fs.existsSync(BINARY_PATH)) {
+    console.error("Error: Atlas not installed. Run 'sudo mbai setup' first.");
+    process.exit(1);
+  }
+
+  console.log('Starting Atlas agent...');
+  execSync(`systemctl start ${SERVICE_NAME}`, { stdio: 'inherit' });
+
+  // Wait a moment then show status
+  setTimeout(() => {
+    execSync(`systemctl status ${SERVICE_NAME} --no-pager`, { stdio: 'inherit' });
+  }, 2000);
+}
+
+function cmdStop() {
+  checkRoot();
+  console.log('Stopping Atlas agent...');
+  execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'inherit' });
+  console.log('Stopped.');
+}
+
+function cmdStatus() {
+  try {
+    execSync(`systemctl status ${SERVICE_NAME} --no-pager`, { stdio: 'inherit' });
+  } catch (e) {}
+}
+
+function cmdLogs() {
+  const lines = process.argv[3] || '50';
+  execSync(`journalctl -u ${SERVICE_NAME} -n ${lines} --no-pager`, { stdio: 'inherit' });
+}
+
+function cmdUninstall() {
+  checkRoot();
+
+  console.log('Stopping Atlas agent...');
+  try {
+    execSync(`systemctl stop ${SERVICE_NAME}`, { stdio: 'pipe' });
+    execSync(`systemctl disable ${SERVICE_NAME}`, { stdio: 'pipe' });
+  } catch (e) {}
+
+  console.log('Removing files...');
+  const filesToRemove = [
+    BINARY_PATH,
+    '/usr/local/bin/atlas-discover',
+    `/etc/systemd/system/${SERVICE_NAME}.service`
+  ];
+
+  for (const f of filesToRemove) {
+    if (fs.existsSync(f)) {
+      fs.unlinkSync(f);
+      console.log(`  Removed: ${f}`);
+    }
+  }
+
+  console.log();
+  console.log('Uninstalled. Config preserved at /etc/atlas/');
+  console.log('To fully remove: sudo rm -rf /etc/atlas /var/atlas');
+}
+
+function showHelp() {
+  console.log(`
+Atlas Agent - AI-powered server monitoring
+
+Usage: mbai <command>
+
+Commands:
+  setup      Download binary, generate config (run first)
+  start      Start the monitoring daemon
+  stop       Stop the daemon
+  status     Check daemon status
+  logs       View recent logs
+  uninstall  Remove Atlas agent
+
+30-day free trial. No API key required.
+https://managedbyai.dev
+`);
+}
+
+// Main
+const command = process.argv[2];
+
+switch (command) {
+  case 'setup':
+    cmdSetup();
+    break;
+  case 'start':
+    cmdStart();
+    break;
+  case 'stop':
+    cmdStop();
+    break;
+  case 'status':
+    cmdStatus();
+    break;
+  case 'logs':
+    cmdLogs();
+    break;
+  case 'uninstall':
+    cmdUninstall();
+    break;
+  case '--help':
+  case '-h':
+  case undefined:
+    showHelp();
+    break;
+  default:
+    console.error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "mbai",
+  "version": "0.1.0",
+  "description": "AI-powered server monitoring that automatically fixes issues",
+  "bin": {
+    "mbai": "./bin/mbai.js"
+  },
+  "keywords": [
+    "server",
+    "monitoring",
+    "devops",
+    "automation",
+    "ai",
+    "self-healing",
+    "atlas"
+  ],
+  "author": "ManagedByAI <support@managedbyai.dev>",
+  "license": "MIT",
+  "homepage": "https://managedbyai.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/managedbyai/atlas-agent"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "os": [
+    "linux",
+    "darwin"
+  ]
+}