robot-resources 0.0.1 → 1.0.0

package/README.md

@@ -1,11 +1,73 @@
-# Robot Resources
+# robot-resources — Unified Installer
 
-AI agent runtime infrastructure.
+One command to install all Robot Resources tools:
 
-## Coming Soon
+```
+npx robot-resources
+```
 
-This package is under active development. Stay tuned for updates.
+## What the wizard does
 
-## Contact
+1. **GitHub OAuth** — authenticates via PKCE, saves API key to `~/.robot-resources/config.json`
+2. **Router install** — detects Python 3.10+, creates venv, pip installs `robot-resources-router`
+3. **Service registration** — registers router as launchd (macOS) or systemd (Linux) service
+4. **MCP auto-config** — detects Claude Desktop and Cursor, injects scraper MCP entry
 
-For inquiries, reach out to the Robot Resources Team.
+## Adding a new tool
+
+When you build a new product for RR, follow this checklist:
+
+### 1. Create the npx entry point
+
+Your tool needs an npm package with a `bin` entry that runs a setup wizard. Two patterns:
+
+- **Node.js tool:** Add `bin` to your package.json pointing to a setup script
+- **Python tool:** Create a thin npm wrapper (like `router/packages/router/`) that handles pip install
+
+The wizard should:
+- Check `~/.robot-resources/config.json` — offer login if missing
+- Install the tool
+- Configure MCP if applicable
+- Print usage instructions
+
+### 2. Update the unified wizard
+
+Edit `packages/cli/lib/wizard.js` to add your tool as a new step between service registration and MCP config.
+
+### 3. Update the landing page
+
+| File | What to change |
+|------|---------------|
+| `web/src/pages/Landing/types.ts` | Add install subsection if new section |
+| `web/src/pages/Landing/components/ContentPanel/animatedContentScreens.ts` | Add install screen (desktop + mobile) |
+| `web/src/pages/Landing/components/TerminalPanel/terminalCommands.ts` | Add install subcommand output |
+
+### 4. Update agent-facing content
+
+| File | What to change |
+|------|---------------|
+| `web/public/llms.txt` | Add tool with `npx @robot-resources/<tool>` |
+| `web/public/llms-full.txt` | Add detailed section with npx install |
+| `web/public/.well-known/ai-resources.json` | Add SoftwareApplication entry with InstallAction |
+
+### 5. Update the publish workflow
+
+Add your package.json path to `.github/workflows/publish.yml` triggers and add a publish step.
+
+### 6. Add to root workspaces
+
+Add your package directory to the `workspaces` array in the root `package.json`.
+
+## Architecture
+
+```
+packages/cli-core/    Shared auth, config, login (private — never published)
+packages/cli/         This package (published as "robot-resources" on npm)
+  bin/setup.js        Entry point
+  lib/wizard.js       Orchestrator — add new tools here
+  lib/service.js      launchd + systemd service registration
+  lib/mcp-config.js   Agent detection + MCP JSON patching
+  lib/python-bridge.js  Python venv management
+  lib/detect.js       Environment detection
+  lib/ui.js           Terminal formatting
+```

package/bin/setup.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { runWizard } from '../lib/wizard.js';
+
+const args = process.argv.slice(2);
+const nonInteractive = args.includes('--non-interactive') || args.includes('--yes') || args.includes('-y');
+
+runWizard({ nonInteractive }).catch((err) => {
+  console.error(`\n  ✗ Setup failed: ${err.message}\n`);
+  process.exit(1);
+});

package/lib/detect.js

