M2 audit: excise the Computer Hub stack — Kigi's last remote-cloud surface

Removed root-and-branch for the zero-egress guarantee (the hub was xAI's remote-workspace/cloud-sandbox service): - Crates deleted: kigi-computer-hub-core, kigi-computer-hub-sdk, kigi-computer-hub-mcp-adapter, kigi-workspace-client (hub-proxied workspace RPC client), and kigi-tracing (its sole network path was the OTLP gRPC exporter; zero consumers remained). kigi-tracing-macros (purely local) stays. - kigi-workspace: every hub surface deleted — hub server/channel/auth, HITL-over-hub permissions, donation/metrics pumps, file upload RPCs, hub tool-snapshot merge (resolve pipeline is MCP-only now), WorkspaceOps::Proxy. Local worktrees, sessions, leader IPC, MCP, and the ACP permission prompt path are untouched; LocalRegistry re-homed into kigi-tool-runtime on the existing ToolDyn types so in-process tool dispatch is unchanged. - kigi-shell: leader workspace-exposure control surface (incl. the wss://computer-hub... URL), [hub] config, ObservabilityBridge, hub WebSocket proxy, dead OTLP config knobs. ClientMode::Headless (never constructed) removed. - kigi-tui/bin: hidden `kigi workspace` command removed (`kigi worktree` stays). - Renames: --xai-api-base-url → --api-base-url / KIGI_API_BASE_URL / [endpoints] api_base_url (serde alias keeps old configs working; the flag feeds BYOK/custom-endpoint routing, not main inference); grok_version → kigi_version in inspect/models-cache/trace metadata (old caches self-heal via version-mismatch refetch). - Dependency tree: dropped fastrace*, opentelemetry-otlp/http/proto, tokio-tungstenite from the workspace; fixed the 4 real useless_format violations the fastrace lint allowance was masking and removed the allowance. - marketplaceAllowlist kept: it gates the LOCAL plugin-marketplace feature, not an xAI service. Known §9 leftover (deliberate, for the M3 sweep): the BYOK default base URL string. Gates: workspace check/clippy 0/0, fmt, deny ok; suites green (workspace 1042, shell 4918, tui 6634, tools 2608, tool-runtime 47, mcp 154).
2026-07-17 22:34:10 -04:00
parent 5919526e91
commit fa75eb139a
90 changed files with 452 additions and 9702 deletions
@@ -0,0 +1,117 @@
+//! In-process tool registry for local dispatch.
+//!
+//! [`LocalRegistry`] maps [`ToolId`]s to type-erased
+//! [`ToolDyn`](crate::tool::ToolDyn) handles.
+//! Toolset finalization registers every config-enabled tool here and
+//! dispatch resolves handles via [`LocalRegistry::find`], so a call
+//! executes in-process without any wire round-trip.
+
+use std::sync::Arc;
+
+use indexmap::IndexMap;
+use parking_lot::RwLock;
+
+use crate::context::ListToolsContext;
+use crate::tool::{ArcTool, Tool};
+use kigi_tool_protocol::ToolId;
+use kigi_tool_types::ToolDescription;
+
+/// In-process registry of tool handles.
+///
+/// Mutations are concurrency-safe (`RwLock` on the entry map), so
+/// callers MAY hot-add or hot-remove tools while dispatch is in use.
+///
+/// Entries use `RwLock<IndexMap>` to preserve insertion order so that
+/// [`list_tools`](Self::list_tools) returns descriptions in the same
+/// order tools were registered (matching the config-defined order).
+#[derive(Clone, Default)]
+pub struct LocalRegistry {
+    entries: Arc<RwLock<IndexMap<ToolId, ArcTool>>>,
+}
+
+impl std::fmt::Debug for LocalRegistry {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("LocalRegistry")
+            .field("entries", &self.entries.read().len())
+            .finish()
+    }
+}
+
+impl LocalRegistry {
+    /// Construct an empty registry.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Register a typed [`Tool`] implementation by value. Subsequent
+    /// registrations of the same id replace the previous handle and
+    /// return the displaced handle for inspection / drop ordering.
+    pub fn register<T>(&self, tool: T) -> Option<ArcTool>
+    where
+        T: Tool + 'static,
+    {
+        self.register_arc(Arc::new(tool))
+    }
+
+    /// Register a typed [`Tool`] implementation already wrapped in `Arc`.
+    pub fn register_arc<T>(&self, tool: Arc<T>) -> Option<ArcTool>
+    where
+        T: Tool + 'static,
+    {
+        let id = tool.id();
+        self.entries.write().insert(id, tool as ArcTool)
+    }
+
+    /// Register a type-erased [`ToolDyn`](crate::tool::ToolDyn) directly.
+    ///
+    /// Use this for inherently dynamic tools (e.g. MCP tools retrieved
+    /// from a registry as `Arc<dyn ToolDyn>`) where the concrete type
+    /// is not available. For native tools with a concrete type, prefer
+    /// [`register`](Self::register).
+    pub fn register_dyn(&self, tool: ArcTool) -> Option<ArcTool> {
+        let id = tool.id();
+        self.entries.write().insert(id, tool)
+    }
+
+    /// Resolve `tool_id` to its in-process handle, if registered.
+    /// Returns a clone of the handle so the caller can dispatch without
+    /// holding the lock across an await point.
+    pub fn find(&self, tool_id: &ToolId) -> Option<ArcTool> {
+        self.entries.read().get(tool_id).cloned()
+    }
+
+    /// Drop the handle bound to `tool_id`. Returns `true` iff a
+    /// matching entry was removed.
+    pub fn unregister(&self, tool_id: &ToolId) -> bool {
+        self.entries.write().shift_remove(tool_id).is_some()
+    }
+
+    /// Number of tools currently registered.
+    pub fn len(&self) -> usize {
+        self.entries.read().len()
+    }
+
+    /// `true` iff no tools are registered.
+    pub fn is_empty(&self) -> bool {
+        self.entries.read().is_empty()
+    }
+
+    /// `true` iff `tool_id` is currently registered.
+    pub fn contains(&self, tool_id: &ToolId) -> bool {
+        self.entries.read().contains_key(tool_id)
+    }
+
+    /// Descriptions of registered tools filtered by `should_list`.
+    ///
+    /// Returns descriptions in **insertion order** — the order tools
+    /// were registered — so the caller sees the same ordering as the
+    /// config-defined tool list.
+    pub fn list_tools(&self, ctx: &ListToolsContext) -> Vec<ToolDescription> {
+        self.entries
+            .read()
+            .values()
+            .filter(|handle| handle.should_list(ctx))
+            .map(|handle| handle.description(ctx))
+            .collect()
+    }
+}