robot-resources 1.7.1 → 1.7.3

package/lib/health-report.js

@@ -0,0 +1,124 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { readConfig } from '@robot-resources/cli-core/config.mjs';
+
+const PROBE_TIMEOUT_MS = 5_000;
+
+/**
+ * Run post-install health checks against all Robot Resources components.
+ *
+ * Probes:
+ *  1. Router   — GET http://127.0.0.1:3838/health
+ *  2. Scraper  — check openclaw.json for scraper MCP registration
+ *  3. Platform — GET {platformUrl}/v1/health with api_key
+ *  4. MCP      — check openclaw.json for openclaw-plugin registration
+ *
+ * @returns {{ status: 'healthy'|'partial'|'failed', components: Object, summary: string }}
+ */
+export async function checkHealth() {
+  const config = readConfig();
+
+  const [router, scraper, platform, mcp] = await Promise.all([
+    probeRouter(),
+    probeScraper(),
+    probePlatform(config),
+    probeMcp(),
+  ]);
+
+  const components = { router, scraper, platform, mcp };
+  const healthyCount = Object.values(components).filter((c) => c.healthy).length;
+  const total = Object.keys(components).length;
+
+  let status;
+  if (healthyCount === total) {
+    status = 'healthy';
+  } else if (healthyCount === 0) {
+    status = 'failed';
+  } else {
+    status = 'partial';
+  }
+
+  const failing = Object.entries(components)
+    .filter(([, c]) => !c.healthy)
+    .map(([name, c]) => `${name}: ${c.detail}`);
+
+  const summary =
+    status === 'healthy'
+      ? `All ${total} components healthy.`
+      : `${healthyCount}/${total} healthy. Issues: ${failing.join('; ')}`;
+
+  return { status, components, summary };
+}
+
+async function probeRouter() {
+  try {
+    if (typeof fetch === 'undefined') {
+      return { healthy: false, detail: 'fetch unavailable' };
+    }
+    const res = await fetch('http://127.0.0.1:3838/health', {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+      return { healthy: false, detail: `HTTP ${res.status}` };
+    }
+    const data = await res.json();
+    if (data.status === 'healthy' || data.status === 'degraded') {
+      return { healthy: true, detail: `running (v${data.version || 'unknown'})` };
+    }
+    return { healthy: false, detail: `status: ${data.status}` };
+  } catch (err) {
+    const detail = err.name === 'AbortError' ? 'timeout' : 'unreachable';
+    return { healthy: false, detail };
+  }
+}
+
+function probeScraper() {
+  try {
+    const ocPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const ocConfig = JSON.parse(readFileSync(ocPath, 'utf-8'));
+    const hasServer = !!ocConfig?.mcp?.servers?.['robot-resources-scraper'];
+    return {
+      healthy: hasServer,
+      detail: hasServer ? 'MCP registered' : 'scraper MCP not registered',
+    };
+  } catch {
+    return { healthy: false, detail: 'openclaw.json not found' };
+  }
+}
+
+async function probePlatform(config) {
+  if (!config.api_key) {
+    return { healthy: false, detail: 'no API key configured' };
+  }
+  try {
+    if (typeof fetch === 'undefined') {
+      return { healthy: false, detail: 'fetch unavailable' };
+    }
+    const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
+    const res = await fetch(`${platformUrl}/health`, {
+      signal: AbortSignal.timeout(PROBE_TIMEOUT_MS),
+    });
+    return {
+      healthy: res.ok,
+      detail: res.ok ? 'reachable' : `HTTP ${res.status}`,
+    };
+  } catch (err) {
+    const detail = err.name === 'AbortError' ? 'timeout' : 'unreachable';
+    return { healthy: false, detail };
+  }
+}
+
+function probeMcp() {
+  try {
+    const ocPath = join(homedir(), '.openclaw', 'openclaw.json');
+    const ocConfig = JSON.parse(readFileSync(ocPath, 'utf-8'));
+    const hasPlugin = !!ocConfig?.plugins?.entries?.['openclaw-plugin']?.enabled;
+    return {
+      healthy: hasPlugin,
+      detail: hasPlugin ? 'plugin registered' : 'openclaw-plugin not registered',
+    };
+  } catch {
+    return { healthy: false, detail: 'openclaw.json not found' };
+  }
+}

package/lib/machine-id.js

@@ -0,0 +1,31 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomUUID } from 'node:crypto';
+
+/**
+ * Reads or creates a persistent machine identifier.
+ * Used for telemetry deduplication across sessions.
+ *
+ * @param {string} [configDir] - Directory to store .machine-id (defaults to ~/.robot-resources)
+ * @returns {string} A UUID v4 machine identifier
+ */
+export function getOrCreateMachineId(configDir) {
+  const dir = configDir ?? join(homedir(), '.robot-resources');
+  const machineIdPath = join(dir, '.machine-id');
+
+  try {
+    const stored = readFileSync(machineIdPath, 'utf-8').trim();
+    if (stored) return stored;
+  } catch {
+    // File doesn't exist or can't be read — fall through to generate
+  }
+
+  const machineId = randomUUID();
+  try {
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(machineIdPath, machineId, 'utf-8');
+  } catch { /* non-fatal */ }
+
+  return machineId;
+}

