4runr-os 2.10.85 → 2.10.86

package/os-tui/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "os-tui"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+ratatui = "0.27"
+crossterm = "0.28"
+tokio = { version = "1", features = ["full"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+tokio-tungstenite = "0.24"
+tungstenite = "0.24"
+futures-util = "0.3"
+anyhow = "1"
+thiserror = "2"
+

package/os-tui/bin/os-tui.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+
+import { spawn } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Try to find the binary in different locations
+const possiblePaths = [
+  // From npm package (installed)
+  join(__dirname, '..', 'target', 'release', 'os-tui'),
+  join(__dirname, '..', 'target', 'release', 'os-tui.exe'),
+  // From global npm install (in PATH)
+  process.platform === 'win32' ? 'os-tui.exe' : 'os-tui',
+  // Development build (local)
+  join(__dirname, '..', '..', '..', 'apps', 'os-tui', 'target', 'release', 'os-tui'),
+  join(__dirname, '..', '..', '..', 'apps', 'os-tui', 'target', 'release', 'os-tui.exe'),
+];
+
+let binaryPath = null;
+for (const testPath of possiblePaths) {
+  // Check if it's a PATH command (string without slashes)
+  if (!testPath.includes('/') && !testPath.includes('\\')) {
+    // Try to find in PATH
+    try {
+      const { execSync } = await import('child_process');
+      const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+      execSync(`${whichCmd} ${testPath}`, { stdio: 'ignore' });
+      binaryPath = testPath;
+      break;
+    } catch {
+      continue;
+    }
+  } else if (existsSync(testPath)) {
+    binaryPath = testPath;
+    break;
+  }
+}
+
+if (!binaryPath) {
+  console.error('Error: os-tui binary not found.');
+  console.error('Please run: cd apps/os-tui && cargo build --release');
+  process.exit(1);
+}
+
+// Spawn the Rust binary with all arguments
+const child = spawn(binaryPath, process.argv.slice(2), {
+  stdio: 'inherit',
+  cwd: process.cwd(),
+});
+
+child.on('error', (err) => {
+  console.error('Failed to start os-tui:', err);
+  process.exit(1);
+});
+
+child.on('exit', (code) => {
+  process.exit(code || 0);
+});
+

package/os-tui/src/app/render_scheduler.rs

@@ -0,0 +1,111 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum RunMode {
+    Local,
+    Browser,
+}
+
+impl RunMode {
+    pub fn detect() -> Self {
+        if let Ok(mode) = std::env::var("RUN_MODE") {
+            match mode.to_lowercase().as_str() {
+                "browser" | "web" => return RunMode::Browser,
+                "local" => return RunMode::Local,
+                _ => {}
+            }
+        }
+
+        // Auto-detect
+        if std::env::var("AWS_EXECUTION_ENV").is_ok()
+            || std::env::var("CLOUDSHELL").is_ok()
+            || std::env::var("TUI_WEB").map(|v| v == "1").unwrap_or(false)
+        {
+            RunMode::Browser
+        } else {
+            RunMode::Local
+        }
+    }
+}
+
+pub struct RenderScheduler {
+    run_mode: RunMode,
+    last_render: Instant,
+    render_scheduled: bool,
+    immediate_render: bool, // Flag for immediate renders (bypass throttling)
+    render_scheduled_count: u64,
+    min_render_interval: Duration,
+}
+
+impl RenderScheduler {
+    pub fn new() -> Self {
+        let run_mode = RunMode::detect();
+        let min_render_interval = match run_mode {
+            RunMode::Browser => Duration::from_millis(50), // Max 20 FPS (browser limitation)
+            RunMode::Local => Duration::from_millis(8), // Max 120 FPS (ultra-responsive, throttled for non-input)
+        };
+
+        Self {
+            run_mode,
+            last_render: Instant::now(),
+            render_scheduled: false,
+            immediate_render: false,
+            render_scheduled_count: 0,
+            min_render_interval,
+        }
+    }
+
+    pub fn run_mode(&self) -> RunMode {
+        self.run_mode
+    }
+
+    pub fn request_render(&mut self, _reason: &str) -> bool {
+        self.render_scheduled_count += 1;
+        self.render_scheduled = true; // Always schedule so the next should_render() can draw
+        let now = Instant::now();
+        let elapsed = now.duration_since(self.last_render);
+        if elapsed >= self.min_render_interval {
+            // Throttle allows: next frame should draw without waiting another interval
+            self.immediate_render = true;
+            true
+        } else {
+            false
+        }
+    }
+
+    /// Request immediate render (bypass throttling) - for critical input events
+    pub fn request_immediate_render(&mut self, _reason: &str) -> bool {
+        self.render_scheduled_count += 1;
+        self.render_scheduled = true;
+        self.immediate_render = true; // Mark as immediate to bypass throttling
+        true
+    }
+
+    pub fn should_render(&mut self) -> bool {
+        if !self.render_scheduled {
+            return false;
+        }
+
+        let now = Instant::now();
+        let elapsed = now.duration_since(self.last_render);
+
+        // If immediate render was requested, bypass throttling
+        // Otherwise, respect the throttle interval
+        if self.immediate_render || elapsed >= self.min_render_interval {
+            self.last_render = now;
+            self.render_scheduled = false;
+            self.immediate_render = false; // Clear immediate flag
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn render_scheduled_count(&self) -> u64 {
+        self.render_scheduled_count
+    }
+
+    pub fn min_render_interval_ms(&self) -> u64 {
+        self.min_render_interval.as_millis() as u64
+    }
+}