feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-tests/fixtures/command_fixture.rs

@@ -0,0 +1,101 @@
+//! Ordinary argv/stdin/stdout fixture: deliberately has no Dever protocol.
+use std::io::{Read, Write};
+use std::path::Path;
+use std::time::Duration;
+
+fn main() {
+    match run() {
+        Ok(code) => std::process::exit(code),
+        Err(error) => {
+            eprintln!("{error}");
+            if matches!(
+                std::env::args().nth(1).as_deref(),
+                Some("tree" | "wait" | "heartbeat")
+            ) && let Some(directory) = std::env::args().nth(2)
+            {
+                let _ = std::fs::write(
+                    Path::new(&directory).join("fixture-error"),
+                    error.to_string(),
+                );
+            }
+            std::process::exit(91);
+        }
+    }
+}
+
+fn run() -> Result<i32, Box<dyn std::error::Error>> {
+    let mut arguments = std::env::args().skip(1);
+    match arguments.next().as_deref() {
+        Some("echo") => {
+            for argument in arguments {
+                std::io::stdout().write_all(argument.as_bytes())?;
+                std::io::stdout().write_all(&[0])?;
+            }
+        }
+        Some("stdin") => {
+            std::io::copy(&mut std::io::stdin(), &mut std::io::stdout())?;
+            std::io::stderr().write_all(&[0, 255, 128, 10])?;
+        }
+        Some("exit") => return Ok(arguments.next().ok_or("missing exit code")?.parse()?),
+        Some("fds") => {
+            let descriptors = std::fs::read_dir("/proc/self/fd")?
+                .map(|entry| entry.map(|entry| entry.path()))
+                .collect::<Result<Vec<_>, _>>()?;
+            for descriptor in descriptors {
+                let Some(number) = descriptor
+                    .file_name()
+                    .and_then(|name| name.to_str())
+                    .and_then(|name| name.parse::<u32>().ok())
+                else {
+                    continue;
+                };
+                if number > 2 && std::fs::read_link(&descriptor).is_ok() {
+                    writeln!(std::io::stdout(), "{number}")?;
+                }
+            }
+        }
+        Some("duplex") => {
+            let count: usize = arguments.next().ok_or("missing output length")?.parse()?;
+            let stdout = std::thread::spawn(move || std::io::stdout().write_all(&vec![254; count]));
+            let stderr = std::thread::spawn(move || std::io::stderr().write_all(&vec![253; count]));
+            let mut input = Vec::new();
+            std::io::stdin().read_to_end(&mut input)?;
+            stdout.join().map_err(|_| "stdout thread panicked")??;
+            stderr.join().map_err(|_| "stderr thread panicked")??;
+        }
+        Some("wait") | Some("tree") => {
+            let directory = arguments.next().ok_or("missing marker directory")?;
+            let directory = Path::new(&directory);
+            let mut starts = std::fs::OpenOptions::new()
+                .create(true)
+                .append(true)
+                .open(directory.join("starts"))?;
+            starts.write_all(b"started\n")?;
+            // Every lifecycle case gets a real descendant. PID namespace exit
+            // must stop its heartbeat before the runtime returns cancellation.
+            let mut child = std::process::Command::new(std::env::current_exe()?)
+                .arg("heartbeat")
+                .arg(directory)
+                .spawn()?;
+            std::fs::write(directory.join("ready"), b"ready")?;
+            let status = child.wait()?;
+            return Ok(status.code().unwrap_or(92));
+        }
+        Some("heartbeat") => {
+            let directory = arguments.next().ok_or("missing marker directory")?;
+            let lifetime = std::fs::OpenOptions::new()
+                .create(true)
+                .truncate(false)
+                .write(true)
+                .open(Path::new(&directory).join("lifetime.lock"))?;
+            lifetime.lock()?;
+            let marker = Path::new(&directory).join("heartbeat");
+            for count in 0..3000 {
+                std::fs::write(&marker, count.to_string())?;
+                std::thread::sleep(Duration::from_millis(10));
+            }
+        }
+        _ => return Err("unknown ordinary command mode".into()),
+    }
+    Ok(0)
+}