package/lib/tool-config.js

@@ -1,77 +1,58 @@
 import { spawn } from 'node:child_process';
 import { createRequire } from 'node:module';
-import { readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, dirname } from 'node:path';
 import { isOpenClawInstalled, isOpenClawPluginInstalled, getOpenClawAuthMode } from './detect.js';
 import { stripJson5 } from './json5.js';
 
 /**
- * Run a command with a heartbeat to keep agent sessions alive.
- * OC kills processes after 5s of no output (noOutputTimeoutMs).
- * Prints immediately, then every 4s (safely under the 5s threshold).
+ * Read openclaw.json, creating it with a minimal structure if it doesn't exist.
+ * Returns parsed config object. Throws on malformed JSON (caller handles).
  */
-function spawnWithHeartbeat(cmd, args, { label, timeout = 30_000 } = {}) {
-  return new Promise((resolve, reject) => {
-    const proc = spawn(cmd, args, {
-      stdio: ['ignore', 'pipe', 'pipe'],
-      timeout,
-    });
-
-    process.stdout.write(`  ${label}...\n`);
-    let seconds = 0;
-    const heartbeat = setInterval(() => {
-      seconds += 4;
-      process.stdout.write(`  ${label}... ${seconds}s\n`);
-    }, 4000);
-
-    proc.on('close', (code) => {
-      clearInterval(heartbeat);
-      if (code === 0) resolve();
-      else reject(new Error(`${cmd} ${args.join(' ')} exited with code ${code}`));
-    });
-
-    proc.on('error', (err) => {
-      clearInterval(heartbeat);
-      reject(err);
-    });
-  });
+function readOrCreateOpenClawConfig() {
+  const configDir = join(homedir(), '.openclaw');
+  const configPath = join(configDir, 'openclaw.json');
+
+  if (!existsSync(configPath)) {
+    mkdirSync(configDir, { recursive: true });
+    const minimal = {};
+    writeFileSync(configPath, JSON.stringify(minimal, null, 2) + '\n', 'utf-8');
+    return minimal;
+  }
+
+  const raw = readFileSync(configPath, 'utf-8');
+  return JSON.parse(stripJson5(raw));
 }
 
 /**
- * Set robot-resources/auto as the default model in openclaw.json.
+ * Trust the Robot Resources plugin in OpenClaw config.
  *
- * This is required so the plugin's before_model_resolve hook fires.
- * Without it, OpenClaw sends requests directly to Anthropic and the
- * plugin never gets a chance to route.
+ * Adds "openclaw-plugin" to plugins.allow so OpenClaw loads it without
+ * provenance warnings. The plugin's before_model_resolve hook intercepts
+ * ALL LLM calls regardless of the default model — no need to change the
+ * default model (which causes LiveSessionModelSwitchError in OC).
  *
  * Returns true if the config was updated, false otherwise.
  */
-function activateRouterModel() {
+function trustPlugin() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
-
-    // Ensure agents.defaults.model exists
-    if (!config.agents) config.agents = {};
-    if (!config.agents.defaults) config.agents.defaults = {};
-    if (!config.agents.defaults.model) config.agents.defaults.model = {};
+    const config = readOrCreateOpenClawConfig();
 
-    const currentPrimary = config.agents.defaults.model.primary;
+    if (!config.plugins) config.plugins = {};
+    if (!Array.isArray(config.plugins.allow)) config.plugins.allow = [];
 
-    // Only change if not already pointing at robot-resources
-    if (currentPrimary && currentPrimary.startsWith('robot-resources/')) {
+    if (config.plugins.allow.includes('openclaw-plugin')) {
       return false;
     }
 
-    config.agents.defaults.model.primary = 'robot-resources/auto';
+    config.plugins.allow.push('openclaw-plugin');
 
     writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
     return true;
   } catch {
-    // Config missing or malformed — non-fatal
     return false;
   }
 }
@@ -89,8 +70,7 @@ function registerScraperMcp() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
+    const config = readOrCreateOpenClawConfig();
 
     if (!config.mcp) config.mcp = {};
     if (!config.mcp.servers) config.mcp.servers = {};
@@ -141,8 +121,7 @@ function registerPluginEntry() {
   const configPath = join(homedir(), '.openclaw', 'openclaw.json');
 
   try {
-    const raw = readFileSync(configPath, 'utf-8');
-    const config = JSON.parse(stripJson5(raw));
+    const config = readOrCreateOpenClawConfig();
 
     if (!config.plugins) config.plugins = {};
     if (!config.plugins.entries) config.plugins.entries = {};
@@ -188,9 +167,8 @@ function configureOpenClaw() {
     // Register plugin in openclaw.json so OC loads it on gateway start.
     registerPluginEntry();
 
-    // Set robot-resources/auto as the default model so the plugin's
-    // before_model_resolve hook actually fires for every request.
-    const configActivated = activateRouterModel();
+    // Trust the plugin so OC loads it without provenance warnings.
+    const configActivated = trustPlugin();
 
     return {
       name: 'OpenClaw',
@@ -245,13 +223,20 @@ export function configureToolRouting() {
 
 /**
  * Restart the OpenClaw gateway so it picks up new plugin + config.
- * Uses heartbeat to keep OC sessions alive during the restart.
+ * Spawns a detached process that waits 3s then restarts — lets the wizard
+ * finish and return output to OC before the gateway dies.
+ *
+ * If called from inside an OC agent session (exec: npx robot-resources),
+ * a synchronous restart kills the session before output is captured.
+ * The deferred approach avoids this: wizard exits → OC captures output →
+ * 3s later gateway restarts → next conversation has all tools loaded.
  */
 async function restartOpenClawGateway() {
-  await spawnWithHeartbeat('openclaw', ['gateway', 'restart'], {
-    label: 'Restarting gateway',
-    timeout: 15_000,
-  });
+  spawn('sh', ['-c', 'sleep 3 && openclaw gateway restart'], {
+    stdio: 'ignore',
+    detached: true,
+  }).unref();
+  process.stdout.write('  Restarting gateway...\n');
 }
 
 // Exported for testing and direct use

package/lib/wizard.js

@@ -1,8 +1,13 @@
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir, hostname } 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';
 import { setupRouter, isRouterInstalled, getVenvPythonPath } from './python-bridge.js';
 import { installService, isServiceRunning, isServiceInstalled } from './service.js';
 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';
 /**
  * Main setup wizard. Handles the full onboarding flow:
@@ -36,24 +41,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
     const config = readConfig();
     if (!config.api_key && !process.env.RR_API_KEY) {
       try {
-        const { hostname } = await import('node:os');
-        const { join } = await import('node:path');
-        const { homedir } = await import('node:os');
-        const { readFileSync, writeFileSync, mkdirSync } = await import('node:fs');
-        const { randomUUID } = await import('node:crypto');
-
-        const rrDir = join(homedir(), '.robot-resources');
-        const machineIdPath = join(rrDir, '.machine-id');
-        let machineId;
-        try {
-          machineId = readFileSync(machineIdPath, 'utf-8').trim();
-        } catch {
-          machineId = randomUUID();
-          try {
-            mkdirSync(rrDir, { recursive: true });
-            writeFileSync(machineIdPath, machineId, 'utf-8');
-          } catch { /* non-fatal */ }
-        }
+        const machineId = getOrCreateMachineId();
 
         const platformUrl = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
         const res = await fetch(`${platformUrl}/v1/auth/signup`, {
@@ -184,7 +172,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
           success(`${r.name}: already configured`);
         } else if (r.action === 'installed') {
           success(`${r.name}: plugin installed`);
-          if (r.configActivated) success(`${r.name}: default model set to robot-resources/auto`);
+          if (r.configActivated) success(`${r.name}: plugin trusted in openclaw.json`);
           if (r.note) info(`  ${r.note}`);
         } else if (r.action === 'instructions') {
           warn(`${r.name}: manual configuration needed:`);
@@ -218,10 +206,7 @@ export async function runWizard({ nonInteractive = false } = {}) {
   } else {
     // Either already registered, or no openclaw.json
     try {
-      const { readFileSync: readFs } = await import('node:fs');
-      const { join: joinPath } = await import('node:path');
-      const { homedir: home } = await import('node:os');
-      const ocConfig = JSON.parse(readFs(joinPath(home(), '.openclaw', 'openclaw.json'), 'utf-8'));
+      const ocConfig = JSON.parse(readFileSync(join(homedir(), '.openclaw', 'openclaw.json'), 'utf-8'));
       if (ocConfig?.mcp?.servers?.['robot-resources-scraper']) {
         success('Scraper MCP already registered in OpenClaw');
         results.scraper = true;
@@ -354,17 +339,52 @@ export async function runWizard({ nonInteractive = false } = {}) {
     blank();
   }
 
+  // ── Best-effort: Single gateway restart ────────────────────────────────
+  //
+  // Merged from two previous restarts (after plugin install + after scraper
+  // registration). Everything is already installed and registered above.
+  // If the session dies during this restart, the gateway picks up changes
+  // on its next natural restart.
+
+  if (isOpenClawInstalled() && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
+    try {
+      await restartOpenClawGateway();
+      success('Gateway restart scheduled — tools available in next conversation');
+    } catch {
+      warn('Gateway restart failed — tools may not be available until OpenClaw restarts.');
+      warn('Run manually: openclaw gateway restart');
+    }
+  }
+
+  // ── Post-install health check ──────────────────────────────────────────
+
+  let healthReport = null;
+  if (somethingInstalled) {
+    try {
+      blank();
+      step('Running post-install health check...');
+      healthReport = await checkHealth();
+
+      if (healthReport.status === 'healthy') {
+        success(`Health: all components healthy`);
+      } else if (healthReport.status === 'partial') {
+        warn(`Health: ${healthReport.summary}`);
+      } else {
+        error(`Health: ${healthReport.summary}`);
+      }
+    } catch {
+      // Non-fatal — health check is informational
+    }
+  }
+
   // ── Status file (persists results for agents that lose the session) ─────
 
   if (somethingInstalled) {
     try {
-      const { readFileSync: readFs, writeFileSync: writeFs, mkdirSync: mkFs } = await import('node:fs');
-      const { join: joinP } = await import('node:path');
-      const { homedir: homeP } = await import('node:os');
-      const statusDir = joinP(homeP(), '.robot-resources');
-      mkFs(statusDir, { recursive: true });
-      const pkgVersion = JSON.parse(readFs(new URL('../package.json', import.meta.url), 'utf-8')).version;
-      writeFs(joinP(statusDir, 'wizard-status.json'), JSON.stringify({
+      const statusDir = join(homedir(), '.robot-resources');
+      mkdirSync(statusDir, { recursive: true });
+      const pkgVersion = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8')).version;
+      writeFileSync(join(statusDir, 'wizard-status.json'), JSON.stringify({
         completed_at: new Date().toISOString(),
         version: pkgVersion,
         router: results.router || false,
@@ -372,25 +392,10 @@ export async function runWizard({ nonInteractive = false } = {}) {
         scraper: results.scraper || false,
         plugin: results.tools?.some(r => r.action === 'installed') || false,
         claim_url: results.claimUrl || readConfig().claim_url || null,
-      }, null, 2) + '\n', 'utf-8');
+        health_report: healthReport || null,
+      }, null, 2) + '\n', { mode: 0o600, encoding: 'utf-8' });
     } catch {
       // Non-fatal — status file is a convenience, not required
     }
   }
-
-  // ── Best-effort: Single gateway restart ────────────────────────────────
-  //
-  // Merged from two previous restarts (after plugin install + after scraper
-  // registration). Everything is already installed and registered above.
-  // If the session dies during this restart, the gateway picks up changes
-  // on its next natural restart.
-
-  if (isOpenClawInstalled() && (results.tools?.some(r => r.action === 'installed') || scraperRegistered)) {
-    try {
-      await restartOpenClawGateway();
-      success('OpenClaw gateway restarted');
-    } catch {
-      // Best-effort — gateway picks up changes on next restart
-    }
-  }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "robot-resources",
-  "version": "1.7.1",
-  "description": "Robot Resources — AI agent runtime tools. One command to install everything.",
+  "version": "1.7.3",
+  "description": "Robot Resources — AI agent tools. One command to install everything.",
   "type": "module",
   "bin": {
     "robot-resources-setup": "./bin/setup.js"