rird-ai 2.3.0 → 2.3.2

package/bin/pty-wrapper.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+/**
+ * PTY Wrapper for RIRD
+ *
+ * Intercepts OpenCode binary output and replaces branding strings.
+ * Works on Windows, macOS, and Linux.
+ *
+ * Usage:
+ *   node pty-wrapper.js <path-to-binary> [args...]
+ *
+ * Environment:
+ *   RIRD_NO_PTY=1  - Disable PTY, use simple pipes (fallback mode)
+ */
+
+const childProcess = require("child_process")
+const fs = require("fs")
+const path = require("path")
+const os = require("os")
+
+// 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" },
+]
+
+/**
+ * Replace branding strings in a buffer/string
+ */
+function replaceBranding(data) {
+  let str = data.toString()
+  for (const { from, to } of REPLACEMENTS) {
+    str = str.replace(from, to)
+  }
+  return str
+}
+
+/**
+ * Try to load node-pty dynamically
+ */
+function tryLoadPty() {
+  try {
+    // Try bun-pty first (listed in package.json)
+    return require("bun-pty")
+  } catch (e1) {
+    try {
+      // Fall back to node-pty
+      return require("node-pty")
+    } catch (e2) {
+      return null
+    }
+  }
+}
+
+/**
+ * Run with PTY (interactive TUI support)
+ */
+function runWithPty(pty, binaryPath, args, env) {
+  const isWindows = os.platform() === "win32"
+  const shell = isWindows ? "cmd.exe" : undefined
+
+  // Get terminal size
+  const cols = process.stdout.columns || 80
+  const rows = process.stdout.rows || 24
+
+  // Spawn PTY
+  const ptyProcess = pty.spawn(binaryPath, args, {
+    name: "xterm-256color",
+    cols: cols,
+    rows: rows,
+    cwd: process.cwd(),
+    env: env,
+    // Windows-specific options
+    ...(isWindows && {
+      useConpty: true,
+      conptyInheritCursor: true,
+    }),
+  })
+
+  // Handle output with branding replacement
+  ptyProcess.onData((data) => {
+    const replaced = replaceBranding(data)
+    process.stdout.write(replaced)
+  })
+
+  // Handle input
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true)
+  }
+  process.stdin.resume()
+  process.stdin.on("data", (data) => {
+    ptyProcess.write(data.toString())
+  })
+
+  // Handle terminal resize
+  process.stdout.on("resize", () => {
+    ptyProcess.resize(
+      process.stdout.columns || 80,
+      process.stdout.rows || 24
+    )
+  })
+
+  // Handle exit
+  ptyProcess.onExit(({ exitCode }) => {
+    if (process.stdin.isTTY) {
+      process.stdin.setRawMode(false)
+    }
+    process.exit(exitCode)
+  })
+
+  // Handle signals
+  process.on("SIGINT", () => {
+    ptyProcess.kill("SIGINT")
+  })
+  process.on("SIGTERM", () => {
+    ptyProcess.kill("SIGTERM")
+  })
+}
+
+/**
+ * Run with simple pipes (fallback mode, less interactive)
+ */
+function runWithPipes(binaryPath, args, env) {
+  const isWindows = os.platform() === "win32"
+
+  // Use spawn with pipe for stdout/stderr to intercept output
+  const child = childProcess.spawn(binaryPath, args, {
+    env: env,
+    cwd: process.cwd(),
+    stdio: ["pipe", "pipe", "pipe"],
+    // Windows needs shell for some binaries
+    ...(isWindows && { shell: false }),
+  })
+
+  // Buffer for incomplete ANSI sequences
+  let stdoutBuffer = ""
+  let stderrBuffer = ""
+
+  // Process stdout
+  child.stdout.on("data", (data) => {
+    stdoutBuffer += data.toString()
+    // Process complete lines or flush on certain patterns
+    const replaced = replaceBranding(stdoutBuffer)
+    process.stdout.write(replaced)
+    stdoutBuffer = ""
+  })
+
+  // Process stderr
+  child.stderr.on("data", (data) => {
+    stderrBuffer += data.toString()
+    const replaced = replaceBranding(stderrBuffer)
+    process.stderr.write(replaced)
+    stderrBuffer = ""
+  })
+
+  // Forward stdin
+  process.stdin.pipe(child.stdin)
+
+  // Handle exit
+  child.on("exit", (code) => {
+    // Flush any remaining buffers
+    if (stdoutBuffer) {
+      process.stdout.write(replaceBranding(stdoutBuffer))
+    }
+    if (stderrBuffer) {
+      process.stderr.write(replaceBranding(stderrBuffer))
+    }
+    process.exit(code || 0)
+  })
+
+  child.on("error", (err) => {
+    console.error("Failed to start process:", err.message)
+    process.exit(1)
+  })
+
+  // Handle signals
+  process.on("SIGINT", () => {
+    child.kill("SIGINT")
+  })
+  process.on("SIGTERM", () => {
+    child.kill("SIGTERM")
+  })
+}
+
+/**
+ * Run with inherited stdio (no branding replacement, but full interactivity)
+ * Used when PTY fails and pipes don't work well
+ */
+function runWithInherited(binaryPath, args, env) {
+  const result = childProcess.spawnSync(binaryPath, args, {
+    stdio: "inherit",
+    env: env,
+    cwd: process.cwd(),
+  })
+
+  if (result.error) {
+    console.error("Failed to start process:", result.error.message)
+    process.exit(1)
+  }
+
+  process.exit(result.status || 0)
+}
+
+/**
+ * Main entry point
+ */
+function main() {
+  const args = process.argv.slice(2)
+
+  if (args.length === 0) {
+    console.error("Usage: pty-wrapper.js <binary> [args...]")
+    process.exit(1)
+  }
+
+  const binaryPath = args[0]
+  const binaryArgs = args.slice(1)
+
+  // Verify binary exists
+  if (!fs.existsSync(binaryPath)) {
+    console.error("Binary not found:", binaryPath)
+    process.exit(1)
+  }
+
+  // Prepare environment
+  const env = { ...process.env }
+
+  // Check for fallback mode
+  const usePipes = process.env.RIRD_NO_PTY === "1"
+  const useInherited = process.env.RIRD_INHERITED === "1"
+
+  if (useInherited) {
+    // No branding replacement, full interactivity
+    runWithInherited(binaryPath, binaryArgs, env)
+    return
+  }
+
+  if (usePipes) {
+    // Simple pipes mode
+    runWithPipes(binaryPath, binaryArgs, env)
+    return
+  }
+
+  // Try PTY first
+  const pty = tryLoadPty()
+
+  if (pty && process.stdout.isTTY) {
+    try {
+      runWithPty(pty, binaryPath, binaryArgs, env)
+      return
+    } catch (err) {
+      // PTY failed, fall through to pipes
+      console.error("PTY initialization failed, falling back to pipes:", err.message)
+    }
+  }
+
+  // Fall back to pipes
+  runWithPipes(binaryPath, binaryArgs, env)
+}
+
+// Export for testing
+module.exports = {
+  replaceBranding,
+  REPLACEMENTS,
+}
+
+// Run if executed directly
+if (require.main === module) {
+  main()
+}

