diff --git a/oxa/oxa-cli/src/lead_input.rs b/oxa/oxa-cli/src/lead_input.rs index e81f4e1a..1a44ecd5 100644 --- a/oxa/oxa-cli/src/lead_input.rs +++ b/oxa/oxa-cli/src/lead_input.rs @@ -16,7 +16,7 @@ type Result = std::result::Result; /// The caller supplies the owner's uid from its user configuration, never project metadata. /// Sources must have private parent directories; producers may atomically replace files. -fn open(path: &Path, uid: u32) -> Result { +pub(crate) fn open(path: &Path, uid: u32) -> Result { let parent = path.parent().ok_or("missing input directory")?; let directory = fs::symlink_metadata(parent).map_err(|_| "input directory unavailable")?; if !directory.is_dir() || directory.uid() != uid || directory.mode() & 0o077 != 0 { diff --git a/oxa/oxa-cli/src/work_board.rs b/oxa/oxa-cli/src/work_board.rs index 35a0e6cc..c9e3ece5 100644 --- a/oxa/oxa-cli/src/work_board.rs +++ b/oxa/oxa-cli/src/work_board.rs @@ -2,6 +2,7 @@ pub mod refill_input; use oxa_work::board::{Board, GitHub, Mergeability, Policy, PullRequest, RequiredCi}; use serde_json::Value; +mod refill; use std::{ collections::{BTreeMap, BTreeSet}, io::{BufRead, IsTerminal, Read}, @@ -415,10 +416,14 @@ impl GitHub for Reader<'_> { pub(crate) fn run( args: &[String], root: &Path, + common: &Path, env: &oxa_config::Env, dirs: &oxa_config::Dirs, policy: &oxa_work::RunPolicy, ) -> Result { + if args.first().is_some_and(|arg| arg == "--refill") { + return refill::run(args, root, common, env, dirs, policy); + } // Existing parser declaration; migrate command/flag metadata together in #1062. let (repo, options) = match args { [shadow, flag, repo, options @ ..] if shadow == "--shadow" && flag == "--repo" => (repo, options), diff --git a/oxa/oxa-cli/src/work_board/refill.rs b/oxa/oxa-cli/src/work_board/refill.rs new file mode 100644 index 00000000..44a26628 --- /dev/null +++ b/oxa/oxa-cli/src/work_board/refill.rs @@ -0,0 +1,193 @@ +//! Owner-selected queue frontend. Existing Reader, Claims, publisher and private-file IO only. +use super::refill_input::{text, Input, Prepared}; +use super::*; +use crate::work_refill::{Consumer, Packet, Partition}; +use oxa_work::board::{assignment::Worker, Action}; +use std::{fs, os::unix::fs::MetadataExt, path::PathBuf}; + +fn private(path: &Path, uid: u32) -> Result { + let mut bytes = Vec::new(); + crate::lead_input::open(path, uid)? + .take(65_537) + .read_to_end(&mut bytes) + .map_err(|_| "cannot read private board input")?; + if bytes.len() > 65_536 { + return Err("board input exceeds capacity".into()); + } + serde_json::from_slice(&bytes).map_err(|_| "invalid private board input".into()) +} + +pub(super) fn run( + args: &[String], + root: &Path, + common: &Path, + env: &oxa_config::Env, + dirs: &oxa_config::Dirs, + policy: &oxa_work::RunPolicy, +) -> Result { + // #1062 owns command declarations; WorkBoard's existing Tail seam retains handler validation. + let [mode, repo_flag, repo, once, token_flag, config_flag, config] = args else { + return Err( + "usage: oxa work board --refill --repo OWNER/REPO --once --token-stdin --config PATH".into(), + ); + }; + if mode != "--refill" + || repo_flag != "--repo" + || once != "--once" + || token_flag != "--token-stdin" + || config_flag != "--config" + { + return Err("invalid board refill options".into()); + } + if repo.split('/').count() != 2 + || repo.split('/').any(|part| { + part.is_empty() + || matches!(part, "." | "..") + || !part + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b"-_.".contains(&b)) + }) + { + return Err("expected OWNER/REPO".into()); + } + if policy.offline { + return Err("GitHub board is unavailable in offline mode".into()); + } + if !crate::work_cmd::trusted(root, env, dirs)? { + return Err("source project is not trusted".into()); + } + let config = Path::new(config) + .canonicalize() + .map_err(|_| "board config unavailable")?; + let authority = dirs + .agent_dir + .canonicalize() + .map_err(|_| "owner controls unavailable")?; + if config.starts_with(root) || !config.starts_with(&authority) { + return Err("board config must be in protected owner controls outside the source project".into()); + } + let uid = fs::metadata(&dirs.home) + .map_err(|_| "owner home unavailable")? + .uid(); + let value = private(&config, uid)?; + if value["enabled"] != true { + return Ok(0); + } + let owner_path = |key| -> Result { + let path = PathBuf::from(text(&value, key)?); + crate::work_cmd::protected_storage(&path, root, common)?; + Ok(path) + }; + let queue = owner_path("queue")?; + let pause = owner_path("pause")?; + match fs::symlink_metadata(&pause) { + Ok(_) => return Ok(0), + Err(e) if e.kind() == std::io::ErrorKind::NotFound => (), + Err(_) => return Err("cannot establish board pause state".into()), + } + let claims = oxa_work::board::Claims::open(&owner_path("claims")?)?; + let worker: Worker = + serde_json::from_value(value["worker"].clone()).map_err(|_| "invalid authenticated worker export")?; + let partition = Partition { + modulus: value["partition"]["modulus"] + .as_u64() + .ok_or("missing partition modulus")?, + residues: serde_json::from_value(value["partition"]["residues"].clone()) + .map_err(|_| "invalid partition residues")?, + }; + let rows = value["packets"] + .as_array() + .filter(|rows| rows.len() <= 20) + .ok_or("expected bounded prepared packets")?; + let mut packets = vec![]; + let mut seen = BTreeSet::new(); + for row in rows { + let number = row["number"] + .as_u64() + .filter(|n| *n > 0 && seen.insert(*n)) + .ok_or("invalid or duplicate prepared ref")?; + let action: Action = + serde_json::from_value(row["action"].clone()).map_err(|_| "invalid prepared action")?; + let path = Path::new(text(row, "taskfile")?) + .canonicalize() + .map_err(|_| "taskfile unavailable")?; + if path.starts_with(root) || !path.starts_with(&authority) { + return Err("taskfile must be in protected owner controls outside source project".into()); + } + let mut task = String::new(); + crate::lead_input::open(&path, uid)? + .take(65_537) + .read_to_string(&mut task) + .map_err(|_| "cannot read prepared taskfile")?; + let header: Vec<_> = task + .lines() + .next() + .unwrap_or("") + .split_ascii_whitespace() + .collect(); + let branch = text(row, "branch")?; + let task_id = format!("{}{number}", if action == Action::BuildIssue { "i" } else { "c" }); + if task.len() > 65_536 + || !matches!(header.len(), 3 | 4) + || header[0] != task_id + || header[2] != branch + || header.get(3).copied().unwrap_or("main") + != if action == Action::BuildIssue { + "main" + } else { + branch + } + { + return Err("prepared taskfile ref/branch/base mismatch".into()); + } + packets.push(Prepared { + number, + revision: text(row, "revision")?.into(), + action, + branch: branch.into(), + task, + }); + } + let stdin = std::io::stdin(); + if stdin.is_terminal() { + return Err("App token input requires a private pipe, not a terminal".into()); + } + let token = token_line(&mut stdin.lock())?; + let gh = + crate::netguard::trusted_executable_for("gh", Some(&policy.host_path), Some(root), Some(&dirs.home)) + .ok_or("no trusted gh executable")?; + let intake = value["intake"] == true; + let mut source = Input::new(&gh, &policy.host_path, repo, &token, &packets, intake); + let now = SystemTime::now() + .duration_since(SystemTime::UNIX_EPOCH) + .map_err(|_| "invalid system clock")? + .as_secs(); + let policy = Policy { + enabled: true, + ..Policy::default() + }; + let consumer = Consumer { + repository: repo, + queue: &queue, + pause: &pause, + claims: &claims, + worker: &worker, + partition: &partition, + policy: &policy, + ttl: 1800, + }; + let inputs: Vec<_> = packets + .iter() + .map(|p| Packet { + number: p.number, + revision: &p.revision, + action: p.action, + task: &p.task, + }) + .collect(); + let mut log = oxa_work::shadow::open_log(&owner_path("log")?)?; + consumer.once(&mut source, &inputs, now, |board| { + oxa_work::shadow::run(&mut log, true, || Ok(board.board.clone()), |_| {}) + })?; + Ok(0) +} diff --git a/oxa/oxa-cli/src/work_cmd.rs b/oxa/oxa-cli/src/work_cmd.rs index b1c79da7..51b05547 100644 --- a/oxa/oxa-cli/src/work_cmd.rs +++ b/oxa/oxa-cli/src/work_cmd.rs @@ -17,7 +17,7 @@ pub(crate) fn trusted(cwd: &Path, env: &Env, dirs: &Dirs) -> Result Result<(), String> { +pub(crate) fn protected_storage(storage: &Path, repo: &Path, common: &Path) -> Result<(), String> { if !storage.is_absolute() || storage .components() @@ -151,7 +151,7 @@ pub(crate) fn run( }; protected_storage(&policy.storage, &root, &common)?; if args.first().is_some_and(|arg| arg == "board") { - return crate::work_board::run(&args[1..], &root, env, dirs, &policy); + return crate::work_board::run(&args[1..], &root, &common, env, dirs, &policy); } if matches!(args.first().map(String::as_str), Some("status" | "--status")) { let json = match args { diff --git a/oxa/oxa-cli/tests/work_refill_cli.rs b/oxa/oxa-cli/tests/work_refill_cli.rs new file mode 100644 index 00000000..b36388ea --- /dev/null +++ b/oxa/oxa-cli/tests/work_refill_cli.rs @@ -0,0 +1,216 @@ +use oxa_fake::TestEnv; +use serde_json::json; +use std::{ + fs, + io::Write, + os::unix::fs::PermissionsExt, + path::Path, + process::{Command, Stdio}, +}; + +fn invoke(env: &TestEnv, config: &Path, token: &str, offline: bool) -> std::process::Output { + let mut command = Command::new(env!("CARGO_BIN_EXE_oxa")); + command + .current_dir(env.work()) + .env_clear() + .envs(env.envs("http://127.0.0.1:1")) + .env("GH_TOKEN", "synthetic-cached") + .env( + "PATH", + format!("{}:{}", env.tmp().display(), std::env::var("PATH").unwrap()), + ); + if offline { + command.arg("--offline"); + } + command + .args([ + "work", + "board", + "--refill", + "--repo", + "example/project", + "--once", + "--token-stdin", + "--config", + ]) + .arg(config) + .stdin(Stdio::piped()) + .stdout(Stdio::piped()) + .stderr(Stdio::piped()); + let mut child = command.spawn().unwrap(); + child.stdin.take().unwrap().write_all(token.as_bytes()).unwrap(); + child.wait_with_output().unwrap() +} + +fn fixture() -> (TestEnv, std::path::PathBuf) { + let env = TestEnv::new(); + assert!(Command::new("git") + .args(["init", "-b", "main"]) + .current_dir(env.work()) + .output() + .unwrap() + .status + .success()); + oxa_perm::TrustStore::default() + .save(&env.agent_dir().join("trust.json"), &env.work(), true) + .unwrap(); + let controls = env.agent_dir().join("board-control"); + fs::create_dir(&controls).unwrap(); + fs::set_permissions(&controls, fs::Permissions::from_mode(0o700)).unwrap(); + fs::set_permissions(env.tmp(), fs::Permissions::from_mode(0o700)).unwrap(); + (env, controls) +} + +#[test] +fn refill_startup_retains_pause_and_refuses_worker_writable_authority() { + let (env, controls) = fixture(); + let config = controls.join("refill.json"); + let pause = controls.join("paused"); + let queue = controls.join("queue"); + let claims = controls.join("claims"); + for path in [&queue, &claims] { + fs::create_dir(path).unwrap(); + fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap(); + } + let sentinel = claims.join("preserved"); + fs::write(&sentinel, b"synthetic imported attempts and holds").unwrap(); + let write_config = |value: serde_json::Value| { + fs::write(&config, value.to_string()).unwrap(); + fs::set_permissions(&config, fs::Permissions::from_mode(0o600)).unwrap(); + }; + write_config(json!({"enabled":false})); + assert!(invoke(&env, &config, "", false).status.success()); + write_config(json!({"enabled":true,"queue":queue,"pause":pause,"claims":claims})); + fs::write(&pause, b"owner paused").unwrap(); + // Separate real processes simulate a service starting again while the pause persists. + for _ in 0..2 { + assert!(invoke(&env, &config, "", false).status.success()); + } + assert_eq!( + fs::read(&sentinel).unwrap(), + b"synthetic imported attempts and holds" + ); + assert_eq!(fs::read_dir(&claims).unwrap().count(), 1); + assert_eq!(fs::read_dir(&queue).unwrap().count(), 0); + assert_eq!(invoke(&env, &config, "", true).status.code(), Some(2)); + let outside = env.tmp().join("untrusted-control.json"); + fs::write(&outside, b"{\"enabled\":false}").unwrap(); + fs::set_permissions(&outside, fs::Permissions::from_mode(0o600)).unwrap(); + assert_eq!(invoke(&env, &outside, "", false).status.code(), Some(2)); +} + +#[test] +fn private_token_and_exact_task_ref_precede_one_durable_publication() { + use oxa_work::board::{assignment::ManualAuthority, AttemptState, Claims, ImportState}; + use std::collections::BTreeMap; + let (env, controls) = fixture(); + let queue = controls.join("queue"); + let root = controls.join("claims"); + for path in [&queue, &root] { + fs::create_dir(path).unwrap(); + fs::set_permissions(path, fs::Permissions::from_mode(0o700)).unwrap(); + } + let claims = Claims::open(&root).unwrap(); + let now = std::time::SystemTime::now() + .duration_since(std::time::UNIX_EPOCH) + .unwrap() + .as_secs(); + claims + .import_snapshot( + Some(ManualAuthority::Owner), + &BTreeMap::from([( + 44, + ImportState { + state: AttemptState::default(), + excluded: false, + }, + )]), + now, + ) + .unwrap(); + let task = controls.join("task.txt"); + fs::write( + &task, + b"i44 local/fake agent/44 main\nSynthetic prepared packet.\n", + ) + .unwrap(); + fs::set_permissions(&task, fs::Permissions::from_mode(0o600)).unwrap(); + let config = controls.join("refill.json"); + fs::write(&config, json!({"enabled":true,"intake":true,"queue":queue,"claims":root, + "pause":controls.join("paused"),"log":controls.join("audit.jsonl"), + "worker":{"id":"oxa:node/helper","kind":"oxa","roles":["builder"],"skills":[]}, + "partition":{"modulus":22,"residues":[0]}, + "packets":[{"number":44,"revision":"revision","action":"build_issue","branch":"agent/44","taskfile":task}] + }).to_string()).unwrap(); + fs::set_permissions(&config, fs::Permissions::from_mode(0o600)).unwrap(); + let gh = env.write( + "tmp/gh", + r#"#!/bin/sh +[ "$GH_TOKEN" = synthetic ] || exit 93 +printf 'read\n' >> "$0.calls" +printf 'HTTP/2.0 200 OK\r\n\r\n' +cat "$0.reply" +"#, + ); + fs::set_permissions(&gh, fs::Permissions::from_mode(0o700)).unwrap(); + fs::write(env.tmp().join("gh.reply"), json!({"data":{"repository":{ + "mergeQueue":null,"pullRequests":{"totalCount":0,"nodes":[],"pageInfo":{"hasNextPage":false,"endCursor":"last"}}, + "i44":{"number":44,"state":"OPEN","updatedAt":"revision"} + }}}).to_string()).unwrap(); + let missing = invoke(&env, &config, "", false); + assert_eq!(missing.status.code(), Some(2)); + assert!(String::from_utf8_lossy(&missing.stderr).contains("App token")); + assert!(!env.tmp().join("gh.calls").exists()); + fs::write( + &task, + b"i46 local/fake agent/44 main\nSynthetic prepared packet.\n", + ) + .unwrap(); + let mismatch = invoke(&env, &config, "synthetic\n", false); + assert_eq!(mismatch.status.code(), Some(2)); + assert_eq!(claims.snapshot().unwrap()[&44].attempts, 0); + assert_eq!(fs::read_dir(&queue).unwrap().count(), 0); + let valid = "i44 local/fake agent/44 main\nSynthetic prepared packet.\n"; + fs::write(&task, valid).unwrap(); + let result = invoke(&env, &config, "synthetic\n", false); + assert!( + result.status.success(), + "{}", + String::from_utf8_lossy(&result.stderr) + ); + let tasks: Vec<_> = fs::read_dir(&queue) + .unwrap() + .map(|entry| entry.unwrap().path()) + .filter(|path| path.is_file()) + .collect(); + assert_eq!(tasks.len(), 1); + assert_eq!(fs::read_to_string(&tasks[0]).unwrap(), valid); + assert_eq!(claims.snapshot().unwrap()[&44].attempts, 1); + assert!(invoke(&env, &config, "synthetic\n", false).status.success()); + assert_eq!(claims.snapshot().unwrap()[&44].attempts, 1); + let peer = env + .work() + .parent() + .unwrap() + .join(".oxa-worktrees") + .join(env.work().file_name().unwrap()) + .join("synthetic-task"); + fs::create_dir_all(&peer).unwrap(); + fs::set_permissions(&peer, fs::Permissions::from_mode(0o700)).unwrap(); + let original: serde_json::Value = serde_json::from_slice(&fs::read(&config).unwrap()).unwrap(); + for key in ["queue", "claims", "pause", "log"] { + let path = peer.join(key); + if matches!(key, "queue" | "claims") { + fs::create_dir(&path).unwrap(); + fs::set_permissions(&path, fs::Permissions::from_mode(0o700)).unwrap(); + } + let mut unsafe_config = original.clone(); + unsafe_config[key] = json!(path); + fs::write(&config, unsafe_config.to_string()).unwrap(); + assert_eq!( + invoke(&env, &config, "synthetic\n", false).status.code(), + Some(2), + "worker-writable {key} must be refused", + ); + } +}