rird 1.0.200

package/script/postinstall.mjs

@@ -0,0 +1,544 @@
+#!/usr/bin/env node
+/**
+ * RIRD AI Browser Agent - Cross-platform Postinstall
+ * Mirrors the install.sh setup for Windows/Mac/Linux
+ */
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+import { execSync, spawnSync } from "child_process"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+// RIRD paths
+const RIRD_HOME = process.env.RIRD_HOME || path.join(os.homedir(), ".rird")
+const BIN_DIR = path.join(RIRD_HOME, "bin")
+const ENGINE_DIR = path.join(RIRD_HOME, "engine")
+const VENV_DIR = path.join(RIRD_HOME, "venv")
+const MCP_DIR = path.join(ENGINE_DIR, "stealth-browser-mcp")
+
+// Installation mode: A = Browser + Files, B = Full Computer Use
+const INSTALL_MODE = process.env.RIRD_MODE || "A"
+
+const isWindows = os.platform() === "win32"
+const isMac = os.platform() === "darwin"
+const isLinux = os.platform() === "linux"
+
+function log(msg) {
+  console.log(`[RIRD] ${msg}`)
+}
+
+function execSafe(cmd, options = {}) {
+  try {
+    return execSync(cmd, { stdio: "pipe", timeout: 120000, ...options })
+  } catch (e) {
+    return null
+  }
+}
+
+function detectPlatformAndArch() {
+  let platform
+  switch (os.platform()) {
+    case "darwin": platform = "darwin"; break
+    case "linux": platform = "linux"; break
+    case "win32": platform = "windows"; break
+    default: platform = os.platform(); break
+  }
+
+  let arch
+  switch (os.arch()) {
+    case "x64": arch = "x64"; break
+    case "arm64": arch = "arm64"; break
+    case "arm": arch = "arm"; break
+    default: arch = os.arch(); break
+  }
+
+  return { platform, arch }
+}
+
+// Check for Python
+function checkPython() {
+  const cmds = isWindows ? ["python", "python3", "py"] : ["python3", "python"]
+  for (const cmd of cmds) {
+    const result = execSafe(`${cmd} --version`)
+    if (result) {
+      log(`Found Python: ${result.toString().trim()}`)
+      return cmd
+    }
+  }
+  log("Python not found - install from https://python.org")
+  return null
+}
+
+// Check for pip
+function checkPip(pythonCmd) {
+  const cmds = isWindows ? ["pip", "pip3"] : ["pip3", "pip"]
+  for (const cmd of cmds) {
+    if (execSafe(`${cmd} --version`)) return cmd
+  }
+  // Try python -m pip
+  if (execSafe(`${pythonCmd} -m pip --version`)) return `${pythonCmd} -m pip`
+  return null
+}
+
+// Install Python dependencies
+function installPythonDeps(pipCmd) {
+  log("Installing Python dependencies...")
+  const deps = [
+    "httpx", "loguru", "Pillow", "nodriver", "fastmcp",
+    "patchright", "beautifulsoup4", "lxml", "pydantic",
+    "psutil", "python-dotenv", "aiohttp", "requests"
+  ]
+  execSafe(`${pipCmd} install --user ${deps.join(" ")}`, { stdio: "inherit" })
+}
+
+// Clone stealth-browser-mcp
+function cloneStealthBrowserMcp() {
+  if (fs.existsSync(MCP_DIR)) {
+    log("stealth-browser-mcp already installed")
+    return true
+  }
+
+  log("Cloning stealth-browser-mcp...")
+
+  // Try git clone
+  if (execSafe("git --version")) {
+    const result = execSafe(`git clone --depth 1 https://github.com/vibheksoni/stealth-browser-mcp "${MCP_DIR}"`, { stdio: "inherit" })
+    if (result !== null || fs.existsSync(MCP_DIR)) {
+      log("stealth-browser-mcp cloned successfully")
+      return true
+    }
+  }
+
+  // Fallback: download zip
+  log("Git not available, trying zip download...")
+  // Create placeholder for now
+  fs.mkdirSync(path.join(MCP_DIR, "src"), { recursive: true })
+  fs.writeFileSync(path.join(MCP_DIR, "src", "server.py"), `#!/usr/bin/env python3
+# Placeholder - run: git clone https://github.com/vibheksoni/stealth-browser-mcp ~/.rird/engine/stealth-browser-mcp
+print("stealth-browser-mcp not installed. Clone manually.")
+`)
+  return false
+}
+
+// Create license validator
+function createLicenseValidator() {
+  const validatorPath = path.join(ENGINE_DIR, "license_validator.py")
+  if (fs.existsSync(validatorPath)) return
+
+  log("Creating license validator...")
+  const content = `#!/usr/bin/env python3
+"""RIRD License Validator"""
+import os, json, hashlib, platform
+from pathlib import Path
+from datetime import datetime, timedelta
+import urllib.request, urllib.error
+
+LICENSE_CACHE_PATH = Path.home() / ".rird" / "license_cache.json"
+RIRD_API_URL = "https://rird.ai/api/desktop/validate-license"
+
+def get_device_fingerprint():
+    parts = [platform.node(), platform.system(), platform.machine(),
+             os.getenv("USER", os.getenv("USERNAME", "unknown"))]
+    return hashlib.sha256("|".join(parts).encode()).hexdigest()[:32]
+
+def load_license_cache():
+    try:
+        if LICENSE_CACHE_PATH.exists():
+            data = json.loads(LICENSE_CACHE_PATH.read_text())
+            cached_at = datetime.fromisoformat(data.get("cached_at", "2000-01-01"))
+            if datetime.now() - cached_at < timedelta(hours=24):
+                return data
+    except: pass
+    return None
+
+def save_license_cache(data):
+    try:
+        LICENSE_CACHE_PATH.parent.mkdir(parents=True, exist_ok=True)
+        data["cached_at"] = datetime.now().isoformat()
+        LICENSE_CACHE_PATH.write_text(json.dumps(data))
+    except: pass
+
+def get_license_key():
+    key = os.getenv("RIRD_LICENSE_KEY")
+    if key: return key.strip()
+    config_path = Path.home() / ".rird" / "license.key"
+    if config_path.exists():
+        try: return config_path.read_text().strip()
+        except: pass
+    return None
+
+def save_license_key(key):
+    config_path = Path.home() / ".rird" / "license.key"
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+    config_path.write_text(key)
+
+def validate_license_online(key):
+    try:
+        payload = json.dumps({
+            "license_key": key,
+            "device_fingerprint": get_device_fingerprint(),
+            "version": "1.0.0",
+            "platform": platform.system(),
+        }).encode()
+        req = urllib.request.Request(RIRD_API_URL, data=payload,
+            headers={"Content-Type": "application/json"}, method="POST")
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            data = json.loads(resp.read().decode())
+            if data.get("valid"):
+                return True, "License valid", data.get("user")
+            return False, data.get("error", "Invalid license"), None
+    except urllib.error.HTTPError as e:
+        if e.code == 401: return False, "Invalid license key", None
+        if e.code == 403: return False, "Subscription inactive", None
+        return True, "Server unavailable - using cached", None
+    except:
+        return True, "Offline - using cached", None
+
+def validate_license_sync():
+    key = get_license_key()
+    if not key:
+        return False, "No license key. Run: rird activate YOUR_KEY"
+    cached = load_license_cache()
+    if cached and cached.get("license_key") == key and cached.get("valid"):
+        return True, f"License valid (cached) - {cached.get('email', 'unknown')}"
+    valid, msg, user = validate_license_online(key)
+    if valid and user:
+        save_license_cache({"license_key": key, "valid": True,
+            "email": user.get("email"), "plan": user.get("plan")})
+        return True, f"License valid - {user.get('email', 'unknown')}"
+    return valid, msg
+
+def activate_license(key):
+    valid, msg, user = validate_license_online(key)
+    if valid and user:
+        save_license_key(key)
+        save_license_cache({"license_key": key, "valid": True,
+            "email": user.get("email"), "plan": user.get("plan")})
+        return True, f"License activated for {user.get('email')}"
+    return False, msg
+
+if __name__ == "__main__":
+    import sys
+    if len(sys.argv) < 2:
+        print("Usage: license_validator.py <activate|status|validate> [key]")
+        sys.exit(1)
+    cmd = sys.argv[1]
+    if cmd == "activate":
+        if len(sys.argv) < 3:
+            print("Usage: license_validator.py activate KEY")
+            sys.exit(1)
+        ok, msg = activate_license(sys.argv[2])
+        print(msg)
+        sys.exit(0 if ok else 1)
+    elif cmd == "status":
+        ok, msg = validate_license_sync()
+        print(msg)
+        sys.exit(0 if ok else 1)
+    elif cmd == "validate":
+        ok, msg = validate_license_sync()
+        print(msg)
+        sys.exit(0 if ok else 1)
+`
+  fs.writeFileSync(validatorPath, content)
+}
+
+// Create rird.json config
+function createConfig(pythonCmd) {
+  const configPath = path.join(ENGINE_DIR, "rird.json")
+
+  log(`Creating config (Mode ${INSTALL_MODE})...`)
+
+  const mcpConfig = {
+    "stealth-browser": {
+      type: "local",
+      command: [pythonCmd, path.join(MCP_DIR, "src", "server.py"), "--minimal"],
+      environment: {
+        FASTMCP_DISABLE_BANNER: "1",
+        PYTHONPATH: path.join(MCP_DIR, "src"),
+        RIRD_PROXIES: "${ROYAL_PROXY}"
+      },
+      timeout: 30000
+    }
+  }
+
+  // Mode B: Add computer-use MCP
+  if (INSTALL_MODE === "B") {
+    if (isWindows) {
+      mcpConfig["computer-use"] = {
+        type: "local",
+        command: ["uvx", "windows-mcp"],
+        environment: {},
+        timeout: 30000,
+        enabled: true
+      }
+    } else if (isMac) {
+      mcpConfig["computer-use"] = {
+        type: "local",
+        command: ["bun", "run", path.join(RIRD_HOME, "mcp", "automation-mcp", "index.ts"), "--stdio"],
+        environment: {},
+        timeout: 30000,
+        enabled: true
+      }
+    } else if (isLinux) {
+      mcpConfig["computer-use"] = {
+        type: "local",
+        command: ["npx", "-y", "mcp-desktop-automation"],
+        environment: { DISPLAY: process.env.DISPLAY || ":0" },
+        timeout: 30000,
+        enabled: true
+      }
+    }
+  }
+
+  const instructions = INSTALL_MODE === "B"
+    ? [
+        "=== RIRD AI - rird.ai ===",
+        "I am your AI assistant that can browse the web and automate tasks.",
+        "",
+        "=== WHAT I CAN DO ===",
+        "- Browse websites and interact with web pages",
+        "- Fill out forms and click buttons",
+        "- Extract data from websites",
+        "- Read and write files on your computer",
+        "- Control your mouse and keyboard",
+        "- Launch and interact with desktop applications",
+        "- Take screenshots and analyze what's on screen",
+        "",
+        "=== HOW I WORK ===",
+        "1. WEB SEARCH:",
+        "   - Finding URLs, quick facts, lists of companies or profiles",
+        "   - Fast lookups that don't require visiting a page",
+        "",
+        "2. BROWSER AUTOMATION:",
+        "   - Navigating to websites and interacting with them",
+        "   - Logging into accounts and filling forms",
+        "   - Extracting content from web pages",
+        "",
+        "3. COMPUTER CONTROL:",
+        "   - Desktop applications and system tasks",
+        "   - Mouse and keyboard automation",
+        "   - File and folder operations"
+      ]
+    : [
+        "=== RIRD AI - rird.ai ===",
+        "I am your AI assistant that can browse the web and automate tasks.",
+        "",
+        "=== WHAT I CAN DO ===",
+        "- Browse websites and interact with web pages",
+        "- Fill out forms and click buttons",
+        "- Extract data from websites",
+        "- Read and write files on your computer",
+        "",
+        "=== HOW I WORK ===",
+        "1. WEB SEARCH:",
+        "   - Finding URLs, quick facts, lists of companies or profiles",
+        "   - Fast lookups that don't require visiting a page",
+        "",
+        "2. BROWSER AUTOMATION:",
+        "   - Navigating to websites and interacting with them",
+        "   - Logging into accounts and filling forms",
+        "   - Extracting content from web pages"
+      ]
+
+  const config = {
+    model: "deepseek/deepseek-reasoner",
+    small_model: "siliconflow/Qwen/Qwen3-8B",
+    visionModel: "siliconflow/Qwen/Qwen2.5-VL-7B-Instruct",
+    agent: {
+      plan: { model: "deepseek/deepseek-reasoner" },
+      build: { model: "deepseek/deepseek-reasoner" }
+    },
+    provider: {
+      deepseek: {
+        models: {
+          "deepseek-reasoner": {
+            id: "deepseek-reasoner",
+            name: "DeepSeek Reasoner",
+            release_date: "2024-12-26",
+            attachment: true,
+            reasoning: true,
+            temperature: true,
+            tool_call: true,
+            limit: { context: 64000, output: 8000 },
+            options: {}
+          }
+        },
+        options: { apiKey: "" }
+      },
+      siliconflow: {
+        models: {
+          "Qwen/Qwen3-8B": {
+            id: "Qwen/Qwen3-8B",
+            name: "Qwen 3 8B",
+            release_date: "2024-12-26",
+            attachment: true,
+            reasoning: false,
+            temperature: true,
+            tool_call: true,
+            limit: { context: 32000, output: 4000 },
+            options: {}
+          },
+          "Qwen/Qwen2.5-VL-7B-Instruct": {
+            id: "Qwen/Qwen2.5-VL-7B-Instruct",
+            name: "Qwen 2.5 VL 7B",
+            release_date: "2024-12-26",
+            attachment: true,
+            reasoning: false,
+            temperature: true,
+            tool_call: true,
+            limit: { context: 32000, output: 4000 },
+            modalities: { input: ["text", "image"], output: ["text"] },
+            options: {}
+          }
+        },
+        options: { apiKey: "", baseUrl: "https://api.siliconflow.com/v1" }
+      }
+    },
+    instructions,
+    mcp: mcpConfig,
+    permission: {
+      edit: "allow",
+      bash: "allow",
+      skill: "allow",
+      webfetch: "allow",
+      external_directory: "allow"
+    },
+    autoupdate: false,
+    $schema: "https://rird.ai/config.json"
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2))
+  log(`Config saved to ${configPath}`)
+}
+
+// Install computer-use MCP (Mode B)
+function installComputerUseMcp() {
+  if (INSTALL_MODE !== "B") return
+
+  log("Installing computer-use MCP...")
+
+  if (isWindows) {
+    log("Windows: computer-use via uvx windows-mcp")
+    execSafe("pip install uv", { stdio: "inherit" })
+  } else if (isMac) {
+    log("macOS: Requires automation-mcp + Accessibility permissions")
+    const mcpPath = path.join(RIRD_HOME, "mcp", "automation-mcp")
+    if (!fs.existsSync(mcpPath)) {
+      fs.mkdirSync(path.join(RIRD_HOME, "mcp"), { recursive: true })
+      execSafe(`git clone --depth 1 https://github.com/ashwwwin/automation-mcp "${mcpPath}"`, { stdio: "inherit" })
+      if (fs.existsSync(mcpPath)) {
+        execSafe("bun install", { cwd: mcpPath, stdio: "inherit" })
+      }
+    }
+  } else if (isLinux) {
+    log("Linux: computer-use via npx mcp-desktop-automation")
+    // Pre-cache the package
+    execSafe("npx -y mcp-desktop-automation --version", { stdio: "pipe" })
+    // Install xdotool as fallback
+    execSafe("sudo apt install -y xdotool 2>/dev/null || true", { stdio: "pipe" })
+  }
+}
+
+// Find and symlink binary (non-Windows)
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `rird-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "opencode.exe" : "opencode"
+
+  try {
+    const packageJsonPath = require.resolve(`${packageName}/package.json`)
+    const packageDir = path.dirname(packageJsonPath)
+    const binaryPath = path.join(packageDir, "bin", binaryName)
+
+    if (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
+    }
+    return { binaryPath, binaryName }
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const binDir = path.join(__dirname, "..", "bin")
+  const targetPath = path.join(binDir, binaryName)
+
+  if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true })
+  }
+
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath)
+  }
+
+  fs.symlinkSync(sourcePath, targetPath)
+  log(`Binary symlinked: ${targetPath} -> ${sourcePath}`)
+}
+
+// Main
+async function main() {
+  log("Setting up RIRD AI...")
+  log(`Mode: ${INSTALL_MODE === "B" ? "Full Computer Use" : "Browser + Files"}`)
+  log(`Platform: ${os.platform()}-${os.arch()}`)
+
+  // Create directories
+  fs.mkdirSync(BIN_DIR, { recursive: true })
+  fs.mkdirSync(ENGINE_DIR, { recursive: true })
+
+  // Check Python
+  const pythonCmd = checkPython()
+  if (!pythonCmd) {
+    log("Warning: Python not found. Some features may not work.")
+  } else {
+    const pipCmd = checkPip(pythonCmd)
+    if (pipCmd) {
+      installPythonDeps(pipCmd)
+    }
+  }
+
+  // Clone stealth-browser-mcp
+  cloneStealthBrowserMcp()
+
+  // Create license validator
+  createLicenseValidator()
+
+  // Create config
+  createConfig(pythonCmd || "python3")
+
+  // Install computer-use MCP (Mode B)
+  installComputerUseMcp()
+
+  // Setup binary symlink (non-Windows)
+  if (!isWindows) {
+    try {
+      const { binaryPath, binaryName } = findBinary()
+      symlinkBinary(binaryPath, binaryName)
+    } catch (e) {
+      log(`Binary setup: ${e.message}`)
+    }
+  }
+
+  log("")
+  log("Setup complete!")
+  log("")
+  log("Next steps:")
+  log("  1. Get license at: rird.ai")
+  log("  2. Activate: rird activate YOUR_LICENSE_KEY")
+  log("  3. Run a task: rird \"go to google and search for AI\"")
+  log("")
+  if (INSTALL_MODE === "B") {
+    log("Full computer use mode enabled!")
+  }
+}
+
+try {
+  main()
+} catch (error) {
+  console.error("[RIRD] Setup error:", error.message)
+  process.exit(0) // Don't fail npm install
+}