Files
openworker/harness/runtime/tests/coding_handoff_git.rs
Rohit PrasadandDevika Verma d53e058eda Introduce OpenWorker Harness SDK (in beta), agent service cluster and relevant developer documentation (#844)
Allow developers to easily build AI apps without worrying about the harness part.
Bundles the Rust agent runtime as a SDK (Rust and TypeScript) for building desktop and web applications. Applications can manage a local harness or connect to an authenticated harness service on k8s with separately scaled workers and sandbox execution.

The implementation is primarily contained in harness/, with deployment tooling in deploy/, Markdown guides in docs/harness/guides/, and the static documentation site in docs-site/. It does not replace the existing Python harness or migrate OpenWorker Desktop.

Co-authored-by: Devika Verma <devikaverma11@gmail.com>
2026-11-06 09:45:20 -08:00

1069 lines
39 KiB
Rust

#![cfg(unix)]
//! Real Git/filesystem contracts. These do not publish artifacts or provision
//! provider environments; the later C4 controller suite must qualify that path.
use openworker_runtime::coding_handoff::{
git::{export, validate, Export},
ObjectFormat,
};
use std::{
path::{Path, PathBuf},
process::Command,
};
fn git(root: &Path, args: &[&str]) -> String {
let out = Command::new("/usr/bin/git")
.args([
"-c",
"core.hooksPath=/dev/null",
"-c",
"user.name=Fixture",
"-c",
"user.email=f@example.invalid",
])
.args(args)
.current_dir(root)
.env("GIT_CONFIG_NOSYSTEM", "1")
.env("GIT_CONFIG_GLOBAL", "/dev/null")
.env("GIT_TERMINAL_PROMPT", "0")
.output()
.unwrap();
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
String::from_utf8(out.stdout).unwrap().trim().into()
}
struct Fixture {
root: tempfile::TempDir,
repo: PathBuf,
request: Export,
}
fn fixture(format: ObjectFormat) -> Fixture {
let root = tempfile::tempdir().unwrap();
let repo = root.path().join("source");
std::fs::create_dir(&repo).unwrap();
git(
&repo,
&[
"init",
"-q",
&format!("--object-format={}", format.git_name()),
],
);
std::fs::write(repo.join("old.txt"), "original\n").unwrap();
std::fs::write(repo.join("gone.txt"), "remove me\n").unwrap();
git(&repo, &["add", "old.txt", "gone.txt"]);
git(&repo, &["commit", "-qm", "base"]);
let base = git(&repo, &["rev-parse", "HEAD"]);
std::fs::rename(repo.join("old.txt"), repo.join("renamed.txt")).unwrap();
std::fs::remove_file(repo.join("gone.txt")).unwrap();
std::fs::write(repo.join("binary.bin"), [0, 255, 1, 0, 200]).unwrap();
std::fs::write(repo.join("space name.txt"), "new\n").unwrap();
git(&repo, &["add", "-A"]);
git(&repo, &["commit", "-qm", "submission"]);
let submitted = git(&repo, &["rev-parse", "HEAD"]);
Fixture {
repo,
root,
request: Export {
operation_id: "handoff_one".into(),
scope_digest: "a".repeat(64),
repository: "org/game".into(),
directory: ".".into(),
object_format: format,
base_commit: base,
submitted_commit: submitted,
},
}
}
#[tokio::test]
async fn bundles_preserve_exact_revisions_binary_renamed_deleted_and_new_files() {
for format in [ObjectFormat::Sha1, ObjectFormat::Sha256] {
let f = fixture(format);
let original_head = git(&f.repo, &["rev-parse", "HEAD"]);
let receipt = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
assert!(receipt.size > 0);
assert_eq!(git(&f.repo, &["rev-parse", "HEAD"]), original_head);
let bundle = f.repo.join(&receipt.path);
let target = f.root.path().join("receiver");
std::fs::create_dir(&target).unwrap();
git(
&target,
&[
"init",
"-q",
&format!("--object-format={}", format.git_name()),
],
);
git(
&target,
&[
"-c",
"protocol.file.allow=always",
"fetch",
"--no-tags",
"--no-write-fetch-head",
bundle.to_str().unwrap(),
&format!("{}:refs/heads/work", receipt.advertised_ref),
],
);
git(
&target,
&["checkout", "--detach", &f.request.submitted_commit],
);
assert_eq!(
std::fs::read(target.join("binary.bin")).unwrap(),
[0, 255, 1, 0, 200]
);
assert_eq!(
std::fs::read_to_string(target.join("renamed.txt")).unwrap(),
"original\n"
);
assert!(!target.join("old.txt").exists() && !target.join("gone.txt").exists());
assert!(target.join("space name.txt").exists());
assert!(target.join(".git").is_dir());
assert_ne!(
git(&target, &["rev-parse", "--absolute-git-dir"]),
git(&f.repo, &["rev-parse", "--absolute-git-dir"])
);
// Re-entry inspects a stable original artifact; HEAD may subsequently
// advance without changing the original submitted revision or ref.
std::fs::write(f.repo.join("later.txt"), "later").unwrap();
git(&f.repo, &["add", "later.txt"]);
git(&f.repo, &["commit", "-qm", "later"]);
assert_eq!(
export(&f.repo, f.request.clone(), true, None)
.await
.unwrap(),
receipt
);
assert_eq!(
export(&f.repo, f.request.clone(), false, None)
.await
.unwrap(),
receipt
);
}
}
#[tokio::test]
async fn inspection_never_creates_missing_markers_or_replays_incomplete_export() {
let f = fixture(ObjectFormat::Sha1);
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
let op = f.repo.join(".openworker/handoffs/handoff_one");
assert!(!op.exists());
std::fs::create_dir_all(&op).unwrap();
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
assert!(!op.join("request.json").exists());
let good = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
let proof = std::fs::read(op.join("receipt.json")).unwrap();
std::fs::remove_file(f.repo.join(&good.path)).unwrap();
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
assert!(export(&f.repo, f.request.clone(), false, None)
.await
.is_err());
assert!(!f.repo.join(good.path).exists());
assert_eq!(std::fs::read(op.join("receipt.json")).unwrap(), proof);
}
#[tokio::test]
async fn wrong_intent_corrupt_bytes_and_marker_symlinks_cannot_reuse_an_export() {
let f = fixture(ObjectFormat::Sha1);
let receipt = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
let mut changed = f.request.clone();
changed.base_commit = changed.submitted_commit.clone();
assert!(export(&f.repo, changed, false, None).await.is_err());
let path = f.repo.join(&receipt.path);
let mut bytes = std::fs::read(&path).unwrap();
bytes.truncate(bytes.len() / 2);
std::fs::write(&path, &bytes).unwrap();
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
let mut other = f.request.clone();
other.operation_id = "handoff_two".into();
let op = f.repo.join(".openworker/handoffs/handoff_two");
std::fs::create_dir(&op).unwrap();
let outside = f.root.path().join("outside.json");
std::fs::write(&outside, "do not read/adopt me").unwrap();
std::os::unix::fs::symlink(&outside, op.join("request.json")).unwrap();
assert!(export(&f.repo, other, false, None).await.is_err());
assert_eq!(
std::fs::read_to_string(outside).unwrap(),
"do not read/adopt me"
);
}
#[tokio::test]
async fn source_helpers_alternates_and_replacement_objects_reject_before_export_mutation() {
for mode in ["helper", "alternates", "replace"] {
let f = fixture(ObjectFormat::Sha1);
match mode {
"helper" => {
git(
&f.repo,
&["config", "filter.bad.clean", "touch ../helper-ran"],
);
}
"alternates" => {
std::fs::write(
f.repo.join(".git/objects/info/alternates"),
"/outside/objects\n",
)
.unwrap();
}
_ => {
git(
&f.repo,
&[
"replace",
&f.request.base_commit,
&f.request.submitted_commit,
],
);
}
}
assert!(export(&f.repo, f.request.clone(), false, None)
.await
.is_err());
assert!(!f
.repo
.join(".openworker/handoffs/handoff_one/request.json")
.exists());
assert!(!f.root.path().join("helper-ran").exists());
}
}
#[tokio::test]
async fn incremental_prerequisites_extra_refs_and_unreachable_objects_are_rejected() {
let f = fixture(ObjectFormat::Sha1);
let receipt = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
let incremental = f.root.path().join("incremental.bundle");
git(
&f.repo,
&[
"bundle",
"create",
incremental.to_str().unwrap(),
"HEAD",
&format!("^{}", f.request.base_commit),
],
);
assert!(validate(&incremental, &f.request, "HEAD").await.is_err());
// Build an unrelated branch, include it in a malicious bundle, then strip
// only its advertised ref. Its extra objects must still be detected.
git(
&f.repo,
&["checkout", "-qb", "unrelated", &f.request.base_commit],
);
std::fs::write(f.repo.join("unrelated.txt"), "not submitted").unwrap();
git(&f.repo, &["add", "unrelated.txt"]);
git(&f.repo, &["commit", "-qm", "unrelated"]);
git(
&f.repo,
&["checkout", "--detach", &f.request.submitted_commit],
);
let all = f.root.path().join("all.bundle");
git(
&f.repo,
&["bundle", "create", all.to_str().unwrap(), "--all"],
);
assert!(validate(&all, &f.request, &receipt.advertised_ref)
.await
.is_err());
let bytes = std::fs::read(&all).unwrap();
let boundary = bytes.windows(2).position(|p| p == b"\n\n").unwrap();
let header = std::str::from_utf8(&bytes[..boundary]).unwrap();
let mut stripped = header
.lines()
.filter(|line| {
line.starts_with('#')
|| line.starts_with('@')
|| line.ends_with(&format!(" {}", receipt.advertised_ref))
})
.collect::<Vec<_>>()
.join("\n")
.into_bytes();
stripped.extend_from_slice(b"\n\n");
stripped.extend_from_slice(&bytes[boundary + 2..]);
let hidden = f.root.path().join("hidden-objects.bundle");
std::fs::write(&hidden, stripped).unwrap();
assert!(validate(&hidden, &f.request, &receipt.advertised_ref)
.await
.is_err());
}
#[tokio::test]
async fn replaced_repository_and_changed_original_ref_cannot_be_adopted() {
let f = fixture(ObjectFormat::Sha1);
let receipt = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
git(
&f.repo,
&[
"update-ref",
&receipt.advertised_ref,
&f.request.base_commit,
&f.request.submitted_commit,
],
);
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
git(
&f.repo,
&[
"update-ref",
&receipt.advertised_ref,
&f.request.submitted_commit,
&f.request.base_commit,
],
);
let old = f.root.path().join("original-source");
std::fs::rename(&f.repo, &old).unwrap();
std::fs::create_dir(&f.repo).unwrap();
git(&f.repo, &["init", "-q"]);
git(
&f.repo,
&[
"-c",
"protocol.file.allow=always",
"fetch",
old.join(&receipt.path).to_str().unwrap(),
&format!("{}:refs/heads/work", receipt.advertised_ref),
],
);
git(&f.repo, &["checkout", "-q", "work"]);
let op = f.repo.join(".openworker/handoffs/handoff_one");
std::fs::create_dir_all(&op).unwrap();
std::fs::copy(
old.join(".openworker/handoffs/handoff_one/request.json"),
op.join("request.json"),
)
.unwrap();
assert!(export(&f.repo, f.request.clone(), true, None)
.await
.is_err());
assert!(!op.join("source.bundle").exists());
}
#[tokio::test]
async fn oversized_stream_stops_without_receipt_and_inspection_never_restarts_export() {
use std::io::Write;
let mut f = fixture(ObjectFormat::Sha1);
let mut file = std::fs::File::create(f.repo.join("large.bin")).unwrap();
let mut state = 0x1234567812345678u64;
let mut chunk = vec![0; 65536];
// Deterministic incompressible fixture, not credential/randomness generation.
for _ in 0..(65 * 1024 * 1024 / chunk.len()) {
for part in chunk.chunks_exact_mut(8) {
state ^= state << 13;
state ^= state >> 7;
state ^= state << 17;
part.copy_from_slice(&state.to_le_bytes());
}
file.write_all(&chunk).unwrap();
}
file.sync_all().unwrap();
drop(file);
git(&f.repo, &["add", "large.bin"]);
git(&f.repo, &["commit", "-qm", "large source"]);
f.request.submitted_commit = git(&f.repo, &["rev-parse", "HEAD"]);
let error = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap_err();
assert!(error.to_string().contains("limit"), "{error:#}");
let op = f.repo.join(".openworker/handoffs/handoff_one");
assert!(!op.join("receipt.json").exists() && !op.join("source.bundle").exists());
assert!(std::fs::metadata(op.join("source.part")).unwrap().len() <= 64 * 1024 * 1024);
assert!(export(&f.repo, f.request.clone(), false, None)
.await
.is_err());
assert!(!op.join("source.bundle").exists());
}
use openworker_runtime::coding_handoff::{
transfer::{self, Transfer, CHUNK},
ArtifactRef, Import, Kind, Manifest, Producer,
};
async fn exported(f: &Fixture, directory: &str) -> Transfer {
let b = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
let manifest = Manifest {
version: 1,
kind: Kind::Submission,
repository: f.request.repository.clone(),
producer: Producer {
team_id: "at_one".into(),
agent_id: "builder_one".into(),
session_id: "s_one".into(),
},
object_format: f.request.object_format,
base_commit: f.request.base_commit.clone(),
submitted_commit: f.request.submitted_commit.clone(),
artifact: ArtifactRef {
session_id: "s_one".into(),
artifact_id: "a_one".into(),
size: b.size,
sha256: b.sha256.clone(),
},
reports: vec![],
};
Transfer {
request: Import {
operation_id: "receive_one".into(),
scope_digest: "b".repeat(64),
manifest_digest: manifest.digest().unwrap(),
directory: directory.into(),
},
manifest,
bundle: b,
}
}
async fn stage(f: &Fixture, target: &Path, t: &Transfer) {
let status = transfer::prepare(target, t.clone(), false).await.unwrap();
assert_eq!(status.received, 0);
let mut offset = 0;
while offset < t.bundle.size {
let bytes = transfer::read_chunk(&f.repo, &t.bundle, offset)
.await
.unwrap();
assert!(bytes.len() <= CHUNK);
let status = transfer::write_chunk(target, &t.handle(), offset, &bytes)
.await
.unwrap();
let replay = transfer::write_chunk(target, &t.handle(), offset, &bytes)
.await
.unwrap();
assert_eq!(status, replay); // Immutable chunk receipt after a lost reply.
offset += bytes.len() as u64;
assert_eq!(status.received, offset);
}
}
#[tokio::test]
async fn private_chunks_and_independent_checkout_preserve_both_object_formats_and_lost_ack() {
for format in [ObjectFormat::Sha1, ObjectFormat::Sha256] {
let f = fixture(format);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
assert!(transfer::finish(target.path(), &t.handle(), true)
.await
.is_err());
assert!(!target.path().join("project").exists());
let r = transfer::finish(target.path(), &t.handle(), false)
.await
.unwrap();
assert_eq!(
r,
transfer::finish(target.path(), &t.handle(), true)
.await
.unwrap()
);
assert_eq!(r.commit, t.manifest.submitted_commit);
assert_eq!(
git(&r.path, &["symbolic-ref", "HEAD"]),
"refs/heads/openworker/import"
);
assert_eq!(
git(&r.path, &["rev-parse", "--show-object-format"]),
format.git_name()
);
assert_eq!(
git(&r.path, &["rev-parse", "--absolute-git-dir"]),
r.path.join(".git").to_str().unwrap()
);
assert_eq!(
std::fs::read(r.path.join("binary.bin")).unwrap(),
[0, 255, 1, 0, 200]
);
assert!(r.path.join("renamed.txt").is_file());
assert!(!r.path.join("gone.txt").exists());
assert!(!r.path.join("old.txt").exists());
assert_eq!(git(&r.path, &["remote"]), "");
assert_eq!(
transfer::inspect(target.path(), &t.handle())
.await
.unwrap()
.receipt,
Some(r.clone())
);
git(&r.path, &["checkout", "--quiet", &t.manifest.base_commit]);
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.is_err());
assert_eq!(git(&r.path, &["rev-parse", "HEAD"]), t.manifest.base_commit);
// Never reset it.
}
}
#[tokio::test]
async fn private_transfer_refuses_changed_identity_chunks_holes_and_symlink_markers() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
assert!(transfer::prepare(target.path(), t.clone(), true)
.await
.is_err());
assert!(!target.path().join(".openworker").exists());
transfer::prepare(target.path(), t.clone(), false)
.await
.unwrap();
let mut changed = t.clone();
changed.request.directory = "other".into();
assert!(transfer::prepare(target.path(), changed, false)
.await
.is_err());
let mut handle = t.handle();
handle.scope_digest = "c".repeat(64);
assert!(transfer::inspect(target.path(), &handle).await.is_err());
let bytes = transfer::read_chunk(&f.repo, &t.bundle, 0).await.unwrap();
assert!(transfer::write_chunk(target.path(), &t.handle(), 1, &bytes)
.await
.is_err());
assert!(
transfer::write_chunk(target.path(), &t.handle(), 0, &bytes[..bytes.len() - 1])
.await
.is_err()
);
assert!(
transfer::write_chunk(target.path(), &t.handle(), CHUNK as u64, &bytes)
.await
.is_err()
);
transfer::write_chunk(target.path(), &t.handle(), 0, &bytes)
.await
.unwrap();
let mut changed = bytes;
changed[0] ^= 1;
assert!(
transfer::write_chunk(target.path(), &t.handle(), 0, &changed)
.await
.is_err()
);
let marker = target
.path()
.join(".openworker/imports/receive_one/request.json");
let original = std::fs::read(&marker).unwrap();
std::fs::remove_file(&marker).unwrap();
let foreign = target.path().join("foreign");
std::fs::write(&foreign, original).unwrap();
std::os::unix::fs::symlink(&foreign, &marker).unwrap();
assert!(transfer::inspect(target.path(), &t.handle()).await.is_err());
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.is_err());
assert!(!target.path().join("project").exists());
}
#[tokio::test]
async fn original_checkout_dispatch_is_not_replayed_and_existing_folders_survive() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
let marker = target
.path()
.join(".openworker/imports/receive_one/checkout.json");
std::fs::write(&marker, "dispatch persisted, acknowledgement lost").unwrap();
assert!(
transfer::inspect(target.path(), &t.handle())
.await
.unwrap()
.checkout_dispatched
);
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.is_err());
assert!(!target.path().join("project").exists());
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
std::fs::create_dir(target.path().join("project")).unwrap();
std::fs::write(target.path().join("project/keep"), "leave me").unwrap();
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.is_err());
assert_eq!(
std::fs::read_to_string(target.path().join("project/keep")).unwrap(),
"leave me"
);
assert!(!target.path().join("project/.git").exists());
}
#[tokio::test]
async fn transferred_bytes_and_original_repository_identity_are_checked() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
let chunk = target
.path()
.join(".openworker/imports/receive_one/chunk-00000000");
let mut bytes = std::fs::read(&chunk).unwrap();
let middle = bytes.len() / 2;
bytes[middle] ^= 1;
std::fs::write(chunk, bytes).unwrap();
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.unwrap_err()
.to_string()
.contains("Imported bytes differ"));
assert!(!target.path().join("project").exists());
std::fs::rename(f.repo.join(".git"), f.repo.join("saved-git")).unwrap();
git(&f.repo, &["init", "-q"]);
assert!(transfer::read_chunk(&f.repo, &t.bundle, 0).await.is_err());
let mut changed = t.clone();
changed.bundle.sha256 = "c".repeat(64);
assert!(changed.validate().is_err());
for path in [
".openworker",
".openworker/imports/other",
"../outside",
"C:\\host",
] {
let mut changed = t.clone();
changed.request.directory = path.into();
assert!(changed.validate().is_err());
}
}
#[tokio::test]
async fn expanded_checkout_limit_stops_compressible_bundles_before_materializing_files() {
let mut f = fixture(ObjectFormat::Sha1);
let file = std::fs::File::create(f.repo.join("huge.bin")).unwrap();
file.set_len(transfer::MAX_CHECKOUT_BYTES + 1).unwrap();
git(&f.repo, &["add", "huge.bin"]);
git(&f.repo, &["commit", "-qm", "compressible"]);
f.request.submitted_commit = git(&f.repo, &["rev-parse", "HEAD"]);
let t = exported(&f, "project").await;
assert!(t.bundle.size < 1024 * 1024);
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
let e = transfer::finish(target.path(), &t.handle(), false)
.await
.unwrap_err();
assert!(e.to_string().contains("Expanded checkout exceeds"), "{e}");
assert!(!target.path().join("project/huge.bin").exists());
assert!(
transfer::inspect(target.path(), &t.handle())
.await
.unwrap()
.checkout_dispatched
);
assert!(transfer::finish(target.path(), &t.handle(), false)
.await
.is_err());
}
async fn private_rpc(root: &Path, method: &str, params: serde_json::Value) -> serde_json::Value {
use tokio::io::AsyncWriteExt;
let mut child = tokio::process::Command::new(env!("CARGO_BIN_EXE_openworker"))
.args(["workspace-stdio", "--root"])
.arg(root)
.stdin(std::process::Stdio::piped())
.stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped())
.kill_on_drop(true)
.spawn()
.unwrap();
let frame = serde_json::json!({"jsonrpc":"2.0","id":1,"method":method,"params":params});
let mut input = child.stdin.take().unwrap();
input
.write_all(format!("{frame}\n").as_bytes())
.await
.unwrap();
input.shutdown().await.unwrap();
drop(input);
let out = tokio::time::timeout(std::time::Duration::from_secs(20), child.wait_with_output())
.await
.unwrap()
.unwrap();
assert!(
out.status.success(),
"{}",
String::from_utf8_lossy(&out.stderr)
);
assert!(out.stdout.len() <= 64000);
serde_json::from_slice(&out.stdout).unwrap()
}
#[tokio::test]
async fn private_stdio_transfers_chunks_across_processes_without_discovering_model_tools() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
use serde_json::json;
let p = private_rpc(target.path(), "handoff/prepare", json!(t)).await;
assert_eq!(p["result"]["received"], 0, "{p}");
let mut offset = 0;
while offset < t.bundle.size {
let r = private_rpc(
&f.repo,
"handoff/read",
json!({"bundle":t.bundle,"offset":offset}),
)
.await;
assert!(r.get("error").is_none(), "{r}");
let w = private_rpc(
target.path(),
"handoff/write",
json!({"handle":t.handle(),"offset":offset,"data":r["result"]["data"]}),
)
.await;
assert!(w.get("error").is_none(), "{w}");
offset = w["result"]["received"].as_u64().unwrap();
}
let r = private_rpc(target.path(), "handoff/finish", json!(t.handle())).await;
assert_eq!(r["result"]["commit"], t.manifest.submitted_commit, "{r}");
let recovered = private_rpc(target.path(), "handoff/inspect_checkout", json!(t.handle())).await;
assert_eq!(recovered["result"], r["result"]);
let workspace_request = openworker_runtime::team_workspace::Request {
operation_id: t.request.operation_id.clone(),
scope_digest: t.request.scope_digest.clone(),
selection: openworker_runtime::team_workspace::Selection::Directory {
path: t.request.directory.clone(),
},
};
let ready = private_rpc(
target.path(),
"handoff/workspace",
json!({"handle":t.handle(),"request":workspace_request}),
)
.await;
let receipt: openworker_runtime::team_workspace::Receipt =
serde_json::from_value(ready["result"].clone()).unwrap();
receipt.verify().unwrap();
assert!(receipt.independent_git.is_some());
assert_eq!(
private_rpc(target.path(), "workspace/verify", json!(receipt)).await["result"],
ready["result"]
);
assert!(private_rpc(target.path(), "tools/list", json!({}))
.await
.get("error")
.is_some());
let bad = private_rpc(
target.path(),
"handoff/write",
json!({"handle":t.handle(),"offset":0,"data":"AA==","host":"/tmp/other"}),
)
.await;
assert!(bad.get("error").is_some());
assert_eq!(
std::fs::read(target.path().join("project/binary.bin")).unwrap(),
[0, 255, 1, 0, 200]
);
}
#[tokio::test]
async fn imported_workspace_pins_own_git_metadata_across_child_commits_and_launch_checks() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
transfer::finish(target.path(), &t.handle(), false)
.await
.unwrap();
let request = openworker_runtime::team_workspace::Request {
operation_id: t.request.operation_id.clone(),
scope_digest: t.request.scope_digest.clone(),
selection: openworker_runtime::team_workspace::Selection::Directory {
path: t.request.directory.clone(),
},
};
let receipt = transfer::workspace_receipt(target.path(), &t.handle(), request.clone())
.await
.unwrap();
assert!(receipt.independent_git.is_some());
assert!(receipt.git_dir.is_none());
receipt.verify().unwrap();
let mut tools =
openworker_runtime::coding::CodingTools::with_workspace(receipt.clone()).unwrap();
tools
.call(&receipt.path, "git_status", &serde_json::json!({}))
.await
.unwrap();
// Builder changes to its own HEAD are normal after the import was admitted.
std::fs::write(receipt.path.join("builder.txt"), "builder work").unwrap();
git(&receipt.path, &["add", "builder.txt"]);
git(&receipt.path, &["commit", "-qm", "builder work"]);
receipt.verify().unwrap();
tools
.call(&receipt.path, "git_log", &serde_json::json!({"limit":1}))
.await
.unwrap();
let mut changed = request;
changed.scope_digest = "c".repeat(64);
assert!(
transfer::workspace_receipt(target.path(), &t.handle(), changed)
.await
.is_err()
);
let dot = receipt.path.join(".git");
std::fs::rename(&dot, receipt.path.join("old-git")).unwrap();
git(&receipt.path, &["init", "-q"]);
assert!(receipt.verify().is_err());
assert!(tools
.call(
&receipt.path,
"read_file",
&serde_json::json!({"path":"builder.txt"})
)
.await
.is_err());
tools.shutdown().await;
}
#[tokio::test]
async fn independent_workspace_cannot_acquire_external_git_objects_or_linked_metadata() {
let f = fixture(ObjectFormat::Sha1);
let t = exported(&f, "project").await;
let target = tempfile::tempdir().unwrap();
stage(&f, target.path(), &t).await;
transfer::finish(target.path(), &t.handle(), false)
.await
.unwrap();
let request = openworker_runtime::team_workspace::Request {
operation_id: t.request.operation_id.clone(),
scope_digest: t.request.scope_digest.clone(),
selection: openworker_runtime::team_workspace::Selection::Directory {
path: "project".into(),
},
};
let receipt = transfer::workspace_receipt(target.path(), &t.handle(), request)
.await
.unwrap();
let dot = receipt.path.join(".git");
std::fs::write(dot.join("commondir"), f.repo.join(".git").to_str().unwrap()).unwrap();
assert!(receipt.verify().is_err());
std::fs::remove_file(dot.join("commondir")).unwrap();
std::fs::write(
dot.join("objects/info/alternates"),
f.repo.join(".git/objects").to_str().unwrap(),
)
.unwrap();
assert!(receipt.verify().is_err());
std::fs::remove_file(dot.join("objects/info/alternates")).unwrap();
std::fs::rename(dot.join("objects"), dot.join("saved-objects")).unwrap();
std::os::unix::fs::symlink(f.repo.join(".git/objects"), dot.join("objects")).unwrap();
assert!(receipt.verify().is_err());
let mut mixed = receipt.clone();
mixed.git_dir = Some(f.repo.join(".git"));
assert!(mixed.verify().is_err());
}
#[tokio::test]
async fn root_repository_bookkeeping_is_excluded_from_normal_git_staging_without_changing_tracked_ignore_rules(
) {
let f = fixture(ObjectFormat::Sha1);
let exclude = f.repo.join(".git/info/exclude");
std::fs::write(&exclude, b"user-pattern\n!/.openworker/\n").unwrap();
std::fs::write(f.repo.join(".gitignore"), "user-build/\n").unwrap();
git(&f.repo, &["add", ".gitignore"]);
git(&f.repo, &["commit", "-qm", "user ignore"]);
let before = std::fs::read(f.repo.join(".gitignore")).unwrap();
let exported = export(&f.repo, f.request.clone(), false, None)
.await
.unwrap();
assert!(!git(&f.repo, &["status", "--porcelain"]).contains(".openworker"));
git(&f.repo, &["add", "-A"]);
assert!(git(&f.repo, &["diff", "--cached", "--name-only"]).is_empty());
assert_eq!(std::fs::read(f.repo.join(".gitignore")).unwrap(), before);
let rules = std::fs::read(&exclude).unwrap();
assert!(rules.starts_with(b"user-pattern\n!/.openworker/\n"));
export(&f.repo, f.request.clone(), true, None)
.await
.unwrap();
assert_eq!(std::fs::read(&exclude).unwrap(), rules); // Inspection cannot append.
assert!(f.repo.join(&exported.path).exists());
let g = fixture(ObjectFormat::Sha1);
let foreign = g.root.path().join("foreign-exclude");
std::fs::write(&foreign, b"keep me").unwrap();
let target = g.repo.join(".git/info/exclude");
std::fs::remove_file(&target).unwrap();
std::os::unix::fs::symlink(&foreign, &target).unwrap();
assert!(export(&g.repo, g.request.clone(), false, None)
.await
.is_err());
assert_eq!(std::fs::read(&foreign).unwrap(), b"keep me");
}
async fn integration_fixture(
root_repository: bool,
format: ObjectFormat,
) -> (
Fixture,
PathBuf,
openworker_runtime::coding_handoff::integrate::Request,
) {
let f = fixture(format);
let root = if root_repository {
f.repo.clone()
} else {
f.root.path().canonicalize().unwrap()
};
let t = exported(&f, ".openworker-received/team/submission").await;
stage(&f, &root, &t).await;
transfer::finish(&root, &t.handle(), false).await.unwrap();
let workspace = transfer::workspace_receipt(
&root,
&t.handle(),
openworker_runtime::team_workspace::Request {
operation_id: t.request.operation_id.clone(),
scope_digest: t.request.scope_digest.clone(),
selection: openworker_runtime::team_workspace::Selection::Directory {
path: t.request.directory.clone(),
},
},
)
.await
.unwrap();
git(
&f.repo,
&["checkout", "-qb", "integrate-main", &f.request.base_commit],
);
let request = openworker_runtime::coding_handoff::integrate::Request {
export: Export {
operation_id: "integrate_one".into(),
scope_digest: "d".repeat(64),
directory: if root_repository {
".".into()
} else {
"source".into()
},
..f.request.clone()
},
expected_head: f.request.base_commit.clone(),
received: workspace,
};
(f, root, request)
}
#[tokio::test]
async fn explicit_integration_cas_preserves_exact_tree_and_lost_receipt_never_replays() {
use openworker_runtime::coding_handoff::integrate::integrate;
for (root_repo, format) in [(false, ObjectFormat::Sha1), (true, ObjectFormat::Sha256)] {
let (f, root, request) = integration_fixture(root_repo, format).await;
let result = integrate(&root, request.clone(), false).await.unwrap();
assert_eq!(result.commit, f.request.submitted_commit);
assert_eq!(git(&f.repo, &["rev-parse", "HEAD"]), result.commit);
assert_eq!(
std::fs::read(f.repo.join("binary.bin")).unwrap(),
[0, 255, 1, 0, 200]
);
assert!(!f.repo.join("old.txt").exists() && !f.repo.join("gone.txt").exists());
assert_eq!(git(&f.repo, &["status", "--porcelain"]), "");
let original_log = git(
&f.repo,
&["reflog", "--format=%H", "refs/heads/integrate-main"],
);
let marker = root.join(".openworker/integrations/integrate_one/receipt.json");
std::fs::remove_file(&marker).unwrap();
assert_eq!(
integrate(&root, request.clone(), true).await.unwrap(),
result
);
assert!(!marker.exists()); // Inspection observes; it does not write a new acknowledgement.
assert_eq!(
git(
&f.repo,
&["reflog", "--format=%H", "refs/heads/integrate-main"]
),
original_log
);
let mut changed = request;
changed.expected_head = f.request.submitted_commit.clone();
assert!(integrate(&root, changed, true).await.is_err());
}
}
#[tokio::test]
async fn integration_refuses_dirty_stale_divergent_and_rewritten_sources_without_reset() {
use openworker_runtime::coding_handoff::integrate::integrate;
for mode in ["dirty", "stale", "divergent", "rewrite"] {
let (f, root, mut request) = integration_fixture(false, ObjectFormat::Sha1).await;
match mode {
"dirty" => std::fs::write(f.repo.join("old.txt"), "preserve my work").unwrap(),
"stale" => request.expected_head = f.request.submitted_commit.clone(),
"divergent" => {
std::fs::write(f.repo.join("divergent"), "mine").unwrap();
git(&f.repo, &["add", "divergent"]);
git(&f.repo, &["commit", "-qm", "other line"]);
request.expected_head = git(&f.repo, &["rev-parse", "HEAD"]);
}
"rewrite" => {
git(
&f.repo,
&["config", "url.https://example.invalid/.insteadOf", "/"],
);
}
_ => unreachable!(),
}
let before = git(&f.repo, &["rev-parse", "HEAD"]);
assert!(
integrate(&root, request.clone(), false).await.is_err(),
"{mode}"
);
assert_eq!(git(&f.repo, &["rev-parse", "HEAD"]), before);
assert!(integrate(&root, request, true).await.is_err(), "{mode}");
assert_eq!(git(&f.repo, &["rev-parse", "HEAD"]), before);
if mode == "dirty" {
assert_eq!(
std::fs::read_to_string(f.repo.join("old.txt")).unwrap(),
"preserve my work"
)
}
}
}
#[tokio::test]
async fn integration_inspection_preserves_partial_index_files_when_branch_cas_was_not_acknowledged()
{
use openworker_runtime::coding_handoff::integrate::{integrate, rpc};
let (f, root, request) = integration_fixture(false, ObjectFormat::Sha1).await;
integrate(&root, request.clone(), false).await.unwrap();
// Recreate the observable crash boundary: index/files at submitted tree,
// original branch ref at expected HEAD, no final acknowledgement receipt.
git(
&f.repo,
&[
"update-ref",
"refs/heads/integrate-main",
&request.expected_head,
&request.export.submitted_commit,
],
);
let receipt = root.join(".openworker/integrations/integrate_one/receipt.json");
std::fs::remove_file(&receipt).unwrap();
let status = git(&f.repo, &["status", "--porcelain"]);
assert!(!status.is_empty());
assert!(rpc(&root, request.clone(), true).await.is_err());
assert_eq!(git(&f.repo, &["rev-parse", "HEAD"]), request.expected_head);
assert_eq!(git(&f.repo, &["status", "--porcelain"]), status);
assert_eq!(
std::fs::read(f.repo.join("binary.bin")).unwrap(),
[0, 255, 1, 0, 200]
);
assert!(!receipt.exists());
}
#[tokio::test]
async fn known_integration_rejection_survives_lost_reply_and_is_not_retried_after_source_changes() {
use openworker_runtime::coding_handoff::integrate::{rpc, Observation};
let (f, root, mut request) = integration_fixture(false, ObjectFormat::Sha1).await;
request.expected_head = "f".repeat(40);
let rejected = rpc(&root, request.clone(), false).await.unwrap();
assert!(matches!(&rejected,Observation::Rejected{reason,..} if reason.contains("stale")));
std::fs::write(f.repo.join("old.txt"), "work after rejection").unwrap();
let before = git(&f.repo, &["status", "--porcelain"]);
assert_eq!(rpc(&root, request, true).await.unwrap(), rejected);
assert_eq!(git(&f.repo, &["status", "--porcelain"]), before);
assert_eq!(
std::fs::read_to_string(f.repo.join("old.txt")).unwrap(),
"work after rejection"
);
}