mirror of
https://github.com/andrewyng/openworker.git
synced 2026-11-20 20:37:44 +00:00
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>
1069 lines
39 KiB
Rust
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"
|
|
);
|
|
}
|