rird 1.0.200

package/src/util/filesystem.ts

@@ -0,0 +1,83 @@
+import { realpathSync } from "fs"
+import { exists } from "fs/promises"
+import { dirname, join, relative } from "path"
+
+export namespace Filesystem {
+  /**
+   * On Windows, normalize a path to its canonical casing using the filesystem.
+   * This is needed because Windows paths are case-insensitive but LSP servers
+   * may return paths with different casing than what we send them.
+   */
+  export function normalizePath(p: string): string {
+    if (process.platform !== "win32") return p
+    try {
+      return realpathSync.native(p)
+    } catch {
+      return p
+    }
+  }
+  export function overlaps(a: string, b: string) {
+    const relA = relative(a, b)
+    const relB = relative(b, a)
+    return !relA || !relA.startsWith("..") || !relB || !relB.startsWith("..")
+  }
+
+  export function contains(parent: string, child: string) {
+    return !relative(parent, child).startsWith("..")
+  }
+
+  export async function findUp(target: string, start: string, stop?: string) {
+    let current = start
+    const result = []
+    while (true) {
+      const search = join(current, target)
+      if (await exists(search)) result.push(search)
+      if (stop === current) break
+      const parent = dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+    return result
+  }
+
+  export async function* up(options: { targets: string[]; start: string; stop?: string }) {
+    const { targets, start, stop } = options
+    let current = start
+    while (true) {
+      for (const target of targets) {
+        const search = join(current, target)
+        if (await exists(search)) yield search
+      }
+      if (stop === current) break
+      const parent = dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+  }
+
+  export async function globUp(pattern: string, start: string, stop?: string) {
+    let current = start
+    const result = []
+    while (true) {
+      try {
+        const glob = new Bun.Glob(pattern)
+        for await (const match of glob.scan({
+          cwd: current,
+          absolute: true,
+          onlyFiles: true,
+          followSymlinks: true,
+          dot: true,
+        })) {
+          result.push(match)
+        }
+      } catch {
+        // Skip invalid glob patterns
+      }
+      if (stop === current) break
+      const parent = dirname(current)
+      if (parent === current) break
+      current = parent
+    }
+    return result
+  }
+}

package/src/util/fn.ts

@@ -0,0 +1,11 @@
+import { z } from "zod"
+
+export function fn<T extends z.ZodType, Result>(schema: T, cb: (input: z.infer<T>) => Result) {
+  const result = (input: z.infer<T>) => {
+    const parsed = schema.parse(input)
+    return cb(parsed)
+  }
+  result.force = (input: z.infer<T>) => cb(input)
+  result.schema = schema
+  return result
+}

package/src/util/iife.ts

@@ -0,0 +1,3 @@
+export function iife<T>(fn: () => T) {
+  return fn()
+}

package/src/util/keybind.ts

@@ -0,0 +1,102 @@
+import { isDeepEqual } from "remeda"
+import type { ParsedKey } from "@opentui/core"
+
+export namespace Keybind {
+  /**
+   * Keybind info derived from OpenTUI's ParsedKey with our custom `leader` field.
+   * This ensures type compatibility and catches missing fields at compile time.
+   */
+  export type Info = Pick<ParsedKey, "name" | "ctrl" | "meta" | "shift" | "super"> & {
+    leader: boolean // our custom field
+  }
+
+  export function match(a: Info, b: Info): boolean {
+    // Normalize super field (undefined and false are equivalent)
+    const normalizedA = { ...a, super: a.super ?? false }
+    const normalizedB = { ...b, super: b.super ?? false }
+    return isDeepEqual(normalizedA, normalizedB)
+  }
+
+  /**
+   * Convert OpenTUI's ParsedKey to our Keybind.Info format.
+   * This helper ensures all required fields are present and avoids manual object creation.
+   */
+  export function fromParsedKey(key: ParsedKey, leader = false): Info {
+    return {
+      name: key.name,
+      ctrl: key.ctrl,
+      meta: key.meta,
+      shift: key.shift,
+      super: key.super ?? false,
+      leader,
+    }
+  }
+
+  export function toString(info: Info): string {
+    const parts: string[] = []
+
+    if (info.ctrl) parts.push("ctrl")
+    if (info.meta) parts.push("alt")
+    if (info.super) parts.push("super")
+    if (info.shift) parts.push("shift")
+    if (info.name) {
+      if (info.name === "delete") parts.push("del")
+      else parts.push(info.name)
+    }
+
+    let result = parts.join("+")
+
+    if (info.leader) {
+      result = result ? `<leader> ${result}` : `<leader>`
+    }
+
+    return result
+  }
+
+  export function parse(key: string): Info[] {
+    if (key === "none") return []
+
+    return key.split(",").map((combo) => {
+      // Handle <leader> syntax by replacing with leader+
+      const normalized = combo.replace(/<leader>/g, "leader+")
+      const parts = normalized.toLowerCase().split("+")
+      const info: Info = {
+        ctrl: false,
+        meta: false,
+        shift: false,
+        leader: false,
+        name: "",
+      }
+
+      for (const part of parts) {
+        switch (part) {
+          case "ctrl":
+            info.ctrl = true
+            break
+          case "alt":
+          case "meta":
+          case "option":
+            info.meta = true
+            break
+          case "super":
+            info.super = true
+            break
+          case "shift":
+            info.shift = true
+            break
+          case "leader":
+            info.leader = true
+            break
+          case "esc":
+            info.name = "escape"
+            break
+          default:
+            info.name = part
+            break
+        }
+      }
+
+      return info
+    })
+  }
+}

package/src/util/lazy.ts

@@ -0,0 +1,11 @@
+export function lazy<T>(fn: () => T) {
+  let value: T | undefined
+  let loaded = false
+
+  return (): T => {
+    if (loaded) return value as T
+    loaded = true
+    value = fn()
+    return value as T
+  }
+}

package/src/util/license.ts

@@ -0,0 +1,325 @@
+import path from "path"
+import os from "os"
+import fs from "fs"
+import crypto from "crypto"
+import { execSync } from "child_process"
+import { Log } from "./log"
+
+const LICENSE_CACHE_PATH = path.join(os.homedir(), ".rird", "license_cache.json")
+const LICENSE_KEY_PATH = path.join(os.homedir(), ".rird", "license.key")
+const RIRD_API_URL = "https://rird.ai/api/desktop/validate-license"
+const CACHE_VALIDITY_HOURS = 24
+
+export interface LicenseCheckResult {
+  valid: boolean
+  message: string
+  user?: any
+}
+
+/**
+ * Get primary MAC address from non-internal network interfaces.
+ * Returns the first non-loopback, non-internal MAC address found.
+ */
+function getPrimaryMacAddress(): string {
+  try {
+    const interfaces = os.networkInterfaces()
+    for (const [name, addrs] of Object.entries(interfaces)) {
+      if (!addrs) continue
+      // Skip virtual interfaces that are commonly spoofed
+      if (name.toLowerCase().includes("virtual") || name.toLowerCase().includes("veth")) continue
+      for (const addr of addrs) {
+        // Get non-internal interface with valid MAC
+        if (!addr.internal && addr.mac && addr.mac !== "00:00:00:00:00:00") {
+          return addr.mac
+        }
+      }
+    }
+  } catch {
+    // Fallback silently
+  }
+  return ""
+}
+
+/**
+ * Get machine ID from system-specific locations.
+ * This is a persistent identifier that survives reboots but not OS reinstalls.
+ */
+function getMachineId(): string {
+  const platform = os.platform()
+
+  try {
+    if (platform === "linux") {
+      // Primary: /etc/machine-id (systemd standard)
+      if (fs.existsSync("/etc/machine-id")) {
+        return fs.readFileSync("/etc/machine-id", "utf-8").trim()
+      }
+      // Fallback: /var/lib/dbus/machine-id
+      if (fs.existsSync("/var/lib/dbus/machine-id")) {
+        return fs.readFileSync("/var/lib/dbus/machine-id", "utf-8").trim()
+      }
+    } else if (platform === "darwin") {
+      // macOS: IOPlatformUUID from ioreg
+      const output = execSync("ioreg -rd1 -c IOPlatformExpertDevice | grep IOPlatformUUID", {
+        encoding: "utf-8",
+        timeout: 5000,
+      })
+      const match = output.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/)
+      if (match) {
+        return match[1]
+      }
+    } else if (platform === "win32") {
+      // Windows: MachineGuid from registry
+      const output = execSync(
+        'reg query "HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography" /v MachineGuid',
+        { encoding: "utf-8", timeout: 5000 }
+      )
+      const match = output.match(/MachineGuid\s+REG_SZ\s+([^\s\r\n]+)/)
+      if (match) {
+        return match[1]
+      }
+    }
+  } catch {
+    // Fallback silently - machine ID is optional but strengthens fingerprint
+  }
+  return ""
+}
+
+/**
+ * Get CPU model string for hardware binding.
+ */
+function getCpuModel(): string {
+  try {
+    const cpus = os.cpus()
+    if (cpus.length > 0) {
+      return cpus[0].model
+    }
+  } catch {
+    // Fallback silently
+  }
+  return ""
+}
+
+/**
+ * Get disk serial number (primary disk) for hardware binding.
+ * This is one of the hardest identifiers to spoof.
+ */
+function getDiskSerial(): string {
+  const platform = os.platform()
+
+  try {
+    if (platform === "linux") {
+      // Try to get the serial of the root disk
+      // First, find the root device
+      const rootDev = execSync("df / | tail -1 | awk '{print $1}'", {
+        encoding: "utf-8",
+        timeout: 5000,
+      }).trim()
+      // Extract base device name (e.g., /dev/sda1 -> sda)
+      const devName = rootDev.replace(/\/dev\//, "").replace(/[0-9]+$/, "")
+      // Get serial from udevadm
+      if (devName) {
+        const serial = execSync(`udevadm info --query=property --name=/dev/${devName} | grep ID_SERIAL_SHORT`, {
+          encoding: "utf-8",
+          timeout: 5000,
+        })
+        const match = serial.match(/ID_SERIAL_SHORT=(.+)/)
+        if (match) {
+          return match[1].trim()
+        }
+      }
+    } else if (platform === "darwin") {
+      // macOS: Use diskutil to get disk serial
+      const output = execSync("diskutil info disk0 | grep 'Device Identifier\\|Serial'", {
+        encoding: "utf-8",
+        timeout: 5000,
+      })
+      const match = output.match(/Serial Number:\s+(\S+)/i)
+      if (match) {
+        return match[1]
+      }
+    } else if (platform === "win32") {
+      // Windows: Use WMIC to get disk serial
+      const output = execSync("wmic diskdrive get SerialNumber", {
+        encoding: "utf-8",
+        timeout: 5000,
+      })
+      const lines = output.split("\n").filter((l) => l.trim() && !l.includes("SerialNumber"))
+      if (lines.length > 0) {
+        return lines[0].trim()
+      }
+    }
+  } catch {
+    // Disk serial is optional - many VMs don't have it
+  }
+  return ""
+}
+
+/**
+ * Get a hardware-bound device fingerprint that is difficult to spoof.
+ * Combines multiple hardware identifiers for robust device identification.
+ *
+ * Components (in order of uniqueness/difficulty to spoof):
+ * 1. Machine ID - System-generated UUID, persistent across reboots
+ * 2. Primary MAC address - Network interface hardware address
+ * 3. Disk serial - Hard drive serial number (hardest to spoof)
+ * 4. CPU model - Processor identification string
+ * 5. Total memory - System RAM in bytes
+ * 6. CPU core count - Number of logical processors
+ * 7. Platform + arch - OS and architecture (least unique, but stable)
+ *
+ * The fingerprint is a SHA-256 hash of all components, making it:
+ * - Deterministic: Same hardware always produces same fingerprint
+ * - Secure: Cannot reverse-engineer the original values
+ * - Tamper-resistant: Changing any component changes the fingerprint
+ */
+function getDeviceFingerprint(): string {
+  const parts: string[] = []
+
+  // Hardware identifiers (hard to spoof)
+  const machineId = getMachineId()
+  const macAddress = getPrimaryMacAddress()
+  const diskSerial = getDiskSerial()
+  const cpuModel = getCpuModel()
+
+  // System characteristics
+  const totalMemory = os.totalmem().toString()
+  const cpuCount = os.cpus().length.toString()
+  const platform = os.platform()
+  const arch = os.arch()
+
+  // Build fingerprint from all available components
+  // Order matters - keep it consistent
+  parts.push(`machine:${machineId}`)
+  parts.push(`mac:${macAddress}`)
+  parts.push(`disk:${diskSerial}`)
+  parts.push(`cpu:${cpuModel}`)
+  parts.push(`mem:${totalMemory}`)
+  parts.push(`cores:${cpuCount}`)
+  parts.push(`platform:${platform}`)
+  parts.push(`arch:${arch}`)
+
+  // Create SHA-256 hash of combined components
+  const combined = parts.join("|")
+  const hash = crypto.createHash("sha256").update(combined).digest("hex")
+
+  // Return first 32 chars for reasonable length while maintaining security
+  return hash.substring(0, 32)
+}
+
+function getLicenseKey(): string | null {
+  if (process.env.RIRD_LICENSE_KEY) {
+    return process.env.RIRD_LICENSE_KEY.trim()
+  }
+  if (fs.existsSync(LICENSE_KEY_PATH)) {
+    try {
+      return fs.readFileSync(LICENSE_KEY_PATH, "utf-8").trim()
+    } catch {
+      return null
+    }
+  }
+  return null
+}
+
+function loadLicenseCache(): any | null {
+  try {
+    if (fs.existsSync(LICENSE_CACHE_PATH)) {
+      const data = JSON.parse(fs.readFileSync(LICENSE_CACHE_PATH, "utf-8"))
+      const cachedAt = new Date(data.cached_at)
+      const now = new Date()
+      const hoursDiff = (now.getTime() - cachedAt.getTime()) / (1000 * 60 * 60)
+      if (hoursDiff < CACHE_VALIDITY_HOURS) {
+        return data
+      }
+    }
+  } catch (e) {
+    // Ignore cache errors
+  }
+  return null
+}
+
+function saveLicenseCache(data: any) {
+  try {
+    const dir = path.dirname(LICENSE_CACHE_PATH)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true, mode: 0o700 })
+    }
+    data.cached_at = new Date().toISOString()
+    fs.writeFileSync(LICENSE_CACHE_PATH, JSON.stringify(data), { mode: 0o600 })
+  } catch (e) {
+    Log.Default.error("license", { error: "Failed to save license cache", details: e })
+  }
+}
+
+export async function validateLicense(): Promise<LicenseCheckResult> {
+  const licenseKey = getLicenseKey()
+  if (!licenseKey) {
+    return {
+      valid: false,
+      message: "No license key found.\nGet your key at: https://rird.ai\nThen run: rird activate YOUR_LICENSE_KEY",
+    }
+  }
+
+  // Check cache first
+  const cached = loadLicenseCache()
+  if (cached && cached.license_key === licenseKey && cached.valid) {
+    Log.Default.debug("Using cached license validation")
+    return {
+      valid: true,
+      message: `License valid (cached) - ${cached.email || "unknown"}`,
+      user: { email: cached.email, plan: cached.plan },
+    }
+  }
+
+  // Validate online
+  try {
+    const response = await fetch(RIRD_API_URL, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        license_key: licenseKey,
+        device_fingerprint: getDeviceFingerprint(),
+        version: "1.0.0", // TODO: Get from package.json
+        platform: os.platform(),
+      }),
+    })
+
+    if (response.status === 200) {
+      const data = await response.json()
+      if (data.valid) {
+        saveLicenseCache({
+          license_key: licenseKey,
+          valid: true,
+          email: data.user?.email,
+          plan: data.user?.plan,
+          expires_at: data.user?.expires_at,
+        })
+        return {
+          valid: true,
+          message: `License valid - ${data.user?.email || "unknown"}`,
+          user: data.user,
+        }
+      } else {
+        // Clear bad cache
+        if (fs.existsSync(LICENSE_CACHE_PATH)) fs.unlinkSync(LICENSE_CACHE_PATH)
+        return { valid: false, message: data.error || "Invalid license" }
+      }
+    } else if (response.status === 401) {
+      return { valid: false, message: "Invalid or expired license key" }
+    } else if (response.status === 403) {
+      return { valid: false, message: "Subscription inactive - please renew at rird.ai" }
+    } else if (response.status === 429) {
+      return { valid: false, message: "Too many validation attempts - please wait" }
+    } else {
+      // Offline/Server error - allow if previously cached (but here we don't have valid cache)
+      // If we are here, cache was invalid or missing.
+      // Strict mode: fail. Lenient mode: warn.
+      // User requested "rate limits connected to auth", implying enforcement.
+      return { valid: false, message: `License server error: ${response.status}` }
+    }
+  } catch (e) {
+    // Network error
+    Log.Default.warn("License check offline")
+    return { valid: false, message: "Could not reach license server" } // Fail safe or fail secure? 
+    // Given the requirement, probably fail secure unless cached.
+  }
+}

