ZacharyZhang-NY/Kigi-CLI
1
0
Fork 0
Code Issues Pull Requests Actions 13 Packages Projects Releases Wiki Activity

M0: compilable skeleton — Kigi 0.1.0 fork surgery

Browse Source 
Hard fork of xai-org/grok-build (Apache-2.0) re-targeted as Kigi, an
unofficial Kimi Code CLI community build.

Rename & identity
- 72 xai-*/xai-grok-* crates -> kigi-* (explicit: xai-grok-pager-bin ->
  kigi-bin [binary `kigi`], xai-grok-pager -> kigi-tui; rest mechanical);
  ptyctl, ptyctl-cli, third_party/ unchanged; proto package
  xai.grok.tools.v1 -> kigi.tools.v1
- Config home ~/.kigi (KIGI_SHARE_DIR override), env prefix GROK_* ->
  KIGI_*, `kigi --version` carries the unofficial-community-build notice
- clap identity, help text, startup banner, prompt templates rebranded
  (templates re-encrypted)

Deletions (PRD removal list #5/#6/#7/#9/#10)
- voice input (xai-grok-voice) and all TUI wiring
- telemetry: Mixpanel client, external OTel stream, Sentry, OTLP layers,
  trace/GCS/S3 upload queues (kigi-file-utils halved), workspace upload
  module & dc_log, heap-profile uploader, auth-diagnostics uploader,
  session-analytics halves of feedback; local zero-egress observability
  preserved in new kigi-log crate (unified log, --debug firehose,
  subsystem file logs, opt-in instrumentation)
- announcements (crate, remote-settings fields, TUI surfaces)
- plugin marketplace (crate, sources/browse/CTA/extensions-modal tab);
  direct plugin install/uninstall/update via kigi-agent git_install kept
- relay/gateway/assets endpoints and features (agent relay, headless
  relay transport, gateway bridge, LeaderEnvUrls); leader IPC socket now
  ~/.kigi/leader.sock + KIGI_LEADER_SOCKET, no ws-url derivation
- functional types rehomed instead of deleted: PermissionMode ->
  kigi-config-types, McpInitStrategy -> kigi-mcp, PrCreationSource ->
  session signals, TerminalDiagnostics -> kigi-pager-render, agent_id ->
  shell util

Endpoints
- kigi-env rewritten: single production KigiEndpoints {coding_api_base_url
  https://api.kimi.com/coding/v1 (KIGI_CODE_BASE_URL), oauth_host
  https://auth.kimi.com (KIGI_OAUTH_HOST), update_base_url (GitHub
  Releases API), upgrade_page_url}; GrokBuildEnvironment enum deleted

Toolchain & workspace hygiene
- Rust 1.97.0 pinned; edition 2024; full cargo update; git2 hoisted to
  workspace at 0.21 (Option->Result API migration), quick-xml 0.41
- Root Cargo.toml hand-maintained (PRD §8.1): version 0.1.0 inherited by
  all members, members sorted, unused deps pruned
- cargo-deny advisories gate (deny.toml with documented transitive
  exceptions); CI workflow (check/clippy/fmt/deny/test, macOS+Linux)
- cross-crate test seams re-gated behind `test-support` cargo feature;
  insta snapshot baselines renamed to the kigi_tui prefix
- clippy --workspace --all-targets: zero warnings; fmt clean

Fixes surfaced by the port
- updater probe/installer divergence (bin/kigi vs bin/grok symlink set)
- idle model-metadata refresh dead under KIGI_CODE_BASE_URL override
  (new is_effective_coding_endpoint_url, loopback+override aware)
- macOS symlinked-TMPDIR fixture canonicalization (foreign_sessions,
  fast-worktree); RSS measurement tests serialized via serial_test

Docs & legal (Apache §4)
- NOTICE added (upstream attribution + change statement); THIRD-PARTY
  notices sustained; kigi-tools ported-code notices extended; README,
  CONTRIBUTING, SECURITY, AGENTS.md rewritten

