fix: file viewer

Author: mohithxkarthikeya

desktop/src-tauri/src/agent/injector.rs

@@ -235,7 +235,7 @@ async fn build_v3_uncached(runbox_id: &str, task: &str, agent_id: &str) -> Strin
                 let block = format!("PROJECT:\n{relevant}\n");
                 let room  = 60usize.min(BUDGET_TOTAL_V3.saturating_sub(used));
                 if est_tokens(&block) <= room {
-                    sections.push(block);
+                    sections.push(block.clone());
                     used += est_tokens(&block);
                 }
             }

desktop/src-tauri/src/bin/stackbox_open.rs

@@ -1,15 +1,13 @@
-
-
 use std::io::Write;
 
 fn main() {
-    let url = match std::env::args().nth(1) {
-        Some(u) if u.starts_with("http://") || u.starts_with("https://") => u,
-        // Some tools pass the URL as-is without a scheme — prepend https
-        Some(u) if !u.is_empty() => format!("https://{}", u),
+    let raw = match std::env::args().nth(1) {
+        Some(a) if !a.is_empty() => a,
         _ => return,
     };
 
+    let url = normalize_to_url(&raw);
+
     // ── 1. POST to the embedded server → triggers "browser-open-url" Tauri event
     let port = 7547u16;
     let body  = url.as_bytes();
@@ -21,12 +19,53 @@ fn main() {
 
     if let Ok(mut stream) = std::net::TcpStream::connect(format!("127.0.0.1:{port}")) {
         let _ = stream.write_all(req.as_bytes());
-        // Read/discard the response so the server doesn't get a broken-pipe error
         let mut buf = [0u8; 256];
         let _ = std::io::Read::read(&mut stream, &mut buf);
     }
 
-    // ── 2. Print to stdout so the URL also appears in the terminal output.
-    //       The PTY reader will pick it up as a fallback if the HTTP post fails.
+    // ── 2. Print to stdout — PTY reader picks it up as fallback
     println!("{}", url);
+}
+
+/// Convert anything the shell might pass as BROWSER argument into a URL.
+fn normalize_to_url(raw: &str) -> String {
+    if raw.starts_with("http://") || raw.starts_with("https://") || raw.starts_with("file://") {
+        return raw.to_string();
+    }
+
+    // Absolute Windows path: C:\... or C:/...
+    if raw.len() >= 2 && raw.chars().nth(1) == Some(':') {
+        let normalised = raw.replace('\\', "/");
+        return format!("file:///{normalised}");
+    }
+
+    let looks_like_path = raw.starts_with('.')
+        || raw.starts_with('/')
+        || raw.starts_with('\\')
+        || has_web_extension(raw);
+
+    if looks_like_path {
+        let base = std::env::current_dir().unwrap_or_else(|_| std::path::PathBuf::from("."));
+        let path = base.join(raw);
+
+        if let Ok(canonical) = path.canonicalize() {
+            if let Ok(url) = url::Url::from_file_path(&canonical) {
+                return url.to_string();
+            }
+            let s = canonical.to_string_lossy().replace('\\', "/");
+            return format!("file:///{}", s.trim_start_matches('/'));
+        }
+
+        // File doesn't exist yet — build URL anyway
+        let s = path.to_string_lossy().replace('\\', "/");
+        return format!("file:///{}", s.trim_start_matches('/'));
+    }
+
+    format!("https://{raw}")
+}
+
+fn has_web_extension(s: &str) -> bool {
+    let lower = s.to_lowercase();
+    lower.ends_with(".html") || lower.ends_with(".htm")
+        || lower.ends_with(".svg") || lower.ends_with(".pdf") || lower.ends_with(".xhtml")
 }

desktop/src-tauri/src/browser/webview.rs

@@ -131,8 +131,16 @@ pub fn browser_destroy(app: AppHandle, id: String) -> Result<(), String> {
 #[tauri::command]
 pub fn browser_navigate(app: AppHandle, id: String, url: String) -> Result<(), String> {
     let wv = app.get_webview(&label(&id)).ok_or("webview not found")?;
-    // .navigate() silently fails on Windows child webviews created via add_child.
-    // Using window.location.assign() via eval is reliable cross-platform.
+
+    // file:// URLs cannot be loaded via window.location.assign() from an http
+    // context — the browser blocks the cross-origin jump. Use the native Tauri
+    // navigate() for file:// only; for http/https keep using eval (more reliable
+    // on Windows child webviews created via add_child).
+    if url.starts_with("file://") {
+        let parsed = url.parse::<url::Url>().map_err(|e: url::ParseError| e.to_string())?;
+        return wv.navigate(parsed).map_err(|e| e.to_string());
+    }
+
     let escaped = url.replace('\\', "\\\\").replace('\'', "\\'");
     wv.eval(&format!("window.location.assign('{}')", escaped))
         .map_err(|e| e.to_string())

desktop/src-tauri/src/commands/pty.rs

@@ -16,11 +16,12 @@ pub async fn pty_spawn(
     runbox_id:  String,
     cwd:        String,
     agent_cmd:  Option<String>,
-    cols:       Option<u16>,   // ← added
-    rows:       Option<u16>,   // ← added
+    cols:       Option<u16>,
+    rows:       Option<u16>,
+    docker:     Option<bool>,   // ← NEW: passed from frontend workspace card
     state:      tauri::State<'_, AppState>,
 ) -> Result<(), String> {
-    pty::spawn(app, session_id, runbox_id, cwd, agent_cmd, cols, rows, &state).await
+    pty::spawn(app, session_id, runbox_id, cwd, agent_cmd, cols, rows, docker.unwrap_or(false), &state).await
 }
 
 #[tauri::command]
@@ -29,23 +30,29 @@ pub fn pty_write(
     data:       String,
     state:      tauri::State<'_, AppState>,
 ) -> Result<(), String> {
-    let mut inject: Option<(String, String, AgentKind)> = None;
+    let mut inject:    Option<(String, String, AgentKind)> = None;
+    let mut open_url:  Option<String> = None;
+    let mut send_data: Option<String> = None;
+
     {
         let mut sessions = state.sessions.lock().unwrap();
         if let Some(s) = sessions.get_mut(&session_id) {
-            let _ = s.writer.write_all(data.as_bytes());
-            let _ = s.writer.flush();
             for ch in data.chars() {
                 match ch {
                     '\r' | '\n' => {
                         let line = s.input_buf.trim().to_string();
                         s.input_buf.clear();
                         if !line.is_empty() {
-                            let token    = line.split_whitespace().next().unwrap_or("");
-                            let base_cmd = token.rsplit(['/', '\\']).next().unwrap_or(token);
-                            let kind     = AgentKind::detect(base_cmd);
-                            if kind != AgentKind::Shell {
-                                inject = Some((s.runbox_id.clone(), s.cwd.clone(), kind));
+                            if let Some(url) = intercept_start_cmd(&line, &s.cwd) {
+                                open_url  = Some(url);
+                                send_data = Some("\x03\r\n".to_string());
+                            } else {
+                                let token    = line.split_whitespace().next().unwrap_or("");
+                                let base_cmd = token.rsplit(['/', '\\']).next().unwrap_or(token);
+                                let kind     = AgentKind::detect(base_cmd);
+                                if kind != AgentKind::Shell {
+                                    inject = Some((s.runbox_id.clone(), s.cwd.clone(), kind));
+                                }
                             }
                         }
                     }
@@ -54,8 +61,17 @@ pub fn pty_write(
                     _ => {}
                 }
             }
+
+            let to_write = send_data.as_deref().unwrap_or(&data);
+            let _ = s.writer.write_all(to_write.as_bytes());
+            let _ = s.writer.flush();
         }
     }
+
+    if let Some(url) = open_url {
+        crate::agent::globals::emit_event("browser-open-url", serde_json::json!(url));
+    }
+
     if let Some((rb, cwd, kind)) = inject {
         let sid = session_id.clone();
         let db  = state.db.clone();
@@ -68,6 +84,41 @@ pub fn pty_write(
     Ok(())
 }
 
+fn intercept_start_cmd(line: &str, cwd: &str) -> Option<String> {
+    let mut parts = line.splitn(2, char::is_whitespace);
+    let cmd = parts.next().unwrap_or("").to_lowercase();
+    if cmd != "start" { return None; }
+
+    let arg = parts.next()?.trim().trim_matches('"').trim_matches('\'');
+    if arg.is_empty() { return None; }
+
+    let lower = arg.to_lowercase();
+    if !lower.ends_with(".html") && !lower.ends_with(".htm")
+        && !lower.ends_with(".svg")  && !lower.ends_with(".pdf") {
+        return None;
+    }
+
+    if arg.starts_with("file://") { return Some(arg.to_string()); }
+
+    if arg.len() >= 2 && arg.chars().nth(1) == Some(':') {
+        let normalised = arg.replace('\\', "/");
+        return Some(format!("file:///{normalised}"));
+    }
+
+    let abs = std::path::Path::new(cwd).join(arg);
+
+    if let Ok(canonical) = abs.canonicalize() {
+        if let Ok(url) = url::Url::from_file_path(&canonical) {
+            return Some(url.to_string());
+        }
+        let s = canonical.to_string_lossy().replace('\\', "/");
+        return Some(format!("file:///{}", s.trim_start_matches('/')));
+    }
+
+    let s = abs.to_string_lossy().replace('\\', "/");
+    Some(format!("file:///{}", s.trim_start_matches('/')))
+}
+
 #[tauri::command]
 pub fn pty_resize(
     session_id: String, cols: u16, rows: u16,