robot-resources 1.15.1 → 1.15.3

package/lib/detect.js

@@ -1,254 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { stripJson5 } from './json5.js';
-
-/**
- * Check if OpenClaw is installed.
- */
-export function isOpenClawInstalled() {
-  const home = homedir();
-  return existsSync(join(home, '.openclaw')) || existsSync(join(home, 'openclaw.json'));
-}
-
-/**
- * Check if the Robot Resources OpenClaw plugin is already installed.
- */
-export function isOpenClawPluginInstalled() {
-  const home = homedir();
-  const extDir = join(home, '.openclaw', 'extensions');
-  return existsSync(join(extDir, 'openclaw-plugin'))
-    || existsSync(join(extDir, 'robot-resources-router'));
-}
-
-/**
- * Check if the Robot Resources scraper OC plugin is already installed.
- */
-export function isScraperOcPluginInstalled() {
-  const home = homedir();
-  const extDir = join(home, '.openclaw', 'extensions');
-  return existsSync(join(extDir, 'robot-resources-scraper-oc-plugin'));
-}
-
-/**
- * Detect OpenClaw auth mode: 'subscription' (OAuth token) or 'apikey'.
- *
- * Subscription users authenticate via Anthropic OAuth tokens.
- * Anthropic rejects these tokens from third-party clients, so the
- * only viable routing path is the OpenClaw plugin (not HTTP proxy).
- *
- * Detection order:
- * 1. ANTHROPIC_AUTH_TOKEN env var → subscription
- * 2. openclaw.json config:
- *    a. auth.type === 'oauth' | 'subscription' → subscription
- *    b. auth.profiles.*.mode === 'token' → subscription
- *    c. gateway.auth.mode === 'token' → subscription
- *    d. providers.anthropic.authToken → subscription
- *    e. providers.anthropic.apiKey → apikey
- * 3. Default → apikey (conservative — proxy works fine)
- */
-export function getOpenClawAuthMode() {
-  // Env var is the strongest signal
-  if (process.env.ANTHROPIC_AUTH_TOKEN) return 'subscription';
-  if (process.env.ANTHROPIC_API_KEY) return 'apikey';
-
-  // Try reading openclaw.json
-  const home = homedir();
-  const candidates = [
-    join(home, '.openclaw', 'openclaw.json'),
-    join(home, 'openclaw.json'),
-  ];
-
-  for (const configPath of candidates) {
-    if (!existsSync(configPath)) continue;
-
-    try {
-      const raw = readFileSync(configPath, 'utf-8');
-      const config = JSON.parse(stripJson5(raw));
-
-      // Check explicit auth type
-      if (config.auth?.type === 'oauth' || config.auth?.type === 'subscription') {
-        return 'subscription';
-      }
-
-      // Check auth profiles (real OC config: auth.profiles["anthropic:default"].mode)
-      const profiles = config.auth?.profiles;
-      if (profiles && typeof profiles === 'object') {
-        for (const profile of Object.values(profiles)) {
-          if (profile?.mode === 'token') return 'subscription';
-        }
-      }
-
-      // Check gateway auth mode
-      if (config.gateway?.auth?.mode === 'token') return 'subscription';
-
-      // Check for authToken in providers
-      const anthropic = config.models?.providers?.anthropic
-        || config.providers?.anthropic;
-      if (anthropic?.authToken) return 'subscription';
-      if (anthropic?.apiKey) return 'apikey';
-    } catch {
-      // Config unreadable — fall through
-    }
-  }
-
-  return 'apikey';
-}
-
-/**
- * Detect if the environment is headless (no browser available).
- * On headless servers, login() tries xdg-open which fails silently,
- * then hangs for 120s waiting for a callback that never comes.
- */
-export function isHeadless() {
-  // SSH session — no local browser
-  if (process.env.SSH_CONNECTION || process.env.SSH_CLIENT) return true;
-  // Linux without a display server
-  if (process.platform === 'linux' && !process.env.DISPLAY && !process.env.WAYLAND_DISPLAY) return true;
-  // Docker / container
-  if (process.env.container || process.env.DOCKER_CONTAINER) return true;
-  return false;
-}
-
-/**
- * Check if Claude Code is installed.
- * Looks for ~/.claude/ directory which Claude Code creates on first run.
- */
-export function isClaudeCodeInstalled() {
-  return existsSync(join(homedir(), '.claude'));
-}
-
-/**
- * Check if Cursor is installed.
- * Looks for ~/.cursor/ directory which Cursor creates on first run.
- */
-export function isCursorInstalled() {
-  return existsSync(join(homedir(), '.cursor'));
-}
-
-// ── Agent-runtime detection (Phase 3) ─────────────────────────────────────
-//
-// Used by the non-OC wizard to pick which shim to install: a NODE_OPTIONS
-// shell line for Node agents, or `pip install robot-resources` for Python.
-// Returns { kind: 'node'|'python'|null, evidence: string[] } so the wizard
-// can show the user WHY we picked a path (debuggable + builds trust).
-//
-// "Evidence" is the dep markers we found, in priority order. Empty string
-// means a generic project (e.g. just package.json, no LLM SDK deps yet) —
-// still picks the language but with low confidence.
-
-// Exported (Phase 11.1) so the SDK-import scanner in source-edit-attach.js
-// can reuse the same canonical list — single source of truth for "which npm
-// packages count as an AI SDK signal."
-export const NODE_AGENT_DEPS = [
-  '@anthropic-ai/sdk',
-  'openai',
-  '@google/generative-ai',
-  '@google-ai/generativelanguage',
-  'langchain',
-  '@langchain/core',
-  '@langchain/anthropic',
-  '@langchain/openai',
-  '@langchain/google-genai',
-  '@langchain/langgraph',
-  '@mastra/core',
-  'crewai-js',
-  'llamaindex',
-  'ai', // Vercel AI SDK
-];
-
-const PYTHON_AGENT_DEPS = [
-  'anthropic',
-  'openai',
-  'google-generativeai',
-  'langchain',
-  'langchain-anthropic',
-  'langchain-openai',
-  'langchain-google-genai',
-  'langgraph',
-  'crewai',
-  'llama-index',
-  'llama_index',
-];
-
-/**
- * Inspect cwd for evidence of a Node agent project. Returns null if no
- * package.json, or `{ evidence: [...] }` describing matched dep markers
- * (empty list means "Node project but no LLM-SDK deps detected" — generic).
- */
-export function detectNodeAgent(cwd = process.cwd()) {
-  const pkgPath = join(cwd, 'package.json');
-  if (!existsSync(pkgPath)) return null;
-
-  try {
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
-    const allDeps = {
-      ...(pkg.dependencies ?? {}),
-      ...(pkg.devDependencies ?? {}),
-      ...(pkg.peerDependencies ?? {}),
-    };
-    const evidence = NODE_AGENT_DEPS.filter(
-      (d) => Object.prototype.hasOwnProperty.call(allDeps, d),
-    );
-    return { evidence };
-  } catch {
-    // package.json unreadable but exists — call it Node, no evidence
-    return { evidence: [] };
-  }
-}
-
-/**
- * Inspect cwd for evidence of a Python agent project. Looks at
- * requirements.txt + pyproject.toml. Returns null if neither exists, or
- * `{ evidence: [...] }`. Empty evidence still resolves to Python — many
- * agent projects use ad-hoc deps not in our markers list.
- */
-export function detectPythonAgent(cwd = process.cwd()) {
-  const reqPath = join(cwd, 'requirements.txt');
-  const pyProjPath = join(cwd, 'pyproject.toml');
-  const hasReq = existsSync(reqPath);
-  const hasPy = existsSync(pyProjPath);
-  if (!hasReq && !hasPy) return null;
-
-  const text = [
-    hasReq ? safeRead(reqPath) : '',
-    hasPy ? safeRead(pyProjPath) : '',
-  ].join('\n').toLowerCase();
-
-  const evidence = PYTHON_AGENT_DEPS.filter((d) => {
-    // Match `dep`, `dep==`, `dep>=`, `dep[extras]`, or `"dep"`/`'dep'` in
-    // pyproject's dependencies array. Word-boundary on the left, anything
-    // version-ish on the right.
-    const escaped = d.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-    const re = new RegExp(`(^|[\\s"'\\[])${escaped}(\\s|[<>=!~\\["',]|$)`, 'm');
-    return re.test(text);
-  });
-
-  return { evidence };
-}
-
-function safeRead(path) {
-  try { return readFileSync(path, 'utf-8'); } catch { return ''; }
-}
-
-/**
- * Decide which shim to install when OpenClaw is NOT detected. Picks Node OR
- * Python based on cwd shape. When BOTH are present (full-stack monorepo
- * with package.json AND pyproject.toml) the caller is responsible for
- * resolving the ambiguity (interactively, or default to JS in --yes mode
- * per the team decision in the plan).
- *
- * Returns one of:
- *   { kind: 'node',   evidence: [...] }
- *   { kind: 'python', evidence: [...] }
- *   { kind: 'both',   node: {...}, python: {...} }
- *   { kind: null }     — unknown project shape, no clear path
- */
-export function detectAgentRuntime(cwd = process.cwd()) {
-  const node = detectNodeAgent(cwd);
-  const python = detectPythonAgent(cwd);
-  if (node && python) return { kind: 'both', node, python };
-  if (node) return { kind: 'node', evidence: node.evidence };
-  if (python) return { kind: 'python', evidence: python.evidence };
-  return { kind: null };
-}

