rird-ai 2.1.221 → 2.1.223

package/bin/rird

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
 
+import { createRequire } from "module"
+import { fileURLToPath } from "url"
+import { dirname } from "path"
+
+const require = createRequire(import.meta.url)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
 const childProcess = require("child_process")
 const fs = require("fs")
 const path = require("path")
@@ -41,20 +49,26 @@ if (command === "upgrade" || command === "update") {
   console.log("  Upgrading to latest version...")
   console.log("")
 
-  const platform = os.platform()
+  // Check if npm is available
+  let hasNpm = false
+  try {
+    childProcess.execSync("npm --version", { stdio: "ignore" })
+    hasNpm = true
+  } catch (e) {}
+
   let result
 
-  if (platform === "win32") {
-    // Windows: Use npm to update (simpler and more reliable)
-    console.log("Running: npm install -g rird-ai@main")
+  if (hasNpm) {
+    console.log("Running: npm install -g rird@latest")
     console.log("")
     result = childProcess.spawnSync(
       "npm",
-      ["install", "-g", "rird-ai@main"],
+      ["install", "-g", "rird@latest"],
       { stdio: "inherit", shell: true }
     )
   } else {
-    // Unix/macOS: Use curl
+    // Fallback to curl for Unix/macOS if npm is missing
+    console.log("Running: curl -fsSL https://rird.ai/install.sh | bash")
     result = childProcess.spawnSync(
       "bash",
       ["-c", "curl -fsSL https://rird.ai/install.sh | bash"],
@@ -62,291 +76,254 @@ if (command === "upgrade" || command === "update") {
     )
   }
 
-  if (result.error) {
-    console.error("Upgrade failed:", result.error.message)
+  if (result.error || result.status !== 0) {
+    console.error("Upgrade failed. Please try running the install command manually.")
     process.exit(1)
   }
-  process.exit(result.status || 0)
-}
-
-// Branding replacements for output - order matters (specific patterns first)
-const REPLACEMENTS = [
-  // URLs and paths
-  { from: /sst\/opencode/gi, to: "rird.ai" },
-  { from: /opencode\.ai/gi, to: "rird.ai" },
-  { from: /rird\.ai\/desktop/gi, to: "rird.ai" },
-  { from: /https?:\/\/[^\s]*opencode[^\s]*/gi, to: (match) => match.replace(/opencode/gi, "rird") },
-  // Known fake/test model names
-  { from: /OpenCode Zen/gi, to: "RIRD AI" },
-  { from: /OpenCode\/Zen/gi, to: "RIRD AI" },
-  { from: /opencode-zen/gi, to: "rird-brain" },
-  { from: /Big Pickle/gi, to: "RIRD AI" },
-  { from: /big-pickle/gi, to: "rird-brain" },
-  { from: /gpt-5-nano/gi, to: "RIRD Brain" },
-  { from: /GPT-5 Nano/gi, to: "RIRD Brain" },
-  // Provider/model name patterns (catch OpenCode/anything)
-  { from: /OpenCode\s*\/\s*(\w+)/gi, to: "RIRD/$1" },
-  // Generic branding
-  { from: /OpenCode/g, to: "RIRD" },
-  { from: /opencode/g, to: "rird" },
-]
-
-function replaceBranding(data) {
-  let str = data.toString()
-  for (const { from, to } of REPLACEMENTS) {
-    str = str.replace(from, to)
-  }
-  return str
+  process.exit(0)
 }
 
-function runWithPty(target, args, env) {
-  let pty = null
-  try {
-    pty = require("bun-pty")
-  } catch (e1) {
-    try {
-      pty = require("node-pty")
-    } catch (e2) {
-      return false // PTY not available
-    }
-  }
-
-  const cols = process.stdout.columns || 80
-  const rows = process.stdout.rows || 24
-  const cwd = env.RIRD_ENGINE_DIR || process.cwd()
-
-  try {
-    const ptyProcess = pty.spawn(target, args, {
-      name: "xterm-256color",
-      cols: cols,
-      rows: rows,
-      cwd: cwd,
-      env: env,
-      ...(os.platform() === "win32" && {
-        useConpty: true,
-        conptyInheritCursor: true,
-      }),
-    })
+// Activate - save license key and validate
+if (command === "activate") {
+  const key = process.argv[3]
 
-    // Handle output with branding replacement
-    ptyProcess.onData((data) => {
-      process.stdout.write(replaceBranding(data))
-    })
+  console.log("")
+  console.log("  RIRD AI")
+  console.log("  Activating license...")
+  console.log("")
 
-    // Handle input
-    if (process.stdin.isTTY) {
-      process.stdin.setRawMode(true)
-    }
-    process.stdin.resume()
-    process.stdin.on("data", (data) => {
-      ptyProcess.write(data.toString())
-    })
+  if (!key || key.length < 10) {
+    console.error("  Error: Invalid license key format")
+    console.log("")
+    console.log("  Usage: rird activate YOUR_LICENSE_KEY")
+    console.log("  Get your key at: https://rird.ai")
+    console.log("")
+    process.exit(1)
+  }
 
-    // Handle terminal resize
-    process.stdout.on("resize", () => {
-      ptyProcess.resize(
-        process.stdout.columns || 80,
-        process.stdout.rows || 24
-      )
-    })
+  const rirdHome = process.env.RIRD_HOME || path.join(os.homedir(), ".rird")
+  const licensePath = path.join(rirdHome, "license.key")
+  const cachePath = path.join(rirdHome, "license_cache.json")
 
-    // Handle exit
-    let exited = false
-    ptyProcess.onExit(({ exitCode }) => {
-      if (exited) return
-      exited = true
-      if (process.stdin.isTTY) {
-        process.stdin.setRawMode(false)
-      }
-      process.stdin.pause()
-      process.exit(exitCode || 0)
-    })
+  if (!fs.existsSync(rirdHome)) {
+    fs.mkdirSync(rirdHome, { recursive: true })
+  }
 
-    // Handle signals - pass to child, don't exit wrapper
-    process.on("SIGINT", () => {
-      if (!exited) ptyProcess.write("\x03") // Send Ctrl+C to PTY
-    })
-    process.on("SIGTERM", () => {
-      if (!exited) ptyProcess.kill()
-    })
+  fs.writeFileSync(licensePath, key.trim())
+  console.log("  License key saved")
 
-    return true // PTY started successfully
-  } catch (err) {
-    return false // PTY failed
+  if (fs.existsSync(cachePath)) {
+    fs.unlinkSync(cachePath)
   }
-}
 
-function runWithPipes(target, args, env) {
-  const cwd = env.RIRD_ENGINE_DIR || process.cwd()
-  const child = childProcess.spawn(target, args, {
-    env: env,
-    cwd: cwd,
-    stdio: ["pipe", "pipe", "pipe"],
-  })
+  console.log("  Validating license...")
 
-  let exited = false
+  const https = require("https")
+  const crypto = require("crypto")
 
-  child.stdout.on("data", (data) => {
-    if (!exited) process.stdout.write(replaceBranding(data))
-  })
+  const parts = [os.hostname(), os.platform(), os.arch(), os.totalmem().toString(), os.cpus().length.toString()]
+  const fingerprint = crypto.createHash("sha256").update(parts.join("|")).digest("hex").substring(0, 32)
 
-  child.stderr.on("data", (data) => {
-    if (!exited) process.stderr.write(replaceBranding(data))
+  const postData = JSON.stringify({
+    license_key: key.trim(),
+    device_fingerprint: fingerprint,
+    version: require("../package.json").version,
+    platform: os.platform()
   })
 
-  process.stdin.pipe(child.stdin)
+  const options = {
+    hostname: "rird.ai",
+    port: 443,
+    path: "/api/desktop/validate-license",
+    method: "POST",
+    headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(postData) }
+  }
 
-  child.on("exit", (code) => {
-    if (exited) return
-    exited = true
-    process.stdin.unpipe(child.stdin)
-    process.stdin.pause()
-    process.exit(code || 0)
+  const req = https.request(options, (res) => {
+    let data = ""
+    res.on("data", (chunk) => data += chunk)
+    res.on("end", () => {
+      try {
+        const result = JSON.parse(data)
+        if (res.statusCode === 200 && result.valid) {
+          console.log("")
+          console.log("  License activated!")
+          if (result.user && result.user.email) console.log("  Welcome, " + result.user.email)
+          console.log("")
+          console.log("  Run 'rird' to get started")
+          console.log("")
+          fs.writeFileSync(cachePath, JSON.stringify({
+            license_key: key.trim(), valid: true,
+            email: result.user ? result.user.email : null,
+            plan: result.user ? result.user.plan : null,
+            cached_at: new Date().toISOString()
+          }))
+          process.exit(0)
+        } else {
+          console.error("")
+          console.error("  Activation failed: " + (result.error || "Invalid license"))
+          console.log("  Check your key and try again")
+          console.log("")
+          process.exit(1)
+        }
+      } catch (e) {
+        console.error("  Error parsing response:", e.message)
+        process.exit(1)
+      }
+    })
   })
 
-  child.on("error", (err) => {
-    if (exited) return
-    exited = true
-    console.error("Failed to start process:", err.message)
+  req.on("error", (e) => {
+    console.error("")
+    console.error("  Could not reach license server: " + e.message)
+    console.log("")
     process.exit(1)
   })
 
-  process.on("SIGINT", () => {
-    if (!exited) child.kill("SIGINT")
-  })
-  process.on("SIGTERM", () => {
-    if (!exited) child.kill("SIGTERM")
-  })
-}
+  req.write(postData)
+  req.end()
+} else if (command === "status") {
+  console.log("")
+  console.log("  RIRD AI")
+  console.log("  Checking license status...")
+  console.log("")
 
-function run(target) {
-  // Set config path to RIRD config
   const rirdHome = process.env.RIRD_HOME || path.join(os.homedir(), ".rird")
-  const brainDir = path.join(rirdHome, "brain")
-  const configPath = path.join(brainDir, "rird.json")
+  const licensePath = path.join(rirdHome, "license.key")
+  const cachePath = path.join(rirdHome, "license_cache.json")
 
-  // Ensure brain directory exists
-  if (!fs.existsSync(brainDir)) {
-    fs.mkdirSync(brainDir, { recursive: true })
+  if (!fs.existsSync(licensePath)) {
+    console.log("  Status: Not activated")
+    console.log("")
+    console.log("  Run: rird activate YOUR_LICENSE_KEY")
+    console.log("  Get your key at: https://rird.ai")
+    console.log("")
+    process.exit(0)
   }
 
-  // Create default config if it doesn't exist
-  if (!fs.existsSync(configPath)) {
-    const defaultConfig = {
-      name: "RIRD AI",
-      autoupdate: false,
-      instructions: [
-        "You are RIRD AI with browser automation and computer control.",
-        "Use file tools (Write, Edit) for saving data.",
-        "Execute tasks autonomously and efficiently."
-      ],
-      permission: {
-        edit: "allow",
-        bash: "allow",
-        skill: "allow",
-        webfetch: "allow",
-        external_directory: "allow"
+  const key = fs.readFileSync(licensePath, "utf-8").trim()
+
+  if (fs.existsSync(cachePath)) {
+    try {
+      const cache = JSON.parse(fs.readFileSync(cachePath, "utf-8"))
+      if (cache.valid && cache.license_key === key) {
+        console.log("  Status: Active")
+        if (cache.email) console.log("  Account: " + cache.email)
+        if (cache.plan) console.log("  Plan: " + cache.plan)
+        console.log("")
+        process.exit(0)
       }
-    }
-    fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2))
+    } catch (e) {}
   }
 
-  const env = { ...process.env }
-  env.OPENCODE_CONFIG = configPath
-  env.RIRD_ENGINE_DIR = brainDir
-  env.RIRD_DISABLE_AUTOUPDATE = "true"
-  env.OPENCODE_DISABLE_AUTOUPDATE = "true"
-  env.OPENCODE_SKIP_UPDATE = "true"
+  console.log("  Status: License key found, checking online...")
+  console.log("")
+  process.exit(0)
+} else {
+  // Only run the binary if NOT processing a special command
+  const envPath = process.env.RIRD_BIN_PATH
+  if (envPath) {
+    run(envPath)
+  }
 
-  const args = process.argv.slice(2)
+  const scriptPath = fs.realpathSync(__filename)
+  const scriptDir = path.dirname(scriptPath)
 
-  // On Windows, use inherited stdio for full TUI support
-  // (branding replacement happens at source level instead)
-  if (os.platform() === "win32") {
-    const child = childProcess.spawn(target, args, {
-      stdio: "inherit",
-      env: env,
-      cwd: env.RIRD_ENGINE_DIR || process.cwd(),
-    })
-    child.on("exit", (code) => process.exit(code || 0))
-    child.on("error", (err) => {
-      console.error(err.message)
-      process.exit(1)
-    })
-    return
+  const platformMap = {
+    darwin: "darwin",
+    linux: "linux",
+    win32: "windows",
+  }
+  const archMap = {
+    x64: "x64",
+    arm64: "arm64",
+    arm: "arm",
   }
 
-  // Try PTY first for full terminal support with branding replacement
-  if (runWithPty(target, args, env)) {
-    return // PTY started successfully
+  let platform = platformMap[os.platform()]
+  if (!platform) {
+    platform = os.platform()
+  }
+  let arch = archMap[os.arch()]
+  if (!arch) {
+    arch = os.arch()
+  }
+  const base = "rird-" + platform + "-" + arch
+  const binary = platform === "windows" ? "rird.exe" : "rird"
+
+  function findBinary(startDir) {
+    let current = startDir
+    for (;;) {
+      const modules = path.join(current, "node_modules")
+      if (fs.existsSync(modules)) {
+        const entries = fs.readdirSync(modules)
+        for (const entry of entries) {
+          if (!entry.startsWith(base)) {
+            continue
+          }
+          const candidate = path.join(modules, entry, "bin", binary)
+          if (fs.existsSync(candidate)) {
+            return candidate
+          }
+        }
+      }
+      const parent = path.dirname(current)
+      if (parent === current) {
+        return
+      }
+      current = parent
+    }
   }
 
-  // Fall back to pipes with branding replacement
-  runWithPipes(target, args, env)
-}
+  const rirdHome = process.env.RIRD_HOME || path.join(os.homedir(), ".rird")
+  const engineDir = path.join(rirdHome, "engine")
+  const brainDir = path.join(rirdHome, "brain")
 
-const envPath = process.env.OPENCODE_BIN_PATH
-if (envPath) {
-  run(envPath)
-}
+  // Use engine config (from postinstall with MCP) if it exists, otherwise brain
+  const engineConfig = path.join(engineDir, "rird.json")
+  const brainConfig = path.join(brainDir, "rird.json")
+  const configPath = fs.existsSync(engineConfig) ? engineConfig : brainConfig
+  const workDir = fs.existsSync(engineConfig) ? engineDir : brainDir
 
-const scriptPath = fs.realpathSync(__filename)
-const scriptDir = path.dirname(scriptPath)
+  const env = { ...process.env }
+  env.RIRD_CONFIG = configPath
+  env.RIRD_ENGINE_DIR = workDir
+  // Enable RIRD search tools
+  env.RIRD_ENABLE_SEARCH = "true"
 
-const platformMap = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-}
-const archMap = {
-  x64: "x64",
-  arm64: "arm64",
-  arm: "arm",
-}
+  function run(binPath) {
+    const result = childProcess.spawnSync(binPath, args, {
+      stdio: "inherit",
+      env: env,
+      cwd: process.cwd(),
+      shell: os.platform() === 'win32'
+    })
+    process.exit(result.status ?? 0)
+  }
 
-let platform = platformMap[os.platform()]
-if (!platform) {
-  platform = os.platform()
-}
-let arch = archMap[os.arch()]
-if (!arch) {
-  arch = os.arch()
-}
-const base = "rird-" + platform + "-" + arch
-const binary = platform === "windows" ? "opencode.exe" : "opencode"
-
-function findBinary(startDir) {
-  let current = startDir
-  for (;;) {
-    const modules = path.join(current, "node_modules")
-    if (fs.existsSync(modules)) {
-      const entries = fs.readdirSync(modules)
-      for (const entry of entries) {
-        if (!entry.startsWith(base)) {
-          continue
-        }
-        const candidate = path.join(modules, entry, "bin", binary)
-        if (fs.existsSync(candidate)) {
-          return candidate
-        }
-      }
-    }
-    const parent = path.dirname(current)
-    if (parent === current) {
-      return
+  const args = process.argv.slice(2)
+
+  const resolved = findBinary(scriptDir)
+  if (!resolved) {
+    // FALLBACK: If binary not found, try to run from source if in dev tree
+    const sourceIndex = path.join(scriptDir, "..", "src", "index.ts")
+    if (fs.existsSync(sourceIndex)) {
+      childProcess.spawnSync("bun", ["run", "--conditions=browser", sourceIndex, ...args], {
+        stdio: "inherit",
+        env: env,
+        cwd: env.RIRD_ENGINE_DIR || process.cwd(),
+        shell: true
+      })
+      process.exit(0)
     }
-    current = parent
+
+    console.error(
+      'It seems that your package manager failed to install the right version of the RIRD CLI for your platform. You can try manually installing the "' +
+        base +
+        '" package',
+    )
+    process.exit(1)
   }
-}
 
-const resolved = findBinary(scriptDir)
-if (!resolved) {
-  console.error(
-    'It seems that your package manager failed to install the right version of the RIRD CLI for your platform. You can try manually installing the "' +
-      base +
-      '" package',
-  )
-  process.exit(1)
+  run(resolved)
 }
-
-run(resolved)

package/package.json

@@ -1 +1,23 @@
-{"name":"rird-ai","version":"2.1.221","bin":{"rird":"./bin/rird"},"scripts":{"postinstall":"node ./postinstall.mjs"},"optionalDependencies":{"rird-windows-x64":"0.0.0-main-202601012037"}}
+{
+  "name": "rird-ai",
+  "bin": {
+    "rird": "./bin/rird"
+  },
+  "scripts": {
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
+  },
+  "version": "2.1.223",
+  "optionalDependencies": {
+    "rird-linux-arm64": "2.1.223",
+    "rird-linux-x64": "2.1.223",
+    "rird-linux-x64-baseline": "2.1.223",
+    "rird-linux-arm64-musl": "2.1.223",
+    "rird-linux-x64-musl": "2.1.223",
+    "rird-linux-x64-baseline-musl": "2.1.223",
+    "rird-darwin-arm64": "2.1.223",
+    "rird-darwin-x64": "2.1.223",
+    "rird-darwin-x64-baseline": "2.1.223",
+    "rird-windows-x64": "2.1.223",
+    "rird-windows-x64-baseline": "2.1.223"
+  }
+}

package/postinstall.mjs

@@ -309,6 +309,16 @@ function createConfig(pythonCmd) {
         "- Launch and interact with desktop applications",
         "- Take screenshots and analyze what's on screen",
         "",
+        "=== RESEARCH STRATEGY ===",
+        "For ANY task that asks to 'find URLs', 'output URLs', 'list profiles', or 'get X items':",
+        "1. ALWAYS START with websearch - it is instant and bypasses detection.",
+        "2. Only fall back to browser automation if websearch fails or task requires interaction (login, forms).",
+        "",
+        "=== TOOL PRIORITY ===",
+        "1. websearch: Use for finding URLs, profiles, and public info.",
+        "2. Browser (stealth-browser): Use for interaction, scrolling, and map searching.",
+        "3. Computer Use: Use for desktop applications when enabled.",
+        "",
         "=== HOW I WORK ===",
         "1. WEB SEARCH:",
         "   - Finding URLs, quick facts, lists of companies or profiles",
@@ -334,6 +344,15 @@ function createConfig(pythonCmd) {
         "- Extract data from websites",
         "- Read and write files on your computer",
         "",
+        "=== RESEARCH STRATEGY ===",
+        "For ANY task that asks to 'find URLs', 'output URLs', 'list profiles', or 'get X items':",
+        "1. ALWAYS START with websearch - it is instant and bypasses detection.",
+        "2. Only fall back to browser automation if websearch fails or task requires interaction (login, forms).",
+        "",
+        "=== TOOL PRIORITY ===",
+        "1. websearch: Use for finding URLs, profiles, and public info.",
+        "2. Browser (stealth-browser): Use for interaction, scrolling, and map searching.",
+        "",
         "=== HOW I WORK ===",
         "1. WEB SEARCH:",
         "   - Finding URLs, quick facts, lists of companies or profiles",
@@ -408,6 +427,10 @@ function createConfig(pythonCmd) {
       webfetch: "allow",
       external_directory: "allow"
     },
+    tools: {
+      websearch: true,
+      codesearch: true
+    },
     autoupdate: false,
     $schema: "https://rird.ai/config.json"
   }