Out of scope for M0 (tracked): Kimi auth/inference (M1), search/fetch,
command parity, config import (M2), Computer Hub excision & final
brand-token sweep (M2), distribution & self-update rewrite (M3).
This commit is contained in:
ZacharyZhang-NY
2026-07-17 05:31:01 -04:00
commit d6c20fc13f
2612 changed files with 1353757 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/codegen/kigi-update/tests/common/artifact_server.rs
+267
View File
@@ -0,0 +1,267 @@
//! Controllable raw HTTP/1.1 artifact server shared by the blitz
//! download/install tests and the concurrent-update convergence tests.
//!
//! Serves a real executable artifact and can truncate the body, close the
//! connection early, serve a right-length-but-garbage body, or hang
//! mid-transfer — for both the parallel byte-range path and the
//! single-connection path. It also counts body-serving GETs (HEAD probes are
//! excluded) so tests can assert how many downloads actually happened, and
//! supports a "slow" mode that widens the race window so concurrent
//! installers genuinely overlap in flight.
use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
/// How the server corrupts (or doesn't) the next download.
#[derive(Clone, Copy, Debug)]
pub enum Mode {
/// Serve the real artifact correctly.
Full,
/// Serve a right-length body that exits non-zero (fails the smoke-test).
Garbage,
/// Advertise the full length but send only `k` bytes then close the socket
/// (silent truncation: premature EOF / short range chunk).
Truncate(usize),
/// Send `k` bytes then hang, so a client-side timeout cancels mid-transfer.
Hang(usize),
}
struct ServerState {
body: Arc<Vec<u8>>,
mode: Mode,
}
pub struct ArtifactServer {
addr: std::net::SocketAddr,
state: Arc<Mutex<ServerState>>,
shutdown: Arc<AtomicBool>,
gets: Arc<AtomicUsize>,
slow: Arc<AtomicBool>,
}
impl ArtifactServer {
pub fn start(body: Vec<u8>) -> Self {
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
listener.set_nonblocking(true).unwrap();
let addr = listener.local_addr().unwrap();
let state = Arc::new(Mutex::new(ServerState {
body: Arc::new(body),
mode: Mode::Full,
}));
let shutdown = Arc::new(AtomicBool::new(false));
let gets = Arc::new(AtomicUsize::new(0));
let slow = Arc::new(AtomicBool::new(false));
let st = state.clone();
let sd = shutdown.clone();
let gc = gets.clone();
let sl = slow.clone();
std::thread::spawn(move || {
while !sd.load(Ordering::Relaxed) {
match listener.accept() {
Ok((stream, _)) => {
let st = st.clone();
let sd = sd.clone();
let gc = gc.clone();
let sl = sl.clone();
std::thread::spawn(move || handle_connection(stream, st, sd, gc, sl));
}
Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
std::thread::sleep(Duration::from_millis(2));
}
Err(_) => break,
}
}
});
Self {
addr,
state,
shutdown,
gets,
slow,
}
}
pub fn uri(&self) -> String {
format!("http://{}", self.addr)
}
pub fn set_mode(&self, mode: Mode) {
self.state.lock().unwrap().mode = mode;
}
/// Number of body-serving GET requests handled so far (HEAD probes from
/// the parallel-download path are excluded). Tests use this to assert
/// how many downloads actually happened — e.g. that a sequential updater
/// converged onto an already-installed binary without re-downloading.
/// One download may span multiple GETs when the parallel byte-range path
/// splits it, so tests asserting exact counts use a small artifact
/// (single-connection path, 1 GET per download).
pub fn request_count(&self) -> usize {
self.gets.load(Ordering::Relaxed)
}
/// When enabled, hold each Full/Garbage response open ~500ms before
/// sending the body. This keeps an installer in flight long enough for
/// concurrent installers to genuinely overlap even on a heavily loaded
/// CI host — a too-short hold would let race tests run the installers
/// back-to-back and never exercise the concurrent window.
pub fn set_slow(&self, slow: bool) {
self.slow.store(slow, Ordering::Relaxed);
}
}
impl Drop for ArtifactServer {
fn drop(&mut self) {
self.shutdown.store(true, Ordering::Relaxed);
}
}
/// Parse `Range: bytes=a-b` from a raw request header block (case-insensitive).
fn parse_range(request: &str) -> Option<(usize, usize)> {
for line in request.lines() {
let lower = line.to_ascii_lowercase();
if let Some(rest) = lower.strip_prefix("range:") {
let spec = rest.trim().strip_prefix("bytes=")?;
let (a, b) = spec.split_once('-')?;
return Some((a.trim().parse().ok()?, b.trim().parse().ok()?));
}
}
None
}
fn handle_connection(
mut stream: TcpStream,
state: Arc<Mutex<ServerState>>,
shutdown: Arc<AtomicBool>,
gets: Arc<AtomicUsize>,
slow: Arc<AtomicBool>,
) {
// A stream accepted from a non-blocking listener can inherit non-blocking
// mode; force blocking so large `write_all`s don't short-write on WouldBlock.
let _ = stream.set_nonblocking(false);
// Avoid Nagle/delayed-ACK stalls on the header-then-body writes.
let _ = stream.set_nodelay(true);
// Read the request header block (until CRLFCRLF). Bodies are never sent by
// the client, so headers are all we need.
let mut buf = Vec::new();
let mut tmp = [0u8; 1024];
stream.set_read_timeout(Some(Duration::from_secs(5))).ok();
loop {
match stream.read(&mut tmp) {
Ok(0) => break,
Ok(n) => {
buf.extend_from_slice(&tmp[..n]);
if buf.windows(4).any(|w| w == b"\r\n\r\n") {
break;
}
if buf.len() > 64 * 1024 {
break;
}
}
Err(_) => return,
}
}
let request = String::from_utf8_lossy(&buf).to_string();
let is_head = request.starts_with("HEAD");
// Count only body-serving GETs; the parallel path's HEAD probe is excluded.
if !is_head {
gets.fetch_add(1, Ordering::Relaxed);
}
let range = parse_range(&request);
let (body, mode) = {
let st = state.lock().unwrap();
(st.body.clone(), st.mode)
};
let total = body.len();
let body: &[u8] = &body;
// Determine the byte slice this request is for, plus the length we will
// claim in Content-Length.
let (slice_start, slice_end_excl) = match range {
Some((a, b)) => (a.min(total), (b + 1).min(total)),
None => (0, total),
};
let claimed_len = slice_end_excl - slice_start;
// For truncation/hang, `k` is a GLOBAL cutoff across the whole artifact:
// a slice that reaches past byte `k` is sent short, so the parallel path's
// later chunk (or the single-connection body) is the one truncated.
let send_end = match mode {
Mode::Truncate(k) | Mode::Hang(k) => slice_end_excl.min(k).max(slice_start),
_ => slice_end_excl,
};
// `payload` is what we actually transmit before any early close; for the
// truncated modes it may be shorter than the advertised `claimed_len`.
let payload: Vec<u8> = match mode {
Mode::Garbage => {
let mut bad = b"#!/bin/sh\nexit 1\n".to_vec();
bad.resize(claimed_len, b'\n');
bad
}
_ => body[slice_start..send_end].to_vec(),
};
// Status line + headers. For range requests we answer 206; HEAD is 200.
let mut head = String::new();
if range.is_some() && !is_head {
head.push_str("HTTP/1.1 206 Partial Content\r\n");
head.push_str(&format!(
"Content-Range: bytes {}-{}/{}\r\n",
slice_start,
slice_end_excl.saturating_sub(1),
total
));
} else {
head.push_str("HTTP/1.1 200 OK\r\n");
head.push_str("Accept-Ranges: bytes\r\n");
}
// Always advertise the (claimed) full length so a truncated transfer is a
// genuine premature EOF rather than a short-but-consistent body.
head.push_str(&format!("Content-Length: {}\r\n", claimed_len));
head.push_str("Connection: close\r\n\r\n");
if stream.write_all(head.as_bytes()).is_err() {
return;
}
if is_head {
let _ = stream.flush();
return;
}
match mode {
Mode::Full | Mode::Garbage => {
// Hold the connection open longer so concurrent installers
// genuinely overlap mid-download (see `set_slow`).
if slow.load(Ordering::Relaxed) {
std::thread::sleep(Duration::from_millis(500));
}
let _ = stream.write_all(&payload);
}
Mode::Truncate(_) => {
// Send the (possibly short) payload then drop the connection without
// meeting Content-Length — the client sees a premature EOF.
let _ = stream.write_all(&payload);
}
Mode::Hang(_) => {
let _ = stream.write_all(&payload);
let _ = stream.flush();
// Hold the connection open longer than any client-side cancel
// timeout so the client times out and cancels (a genuine mid-flight
// cancel rather than a server-side close).
for _ in 0..30 {
if shutdown.load(Ordering::Relaxed) {
break;
}
std::thread::sleep(Duration::from_millis(20));
}
}
}
let _ = stream.flush();
}
crates/codegen/kigi-update/tests/common/mod.rs
+353
View File
@@ -0,0 +1,353 @@
//! Shared helpers for integration tests.
//!
//! Each `tests/*.rs` integration test is its own binary, so each binary has
//! its own `OnceLock<KIGI_SHARE_DIR>`. The helpers below ensure the per-binary
//! initialization is identical: same env-var set, same isolation guarantees,
//! same reset between tests.
//!
//! Mirrors the KIGI_SHARE_DIR isolation pattern used in other integration tests.
//!
//! ## Usage
//!
//! ```ignore
//! mod common;
//! use common::{test_home, reset_home};
//!
//! #[tokio::test]
//! #[serial_test::serial]
//! async fn my_test() {
//! let _ = test_home(); // initializes KIGI_SHARE_DIR once per binary
//! reset_home(); // wipes state between tests
//! // ...
//! }
//! ```
#![allow(dead_code)] // each test binary uses a different subset
#[cfg(unix)]
pub mod artifact_server;
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::sync::OnceLock;
// ─────────────────────────────────────────────────────────────────────────────
// KIGI_SHARE_DIR isolation
// ─────────────────────────────────────────────────────────────────────────────
/// Returns a process-wide test `KIGI_SHARE_DIR`, initialized exactly once per test
/// binary. Once initialized, `kigi_config::kigi_home()` will resolve to
/// this directory for the lifetime of the process.
///
/// Also clears env vars that the auto-update code consults so a parent shell's
/// values can't pollute the baseline (e.g. running tests from `npm run` would
/// otherwise inherit `npm_config_user_agent` and `NPM_TOKEN`).
pub fn test_home() -> &'static PathBuf {
static HOME: OnceLock<PathBuf> = OnceLock::new();
HOME.get_or_init(|| {
let dir = tempfile::TempDir::new().unwrap();
let path = dir.keep();
// SAFETY: called once at OnceLock init, before any other thread touches
// these env vars. Tests using this helper must be `#[serial]`.
unsafe {
std::env::set_var("KIGI_SHARE_DIR", &path);
std::env::remove_var("KIGI_TEST_VERSION");
std::env::remove_var("NPM_TOKEN");
std::env::remove_var("KIGI_INSTALLER");
std::env::remove_var("KIGI_MANAGED_BY_NPM");
std::env::remove_var("KIGI_MANAGED_BY_INTERNAL");
}
path
})
}
/// Wipe state in `KIGI_SHARE_DIR` between tests so each test sees a clean home.
/// Removes the well-known files and subdirectories the update path writes,
/// and clears env vars that individual tests may set.
pub fn reset_home() {
let home = test_home();
let _ = std::fs::remove_file(home.join("config.toml"));
let _ = std::fs::remove_file(home.join("version.json"));
let _ = std::fs::remove_file(home.join("version.json.tmp"));
let _ = std::fs::remove_dir_all(home.join("bin"));
let _ = std::fs::remove_dir_all(home.join("downloads"));
// SAFETY: tests using this helper must be `#[serial]`.
unsafe {
std::env::remove_var("KIGI_TEST_VERSION");
std::env::remove_var("NPM_TOKEN");
std::env::remove_var("KIGI_INSTALLER");
}
}
/// Override the version reported by `get_installed_grok_version()` for the
/// duration of the test (until [`reset_home`] or process exit).
pub fn set_test_version(v: &str) {
// SAFETY: tests using this helper must be `#[serial]`.
unsafe { std::env::set_var("KIGI_TEST_VERSION", v) };
}
// ─────────────────────────────────────────────────────────────────────────────
// Install-test fixtures (shared by the blitz + convergence suites)
// ─────────────────────────────────────────────────────────────────────────────
/// Host `{os}-{arch}` string matching the versioned binary naming scheme
/// (`grok-{version}-{platform}`).
pub fn host_platform() -> String {
let os = if cfg!(target_os = "macos") {
"macos"
} else if cfg!(target_os = "linux") {
"linux"
} else {
panic!("unsupported test platform");
};
let arch = if cfg!(target_arch = "x86_64") {
"x86_64"
} else if cfg!(target_arch = "aarch64") {
"aarch64"
} else {
panic!("unsupported test arch");
};
format!("{os}-{arch}")
}
/// Minimal [`kigi_update::UpdateConfig`] for install tests.
pub fn make_update_config(channel: &str) -> kigi_update::UpdateConfig {
kigi_update::UpdateConfig {
proxy_base_url: "http://test.invalid/v1".to_string(),
auth_scope: "test".to_string(),
deployment_key: None,
alpha_test_key: None,
channel: channel.to_string(),
npm_registry: None,
}
}
/// True if shell-script artifacts can execute in this environment. False in
/// restricted sandboxes (e.g. hermetic remote execution) that lack /bin/sh.
#[cfg(unix)]
pub fn can_exec_shell_scripts() -> bool {
use std::os::unix::fs::PermissionsExt;
let dir = tempfile::tempdir().unwrap();
let p = dir.path().join("probe");
std::fs::write(&p, b"#!/bin/sh\nexit 0\n").unwrap();
std::fs::set_permissions(&p, std::fs::Permissions::from_mode(0o755)).unwrap();
std::process::Command::new(&p)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null())
.status()
.map(|s| s.success())
.unwrap_or(false)
}
/// A small real executable: exits 0 for `--version`, so the smoke-test passes.
pub fn small_good_artifact() -> Vec<u8> {
b"#!/bin/sh\nexit 0\n".to_vec()
}
/// Backdate every file in `KIGI_SHARE_DIR/downloads` by ~2 hours.
///
/// `cleanup_old_downloads` deliberately never deletes a freshly-written
/// binary or temp file (it may belong to a concurrent in-flight install), so
/// tests asserting the retention policy must age their fixtures to look like
/// real leftovers from previous releases.
pub fn backdate_downloads() {
let downloads = test_home().join("downloads");
let Ok(entries) = std::fs::read_dir(&downloads) else {
return;
};
let old = std::time::SystemTime::now() - std::time::Duration::from_secs(2 * 60 * 60);
for entry in entries.flatten() {
let p = entry.path();
if p.is_file()
&& let Ok(f) = std::fs::File::options().write(true).open(&p)
{
let _ = f.set_times(std::fs::FileTimes::new().set_modified(old));
}
}
}
// ─────────────────────────────────────────────────────────────────────────────
// PATH-override fake binary
// ─────────────────────────────────────────────────────────────────────────────
/// RAII guard that places a sh-script with name `name` at the head of `PATH`.
/// Restores `PATH` on drop.
///
/// All tests using this MUST be `#[serial]` because `PATH` is process-global.
pub struct FakeBinGuard {
pub tmp: tempfile::TempDir,
pub name: String,
prev_path: OsString,
}
impl FakeBinGuard {
/// Install a fake binary at `<tmp>/<name>` whose body is produced by
/// `script_body(<tmp>)`, and prepend `<tmp>` to `PATH`.
pub fn install<F>(name: &str, script_body: F) -> Self
where
F: FnOnce(&Path) -> String,
{
let tmp = tempfile::tempdir().unwrap();
let dir = tmp.path().to_path_buf();
let body = script_body(&dir);
let script_path = dir.join(name);
std::fs::write(&script_path, body).unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&script_path, std::fs::Permissions::from_mode(0o755)).unwrap();
}
let prev_path = std::env::var_os("PATH").unwrap_or_default();
let mut new_path = OsString::from(&dir);
new_path.push(":");
new_path.push(&prev_path);
// SAFETY: serial_test ensures no other thread races on PATH.
unsafe { std::env::set_var("PATH", &new_path) };
Self {
tmp,
name: name.to_string(),
prev_path,
}
}
/// Install a fake `npm` using the standard [`fake_npm_script`] template.
pub fn install_npm() -> Self {
Self::install("npm", fake_npm_script)
}
/// Install a fake `gh` using the standard [`fake_gh_script`] template.
pub fn install_gh() -> Self {
Self::install("gh", fake_gh_script)
}
/// The tempdir backing this guard (where canned stdout/stderr/exit files
/// can be written by tests, and where `<name>-args.log` is appended).
pub fn dir(&self) -> PathBuf {
self.tmp.path().to_path_buf()
}
/// Argv lines logged by the fake script — one line per invocation.
pub fn args_log(&self) -> Vec<String> {
std::fs::read_to_string(self.dir().join(format!("{}-args.log", self.name)))
.unwrap_or_default()
.lines()
.map(String::from)
.collect()
}
pub fn set_stdout(&self, content: &str) {
std::fs::write(self.dir().join(format!("{}-stdout", self.name)), content).unwrap();
}
pub fn set_stderr(&self, content: &str) {
std::fs::write(self.dir().join(format!("{}-stderr", self.name)), content).unwrap();
}
pub fn set_alpha_stdout(&self, content: &str) {
std::fs::write(
self.dir().join(format!("{}-alpha-stdout", self.name)),
content,
)
.unwrap();
}
pub fn set_stable_only_stdout(&self, content: &str) {
std::fs::write(
self.dir().join(format!("{}-stable-only-stdout", self.name)),
content,
)
.unwrap();
}
pub fn set_with_pre_stdout(&self, content: &str) {
std::fs::write(
self.dir().join(format!("{}-with-pre-stdout", self.name)),
content,
)
.unwrap();
}
pub fn set_exit_code(&self, code: i32) {
std::fs::write(
self.dir().join(format!("{}-exit", self.name)),
code.to_string(),
)
.unwrap();
}
}
impl Drop for FakeBinGuard {
fn drop(&mut self) {
// SAFETY: serial_test ensures no other thread races on PATH.
unsafe { std::env::set_var("PATH", &self.prev_path) };
}
}
/// Single-quote a path for safe substitution into a sh script.
fn single_quote_for_sh(p: &Path) -> String {
let s = p.to_string_lossy();
// Escape any embedded single quotes (paranoid — tempdir paths shouldn't
// contain them, but defensively quote).
let escaped = s.replace('\'', "'\\''");
format!("'{escaped}'")
}
/// sh script body for a fake `npm`. Logs argv to `<dir>/npm-args.log` and
/// dispatches stdout based on the first matching argv pattern:
///
/// - argv contains `@alpha` → cat `<dir>/npm-alpha-stdout`
/// - else → cat `<dir>/npm-stdout`
///
/// Always cats `<dir>/npm-stderr` to stderr (if exists). Exits with the integer
/// in `<dir>/npm-exit` (default 0).
pub fn fake_npm_script(dir: &Path) -> String {
let dq = single_quote_for_sh(dir);
format!(
r#"#!/bin/sh
echo "$@" >> {dq}/npm-args.log
if echo "$@" | grep -q '@alpha'; then
if [ -f {dq}/npm-alpha-stdout ]; then cat {dq}/npm-alpha-stdout; fi
elif [ -f {dq}/npm-stdout ]; then
cat {dq}/npm-stdout
fi
if [ -f {dq}/npm-stderr ]; then cat {dq}/npm-stderr >&2; fi
exit_code=0
if [ -f {dq}/npm-exit ]; then exit_code=$(cat {dq}/npm-exit); fi
exit "$exit_code"
"#
)
}
/// sh script body for a fake `gh`. Logs argv to `<dir>/gh-args.log` and
/// dispatches stdout based on `release list` argv:
///
/// - argv contains `release list --exclude-pre-releases` → `<dir>/gh-stable-only-stdout`
/// - argv contains `release list` (no exclude flag) → `<dir>/gh-with-pre-stdout`
/// - else → `<dir>/gh-stdout`
///
/// Exits with `<dir>/gh-exit` (default 0).
pub fn fake_gh_script(dir: &Path) -> String {
let dq = single_quote_for_sh(dir);
format!(
r#"#!/bin/sh
echo "$@" >> {dq}/gh-args.log
if echo "$@" | grep -q 'release list'; then
if echo "$@" | grep -q '\-\-exclude-pre-releases'; then
if [ -f {dq}/gh-stable-only-stdout ]; then cat {dq}/gh-stable-only-stdout; fi
else
if [ -f {dq}/gh-with-pre-stdout ]; then cat {dq}/gh-with-pre-stdout; fi
fi
elif [ -f {dq}/gh-stdout ]; then
cat {dq}/gh-stdout
fi
exit_code=0
if [ -f {dq}/gh-exit ]; then exit_code=$(cat {dq}/gh-exit); fi
exit "$exit_code"
"#
)
}