package/lib/health-report.js

@@ -1,130 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { readConfig } from './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 robot-resources-router 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 hasRouter = !!ocConfig?.plugins?.entries?.['robot-resources-router']?.enabled;
-    const hasScraper = !!ocConfig?.plugins?.entries?.['robot-resources-scraper-oc-plugin']?.enabled;
-
-    if (hasRouter && hasScraper) {
-      return { healthy: true, detail: 'plugins registered' };
-    }
-    if (!hasRouter && !hasScraper) {
-      return { healthy: false, detail: 'router + scraper plugins not registered' };
-    }
-    const missing = !hasRouter ? 'robot-resources-router' : 'robot-resources-scraper-oc-plugin';
-    return { healthy: false, detail: `${missing} not registered` };
-  } catch {
-    return { healthy: false, detail: 'openclaw.json not found' };
-  }
-}

package/lib/install-node-shim.js

@@ -1,188 +0,0 @@
-import { writeShellLine, hasShellLine } from './shell-config.js';
-import { readConfig } from './config.mjs';
-import { detectNodeAgent } from './detect.js';
-import { installRouterFiles } from './install-router-files.js';
-import { writePersistedNodeOptions } from './windows-env.js';
-
-const PLATFORM_URL = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
-
-/**
- * Install the Node shim into the user's shell config (POSIX) or user
- * environment registry (Windows).
- *
- * POSIX path (Phases 3 + 8):
- *   1. Copy `@robot-resources/router` to ~/.robot-resources/router/
- *      (absolute path; survives cwd changes + npm/npx cache cleanup).
- *   2. Append marker block with `--require <abs path>` to detected rc files
- *      (zsh / bash / fish).
- *
- * Windows path (Phase 9):
- *   1. Same router-files copy — `homedir()` is platform-aware.
- *   2. `setx NODE_OPTIONS "..."` writes to HKCU\\Environment so every new
- *      cmd / PowerShell / Win+R-launched Node process inherits it.
- *
- * Both paths emit `node_shim_installed` telemetry. The user has to open a
- * new terminal for the change to take effect.
- *
- * Returns a UI-friendly result the wizard can format and print.
- */
-export async function installNodeShim({ cwd = process.cwd(), dryRun = false } = {}) {
-  const sdks = detectSdks(cwd);
-
-  if (dryRun) {
-    await emit({
-      shell: 'dryrun',
-      shell_config_path: null,
-      sdks_detected: sdks,
-      dry_run: true,
-      reason: null,
-    });
-    return { ok: true, message: 'Dry-run: would have written NODE_OPTIONS.' };
-  }
-
-  // Phase 8: copy router to an absolute path under ~/.robot-resources/router/
-  // before we wire the env config. If the copy fails, we don't write a
-  // broken NODE_OPTIONS line on either platform.
-  let autoPath;
-  try {
-    autoPath = installRouterFiles();
-  } catch (err) {
-    await emit({
-      shell: process.platform === 'win32' ? 'win32' : 'unknown',
-      shell_config_path: null,
-      sdks_detected: sdks,
-      dry_run: false,
-      reason: 'router_copy_failed',
-      error_messages: [err.message],
-    });
-    return {
-      ok: false,
-      message: `Could not copy router files to ~/.robot-resources/router/: ${err.message}`,
-    };
-  }
-
-  // Windows branch — Phase 9. Mirrors the POSIX flow in shape: detect
-  // already-installed via the persisted registry value, write via setx,
-  // emit equivalent telemetry.
-  if (process.platform === 'win32') {
-    const winResult = writePersistedNodeOptions({ autoPath });
-    await emit({
-      shell: 'win32',
-      shell_config_path: 'HKCU\\Environment\\NODE_OPTIONS',
-      sdks_detected: sdks,
-      dry_run: false,
-      already_installed: !!winResult.already,
-      files_written: winResult.ok && !winResult.already ? 1 : 0,
-      files_with_errors: winResult.ok ? 0 : 1,
-      error_messages: winResult.ok ? [] : [winResult.error_message || winResult.reason || 'unknown'],
-      auto_path: autoPath,
-      win_node_options_length: winResult.length,
-      reason: winResult.ok ? null : winResult.reason,
-    });
-    if (winResult.ok && winResult.already) {
-      return {
-        ok: true,
-        already: true,
-        message: 'NODE_OPTIONS already includes the auto-attach line. No changes made.',
-      };
-    }
-    if (!winResult.ok) {
-      return {
-        ok: false,
-        reason: winResult.reason,
-        message: `Could not set NODE_OPTIONS via setx (${winResult.reason}): ${winResult.error_message || ''}`,
-      };
-    }
-    return {
-      ok: true,
-      written: ['HKCU\\Environment\\NODE_OPTIONS'],
-      errors: [],
-      message:
-        'Set NODE_OPTIONS in your user environment (HKCU\\Environment). ' +
-        'Open a new terminal for it to take effect. Existing terminals will not see the change.',
-    };
-  }
-
-  const alreadyInstalled = hasShellLine();
-  const result = writeShellLine({ autoPath });
-
-  // Single shell value for the funnel even though we may have written to
-  // multiple rc files. Pick the dominant one for telemetry.
-  const dominant = pickDominantShell(result.written);
-
-  await emit({
-    shell: dominant,
-    shell_config_path: result.written.join(','),
-    sdks_detected: sdks,
-    dry_run: false,
-    already_installed: alreadyInstalled,
-    files_written: result.written.length,
-    files_with_errors: result.errors.length,
-    error_messages: result.errors.map((e) => `${e.path}: ${e.message}`).slice(0, 3),
-    auto_path: autoPath,
-  });
-
-  if (alreadyInstalled && result.written.length === 0) {
-    return {
-      ok: true,
-      already: true,
-      message: 'NODE_OPTIONS auto-attach already installed. No changes made.',
-    };
-  }
-
-  if (result.written.length === 0 && result.errors.length > 0) {
-    return {
-      ok: false,
-      message: `Could not write to any shell rc file. Errors: ${result.errors.map((e) => e.message).join(', ')}`,
-    };
-  }
-
-  return {
-    ok: true,
-    written: result.written,
-    errors: result.errors,
-    message:
-      `Installed NODE_OPTIONS auto-attach in ${result.written.length} shell file(s). ` +
-      'Open a new terminal (or source the file) for it to take effect.',
-  };
-}
-
-function detectSdks(cwd) {
-  const result = detectNodeAgent(cwd);
-  return result?.evidence ?? [];
-}
-
-function pickDominantShell(paths) {
-  // Use process.env.SHELL as the tiebreaker — that's the user's actual
-  // login shell. Fall back to the first written file's basename.
-  const shellEnv = (process.env.SHELL || '').toLowerCase();
-  if (shellEnv.includes('zsh')) return 'zsh';
-  if (shellEnv.includes('fish')) return 'fish';
-  if (shellEnv.includes('bash')) return 'bash';
-  if (paths[0]?.endsWith('.zshrc')) return 'zsh';
-  if (paths[0]?.endsWith('.bashrc') || paths[0]?.endsWith('.bash_profile')) return 'bash';
-  if (paths[0]?.endsWith('config.fish')) return 'fish';
-  return 'unknown';
-}
-
-async function emit(payload) {
-  const config = readConfig();
-  if (!config.api_key) return;
-  try {
-    await fetch(`${PLATFORM_URL}/v1/telemetry`, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${config.api_key}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        product: 'cli',
-        event_type: 'node_shim_installed',
-        payload: { ...payload, platform: process.platform },
-      }),
-      signal: AbortSignal.timeout(5_000),
-    });
-  } catch {
-    // Best-effort — never let telemetry break the install path.
-  }
-}