package/src/util/locale.ts

@@ -0,0 +1,81 @@
+export namespace Locale {
+  export function titlecase(str: string) {
+    return str.replace(/\b\w/g, (c) => c.toUpperCase())
+  }
+
+  export function time(input: number): string {
+    const date = new Date(input)
+    return date.toLocaleTimeString(undefined, { timeStyle: "short" })
+  }
+
+  export function datetime(input: number): string {
+    const date = new Date(input)
+    const localTime = time(input)
+    const localDate = date.toLocaleDateString()
+    return `${localTime} · ${localDate}`
+  }
+
+  export function todayTimeOrDateTime(input: number): string {
+    const date = new Date(input)
+    const now = new Date()
+    const isToday =
+      date.getFullYear() === now.getFullYear() && date.getMonth() === now.getMonth() && date.getDate() === now.getDate()
+
+    if (isToday) {
+      return time(input)
+    } else {
+      return datetime(input)
+    }
+  }
+
+  export function number(num: number): string {
+    if (num >= 1000000) {
+      return (num / 1000000).toFixed(1) + "M"
+    } else if (num >= 1000) {
+      return (num / 1000).toFixed(1) + "K"
+    }
+    return num.toString()
+  }
+
+  export function duration(input: number) {
+    if (input < 1000) {
+      return `${input}ms`
+    }
+    if (input < 60000) {
+      return `${(input / 1000).toFixed(1)}s`
+    }
+    if (input < 3600000) {
+      const minutes = Math.floor(input / 60000)
+      const seconds = Math.floor((input % 60000) / 1000)
+      return `${minutes}m ${seconds}s`
+    }
+    if (input < 86400000) {
+      const hours = Math.floor(input / 3600000)
+      const minutes = Math.floor((input % 3600000) / 60000)
+      return `${hours}h ${minutes}m`
+    }
+    const hours = Math.floor(input / 3600000)
+    const days = Math.floor((input % 3600000) / 86400000)
+    return `${days}d ${hours}h`
+  }
+
+  export function truncate(str: string, len: number): string {
+    if (str.length <= len) return str
+    return str.slice(0, len - 1) + "…"
+  }
+
+  export function truncateMiddle(str: string, maxLength: number = 35): string {
+    if (str.length <= maxLength) return str
+
+    const ellipsis = "…"
+    const keepStart = Math.ceil((maxLength - ellipsis.length) / 2)
+    const keepEnd = Math.floor((maxLength - ellipsis.length) / 2)
+
+    return str.slice(0, keepStart) + ellipsis + str.slice(-keepEnd)
+  }
+
+  export function pluralize(count: number, singular: string, plural: string): string {
+    const template = count === 1 ? singular : plural
+    return template.replace("{}", count.toString())
+  }
+}