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).
2026-07-17 05:31:01 -04:00
commit d6c20fc13f
2612 changed files with 1353757 additions and 0 deletions
@@ -0,0 +1,212 @@
+//! `x.ai/share_session` extension handler.
+//!
+//! Loads a local session, exports it, and asks the backend for a public
+//! share URL.
+
+use agent_client_protocol as acp;
+
+use super::{ExtResult, parse_params, to_raw_response};
+use crate::agent::MvpAgent;
+use crate::remote::client::BackendClient;
+use crate::session::export::ExportedSession;
+use crate::session::info::Info as SessionInfo;
+use crate::session::persistence::list_summaries;
+use crate::session::share::{ShareSessionRequest, ShareSessionResponse};
+
+#[tracing::instrument(skip_all, fields(method = %args.method))]
+pub async fn handle(agent: &MvpAgent, args: &acp::ExtRequest) -> ExtResult {
+    match args.method.as_ref() {
+        "x.ai/share_session" => {
+            tracing::info!("handling share session request");
+            handle_share_session(agent, args).await
+        }
+        _ => Err(acp::Error::method_not_found()),
+    }
+}
+
+async fn handle_share_session(agent: &MvpAgent, args: &acp::ExtRequest) -> ExtResult {
+    let request: ShareSessionRequest = parse_params(args)?;
+
+    // Get auth - required for sharing.
+    let auth = require_xai_auth_for_share(&agent.auth_manager)?;
+
+    // Remote settings / feature-flag gate: sharing_enabled defaults to false
+    // and is only enabled for eligible accounts.
+    let sharing_enabled = agent
+        .cfg
+        .borrow()
+        .remote_settings
+        .as_ref()
+        .and_then(|rs| rs.sharing_enabled)
+        .unwrap_or(false);
+    if !sharing_enabled {
+        return Err(
+            acp::Error::invalid_params().data("Session sharing is not available for your account.")
+        );
+    }
+
+    // Only block for ZDR teams (hard data-retention policy), not for
+    // coding-data-retention opt-out — sharing is user-initiated.
+    if auth.is_zdr_team() {
+        return Err(acp::Error::invalid_params()
+            .data("Session sharing is disabled for your team's data retention policy"));
+    }
+
+    // Find session info by searching through summaries
+    let summaries = list_summaries(None).await.map_err(|e| {
+        acp::Error::internal_error().data(format!("Failed to list sessions: {}", e))
+    })?;
+
+    let summary = summaries
+        .iter()
+        .find(|s| s.info.id.0.as_ref() == request.session_id.as_str())
+        .ok_or_else(|| acp::Error::resource_not_found(Some("Session not found".into())))?;
+
+    let info = SessionInfo {
+        id: acp::SessionId::new(request.session_id.clone()),
+        cwd: summary.info.cwd.clone(),
+    };
+
+    // Load and export session
+    let exported = ExportedSession::from_local_session(&info)
+        .await
+        .map_err(|e| acp::Error::internal_error().data(format!("Failed to load session: {}", e)))?;
+
+    // Check for empty session
+    if exported.messages.is_empty() {
+        return Err(acp::Error::invalid_params().data("No messages to share yet"));
+    }
+
+    // Upload to backend and get share URL.
+    let client = BackendClient::new().with_auth_manager(agent.auth_manager.clone());
+    let agent_id = crate::util::agent_id::agent_id();
+    let share_url = client
+        .share_session(&exported, &agent_id)
+        .await
+        .map_err(|e| {
+            tracing::error!(error = %e, "Failed to share session with backend");
+            acp::Error::internal_error().data(format!("Failed to share session: {}", e))
+        })?;
+
+    let response = ShareSessionResponse { share_url };
+    to_raw_response(&response)
+}
+
+fn require_xai_auth_for_share(
+    auth_manager: &crate::auth::AuthManager,
+) -> Result<crate::auth::GrokAuth, acp::Error> {
+    super::auth_gate::require_xai_auth(
+        auth_manager,
+        "Authentication required to share session",
+        "Share session is disabled. Run `grok login` to authenticate.",
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::auth::GrokComConfig;
+    use crate::auth::{AuthMode, GrokAuth};
+    use chrono::{Duration, Utc};
+    use std::sync::Arc;
+    use tempfile::tempdir;
+
+    fn make_auth_manager_with_token_expiring_in(
+        ttl: Duration,
+    ) -> (Arc<crate::auth::AuthManager>, tempfile::TempDir) {
+        let dir = tempdir().expect("tempdir for share auth test");
+        let mgr = Arc::new(crate::auth::AuthManager::new(
+            dir.path(),
+            GrokComConfig::default(),
+        ));
+
+        let expires_at = Utc::now() + ttl;
+
+        // We must explicitly set oidc_issuer to a first-party xAI issuer.
+        // Only OIDC tokens against https://auth.x.ai (or the local-dev equivalent)
+        // return true from is_xai_auth(). This is required for the share tests to
+        // exercise the happy path through require_xai_auth_for_share.
+        let auth = GrokAuth {
+            auth_mode: AuthMode::Oidc,
+            oidc_issuer: Some("https://auth.x.ai".to_string()),
+            key: "test-key".into(),
+            expires_at: Some(expires_at),
+            create_time: Utc::now() - Duration::hours(1),
+            ..Default::default()
+        };
+        mgr.hot_swap(auth);
+        (mgr, dir)
+    }
+
+    #[test]
+    fn share_works_outside_the_5m_early_invalidation_window() {
+        let (mgr, _dir) = make_auth_manager_with_token_expiring_in(Duration::minutes(10));
+        assert!(mgr.current().is_some());
+        assert!(require_xai_auth_for_share(&mgr).is_ok());
+    }
+
+    #[test]
+    fn share_succeeds_inside_the_5m_early_invalidation_window() {
+        let (mgr, _dir) = make_auth_manager_with_token_expiring_in(Duration::seconds(1));
+        // This is exactly the state that triggered the user bug:
+        assert!(
+            mgr.current().is_none(),
+            "current() drops the token inside the buffer"
+        );
+        assert!(mgr.expired_auth().is_some());
+
+        // Now that we use current_or_expired(), this passes.
+        let res = require_xai_auth_for_share(&mgr);
+        assert!(
+            res.is_ok(),
+            "require_xai_auth_for_share must succeed for a still-valid buffered xAI token"
+        );
+    }
+
+    #[test]
+    fn share_fails_with_no_auth_at_all() {
+        let dir = tempdir().expect("tempdir");
+        let mgr = Arc::new(crate::auth::AuthManager::new(
+            dir.path(),
+            GrokComConfig::default(),
+        ));
+        assert!(require_xai_auth_for_share(&mgr).is_err());
+    }
+
+    #[test]
+    fn share_rejects_non_xai_auth_with_actionable_grok_login_message() {
+        let dir = tempdir().expect("tempdir");
+        let mgr = Arc::new(crate::auth::AuthManager::new(
+            dir.path(),
+            GrokComConfig::default(),
+        ));
+
+        // API key is the simplest non-xAI credential (External and enterprise OIDC
+        // are also rejected the same way).
+        let non_xai = GrokAuth {
+            auth_mode: AuthMode::ApiKey,
+            key: "xai-test-key".into(),
+            create_time: Utc::now(),
+            ..Default::default()
+        };
+        mgr.hot_swap(non_xai);
+
+        let err = require_xai_auth_for_share(&mgr)
+            .expect_err("non-xAI accounts (API key, External, enterprise IdP) must be rejected");
+
+        // This is the key assertion the review asked for: we must test the *exact*
+        // actionable data string for the non-xAI path (distinct from the generic
+        // "Authentication required to share session" path).
+        let serialized =
+            serde_json::to_value(&err).expect("acp::Error serializes to JSON-RPC shape");
+        let data = serialized
+            .get("data")
+            .and_then(|v| v.as_str())
+            .expect("auth_required error carries a data string");
+
+        assert_eq!(
+            data,
+            "Share session is disabled. Run `grok login` to authenticate."
+        );
+    }
+}