package/lib/install-python-shim.js

@@ -1,107 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { detectVenv, runPipInstall } from './venv-detect.js';
-import { readConfig } from './config.mjs';
-import { detectPythonAgent } from './detect.js';
-
-const PLATFORM_URL = process.env.RR_PLATFORM_URL || 'https://api.robotresources.ai';
-
-/**
- * Install the Python shim into the user's active/cwd venv. Phase 3 entry
- * for the non-OC Python path.
- *
- * Steps:
- *   1. Resolve Python via detectVenv. Bail with `confidence: 'low'` if we
- *      can't find a venv — we never `pip install` into system Python (can
- *      break OS Python on Linux).
- *   2. Run `pip install --upgrade robot-resources`. Captures exit code +
- *      stderr tail for telemetry.
- *   3. Emit `python_shim_installed` telemetry with venv kind, Python
- *      version, detected SDK markers, pip exit code.
- *
- * Returns a UI-friendly result the wizard can format and print. Never
- * throws — any unexpected error becomes a structured `{ ok: false, ... }`.
- */
-export async function installPythonShim({ cwd = process.cwd() } = {}) {
-  const venv = detectVenv(cwd);
-
-  if (!venv.python) {
-    await emit({
-      kind: 'none',
-      python_version: null,
-      sdks_detected: detectSdks(cwd),
-      pip_exit_code: null,
-      reason: 'no_venv_found',
-    });
-    return {
-      ok: false,
-      reason: 'no_venv_found',
-      message:
-        'No active venv or ./.venv detected. Activate your venv first ' +
-        '(source .venv/bin/activate) or pass --python=/path/to/python, ' +
-        'then re-run.',
-    };
-  }
-
-  const pipResult = runPipInstall({
-    python: venv.python,
-    packageSpec: 'robot-resources>=0.2.0',
-  });
-
-  const pythonVersion = readPythonVersion(venv.python);
-  const sdks = detectSdks(cwd);
-
-  await emit({
-    kind: venv.kind,
-    python_version: pythonVersion,
-    sdks_detected: sdks,
-    pip_exit_code: pipResult.code,
-    pip_stderr_tail: pipResult.ok ? null : pipResult.stderr,
-  });
-
-  return {
-    ok: pipResult.ok,
-    venv,
-    pythonVersion,
-    sdks,
-    pipResult,
-    message: pipResult.ok
-      ? `Installed robot-resources into ${venv.kind} venv (${venv.python})`
-      : `pip install failed (exit ${pipResult.code}): ${pipResult.stderr.slice(0, 200)}`,
-  };
-}
-
-function detectSdks(cwd) {
-  const result = detectPythonAgent(cwd);
-  return result?.evidence ?? [];
-}
-
-function readPythonVersion(python) {
-  try {
-    const r = spawnSync(python, ['--version'], { encoding: 'utf-8' });
-    return (r.stdout || r.stderr || '').trim().replace(/^Python\s+/, '');
-  } catch {
-    return null;
-  }
-}
-
-async function emit(payload) {
-  const config = readConfig();
-  if (!config.api_key) return;
-  try {
-    await fetch(`${PLATFORM_URL}/v1/telemetry`, {
-      method: 'POST',
-      headers: {
-        'Authorization': `Bearer ${config.api_key}`,
-        'Content-Type': 'application/json',
-      },
-      body: JSON.stringify({
-        product: 'cli',
-        event_type: 'python_shim_installed',
-        payload: { ...payload, platform: process.platform },
-      }),
-      signal: AbortSignal.timeout(5_000),
-    });
-  } catch {
-    // Best-effort — never let telemetry break the install path.
-  }
-}