M0: compilable skeleton — Kigi 0.1.0 fork surgery

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).

crates/codegen/ptyctl-cli/src/commands/client.rs

@@ -0,0 +1,196 @@
+//! Client commands — send/screen/status/cursor/resize/stop via HTTP.
+
+use anyhow::{Context, Result};
+use reqwest::Client;
+
+/// Send keystrokes to a session.
+pub async fn send(url: &str, keys: &str, enter: bool) -> Result<()> {
+    let mut keys = keys.to_string();
+    if enter {
+        keys.push_str("<CR>");
+    }
+
+    let client = Client::new();
+    let resp = client
+        .post(format!("{url}/control/send"))
+        .json(&serde_json::json!({"keys": keys}))
+        .send()
+        .await
+        .context("failed to send keys")?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("send failed: {body}");
+    }
+    Ok(())
+}
+
+/// Query screen content.
+pub async fn screen(
+    url: &str,
+    rows: Option<&str>,
+    cols: Option<&str>,
+    cursor: Option<char>,
+    format: &str,
+    full: bool,
+    line_numbers: bool,
+) -> Result<()> {
+    let client = Client::new();
+    let mut req = client.get(format!("{url}/query/screen"));
+
+    if let Some(r) = rows {
+        req = req.query(&[("rows", r)]);
+    }
+    if let Some(c) = cols {
+        req = req.query(&[("cols", c)]);
+    }
+    if let Some(ch) = cursor {
+        req = req.query(&[("cursor", &ch.to_string())]);
+    }
+    req = req.query(&[("format", format)]);
+    if full {
+        req = req.query(&[("full", "true")]);
+    }
+
+    let resp = req.send().await.context("failed to query screen")?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("screen query failed: {body}");
+    }
+
+    let body = resp.text().await?;
+
+    if format == "html" || format == "styled" {
+        println!("{body}");
+    } else {
+        // Parse as JSON and print lines.
+        let output: serde_json::Value = serde_json::from_str(&body)?;
+        if let Some(lines) = output.get("lines").and_then(|l| l.as_array()) {
+            for (i, line) in lines.iter().enumerate() {
+                let text = line.as_str().unwrap_or("");
+                if line_numbers {
+                    println!("{:4} {text}", i + 1);
+                } else {
+                    println!("{text}");
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Query cursor position.
+pub async fn cursor(url: &str) -> Result<()> {
+    let client = Client::new();
+    let resp = client
+        .get(format!("{url}/query/cursor"))
+        .send()
+        .await
+        .context("failed to query cursor")?;
+    let body = resp.text().await?;
+    println!("{body}");
+    Ok(())
+}
+
+/// Query session status.
+pub async fn status(url: &str) -> Result<()> {
+    let client = Client::new();
+    let resp = client
+        .get(format!("{url}/query/status"))
+        .send()
+        .await
+        .context("failed to query status")?;
+    let body = resp.text().await?;
+    println!("{body}");
+    Ok(())
+}
+
+/// Resize terminal.
+pub async fn resize(url: &str, size: &str) -> Result<()> {
+    let (cols, rows) = size
+        .split_once('x')
+        .ok_or_else(|| anyhow::anyhow!("invalid size format, expected COLSxROWS (e.g. 120x40)"))?;
+    let cols: u16 = cols.parse().context("invalid cols")?;
+    let rows: u16 = rows.parse().context("invalid rows")?;
+
+    let client = Client::new();
+    let resp = client
+        .post(format!("{url}/control/resize"))
+        .json(&serde_json::json!({"cols": cols, "rows": rows}))
+        .send()
+        .await
+        .context("failed to resize")?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("resize failed: {body}");
+    }
+    println!("Resized to {cols}x{rows}");
+    Ok(())
+}
+
+/// Long-poll the wait endpoint; prints the outcome JSON and returns whether it matched.
+pub async fn wait(
+    url: &str,
+    text: Option<&str>,
+    regex: Option<&str>,
+    gone: Option<&str>,
+    stable_ms: Option<u64>,
+    timeout_secs: u64,
+) -> Result<bool> {
+    // The HTTP timeout outlasts the wait so the server, not the client, decides the outcome.
+    let client = Client::builder()
+        .timeout(std::time::Duration::from_secs(
+            timeout_secs.saturating_add(5),
+        ))
+        .build()
+        .context("failed to build HTTP client")?;
+
+    let mut req = client
+        .get(format!("{url}/wait"))
+        .query(&[("timeout_ms", timeout_secs.saturating_mul(1000).to_string())]);
+    if let Some(t) = text {
+        req = req.query(&[("text", t)]);
+    }
+    if let Some(r) = regex {
+        req = req.query(&[("regex", r)]);
+    }
+    if let Some(g) = gone {
+        req = req.query(&[("gone", g)]);
+    }
+    if let Some(ms) = stable_ms {
+        req = req.query(&[("stable_ms", ms.to_string())]);
+    }
+
+    let resp = req.send().await.context("failed to call wait")?;
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("wait failed: {body}");
+    }
+
+    let outcome: serde_json::Value = resp.json().await.context("invalid wait response")?;
+    println!("{}", serde_json::to_string_pretty(&outcome)?);
+    Ok(outcome
+        .get("matched")
+        .and_then(|m| m.as_bool())
+        .unwrap_or(false))
+}
+
+/// Stop a session.
+pub async fn stop(url: &str) -> Result<()> {
+    let client = Client::new();
+    let resp = client
+        .post(format!("{url}/control/stop"))
+        .send()
+        .await
+        .context("failed to stop session")?;
+
+    if !resp.status().is_success() {
+        let body = resp.text().await.unwrap_or_default();
+        anyhow::bail!("stop failed: {body}");
+    }
+    println!("Session stopped");
+    Ok(())
+}

crates/codegen/ptyctl-cli/src/commands/mod.rs

@@ -0,0 +1,2 @@
+pub mod client;
+pub mod run;

crates/codegen/ptyctl-cli/src/commands/run.rs

@@ -0,0 +1,119 @@
+//! `ptyctl run` — spawn a PTY session and start the HTTP server.
+
+use std::collections::HashMap;
+use std::net::SocketAddr;
+use std::path::PathBuf;
+
+use anyhow::{Context, Result, bail};
+use tokio::net::TcpListener;
+
+use ptyctl::pty::PtyConfig;
+use ptyctl::server;
+use ptyctl::session::{PtySession, SessionConfig};
+
+use crate::registry;
+
+/// Run the `ptyctl run` command.
+#[allow(clippy::too_many_arguments)]
+pub async fn run(
+    command: Vec<String>,
+    width: u16,
+    height: u16,
+    cwd: Option<PathBuf>,
+    env_vars: Vec<String>,
+    port: u16,
+    name: Option<String>,
+    force: bool,
+    timeout: Option<u64>,
+    linger: bool,
+    quiet: bool,
+) -> Result<()> {
+    // Refuse to take over a name whose server is still reachable unless --force; stale entries are replaced.
+    if let Some(ref session_name) = name
+        && !force
+        && let Ok(existing) = registry::lookup_session(session_name)
+        && registry::server_alive(existing.port).await
+    {
+        bail!(
+            "session '{session_name}' is already running on port {} (use --force to replace it)",
+            existing.port
+        );
+    }
+
+    // Parse env vars.
+    let mut env = HashMap::new();
+    for var in &env_vars {
+        if let Some((k, v)) = var.split_once('=') {
+            env.insert(k.to_string(), v.to_string());
+        }
+    }
+
+    let cwd_str = cwd
+        .as_ref()
+        .map(|p| p.display().to_string())
+        .unwrap_or_else(|| ".".into());
+
+    let config = SessionConfig {
+        pty: PtyConfig {
+            command: command.clone(),
+            cols: width,
+            rows: height,
+            cwd,
+            env,
+        },
+        timeout,
+        linger,
+    };
+
+    // Start the session.
+    let session = PtySession::start(config).await?;
+    let pid = session.status_basic().1;
+
+    // Build the HTTP server.
+    let router = server::build_router(session);
+
+    // Bind to the requested port.
+    let addr = SocketAddr::from(([127, 0, 0, 1], port));
+    let listener = TcpListener::bind(addr)
+        .await
+        .context("failed to bind TCP listener")?;
+    let actual_addr = listener.local_addr()?;
+    let actual_port = actual_addr.port();
+
+    // Register named session.
+    if let Some(ref session_name) = name {
+        let info = registry::SessionInfo {
+            port: actual_port,
+            pid,
+            command: command.clone(),
+            cwd: cwd_str,
+            started_at: chrono::Utc::now().to_rfc3339(),
+        };
+        registry::register_session(session_name, &info)?;
+    }
+
+    if !quiet {
+        eprintln!("Command: {}", command.join(" "));
+        if let Some(p) = pid {
+            eprintln!("PID: {p}");
+        }
+        eprintln!("Server listening on port: {actual_port}");
+    } else {
+        println!("{actual_port}");
+    }
+
+    // Serve until shutdown.
+    let shutdown_result = axum::serve(listener, router)
+        .await
+        .context("HTTP server error");
+
+    // Clean up only a registration that still points at this server; a --force takeover may have replaced it.
+    if let Some(ref session_name) = name
+        && let Ok(info) = registry::lookup_session(session_name)
+        && info.port == actual_port
+    {
+        let _ = registry::unregister_session(session_name);
+    }
+
+    shutdown_result
+}