@pheem49/mint 1.16.0 → 1.18.0

package/crates/mint-core/src/system/shell.rs

@@ -36,6 +36,8 @@ pub(crate) const SHELL_COMMAND_TIMEOUT: Duration = Duration::from_secs(180);
 pub(crate) struct CommandResult {
     pub(crate) status_code: Option<i32>,
     pub(crate) success: bool,
+    pub(crate) job_id: Option<String>,
+    pub(crate) cancelled: bool,
     pub(crate) stdout: Vec<u8>,
     pub(crate) stderr: Vec<u8>,
 }
@@ -62,10 +64,20 @@ fn spawn_reader(
 /// the same timeout/output-buffering behavior for `docker exec` instead of
 /// duplicating it.
 pub(crate) fn run_with_timeout(
+    cmd: Command,
+    timeout: Duration,
+    command: &str,
+    cwd: &Path,
+) -> std::io::Result<CommandResult> {
+    run_with_timeout_cancellable(cmd, timeout, command, cwd, None)
+}
+
+fn run_with_timeout_cancellable(
     mut cmd: Command,
     timeout: Duration,
     command: &str,
     cwd: &Path,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
 ) -> std::io::Result<CommandResult> {
     cmd.stdin(Stdio::null())
         .stdout(Stdio::piped())
@@ -82,12 +94,50 @@ pub(crate) fn run_with_timeout(
 
     let deadline = Instant::now() + timeout;
     loop {
+        if cancellation.is_some_and(|token| token.is_cancelled()) {
+            #[cfg(unix)]
+            unsafe {
+                libc::kill(-(child.id() as i32), libc::SIGTERM);
+            }
+            // Allow the browser helper to drop its separate Chrome runtime.
+            let grace = Instant::now() + Duration::from_millis(500);
+            while Instant::now() < grace {
+                if child.try_wait()?.is_some() {
+                    break;
+                }
+                std::thread::sleep(Duration::from_millis(10));
+            }
+            #[cfg(unix)]
+            unsafe {
+                libc::kill(-(child.id() as i32), libc::SIGKILL);
+            }
+            #[cfg(windows)]
+            {
+                let _ = Command::new("taskkill")
+                    .args(["/PID", &child.id().to_string(), "/T", "/F"])
+                    .output();
+            }
+            let _ = child.kill();
+            let _ = child.wait();
+            let stdout = stdout_handle.join().unwrap_or_default();
+            let stderr = stderr_handle.join().unwrap_or_default();
+            return Ok(CommandResult {
+                status_code: None,
+                success: false,
+                job_id: None,
+                cancelled: true,
+                stdout,
+                stderr,
+            });
+        }
         if let Some(status) = child.try_wait()? {
             let stdout = stdout_handle.join().unwrap_or_default();
             let stderr = stderr_handle.join().unwrap_or_default();
             return Ok(CommandResult {
                 status_code: status.code(),
                 success: status.success(),
+                job_id: None,
+                cancelled: false,
                 stdout,
                 stderr,
             });
@@ -117,6 +167,8 @@ pub(crate) fn run_with_timeout(
             return Ok(CommandResult {
                 status_code: None,
                 success: false,
+                job_id: Some(started.id),
+                cancelled: false,
                 stdout: Vec::new(),
                 stderr,
             });
@@ -133,6 +185,8 @@ pub struct ShellOutput {
     pub mode: String,
     pub status: Option<i32>,
     pub success: bool,
+    pub job_id: Option<String>,
+    pub cancelled: bool,
     pub sandboxed: bool,
     /// Set when a mutating/network command ran unconfined because sandboxing was
     /// unavailable (rather than intentionally disabled via `sandboxMode: "off"`),
@@ -193,6 +247,23 @@ pub fn run_shell_command(
     config: &MintConfig,
     chat_id: Option<&str>,
 ) -> Result<ShellOutput, ShellError> {
+    run_shell_command_cancellable(command, cwd, approved, config, chat_id, None)
+}
+
+pub fn run_shell_command_cancellable(
+    command: &str,
+    cwd: &Path,
+    approved: bool,
+    config: &MintConfig,
+    chat_id: Option<&str>,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
+) -> Result<ShellOutput, ShellError> {
+    if cancellation.is_some_and(|token| token.is_cancelled()) {
+        return Err(ShellError::Execute(std::io::Error::new(
+            std::io::ErrorKind::Interrupted,
+            "Command cancelled before dispatch",
+        )));
+    }
     if crate::bg_shell::is_shutting_down() {
         return Err(ShellError::Execute(std::io::Error::other(
             "Mint backend is shutting down",
@@ -245,7 +316,7 @@ pub fn run_shell_command(
     let sandbox_mode = config.sandbox_mode.trim().to_ascii_lowercase();
     let mut sandbox_warning = None;
     if config.safety_enabled && sandbox_mode != "off" {
-        if let Some(output) = run_in_sandbox(&prepared_cmd, &cwd, config)? {
+        if let Some(output) = run_in_sandbox(&prepared_cmd, &cwd, config, cancellation)? {
             return Ok(shell_output(
                 command,
                 cwd,
@@ -288,8 +359,10 @@ pub fn run_shell_command(
     }
 
     let mut cmd = shell_command(&prepared_cmd);
+    crate::browser::workflow::configure_shell(&mut cmd, config);
     cmd.current_dir(&cwd);
-    let output = run_with_timeout(cmd, SHELL_COMMAND_TIMEOUT, command, &cwd)?;
+    let output =
+        run_with_timeout_cancellable(cmd, SHELL_COMMAND_TIMEOUT, command, &cwd, cancellation)?;
     Ok(shell_output(
         command,
         cwd,
@@ -321,6 +394,7 @@ fn run_in_sandbox(
     command: &str,
     cwd: &Path,
     config: &MintConfig,
+    cancellation: Option<&tokio_util::sync::CancellationToken>,
 ) -> Result<Option<CommandResult>, ShellError> {
     #[cfg(target_os = "linux")]
     {
@@ -331,21 +405,42 @@ fn run_in_sandbox(
             return Ok(None);
         }
         let mut process = Command::new(sandbox);
+        crate::browser::workflow::configure_shell(&mut process, config);
         // Own process group, same reasoning as `shell_command`'s: lets a
         // timed-out or interrupted run be killed as a whole tree via
         // `terminate_process_group` instead of just the `bwrap` wrapper.
-        process
-            .process_group(0)
-            .args(["--die-with-parent", "--ro-bind", "/", "/", "--dev", "/dev"])
-            .args(["--proc", "/proc", "--tmpfs", "/tmp"]);
-        for root in writable_roots(config, cwd) {
+        let roots = writable_roots(config, cwd);
+        let has_tmp = roots
+            .iter()
+            .any(|r| r == Path::new("/tmp") || r == &std::env::temp_dir());
+
+        process.process_group(0).args([
+            "--die-with-parent",
+            "--ro-bind",
+            "/",
+            "/",
+            "--dev",
+            "/dev",
+            "--proc",
+            "/proc",
+        ]);
+        if !has_tmp {
+            process.args(["--tmpfs", "/tmp"]);
+        }
+        for root in roots {
             process.arg("--bind").arg(&root).arg(&root);
         }
         process
             .arg("--chdir")
             .arg(cwd)
             .args(["bash", "-lc", command]);
-        let output = run_with_timeout(process, SHELL_COMMAND_TIMEOUT, command, cwd)?;
+        let output = run_with_timeout_cancellable(
+            process,
+            SHELL_COMMAND_TIMEOUT,
+            command,
+            cwd,
+            cancellation,
+        )?;
         Ok(Some(output))
     }
 
@@ -358,19 +453,26 @@ fn run_in_sandbox(
             return Ok(None);
         }
         let mut process = Command::new(sandbox);
+        crate::browser::workflow::configure_shell(&mut process, config);
         process
             .process_group(0)
             .arg("-p")
             .arg(mac_sandbox_profile(config, cwd))
             .args(["bash", "-lc", command])
             .current_dir(cwd);
-        let output = run_with_timeout(process, SHELL_COMMAND_TIMEOUT, command, cwd)?;
+        let output = run_with_timeout_cancellable(
+            process,
+            SHELL_COMMAND_TIMEOUT,
+            command,
+            cwd,
+            cancellation,
+        )?;
         return Ok(Some(output));
     }
 
     #[cfg(not(any(target_os = "linux", target_os = "macos")))]
     {
-        let _ = (command, cwd, config);
+        let _ = (command, cwd, config, cancellation);
         Ok(None)
     }
 }
@@ -438,6 +540,27 @@ pub(crate) fn writable_roots(config: &MintConfig, cwd: &Path) -> Vec<PathBuf> {
         .filter(|root| root.exists())
         .cloned()
         .collect::<Vec<_>>();
+    let temp = std::env::temp_dir();
+    if temp.exists() && !roots.iter().any(|r| r == &temp) {
+        roots.push(temp.clone());
+    }
+    if let Ok(canonical_temp) = temp.canonicalize() {
+        if !roots.iter().any(|r| r == &canonical_temp) {
+            roots.push(canonical_temp);
+        }
+    }
+    #[cfg(unix)]
+    {
+        let slash_tmp = PathBuf::from("/tmp");
+        if slash_tmp.exists() && !roots.iter().any(|r| r == &slash_tmp) {
+            roots.push(slash_tmp.clone());
+        }
+        if let Ok(canonical_slash_tmp) = slash_tmp.canonicalize() {
+            if !roots.iter().any(|r| r == &canonical_slash_tmp) {
+                roots.push(canonical_slash_tmp);
+            }
+        }
+    }
     if !roots.iter().any(|root| cwd.starts_with(root)) {
         roots.push(cwd.to_path_buf());
     }
@@ -525,6 +648,8 @@ fn shell_output(
         mode: mode.into(),
         status: output.status_code,
         success: output.success,
+        job_id: output.job_id,
+        cancelled: output.cancelled,
         sandboxed,
         sandbox_warning,
         stdout: String::from_utf8_lossy(&output.stdout).into_owned(),
@@ -534,6 +659,34 @@ fn shell_output(
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    #[cfg(unix)]
+    fn cancellation_stops_the_foreground_process_group_and_preserves_partial_output() {
+        let token = tokio_util::sync::CancellationToken::new();
+        let cancel = token.clone();
+        let thread = std::thread::spawn(move || {
+            std::thread::sleep(std::time::Duration::from_millis(400));
+            cancel.cancel();
+        });
+        let mut config = local_config();
+        config.allowed_write_paths.push(std::env::temp_dir());
+        let started = std::time::Instant::now();
+        let result = super::run_shell_command_cancellable(
+            "printf started; sleep 5; printf should-not-run",
+            &std::env::temp_dir(),
+            true,
+            &config,
+            None,
+            Some(&token),
+        )
+        .unwrap();
+        thread.join().unwrap();
+        assert!(result.cancelled);
+        assert_eq!(result.status, None);
+        assert!(result.stdout.contains("started"));
+        assert!(!result.stdout.contains("should-not-run"));
+        assert!(started.elapsed() < std::time::Duration::from_secs(2));
+    }
     use super::*;
 
     fn local_config() -> MintConfig {
@@ -697,4 +850,20 @@ mod tests {
         assert!(matches!(job.status, crate::bg_shell::JobStatus::Running));
         let _ = crate::bg_shell::kill_job(&job.id);
     }
+
+    #[test]
+    fn writable_roots_always_includes_temp_directory() {
+        let config = MintConfig {
+            allowed_write_paths: vec![],
+            ..MintConfig::default()
+        };
+        let cwd = std::env::current_dir().unwrap_or_else(|_| PathBuf::from("."));
+        let roots = writable_roots(&config, &cwd);
+        let temp = std::env::temp_dir();
+        assert!(
+            roots
+                .iter()
+                .any(|r| r == &temp || (cfg!(unix) && r == Path::new("/tmp")))
+        );
+    }
 }

package/crates/mint-core/src/system/workspace.rs

@@ -5,6 +5,110 @@ use std::{
 };
 
 const MAX_DEPTH: usize = 9;
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PreparedWorkspaceMedia {
+    pub path: PathBuf,
+    pub mime_type: &'static str,
+    pub byte_length: u64,
+}
+
+/// Authorize one document/media file without reading its payload into memory.
+pub fn prepare_media(
+    root: &Path,
+    relative: &str,
+    config: &crate::MintConfig,
+) -> Result<PreparedWorkspaceMedia, String> {
+    let root = crate::assert_path_capability(root, crate::Capability::Read, config)
+        .map_err(|error| error.to_string())?;
+    let path = resolve(&root, relative)?;
+    let path = crate::assert_path_capability(&path, crate::Capability::Read, config)
+        .map_err(|error| error.to_string())?
+        .canonicalize()
+        .map_err(|error| error.to_string())?;
+    let extension = path
+        .extension()
+        .and_then(|value| value.to_str())
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+    let mime_type = match extension.as_str() {
+        "pdf" => "application/pdf",
+        "mp3" => "audio/mpeg",
+        "wav" => "audio/wav",
+        "ogg" | "oga" | "opus" => "audio/ogg",
+        "flac" => "audio/flac",
+        "m4a" => "audio/mp4",
+        "aac" => "audio/aac",
+        "weba" => "audio/webm",
+        "mp4" | "m4v" => "video/mp4",
+        "webm" => "video/webm",
+        "ogv" => "video/ogg",
+        "mov" => "video/quicktime",
+        _ => {
+            return Err("Select a supported PDF, audio, or video file inside the workspace".into());
+        }
+    };
+    let metadata = fs::metadata(&path).map_err(|error| error.to_string())?;
+    if !metadata.is_file() {
+        return Err("Select a media file".into());
+    }
+    Ok(PreparedWorkspaceMedia {
+        path,
+        mime_type,
+        byte_length: metadata.len(),
+    })
+}
+
+const MAX_PREVIEW_IMAGE_BYTES: u64 = 32 * 1024 * 1024;
+
+/// Return image bytes over the existing IPC/API boundary, without a background service.
+pub fn read_image(
+    root: &Path,
+    relative: &str,
+    config: &crate::MintConfig,
+) -> Result<String, String> {
+    use base64::Engine;
+    use std::io::Read;
+    let root = crate::assert_path_capability(root, crate::Capability::Read, config)
+        .map_err(|error| error.to_string())?;
+    let path = resolve(&root, relative)?;
+    crate::assert_path_capability(&path, crate::Capability::Read, config)
+        .map_err(|error| error.to_string())?;
+    let extension = path
+        .extension()
+        .and_then(|value| value.to_str())
+        .unwrap_or_default()
+        .to_ascii_lowercase();
+    let mime = match extension.as_str() {
+        "png" => "image/png",
+        "jpg" | "jpeg" => "image/jpeg",
+        "gif" => "image/gif",
+        "webp" => "image/webp",
+        "ico" => "image/x-icon",
+        "svg" => "image/svg+xml",
+        _ => return Err("Select a supported image file inside the workspace".into()),
+    };
+    let file = fs::File::open(&path).map_err(|error| error.to_string())?;
+    let metadata = file.metadata().map_err(|error| error.to_string())?;
+    if !metadata.is_file() {
+        return Err("Select an image file".into());
+    }
+    if metadata.len() > MAX_PREVIEW_IMAGE_BYTES {
+        return Err("Image preview supports files up to 32 MiB".into());
+    }
+    let mut bytes = Vec::new();
+    file.take(MAX_PREVIEW_IMAGE_BYTES + 1)
+        .read_to_end(&mut bytes)
+        .map_err(|error| error.to_string())?;
+    if bytes.len() as u64 > MAX_PREVIEW_IMAGE_BYTES {
+        return Err("Image preview supports files up to 32 MiB".into());
+    }
+    Ok(format!(
+        "data:{mime};base64,{}",
+        base64::engine::general_purpose::STANDARD.encode(bytes)
+    ))
+}
 const MAX_CHILDREN: usize = 400;
 const COLLAPSED: &[&str] = &[
     ".git",
@@ -204,6 +308,106 @@ mod tests {
         root
     }
 
+    #[test]
+    fn workspace_media_prepares_scoped_files_without_reading_large_payloads() {
+        let root = root();
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        for (name, mime) in [
+            ("book.PDF", "application/pdf"),
+            ("song.mp3", "audio/mpeg"),
+            ("clip.webm", "video/webm"),
+        ] {
+            fs::write(root.join(name), [0_u8, 255, 128]).unwrap();
+            let media = prepare_media(&root, name, &config).unwrap();
+            assert_eq!(media.mime_type, mime);
+            assert_eq!(media.byte_length, 3);
+            assert_eq!(media.path, root.join(name).canonicalize().unwrap());
+        }
+        fs::File::create(root.join("large.mp4"))
+            .unwrap()
+            .set_len(1024 * 1024 * 1024)
+            .unwrap();
+        assert_eq!(
+            prepare_media(&root, "large.mp4", &config)
+                .unwrap()
+                .byte_length,
+            1024 * 1024 * 1024
+        );
+        fs::write(root.join("private.txt"), "not media").unwrap();
+        assert!(prepare_media(&root, "private.txt", &config).is_err());
+        assert!(prepare_media(&root, "../book.PDF", &config).is_err());
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn workspace_media_rejects_links_outside_the_selected_root() {
+        let root = root();
+        let outside =
+            std::env::temp_dir().join(format!("mint-outside-media-{}.mp4", uuid::Uuid::new_v4()));
+        fs::write(&outside, [1_u8]).unwrap();
+        std::os::unix::fs::symlink(&outside, root.join("escape.mp4")).unwrap();
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        assert!(prepare_media(&root, "escape.mp4", &config).is_err());
+        fs::remove_file(outside).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[test]
+    fn workspace_image_reads_binary_data_directly_and_rejects_unsupported_or_oversized_files() {
+        let root = root();
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        fs::write(root.join("photo.PNG"), [0_u8, 255, 128, 1]).unwrap();
+        assert_eq!(
+            read_image(&root, "photo.PNG", &config).unwrap(),
+            "data:image/png;base64,AP+AAQ=="
+        );
+        fs::write(root.join("icon.svg"), "<svg/>").unwrap();
+        assert_eq!(
+            read_image(&root, "icon.svg", &config).unwrap(),
+            "data:image/svg+xml;base64,PHN2Zy8+"
+        );
+        fs::write(root.join("notes.txt"), "hello").unwrap();
+        assert!(read_image(&root, "notes.txt", &config).is_err());
+        assert!(read_image(&root, "../photo.PNG", &config).is_err());
+        assert!(read_image(&root, root.join("photo.PNG").to_str().unwrap(), &config).is_err());
+        let large = fs::File::create(root.join("large.png")).unwrap();
+        large.set_len(MAX_PREVIEW_IMAGE_BYTES + 1).unwrap();
+        assert!(
+            read_image(&root, "large.png", &config)
+                .unwrap_err()
+                .contains("32 MiB")
+        );
+        fs::remove_dir_all(root).unwrap();
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn workspace_image_rejects_symlinks_outside_its_source_root() {
+        let root = root();
+        let other = root
+            .join("../")
+            .join(format!("mint-outside-{}.png", uuid::Uuid::new_v4()));
+        fs::write(&other, [1_u8, 2, 3]).unwrap();
+        std::os::unix::fs::symlink(&other, root.join("escape.png")).unwrap();
+        let config = crate::MintConfig {
+            allowed_read_paths: vec![root.clone()],
+            ..Default::default()
+        };
+        assert!(read_image(&root, "escape.png", &config).is_err());
+        fs::remove_file(other).unwrap();
+        fs::remove_dir_all(root).unwrap();
+    }
+
     #[test]
     fn interface_workspace_operations_return_snapshots_and_advance_revision() {
         let root = root();

package/crates/mint-core/tests/background_retention.rs

@@ -20,7 +20,7 @@ fn retains_latest_hundred_finished_jobs_without_evicting_active_jobs() {
                 .id,
         );
     }
-    let deadline = Instant::now() + Duration::from_secs(5);
+    let deadline = Instant::now() + Duration::from_secs(30);
     while bg_shell::running_count() > 1 && Instant::now() < deadline {
         std::thread::sleep(Duration::from_millis(20));
     }

package/crates/mint-core/tests/memory_persistence.rs

@@ -85,6 +85,33 @@ fn stores_and_reads_interaction_agent_activity() {
     );
 }
 
+#[test]
+fn exports_trajectory_json_from_agent_activity() {
+    let store = store("trajectory-export");
+    let interaction_id = store
+        .add_interaction_with_metadata(
+            "Write hello world",
+            "Done",
+            "anthropic",
+            "claude-3-7-sonnet",
+        )
+        .unwrap();
+    store
+        .set_interaction_agent_activity_json(
+            interaction_id,
+            r#"[{"type":"Thought","data":{"thought":"inspect code"}},{"type":"ToolEnd","data":{"action":"write_file","input":{"path":"src/main.rs"},"result":"Written successfully","elapsed_ms":45,"status":"success"}},{"type":"RunCompleted","data":{"summary":{"runId":"run-999","task":"Write hello world","outcome":"SUCCESS","totalTokens":500,"toolCallsCount":1,"filesChanged":["src/main.rs"],"filesCreated":["src/main.rs"],"durationSecs":1.2,"toolTimeline":[],"retriesCount":0}}}]"#,
+        )
+        .unwrap();
+
+    let trajectory_json = store
+        .export_trajectory_json("default", Some("run-999"))
+        .unwrap();
+    assert!(trajectory_json.contains("\"schemaVersion\": \"1.0\""));
+    assert!(trajectory_json.contains("\"runId\": \"run-999\""));
+    assert!(trajectory_json.contains("\"outcome\": \"SUCCESS\""));
+    assert!(trajectory_json.contains("\"action\": \"write_file\""));
+}
+
 #[test]
 fn preserves_chat_history_when_store_is_reopened() {
     let path = test_path("reopen-history", "sqlite");

package/crates/mint-mod-runtime/src/lib.rs

@@ -384,39 +384,33 @@ pub fn preview(manifest: &Value, source: &str) -> Result<Value, String> {
     .snapshot()
 }
 
-/// Newline-delimited IPC. The parent grants capabilities; this process has no OS SDK.
-pub fn worker_main() -> Result<(), String> {
-    fn read() -> Result<Value, String> {
-        let mut line = String::new();
-        io::stdin()
-            .read_line(&mut line)
-            .map_err(|e| e.to_string())?;
-        if line.len() > 1024 * 1024 {
-            return Err("IPC request too large".into());
-        }
-        serde_json::from_str(&line).map_err(|e| e.to_string())
-    }
-    fn send(value: &Value) {
-        println!("{}", value);
-        let _ = io::stdout().flush();
-    }
+/// Runs the worker exchange loop using custom reader and sender functions.
+pub fn run_worker_loop<R, W>(read: R, send: W) -> Result<(), String>
+where
+    R: Fn() -> Result<Value, String> + Clone + Send + Sync + 'static,
+    W: Fn(Value) + Clone + Send + Sync + 'static,
+{
     let init = read()?;
+    let host_send = send.clone();
+    let host_read = read.clone();
     let engine = Engine::new(
         init["compiled"].as_str().ok_or("Missing compiled source")?,
         &init["state"],
-        |request| {
+        move |request| {
             let request = serde_json::from_str::<Value>(&request).unwrap_or(Value::Null);
-            send(&json!({"host":request}));
-            read().unwrap_or_else(|e| json!({"error":e})).to_string()
+            host_send(json!({"host":request}));
+            host_read()
+                .unwrap_or_else(|e| json!({"error":e}))
+                .to_string()
         },
     );
     let engine = match engine {
         Ok(e) => {
-            send(&json!({"ok":e.snapshot()?}));
+            send(json!({"ok":e.snapshot()?}));
             e
         }
         Err(e) => {
-            send(&json!({"error":e}));
+            send(json!({"error":e}));
             return Ok(());
         }
     };
@@ -430,9 +424,9 @@ pub fn worker_main() -> Result<(), String> {
             break;
         }
         match engine.dispatch(kind, &request["payload"]) {
-            Ok(v) => send(&json!({"ok":v})),
+            Ok(v) => send(json!({"ok":v})),
             Err(e) => {
-                send(&json!({"error":e}));
+                send(json!({"error":e}));
                 break;
             }
         }
@@ -440,6 +434,26 @@ pub fn worker_main() -> Result<(), String> {
     Ok(())
 }
 
+/// Newline-delimited IPC. The parent grants capabilities; this process has no OS SDK.
+pub fn worker_main() -> Result<(), String> {
+    run_worker_loop(
+        || {
+            let mut line = String::new();
+            io::stdin()
+                .read_line(&mut line)
+                .map_err(|e| e.to_string())?;
+            if line.len() > 1024 * 1024 {
+                return Err("IPC request too large".into());
+            }
+            serde_json::from_str(&line).map_err(|e| e.to_string())
+        },
+        |value| {
+            println!("{}", value);
+            let _ = io::stdout().flush();
+        },
+    )
+}
+
 pub fn pack(manifest: &Value, source: &str, readme: &str) -> Result<Vec<u8>, String> {
     let m: Manifest = serde_json::from_value(manifest.clone()).map_err(|e| e.to_string())?;
     compile(&m, source)?;