robot-resources 1.9.0 → 1.9.2

package/lib/service.js

@@ -322,6 +322,163 @@ function getLinuxUnitPath() {
   return isRoot() ? SYSTEM_UNIT_PATH : getUserUnitPath();
 }
 
+// ─── Crontab @reboot fallback (Docker / WSL-no-systemd / rootless) ──────────
+//
+// When systemd isn't available, we fall back to a cron @reboot entry plus an
+// immediate detached spawn. This gives the router:
+//   1. Persistence across reboot — @reboot fires when cron starts at boot.
+//   2. Immediate availability — the detached process starts right now.
+//
+// The crontab command invokes a wrapper script (same idea as the Windows .cmd
+// wrapper) so env vars from router.env are sourced before launch. Cron runs
+// commands with a minimal env so sourcing is required.
+
+const CRONTAB_MARKER = '# robot-resources-router';
+const CRONTAB_MARKER_FILE = '.crontab-installed';
+
+function hasCrontab() {
+  const res = spawnSync('crontab', ['-l'], { stdio: 'pipe', encoding: 'utf-8' });
+  // Exit 0 = crontab exists; exit 1 with "no crontab" message = cron available
+  // but empty; exit 127 / ENOENT = no crontab command at all.
+  return res.error?.code !== 'ENOENT' && res.status !== 127;
+}
+
+function getCronWrapperPath() {
+  return join(homedir(), '.robot-resources', 'rr-router-run.sh');
+}
+
+function getCrontabMarkerPath() {
+  return join(homedir(), '.robot-resources', CRONTAB_MARKER_FILE);
+}
+
+function buildCronWrapper(venvPythonPath, envFilePath, logsDir) {
+  // POSIX /bin/sh so it runs under any cron implementation (cron, cronie,
+  // busybox). `set -a` auto-exports every var we source. nohup detaches from
+  // cron's controlling terminal so the router stays alive after cron exits.
+  return [
+    '#!/bin/sh',
+    'set -a',
+    `. "${envFilePath}"`,
+    'set +a',
+    `exec nohup "${venvPythonPath}" -m robot_resources.cli.main start \\`,
+    `  >> "${join(logsDir, 'router.stdout.log')}" \\`,
+    `  2>> "${join(logsDir, 'router.stderr.log')}"`,
+    '',
+  ].join('\n');
+}
+
+function readCurrentCrontab() {
+  const res = spawnSync('crontab', ['-l'], { stdio: 'pipe', encoding: 'utf-8' });
+  // Exit 1 with no stdout usually means "no crontab for user" — treat as empty.
+  if (res.status !== 0) return '';
+  return res.stdout || '';
+}
+
+function writeCrontab(contents) {
+  const res = spawnSync('crontab', ['-'], {
+    input: contents,
+    stdio: ['pipe', 'pipe', 'pipe'],
+    encoding: 'utf-8',
+  });
+  if (res.status !== 0) {
+    const stderr = (res.stderr || '').toString().trim();
+    throw new Error(`crontab write failed (status ${res.status}): ${stderr || 'unknown error'}`);
+  }
+}
+
+function spawnDetachedRouter(wrapperPath) {
+  // Immediate start so wizard's health check can verify :3838 right away.
+  // Best-effort: if cron or sh is unavailable, at least log it; the @reboot
+  // entry will still fire next boot.
+  const child = spawnSync('sh', ['-c', `nohup "${wrapperPath}" > /dev/null 2>&1 &`], {
+    stdio: 'ignore',
+    detached: true,
+  });
+  return child.status === 0;
+}
+
+function installCrontab(venvPythonPath) {
+  if (!hasCrontab()) {
+    throw new Error(
+      'crontab command not available — cannot install @reboot fallback.\n' +
+      `  Run the router manually: ${venvPythonPath} -m robot_resources.cli.main start`,
+    );
+  }
+
+  const logsDir = join(homedir(), '.robot-resources', 'logs');
+  mkdirSync(logsDir, { recursive: true });
+
+  // Snapshot provider env + PATH so the router has the keys it needs when
+  // cron fires at boot. Cron runs with a minimal env by default.
+  const resolvedKeys = resolveProviderEnv();
+  const envFilePath = writeEnvFile(resolvedKeys);
+
+  // Write wrapper script (0o700 — contains nothing secret itself, but only
+  // the owner should be able to execute it).
+  const wrapperPath = getCronWrapperPath();
+  writeFileSync(wrapperPath, buildCronWrapper(venvPythonPath, envFilePath, logsDir));
+  chmodSync(wrapperPath, 0o700);
+
+  // Add or replace our @reboot entry. Idempotent: strip any existing
+  // robot-resources lines first, then append a fresh one.
+  const current = readCurrentCrontab();
+  const filtered = current
+    .split('\n')
+    .filter((line) => !line.includes(CRONTAB_MARKER) && !line.includes('robot_resources.cli.main'))
+    .join('\n');
+  const trimmed = filtered.trimEnd();
+  const entry = `@reboot "${wrapperPath}" ${CRONTAB_MARKER}`;
+  const next = (trimmed ? trimmed + '\n' : '') + entry + '\n';
+  writeCrontab(next);
+
+  // Marker file lets uninstallService() know we used this fallback without
+  // having to re-parse the crontab.
+  writeFileSync(getCrontabMarkerPath(), new Date().toISOString() + '\n', { mode: 0o600 });
+
+  // Start now so :3838 is live before the wizard's health check runs.
+  spawnDetachedRouter(wrapperPath);
+}
+
+function uninstallCrontab() {
+  if (!existsSync(getCrontabMarkerPath())) return;
+
+  // Remove our line(s) from the user crontab; leave other entries alone.
+  if (hasCrontab()) {
+    try {
+      const current = readCurrentCrontab();
+      const filtered = current
+        .split('\n')
+        .filter((line) => !line.includes(CRONTAB_MARKER) && !line.includes('robot_resources.cli.main'))
+        .join('\n')
+        .trimEnd();
+      writeCrontab(filtered ? filtered + '\n' : '');
+    } catch {
+      // Best-effort — don't block uninstall if crontab write fails.
+    }
+  }
+
+  // Best-effort: kill the running router process.
+  spawnSync('pkill', ['-f', 'robot_resources.cli.main start'], { stdio: 'ignore' });
+
+  // Clean up marker + wrapper.
+  try { unlinkSync(getCrontabMarkerPath()); } catch { /* already gone */ }
+  try { unlinkSync(getCronWrapperPath()); } catch { /* already gone */ }
+}
+
+function isCrontabInstalled() {
+  return existsSync(getCrontabMarkerPath());
+}
+
+function isCrontabRouterRunning() {
+  // Cheapest check: is anything listening on :3838?
+  // We can't rely on `systemctl is-active` since we aren't using systemd.
+  const res = spawnSync('sh', ['-c', `lsof -i :${ROUTER_PORT} -t 2>/dev/null`], {
+    stdio: 'pipe',
+    encoding: 'utf-8',
+  });
+  return res.status === 0 && (res.stdout || '').trim().length > 0;
+}
+
 // ─── Windows (Task Scheduler) ───────────────────────────────────────────────
 
 function getWrapperCmdPath() {
@@ -421,30 +578,23 @@ export function installService(venvPythonPath) {
   if (process.platform === 'linux') {
     const mode = getLinuxMode();
 
-    if (mode === 'docker') {
-      return {
-        type: 'skipped',
-        reason: 'Running inside Docker — service registration skipped.\n' +
-          '  Options:\n' +
-          '  1. Dockerfile entrypoint:\n' +
-          `     CMD ["${venvPythonPath}", "-m", "robot_resources.cli.main", "start"]\n` +
-          '  2. Docker Compose sidecar:\n' +
-          '     services:\n' +
-          '       router:\n' +
-          `         command: ${venvPythonPath} -m robot_resources.cli.main start\n` +
-          '         ports: ["3838:3838"]\n' +
-          '  3. Background process:\n' +
-          `     ${venvPythonPath} -m robot_resources.cli.main start &`,
-      };
-    }
-
-    if (mode === 'wsl-no-systemd') {
-      return {
-        type: 'skipped',
-        reason: 'WSL without systemd detected — service registration skipped.\n' +
-          '  Enable systemd in WSL (wsl.conf → [boot] systemd=true) or run manually:\n' +
-          `  ${venvPythonPath} -m robot_resources.cli.main start`,
-      };
+    // Docker and WSL-no-systemd fall through to the crontab fallback.
+    // Previously these returned { type: 'skipped' } and the router was never
+    // registered — users ended up with install_complete service=false and
+    // silent failure. crontab @reboot + immediate detached spawn gives us
+    // persistence across reboot without requiring systemd.
+    if (mode === 'docker' || mode === 'wsl-no-systemd') {
+      try {
+        installCrontab(venvPythonPath);
+        return { type: 'crontab', path: getCronWrapperPath() };
+      } catch (err) {
+        // Last-resort message if even cron is unavailable.
+        return {
+          type: 'skipped',
+          reason: `${mode === 'docker' ? 'Running inside Docker' : 'WSL without systemd'} and crontab fallback failed: ${err.message}\n` +
+            `  Run the router manually: ${venvPythonPath} -m robot_resources.cli.main start`,
+        };
+      }
     }
 
     if (mode === 'system') {
@@ -474,9 +624,10 @@ export function installService(venvPythonPath) {
 export function uninstallService() {
   if (process.platform === 'darwin') return uninstallLaunchd();
   if (process.platform === 'linux') {
-    // Clean up whichever variant is installed
+    // Clean up whichever variant is installed.
     if (existsSync(SYSTEM_UNIT_PATH)) return uninstallSystemdSystem();
     if (existsSync(getUserUnitPath())) return uninstallSystemdUser();
+    if (isCrontabInstalled()) return uninstallCrontab();
   }
   if (process.platform === 'win32') return uninstallTaskScheduler();
 }
@@ -496,12 +647,17 @@ export function isServiceRunning() {
         return false;
       }
     }
-    try {
-      execSync(`systemctl --user is-active ${SERVICE_NAME}`, { stdio: 'pipe' });
-      return true;
-    } catch {
-      return false;
+    if (existsSync(getUserUnitPath())) {
+      try {
+        execSync(`systemctl --user is-active ${SERVICE_NAME}`, { stdio: 'pipe' });
+        return true;
+      } catch {
+        return false;
+      }
     }
+    // Crontab fallback — check if anything is listening on :3838.
+    if (isCrontabInstalled()) return isCrontabRouterRunning();
+    return false;
   }
   if (process.platform === 'win32') return isTaskSchedulerRunning();
   return false;
@@ -512,7 +668,9 @@ export function isServiceRunning() {
  */
 export function isServiceInstalled() {
   if (process.platform === 'darwin') return existsSync(getPlistPath());
-  if (process.platform === 'linux') return existsSync(SYSTEM_UNIT_PATH) || existsSync(getUserUnitPath());
+  if (process.platform === 'linux') {
+    return existsSync(SYSTEM_UNIT_PATH) || existsSync(getUserUnitPath()) || isCrontabInstalled();
+  }
   if (process.platform === 'win32') return isTaskSchedulerInstalled();
   return false;
 }

package/lib/wizard.js

@@ -9,6 +9,40 @@ import { installService, isServiceRunning, isServiceInstalled } from './service.
 import { configureToolRouting, registerScraperMcp, restartOpenClawGateway } from './tool-config.js';
 import { checkHealth } from './health-report.js';
 import { header, step, success, warn, error, info, blank, summary } from './ui.js';
+/**
+ * Classify an install error into a short reason code + bounded detail string.
+ *
+ * Before this existed, install_complete telemetry reported router:false with
+ * no context — 100% of rr-router installs failed and we couldn't diagnose.
+ * The reason code slots into a small enum so we can aggregate in the admin
+ * dashboard; detail is the tail of stderr/error message for deep-dives.
+ */
+function classifyRouterError(err) {
+  const msg = (err?.message || String(err)).toLowerCase();
+  let reason = 'unknown';
+
+  if (msg.includes('python 3.10+') || msg.includes('python is required')) {
+    reason = 'python_not_found';
+  } else if (err?.code === 'ENOENT' || msg.includes('enoent')) {
+    reason = 'spawn_enoent';
+  } else if (msg.includes('timeout') || msg.includes('timed out') || err?.code === 'ETIMEDOUT') {
+    reason = 'timeout';
+  } else if (msg.includes('exited with code') || msg.includes('pip install')) {
+    reason = 'pip_install_failed';
+  } else if (msg.includes('permission denied') || err?.code === 'EACCES') {
+    reason = 'permission_denied';
+  } else if (msg.includes('disk') || msg.includes('space') || err?.code === 'ENOSPC') {
+    reason = 'disk_full';
+  } else if (msg.includes('network') || msg.includes('getaddrinfo') || msg.includes('enetunreach')) {
+    reason = 'network';
+  }
+
+  const rawDetail = err?.stderr?.trim?.() || err?.message || String(err);
+  const detail = rawDetail.slice(-500);
+
+  return { reason, detail, exitCode: err?.exitCode ?? null };
+}
+
 /**
  * Main setup wizard. Handles the full onboarding flow:
  * 1. Router installation (Python venv + pip)
@@ -128,6 +162,8 @@ export async function runWizard({ nonInteractive = false } = {}) {
       warn('Python 3.10+ not found — skipping Router installation');
       info('Install Python from https://python.org and re-run this wizard');
       info('Scraper works without Python');
+      // Record the reason so install_complete tells us why router=false.
+      results.routerError = { reason: 'python_not_found', detail: 'Python 3.10+ not detected on PATH' };
     } else {
       info(`Found Python ${python.version} (${python.bin})`);
       step('Installing Router (this may take a moment)...');
@@ -138,7 +174,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
         results.router = true;
       } catch (err) {
         error(`Router installation failed: ${err.message}`);
-        results.routerError = 'install-failed';
+        results.routerError = classifyRouterError(err);
       }
     }
   }
@@ -298,15 +334,21 @@ export async function runWizard({ nonInteractive = false } = {}) {
     try {
       const config = readConfig();
       const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+      const installPayload = {
+        router: results.router || false,
+        service: results.service || false,
+        scraper: results.scraper || false,
+        source: 'wizard',
+      };
+      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',
         event_type: 'install_complete',
-        payload: {
-          router: results.router || false,
-          service: results.service || false,
-          scraper: results.scraper || false,
-          source: 'wizard',
-        },
+        payload: installPayload,
       });
 
       for (let attempt = 0; attempt < 2; attempt++) {

package/package.json

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