diff --git a/.forge/prs/65e5642d-e72d-4514-9791-39bf0ff0f590/patch.diff b/.forge/prs/65e5642d-e72d-4514-9791-39bf0ff0f590/patch.diffnew file mode 100644index 0000000..5ecc32c--- /dev/null+++ b/.forge/prs/65e5642d-e72d-4514-9791-39bf0ff0f590/patch.diff@@ -0,0 +1,482 @@1+From 3df50af3fa2023250dc356c2a0abf938039cdbfd Mon Sep 17 00:00:00 20012+From: hu13-test <[email protected]>3+Date: Tue, 27 Oct 2026 14:08:06 +00004+Subject: [PATCH] dumb static clone via repo.git (#54)5+6+---7+ .../issue.md | 11 ++8+ entrypoint.sh | 2 +-9+ src/agents.rs | 2 +-10+ src/build.rs | 46 ++++--11+ src/gitx.rs | 134 ++++++++++++++++++12+ src/main.rs | 2 +-13+ src/serve.rs | 10 ++14+ tests/clone_origin.rs | 88 ++++++++++--15+ 8 files changed, 266 insertions(+), 29 deletions(-)16+ create mode 100644 .forge/issues/d2ea6e8e-41d9-4051-9db3-cb362ec1199f/issue.md17+18+diff --git a/.forge/issues/d2ea6e8e-41d9-4051-9db3-cb362ec1199f/issue.md b/.forge/issues/d2ea6e8e-41d9-4051-9db3-cb362ec1199f/issue.md19+new file mode 10064420+index 0000000..c4b8d0c21+--- /dev/null22++++ b/.forge/issues/d2ea6e8e-41d9-4051-9db3-cb362ec1199f/issue.md23+@@ -0,0 +1,11 @@24++---25++id: d2ea6e8e-41d9-4051-9db3-cb362ec1199f26++title: Dumb static git clone via repo.git27++state: open28++labels: []29++assignees: []30++milestone: null31++created: 2026-10-27T14:03:54.332624090Z32++updated: null33++---34++Approved: emit dist/repo.git bare + update-server-info at build so git clone https://hub13link/repo.git works on docker/Pages/nginx with one shape. No GitHub URL. Keep bundle+tarball. Update clone_block to advertise dumb URL with public-origin, keep serve smart intact.35+diff --git a/entrypoint.sh b/entrypoint.sh36+index 21a094f..69cc5f6 10075537+--- a/entrypoint.sh38++++ b/entrypoint.sh39+@@ -9,7 +9,7 @@40+ # HU13_BRANCH branch to build (default: main/master auto-detect)41+ # HU13_CLONE_URL clone URL to advertise (default: repo origin remote)42+ # HU13_PUBLIC_ORIGIN public base URL of this server (default: unset;43+-# when set, clone block advertises `<origin>/repo.bundle`)44++# when set, clone block advertises `<origin>/repo.git`)45+ # HU13_REPO_NAME repo display name (default: repo dir name; never blank)46+ # HU13_DESCRIPTION47+ # site description (default: hidden, no empty <p>)48+diff --git a/src/agents.rs b/src/agents.rs49+index d4e49f1..11a1a72 10064450+--- a/src/agents.rs51++++ b/src/agents.rs52+@@ -40,7 +40,7 @@ fn agents_markdown(53+ - Site: `{site_name}`, {clone_line}\n\54+ - Raw file bytes: `/raw/<path>` (byte-identical to the repo).\n\55+ - JSON API (compact fixed-order, same data as HTML): `/api/issues.json`, `/api/pulls.json`, `/api/commits.json`, `/api/releases.json`, `/api/wiki.json`.\n\56+- - Snapshots: `/repo.tar.gz` (extract) + `/repo.bundle` (`git clone -b {branch} repo.bundle`). The bundle is authoritative when no clone URL is configured.\n\57++ - Clone: `git clone <origin>/repo.git` (dumb-HTTP, works on any static server) or `/repo.tar.gz` (extract) + `/repo.bundle` (`git clone -b {branch} repo.bundle`). The bundle is authoritative when no clone URL is configured.\n\58+ - Releases + artifacts: `/releases/index.html`, `/releases/<ver>.html`, downloads under `/releases/<ver>/<file>`.\n\59+ - Feed: `/feed.atom` (up to 50 entries, commits + releases newest-first — poll this, not the HTML).\n\60+ - Human pages mirror the same data: `/commits.html`, `/commit/<sha>.html`, `/issues/index.html`, `/pulls/index.html`, `/tasks/index.html`, `/ci/index.html`, `/wiki/index.html`.\n\n\61+diff --git a/src/build.rs b/src/build.rs62+index 68698e3..5ca0e2a 10064463+--- a/src/build.rs64++++ b/src/build.rs65+@@ -7,7 +7,9 @@66+ //! `tasks/index.html`, `ci/index.html`, `releases/index.html`,67+ //! `releases/<ver>.html`, `releases/<ver>/<file>` artifacts,68+ //! `wiki/index.html`, `wiki/<path>.html`, `api/*.json`, `agents.html` +69+-//! `agents.md`, `repo.bundle` + `repo.tar.gz`, and `style.css`.70++//! `agents.md`, `repo.bundle` + `repo.tar.gz` + `repo.git/` (dumb-HTTP,71++//! issue #54: `git clone <origin>/repo.git` works on any static server),72++//! and `style.css`.73+ //!74+ //! Bodies from the repo are semi-trusted but treated as untrusted:75+ //! markdown goes through [`markdown_to_html`], which escapes raw HTML;76+@@ -35,7 +37,7 @@ pub struct BuildOptions {77+ pub clone_url_flag: Option<String>,78+ /// `--public-origin` flag (else `$HU13_PUBLIC_ORIGIN`, else unset).79+ /// Base URL of this server, e.g. `http://host:39313`. When set, the80+- /// clone block advertises `git clone <origin>/repo.bundle`.81++ /// clone block advertises `git clone <origin>/repo.git` (dumb-HTTP).82+ /// Empty/whitespace falls through to unset.83+ pub public_origin_flag: Option<String>,84+ /// `--repo-name` flag (else `$HU13_REPO_NAME`, else repo dir name).85+@@ -630,15 +632,16 @@ pub fn file_table_html(86+ }87+ 88+ /// Prominent Clone & download section for the code tab (m6, f0rge89+-/// issues #20 + #32 + #34): collapsed native `<details>` (closed by90+-/// default, zero JS, keyboard accessible, works file://) with stacked91+-/// no-JS sections and selectable `<pre>` commands inside. When a public92+-/// origin is configured the primary command is93+-/// `git clone <origin>/repo.bundle` (exact snapshot note + tarball94+-/// secondary, origin remote demoted to "mirror source"); otherwise95+-/// bundle-first as before (`git clone <url>` first when a clone URL is96+-/// configured, else local bundle) plus the bundle/tarball links with97+-/// sizes and shas. The `<summary>` always shows `Clone & download`98++/// issues #20 + #32 + #34; dumb-clone #54): collapsed native `<details>`99++/// (closed by default, zero JS, keyboard accessible, works file://) with100++/// stacked no-JS sections and selectable `<pre>` commands inside. When a101++/// public origin is configured the primary command is102++/// `git clone <origin>/repo.git` (dumb-HTTP, works on Pages/nginx/serve103++/// with zero dynamic; exact snapshot note + bundle/tarball secondary,104++/// origin remote demoted to "mirror source"); otherwise dumb-local first105++/// (`git clone <url>` first when a clone URL is configured, else local106++/// `git clone repo.git`) plus the bundle/tarball links with sizes and107++/// shas. The `<summary>` always shows `Clone & download`108+ /// plus a branch@sha hint. The summary also carries the CI verdict badge109+ /// (m6 finish, f0rge #53): `Clone & download · branch @ sha · CI badge`110+ /// so the standalone repo-meta branch/CI line is gone (no duplication).111+@@ -687,16 +690,24 @@ pub fn clone_block(112+ );113+ if let Some(origin) = public_origin.map(str::trim).filter(|s| !s.is_empty()) {114+ let base = origin.trim_end_matches('/');115++ let dumb_url = format!("{base}/repo.git");116+ let bundle_url = format!("{base}/repo.bundle");117+ let tarball_url = format!("{base}/repo.tar.gz");118+ out.push_str("<h3>Clone with git</h3>\n");119+ out.push_str(&format!(120+ "<pre class=\"clone-cmd\"><code>git clone {}</code></pre>\n\121+ <p>exact snapshot of <code>{}</code> @ <code>{}</code>.</p>\n",122+- esc(&bundle_url),123++ esc(&dumb_url),124+ esc(branch),125+ esc(short_sha)126+ ));127++ out.push_str("<h3>Download the snapshot</h3>\n");128++ out.push_str(&format!(129++ "<pre class=\"clone-cmd\"><code>curl -O {}</code></pre>\n\130++ <pre class=\"clone-cmd\"><code>git clone repo.bundle -b {}</code></pre>\n<p>{bundle_link}</p>\n",131++ esc(&bundle_url),132++ esc(branch)133++ ));134+ out.push_str("<h3>Download the tarball</h3>\n");135+ out.push_str(&format!(136+ "<pre class=\"clone-cmd\"><code>curl -O {}</code></pre>\n<p>{tarball_link}</p>\n",137+@@ -718,6 +729,12 @@ pub fn clone_block(138+ esc(url)139+ ));140+ }141++ out.push_str("<h3>Clone this mirror</h3>\n");142++ out.push_str(&format!(143++ "<pre class=\"clone-cmd\"><code>git clone repo.git -b {}</code></pre>\n\144++ <p>dumb-HTTP checkout served from this server; ask the host for its address.</p>\n",145++ esc(branch)146++ ));147+ out.push_str("<h3>Clone the bundle</h3>\n");148+ out.push_str(&format!(149+ "<pre class=\"clone-cmd\"><code>git clone repo.bundle -b {}</code></pre>\n<p>{bundle_link}</p>\n",150+@@ -1067,8 +1084,11 @@ pub fn run_build(repo: &Path, out: &Path, opts: &BuildOptions) -> Result<BuildSu151+ // Mailbox forms (m4, issue #9): free textboxes, honeypot, license box.152+ crate::inbox::render_forms(out, &name, &nav, &branch, &short_sha, desc_opt)?;153+ 154+- // Snapshot last so the index can link sizes.155++ // Snapshot last so the index can link sizes. Dumb-HTTP repo.git (#54)156++ // rides alongside the bundle/tarball so `git clone <origin>/repo.git`157++ // works on any static server (Pages/nginx/serve), no smart HTTP.158+ let snap = gitx::snapshot(repo, &branch, out).map_err(|e| format!("hu13: {e}"))?;159++ gitx::export_dumb_repo(repo, &branch, out).map_err(|e| format!("hu13: {e}"))?;160+ let bundle_size = std::fs::metadata(&snap.bundle)161+ .map(|m| m.len())162+ .unwrap_or(0);163+diff --git a/src/gitx.rs b/src/gitx.rs164+index 219d25a..ac68f8f 100644165+--- a/src/gitx.rs166++++ b/src/gitx.rs167+@@ -767,6 +767,140 @@ pub fn snapshot(repo: &Path, branch: &str, out: &Path) -> Result<Snapshot, GitEr168+ Ok(Snapshot { bundle, tarball })169+ }170+ 171++fn run_plain_git(args: &[&OsStr]) -> Result<GitOutput, GitError> {172++ let mut cmd = Command::new("git");173++ cmd.args(args).stdout(Stdio::piped()).stderr(Stdio::piped());174++ let mut child = cmd.spawn().map_err(|e| GitError::Spawn(e.to_string()))?;175++ let stdout_handle = child.stdout.take();176++ let stderr_handle = child.stderr.take();177++ let (tx_out, rx_out) = mpsc::channel::<Vec<u8>>();178++ let (tx_err, rx_err) = mpsc::channel::<Vec<u8>>();179++ if let Some(mut out) = stdout_handle {180++ let tx = tx_out;181++ thread::spawn(move || {182++ let mut buf = Vec::new();183++ let _ = out.read_to_end(&mut buf);184++ let _ = tx.send(buf);185++ });186++ } else {187++ let _ = tx_out.send(Vec::new());188++ }189++ if let Some(mut err) = stderr_handle {190++ let tx = tx_err;191++ thread::spawn(move || {192++ let mut buf = Vec::new();193++ let _ = err.read_to_end(&mut buf);194++ let _ = tx.send(buf);195++ });196++ } else {197++ let _ = tx_err.send(Vec::new());198++ }199++ let start = Instant::now();200++ loop {201++ match child.try_wait() {202++ Err(e) => {203++ return Err(GitError::Failed {204++ cmd: format!(205++ "git {}",206++ args.iter()207++ .map(|a| a.to_string_lossy())208++ .collect::<Vec<_>>()209++ .join(" ")210++ ),211++ status: "wait-error".to_string(),212++ stderr: e.to_string(),213++ });214++ }215++ Ok(Some(status)) => {216++ let stdout = rx_out217++ .recv_timeout(Duration::from_secs(5))218++ .unwrap_or_default();219++ let stderr = rx_err220++ .recv_timeout(Duration::from_secs(5))221++ .unwrap_or_default();222++ return Ok(GitOutput {223++ status_ok: status.success(),224++ status_str: status.to_string(),225++ stdout,226++ stderr,227++ });228++ }229++ Ok(None) => {230++ if start.elapsed() >= GIT_TIMEOUT {231++ let _ = child.kill();232++ let _ = child.wait();233++ return Err(GitError::Timeout(234++ "git clone/update-server-info".to_string(),235++ ));236++ }237++ thread::sleep(Duration::from_millis(10));238++ }239++ }240++ }241++}242++243++/// Export a dumb-HTTP clone dir into `out/repo.git` (issue #54).244++///245++/// Runs `git clone --bare --single-branch` plus246++/// `git --git-dir=<dest> update-server-info`, so plain static servers247++/// (Pages/nginx/`hu13 serve`) all serve `git clone <origin>/repo.git`248++/// with zero dynamic smart HTTP. No GitHub, no config.249++///250++/// Failures are loud (build fails, never a silent missing dir), and an251++/// existing `out/repo.git` is removed first so stale objects never survive.252++pub fn export_dumb_repo(repo: &Path, branch: &str, out: &Path) -> Result<PathBuf, GitError> {253++ std::fs::create_dir_all(out)254++ .map_err(|e| GitError::Io(format!("create out dir {}: {e}", out.to_string_lossy())))?;255++ let dest = out.join("repo.git");256++ if dest.exists() {257++ std::fs::remove_dir_all(&dest)258++ .map_err(|e| GitError::Io(format!("clean {}: {e}", dest.to_string_lossy())))?;259++ }260++ let repo_abs = std::fs::canonicalize(repo).unwrap_or_else(|_| repo.to_path_buf());261++ let repo_str = repo_abs.to_string_lossy().into_owned();262++ let dest_str = dest.to_string_lossy().into_owned();263++ let os_repo = OsString::from(&repo_str);264++ let os_dest = OsString::from(&dest_str);265++ let os_branch = OsString::from(branch);266++ let a_clone: &OsStr = OsStr::new("clone");267++ let a_bare: &OsStr = OsStr::new("--bare");268++ let a_single: &OsStr = OsStr::new("--single-branch");269++ let a_branch: &OsStr = OsStr::new("--branch");270++ let a_sep: &OsStr = OsStr::new("--");271++ let args: Vec<&OsStr> = vec![272++ a_clone,273++ a_bare,274++ a_single,275++ a_branch,276++ os_branch.as_os_str(),277++ a_sep,278++ OsStr::new(os_repo.as_os_str()),279++ os_dest.as_os_str(),280++ ];281++ let out1 = run_plain_git(&args)?;282++ if !out1.status_ok {283++ let stderr = String::from_utf8_lossy(&out1.stderr).trim().to_string();284++ return Err(GitError::Failed {285++ cmd: format!("git clone --bare --single-branch --branch {branch} <repo> repo.git"),286++ status: out1.status_str,287++ stderr,288++ });289++ }290++ let git_dir_flag = OsString::from(format!("--git-dir={dest_str}"));291++ let a_usi: &OsStr = OsStr::new("update-server-info");292++ let args2: Vec<&OsStr> = vec![git_dir_flag.as_os_str(), a_usi];293++ let out2 = run_plain_git(&args2)?;294++ if !out2.status_ok {295++ let stderr = String::from_utf8_lossy(&out2.stderr).trim().to_string();296++ return Err(GitError::Failed {297++ cmd: "git --git-dir=<dest> update-server-info".to_string(),298++ status: out2.status_str,299++ stderr,300++ });301++ }302++ Ok(dest)303++}304++305+ // ---------------------------------------------------------------------------306+ // tests (std-only fixture repos)307+ // ---------------------------------------------------------------------------308+diff --git a/src/main.rs b/src/main.rs309+index cffc87e..148c678 100644310+--- a/src/main.rs311++++ b/src/main.rs312+@@ -51,7 +51,7 @@ OPTIONS:313+ --branch <NAME> Branch to pin (else HU13_BRANCH, else try main/master)314+ --clone-url <URL> Clone URL to advertise (else git origin remote, else none)315+ --public-origin <URL> Public base URL of this server (else HU13_PUBLIC_ORIGIN, else unset;316+- when set, clone block advertises `<origin>/repo.bundle`)317++ when set, clone block advertises `<origin>/repo.git`)318+ --repo-name <S> Repo display name (else HU13_REPO_NAME, else repo dir name;319+ --title is a deprecated alias; empty falls back, never blank)320+ --description <S> Site description (else HU13_DESCRIPTION, else hidden;321+diff --git a/src/serve.rs b/src/serve.rs322+index d6429f5..a119e85 100644323+--- a/src/serve.rs324++++ b/src/serve.rs325+@@ -394,6 +394,16 @@ fn content_type_for(name: &str) -> &'static str {326+ "application/atom+xml; charset=utf-8"327+ } else if lower.ends_with(".md") || lower.ends_with(".txt") {328+ "text/plain; charset=utf-8"329++ } else if lower.ends_with("/head")330++ || lower.ends_with("/info/refs")331++ || lower.ends_with("/info/packs")332++ || lower.ends_with("/info/alternates")333++ || lower.ends_with("packed-refs")334++ {335++ // Dumb-HTTP git files (#54): plain text so any static server336++ // (Pages/nginx/serve) serves `repo.git` identically. Git ignores337++ // mime for dumb reads, but explicit beats octet-stream guessing.338++ "text/plain; charset=utf-8"339+ } else if lower.ends_with(".gz") {340+ "application/gzip"341+ } else {342+diff --git a/tests/clone_origin.rs b/tests/clone_origin.rs343+index d5881c7..0d514a3 100644344+--- a/tests/clone_origin.rs345++++ b/tests/clone_origin.rs346+@@ -1,7 +1,8 @@347+-//! Clone-from-server (m6, f0rge issue #32):348++//! Clone-from-server (m6, f0rge issue #32; dumb-clone #54):349+ //! `--public-origin` / `HU13_PUBLIC_ORIGIN` (flag > env > unset),350+ //! clone-block both-mode asserts, serve `/repo.bundle` byte-identical,351+-//! live `git clone http://host:port/repo.bundle`, entrypoint passthrough.352++//! live `git clone http://host:port/repo.bundle` (smart, serve-only) +353++//! `git clone <origin>/repo.git` (dumb, any static server), entrypoint passthrough.354+ 355+ use std::io::{BufRead, BufReader, Read, Write};356+ use std::net::TcpStream;357+@@ -113,15 +114,23 @@ fn public_origin_primary_is_absolute_bundle_with_snapshot_note() {358+ let out = build_with(&repo, &["--public-origin", origin]);359+ let index = std::fs::read_to_string(out.join("index.html")).expect("index");360+ assert!(361+- index.contains(&format!("git clone {origin}/repo.bundle")),362+- "primary absolute bundle cmd"363++ index.contains(&format!("git clone {origin}/repo.git")),364++ "primary dumb clone cmd"365+ );366+ assert!(index.contains("exact snapshot of"), "snapshot note present");367+ assert!(index.contains("main"), "branch in snapshot note");368+ assert!(index.contains("/repo.tar.gz"), "secondary tarball link");369+ assert!(370+- !index.contains("git clone repo.bundle -b"),371+- "local bundle cmd replaced by absolute one"372++ index.contains(&format!("curl -O {origin}/repo.bundle")),373++ "bundle dumb download secondary"374++ );375++ assert!(376++ out.join("repo.git").join("HEAD").exists(),377++ "repo.git emitted"378++ );379++ assert!(380++ out.join("repo.git").join("info/refs").exists(),381++ "update-server-info ran"382+ );383+ set_env("HU13_PUBLIC_ORIGIN", None);384+ }385+@@ -136,14 +145,14 @@ fn public_origin_with_clone_url_shows_mirror_source() {386+ let out = build_with(&repo, &["--public-origin", origin, "--clone-url", mirror]);387+ let index = std::fs::read_to_string(out.join("index.html")).expect("index");388+ assert!(389+- index.contains(&format!("git clone {origin}/repo.bundle")),390+- "public origin still primary"391++ index.contains(&format!("git clone {origin}/repo.git")),392++ "public origin still primary (dumb)"393+ );394+ assert!(index.contains("mirror source"), "mirror source label");395+ assert!(index.contains(mirror), "origin remote shown");396+- // Primary (absolute bundle) must come before the mirror source line.397++ // Primary (dumb) must come before the mirror source line.398+ let primary = index399+- .find(&format!("git clone {origin}/repo.bundle"))400++ .find(&format!("git clone {origin}/repo.git"))401+ .expect("primary pos");402+ let mirror_pos = index.find("mirror source").expect("mirror pos");403+ assert!(primary < mirror_pos, "primary before mirror source");404+@@ -159,15 +168,15 @@ fn public_origin_flag_beats_env_and_trailing_slash_stripped() {405+ let out = build_with(&repo, &[]);406+ let index = std::fs::read_to_string(out.join("index.html")).expect("index");407+ assert!(408+- index.contains("git clone http://env.example:39313/repo.bundle"),409++ index.contains("git clone http://env.example:39313/repo.git"),410+ "env origin used, trailing slash stripped (no //)"411+ );412+- assert!(!index.contains("//repo.bundle"), "no doubled slash");413++ assert!(!index.contains("//repo.git"), "no doubled slash");414+ // Flag beats env.415+ let out = build_with(&repo, &["--public-origin", "http://flag.example:39313"]);416+ let index = std::fs::read_to_string(out.join("index.html")).expect("index");417+ assert!(418+- index.contains("git clone http://flag.example:39313/repo.bundle"),419++ index.contains("git clone http://flag.example:39313/repo.git"),420+ "flag wins over env"421+ );422+ assert!(!index.contains("env.example"), "env suppressed by flag");423+@@ -326,3 +335,56 @@ fn git_clone_over_http_bundle_works() {424+ assert!(dest.join("hello.txt").exists(), "cloned file present");425+ set_env("HU13_PUBLIC_ORIGIN", None);426+ }427++428++#[test]429++fn dumb_repo_git_clones_file_and_http() {430++ // #54: dist/repo.git is a bare dumb-HTTP dir — `git clone <path>` and431++ // `git clone http://host/repo.git` both work, no smart HTTP, no GitHub.432++ let _guard = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());433++ set_env("HU13_PUBLIC_ORIGIN", None);434++ let repo = fixture_repo();435++ let out = build_with(&repo, &[]);436++ let git_dir = out.join("repo.git");437++ assert!(git_dir.join("HEAD").exists(), "HEAD emitted");438++ assert!(git_dir.join("info/refs").exists(), "info/refs emitted");439++ assert!(440++ git_dir.join("objects/info/packs").exists(),441++ "objects/info/packs emitted"442++ );443++ // File-path clone (works on file:// + any static host).444++ let dest_parent = fresh("dumb-file");445++ let dest = dest_parent.join("cloned");446++ let st = Command::new("git")447++ .arg("clone")448++ .arg("-b")449++ .arg("main")450++ .arg(&git_dir)451++ .arg(&dest)452++ .status()453++ .expect("spawn git clone");454++ assert!(st.success(), "file clone of repo.git works");455++ assert!(dest.join("README.md").exists(), "cloned README present");456++ // HTTP clone via hu13 serve (same bytes Pages/nginx would serve).457++ let inbox = fresh("inbox-dumb");458++ let srv = start_server(&out, &inbox);459++ let raw = get(&srv.addr, "/repo.git/info/refs");460++ let (head, body) = split_response(&raw);461++ let head = String::from_utf8_lossy(head).into_owned();462++ assert!(head.contains("200"), "GET info/refs -> 200, got: {head}");463++ assert!(!body.is_empty(), "info/refs non-empty");464++ let url = format!("http://{}/repo.git", srv.addr);465++ let dest_parent = fresh("dumb-http");466++ let dest = dest_parent.join("cloned");467++ let st = Command::new("git")468++ .arg("clone")469++ .arg("-b")470++ .arg("main")471++ .arg(&url)472++ .arg(&dest)473++ .status()474++ .expect("spawn git clone");475++ assert!(st.success(), "git clone {url} works");476++ assert!(dest.join("README.md").exists(), "http cloned README");477++ assert!(dest.join("hello.txt").exists(), "http cloned file");478++ set_env("HU13_PUBLIC_ORIGIN", None);479++}480+-- 481+2.56.0482+