package/bin/rird

@@ -351,6 +351,14 @@ if (command === "activate") {
   env.RIRD_ENGINE_DIR = workDir
   // Enable RIRD search tools
   env.RIRD_ENABLE_SEARCH = "true"
+  // Ship defaults: prioritize startup/runtime latency.
+  // These are opt-out so power users can re-enable by setting env vars.
+  if (!("RIRD_DISABLE_SNAPSHOTS" in env)) env.RIRD_DISABLE_SNAPSHOTS = "1"
+  if (!("RIRD_DISABLE_SESSION_SUMMARY" in env)) env.RIRD_DISABLE_SESSION_SUMMARY = "1"
+  // Keep startup latency low by default (users can still run `rird upgrade`).
+  if (!("RIRD_SKIP_AUTO_UPDATE" in env) && !("OPENCODE_SKIP_AUTO_UPDATE" in env)) {
+    env.RIRD_SKIP_AUTO_UPDATE = "1"
+  }
 
   // PRIMARY: Inject license key directly - this is the most reliable auth method
   const licenseKeyPath = path.join(rirdHome, "license.key")
@@ -366,33 +374,6 @@ if (command === "activate") {
     }
   }
 
-  // FALLBACK: Inject provider API keys from license cache
-  const licenseCachePath = path.join(rirdHome, "license_cache.json")
-  if (fs.existsSync(licenseCachePath)) {
-    try {
-      const licenseCache = JSON.parse(fs.readFileSync(licenseCachePath, "utf-8"))
-      if (licenseCache.providers) {
-        if (licenseCache.providers.deepseek && licenseCache.providers.deepseek.apiKey) {
-          env.DEEPSEEK_API_KEY = licenseCache.providers.deepseek.apiKey
-        }
-        if (licenseCache.providers.siliconflow && licenseCache.providers.siliconflow.apiKey) {
-          env.SILICONFLOW_API_KEY = licenseCache.providers.siliconflow.apiKey
-        }
-        if (licenseCache.providers.openai && licenseCache.providers.openai.apiKey) {
-          env.OPENAI_API_KEY = licenseCache.providers.openai.apiKey
-        }
-        if (licenseCache.providers.anthropic && licenseCache.providers.anthropic.apiKey) {
-          env.ANTHROPIC_API_KEY = licenseCache.providers.anthropic.apiKey
-        }
-        if (licenseCache.providers.google && licenseCache.providers.google.apiKey) {
-          env.GOOGLE_GENERATIVE_AI_API_KEY = licenseCache.providers.google.apiKey
-        }
-      }
-    } catch (e) {
-      // Ignore cache read errors
-    }
-  }
-
   function run(binPath) {
     const result = childProcess.spawnSync(binPath, args, {
       stdio: "inherit",

package/bin/rird-perf.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+
+// Performance timing wrapper for rird binary
+const startTime = Date.now();
+
+// Mark key milestones
+const perf = {
+  start: 0,
+  importsDone: null,
+  commandStart: null,
+  commandEnd: null,
+};
+
+perf.start = Date.now() - startTime;
+
+// Track where actual command execution happens
+const originalExit = process.exit;
+let exitCode = 0;
+
+process.exit = function(code) {
+  perf.commandEnd = Date.now() - startTime;
+  
+  const elapsed = perf.commandEnd - perf.start;
+  const debugFlag = process.argv.includes("--perf-debug") || process.env.RIRD_PERF_DEBUG;
+  
+  if (debugFlag || elapsed > 1000) {
+    console.error(`[RIRD PERF] Total: ${elapsed}ms`);
+    if (elapsed > 1000) {
+      console.error("[RIRD WARN] Slow startup detected - consider profiling");
+    }
+  }
+  
+  originalExit.call(process, code);
+};
+
+// Now execute the actual rird binary
+import("./rird.js");

package/package.json

@@ -1,31 +1,24 @@
 {
   "name": "rird-ai",
-  "version": "2.3.0",
-  "description": "RIRD - AI computer use agent with browser automation",
-  "license": "MIT",
-  "homepage": "https://rird.ai",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/rird-ai/rird.git"
-  },
+  "type": "module",
   "bin": {
     "rird": "./bin/rird"
   },
   "scripts": {
-    "postinstall": "node ./postinstall.mjs"
+    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
+  "version": "2.3.2",
   "optionalDependencies": {
-    "rird-windows-x64": "2.3.0",
-    "rird-windows-x64-baseline": "2.3.0",
-    "rird-darwin-arm64": "2.3.0",
-    "rird-darwin-x64": "2.3.0",
-    "rird-darwin-x64-baseline": "2.3.0",
-    "rird-linux-arm64": "2.3.0",
-    "rird-linux-x64": "2.3.0",
-    "rird-linux-x64-baseline": "2.3.0",
-    "rird-linux-arm64-musl": "2.3.0",
-    "rird-linux-x64-musl": "2.3.0",
-    "rird-linux-x64-baseline-musl": "2.3.0"
-  },
-  "keywords": ["ai", "automation", "browser", "rird"]
-}
+    "rird-linux-arm64": "2.3.2",
+    "rird-linux-x64": "2.3.2",
+    "rird-linux-x64-baseline": "2.3.2",
+    "rird-linux-arm64-musl": "2.3.2",
+    "rird-linux-x64-musl": "2.3.2",
+    "rird-linux-x64-baseline-musl": "2.3.2",
+    "rird-darwin-arm64": "2.3.2",
+    "rird-darwin-x64": "2.3.2",
+    "rird-darwin-x64-baseline": "2.3.2",
+    "rird-windows-x64": "2.3.2",
+    "rird-windows-x64-baseline": "2.3.2"
+  }
+}

package/postinstall.mjs

@@ -350,7 +350,8 @@ function createConfig(pythonCmd) {
 
   const config = {
     model: "rird/qwen3:8b",
-    small_model: "rird/deepseek-reasoner",
+    // Use the Actor model for tool-call continuation steps (fast + tool-call compatible).
+    small_model: "rird/qwen3:8b",
     visionModel: "rird/qwen2.5-vl-7b",
     agent: {
       plan: { model: "rird/deepseek-reasoner" },
@@ -367,6 +368,7 @@ function createConfig(pythonCmd) {
             reasoning: true,
             temperature: true,
             tool_call: true,
+            interleaved: { field: "reasoning_content" },
             limit: { context: 32768, output: 8192 },
             options: {}
           },
@@ -388,7 +390,7 @@ function createConfig(pythonCmd) {
             attachment: true,
             reasoning: false,
             temperature: true,
-            tool_call: true,
+            tool_call: false,
             limit: { context: 32768, output: 8192 },
             modalities: { input: ["text", "image"], output: ["text"] },
             options: {}