@conversionpros/aiva 1.0.1 → 2.0.1

package/lib/prerequisites.js

@@ -0,0 +1,236 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const pc = require('picocolors');
+
+function commandExists(cmd) {
+  try {
+    execSync(`which ${cmd}`, { stdio: 'pipe' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getNodeMajor() {
+  return parseInt(process.versions.node.split('.')[0], 10);
+}
+
+function section(title) {
+  console.log();
+  console.log(pc.bold(`  ${title}`));
+  console.log(pc.dim('  ' + '-'.repeat(40)));
+}
+
+function ok(msg) { console.log(`  ${pc.green('+')} ${msg}`); }
+function warn(msg) { console.log(`  ${pc.yellow('!')} ${msg}`); }
+function fail(msg) { console.log(`  ${pc.red('x')} ${msg}`); }
+function info(msg) { console.log(`  ${pc.dim(msg)}`); }
+
+async function installPrerequisites() {
+  section('System Prerequisites');
+
+  // Check macOS
+  if (process.platform !== 'darwin') {
+    fail('This installer requires macOS.');
+    process.exit(1);
+  }
+  ok('macOS detected');
+
+  // Homebrew
+  if (commandExists('brew')) {
+    ok('Homebrew installed');
+  } else {
+    warn('Homebrew not found. Installing...');
+    try {
+      execSync('/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"', {
+        stdio: 'inherit'
+      });
+      // Add to PATH for this session
+      const brewPaths = ['/opt/homebrew/bin', '/usr/local/bin'];
+      for (const p of brewPaths) {
+        if (!process.env.PATH.includes(p)) {
+          process.env.PATH = `${p}:${process.env.PATH}`;
+        }
+      }
+      ok('Homebrew installed');
+    } catch (e) {
+      fail(`Homebrew installation failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Node.js 18+
+  if (getNodeMajor() >= 18) {
+    ok(`Node.js ${process.versions.node}`);
+  } else {
+    warn(`Node.js ${process.versions.node} is too old. Installing latest via Homebrew...`);
+    try {
+      execSync('brew install node', { stdio: 'inherit' });
+      ok('Node.js updated');
+    } catch (e) {
+      fail(`Node.js installation failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // Git
+  if (commandExists('git')) {
+    ok('Git installed');
+  } else {
+    warn('Git not found. Installing...');
+    execSync('brew install git', { stdio: 'inherit' });
+    ok('Git installed');
+  }
+
+  // PM2
+  if (commandExists('pm2')) {
+    ok('PM2 installed');
+  } else {
+    warn('PM2 not found. Installing globally...');
+    try {
+      execSync('npm install -g pm2', { stdio: 'inherit' });
+      ok('PM2 installed');
+    } catch (e) {
+      fail(`PM2 installation failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+async function installTailscale(activationCode) {
+  section('Tailscale Network');
+
+  if (commandExists('tailscale')) {
+    ok('Tailscale installed');
+  } else {
+    warn('Tailscale not found. Installing via Homebrew...');
+    try {
+      execSync('brew install --cask tailscale', { stdio: 'inherit' });
+      ok('Tailscale installed');
+    } catch (e) {
+      fail(`Tailscale installation failed: ${e.message}`);
+      info('Install manually from https://tailscale.com/download');
+      return false;
+    }
+  }
+
+  // Decrypt and join
+  const { decryptTailscaleKey } = require('./constants');
+  const tsKey = decryptTailscaleKey(activationCode);
+
+  if (!tsKey) {
+    warn('Tailscale auth key not yet configured (placeholder). Skipping auto-join.');
+    info('You can join manually: sudo tailscale up --auth-key <key>');
+    return false;
+  }
+
+  try {
+    execSync(`sudo tailscale up --auth-key ${tsKey}`, { stdio: 'inherit' });
+    ok('Joined Tailscale network');
+    return true;
+  } catch (e) {
+    warn(`Tailscale join failed: ${e.message}`);
+    info('You can join manually later: sudo tailscale up');
+    return false;
+  }
+}
+
+async function installOpenClaw() {
+  section('OpenClaw');
+
+  if (commandExists('openclaw')) {
+    const ver = execSync('openclaw --version 2>/dev/null || echo unknown', { stdio: 'pipe' }).toString().trim();
+    ok(`OpenClaw already installed (${ver})`);
+  } else {
+    warn('OpenClaw not found. Installing globally...');
+    try {
+      execSync('npm install -g openclaw', { stdio: 'inherit' });
+      ok('OpenClaw installed');
+    } catch (e) {
+      fail(`OpenClaw installation failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+}
+
+async function cloneApp() {
+  section('AIVA App');
+
+  const os = require('os');
+  const path = require('path');
+  const fs = require('fs');
+  const appDir = path.join(os.homedir(), '.openclaw', 'workspace', 'aiva-tasks');
+
+  if (fs.existsSync(path.join(appDir, 'server.js'))) {
+    ok(`AIVA app already exists at ${appDir}`);
+    info('Pulling latest...');
+    try {
+      execSync('git pull origin main', { cwd: appDir, stdio: 'pipe' });
+      ok('Updated to latest');
+    } catch (e) {
+      warn(`git pull failed: ${e.message}`);
+    }
+  } else {
+    const { GITHUB_CLONE_URL } = require('./constants');
+    info(`Cloning AIVA app to ${appDir}...`);
+    const parentDir = path.dirname(appDir);
+    if (!fs.existsSync(parentDir)) {
+      fs.mkdirSync(parentDir, { recursive: true });
+    }
+    try {
+      execSync(`git clone ${GITHUB_CLONE_URL} "${appDir}"`, { stdio: 'pipe' });
+      ok('AIVA app cloned');
+    } catch (e) {
+      fail(`Clone failed: ${e.message}`);
+      process.exit(1);
+    }
+  }
+
+  // npm install
+  info('Installing dependencies...');
+  try {
+    execSync('npm install --production', { cwd: appDir, stdio: 'pipe' });
+    ok('Dependencies installed');
+  } catch (e) {
+    warn(`npm install had issues: ${e.message}`);
+  }
+
+  // Create message-router directory (SOP requirement)
+  const mrDir = path.join(appDir, 'message-router');
+  if (!fs.existsSync(mrDir)) {
+    fs.mkdirSync(mrDir, { recursive: true });
+    ok('Created message-router directory');
+  }
+
+  return appDir;
+}
+
+async function setPowerSettings() {
+  section('Power & Sleep Settings');
+  info('Setting device to stay awake 24/7...');
+  try {
+    execSync('sudo pmset -a sleep 0 displaysleep 0 disksleep 0', { stdio: 'pipe' });
+    execSync('sudo pmset -a hibernatemode 0', { stdio: 'pipe' });
+    execSync('sudo pmset -a womp 1', { stdio: 'pipe' });
+    execSync('defaults write com.apple.screensaver idleTime 0', { stdio: 'pipe' });
+    ok('Power settings configured (always awake)');
+  } catch (e) {
+    warn(`Power settings failed (may need sudo): ${e.message}`);
+    info('Run manually: sudo pmset -a sleep 0 displaysleep 0 disksleep 0');
+  }
+}
+
+module.exports = {
+  installPrerequisites,
+  installTailscale,
+  installOpenClaw,
+  cloneApp,
+  setPowerSettings,
+  commandExists,
+  section,
+  ok,
+  warn,
+  fail,
+  info
+};

package/lib/process.js

@@ -1,127 +1,59 @@
 'use strict';
 
-const { execSync, spawn } = require('child_process');
+const { execSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
+const os = require('os');
 const pc = require('picocolors');
-const { loadConfig, getLogsDir, getAivaHome, getDataDir, getUploadsDir } = require('./config');
+const { loadConfig, getLogsDir, getAivaHome } = require('./config');
 const { checkHealth, checkGateway } = require('./health');
 
-function getEcosystemPath() {
-  return path.join(getAivaHome(), 'ecosystem.config.js');
-}
-
-function writeEcosystem() {
-  const config = loadConfig();
-  const serverPath = path.join(__dirname, 'server.js');
-  const ecosystemPath = getEcosystemPath();
-
-  const content = `module.exports = {
-  apps: [{
-    name: 'aiva-app',
-    script: '${serverPath}',
-    cwd: '${getAivaHome()}',
-    env: {
-      PORT: '${config.port || 3847}',
-      AIVA_CONFIG_PATH: '${path.join(getAivaHome(), 'config.json')}',
-      AIVA_DATA_DIR: '${getDataDir()}',
-      AIVA_UPLOADS_DIR: '${getUploadsDir()}',
-      AIVA_LOGS_DIR: '${getLogsDir()}',
-      AIVA_HOME: '${getAivaHome()}',
-      NODE_ENV: 'production'
-    },
-    watch: false,
-    max_restarts: 10,
-    restart_delay: 3000,
-    log_file: '${path.join(getLogsDir(), 'aiva.log')}',
-    out_file: '${path.join(getLogsDir(), 'aiva-out.log')}',
-    error_file: '${path.join(getLogsDir(), 'aiva-error.log')}',
-    merge_logs: true,
-    time: true
-  }]
-};
-`;
-  fs.writeFileSync(ecosystemPath, content);
-}
+const APP_DIR = path.join(os.homedir(), '.openclaw', 'workspace', 'aiva-tasks');
+const PLIST_LABEL = 'com.aiva.tasks';
+const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
 
-function ensurePm2() {
-  try {
-    execSync('which pm2', { stdio: 'pipe' });
-  } catch {
-    console.log(pc.yellow('PM2 not found. Installing globally...'));
-    try {
-      execSync('npm install -g pm2', { stdio: 'inherit' });
-    } catch (e) {
-      console.error(pc.red('Failed to install PM2. Please run: npm install -g pm2'));
-      process.exit(1);
-    }
-  }
+function getUid() {
+  return process.getuid ? process.getuid() : 501;
 }
 
-async function startServer(opts = {}) {
-  const config = loadConfig();
-  const port = config.port || 3847;
+async function startServer() {
+  console.log(pc.cyan('Starting AIVA...'));
 
-  if (opts.foreground) {
-    console.log(pc.cyan(`Starting AIVA in foreground on port ${port}...`));
-    const serverPath = path.join(__dirname, 'server.js');
-    const child = spawn('node', [serverPath], {
-      stdio: 'inherit',
-      env: {
-        ...process.env,
-        PORT: String(port),
-        AIVA_CONFIG_PATH: path.join(getAivaHome(), 'config.json'),
-        AIVA_DATA_DIR: getDataDir(),
-        AIVA_UPLOADS_DIR: getUploadsDir(),
-        AIVA_LOGS_DIR: getLogsDir(),
-        AIVA_HOME: getAivaHome()
-      }
-    });
-    child.on('exit', (code) => process.exit(code));
+  if (!fs.existsSync(PLIST_PATH)) {
+    console.log(pc.yellow('LaunchAgent plist not found. Run "aiva setup" first.'));
     return;
   }
 
-  ensurePm2();
-  writeEcosystem();
-
-  console.log(pc.cyan(`Starting AIVA on port ${port}...`));
+  const uid = getUid();
   try {
-    execSync(`pm2 start ${getEcosystemPath()}`, { stdio: 'pipe' });
-    // Wait briefly for startup
-    await new Promise(r => setTimeout(r, 2000));
-    const health = await checkHealth(port);
-    if (health.ok) {
-      console.log(pc.green(`AIVA is running at http://localhost:${port}`));
-    } else {
-      console.log(pc.yellow(`AIVA process started but health check pending. Check: aiva logs`));
-    }
+    execSync(`launchctl bootstrap gui/${uid} "${PLIST_PATH}" 2>/dev/null || true`, { stdio: 'pipe' });
+    execSync(`launchctl kickstart -k gui/${uid}/${PLIST_LABEL}`, { stdio: 'pipe' });
+    console.log(pc.green('AIVA started via LaunchAgent.'));
   } catch (e) {
-    console.error(pc.red('Failed to start AIVA:'), e.message);
+    console.error(pc.red('Failed to start:'), e.message);
+    console.log(pc.dim(`Try manually: launchctl kickstart -k gui/${uid}/${PLIST_LABEL}`));
   }
 }
 
 function stopServer() {
-  ensurePm2();
   console.log(pc.cyan('Stopping AIVA...'));
   try {
-    execSync('pm2 stop aiva-app', { stdio: 'pipe' });
+    // Kill port first (SOP requirement)
+    execSync('lsof -ti:3847 | xargs kill -9 2>/dev/null || true', { stdio: 'pipe' });
     console.log(pc.green('AIVA stopped.'));
   } catch {
-    console.log(pc.yellow('AIVA is not running.'));
+    console.log(pc.yellow('AIVA may not be running.'));
   }
 }
 
 function restartServer() {
-  ensurePm2();
-  writeEcosystem();
   console.log(pc.cyan('Restarting AIVA...'));
+  // Kill port first (SOP gotcha)
   try {
-    execSync('pm2 restart aiva-app', { stdio: 'pipe' });
-    console.log(pc.green('AIVA restarted.'));
-  } catch {
-    console.log(pc.yellow('AIVA not running. Starting...'));
-    startServer();
-  }
+    execSync('lsof -ti:3847 | xargs kill -9 2>/dev/null || true', { stdio: 'pipe' });
+  } catch { /* ok */ }
+
+  setTimeout(() => startServer(), 2000);
 }
 
 async function getStatus() {
@@ -130,40 +62,19 @@ async function getStatus() {
   const pkg = require('../package.json');
 
   console.log(pc.bold(`\n${config.name || 'AIVA'} Status`));
-  console.log(pc.dim('─'.repeat(40)));
+  console.log(pc.dim('-'.repeat(40)));
   console.log(`  Version:     ${pc.cyan(pkg.version)}`);
   console.log(`  Port:        ${port}`);
 
-  // PM2 status
-  let pm2Status = 'unknown';
-  let uptime = '-';
-  let memory = '-';
+  // Check if process is running on port 3847
+  let running = false;
   try {
-    const raw = execSync('pm2 jlist', { stdio: 'pipe' }).toString();
-    const procs = JSON.parse(raw);
-    const aiva = procs.find(p => p.name === 'aiva-app');
-    if (aiva) {
-      pm2Status = aiva.pm2_env?.status || 'unknown';
-      if (aiva.pm2_env?.pm_uptime) {
-        const ms = Date.now() - aiva.pm2_env.pm_uptime;
-        const hours = Math.floor(ms / 3600000);
-        const mins = Math.floor((ms % 3600000) / 60000);
-        uptime = hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
-      }
-      if (aiva.monit?.memory) {
-        memory = `${Math.round(aiva.monit.memory / 1024 / 1024)}MB`;
-      }
-    } else {
-      pm2Status = 'not registered';
-    }
-  } catch {
-    pm2Status = 'pm2 not available';
-  }
+    const pid = execSync('lsof -ti:3847 2>/dev/null', { stdio: 'pipe' }).toString().trim();
+    running = !!pid;
+    if (running) console.log(`  PID:         ${pid}`);
+  } catch { /* not running */ }
 
-  const statusColor = pm2Status === 'online' ? pc.green : pm2Status === 'stopped' ? pc.red : pc.yellow;
-  console.log(`  Status:      ${statusColor(pm2Status)}`);
-  console.log(`  Uptime:      ${uptime}`);
-  console.log(`  Memory:      ${memory}`);
+  console.log(`  Status:      ${running ? pc.green('Running') : pc.red('Stopped')}`);
 
   // Health check
   const health = await checkHealth(port);
@@ -175,33 +86,36 @@ async function getStatus() {
     console.log(`  Gateway:     ${gw.ok ? pc.green('Connected') : pc.red('Unreachable')}`);
   }
 
-  // Data dir size
-  try {
-    const size = execSync(`du -sh "${getDataDir()}" 2>/dev/null | cut -f1`, { stdio: 'pipe' }).toString().trim();
-    console.log(`  Data size:   ${size || '-'}`);
-  } catch {
-    console.log(`  Data size:   -`);
-  }
+  // LaunchAgent status
+  console.log(`  LaunchAgent: ${fs.existsSync(PLIST_PATH) ? pc.green('Installed') : pc.yellow('Not installed')}`);
 
-  console.log(pc.dim('─'.repeat(40)));
+  console.log(pc.dim('-'.repeat(40)));
   console.log();
 }
 
 function getLogs(lines = 50) {
-  ensurePm2();
-  try {
-    execSync(`pm2 logs aiva-app --lines ${lines} --nostream`, { stdio: 'inherit' });
-  } catch {
-    // Try reading log files directly
-    const logFile = path.join(getLogsDir(), 'aiva.log');
-    if (fs.existsSync(logFile)) {
-      const content = fs.readFileSync(logFile, 'utf8');
-      const logLines = content.split('\n');
-      console.log(logLines.slice(-lines).join('\n'));
-    } else {
-      console.log(pc.yellow('No logs found.'));
-    }
+  const logFile = '/tmp/aiva-app.log';
+  const errFile = '/tmp/aiva-app-err.log';
+
+  if (fs.existsSync(logFile)) {
+    console.log(pc.bold('\n--- stdout ---'));
+    try {
+      const out = execSync(`tail -n ${lines} "${logFile}"`, { stdio: 'pipe' }).toString();
+      console.log(out);
+    } catch { console.log(pc.dim('(empty)')); }
+  }
+
+  if (fs.existsSync(errFile)) {
+    console.log(pc.bold('--- stderr ---'));
+    try {
+      const err = execSync(`tail -n ${lines} "${errFile}"`, { stdio: 'pipe' }).toString();
+      console.log(err);
+    } catch { console.log(pc.dim('(empty)')); }
+  }
+
+  if (!fs.existsSync(logFile) && !fs.existsSync(errFile)) {
+    console.log(pc.yellow('No logs found. Is AIVA running?'));
   }
 }
 
-module.exports = { startServer, stopServer, restartServer, getStatus, getLogs, writeEcosystem, ensurePm2 };
+module.exports = { startServer, stopServer, restartServer, getStatus, getLogs };