robot-resources 1.9.4 → 1.9.6

package/lib/service.js

@@ -216,6 +216,28 @@ WantedBy=default.target
 `;
 }
 
+/**
+ * Check whether linger is enabled for the current user.
+ *
+ * Without linger, systemd-user services are torn down when the user logs
+ * out (SSH disconnect, login manager logout). On the Finland signup
+ * (2026-04-23) this was the root cause: 3 heartbeats, then session ended,
+ * then the router died with the session.
+ */
+function isLingerEnabled() {
+  try {
+    const user = process.env.USER || process.env.LOGNAME;
+    if (!user) return false;
+    const res = spawnSync('loginctl', ['show-user', user, '--property=Linger'], {
+      stdio: 'pipe', encoding: 'utf-8',
+    });
+    if (res.status !== 0) return false;
+    return /^Linger=yes\s*$/m.test(res.stdout || '');
+  } catch {
+    return false;
+  }
+}
+
 function installSystemdUser(venvPythonPath) {
   const unitPath = getUserUnitPath();
   const logsDir = join(homedir(), '.robot-resources', 'logs');
@@ -232,12 +254,17 @@ function installSystemdUser(venvPythonPath) {
   execSync('systemctl --user enable robot-resources-router.service', { stdio: 'pipe' });
   execSync('systemctl --user start robot-resources-router.service', { stdio: 'pipe' });
 
-  // Enable linger so the service survives SSH disconnects (critical for VMs)
+  // Enable linger so the service survives SSH disconnects (critical for VMs).
+  // On many distros this needs polkit auth and silently no-ops from a
+  // non-interactive shell — we attempt it then VERIFY the result.
+  let lingerEnabled = false;
   try {
     execSync('loginctl enable-linger', { stdio: 'pipe' });
   } catch {
-    // Non-fatal — linger may not be available (e.g. no loginctl)
+    // fall through to verification
   }
+  lingerEnabled = isLingerEnabled();
+  return { lingerEnabled };
 }
 
 function uninstallSystemdUser() {
@@ -603,8 +630,29 @@ export function installService(venvPythonPath) {
     }
 
     // mode === 'user'
-    installSystemdUser(venvPythonPath);
-    return { type: 'systemd-user', path: getUserUnitPath() };
+    const { lingerEnabled } = installSystemdUser(venvPythonPath);
+
+    // Belt-and-suspenders: ALSO install crontab @reboot so the router comes
+    // back on reboot even if linger isn't taking effect (polkit denied,
+    // container restrictions, etc.). Idempotent — removes any existing
+    // RR crontab entry before adding the fresh one. Safe to call even
+    // when crontab is absent (we skip silently).
+    let crontabFallback = false;
+    if (hasCrontab()) {
+      try {
+        installCrontab(venvPythonPath);
+        crontabFallback = true;
+      } catch {
+        // Non-fatal — systemd-user still works while user is logged in.
+      }
+    }
+
+    return {
+      type: 'systemd-user',
+      path: getUserUnitPath(),
+      lingerEnabled,
+      crontabFallback,
+    };
   }
 
   if (process.platform === 'win32') {
@@ -624,10 +672,12 @@ export function installService(venvPythonPath) {
 export function uninstallService() {
   if (process.platform === 'darwin') return uninstallLaunchd();
   if (process.platform === 'linux') {
-    // Clean up whichever variant is installed.
-    if (existsSync(SYSTEM_UNIT_PATH)) return uninstallSystemdSystem();
-    if (existsSync(getUserUnitPath())) return uninstallSystemdUser();
-    if (isCrontabInstalled()) return uninstallCrontab();
+    // Clean up whatever variants are installed. systemd-user users may
+    // also have a crontab belt installed alongside — remove both.
+    if (existsSync(SYSTEM_UNIT_PATH)) uninstallSystemdSystem();
+    if (existsSync(getUserUnitPath())) uninstallSystemdUser();
+    if (isCrontabInstalled()) uninstallCrontab();
+    return;
   }
   if (process.platform === 'win32') return uninstallTaskScheduler();
 }

package/lib/wizard.js

@@ -1,6 +1,6 @@
 import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
 import { join } from 'node:path';
-import { homedir, hostname } from 'node:os';
+import { homedir, hostname, release as osRelease } from 'node:os';
 import { readConfig, writeConfig } from '@robot-resources/cli-core/config.mjs';
 import { findPython, isPortAvailable, isHeadless, isOpenClawInstalled } from './detect.js';
 import { getOrCreateMachineId } from './machine-id.js';
@@ -69,6 +69,8 @@ function classifyRouterError(err) {
 export async function runWizard({ nonInteractive = false } = {}) {
   header();
 
+  const wizardStartMs = Date.now();
+
   const results = {
     auth: false,
     authMethod: null, // 'config' | 'apikey' | 'github'
@@ -76,6 +78,18 @@ export async function runWizard({ nonInteractive = false } = {}) {
     routerError: null,
     providerKeys: false,
     service: false,
+    // Diagnostic fields populated as the wizard progresses. All are sent
+    // in install_complete (success AND failure) so we can distinguish
+    // "pip installed but router never served a request" from a real
+    // working setup in post-hoc telemetry.
+    serviceType: null,
+    lingerEnabled: null,
+    crontabFallback: null,
+    pluginInstalled: false,
+    openclawDetected: false,
+    openclawConfigPatched: false,
+    scraperMcpRegistered: false,
+    healthCheck: { attempted: false },
   };
 
   // ── Step 0: Provision API key (before anything else) ────────────────────
@@ -222,12 +236,25 @@ export async function runWizard({ nonInteractive = false } = {}) {
 
       try {
         const svc = installService(getVenvPythonPath());
+        results.serviceType = svc.type || null;
+        // systemd-user only survives user sessions with linger enabled; the
+        // installer now verifies the bit actually flipped and installs a
+        // crontab @reboot belt when it didn't. Capture both signals so we
+        // can tell which users land on a live-forever setup vs one that
+        // dies on logout.
+        results.lingerEnabled = svc.lingerEnabled ?? null;
+        results.crontabFallback = svc.crontabFallback ?? null;
         if (svc.type === 'skipped') {
           warn(svc.reason);
           results.service = false;
         } else {
           success(`Router registered as ${svc.type} service`);
           info(`Config: ${svc.path}`);
+          if (svc.type === 'systemd-user') {
+            if (svc.lingerEnabled) info('Linger enabled — router survives logout');
+            else warn('Linger not enabled — router may stop when you log out');
+            if (svc.crontabFallback) info('Crontab @reboot installed as fallback');
+          }
           info('Router will start automatically and restart on crash');
           results.service = true;
         }
@@ -247,6 +274,15 @@ export async function runWizard({ nonInteractive = false } = {}) {
     const toolResults = configureToolRouting();
     results.tools = toolResults;
 
+    // Surface OC-specific signals for install_complete diagnostics.
+    results.openclawDetected = isOpenClawInstalled();
+    const ocResult = toolResults.find((r) => r.name === 'OpenClaw');
+    if (ocResult) {
+      results.pluginInstalled =
+        ocResult.action === 'installed' || ocResult.action === 'already_configured';
+      results.openclawConfigPatched = Boolean(ocResult.configActivated);
+    }
+
     if (toolResults.length === 0) {
       info('No supported AI tools detected');
       info('Point your tool at http://localhost:3838 to enable cost optimization');
@@ -289,6 +325,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
   if (scraperRegistered) {
     success('Scraper MCP registered in OpenClaw — scraper_compress_url(url) available');
     results.scraper = true;
+    results.scraperMcpRegistered = true;
   } else {
     // Either already registered, or no openclaw.json
     try {
@@ -296,6 +333,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
       if (ocConfig?.mcp?.servers?.['robot-resources-scraper']) {
         success('Scraper MCP already registered in OpenClaw');
         results.scraper = true;
+        results.scraperMcpRegistered = true;
       }
     } catch {
       // No openclaw.json — not on OC, skip
@@ -303,13 +341,25 @@ export async function runWizard({ nonInteractive = false } = {}) {
   }
 
   // ── Step 4.5: Router Healthcheck ──────────────────────────────────────
+  //
+  // Verify the router is actually serving /health — not just that pip
+  // exited 0. Runs regardless of whether service registration succeeded:
+  // a router started by the wizard's spawn (or by a running OC) still
+  // deserves to be probed, and a router that pip-installed but fails to
+  // respond means the install is NOT actually complete.
+  //
+  // If we declared router=true from Step 1 (pip success) but /health
+  // won't answer, downgrade router→false with a dedicated error reason.
+  // This closes the "install looks green but nothing works" gap that
+  // produced 34 silent-after-install real users with no diagnostics.
 
-  // Router: verify it's responding on localhost:3838
-  if (results.service) {
+  if (results.router) {
     blank();
     step('Verifying Router is responding...');
 
-    let healthy = false;
+    const checkStart = Date.now();
+    let healthData = null;
+    let lastErr = null;
     // Retry a few times — the service may need a moment to start
     for (let attempt = 0; attempt < 3; attempt++) {
       try {
@@ -319,20 +369,38 @@ export async function runWizard({ nonInteractive = false } = {}) {
         if (res.ok) {
           const data = await res.json();
           if (data.status === 'healthy' || data.status === 'degraded') {
-            success(`Router healthy (v${data.version || 'unknown'})`);
-            healthy = true;
+            healthData = data;
             break;
           }
         }
-      } catch {
-        // Wait before retrying
-        await new Promise((r) => setTimeout(r, 2000));
+      } catch (err) {
+        lastErr = err?.message || String(err);
       }
+      if (attempt < 2) await new Promise((r) => setTimeout(r, 2000));
     }
 
-    if (!healthy) {
-      warn('Router not responding yet — it may need a few more seconds to start');
+    results.healthCheck = {
+      attempted: true,
+      passed: Boolean(healthData),
+      version: healthData?.version ?? null,
+      status: healthData?.status ?? null,
+      latencyMs: Date.now() - checkStart,
+      error: healthData ? null : lastErr,
+    };
+
+    if (healthData) {
+      success(`Router healthy (v${healthData.version || 'unknown'})`);
+    } else {
+      warn('Router not responding — marking install as failed.');
       info('Check manually: curl http://localhost:3838/health');
+      // Bug fix: previously we left router=true here. Now we downgrade
+      // so install_complete reflects reality and the error is classified.
+      results.router = false;
+      results.routerError = {
+        reason: 'health_check_failed',
+        detail: (lastErr || 'no response').slice(-500),
+        exitCode: null,
+      };
     }
   }
 
@@ -349,22 +417,33 @@ export async function runWizard({ nonInteractive = false } = {}) {
     try {
       const config = readConfig();
       const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+      // Everything populated unconditionally so success installs carry
+      // the same diagnostic weight as failures. Prior versions only
+      // captured routerError+platform on failure, leaving 34 "successful"
+      // installs with no post-hoc signal to explain why they never emit
+      // another event.
       const installPayload = {
+        source: 'wizard',
         router: results.router || false,
         service: results.service || false,
         scraper: results.scraper || false,
-        source: 'wizard',
+        platform: process.platform,
+        os_release: osRelease(),
+        node_version: process.version,
+        install_duration_ms: Date.now() - wizardStartMs,
+        python_source: results.pythonSource ?? null,
+        service_type: results.serviceType ?? null,
+        linger_enabled: results.lingerEnabled,
+        crontab_fallback: results.crontabFallback,
+        health_check: results.healthCheck,
+        plugin_installed: results.pluginInstalled,
+        openclaw_detected: results.openclawDetected,
+        openclaw_config_patched: results.openclawConfigPatched,
+        scraper_mcp_registered: results.scraperMcpRegistered,
       };
-      if (results.pythonSource) {
-        // 'system' when the user had Python installed, 'uv' when we
-        // auto-bootstrapped one. Lets us measure how many installs were
-        // rescued by the uv fallback.
-        installPayload.pythonSource = results.pythonSource;
-      }
       if (results.routerError && typeof results.routerError === 'object') {
         installPayload.routerError = results.routerError.reason;
         installPayload.routerErrorDetail = results.routerError.detail;
-        installPayload.platform = process.platform;
       }
       const body = JSON.stringify({
         product: 'cli',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "robot-resources",
-  "version": "1.9.4",
+  "version": "1.9.6",
   "description": "Robot Resources — AI agent tools. One command to install everything.",
   "type": "module",
   "bin": {