@@ -0,0 +1,85 @@
+import { execSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+// Re-export findPython from the shared cli-core implementation.
+export { findPython } from '@robot-resources/cli-core/python-bridge.mjs';
+
+import { getVenvPython, MANAGED_VENV_DIR } from '@robot-resources/cli-core/python-bridge.mjs';
+
+/**
+ * Check if the router venv exists and has the package installed.
+ * Returns { venvDir, venvPython } or null.
+ */
+export function checkRouterVenv() {
+  const venvPython = getVenvPython();
+
+  if (!existsSync(venvPython)) return null;
+
+  try {
+    execSync(`"${venvPython}" -c "import robot_resources" 2>&1`, { encoding: 'utf-8' });
+    return { venvDir: MANAGED_VENV_DIR, venvPython };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Detect installed AI agents by checking their config file locations.
+ */
+export function detectAgents() {
+  const home = homedir();
+  const agents = [];
+
+  const known = [
+    {
+      name: 'Claude Desktop',
+      configPath: process.platform === 'darwin'
+        ? join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+        : join(home, '.config', 'Claude', 'claude_desktop_config.json'),
+    },
+    {
+      name: 'Cursor',
+      configPath: join(home, '.cursor', 'mcp.json'),
+    },
+  ];
+
+  for (const agent of known) {
+    // Check if the config file or its parent directory exists
+    const configExists = existsSync(agent.configPath);
+    const dirExists = existsSync(join(agent.configPath, '..'));
+    if (configExists || dirExists) {
+      agents.push({ ...agent, configExists });
+    }
+  }
+
+  return agents;
+}
+
+/**
+ * Check if port 3838 is available.
+ */
+export function isPortAvailable(port = 3838) {
+  try {
+    execSync(`lsof -i :${port} -t 2>/dev/null`, { encoding: 'utf-8' });
+    return false; // port is in use
+  } catch {
+    return true; // port is available (lsof returned non-zero = no process)
+  }
+}
+
+/**
+ * Check if the router service is already registered.
+ */
+export function isServiceRegistered() {
+  if (process.platform === 'darwin') {
+    const plistPath = join(homedir(), 'Library', 'LaunchAgents', 'ai.robotresources.router.plist');
+    return existsSync(plistPath);
+  }
+  if (process.platform === 'linux') {
+    const unitPath = join(homedir(), '.config', 'systemd', 'user', 'robot-resources-router.service');
+    return existsSync(unitPath);
+  }
+  return false;
+}

package/lib/mcp-config.js

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, copyFileSync, mkdirSync, existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { detectAgents } from './detect.js';
+
+const SCRAPER_MCP_ENTRY = {
+  command: 'npx',
+  args: ['-y', '@robot-resources/scraper-mcp'],
+};
+
+const MCP_KEY = 'robot-resources-scraper';
+
+/**
+ * Read a JSON file safely. Returns null on failure.
+ */
+function readJsonSafe(filePath) {
+  try {
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write JSON with backup. Creates parent directory if needed.
+ */
+function writeJsonSafe(filePath, data) {
+  const dir = join(filePath, '..');
+  mkdirSync(dir, { recursive: true });
+
+  // Create backup if file exists
+  if (existsSync(filePath)) {
+    copyFileSync(filePath, `${filePath}.bak`);
+  }
+
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + '\n');
+}
+
+/**
+ * Configure MCP in all detected agents.
+ * Returns array of { name, configPath, action } results.
+ */
+export function configureAgentMCP() {
+  const agents = detectAgents();
+  const results = [];
+
+  for (const agent of agents) {
+    try {
+      let config = agent.configExists ? readJsonSafe(agent.configPath) : {};
+
+      if (!config) {
+        results.push({ name: agent.name, configPath: agent.configPath, action: 'skipped', reason: 'invalid JSON' });
+        continue;
+      }
+
+      // Ensure mcpServers key exists
+      config.mcpServers = config.mcpServers || {};
+
+      // Skip if already configured
+      if (config.mcpServers[MCP_KEY]) {
+        results.push({ name: agent.name, configPath: agent.configPath, action: 'exists' });
+        continue;
+      }
+
+      // Add scraper MCP
+      config.mcpServers[MCP_KEY] = SCRAPER_MCP_ENTRY;
+      writeJsonSafe(agent.configPath, config);
+      results.push({ name: agent.name, configPath: agent.configPath, action: 'added' });
+    } catch (err) {
+      results.push({ name: agent.name, configPath: agent.configPath, action: 'error', reason: err.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Remove RR MCP entries from all detected agents.
+ */
+export function removeAgentMCP() {
+  const agents = detectAgents();
+
+  for (const agent of agents) {
+    if (!agent.configExists) continue;
+    const config = readJsonSafe(agent.configPath);
+    if (!config?.mcpServers?.[MCP_KEY]) continue;
+
+    delete config.mcpServers[MCP_KEY];
+    writeJsonSafe(agent.configPath, config);
+  }
+}

package/lib/python-bridge.js

@@ -0,0 +1,28 @@
+import {
+  findPython,
+  ensureVenv,
+  installRouter,
+  isRouterInstalled,
+  getVenvPythonPath,
+} from '@robot-resources/cli-core/python-bridge.mjs';
+
+// Re-export shared primitives used by wizard.js and other CLI code.
+export { ensureVenv, isRouterInstalled, getVenvPythonPath };
+
+/**
+ * Full setup: find Python, create venv, install router.
+ * Returns { venvPython, pythonVersion } or throws.
+ */
+export async function setupRouter() {
+  const python = findPython();
+  if (!python) {
+    throw new Error(
+      'Python 3.10+ not found. Install Python from https://python.org and try again.\n' +
+      '  The Router requires Python. Scraper and MCP tools work without it.'
+    );
+  }
+
+  const venvPython = ensureVenv(python.bin);
+  installRouter();
+  return { venvPython, pythonVersion: python.version };
+}

package/lib/service.js

@@ -0,0 +1,270 @@
+import { execSync } from 'node:child_process';
+import { existsSync, writeFileSync, unlinkSync, mkdirSync, chmodSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join, dirname } from 'node:path';
+import { readProviderKeys } from '@robot-resources/cli-core/config.mjs';
+
+const LABEL = 'ai.robotresources.router';
+const ROUTER_PORT = 3838;
+
+// Maps config.json provider_keys names to environment variable names
+const CONFIG_TO_ENV = {
+  openai: 'OPENAI_API_KEY',
+  anthropic: 'ANTHROPIC_API_KEY',
+  google: 'GOOGLE_API_KEY',
+};
+
+// ─── macOS (launchd) ────────────────────────────────────────────────────────
+
+function getPlistPath() {
+  return join(homedir(), 'Library', 'LaunchAgents', `${LABEL}.plist`);
+}
+
+function buildPlist(venvPythonPath) {
+  const home = homedir();
+  const logsDir = join(home, '.robot-resources', 'logs');
+
+  // Snapshot provider API keys: env vars take priority, then config.json
+  const envVars = {};
+  const configKeys = readProviderKeys();
+  const keyNames = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
+  for (const key of keyNames) {
+    const value = process.env[key];
+    if (value) {
+      envVars[key] = value;
+    }
+  }
+  // Fill in from config.json for any keys not found in environment
+  for (const [configName, envName] of Object.entries(CONFIG_TO_ENV)) {
+    if (!envVars[envName] && configKeys[configName]) {
+      envVars[envName] = configKeys[configName];
+    }
+  }
+  // Ensure PATH includes common binary locations
+  envVars.PATH = '/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin';
+
+  const envEntries = Object.entries(envVars)
+    .map(([k, v]) => `      <key>${k}</key>\n      <string>${v}</string>`)
+    .join('\n');
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
+  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${venvPythonPath}</string>
+    <string>-m</string>
+    <string>robot_resources.cli.main</string>
+    <string>start</string>
+  </array>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>KeepAlive</key>
+  <true/>
+  <key>StandardOutPath</key>
+  <string>${logsDir}/router.stdout.log</string>
+  <key>StandardErrorPath</key>
+  <string>${logsDir}/router.stderr.log</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+${envEntries}
+  </dict>
+  <key>WorkingDirectory</key>
+  <string>${home}/.robot-resources</string>
+</dict>
+</plist>
+`;
+}
+
+function installLaunchd(venvPythonPath) {
+  const plistPath = getPlistPath();
+  const logsDir = join(homedir(), '.robot-resources', 'logs');
+  const launchAgentsDir = join(homedir(), 'Library', 'LaunchAgents');
+
+  mkdirSync(logsDir, { recursive: true });
+  mkdirSync(launchAgentsDir, { recursive: true });
+
+  // Unload existing service if present
+  if (existsSync(plistPath)) {
+    try {
+      execSync(`launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null`, { stdio: 'pipe' });
+    } catch {
+      // Not loaded — fine
+    }
+  }
+
+  writeFileSync(plistPath, buildPlist(venvPythonPath));
+  chmodSync(plistPath, 0o600);
+  execSync(`launchctl bootstrap gui/$(id -u) "${plistPath}"`, { stdio: 'pipe' });
+}
+
+function uninstallLaunchd() {
+  const plistPath = getPlistPath();
+  if (!existsSync(plistPath)) return;
+
+  try {
+    execSync(`launchctl bootout gui/$(id -u) "${plistPath}" 2>/dev/null`, { stdio: 'pipe' });
+  } catch {
+    // Already unloaded
+  }
+  unlinkSync(plistPath);
+}
+
+function isLaunchdRunning() {
+  try {
+    const output = execSync(`launchctl print gui/$(id -u)/${LABEL} 2>&1`, { encoding: 'utf-8' });
+    return output.includes('state = running');
+  } catch {
+    return false;
+  }
+}
+
+// ─── Linux (systemd) ────────────────────────────────────────────────────────
+
+function getUnitPath() {
+  return join(homedir(), '.config', 'systemd', 'user', 'robot-resources-router.service');
+}
+
+function buildUnit(venvPythonPath) {
+  const home = homedir();
+  const logsDir = join(home, '.robot-resources', 'logs');
+
+  // Snapshot provider API keys: env vars take priority, then config.json
+  const envLines = [];
+  const configKeys = readProviderKeys();
+  const keyNames = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
+  const resolvedKeys = {};
+  for (const key of keyNames) {
+    if (process.env[key]) {
+      resolvedKeys[key] = process.env[key];
+    }
+  }
+  for (const [configName, envName] of Object.entries(CONFIG_TO_ENV)) {
+    if (!resolvedKeys[envName] && configKeys[configName]) {
+      resolvedKeys[envName] = configKeys[configName];
+    }
+  }
+  for (const [key, value] of Object.entries(resolvedKeys)) {
+    envLines.push(`Environment=${key}=${value}`);
+  }
+  envLines.push('Environment=PATH=/usr/local/bin:/usr/bin:/bin');
+
+  return `[Unit]
+Description=Robot Resources Router — LLM cost optimization proxy
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+ExecStart=${venvPythonPath} -m robot_resources.cli.main start
+Restart=on-failure
+RestartSec=5
+${envLines.join('\n')}
+WorkingDirectory=${home}/.robot-resources
+StandardOutput=append:${logsDir}/router.stdout.log
+StandardError=append:${logsDir}/router.stderr.log
+
+[Install]
+WantedBy=default.target
+`;
+}
+
+function installSystemd(venvPythonPath) {
+  const unitPath = getUnitPath();
+  const logsDir = join(homedir(), '.robot-resources', 'logs');
+  const unitDir = dirname(unitPath);
+
+  mkdirSync(logsDir, { recursive: true });
+  mkdirSync(unitDir, { recursive: true });
+
+  writeFileSync(unitPath, buildUnit(venvPythonPath));
+  chmodSync(unitPath, 0o600);
+  execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+  execSync('systemctl --user enable robot-resources-router.service', { stdio: 'pipe' });
+  execSync('systemctl --user start robot-resources-router.service', { stdio: 'pipe' });
+}
+
+function uninstallSystemd() {
+  const unitPath = getUnitPath();
+  if (!existsSync(unitPath)) return;
+
+  try {
+    execSync('systemctl --user stop robot-resources-router.service', { stdio: 'pipe' });
+    execSync('systemctl --user disable robot-resources-router.service', { stdio: 'pipe' });
+  } catch {
+    // Already stopped
+  }
+  unlinkSync(unitPath);
+  execSync('systemctl --user daemon-reload', { stdio: 'pipe' });
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Register the router as a system service and start it.
+ */
+export function installService(venvPythonPath) {
+  if (process.platform === 'darwin') {
+    installLaunchd(venvPythonPath);
+    return { type: 'launchd', path: getPlistPath() };
+  }
+  if (process.platform === 'linux') {
+    installSystemd(venvPythonPath);
+    return { type: 'systemd', path: getUnitPath() };
+  }
+  throw new Error(
+    `Service registration not supported on ${process.platform}.\n` +
+    `  Run the router manually: rr-router start`
+  );
+}
+
+/**
+ * Stop and remove the router service.
+ */
+export function uninstallService() {
+  if (process.platform === 'darwin') return uninstallLaunchd();
+  if (process.platform === 'linux') return uninstallSystemd();
+}
+
+/**
+ * Check if the router service is currently running.
+ */
+export function isServiceRunning() {
+  if (process.platform === 'darwin') return isLaunchdRunning();
+  if (process.platform === 'linux') {
+    try {
+      execSync('systemctl --user is-active robot-resources-router.service', { stdio: 'pipe' });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a service config file exists.
+ */
+export function isServiceInstalled() {
+  if (process.platform === 'darwin') return existsSync(getPlistPath());
+  if (process.platform === 'linux') return existsSync(getUnitPath());
+  return false;
+}
+
+/**
+ * Get missing provider API keys (not in environment or config.json).
+ */
+export function getMissingProviderKeys() {
+  const keys = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'GOOGLE_API_KEY'];
+  const configKeys = readProviderKeys();
+  return keys.filter((k) => {
+    if (process.env[k]) return false;
+    // Check config.json using the provider name mapping
+    const configName = Object.entries(CONFIG_TO_ENV).find(([, env]) => env === k)?.[0];
+    return !configName || !configKeys[configName];
+  });
+}

package/lib/ui.js

@@ -0,0 +1,87 @@
+import { createInterface } from 'node:readline';
+
+// ANSI color helpers (no dependencies)
+const c = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  dim: '\x1b[2m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  cyan: '\x1b[36m',
+  orange: '\x1b[38;5;208m',
+};
+
+export function header() {
+  console.log(`\n  ${c.orange}${c.bold}██ Robot Resources — Setup${c.reset}\n`);
+}
+
+export function step(msg) {
+  console.log(`  ${c.cyan}→${c.reset} ${msg}`);
+}
+
+export function success(msg) {
+  console.log(`  ${c.green}✓${c.reset} ${msg}`);
+}
+
+export function warn(msg) {
+  console.log(`  ${c.yellow}!${c.reset} ${msg}`);
+}
+
+export function error(msg) {
+  console.log(`  ${c.red}✗${c.reset} ${msg}`);
+}
+
+export function info(msg) {
+  console.log(`  ${c.dim}${msg}${c.reset}`);
+}
+
+export function blank() {
+  console.log('');
+}
+
+export function summary(lines) {
+  console.log(`\n  ${c.orange}${c.bold}── Summary ──${c.reset}\n`);
+  for (const line of lines) {
+    console.log(`  ${line}`);
+  }
+  console.log('');
+}
+
+/**
+ * Prompt for free-text input (e.g. API keys).
+ * Returns the trimmed answer, or empty string if skipped.
+ * In non-interactive mode, returns the default value.
+ */
+export function prompt(question, { defaultValue = '', nonInteractive = false } = {}) {
+  if (nonInteractive) return Promise.resolve(defaultValue);
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  return new Promise((resolve) => {
+    rl.question(`  ${question}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+
+/**
+ * Prompt for yes/no confirmation. Returns true for yes.
+ * In non-interactive mode, returns the default value.
+ */
+export function confirm(question, { defaultYes = true, nonInteractive = false } = {}) {
+  if (nonInteractive) return Promise.resolve(defaultYes);
+
+  const hint = defaultYes ? 'Y/n' : 'y/N';
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  return new Promise((resolve) => {
+    rl.question(`  ${question} (${hint}): `, (answer) => {
+      rl.close();
+      const trimmed = answer.trim().toLowerCase();
+      if (trimmed === '') resolve(defaultYes);
+      else resolve(trimmed === 'y' || trimmed === 'yes');
+    });
+  });
+}

package/lib/wizard.js

@@ -0,0 +1,261 @@
+import { readConfig, writeConfig, readProviderKeys, writeProviderKeys } from '@robot-resources/cli-core/config.mjs';
+import { login } from '@robot-resources/cli-core/login.mjs';
+import { findPython, isPortAvailable } from './detect.js';
+import { setupRouter, isRouterInstalled, getVenvPythonPath } from './python-bridge.js';
+import { installService, isServiceRunning, isServiceInstalled, getMissingProviderKeys } from './service.js';
+import { configureAgentMCP } from './mcp-config.js';
+import { header, step, success, warn, error, info, blank, summary, confirm, prompt } from './ui.js';
+
+/**
+ * Main setup wizard. Handles the full onboarding flow:
+ * 1. Authentication (GitHub OAuth)
+ * 2. Router installation (Python venv + pip)
+ * 3. Service registration (launchd/systemd)
+ * 4. MCP auto-configuration (Claude Desktop, Cursor)
+ */
+export async function runWizard({ nonInteractive = false } = {}) {
+  header();
+
+  const results = {
+    auth: false,
+    router: false,
+    routerError: null,
+    providerKeys: false,
+    service: false,
+    mcp: [],
+  };
+
+  // ── Step 1: Authentication ──────────────────────────────────────────────
+
+  const config = readConfig();
+
+  if (config.api_key) {
+    success(`Already logged in as ${config.user_name || config.user_email || 'unknown'}`);
+    results.auth = true;
+  } else if (process.env.RR_API_KEY) {
+    // Agent flow: API key provided via environment variable
+    const envKey = process.env.RR_API_KEY;
+    if (!envKey.startsWith('rr_live_')) {
+      error('RR_API_KEY must start with rr_live_');
+      info('Get a valid key from POST /v1/auth/signup or the dashboard');
+    } else {
+      writeConfig({ api_key: envKey, signup_source: 'agent' });
+      success('API key loaded from RR_API_KEY environment variable');
+      results.auth = true;
+    }
+  } else {
+    step('Setting up your Robot Resources account...');
+
+    const shouldLogin = await confirm('Log in with GitHub?', { nonInteractive });
+    if (shouldLogin) {
+      try {
+        await login();
+        results.auth = true;
+      } catch (err) {
+        error(`Login failed: ${err.message}`);
+        info('You can log in later with: npx robot-resources login');
+        blank();
+      }
+    } else {
+      info('Skipping login. You can log in later with: npx robot-resources login');
+    }
+  }
+
+  // ── Step 2: Router Installation ─────────────────────────────────────────
+
+  blank();
+  step('Checking Router...');
+
+  if (isRouterInstalled()) {
+    success('Router already installed');
+    results.router = true;
+  } else {
+    const python = findPython();
+    if (!python) {
+      warn('Python 3.10+ not found — skipping Router installation');
+      info('Install Python from https://python.org and re-run this wizard');
+      info('Scraper and MCP tools work without Python');
+    } else {
+      info(`Found Python ${python.version} (${python.bin})`);
+      step('Installing Router (this may take a moment)...');
+
+      try {
+        await setupRouter();
+        success('Router installed');
+        results.router = true;
+      } catch (err) {
+        error(`Router installation failed: ${err.message}`);
+        results.routerError = 'install-failed';
+      }
+    }
+  }
+
+  // ── Step 2.5: Provider API Keys ──────────────────────────────────────────
+
+  if (results.router) {
+    blank();
+    step('Configuring LLM provider API keys...');
+    info('The Router forwards your requests to LLM providers on your behalf.');
+    info('Keys are stored locally in ~/.robot-resources/config.json (readable only by you).');
+    info('You need at least one provider key. Press Enter to skip any provider.');
+    blank();
+
+    const existingKeys = readProviderKeys();
+    const providers = [
+      { env: 'OPENAI_API_KEY', config: 'openai', label: 'OpenAI' },
+      { env: 'ANTHROPIC_API_KEY', config: 'anthropic', label: 'Anthropic' },
+      { env: 'GOOGLE_API_KEY', config: 'google', label: 'Google AI' },
+    ];
+
+    const newKeys = {};
+
+    for (const p of providers) {
+      const fromEnv = process.env[p.env];
+      const fromConfig = existingKeys[p.config];
+
+      if (fromEnv) {
+        success(`${p.label}: found in environment (${p.env})`);
+        continue;
+      }
+      if (fromConfig) {
+        success(`${p.label}: found in config`);
+        continue;
+      }
+
+      const key = await prompt(`${p.label} API key (${p.env})`, { nonInteractive });
+      if (key) {
+        newKeys[p.config] = key;
+        success(`${p.label}: saved`);
+      } else {
+        info(`${p.label}: skipped`);
+      }
+    }
+
+    if (Object.keys(newKeys).length > 0) {
+      writeProviderKeys(newKeys);
+      results.providerKeys = true;
+    }
+  }
+
+  // ── Step 3: Service Registration ────────────────────────────────────────
+
+  if (results.router) {
+    blank();
+    step('Configuring Router as system service...');
+
+    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()) {
+        warn('Port 3838 is already in use');
+        info('Another process may be using this port. The service will retry on restart.');
+      }
+
+      // Check for provider API keys (env + config.json)
+      const missingKeys = getMissingProviderKeys();
+      if (missingKeys.length === 3) {
+        warn('No LLM provider API keys configured');
+        info('The Router needs at least one of: OPENAI_API_KEY, ANTHROPIC_API_KEY, GOOGLE_API_KEY');
+        info('Re-run this wizard or set them in your shell profile');
+      } else if (missingKeys.length > 0) {
+        info(`Provider keys configured: ${3 - missingKeys.length}/3`);
+      }
+
+      try {
+        const svc = installService(getVenvPythonPath());
+        success(`Router registered as ${svc.type} service`);
+        info(`Config: ${svc.path}`);
+        info('Router will start automatically on login and restart on crash');
+        results.service = true;
+      } catch (err) {
+        error(`Service registration failed: ${err.message}`);
+        info('You can start the router manually: rr-router start');
+      }
+    }
+  }
+
+  // ── Step 4: MCP Auto-Configuration ──────────────────────────────────────
+
+  blank();
+  step('Configuring MCP in detected agents...');
+
+  const mcpResults = configureAgentMCP();
+  results.mcp = mcpResults;
+
+  if (mcpResults.length === 0) {
+    info('No supported agents detected (Claude Desktop, Cursor)');
+    info('You can manually add MCP servers to your agent config later');
+  } else {
+    for (const r of mcpResults) {
+      if (r.action === 'added') {
+        success(`${r.name}: scraper MCP configured`);
+      } else if (r.action === 'exists') {
+        success(`${r.name}: already configured`);
+      } else if (r.action === 'skipped') {
+        warn(`${r.name}: skipped (${r.reason})`);
+      } else if (r.action === 'error') {
+        error(`${r.name}: ${r.reason}`);
+      }
+    }
+  }
+
+  // ── Summary ─────────────────────────────────────────────────────────────
+
+  const lines = [];
+
+  if (results.auth) {
+    lines.push('✓ Authenticated with GitHub');
+  } else {
+    lines.push('○ Not logged in (run: npx robot-resources login)');
+  }
+
+  if (results.router && results.service) {
+    lines.push('✓ Router installed and running as system service');
+    lines.push('  Proxy: http://localhost:3838');
+  } else if (results.router) {
+    lines.push('✓ Router installed (start manually: rr-router start)');
+  } else if (results.routerError === 'install-failed') {
+    lines.push('○ Router install failed (pip package not yet available — coming soon)');
+  } else {
+    lines.push('○ Router not installed (Python 3.10+ required)');
+  }
+
+  const mcpAdded = mcpResults.filter((r) => r.action === 'added' || r.action === 'exists');
+  if (mcpAdded.length > 0) {
+    lines.push(`✓ MCP configured in: ${mcpAdded.map((r) => r.name).join(', ')}`);
+  } else {
+    lines.push('○ No agents configured (add MCP manually if needed)');
+  }
+
+  summary(lines);
+
+  // ── Human notification (especially important for agent/non-interactive installs) ──
+
+  const somethingInstalled = results.router || results.service || mcpAdded.length > 0;
+
+  if (somethingInstalled && nonInteractive) {
+    blank();
+    warn('IMPORTANT: Notify your human about this installation.');
+    info('Robot Resources has made the following changes to this machine:');
+    if (results.router)  info('  • Router installed in ~/.robot-resources/');
+    if (results.service) info('  • Router registered as a system service (localhost:3838)');
+    if (results.service) info('  • All LLM calls using this proxy will be cost-optimized');
+    for (const r of mcpAdded) {
+      info(`  • ${r.name} config modified to add Scraper MCP`);
+    }
+    blank();
+    info('Suggested message to your human:');
+    info('"I installed Robot Resources Router. It saves 60-90% on LLM costs.');
+    info(' All calls now route through localhost:3838 for cost optimization.');
+    info(' More info: https://robotresources.ai"');
+    blank();
+  } else if (somethingInstalled) {
+    blank();
+    info('Dashboard & monitoring: https://robotresources.ai/dashboard');
+  }
+}

package/package.json

@@ -1,13 +1,48 @@
 {
   "name": "robot-resources",
-  "version": "0.0.1",
-  "description": "AI agent runtime infrastructure - placeholder package",
-  "main": "index.js",
-  "author": "Robot Resources Team <manuelsobrino6@gmail.com>",
+  "version": "1.0.0",
+  "description": "Robot Resources — AI agent runtime tools. One command to install everything.",
+  "type": "module",
+  "bin": {
+    "robot-resources-setup": "./bin/setup.js"
+  },
+  "main": "./bin/setup.js",
+  "scripts": {
+    "test": "vitest",
+    "test:run": "vitest run"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "dependencies": {
+    "@robot-resources/cli-core": "*"
+  },
+  "devDependencies": {
+    "vitest": "^1.2.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "llm",
+    "router",
+    "scraper",
+    "mcp",
+    "cost-optimization",
+    "robot-resources"
+  ],
   "license": "MIT",
-  "keywords": ["ai", "agents", "runtime", "infrastructure"],
+  "author": "Robot Resources Team",
   "repository": {
     "type": "git",
-    "url": "https://github.com/robot-resources"
+    "url": "git+https://github.com/robot-resources/robot-resources.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/index.js

@@ -1,6 +0,0 @@
-/**
- * Robot Resources - AI agent runtime infrastructure
- * Coming soon.
- */
-
-module.exports = {};