robot-resources 1.8.2 → 1.9.1

package/lib/service.js

@@ -1,4 +1,4 @@
-import { execSync } from 'node:child_process';
+import { execSync, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, chmodSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
@@ -6,6 +6,7 @@ import { readProviderKeys } from '@robot-resources/cli-core/config.mjs';
 
 const LABEL = 'ai.robotresources.router';
 const SERVICE_NAME = 'robot-resources-router.service';
+const TASK_NAME = 'RobotResourcesRouter';
 const ROUTER_PORT = 3838;
 
 // Maps config.json provider_keys names to environment variable names
@@ -57,7 +58,11 @@ function resolveProviderEnv() {
       resolvedKeys[envName] = configKeys[configName];
     }
   }
-  resolvedKeys['PATH'] = '/usr/local/bin:/usr/bin:/bin';
+  // Windows inherits PATH from the user profile when schtasks fires the task;
+  // overwriting it to a Unix path would break every `python.exe` resolution.
+  if (process.platform !== 'win32') {
+    resolvedKeys['PATH'] = '/usr/local/bin:/usr/bin:/bin';
+  }
   return resolvedKeys;
 }
 
@@ -317,6 +322,248 @@ 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() {
+  return join(homedir(), '.robot-resources', 'rr-router-run.cmd');
+}
+
+function buildWrapperCmd(venvPythonPath, envFilePath, logsDir) {
+  // The wrapper sources router.env line-by-line into `set` (so quoting is
+  // handled by cmd.exe), then launches the router. stdout/stderr append to
+  // log files so the scheduled task — which has no attached console — leaves
+  // a trail the user can read.
+  return [
+    '@echo off',
+    'setlocal enabledelayedexpansion',
+    `for /f "usebackq tokens=* delims=" %%a in ("${envFilePath}") do set "%%a"`,
+    `"${venvPythonPath}" -m robot_resources.cli.main start >> "${join(logsDir, 'router.stdout.log')}" 2>> "${join(logsDir, 'router.stderr.log')}"`,
+    '',
+  ].join('\r\n');
+}
+
+function runSchtasks(args, { ignoreStatus = false } = {}) {
+  // spawnSync (not execSync) because paths like `C:\Users\Some Person\...`
+  // have spaces and shell re-tokenization via execSync is a quoting footgun.
+  // spawnSync with an arg array passes each arg verbatim to schtasks.exe.
+  const res = spawnSync('schtasks.exe', args, { stdio: 'pipe', encoding: 'utf-8' });
+  if (!ignoreStatus && res.status !== 0) {
+    const stderr = (res.stderr || '').toString().trim();
+    const stdout = (res.stdout || '').toString().trim();
+    throw new Error(`schtasks ${args[0]} failed (status ${res.status}): ${stderr || stdout || 'unknown error'}`);
+  }
+  return res;
+}
+
+function installTaskScheduler(venvPythonPath) {
+  const logsDir = join(homedir(), '.robot-resources', 'logs');
+  mkdirSync(logsDir, { recursive: true });
+
+  const resolvedKeys = resolveProviderEnv();
+  const envFilePath = writeEnvFile(resolvedKeys);
+  const wrapperPath = getWrapperCmdPath();
+  writeFileSync(wrapperPath, buildWrapperCmd(venvPythonPath, envFilePath, logsDir));
+
+  // /rl LIMITED is the default — explicit here for readability. /f overwrites
+  // an existing task of the same name so the install is idempotent.
+  runSchtasks([
+    '/create', '/sc', 'onlogon',
+    '/tn', TASK_NAME,
+    '/tr', `"${wrapperPath}"`,
+    '/rl', 'LIMITED',
+    '/f',
+  ]);
+
+  // Launch now so the wizard's post-install health check can hit port 3838.
+  // Best-effort — if the immediate run fails, the task is still registered
+  // and will fire at next logon.
+  runSchtasks(['/run', '/tn', TASK_NAME], { ignoreStatus: true });
+}
+
+function uninstallTaskScheduler() {
+  runSchtasks(['/end', '/tn', TASK_NAME], { ignoreStatus: true });
+  runSchtasks(['/delete', '/tn', TASK_NAME, '/f'], { ignoreStatus: true });
+  if (existsSync(getWrapperCmdPath())) unlinkSync(getWrapperCmdPath());
+}
+
+function isTaskSchedulerRunning() {
+  const res = spawnSync(
+    'schtasks.exe',
+    ['/query', '/tn', TASK_NAME, '/fo', 'LIST', '/v'],
+    { stdio: 'pipe', encoding: 'utf-8' },
+  );
+  if (res.status !== 0) return false;
+  // 0x41301 is TASK_RUNNING (HRESULT). Locale-independent — the localized
+  // "Running" / "In corso" / "実行中" string is unreliable across Windows SKUs.
+  return (res.stdout || '').includes('0x41301');
+}
+
+function isTaskSchedulerInstalled() {
+  const res = spawnSync(
+    'schtasks.exe',
+    ['/query', '/tn', TASK_NAME],
+    { stdio: 'pipe' },
+  );
+  return res.status === 0;
+}
+
 // ─── Public API ─────────────────────────────────────────────────────────────
 
 /**
@@ -331,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') {
@@ -367,6 +607,11 @@ export function installService(venvPythonPath) {
     return { type: 'systemd-user', path: getUserUnitPath() };
   }
 
+  if (process.platform === 'win32') {
+    installTaskScheduler(venvPythonPath);
+    return { type: 'schtasks', path: getWrapperCmdPath() };
+  }
+
   throw new Error(
     `Service registration not supported on ${process.platform}.\n` +
     `  Run the router manually: rr-router start`
@@ -379,10 +624,12 @@ 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();
 }
 
 /**
@@ -400,13 +647,19 @@ 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;
 }
 
@@ -415,7 +668,10 @@ 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

@@ -162,9 +162,6 @@ export async function runWizard({ nonInteractive = false } = {}) {
     if (isServiceRunning()) {
       success('Router service already running');
       results.service = true;
-    } else if (process.platform === 'win32') {
-      warn('Windows detected — automatic service not supported');
-      info('Run the router manually: rr-router start');
     } else {
       // Check port availability
       if (!isPortAvailable()) {

package/package.json

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