feat: auto-create evonexus user + systemd service on VPS setup

DavidsonGomes · claude · DavidsonGomes · commit 33c3d4aa1615 · 2026-04-12T16:53:00.000-03:00
Setup now detects root-on-VPS (no SUDO_USER) and automatically:
- Creates dedicated 'evonexus' user
- Copies installation to /home/evonexus/evo-nexus
- Installs uv + claude-code for the user
- Creates systemd service (evo-nexus) with auto-start on boot
- CLI update mode uses systemctl restart when service exists

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/cli/bin/cli.mjs b/cli/bin/cli.mjs
@@ -222,18 +222,45 @@ async function main() {
       console.log(`  ${YELLOW}!${RESET} Frontend build failed — run: cd dashboard/frontend && npm run build`);
     }
 
-    // Restart services if start-services.sh exists
+    // Restart services — prefer systemd if available, fallback to start-services.sh
+    const hasSystemd = check("systemctl is-active --quiet evo-nexus 2>/dev/null") ||
+                       check("systemctl is-enabled --quiet evo-nexus 2>/dev/null");
     const startScript = resolve(targetPath, "start-services.sh");
-    if (existsSync(startScript)) {
+
+    if (hasSystemd) {
+      console.log(`\n  ${DIM}Restarting via systemd...${RESET}`);
+      // If install dir differs from service dir, sync files
+      try {
+        const serviceDir = execSync("systemctl show evo-nexus -p WorkingDirectory --value 2>/dev/null", { encoding: "utf-8" }).trim();
+        if (serviceDir && resolve(serviceDir) !== resolve(targetPath)) {
+          console.log(`  ${DIM}Syncing to service directory ${serviceDir}...${RESET}`);
+          run(`rsync -a --delete --exclude='.venv' --exclude='node_modules' --exclude='logs' --exclude='dashboard/data' "${targetPath}/" "${serviceDir}/"`, { cwd: targetPath });
+          // Rebuild in service dir
+          const svcFrontend = resolve(serviceDir, "dashboard", "frontend");
+          if (existsSync(resolve(svcFrontend, "package.json"))) {
+            run("npm install --silent && npm run build --silent", { cwd: svcFrontend });
+          }
+          // Fix ownership
+          const serviceUser = execSync("systemctl show evo-nexus -p User --value 2>/dev/null", { encoding: "utf-8" }).trim();
+          if (serviceUser) {
+            run(`chown -R ${serviceUser}:${serviceUser} "${serviceDir}"`);
+          }
+        }
+      } catch {}
+      run("systemctl restart evo-nexus");
+    } else if (existsSync(startScript)) {
       console.log(`\n  ${DIM}Restarting services...${RESET}`);
       run(`bash ${startScript}`, { cwd: targetPath });
-      // Wait and verify
+    }
+
+    // Wait and verify
+    if (hasSystemd || existsSync(startScript)) {
       await new Promise(r => setTimeout(r, 3000));
       try {
         execSync("curl -sf http://localhost:8080/api/version", { timeout: 5000 });
         console.log(`  ${GREEN}✓${RESET} Dashboard restarted`);
       } catch {
-        console.log(`  ${YELLOW}!${RESET} Dashboard may not have started — check logs/dashboard.log`);
+        console.log(`  ${YELLOW}!${RESET} Dashboard may not have started — check: journalctl -u evo-nexus -n 20`);
       }
     }
 
@@ -274,15 +301,27 @@ async function main() {
 `);
 
       if (isRemote) {
-        // Remote mode: services already running, don't suggest make dashboard-app
-        console.log(`  ${BOLD}The dashboard is already running.${RESET}
+        // Remote mode: services already running via systemd
+        const hasSvc = check("systemctl is-enabled --quiet evo-nexus 2>/dev/null");
+        if (hasSvc) {
+          console.log(`  ${BOLD}The dashboard is running via systemd.${RESET}
+  Open the URL shown above to create your admin account.
+
+  ${BOLD}Useful commands:${RESET}
+  ${CYAN}•${RESET} ${BOLD}systemctl restart evo-nexus${RESET}  — restart services
+  ${CYAN}•${RESET} ${BOLD}systemctl status evo-nexus${RESET}   — check status
+  ${CYAN}•${RESET} ${BOLD}journalctl -u evo-nexus -f${RESET}   — follow logs
+  ${CYAN}•${RESET} ${BOLD}su - evonexus${RESET}                — switch to service user
+`);
+        } else {
+          console.log(`  ${BOLD}The dashboard is already running.${RESET}
   Open the URL shown above to create your admin account.
 
   ${BOLD}Useful commands:${RESET}
   ${CYAN}•${RESET} ${BOLD}./start-services.sh${RESET}  — restart dashboard services
-  ${CYAN}•${RESET} ${BOLD}make scheduler${RESET}       — start automated routines
   ${CYAN}•${RESET} ${BOLD}make help${RESET}            — see all available commands
 `);
+        }
       } else {
         console.log(`  ${BOLD}Next steps:${RESET}
   ${CYAN}1.${RESET} cd ${targetDir}
diff --git a/setup.py b/setup.py
@@ -715,6 +715,44 @@ def create_folders(config: dict):
     print(f"  {GREEN}✓{RESET} Created workspace folders ({count})")
 
 
+def _setup_systemd_service(service_user, install_dir, logs_dir):
+    """Create and start a systemd service for EvoNexus."""
+    service_home = f"/home/{service_user}"
+    service_name = "evo-nexus"
+    service_file = f"/etc/systemd/system/{service_name}.service"
+
+    print(f"  {DIM}Creating systemd service...{RESET}")
+
+    with open(service_file, "w") as f:
+        f.write(f"""[Unit]
+Description=EvoNexus Dashboard + Scheduler + Terminal Server
+After=network.target
+Documentation=https://github.com/EvolutionAPI/evo-nexus
+
+[Service]
+Type=oneshot
+RemainAfterExit=yes
+User={service_user}
+Group={service_user}
+WorkingDirectory={install_dir}
+Environment=PATH={service_home}/.local/bin:/usr/local/bin:/usr/bin:/bin
+Environment=HOME={service_home}
+ExecStart=/bin/bash {install_dir}/start-services.sh
+ExecStop=/bin/bash -c 'pkill -f "terminal-server/bin/server.js" 2>/dev/null; pkill -f "dashboard/backend.*app.py" 2>/dev/null'
+StandardOutput=append:{logs_dir}/service.log
+StandardError=append:{logs_dir}/service.log
+
+[Install]
+WantedBy=multi-user.target
+""")
+
+    os.system("systemctl daemon-reload")
+    os.system(f"systemctl enable {service_name} >/dev/null 2>&1")
+    os.system(f"systemctl start {service_name}")
+    print(f"  {GREEN}✓{RESET} Systemd service created and enabled (auto-starts on boot)")
+    print(f"  {DIM}  Manage with: systemctl {{start|stop|restart|status}} {service_name}{RESET}")
+
+
 def main():
     banner()
 
@@ -845,41 +883,82 @@ def main():
     # Data dir for SQLite
     (WORKSPACE / "dashboard" / "data").mkdir(parents=True, exist_ok=True)
 
-    # Fix ownership BEFORE starting services.
-    # When running with sudo, all files (including .venv, node_modules,
-    # frontend dist, data dir) are created as root. The services MUST
-    # run as the original user, so we chown everything now.
+    # Determine the service user.
+    # Priority: SUDO_USER (ran with sudo) > create 'evonexus' user (root on VPS) > current user
     sudo_user = os.environ.get("SUDO_USER", "")
-    if sudo_user and os.getuid() == 0:
-        print(f"  {DIM}Fixing file ownership for {sudo_user}...{RESET}")
-        os.system(f"chown -R {sudo_user}:{sudo_user} {WORKSPACE}")
-        # Ensure .venv binaries are executable after chown
-        os.system(f"chmod -R u+x {WORKSPACE}/.venv/bin/ 2>/dev/null")
-        run_as = f"su - {sudo_user} -c"
-        print(f"  {GREEN}✓{RESET} Ownership fixed")
+    service_user = sudo_user  # may be empty
+
+    if os.getuid() == 0 and not sudo_user and is_remote:
+        # Running as root directly (common on VPS) — create dedicated user
+        service_user = "evonexus"
+        print(f"\n  {DIM}Creating dedicated service user '{service_user}'...{RESET}")
+        ret = os.system(f"id {service_user} >/dev/null 2>&1")
+        if ret != 0:
+            os.system(f"useradd -m -s /bin/bash {service_user}")
+            print(f"  {GREEN}✓{RESET} User '{service_user}' created")
+        else:
+            print(f"  {DIM}✓ User '{service_user}' already exists{RESET}")
+
+        # Copy installation to user home
+        service_home = f"/home/{service_user}"
+        service_dir = f"{service_home}/evo-nexus"
+        if str(WORKSPACE.resolve()) != service_dir:
+            print(f"  {DIM}Copying installation to {service_dir}...{RESET}")
+            os.system(f"rm -rf {service_dir}")
+            os.system(f"cp -a {WORKSPACE} {service_dir}")
+            print(f"  {GREEN}✓{RESET} Copied to {service_dir}")
+        # Update WORKSPACE reference for start-services.sh
+        install_dir = Path(service_dir)
+
+        # Install uv + claude-code for the service user
+        ret = os.system(f"su - {service_user} -c 'command -v uv' >/dev/null 2>&1")
+        if ret != 0:
+            print(f"  {DIM}Installing uv for {service_user}...{RESET}")
+            os.system(f"su - {service_user} -c 'curl -LsSf https://astral.sh/uv/install.sh | sh' >/dev/null 2>&1")
+            print(f"  {GREEN}✓{RESET} uv installed")
+
+        ret = os.system(f"su - {service_user} -c 'export PATH=$HOME/.local/bin:$PATH && command -v claude' >/dev/null 2>&1")
+        if ret != 0:
+            print(f"  {DIM}Installing Claude Code for {service_user}...{RESET}")
+            os.system(f"su - {service_user} -c 'npm install -g @anthropic-ai/claude-code --prefix ~/.local' >/dev/null 2>&1")
+            print(f"  {GREEN}✓{RESET} Claude Code installed")
+
+        # Sync deps as service user
+        print(f"  {DIM}Syncing dependencies as {service_user}...{RESET}")
+        os.system(f"su - {service_user} -c 'export PATH=$HOME/.local/bin:$PATH && cd {service_dir} && uv sync -q' 2>/dev/null")
+
+        # Fix ownership
+        os.system(f"chown -R {service_user}:{service_user} {service_dir}")
+        os.system(f"chown -R {service_user}:{service_user} {service_home}")
     else:
-        run_as = "bash -c"
+        install_dir = WORKSPACE
+
+    # Fix ownership BEFORE starting services.
+    if service_user and os.getuid() == 0:
+        target_dir = install_dir if service_user == "evonexus" else WORKSPACE
+        print(f"  {DIM}Fixing file ownership for {service_user}...{RESET}")
+        os.system(f"chown -R {service_user}:{service_user} {target_dir}")
+        os.system(f"chmod -R u+x {target_dir}/.venv/bin/ 2>/dev/null")
+        print(f"  {GREEN}✓{RESET} Ownership fixed")
 
     # Start dashboard services
-    logs_dir = WORKSPACE / "logs"
+    logs_dir = install_dir / "logs"
     logs_dir.mkdir(exist_ok=True)
-    if sudo_user and os.getuid() == 0:
-        os.system(f"chown -R {sudo_user}:{sudo_user} {logs_dir}")
+    if service_user and os.getuid() == 0:
+        os.system(f"chown -R {service_user}:{service_user} {logs_dir}")
+
     print(f"\n  {DIM}Starting dashboard services...{RESET}")
-    # Stop any existing services (systemd, background processes)
-    os.system("systemctl stop evonexus 2>/dev/null; systemctl disable evonexus 2>/dev/null")
+    # Stop any existing services
+    os.system("systemctl stop evo-nexus 2>/dev/null")
     os.system("pkill -f 'terminal-server/bin/server.js' 2>/dev/null")
     os.system("pkill -f 'app.py' 2>/dev/null")
     os.system("sleep 1")
-    if sudo_user:
-        print(f"  {DIM}(services will run as {sudo_user}, not root){RESET}")
 
-    # Start terminal-server
-    # Create a startup script that persists processes properly
-    startup_script = WORKSPACE / "start-services.sh"
+    # Create start-services.sh
+    startup_script = install_dir / "start-services.sh"
     startup_script.write_text(f"""#!/bin/bash
 export PATH="/usr/local/bin:/usr/bin:/bin:$HOME/.local/bin"
-cd {WORKSPACE}
+cd {install_dir}
 
 # Kill existing services
 pkill -f 'terminal-server/bin/server.js' 2>/dev/null
@@ -894,14 +973,19 @@ def main():
 
 # Start Flask dashboard
 cd dashboard/backend
-nohup {WORKSPACE}/.venv/bin/python app.py > {logs_dir}/dashboard.log 2>&1 &
+nohup {install_dir}/.venv/bin/python app.py > {logs_dir}/dashboard.log 2>&1 &
 """, encoding="utf-8")
     os.chmod(startup_script, 0o755)
 
-    if sudo_user:
-        os.system(f"su - {sudo_user} -c '{startup_script}'")
+    # Create systemd service (remote/VPS only, when we have a service user)
+    if is_remote and service_user and os.getuid() == 0:
+        _setup_systemd_service(service_user, install_dir, logs_dir)
+    elif service_user:
+        print(f"  {DIM}(services will run as {service_user}){RESET}")
+        os.system(f"su - {service_user} -c '{startup_script}'")
     else:
         os.system(str(startup_script))
+
     import time as _time
     _time.sleep(3)
     # Verify
@@ -920,6 +1004,15 @@ def main():
     dashboard_url = access_config.get('url', f'http://localhost:{dashboard_port}')
 
     if is_remote:
+        svc_msg = ""
+        if service_user == "evonexus":
+            svc_msg = f"""
+  Servico systemd:
+    {DIM}systemctl status evo-nexus{RESET}     — verificar status
+    {DIM}systemctl restart evo-nexus{RESET}    — reiniciar
+    {DIM}journalctl -u evo-nexus -f{RESET}     — ver logs
+    {DIM}su - evonexus{RESET}                  — acessar usuario do servico
+"""
         print(f"""
   {GREEN}{'='*50}{RESET}
   {GREEN}Setup concluido!{RESET}
@@ -933,7 +1026,7 @@ def main():
     1. Acesse o link acima e crie sua conta de administrador
     2. Va em {BOLD}Providers{RESET} e configure o AI Provider
     3. Abra um agente e comece a usar!
-""")
+{svc_msg}""")
     else:
         print(f"""
   {GREEN}Done!{RESET} Next steps:
