mirror of
https://github.com/outbackdingo/optimclaw.git
synced 2026-08-27 16:10:09 +00:00
Compare commits
1
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 [email protected]andClaude Opus 4.6
|
fd5369a332 |
+1
-18
@@ -4,7 +4,7 @@ DATABASE_POOL_SIZE=10
|
||||
|
||||
# LLM Provider
|
||||
# LLM_BACKEND=nearai # default
|
||||
# Possible values: nearai, ollama, openai_compatible, openai, anthropic, github_copilot, tinfoil, openai_codex, gemini_oauth
|
||||
# Possible values: nearai, ollama, openai_compatible, openai, anthropic, github_copilot, tinfoil, openai_codex
|
||||
# LLM_REQUEST_TIMEOUT_SECS=120 # Increase for local LLMs (Ollama, vLLM, LM Studio)
|
||||
|
||||
# === Anthropic Direct ===
|
||||
@@ -110,23 +110,6 @@ NEARAI_AUTH_URL=https://private.near.ai
|
||||
# OPENAI_CODEX_AUTH_URL=https://auth.openai.com # override (rare)
|
||||
# OPENAI_CODEX_API_URL=https://chatgpt.com/backend-api/codex # override (rare)
|
||||
|
||||
# === Google Gemini (OAuth, Gemini CLI compatible) ===
|
||||
# LLM_BACKEND=gemini_oauth
|
||||
# GEMINI_MODEL=gemini-2.5-flash # default
|
||||
# GEMINI_CREDENTIALS_PATH=~/.gemini/oauth_creds.json # default
|
||||
# GEMINI_API_KEY=... # optional: use API key instead of OAuth
|
||||
# GEMINI_API_KEY_AUTH_MECHANISM=query # "query" (default) or "header"
|
||||
# GEMINI_SAFETY_BLOCK_NONE=true # disable safety filters (default: false)
|
||||
# GEMINI_CLI_CUSTOM_HEADERS=Key:Value,Key2:Value2
|
||||
# GEMINI_TOP_P=0.95
|
||||
# GEMINI_TOP_K=40
|
||||
# GEMINI_SEED=42
|
||||
# GEMINI_PRESENCE_PENALTY=0.0
|
||||
# GEMINI_FREQUENCY_PENALTY=0.0
|
||||
# GEMINI_RESPONSE_MIME_TYPE=application/json
|
||||
# GEMINI_RESPONSE_JSON_SCHEMA={"type":"object"}
|
||||
# GEMINI_CACHED_CONTENT=cachedContents/abc123
|
||||
|
||||
# For full provider setup guide see docs/LLM_PROVIDERS.md
|
||||
|
||||
# Channel Configuration
|
||||
|
||||
@@ -121,7 +121,6 @@ jobs:
|
||||
fi
|
||||
|
||||
# Whole-function context: detect edits inside existing test functions.
|
||||
# Uses -W (whole function) which works when git recognises function boundaries.
|
||||
if git diff "${BASE_REF}...${HEAD_REF}" -W -- '*.rs' | awk '
|
||||
/^@@/ { if (has_test && has_add) { found=1; exit } has_test=0; has_add=0 }
|
||||
/^ .*#\[test\]/ || /^ .*#\[tokio::test\]/ || /^ .*#\[cfg\(test\)\]/ || /^ .*mod tests/ { has_test=1 }
|
||||
@@ -133,40 +132,6 @@ jobs:
|
||||
exit 0
|
||||
fi
|
||||
|
||||
# Line-level check: detect changes inside #[cfg(test)] mod blocks.
|
||||
# git -W relies on function boundary detection which misses Rust mod blocks,
|
||||
# so this fallback checks whether changed line numbers fall within test modules.
|
||||
# We specifically match #[cfg(test)] that is followed by `mod` (same or next
|
||||
# line) to avoid false positives from standalone #[cfg(test)] items like
|
||||
# individual statics or functions.
|
||||
CHANGED_RS=$(echo "$CHANGED_FILES" | grep '\.rs$' || true)
|
||||
if [ -n "$CHANGED_RS" ]; then
|
||||
while IFS= read -r rs_file; do
|
||||
[ -f "$rs_file" ] || continue
|
||||
|
||||
# Find the line where #[cfg(test)] precedes a `mod` declaration.
|
||||
# Handles both `#[cfg(test)] mod tests` (same line) and the two-line form.
|
||||
TEST_MOD_START=$(awk '
|
||||
/^[[:space:]]*#\[cfg\(test\)\].*mod / { print NR; exit }
|
||||
/^[[:space:]]*#\[cfg\(test\)\][[:space:]]*$/ { pending=NR; next }
|
||||
pending && /^[[:space:]]*mod / { print pending; exit }
|
||||
{ pending=0 }
|
||||
' "$rs_file")
|
||||
[ -n "$TEST_MOD_START" ] || continue
|
||||
|
||||
# Get changed line numbers in this file from the diff hunk headers.
|
||||
# Each @@ line looks like: @@ -old,count +new,count @@
|
||||
while IFS= read -r hunk_line; do
|
||||
line_no=$(echo "$hunk_line" | sed -E 's/^@@ -[0-9,]+ \+([0-9]+).*/\1/')
|
||||
[ -n "$line_no" ] || continue
|
||||
if [ "$line_no" -ge "$TEST_MOD_START" ]; then
|
||||
echo "Test changes found: $rs_file has changes at line $line_no inside #[cfg(test)] mod block (starts at line $TEST_MOD_START)."
|
||||
exit 0
|
||||
fi
|
||||
done < <(git diff "${BASE_REF}...${HEAD_REF}" -U0 -- "$rs_file" | grep -E '^@@')
|
||||
done <<< "$CHANGED_RS"
|
||||
fi
|
||||
|
||||
if grep -qE '^tests/' <<< "$CHANGED_FILES"; then
|
||||
echo "Test file changes found under tests/."
|
||||
exit 0
|
||||
|
||||
Generated
+26
-10
@@ -1510,7 +1510,7 @@ version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "980c2afde4af43d6a05c5be738f9eae595cff86dce1f38f88b95058a98c027f3"
|
||||
dependencies = [
|
||||
"crossterm",
|
||||
"crossterm 0.29.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -1731,7 +1731,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "04a63daf06a168535c74ab97cdba3ed4fa5d4f32cb36e437dcceb83d66854b7c"
|
||||
dependencies = [
|
||||
"crokey-proc_macros",
|
||||
"crossterm",
|
||||
"crossterm 0.29.0",
|
||||
"once_cell",
|
||||
"serde",
|
||||
"strict",
|
||||
@@ -1743,7 +1743,7 @@ version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "847f11a14855fc490bd5d059821895c53e77eeb3c2b73ee3dded7ce77c93b231"
|
||||
dependencies = [
|
||||
"crossterm",
|
||||
"crossterm 0.29.0",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"strict",
|
||||
@@ -1817,6 +1817,22 @@ version = "0.8.21"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
|
||||
|
||||
[[package]]
|
||||
name = "crossterm"
|
||||
version = "0.28.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "829d955a0bb380ef178a640b91779e3987da38c9aea133b20614cfed8cdea9c6"
|
||||
dependencies = [
|
||||
"bitflags 2.11.0",
|
||||
"crossterm_winapi",
|
||||
"mio",
|
||||
"parking_lot",
|
||||
"rustix 0.38.44",
|
||||
"signal-hook",
|
||||
"signal-hook-mio",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossterm"
|
||||
version = "0.29.0"
|
||||
@@ -2136,7 +2152,7 @@ dependencies = [
|
||||
"libc",
|
||||
"option-ext",
|
||||
"redox_users 0.5.2",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -2323,7 +2339,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
|
||||
dependencies = [
|
||||
"libc",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -3410,7 +3426,7 @@ dependencies = [
|
||||
"clap_complete",
|
||||
"criterion",
|
||||
"cron",
|
||||
"crossterm",
|
||||
"crossterm 0.28.1",
|
||||
"deadpool-postgres",
|
||||
"dirs 6.0.0",
|
||||
"dotenvy",
|
||||
@@ -4134,7 +4150,7 @@ version = "0.50.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -5472,7 +5488,7 @@ dependencies = [
|
||||
"errno",
|
||||
"libc",
|
||||
"linux-raw-sys 0.12.1",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -6379,7 +6395,7 @@ dependencies = [
|
||||
"getrandom 0.4.2",
|
||||
"once_cell",
|
||||
"rustix 1.1.4",
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.59.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -8029,7 +8045,7 @@ version = "0.1.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
|
||||
dependencies = [
|
||||
"windows-sys 0.61.2",
|
||||
"windows-sys 0.48.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
|
||||
+2
-1
@@ -12,6 +12,7 @@ exclude = [
|
||||
"tools-src/google-drive",
|
||||
"tools-src/google-sheets",
|
||||
"tools-src/google-slides",
|
||||
"tools-src/composio",
|
||||
"tools-src/slack",
|
||||
"tools-src/telegram",
|
||||
"fuzz",
|
||||
@@ -88,7 +89,7 @@ async-trait = "0.1"
|
||||
clap = { version = "4", features = ["derive", "env"] }
|
||||
|
||||
# Terminal
|
||||
crossterm = "0.29"
|
||||
crossterm = "0.28"
|
||||
rustyline = { version = "17", features = ["custom-bindings", "derive", "with-file-history"] }
|
||||
termimad = "0.34"
|
||||
|
||||
|
||||
+5
-14
@@ -3,7 +3,6 @@
|
||||
This document tracks feature parity between IronClaw (Rust implementation) and OpenClaw (TypeScript reference implementation). Use this to coordinate work across developers.
|
||||
|
||||
**Legend:**
|
||||
|
||||
- ✅ Implemented
|
||||
- 🚧 Partial (in progress or incomplete)
|
||||
- ❌ Not implemented
|
||||
@@ -205,7 +204,7 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
| Skills (modular capabilities) | ✅ | ✅ | Prompt-based skills with trust gating, attenuation, activation criteria, catalog, selector |
|
||||
| Skill routing blocks | ✅ | 🚧 | ActivationCriteria (keywords, patterns, tags) but no "Use when / Don't use when" blocks |
|
||||
| Skill path compaction | ✅ | ❌ | ~ prefix to reduce prompt tokens |
|
||||
| Thinking modes (off/minimal/low/medium/high/xhigh/adaptive) | ✅ | 🚧 | thinkingConfig for Gemini models (thinkingBudget/thinkingLevel); no per-level control yet |
|
||||
| Thinking modes (off/minimal/low/medium/high/xhigh/adaptive) | ✅ | ❌ | Configurable reasoning depth |
|
||||
| Per-model thinkingDefault override | ✅ | ❌ | Override thinking level per model; Anthropic Claude 4.6 defaults to adaptive |
|
||||
| Block-level streaming | ✅ | ❌ | |
|
||||
| Tool-level streaming | ✅ | ❌ | |
|
||||
@@ -237,13 +236,9 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
| NEAR AI | ✅ | ✅ | - | Primary provider |
|
||||
| Anthropic (Claude) | ✅ | 🚧 | - | Via NEAR AI proxy; Opus 4.5, Sonnet 4, Sonnet 4.6, adaptive thinking default |
|
||||
| OpenAI | ✅ | 🚧 | - | Via NEAR AI proxy; GPT-5.4 + Codex OAuth |
|
||||
| AWS Bedrock | ✅ | ✅ | - | Native Converse API via aws-sdk-bedrockruntime (requires `--features bedrock`) |
|
||||
| Google Gemini | ✅ | ✅ | - | OAuth (PKCE + S256), function calling, thinkingConfig, generationConfig |
|
||||
| io.net | ✅ | ✅ | P3 | Via `ionet` adapter |
|
||||
| Mistral | ✅ | ✅ | P3 | Via `mistral` adapter |
|
||||
| Yandex AI Studio | ✅ | ✅ | P3 | Via `yandex` adapter |
|
||||
| Cloudflare Workers AI | ✅ | ✅ | P3 | Via `cloudflare` adapter |
|
||||
| NVIDIA API | ✅ | ✅ | P3 | Via `nvidia` adapter and `providers.json` |
|
||||
| AWS Bedrock | ✅ | ❌ | P3 | |
|
||||
| Google Gemini | ✅ | ❌ | P3 | |
|
||||
| NVIDIA API | ✅ | ❌ | P3 | New provider |
|
||||
| OpenRouter | ✅ | ✅ | - | Via OpenAI-compatible provider (RigAdapter) |
|
||||
| Tinfoil | ❌ | ✅ | - | Private inference provider (IronClaw-only) |
|
||||
| OpenAI-compatible | ❌ | ✅ | - | Generic OpenAI-compatible endpoint (RigAdapter) |
|
||||
@@ -471,7 +466,7 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
| Device pairing | ✅ | ❌ | |
|
||||
| Tailscale identity | ✅ | ❌ | |
|
||||
| Trusted-proxy auth | ✅ | ❌ | Header-based reverse proxy auth |
|
||||
| OAuth flows | ✅ | 🚧 | NEAR AI OAuth + Gemini OAuth (PKCE, S256) + hosted extension/MCP OAuth broker; external auth-proxy rollout still pending |
|
||||
| OAuth flows | ✅ | 🚧 | NEAR AI OAuth plus hosted extension/MCP OAuth broker; external auth-proxy rollout still pending |
|
||||
| DM pairing verification | ✅ | ✅ | ironclaw pairing approve, host APIs |
|
||||
| Allowlist/blocklist | ✅ | 🚧 | allow_from + pairing store |
|
||||
| Per-group tool policies | ✅ | ❌ | |
|
||||
@@ -528,7 +523,6 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
## Implementation Priorities
|
||||
|
||||
### P0 - Core (Already Done)
|
||||
|
||||
- ✅ TUI channel with approval overlays
|
||||
- ✅ HTTP webhook channel
|
||||
- ✅ DM pairing (ironclaw pairing list/approve, host APIs)
|
||||
@@ -556,7 +550,6 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
- ✅ OpenAI-compatible / OpenRouter provider support
|
||||
|
||||
### P1 - High Priority
|
||||
|
||||
- ❌ Slack channel (real implementation)
|
||||
- ✅ Telegram channel (WASM, DM pairing, caption, /start)
|
||||
- ❌ WhatsApp channel
|
||||
@@ -564,7 +557,6 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
- ✅ Hooks system (core lifecycle hooks + bundled/plugin/workspace hooks + outbound webhooks)
|
||||
|
||||
### P2 - Medium Priority
|
||||
|
||||
- ❌ Media handling (images, PDFs)
|
||||
- ✅ Ollama/local model support (via rig::providers::ollama)
|
||||
- ❌ Configuration hot-reload
|
||||
@@ -573,7 +565,6 @@ This document tracks feature parity between IronClaw (Rust implementation) and O
|
||||
- ❌ Partial output preservation on abort
|
||||
|
||||
### P3 - Lower Priority
|
||||
|
||||
- ❌ Discord channel
|
||||
- ❌ Matrix channel
|
||||
- ❌ Other messaging platforms
|
||||
|
||||
@@ -3,11 +3,11 @@
|
||||
"wit_version": "0.3.0",
|
||||
"type": "channel",
|
||||
"name": "feishu",
|
||||
"description": "Feishu/Lark Bot channel for receiving and responding to Feishu messages via Event Subscription webhooks",
|
||||
"description": "Feishu/Lark Bot channel for receiving and responding to Feishu messages",
|
||||
"auth": {
|
||||
"secret_name": "feishu_app_id",
|
||||
"display_name": "Feishu / Lark",
|
||||
"instructions": "Create a bot at https://open.feishu.cn/app (Feishu) or https://open.larksuite.com/app (Lark). You need the App ID and App Secret. Note: IronClaw supports Event Subscription webhook delivery, but not Feishu's long-connection websocket mode.",
|
||||
"instructions": "Create a bot at https://open.feishu.cn/app (Feishu) or https://open.larksuite.com/app (Lark). You need the App ID and App Secret.",
|
||||
"setup_url": "https://open.feishu.cn/app",
|
||||
"token_hint": "App ID looks like cli_XXXX, App Secret is a long alphanumeric string",
|
||||
"env_var": "FEISHU_APP_ID"
|
||||
@@ -16,7 +16,7 @@
|
||||
"required_secrets": [
|
||||
{
|
||||
"name": "feishu_app_id",
|
||||
"prompt": "Enter your Feishu/Lark App ID (from https://open.feishu.cn/app). Use webhook-based Event Subscription, not long-connection websocket mode.",
|
||||
"prompt": "Enter your Feishu/Lark App ID (from https://open.feishu.cn/app)",
|
||||
"optional": false
|
||||
},
|
||||
{
|
||||
@@ -26,7 +26,7 @@
|
||||
},
|
||||
{
|
||||
"name": "feishu_verification_token",
|
||||
"prompt": "Enter your Feishu/Lark Verification Token (from Event Subscription webhook settings)",
|
||||
"prompt": "Enter your Feishu/Lark Verification Token (from Event Subscription settings)",
|
||||
"optional": true
|
||||
}
|
||||
],
|
||||
|
||||
@@ -5,9 +5,7 @@
|
||||
//!
|
||||
//! This WASM component implements the channel interface for handling Feishu
|
||||
//! webhooks (Event Subscription v2.0) and sending messages back via the
|
||||
//! Feishu/Lark Bot API. IronClaw currently does not connect to Feishu's
|
||||
//! long-connection websocket subscription mode; use Event Subscription
|
||||
//! webhooks for this channel.
|
||||
//! Feishu/Lark Bot API.
|
||||
//!
|
||||
//! # Features
|
||||
//!
|
||||
|
||||
+3
-48
@@ -1,8 +1,8 @@
|
||||
# LLM Provider Configuration
|
||||
|
||||
IronClaw defaults to NEAR AI for model access, but supports any OpenAI-compatible
|
||||
endpoint as well as Anthropic, Ollama, and Google Gemini directly. This guide covers
|
||||
the most common configurations.
|
||||
endpoint as well as Anthropic and Ollama directly. This guide covers the most common
|
||||
configurations.
|
||||
|
||||
## Provider Overview
|
||||
|
||||
@@ -11,7 +11,7 @@ the most common configurations.
|
||||
| NEAR AI | `nearai` | OAuth (browser) | Default; multi-model |
|
||||
| Anthropic | `anthropic` | `ANTHROPIC_API_KEY` | Claude models |
|
||||
| OpenAI | `openai` | `OPENAI_API_KEY` | GPT models |
|
||||
| Google Gemini | `gemini_oauth` | OAuth (browser) | Gemini models; function calling |
|
||||
| Google Gemini | `gemini` | `GEMINI_API_KEY` | Gemini models |
|
||||
| io.net | `ionet` | `IONET_API_KEY` | Intelligence API |
|
||||
| Mistral | `mistral` | `MISTRAL_API_KEY` | Mistral models |
|
||||
| Yandex AI Studio | `yandex` | `YANDEX_API_KEY` | YandexGPT models |
|
||||
@@ -62,51 +62,6 @@ Popular models: `gpt-4o`, `gpt-4o-mini`, `o3-mini`
|
||||
|
||||
---
|
||||
|
||||
## Google Gemini (OAuth)
|
||||
|
||||
Uses Google OAuth with PKCE (S256) for authentication — no API key required.
|
||||
On first run, a browser opens for Google account login. Credentials (including
|
||||
refresh token) are saved to `~/.gemini/oauth_creds.json` with `0600` permissions.
|
||||
|
||||
```env
|
||||
LLM_BACKEND=gemini_oauth
|
||||
GEMINI_MODEL=gemini-2.5-flash
|
||||
```
|
||||
|
||||
### Supported features
|
||||
|
||||
| Feature | Status | Notes |
|
||||
|---|---|---|
|
||||
| Function calling | ✅ | `functionDeclarations` / `functionCall` / `functionResponse` |
|
||||
| `generationConfig` | ✅ | `temperature`, `maxOutputTokens` passed from request |
|
||||
| `thinkingConfig` | ✅ | `thinkingBudget`/`thinkingLevel` for thinking-capable models (does NOT set `includeThoughts`) |
|
||||
| `toolConfig` | ✅ | `functionCallingConfig.mode`: `AUTO`/`ANY`/`NONE` |
|
||||
| SSE streaming | ✅ | Cloud Code API with `streamGenerateContent?alt=sse` |
|
||||
| Token refresh | ✅ | Automatic via refresh token |
|
||||
|
||||
### Popular models
|
||||
|
||||
| Model | ID | Notes |
|
||||
|---|---|---|
|
||||
| Gemini 3.1 Pro | `gemini-3.1-pro-preview` | Latest, strongest reasoning |
|
||||
| Gemini 3.1 Pro Custom Tools | `gemini-3.1-pro-preview-customtools` | Enhanced tool use |
|
||||
| Gemini 3 Pro | `gemini-3-pro-preview` | Preview |
|
||||
| Gemini 3 Flash | `gemini-3-flash-preview` | Fast preview with thinking |
|
||||
| Gemini 3.1 Flash Lite | `gemini-3.1-flash-lite-preview` | Preview, lightweight |
|
||||
| Gemini 2.5 Pro | `gemini-2.5-pro` | Stable, strong reasoning |
|
||||
| Gemini 2.5 Flash | `gemini-2.5-flash` | Fast, good quality |
|
||||
| Gemini 2.5 Flash Lite | `gemini-2.5-flash-lite` | Fastest, lightweight |
|
||||
|
||||
### Cloud Code API vs standard API
|
||||
|
||||
Models containing `-preview` (with hyphen) or `gemini-3` in the name, as well
|
||||
as any `gemini-` model with major version >= 2, route through the Cloud Code
|
||||
API (`cloudcode-pa.googleapis.com`) which supports SSE streaming
|
||||
and project-scoped access. Other models use the standard Generative Language
|
||||
API (`generativelanguage.googleapis.com`).
|
||||
|
||||
---
|
||||
|
||||
## GitHub Copilot
|
||||
|
||||
GitHub Copilot exposes chat endpoint at
|
||||
|
||||
@@ -162,7 +162,7 @@ pub struct AgentDeps {
|
||||
/// HTTP interceptor for trace recording/replay.
|
||||
pub http_interceptor: Option<Arc<dyn crate::llm::recording::HttpInterceptor>>,
|
||||
/// Audio transcription middleware for voice messages.
|
||||
pub transcription: Option<Arc<crate::llm::transcription::TranscriptionMiddleware>>,
|
||||
pub transcription: Option<Arc<crate::transcription::TranscriptionMiddleware>>,
|
||||
/// Document text extraction middleware for PDF, DOCX, PPTX, etc.
|
||||
pub document_extraction: Option<Arc<crate::document_extraction::DocumentExtractionMiddleware>>,
|
||||
/// Sandbox readiness state for full-job routine dispatch.
|
||||
|
||||
@@ -6,7 +6,6 @@
|
||||
//! via the `LoopDelegate` trait.
|
||||
|
||||
use async_trait::async_trait;
|
||||
use std::borrow::Cow;
|
||||
|
||||
use crate::agent::session::PendingApproval;
|
||||
use crate::error::Error;
|
||||
@@ -236,12 +235,12 @@ pub async fn run_agentic_loop(
|
||||
///
|
||||
/// `max` is a byte budget. The result is truncated at the last valid char
|
||||
/// boundary at or before `max` bytes, so it is always valid UTF-8.
|
||||
pub fn truncate_for_preview(s: &str, max: usize) -> Cow<'_, str> {
|
||||
pub fn truncate_for_preview(s: &str, max: usize) -> String {
|
||||
if s.len() <= max {
|
||||
Cow::Borrowed(s)
|
||||
s.to_string()
|
||||
} else {
|
||||
let end = crate::util::floor_char_boundary(s, max);
|
||||
Cow::Owned(format!("{}...", &s[..end]))
|
||||
format!("{}...", &s[..end])
|
||||
}
|
||||
}
|
||||
|
||||
@@ -598,24 +597,12 @@ mod tests {
|
||||
assert_eq!(truncate_for_preview("hello", 10), "hello");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_truncate_short_string_borrows() {
|
||||
let result = truncate_for_preview("hello", 10);
|
||||
assert!(matches!(result, Cow::Borrowed("hello")));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_truncate_long_string_adds_ellipsis() {
|
||||
let result = truncate_for_preview("hello world", 5);
|
||||
assert_eq!(result, "hello...");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_truncate_long_string_owns() {
|
||||
let result = truncate_for_preview("hello world", 5);
|
||||
assert!(matches!(result, Cow::Owned(_)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_truncate_multibyte_safe() {
|
||||
let result = truncate_for_preview("café", 4);
|
||||
|
||||
+5
-36
@@ -317,7 +317,7 @@ impl<'a> LoopDelegate for ChatDelegate<'a> {
|
||||
.channels
|
||||
.send_status(
|
||||
&self.message.channel,
|
||||
StatusUpdate::Thinking(format!("Thinking (step {iteration})...")),
|
||||
StatusUpdate::Thinking("Calling LLM...".into()),
|
||||
&self.message.metadata,
|
||||
)
|
||||
.await;
|
||||
@@ -435,7 +435,7 @@ impl<'a> LoopDelegate for ChatDelegate<'a> {
|
||||
.channels
|
||||
.send_status(
|
||||
&self.message.channel,
|
||||
StatusUpdate::Thinking(contextual_tool_message(&tool_calls)),
|
||||
StatusUpdate::Thinking(format!("Executing {} tool(s)...", tool_calls.len())),
|
||||
&self.message.metadata,
|
||||
)
|
||||
.await;
|
||||
@@ -915,14 +915,7 @@ pub(super) async fn execute_chat_tool_standalone(
|
||||
params: &serde_json::Value,
|
||||
job_ctx: &crate::context::JobContext,
|
||||
) -> Result<String, Error> {
|
||||
crate::tools::execute::execute_tool_with_safety(
|
||||
tools,
|
||||
safety,
|
||||
tool_name,
|
||||
params.clone(),
|
||||
job_ctx,
|
||||
)
|
||||
.await
|
||||
crate::tools::execute::execute_tool_with_safety(tools, safety, tool_name, params, job_ctx).await
|
||||
}
|
||||
|
||||
/// Parsed auth result fields for emitting StatusUpdate::AuthRequired.
|
||||
@@ -976,30 +969,6 @@ pub(super) fn check_auth_required(
|
||||
Some((name, instructions))
|
||||
}
|
||||
|
||||
/// Build a contextual thinking message based on tool names.
|
||||
///
|
||||
/// Instead of a generic "Executing 2 tool(s)..." this returns messages like
|
||||
/// "Running command..." or "Fetching page..." for single-tool calls, falling
|
||||
/// back to "Executing N tool(s)..." for multi-tool calls.
|
||||
fn contextual_tool_message(tool_calls: &[crate::llm::ToolCall]) -> String {
|
||||
if tool_calls.len() == 1 {
|
||||
match tool_calls[0].name.as_str() {
|
||||
"shell" => "Running command...".into(),
|
||||
"web_fetch" => "Fetching page...".into(),
|
||||
"memory_search" => "Searching memory...".into(),
|
||||
"memory_write" => "Writing to memory...".into(),
|
||||
"memory_read" => "Reading memory...".into(),
|
||||
"http_request" => "Making HTTP request...".into(),
|
||||
"file_read" => "Reading file...".into(),
|
||||
"file_write" => "Writing file...".into(),
|
||||
"json_transform" => "Transforming data...".into(),
|
||||
name => format!("Running {name}..."),
|
||||
}
|
||||
} else {
|
||||
format!("Executing {} tool(s)...", tool_calls.len())
|
||||
}
|
||||
}
|
||||
|
||||
/// Compact messages for retry after a context-length-exceeded error.
|
||||
///
|
||||
/// Keeps all `System` messages (which carry the system prompt and instructions),
|
||||
@@ -1900,7 +1869,7 @@ mod tests {
|
||||
Ok(ToolCompletionResponse {
|
||||
content: None,
|
||||
tool_calls: vec![ToolCall {
|
||||
id: crate::llm::generate_tool_call_id(0, 0),
|
||||
id: format!("call_{}", uuid::Uuid::new_v4()),
|
||||
name: "echo".to_string(),
|
||||
arguments: serde_json::json!({"message": "looping"}),
|
||||
}],
|
||||
@@ -2053,7 +2022,7 @@ mod tests {
|
||||
Ok(ToolCompletionResponse {
|
||||
content: None,
|
||||
tool_calls: vec![ToolCall {
|
||||
id: crate::llm::generate_tool_call_id(0, 0),
|
||||
id: format!("call_{}", uuid::Uuid::new_v4()),
|
||||
name: "nonexistent_tool".to_string(),
|
||||
arguments: serde_json::json!({}),
|
||||
}],
|
||||
|
||||
@@ -529,8 +529,8 @@ pub fn normalize_cron_expression(schedule: &str) -> String {
|
||||
let trimmed = schedule.trim();
|
||||
let fields: Vec<&str> = trimmed.split_whitespace().collect();
|
||||
match fields.len() {
|
||||
5 => format!("0 {} *", fields.join(" ")),
|
||||
6 => format!("{} *", fields.join(" ")),
|
||||
5 => format!("0 {} *", trimmed),
|
||||
6 => format!("{} *", trimmed),
|
||||
_ => trimmed.to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -549,7 +549,11 @@ impl Scheduler {
|
||||
|
||||
// Delegate to shared tool execution pipeline
|
||||
let output_str = crate::tools::execute::execute_tool_with_safety(
|
||||
&tools, &safety, tool_name, params, &job_ctx,
|
||||
&tools,
|
||||
&safety,
|
||||
tool_name,
|
||||
&normalized_params,
|
||||
&job_ctx,
|
||||
)
|
||||
.await?;
|
||||
|
||||
|
||||
+8
-22
@@ -17,7 +17,7 @@ use serde::{Deserialize, Serialize};
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::channels::web::util::truncate_preview;
|
||||
use crate::llm::{ChatMessage, ToolCall, generate_tool_call_id};
|
||||
use crate::llm::{ChatMessage, ToolCall};
|
||||
|
||||
/// A session containing one or more threads.
|
||||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
@@ -414,12 +414,7 @@ impl Thread {
|
||||
/// completed actions in subsequent turns.
|
||||
pub fn messages(&self) -> Vec<ChatMessage> {
|
||||
let mut messages = Vec::new();
|
||||
// We use the enumeration index (`turn_idx`) rather than `turn.turn_number`
|
||||
// intentionally: after `truncate_turns()`, the remaining turns are
|
||||
// re-numbered starting from 0, so the enumeration index and turn_number
|
||||
// are equivalent. Using the index avoids coupling to the field and keeps
|
||||
// tool-call ID generation deterministic for the current message window.
|
||||
for (turn_idx, turn) in self.turns.iter().enumerate() {
|
||||
for turn in &self.turns {
|
||||
if turn.image_content_parts.is_empty() {
|
||||
messages.push(ChatMessage::user(&turn.user_input));
|
||||
} else {
|
||||
@@ -430,23 +425,13 @@ impl Thread {
|
||||
}
|
||||
|
||||
if !turn.tool_calls.is_empty() {
|
||||
// Assign synthetic call IDs for this turn's tool calls, so that
|
||||
// declarations and results can be consistently correlated.
|
||||
let tool_calls_with_ids: Vec<(String, &_)> = turn
|
||||
// Build ToolCall objects with synthetic stable IDs
|
||||
let tool_calls: Vec<ToolCall> = turn
|
||||
.tool_calls
|
||||
.iter()
|
||||
.enumerate()
|
||||
.map(|(tc_idx, tc)| {
|
||||
// Use provider-compatible tool call IDs derived from turn/tool indices.
|
||||
(generate_tool_call_id(turn_idx, tc_idx), tc)
|
||||
})
|
||||
.collect();
|
||||
|
||||
// Build ToolCall objects using the synthetic call IDs.
|
||||
let tool_calls: Vec<ToolCall> = tool_calls_with_ids
|
||||
.iter()
|
||||
.map(|(call_id, tc)| ToolCall {
|
||||
id: call_id.clone(),
|
||||
.map(|(i, tc)| ToolCall {
|
||||
id: format!("turn{}_{}", turn.turn_number, i),
|
||||
name: tc.name.clone(),
|
||||
arguments: tc.parameters.clone(),
|
||||
})
|
||||
@@ -456,7 +441,8 @@ impl Thread {
|
||||
messages.push(ChatMessage::assistant_with_tool_calls(None, tool_calls));
|
||||
|
||||
// Individual tool result messages, truncated to limit context size.
|
||||
for (call_id, tc) in tool_calls_with_ids {
|
||||
for (i, tc) in turn.tool_calls.iter().enumerate() {
|
||||
let call_id = format!("turn{}_{}", turn.turn_number, i);
|
||||
let content = if let Some(ref err) = tc.error {
|
||||
// .error already contains the full error text;
|
||||
// pass through without wrapping to avoid double-prefix.
|
||||
|
||||
@@ -556,33 +556,6 @@ impl Agent {
|
||||
.await;
|
||||
}
|
||||
|
||||
// Emit per-turn cost summary
|
||||
{
|
||||
let usage = self.cost_guard().model_usage().await;
|
||||
let (total_in, total_out, total_cost) =
|
||||
usage
|
||||
.values()
|
||||
.fold((0u64, 0u64, rust_decimal::Decimal::ZERO), |acc, m| {
|
||||
(
|
||||
acc.0 + m.input_tokens,
|
||||
acc.1 + m.output_tokens,
|
||||
acc.2 + m.cost,
|
||||
)
|
||||
});
|
||||
let _ = self
|
||||
.channels
|
||||
.send_status(
|
||||
&message.channel,
|
||||
StatusUpdate::TurnCost {
|
||||
input_tokens: total_in,
|
||||
output_tokens: total_out,
|
||||
cost_usd: format!("${:.4}", total_cost),
|
||||
},
|
||||
&message.metadata,
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
Ok(SubmissionResult::response(response))
|
||||
}
|
||||
Ok(AgenticLoopResult::NeedApproval { pending }) => {
|
||||
|
||||
+8
-8
@@ -386,7 +386,7 @@ impl AppBuilder {
|
||||
let b = tools
|
||||
.register_builder_tool(llm.clone(), Some(self.config.builder.to_builder_config()))
|
||||
.await;
|
||||
tracing::debug!("Builder mode enabled");
|
||||
tracing::info!("Builder mode enabled");
|
||||
Some(b)
|
||||
} else {
|
||||
None
|
||||
@@ -729,13 +729,13 @@ impl AppBuilder {
|
||||
self.init_database().await?;
|
||||
self.init_secrets().await?;
|
||||
|
||||
// Post-init validation: backends with dedicated config (nearai, gemini_oauth,
|
||||
// bedrock, openai_codex) handle their own credential resolution. For registry-based
|
||||
// backends, fail early if no provider config was resolved.
|
||||
if !matches!(
|
||||
self.config.llm.backend.as_str(),
|
||||
"nearai" | "gemini_oauth" | "bedrock" | "openai_codex"
|
||||
) && self.config.llm.provider.is_none()
|
||||
// Post-init validation: if a non-nearai backend was selected but
|
||||
// credentials were never resolved (deferred resolution found no keys),
|
||||
// fail early with a clear error instead of a confusing runtime failure.
|
||||
if self.config.llm.backend != "nearai"
|
||||
&& self.config.llm.backend != "bedrock"
|
||||
&& self.config.llm.backend != "openai_codex"
|
||||
&& self.config.llm.provider.is_none()
|
||||
{
|
||||
let backend = &self.config.llm.backend;
|
||||
anyhow::bail!(
|
||||
|
||||
+91
-186
@@ -1,11 +1,8 @@
|
||||
//! Boot screen displayed after all initialization completes.
|
||||
//!
|
||||
//! Shows a compact ANSI-styled status panel with three tiers:
|
||||
//! - **Tier 1 (always):** Name + version, model + backend.
|
||||
//! - **Tier 2 (conditional):** Gateway URL, tunnel URL, non-default channels.
|
||||
//! - **Tier 3 (removed):** Database, tool count, features → use `ironclaw status`.
|
||||
|
||||
use crate::cli::fmt;
|
||||
//! Shows a polished ANSI-styled status panel summarizing the agent's runtime
|
||||
//! state: model, database, tool count, enabled features, active channels,
|
||||
//! and the gateway URL.
|
||||
|
||||
/// All displayable fields for the boot screen.
|
||||
pub struct BootInfo {
|
||||
@@ -32,217 +29,128 @@ pub struct BootInfo {
|
||||
pub tunnel_url: Option<String>,
|
||||
/// Provider name for the managed tunnel (e.g., "ngrok").
|
||||
pub tunnel_provider: Option<String>,
|
||||
/// Time elapsed during startup. Shown at the bottom when present.
|
||||
pub startup_elapsed: Option<std::time::Duration>,
|
||||
}
|
||||
|
||||
const KW: usize = 10;
|
||||
|
||||
/// Print the boot screen to stdout.
|
||||
///
|
||||
/// **Tier 1 (always):** Name + version, model + backend.
|
||||
/// **Tier 2 (conditional):** Gateway URL, tunnel URL, non-default channels.
|
||||
/// **Tier 3 (removed):** Database, tool count, features — use `ironclaw status`.
|
||||
pub fn print_boot_screen(info: &BootInfo) {
|
||||
let border = format!(" {}", fmt::separator(58));
|
||||
// ANSI codes matching existing REPL palette
|
||||
let bold = "\x1b[1m";
|
||||
let cyan = "\x1b[36m";
|
||||
let dim = "\x1b[90m";
|
||||
let yellow = "\x1b[33m";
|
||||
let yellow_underline = "\x1b[33;4m";
|
||||
let reset = "\x1b[0m";
|
||||
|
||||
let border = format!(" {dim}{}{reset}", "\u{2576}".repeat(58));
|
||||
|
||||
println!();
|
||||
println!("{border}");
|
||||
println!();
|
||||
|
||||
// ── Tier 1: always shown ──────────────────────────────────────────
|
||||
|
||||
println!(
|
||||
" {}{}{} v{}",
|
||||
fmt::bold(),
|
||||
info.agent_name,
|
||||
fmt::reset(),
|
||||
info.version
|
||||
);
|
||||
println!(" {bold}{}{reset} v{}", info.agent_name, info.version);
|
||||
println!();
|
||||
|
||||
// Model line
|
||||
let model_display = if let Some(ref cheap) = info.cheap_model {
|
||||
format!(
|
||||
"{}{}{} {}cheap{} {}{}{}",
|
||||
fmt::accent(),
|
||||
info.llm_model,
|
||||
fmt::reset(),
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::accent(),
|
||||
cheap,
|
||||
fmt::reset(),
|
||||
"{cyan}{}{reset} {dim}cheap{reset} {cyan}{}{reset}",
|
||||
info.llm_model, cheap
|
||||
)
|
||||
} else {
|
||||
format!("{}{}{}", fmt::accent(), info.llm_model, fmt::reset())
|
||||
format!("{cyan}{}{reset}", info.llm_model)
|
||||
};
|
||||
println!(
|
||||
" {}{:<width$}{} {model_display} {}via {}{}",
|
||||
fmt::dim(),
|
||||
"model",
|
||||
fmt::reset(),
|
||||
fmt::dim(),
|
||||
info.llm_backend,
|
||||
fmt::reset(),
|
||||
width = KW,
|
||||
" {dim}model{reset} {model_display} {dim}via {}{reset}",
|
||||
info.llm_backend
|
||||
);
|
||||
|
||||
// ── Tier 2: conditional ───────────────────────────────────────────
|
||||
// Database line
|
||||
let db_status = if info.db_connected {
|
||||
"connected"
|
||||
} else {
|
||||
"none"
|
||||
};
|
||||
println!(
|
||||
" {dim}database{reset} {cyan}{}{reset} {dim}({db_status}){reset}",
|
||||
info.db_backend
|
||||
);
|
||||
|
||||
// Gateway URL
|
||||
if let Some(ref url) = info.gateway_url {
|
||||
// Tools line
|
||||
println!(
|
||||
" {dim}tools{reset} {cyan}{}{reset} {dim}registered{reset}",
|
||||
info.tool_count
|
||||
);
|
||||
|
||||
// Features line
|
||||
let mut features = Vec::new();
|
||||
if info.embeddings_enabled {
|
||||
if let Some(ref provider) = info.embeddings_provider {
|
||||
features.push(format!("embeddings ({provider})"));
|
||||
} else {
|
||||
features.push("embeddings".to_string());
|
||||
}
|
||||
}
|
||||
if info.heartbeat_enabled {
|
||||
let mins = info.heartbeat_interval_secs / 60;
|
||||
features.push(format!("heartbeat ({mins}m)"));
|
||||
}
|
||||
match info.docker_status {
|
||||
crate::sandbox::detect::DockerStatus::Available => {
|
||||
features.push("sandbox".to_string());
|
||||
}
|
||||
crate::sandbox::detect::DockerStatus::NotInstalled => {
|
||||
features.push(format!("{yellow}sandbox (docker not installed){reset}"));
|
||||
}
|
||||
crate::sandbox::detect::DockerStatus::NotRunning => {
|
||||
features.push(format!("{yellow}sandbox (docker not running){reset}"));
|
||||
}
|
||||
crate::sandbox::detect::DockerStatus::Disabled => {
|
||||
// Don't show sandbox when disabled
|
||||
}
|
||||
}
|
||||
if info.claude_code_enabled {
|
||||
features.push("claude-code".to_string());
|
||||
}
|
||||
if info.routines_enabled {
|
||||
features.push("routines".to_string());
|
||||
}
|
||||
if info.skills_enabled {
|
||||
features.push("skills".to_string());
|
||||
}
|
||||
if !features.is_empty() {
|
||||
println!(
|
||||
" {}{:<width$}{} {}{}{}",
|
||||
fmt::dim(),
|
||||
"gateway",
|
||||
fmt::reset(),
|
||||
fmt::link(),
|
||||
url,
|
||||
fmt::reset(),
|
||||
width = KW,
|
||||
" {dim}features{reset} {cyan}{}{reset}",
|
||||
features.join(" ")
|
||||
);
|
||||
}
|
||||
|
||||
// Channels line
|
||||
if !info.channels.is_empty() {
|
||||
println!(
|
||||
" {dim}channels{reset} {cyan}{}{reset}",
|
||||
info.channels.join(" ")
|
||||
);
|
||||
}
|
||||
|
||||
// Gateway URL (highlighted)
|
||||
if let Some(ref url) = info.gateway_url {
|
||||
println!();
|
||||
println!(" {dim}gateway{reset} {yellow_underline}{url}{reset}");
|
||||
}
|
||||
|
||||
// Tunnel URL
|
||||
if let Some(ref url) = info.tunnel_url {
|
||||
let provider_tag = info
|
||||
.tunnel_provider
|
||||
.as_deref()
|
||||
.map(|p| format!(" {}({}){}", fmt::dim(), p, fmt::reset()))
|
||||
.map(|p| format!(" {dim}({p}){reset}"))
|
||||
.unwrap_or_default();
|
||||
println!(
|
||||
" {}{:<width$}{} {}{}{}{}",
|
||||
fmt::dim(),
|
||||
"tunnel",
|
||||
fmt::reset(),
|
||||
fmt::link(),
|
||||
url,
|
||||
fmt::reset(),
|
||||
provider_tag,
|
||||
width = KW,
|
||||
);
|
||||
println!(" {dim}tunnel{reset} {yellow_underline}{url}{reset}{provider_tag}");
|
||||
}
|
||||
|
||||
// Non-default channels (skip if only the default set)
|
||||
let non_default: Vec<&str> = info
|
||||
.channels
|
||||
.iter()
|
||||
.filter(|c| !matches!(c.as_str(), "repl" | "gateway"))
|
||||
.map(|c| c.as_str())
|
||||
.collect();
|
||||
if !non_default.is_empty() {
|
||||
println!(
|
||||
" {}{:<width$}{} {}{}{}",
|
||||
fmt::dim(),
|
||||
"channels",
|
||||
fmt::reset(),
|
||||
fmt::accent(),
|
||||
non_default.join(" "),
|
||||
fmt::reset(),
|
||||
width = KW,
|
||||
);
|
||||
}
|
||||
|
||||
// ── Tier 3: compact feature tags ──────────────────────────────────
|
||||
|
||||
let mut tags: Vec<String> = Vec::new();
|
||||
|
||||
// Database
|
||||
if info.db_connected {
|
||||
tags.push(format!("db:{}", info.db_backend));
|
||||
}
|
||||
|
||||
// Tool count
|
||||
if info.tool_count > 0 {
|
||||
tags.push(format!("tools:{}", info.tool_count));
|
||||
}
|
||||
|
||||
// Routines
|
||||
if info.routines_enabled {
|
||||
tags.push("routines".to_string());
|
||||
}
|
||||
|
||||
// Heartbeat with interval
|
||||
if info.heartbeat_enabled {
|
||||
let interval = if info.heartbeat_interval_secs >= 3600
|
||||
&& info.heartbeat_interval_secs.is_multiple_of(3600)
|
||||
{
|
||||
format!("{}h", info.heartbeat_interval_secs / 3600)
|
||||
} else if info.heartbeat_interval_secs >= 60
|
||||
&& info.heartbeat_interval_secs.is_multiple_of(60)
|
||||
{
|
||||
format!("{}m", info.heartbeat_interval_secs / 60)
|
||||
} else {
|
||||
format!("{}s", info.heartbeat_interval_secs)
|
||||
};
|
||||
tags.push(format!("heartbeat:{interval}"));
|
||||
}
|
||||
|
||||
// Skills
|
||||
if info.skills_enabled {
|
||||
tags.push("skills".to_string());
|
||||
}
|
||||
|
||||
// Sandbox / Docker
|
||||
if info.sandbox_enabled {
|
||||
let suffix = match info.docker_status {
|
||||
crate::sandbox::detect::DockerStatus::Available => "",
|
||||
crate::sandbox::detect::DockerStatus::NotRunning => ":stopped",
|
||||
_ => ":unavail",
|
||||
};
|
||||
tags.push(format!("sandbox{suffix}"));
|
||||
}
|
||||
|
||||
// Embeddings
|
||||
if info.embeddings_enabled {
|
||||
if let Some(ref provider) = info.embeddings_provider {
|
||||
tags.push(format!("embeddings:{provider}"));
|
||||
} else {
|
||||
tags.push("embeddings".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
// Claude Code bridge
|
||||
if info.claude_code_enabled {
|
||||
tags.push("claude-code".to_string());
|
||||
}
|
||||
|
||||
if !tags.is_empty() {
|
||||
println!(
|
||||
" {}{:<width$}{} {}",
|
||||
fmt::dim(),
|
||||
"features",
|
||||
fmt::reset(),
|
||||
tags.join(" "),
|
||||
width = KW,
|
||||
);
|
||||
}
|
||||
|
||||
// ── Footer ────────────────────────────────────────────────────────
|
||||
|
||||
println!();
|
||||
println!("{border}");
|
||||
|
||||
// Startup elapsed
|
||||
if let Some(elapsed) = info.startup_elapsed {
|
||||
let millis = elapsed.as_millis();
|
||||
let elapsed_str = if millis < 1000 {
|
||||
format!("{millis}ms")
|
||||
} else {
|
||||
let secs = elapsed.as_secs_f64();
|
||||
format!("{secs:.1}s")
|
||||
};
|
||||
println!(" {}ready in {}{}", fmt::dim(), elapsed_str, fmt::reset());
|
||||
}
|
||||
|
||||
// Hint to run `ironclaw status` for full details
|
||||
println!(
|
||||
" {}Run `ironclaw status` for full system details.{}",
|
||||
fmt::hint(),
|
||||
fmt::reset()
|
||||
);
|
||||
|
||||
println!();
|
||||
println!(" /help for commands, /quit to exit");
|
||||
println!();
|
||||
}
|
||||
|
||||
@@ -279,7 +187,6 @@ mod tests {
|
||||
],
|
||||
tunnel_url: Some("https://abc123.ngrok.io".to_string()),
|
||||
tunnel_provider: Some("ngrok".to_string()),
|
||||
startup_elapsed: None,
|
||||
};
|
||||
// Should not panic
|
||||
print_boot_screen(&info);
|
||||
@@ -309,7 +216,6 @@ mod tests {
|
||||
channels: vec![],
|
||||
tunnel_url: None,
|
||||
tunnel_provider: None,
|
||||
startup_elapsed: None,
|
||||
};
|
||||
// Should not panic
|
||||
print_boot_screen(&info);
|
||||
@@ -339,7 +245,6 @@ mod tests {
|
||||
channels: vec!["repl".to_string()],
|
||||
tunnel_url: None,
|
||||
tunnel_provider: None,
|
||||
startup_elapsed: None,
|
||||
};
|
||||
// Should not panic
|
||||
print_boot_screen(&info);
|
||||
|
||||
+12
-25
@@ -568,12 +568,14 @@ impl Drop for PidLock {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use std::process::Command;
|
||||
use std::sync::Mutex;
|
||||
use std::thread;
|
||||
use std::time::{Duration, Instant};
|
||||
use tempfile::tempdir;
|
||||
|
||||
static ENV_MUTEX: Mutex<()> = Mutex::new(());
|
||||
|
||||
#[test]
|
||||
fn test_save_and_load_database_url() {
|
||||
let dir = tempdir().unwrap();
|
||||
@@ -667,23 +669,8 @@ INJECTED="pwned"#;
|
||||
|
||||
#[test]
|
||||
fn test_ironclaw_env_path() {
|
||||
// Use compute_ironclaw_base_dir() directly to avoid LazyLock caching,
|
||||
// which can be poisoned by whichever test initializes it first.
|
||||
let _guard = lock_env();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: Under lock_env(), no concurrent env access.
|
||||
unsafe { std::env::remove_var("IRONCLAW_BASE_DIR") };
|
||||
|
||||
let path = compute_ironclaw_base_dir().join(".env");
|
||||
assert!(
|
||||
path.ends_with(".ironclaw/.env"),
|
||||
"expected path ending with .ironclaw/.env, got: {}",
|
||||
path.display()
|
||||
);
|
||||
|
||||
if let Some(val) = old_val {
|
||||
unsafe { std::env::set_var("IRONCLAW_BASE_DIR", val) };
|
||||
}
|
||||
let path = ironclaw_env_path();
|
||||
assert!(path.ends_with(".ironclaw/.env"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -849,7 +836,7 @@ INJECTED="pwned"#;
|
||||
|
||||
#[test]
|
||||
fn test_libsql_autodetect_sets_backend_when_db_exists() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("DATABASE_BACKEND").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::remove_var("DATABASE_BACKEND") };
|
||||
@@ -920,7 +907,7 @@ INJECTED="pwned"#;
|
||||
|
||||
#[test]
|
||||
fn test_libsql_autodetect_does_not_override_explicit_backend() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("DATABASE_BACKEND").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::set_var("DATABASE_BACKEND", "postgres") };
|
||||
@@ -1047,7 +1034,7 @@ INJECTED="pwned"#;
|
||||
fn test_ironclaw_base_dir_default() {
|
||||
// This test must run first (or in isolation) before the LazyLock is initialized.
|
||||
// It verifies that when IRONCLAW_BASE_DIR is not set, the default path is used.
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::remove_var("IRONCLAW_BASE_DIR") };
|
||||
@@ -1067,7 +1054,7 @@ INJECTED="pwned"#;
|
||||
fn test_ironclaw_base_dir_env_override() {
|
||||
// This test verifies that when IRONCLAW_BASE_DIR is set,
|
||||
// the custom path is used. Must run before LazyLock is initialized.
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::set_var("IRONCLAW_BASE_DIR", "/custom/ironclaw/path") };
|
||||
@@ -1089,7 +1076,7 @@ INJECTED="pwned"#;
|
||||
fn test_compute_base_dir_env_path_join() {
|
||||
// Verifies that ironclaw_env_path correctly joins .env to the base dir.
|
||||
// Uses compute_ironclaw_base_dir directly to avoid LazyLock caching.
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::set_var("IRONCLAW_BASE_DIR", "/my/custom/dir") };
|
||||
@@ -1111,7 +1098,7 @@ INJECTED="pwned"#;
|
||||
#[test]
|
||||
fn test_ironclaw_base_dir_empty_env() {
|
||||
// Verifies that empty IRONCLAW_BASE_DIR falls back to default.
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::set_var("IRONCLAW_BASE_DIR", "") };
|
||||
@@ -1133,7 +1120,7 @@ INJECTED="pwned"#;
|
||||
#[test]
|
||||
fn test_ironclaw_base_dir_special_chars() {
|
||||
// Verifies that paths with special characters are handled correctly.
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let old_val = std::env::var("IRONCLAW_BASE_DIR").ok();
|
||||
// SAFETY: ENV_MUTEX ensures single-threaded access to env vars in tests
|
||||
unsafe { std::env::set_var("IRONCLAW_BASE_DIR", "/tmp/test_with-special.chars") };
|
||||
|
||||
@@ -333,12 +333,6 @@ pub enum StatusUpdate {
|
||||
},
|
||||
/// Suggested follow-up messages for the user.
|
||||
Suggestions { suggestions: Vec<String> },
|
||||
/// Per-turn token usage and cost summary (shown as subtle metadata).
|
||||
TurnCost {
|
||||
input_tokens: u64,
|
||||
output_tokens: u64,
|
||||
cost_usd: String,
|
||||
},
|
||||
}
|
||||
|
||||
impl StatusUpdate {
|
||||
|
||||
+126
-338
@@ -20,7 +20,6 @@
|
||||
use std::borrow::Cow;
|
||||
use std::io::{self, IsTerminal, Write};
|
||||
use std::sync::Arc;
|
||||
use std::sync::Mutex;
|
||||
use std::sync::atomic::{AtomicBool, Ordering};
|
||||
|
||||
use async_trait::async_trait;
|
||||
@@ -41,7 +40,6 @@ use tokio_stream::wrappers::ReceiverStream;
|
||||
use crate::agent::truncate_for_preview;
|
||||
use crate::bootstrap::ironclaw_base_dir;
|
||||
use crate::channels::{Channel, IncomingMessage, MessageStream, OutgoingResponse, StatusUpdate};
|
||||
use crate::cli::fmt;
|
||||
use crate::error::ChannelError;
|
||||
|
||||
/// Max characters for tool result previews in the terminal.
|
||||
@@ -121,7 +119,7 @@ impl Hinter for ReplHelper {
|
||||
|
||||
impl Highlighter for ReplHelper {
|
||||
fn highlight_hint<'h>(&self, hint: &'h str) -> Cow<'h, str> {
|
||||
Cow::Owned(format!("{}{hint}{}", fmt::dim(), fmt::reset()))
|
||||
Cow::Owned(format!("\x1b[90m{hint}\x1b[0m"))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -145,207 +143,55 @@ impl ConditionalEventHandler for EscInterruptHandler {
|
||||
}
|
||||
}
|
||||
|
||||
/// Approval action chosen by the interactive selector.
|
||||
#[derive(Clone, Copy)]
|
||||
enum ApprovalAction {
|
||||
Approve,
|
||||
Always,
|
||||
Deny,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for ApprovalAction {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
match self {
|
||||
Self::Approve => write!(f, "Approve (y)"),
|
||||
Self::Always => write!(f, "Always approve (a)"),
|
||||
Self::Deny => write!(f, "Deny (n)"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl ApprovalAction {
|
||||
fn as_input(self) -> &'static str {
|
||||
match self {
|
||||
Self::Approve => "y",
|
||||
Self::Always => "a",
|
||||
Self::Deny => "n",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Interactive approval selector using crossterm raw mode.
|
||||
/// Returns the approval action string ("y", "a", or "n").
|
||||
fn run_approval_selector(allow_always: bool) -> Option<&'static str> {
|
||||
use crossterm::{
|
||||
cursor,
|
||||
event::{self, Event as CtEvent, KeyCode as CtKeyCode, KeyEventKind},
|
||||
execute,
|
||||
terminal::{self, ClearType},
|
||||
};
|
||||
|
||||
let options: Vec<ApprovalAction> = if allow_always {
|
||||
vec![
|
||||
ApprovalAction::Approve,
|
||||
ApprovalAction::Always,
|
||||
ApprovalAction::Deny,
|
||||
]
|
||||
} else {
|
||||
vec![ApprovalAction::Approve, ApprovalAction::Deny]
|
||||
};
|
||||
|
||||
let num = options.len();
|
||||
let mut sel: usize = 0;
|
||||
// Total lines: options + hint line
|
||||
let total_lines = (num + 1) as u16;
|
||||
|
||||
let render = |sel: usize| {
|
||||
let mut w = io::stderr();
|
||||
let pipe = format!("{}│{}", fmt::accent(), fmt::reset());
|
||||
for (i, opt) in options.iter().enumerate() {
|
||||
if i == sel {
|
||||
let _ = write!(w, " {pipe} {}● {opt}{}\r\n", fmt::bold(), fmt::reset());
|
||||
} else {
|
||||
let _ = write!(w, " {pipe} {}○ {opt}{}\r\n", fmt::dim(), fmt::reset());
|
||||
}
|
||||
}
|
||||
let _ = write!(
|
||||
w,
|
||||
" {}└{} {}↑↓ enter to select{}\r\n",
|
||||
fmt::accent(),
|
||||
fmt::reset(),
|
||||
fmt::dim(),
|
||||
fmt::reset()
|
||||
);
|
||||
let _ = w.flush();
|
||||
};
|
||||
|
||||
let _ = terminal::enable_raw_mode();
|
||||
render(sel);
|
||||
|
||||
let result = loop {
|
||||
let Ok(evt) = event::read() else { break None };
|
||||
if let CtEvent::Key(key) = evt {
|
||||
if key.kind != KeyEventKind::Press {
|
||||
continue;
|
||||
}
|
||||
match key.code {
|
||||
CtKeyCode::Up | CtKeyCode::Char('k') => {
|
||||
sel = if sel == 0 { num - 1 } else { sel - 1 };
|
||||
}
|
||||
CtKeyCode::Down | CtKeyCode::Char('j') => {
|
||||
sel = (sel + 1) % num;
|
||||
}
|
||||
CtKeyCode::Enter => break Some(options[sel].as_input()),
|
||||
CtKeyCode::Char('y') | CtKeyCode::Char('Y') => break Some("y"),
|
||||
CtKeyCode::Char('a') | CtKeyCode::Char('A') if allow_always => break Some("a"),
|
||||
CtKeyCode::Char('n') | CtKeyCode::Char('N') => break Some("n"),
|
||||
CtKeyCode::Esc => break None,
|
||||
_ => continue,
|
||||
}
|
||||
// Redraw: move up, clear, render
|
||||
let mut w = io::stderr();
|
||||
let _ = execute!(w, cursor::MoveUp(total_lines));
|
||||
let _ = execute!(w, terminal::Clear(ClearType::FromCursorDown));
|
||||
render(sel);
|
||||
}
|
||||
};
|
||||
|
||||
let _ = terminal::disable_raw_mode();
|
||||
|
||||
// Overwrite selector with the confirmed choice
|
||||
let mut w = io::stderr();
|
||||
let _ = execute!(w, cursor::MoveUp(total_lines));
|
||||
let _ = execute!(w, terminal::Clear(ClearType::FromCursorDown));
|
||||
let (label, color) = if let Some(action) = result {
|
||||
let l = options
|
||||
.iter()
|
||||
.find(|o| o.as_input() == action)
|
||||
.unwrap_or(&options[0]);
|
||||
let c = if action == "n" {
|
||||
fmt::error()
|
||||
} else {
|
||||
fmt::success()
|
||||
};
|
||||
(l.to_string(), c)
|
||||
} else {
|
||||
(ApprovalAction::Deny.to_string(), fmt::error())
|
||||
};
|
||||
let _ = writeln!(
|
||||
w,
|
||||
" {}└{} {color}● {label}{}",
|
||||
fmt::accent(),
|
||||
fmt::reset(),
|
||||
fmt::reset()
|
||||
);
|
||||
|
||||
result
|
||||
}
|
||||
|
||||
/// Build a termimad skin with our color scheme.
|
||||
fn make_skin() -> MadSkin {
|
||||
let mut skin = MadSkin::default();
|
||||
skin.set_headers_fg(crossterm::style::Color::Yellow);
|
||||
skin.bold.set_fg(crossterm::style::Color::White);
|
||||
skin.italic.set_fg(crossterm::style::Color::Magenta);
|
||||
skin.inline_code.set_fg(crossterm::style::Color::Green);
|
||||
skin.code_block.set_fg(crossterm::style::Color::Green);
|
||||
skin.set_headers_fg(termimad::crossterm::style::Color::Yellow);
|
||||
skin.bold.set_fg(termimad::crossterm::style::Color::White);
|
||||
skin.italic
|
||||
.set_fg(termimad::crossterm::style::Color::Magenta);
|
||||
skin.inline_code
|
||||
.set_fg(termimad::crossterm::style::Color::Green);
|
||||
skin.code_block
|
||||
.set_fg(termimad::crossterm::style::Color::Green);
|
||||
skin.code_block.left_margin = 2;
|
||||
skin
|
||||
}
|
||||
|
||||
/// Truncate a string to `max_chars` using character boundaries.
|
||||
///
|
||||
/// For strings longer than `max_chars`, shows the first half and last half
|
||||
/// separated by `...` so both ends are visible.
|
||||
fn smart_truncate(s: &str, max_chars: usize) -> Cow<'_, str> {
|
||||
let char_count = s.chars().count();
|
||||
if char_count <= max_chars {
|
||||
return Cow::Borrowed(s);
|
||||
}
|
||||
// Account for the 3-char "..." separator
|
||||
let budget = max_chars.saturating_sub(3);
|
||||
let head_len = budget / 2;
|
||||
let tail_len = budget - head_len;
|
||||
let head: String = s.chars().take(head_len).collect();
|
||||
let tail: String = s
|
||||
.chars()
|
||||
.skip(char_count.saturating_sub(tail_len))
|
||||
.collect();
|
||||
Cow::Owned(format!("{head}...{tail}"))
|
||||
}
|
||||
|
||||
/// Format JSON params as `key: value` lines for the approval card.
|
||||
fn format_json_params(params: &serde_json::Value, indent: &str) -> String {
|
||||
let max_val_len = fmt::term_width().saturating_sub(8);
|
||||
|
||||
match params {
|
||||
serde_json::Value::Object(map) => {
|
||||
let mut lines = Vec::new();
|
||||
for (key, value) in map {
|
||||
let val_str = match value {
|
||||
serde_json::Value::String(s) => {
|
||||
let display = smart_truncate(s, max_val_len);
|
||||
format!("{}\"{display}\"{}", fmt::success(), fmt::reset())
|
||||
let display = if s.len() > 120 { &s[..120] } else { s };
|
||||
format!("\x1b[32m\"{display}\"\x1b[0m")
|
||||
}
|
||||
other => {
|
||||
let rendered = other.to_string();
|
||||
smart_truncate(&rendered, max_val_len).into_owned()
|
||||
if rendered.len() > 120 {
|
||||
format!("{}...", &rendered[..120])
|
||||
} else {
|
||||
rendered
|
||||
}
|
||||
}
|
||||
};
|
||||
lines.push(format!(
|
||||
"{indent}{}{key}{}: {val_str}",
|
||||
fmt::accent(),
|
||||
fmt::reset()
|
||||
));
|
||||
lines.push(format!("{indent}\x1b[36m{key}\x1b[0m: {val_str}"));
|
||||
}
|
||||
lines.join("\n")
|
||||
}
|
||||
other => {
|
||||
let pretty = serde_json::to_string_pretty(other).unwrap_or_else(|_| other.to_string());
|
||||
let truncated = smart_truncate(&pretty, 300);
|
||||
let truncated = if pretty.len() > 300 {
|
||||
format!("{}...", &pretty[..300])
|
||||
} else {
|
||||
pretty
|
||||
};
|
||||
truncated
|
||||
.lines()
|
||||
.map(|l| format!("{indent}{}{l}{}", fmt::dim(), fmt::reset()))
|
||||
.map(|l| format!("{indent}\x1b[90m{l}\x1b[0m"))
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
}
|
||||
@@ -364,12 +210,6 @@ pub struct ReplChannel {
|
||||
is_streaming: Arc<AtomicBool>,
|
||||
/// When true, the one-liner startup banner is suppressed (boot screen shown instead).
|
||||
suppress_banner: Arc<AtomicBool>,
|
||||
/// Sender to inject messages into the agent loop (set after start()).
|
||||
msg_tx: Arc<Mutex<Option<mpsc::Sender<IncomingMessage>>>>,
|
||||
/// When true, the readline thread must yield stdin (approval selector or agent processing).
|
||||
stdin_locked: Arc<AtomicBool>,
|
||||
/// Number of transient status lines (Thinking) to erase on next output.
|
||||
transient_lines: std::sync::atomic::AtomicU8,
|
||||
}
|
||||
|
||||
impl ReplChannel {
|
||||
@@ -386,9 +226,6 @@ impl ReplChannel {
|
||||
debug_mode: Arc::new(AtomicBool::new(false)),
|
||||
is_streaming: Arc::new(AtomicBool::new(false)),
|
||||
suppress_banner: Arc::new(AtomicBool::new(false)),
|
||||
msg_tx: Arc::new(Mutex::new(None)),
|
||||
stdin_locked: Arc::new(AtomicBool::new(false)),
|
||||
transient_lines: std::sync::atomic::AtomicU8::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -405,9 +242,6 @@ impl ReplChannel {
|
||||
debug_mode: Arc::new(AtomicBool::new(false)),
|
||||
is_streaming: Arc::new(AtomicBool::new(false)),
|
||||
suppress_banner: Arc::new(AtomicBool::new(false)),
|
||||
msg_tx: Arc::new(Mutex::new(None)),
|
||||
stdin_locked: Arc::new(AtomicBool::new(false)),
|
||||
transient_lines: std::sync::atomic::AtomicU8::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -419,17 +253,6 @@ impl ReplChannel {
|
||||
fn is_debug(&self) -> bool {
|
||||
self.debug_mode.load(Ordering::Relaxed)
|
||||
}
|
||||
|
||||
/// Erase transient status lines (Thinking indicators) from the terminal.
|
||||
fn clear_transient(&self) {
|
||||
use crossterm::{cursor, execute, terminal};
|
||||
let n = self.transient_lines.swap(0, Ordering::Relaxed);
|
||||
if n > 0 {
|
||||
let mut stderr = io::stderr();
|
||||
let _ = execute!(stderr, cursor::MoveUp(n as u16));
|
||||
let _ = execute!(stderr, terminal::Clear(terminal::ClearType::FromCursorDown));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Default for ReplChannel {
|
||||
@@ -439,30 +262,33 @@ impl Default for ReplChannel {
|
||||
}
|
||||
|
||||
fn print_help() {
|
||||
let h = fmt::bold();
|
||||
let c = fmt::bold_accent();
|
||||
let d = fmt::dim();
|
||||
let r = fmt::reset();
|
||||
let hi = fmt::hint();
|
||||
// Bold white for section headers, bold cyan for commands, dim gray for descriptions
|
||||
let h = "\x1b[1m"; // bold (section headers)
|
||||
let c = "\x1b[1;36m"; // bold cyan (commands)
|
||||
let d = "\x1b[90m"; // dim gray (descriptions)
|
||||
let r = "\x1b[0m"; // reset
|
||||
|
||||
println!();
|
||||
println!(" {h}IronClaw REPL{r}");
|
||||
println!();
|
||||
println!(" {h}Quick start{r}");
|
||||
println!(" {c}/new{r} {hi}Start a new thread{r}");
|
||||
println!(" {c}/compact{r} {hi}Compress context window{r}");
|
||||
println!(" {c}/quit{r} {hi}Exit{r}");
|
||||
println!(" {h}Commands{r}");
|
||||
println!(" {c}/help{r} {d}show this help{r}");
|
||||
println!(" {c}/debug{r} {d}toggle verbose output{r}");
|
||||
println!(" {c}/quit{r} {c}/exit{r} {d}exit the repl{r}");
|
||||
println!();
|
||||
println!(" {h}All commands{r}");
|
||||
println!(
|
||||
" {d}Conversation{r} {c}/new{r} {c}/clear{r} {c}/compact{r} {c}/undo{r} {c}/redo{r} {c}/summarize{r} {c}/suggest{r}"
|
||||
);
|
||||
println!(" {d}Threads{r} {c}/thread{r} {c}/resume{r} {c}/list{r}");
|
||||
println!(" {d}Execution{r} {c}/interrupt{r} {d}(esc){r} {c}/cancel{r}");
|
||||
println!(
|
||||
" {d}System{r} {c}/tools{r} {c}/model{r} {c}/version{r} {c}/status{r} {c}/debug{r} {c}/heartbeat{r}"
|
||||
);
|
||||
println!(" {d}Session{r} {c}/help{r} {c}/quit{r}");
|
||||
println!(" {h}Conversation{r}");
|
||||
println!(" {c}/undo{r} {d}undo the last turn{r}");
|
||||
println!(" {c}/redo{r} {d}redo an undone turn{r}");
|
||||
println!(" {c}/clear{r} {d}clear conversation{r}");
|
||||
println!(" {c}/compact{r} {d}compact context window{r}");
|
||||
println!(" {c}/new{r} {d}new conversation thread{r}");
|
||||
println!(" {c}/interrupt{r} {d}stop current operation{r}");
|
||||
println!(" {c}esc{r} {d}stop current operation{r}");
|
||||
println!();
|
||||
println!(" {h}Approval responses{r}");
|
||||
println!(" {c}yes{r} ({c}y{r}) {d}approve tool execution{r}");
|
||||
println!(" {c}no{r} ({c}n{r}) {d}deny tool execution{r}");
|
||||
println!(" {c}always{r} ({c}a{r}) {d}approve for this session{r}");
|
||||
println!();
|
||||
}
|
||||
|
||||
@@ -479,15 +305,10 @@ impl Channel for ReplChannel {
|
||||
|
||||
async fn start(&self) -> Result<MessageStream, ChannelError> {
|
||||
let (tx, rx) = mpsc::channel(32);
|
||||
// Store tx so send_status can inject approval responses directly
|
||||
if let Ok(mut guard) = self.msg_tx.lock() {
|
||||
*guard = Some(tx.clone());
|
||||
}
|
||||
let single_message = self.single_message.clone();
|
||||
let user_id = self.user_id.clone();
|
||||
let debug_mode = Arc::clone(&self.debug_mode);
|
||||
let suppress_banner = Arc::clone(&self.suppress_banner);
|
||||
let stdin_locked = Arc::clone(&self.stdin_locked);
|
||||
let esc_interrupt_triggered_for_thread = Arc::new(AtomicBool::new(false));
|
||||
|
||||
std::thread::spawn(move || {
|
||||
@@ -536,33 +357,18 @@ impl Channel for ReplChannel {
|
||||
let _ = rl.load_history(&hist_path);
|
||||
|
||||
if !suppress_banner.load(Ordering::Relaxed) {
|
||||
println!(
|
||||
"{}IronClaw{} /help for commands, /quit to exit",
|
||||
fmt::bold(),
|
||||
fmt::reset()
|
||||
);
|
||||
println!("\x1b[1mIronClaw\x1b[0m /help for commands, /quit to exit");
|
||||
println!();
|
||||
}
|
||||
|
||||
loop {
|
||||
// Yield stdin while approval selector or agent processing locks it
|
||||
while stdin_locked.load(Ordering::Relaxed) {
|
||||
std::thread::sleep(std::time::Duration::from_millis(50));
|
||||
}
|
||||
|
||||
let prompt = if debug_mode.load(Ordering::Relaxed) {
|
||||
format!(
|
||||
"{}[debug]{} {}\u{203A}{} ",
|
||||
fmt::warning(),
|
||||
fmt::reset(),
|
||||
fmt::bold_accent(),
|
||||
fmt::reset()
|
||||
)
|
||||
"\x1b[33m[debug]\x1b[0m \x1b[1;36m\u{203A}\x1b[0m "
|
||||
} else {
|
||||
format!("{}\u{203A}{} ", fmt::bold_accent(), fmt::reset())
|
||||
"\x1b[1;36m\u{203A}\x1b[0m "
|
||||
};
|
||||
|
||||
match rl.readline(&prompt) {
|
||||
match rl.readline(prompt) {
|
||||
Ok(line) => {
|
||||
let line = line.trim();
|
||||
if line.is_empty() {
|
||||
@@ -588,9 +394,9 @@ impl Channel for ReplChannel {
|
||||
let current = debug_mode.load(Ordering::Relaxed);
|
||||
debug_mode.store(!current, Ordering::Relaxed);
|
||||
if !current {
|
||||
println!("{}debug mode on{}", fmt::dim(), fmt::reset());
|
||||
println!("\x1b[90mdebug mode on\x1b[0m");
|
||||
} else {
|
||||
println!("{}debug mode off{}", fmt::dim(), fmt::reset());
|
||||
println!("\x1b[90mdebug mode off\x1b[0m");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
@@ -599,11 +405,7 @@ impl Channel for ReplChannel {
|
||||
|
||||
let msg =
|
||||
IncomingMessage::new("repl", &user_id, line).with_timezone(&sys_tz);
|
||||
// Lock stdin before sending so readline doesn't restart
|
||||
// while the agent is processing (approval selector needs stdin)
|
||||
stdin_locked.store(true, Ordering::Relaxed);
|
||||
if tx.blocking_send(msg).is_err() {
|
||||
stdin_locked.store(false, Ordering::Relaxed);
|
||||
break;
|
||||
}
|
||||
}
|
||||
@@ -654,23 +456,21 @@ impl Channel for ReplChannel {
|
||||
_msg: &IncomingMessage,
|
||||
response: OutgoingResponse,
|
||||
) -> Result<(), ChannelError> {
|
||||
let width = fmt::term_width();
|
||||
let width = crossterm::terminal::size()
|
||||
.map(|(w, _)| w as usize)
|
||||
.unwrap_or(80);
|
||||
|
||||
// If we were streaming, the content was already printed via StreamChunk.
|
||||
// Just finish the line and reset.
|
||||
if self.is_streaming.swap(false, Ordering::Relaxed) {
|
||||
println!();
|
||||
println!();
|
||||
self.stdin_locked.store(false, Ordering::Relaxed);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
// Clear any leftover thinking indicators
|
||||
self.clear_transient();
|
||||
|
||||
// Dim separator line before the response
|
||||
let sep_width = width.min(80);
|
||||
eprintln!("{}", fmt::separator(sep_width));
|
||||
eprintln!("\x1b[90m{}\x1b[0m", "\u{2500}".repeat(sep_width));
|
||||
|
||||
// Render markdown
|
||||
let skin = make_skin();
|
||||
@@ -678,8 +478,6 @@ impl Channel for ReplChannel {
|
||||
|
||||
print!("{text}");
|
||||
println!();
|
||||
// Unlock stdin so readline can resume
|
||||
self.stdin_locked.store(false, Ordering::Relaxed);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
@@ -692,34 +490,31 @@ impl Channel for ReplChannel {
|
||||
|
||||
match status {
|
||||
StatusUpdate::Thinking(msg) => {
|
||||
self.clear_transient();
|
||||
let display = truncate_for_preview(&msg, CLI_STATUS_MAX);
|
||||
eprintln!(" {}\u{25CB} {display}{}", fmt::dim(), fmt::reset());
|
||||
self.transient_lines.store(1, Ordering::Relaxed);
|
||||
eprintln!(" \x1b[90m\u{25CB} {display}\x1b[0m");
|
||||
}
|
||||
StatusUpdate::ToolStarted { name } => {
|
||||
self.clear_transient();
|
||||
eprintln!(" {}\u{25CB} {name}{}", fmt::dim(), fmt::reset());
|
||||
self.transient_lines.store(1, Ordering::Relaxed);
|
||||
eprintln!(" \x1b[33m\u{25CB} {name}\x1b[0m");
|
||||
}
|
||||
StatusUpdate::ToolCompleted { name, success, .. } => {
|
||||
self.clear_transient();
|
||||
if success {
|
||||
eprintln!(" {}\u{25CF} {name}{}", fmt::success(), fmt::reset());
|
||||
eprintln!(" \x1b[32m\u{25CF} {name}\x1b[0m");
|
||||
} else {
|
||||
eprintln!(" {}\u{2717} {name} (failed){}", fmt::error(), fmt::reset());
|
||||
eprintln!(" \x1b[31m\u{2717} {name} (failed)\x1b[0m");
|
||||
}
|
||||
}
|
||||
StatusUpdate::ToolResult { name: _, preview } => {
|
||||
let display = truncate_for_preview(&preview, CLI_TOOL_RESULT_MAX);
|
||||
eprintln!(" {}{display}{}", fmt::dim(), fmt::reset());
|
||||
eprintln!(" \x1b[90m{display}\x1b[0m");
|
||||
}
|
||||
StatusUpdate::StreamChunk(chunk) => {
|
||||
// Print separator on the false-to-true transition
|
||||
if !self.is_streaming.swap(true, Ordering::Relaxed) {
|
||||
self.clear_transient();
|
||||
let sep_width = fmt::term_width().min(80);
|
||||
eprintln!("{}", fmt::separator(sep_width));
|
||||
let width = crossterm::terminal::size()
|
||||
.map(|(w, _)| w as usize)
|
||||
.unwrap_or(80);
|
||||
let sep_width = width.min(80);
|
||||
eprintln!("\x1b[90m{}\x1b[0m", "\u{2500}".repeat(sep_width));
|
||||
}
|
||||
print!("{chunk}");
|
||||
let _ = io::stdout().flush();
|
||||
@@ -730,67 +525,73 @@ impl Channel for ReplChannel {
|
||||
browse_url,
|
||||
} => {
|
||||
eprintln!(
|
||||
" {}[job]{} {title} {}({job_id}){} {}{browse_url}{}",
|
||||
fmt::accent(),
|
||||
fmt::reset(),
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::link(),
|
||||
fmt::reset()
|
||||
" \x1b[36m[job]\x1b[0m {title} \x1b[90m({job_id})\x1b[0m \x1b[4m{browse_url}\x1b[0m"
|
||||
);
|
||||
}
|
||||
StatusUpdate::Status(msg) => {
|
||||
if debug || msg.contains("approval") || msg.contains("Approval") {
|
||||
let display = truncate_for_preview(&msg, CLI_STATUS_MAX);
|
||||
eprintln!(" {}{display}{}", fmt::dim(), fmt::reset());
|
||||
eprintln!(" \x1b[90m{display}\x1b[0m");
|
||||
}
|
||||
}
|
||||
StatusUpdate::ApprovalNeeded {
|
||||
request_id: _,
|
||||
request_id,
|
||||
tool_name,
|
||||
description: _,
|
||||
description,
|
||||
parameters,
|
||||
allow_always,
|
||||
} => {
|
||||
self.clear_transient();
|
||||
let pipe = format!("{}│{}", fmt::accent(), fmt::reset());
|
||||
let term_width = crossterm::terminal::size()
|
||||
.map(|(w, _)| w as usize)
|
||||
.unwrap_or(80);
|
||||
let box_width = (term_width.saturating_sub(4)).clamp(40, 60);
|
||||
|
||||
// Header: ◆ tool requires approval
|
||||
eprintln!();
|
||||
eprintln!(
|
||||
" {}\u{25C6} {}{tool_name}{} requires approval",
|
||||
fmt::accent(),
|
||||
fmt::bold(),
|
||||
fmt::reset()
|
||||
// Short request ID for the bottom border
|
||||
let short_id = if request_id.len() > 8 {
|
||||
&request_id[..8]
|
||||
} else {
|
||||
&request_id
|
||||
};
|
||||
|
||||
// Top border: ┌ tool_name requires approval ───
|
||||
let top_label = format!(" {tool_name} requires approval ");
|
||||
let top_fill = box_width.saturating_sub(top_label.len() + 1);
|
||||
let top_border = format!(
|
||||
"\u{250C}\x1b[33m{top_label}\x1b[0m{}",
|
||||
"\u{2500}".repeat(top_fill)
|
||||
);
|
||||
|
||||
// Params: │ key value
|
||||
let param_lines = format_json_params(¶meters, &format!(" {pipe} "));
|
||||
if !param_lines.is_empty() {
|
||||
eprintln!(" {pipe}");
|
||||
for line in param_lines.lines() {
|
||||
eprintln!("{line}");
|
||||
}
|
||||
// Bottom border: └─ short_id ─────
|
||||
let bot_label = format!(" {short_id} ");
|
||||
let bot_fill = box_width.saturating_sub(bot_label.len() + 2);
|
||||
let bot_border = format!(
|
||||
"\u{2514}\u{2500}\x1b[90m{bot_label}\x1b[0m{}",
|
||||
"\u{2500}".repeat(bot_fill)
|
||||
);
|
||||
|
||||
eprintln!();
|
||||
eprintln!(" {top_border}");
|
||||
eprintln!(" \u{2502} \x1b[90m{description}\x1b[0m");
|
||||
eprintln!(" \u{2502}");
|
||||
|
||||
// Params
|
||||
let param_lines = format_json_params(¶meters, " \u{2502} ");
|
||||
// The format_json_params already includes the indent prefix
|
||||
// but we need to handle the case where each line already starts with it
|
||||
for line in param_lines.lines() {
|
||||
eprintln!("{line}");
|
||||
}
|
||||
eprintln!(" {pipe}");
|
||||
// Run interactive selector directly from send_status
|
||||
// stdin is already locked by Thinking/ToolStarted, so the
|
||||
// readline thread is not competing for stdin.
|
||||
let msg_tx = Arc::clone(&self.msg_tx);
|
||||
let user_id = self.user_id.clone();
|
||||
let lock_flag = Arc::clone(&self.stdin_locked);
|
||||
tokio::task::spawn_blocking(move || {
|
||||
let action = run_approval_selector(allow_always).unwrap_or("n");
|
||||
// Unlock stdin so readline can resume after approval
|
||||
lock_flag.store(false, Ordering::Relaxed);
|
||||
let Ok(guard) = msg_tx.lock() else {
|
||||
return;
|
||||
};
|
||||
if let Some(tx) = guard.as_ref() {
|
||||
let msg = IncomingMessage::new("repl", &user_id, action);
|
||||
let _ = tx.blocking_send(msg);
|
||||
}
|
||||
});
|
||||
|
||||
eprintln!(" \u{2502}");
|
||||
if allow_always {
|
||||
eprintln!(
|
||||
" \u{2502} \x1b[32myes\x1b[0m (y) / \x1b[34malways\x1b[0m (a) / \x1b[31mno\x1b[0m (n)"
|
||||
);
|
||||
} else {
|
||||
eprintln!(" \u{2502} \x1b[32myes\x1b[0m (y) / \x1b[31mno\x1b[0m (n)");
|
||||
}
|
||||
eprintln!(" {bot_border}");
|
||||
eprintln!();
|
||||
}
|
||||
StatusUpdate::AuthRequired {
|
||||
extension_name,
|
||||
@@ -799,16 +600,12 @@ impl Channel for ReplChannel {
|
||||
..
|
||||
} => {
|
||||
eprintln!();
|
||||
eprintln!(
|
||||
"{} Authentication required for {extension_name}{}",
|
||||
fmt::warning(),
|
||||
fmt::reset()
|
||||
);
|
||||
eprintln!("\x1b[33m Authentication required for {extension_name}\x1b[0m");
|
||||
if let Some(ref instr) = instructions {
|
||||
eprintln!(" {instr}");
|
||||
}
|
||||
if let Some(ref url) = setup_url {
|
||||
eprintln!(" {}{url}{}", fmt::link(), fmt::reset());
|
||||
eprintln!(" \x1b[4m{url}\x1b[0m");
|
||||
}
|
||||
eprintln!();
|
||||
}
|
||||
@@ -818,32 +615,21 @@ impl Channel for ReplChannel {
|
||||
message,
|
||||
} => {
|
||||
if success {
|
||||
eprintln!(
|
||||
"{} {extension_name}: {message}{}",
|
||||
fmt::success(),
|
||||
fmt::reset()
|
||||
);
|
||||
eprintln!("\x1b[32m {extension_name}: {message}\x1b[0m");
|
||||
} else {
|
||||
eprintln!(
|
||||
"{} {extension_name}: {message}{}",
|
||||
fmt::error(),
|
||||
fmt::reset()
|
||||
);
|
||||
eprintln!("\x1b[31m {extension_name}: {message}\x1b[0m");
|
||||
}
|
||||
}
|
||||
StatusUpdate::ImageGenerated { path, .. } => {
|
||||
if let Some(ref p) = path {
|
||||
eprintln!("{} [image] {p}{}", fmt::accent(), fmt::reset());
|
||||
eprintln!("\x1b[36m [image] {p}\x1b[0m");
|
||||
} else {
|
||||
eprintln!("{} [image generated]{}", fmt::accent(), fmt::reset());
|
||||
eprintln!("\x1b[36m [image generated]\x1b[0m");
|
||||
}
|
||||
}
|
||||
StatusUpdate::Suggestions { .. } => {
|
||||
// Suggestions are only rendered by the web gateway
|
||||
}
|
||||
StatusUpdate::TurnCost { .. } => {
|
||||
// Cost display is handled by the TUI channel
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -854,9 +640,11 @@ impl Channel for ReplChannel {
|
||||
response: OutgoingResponse,
|
||||
) -> Result<(), ChannelError> {
|
||||
let skin = make_skin();
|
||||
let width = fmt::term_width();
|
||||
let width = crossterm::terminal::size()
|
||||
.map(|(w, _)| w as usize)
|
||||
.unwrap_or(80);
|
||||
|
||||
eprintln!("{}\u{25CF}{} notification", fmt::accent(), fmt::reset());
|
||||
eprintln!("\x1b[34m\u{25CF}\x1b[0m notification");
|
||||
let text = termimad::FmtText::from(&skin, &response.content, Some(width));
|
||||
eprint!("{text}");
|
||||
eprintln!();
|
||||
|
||||
@@ -117,7 +117,7 @@ async fn register_channel(
|
||||
wasm_router: &Arc<WasmChannelRouter>,
|
||||
) -> (String, Box<dyn crate::channels::Channel>) {
|
||||
let channel_name = loaded.name().to_string();
|
||||
tracing::debug!("Loaded WASM channel: {}", channel_name);
|
||||
tracing::info!("Loaded WASM channel: {}", channel_name);
|
||||
let owner_actor_id = config
|
||||
.channels
|
||||
.wasm_channel_owner_ids
|
||||
|
||||
@@ -3059,8 +3059,8 @@ fn status_to_wit(
|
||||
},
|
||||
metadata_json,
|
||||
},
|
||||
// Suggestions and turn cost are web-gateway-only; skip for WASM channels
|
||||
StatusUpdate::Suggestions { .. } | StatusUpdate::TurnCost { .. } => return None,
|
||||
// Suggestions are web-gateway-only; skip for WASM channels
|
||||
StatusUpdate::Suggestions { .. } => return None,
|
||||
})
|
||||
}
|
||||
|
||||
|
||||
@@ -415,16 +415,6 @@ impl Channel for GatewayChannel {
|
||||
suggestions,
|
||||
thread_id,
|
||||
},
|
||||
StatusUpdate::TurnCost {
|
||||
input_tokens,
|
||||
output_tokens,
|
||||
cost_usd,
|
||||
} => SseEvent::TurnCost {
|
||||
input_tokens,
|
||||
output_tokens,
|
||||
cost_usd,
|
||||
thread_id,
|
||||
},
|
||||
};
|
||||
|
||||
self.state.sse.broadcast(event);
|
||||
|
||||
@@ -144,7 +144,6 @@ impl SseManager {
|
||||
SseEvent::Heartbeat => "heartbeat",
|
||||
SseEvent::ImageGenerated { .. } => "image_generated",
|
||||
SseEvent::Suggestions { .. } => "suggestions",
|
||||
SseEvent::TurnCost { .. } => "turn_cost",
|
||||
SseEvent::ExtensionStatus { .. } => "extension_status",
|
||||
};
|
||||
Ok(Event::default().event(event_type).data(data))
|
||||
|
||||
+84
-582
@@ -61,16 +61,8 @@ if (mql.addEventListener) {
|
||||
mql.addListener(onSchemeChange);
|
||||
}
|
||||
|
||||
// Bind theme toggle buttons (CSP-compliant — no inline onclick).
|
||||
// Bind theme toggle button (CSP-compliant — no inline onclick).
|
||||
document.getElementById('theme-toggle').addEventListener('click', toggleTheme);
|
||||
document.getElementById('settings-theme-toggle')?.addEventListener('click', () => {
|
||||
toggleTheme();
|
||||
const btn = document.getElementById('settings-theme-toggle');
|
||||
if (btn) {
|
||||
const mode = localStorage.getItem('ironclaw-theme') || 'system';
|
||||
btn.textContent = 'Theme: ' + mode.charAt(0).toUpperCase() + mode.slice(1);
|
||||
}
|
||||
});
|
||||
|
||||
let token = '';
|
||||
let eventSource = null;
|
||||
@@ -95,19 +87,6 @@ let authFlowPending = false;
|
||||
let _ghostSuggestion = '';
|
||||
let currentSettingsSubtab = 'inference';
|
||||
|
||||
// --- Streaming Debounce State ---
|
||||
let _streamBuffer = '';
|
||||
let _streamDebounceTimer = null;
|
||||
const STREAM_DEBOUNCE_MS = 50;
|
||||
|
||||
// --- Connection Status Banner State ---
|
||||
let _connectionLostTimer = null;
|
||||
let _connectionLostAt = null;
|
||||
let _reconnectAttempts = 0;
|
||||
|
||||
// --- Send Cooldown State ---
|
||||
let _sendCooldown = false;
|
||||
|
||||
// --- Slash Commands ---
|
||||
|
||||
const SLASH_COMMANDS = [
|
||||
@@ -147,36 +126,12 @@ function authenticate() {
|
||||
return;
|
||||
}
|
||||
|
||||
// Loading state for Connect button
|
||||
const connectBtn = document.getElementById('auth-connect-btn');
|
||||
if (connectBtn) {
|
||||
connectBtn.disabled = true;
|
||||
connectBtn.textContent = 'Connecting...';
|
||||
}
|
||||
|
||||
// Test the token against the health-ish endpoint (chat/threads requires auth)
|
||||
apiFetch('/api/chat/threads')
|
||||
.then(() => {
|
||||
sessionStorage.setItem('ironclaw_token', token);
|
||||
const authScreen = document.getElementById('auth-screen');
|
||||
const app = document.getElementById('app');
|
||||
// Cross-fade: fade out auth screen, then show app
|
||||
if (authScreen) authScreen.style.opacity = '0';
|
||||
// Show app container (invisible — opacity:0 in CSS) so layout computes
|
||||
app.style.display = 'flex';
|
||||
// Position tab indicator instantly (no transition) before fade-in
|
||||
const indicator = document.getElementById('tab-indicator');
|
||||
if (indicator) indicator.style.transition = 'none';
|
||||
updateTabIndicator();
|
||||
// Force layout so the instant position is applied, then restore transition
|
||||
if (indicator) {
|
||||
void indicator.offsetLeft;
|
||||
indicator.style.transition = '';
|
||||
}
|
||||
// Now fade in
|
||||
app.classList.add('visible');
|
||||
// Hide auth screen after fade-out transition completes
|
||||
setTimeout(() => { if (authScreen) authScreen.style.display = 'none'; }, 300);
|
||||
document.getElementById('auth-screen').style.display = 'none';
|
||||
document.getElementById('app').style.display = 'flex';
|
||||
// Strip token and log_level from URL so they're not visible in the address bar
|
||||
const cleaned = new URL(window.location);
|
||||
const urlLogLevel = cleaned.searchParams.get('log_level');
|
||||
@@ -200,14 +155,8 @@ function authenticate() {
|
||||
.catch(() => {
|
||||
sessionStorage.removeItem('ironclaw_token');
|
||||
document.getElementById('auth-screen').style.display = '';
|
||||
document.getElementById('auth-screen').style.opacity = '';
|
||||
document.getElementById('app').style.display = 'none';
|
||||
document.getElementById('auth-error').textContent = I18n.t('auth.errorInvalid');
|
||||
// Reset Connect button on error
|
||||
if (connectBtn) {
|
||||
connectBtn.disabled = false;
|
||||
connectBtn.textContent = 'Connect';
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
@@ -215,8 +164,29 @@ document.getElementById('token-input').addEventListener('keydown', (e) => {
|
||||
if (e.key === 'Enter') authenticate();
|
||||
});
|
||||
|
||||
// Note: main event listener registration is at the bottom of this file (search
|
||||
// "Event Listener Registration"). Do NOT add duplicate listeners here.
|
||||
// --- Static element event bindings (CSP-compliant, no inline handlers) ---
|
||||
document.getElementById('auth-connect-btn').addEventListener('click', () => authenticate());
|
||||
document.getElementById('restart-overlay').addEventListener('click', () => cancelRestart());
|
||||
document.getElementById('restart-close-btn').addEventListener('click', () => cancelRestart());
|
||||
document.getElementById('restart-cancel-btn').addEventListener('click', () => cancelRestart());
|
||||
document.getElementById('restart-confirm-btn').addEventListener('click', () => confirmRestart());
|
||||
document.getElementById('language-btn').addEventListener('click', () => toggleLanguageMenu());
|
||||
// Language option clicks handled by delegated data-action="switch-language" handler.
|
||||
document.getElementById('restart-btn').addEventListener('click', () => triggerRestart());
|
||||
document.getElementById('thread-new-btn').addEventListener('click', () => createNewThread());
|
||||
document.getElementById('thread-toggle-btn').addEventListener('click', () => toggleThreadSidebar());
|
||||
document.getElementById('assistant-thread').addEventListener('click', () => switchToAssistant());
|
||||
document.getElementById('send-btn').addEventListener('click', () => sendMessage());
|
||||
document.getElementById('memory-edit-btn').addEventListener('click', () => startMemoryEdit());
|
||||
document.getElementById('memory-save-btn').addEventListener('click', () => saveMemoryEdit());
|
||||
document.getElementById('memory-cancel-btn').addEventListener('click', () => cancelMemoryEdit());
|
||||
document.getElementById('logs-server-level').addEventListener('change', function() { setServerLogLevel(this.value); });
|
||||
document.getElementById('logs-pause-btn').addEventListener('click', () => toggleLogsPause());
|
||||
document.getElementById('logs-clear-btn').addEventListener('click', () => clearLogs());
|
||||
document.getElementById('wasm-install-btn').addEventListener('click', () => installWasmExtension());
|
||||
document.getElementById('mcp-add-btn').addEventListener('click', () => addMcpServer());
|
||||
document.getElementById('skill-search-btn').addEventListener('click', () => searchClawHub());
|
||||
document.getElementById('skill-install-btn').addEventListener('click', () => installSkillFromForm());
|
||||
|
||||
// Auto-authenticate from URL param or saved session
|
||||
(function autoAuth() {
|
||||
@@ -251,9 +221,7 @@ function apiFetch(path, options) {
|
||||
return fetch(path, opts).then((res) => {
|
||||
if (!res.ok) {
|
||||
return res.text().then(function(body) {
|
||||
const err = new Error(body || (res.status + ' ' + res.statusText));
|
||||
err.status = res.status;
|
||||
throw err;
|
||||
throw new Error(body || (res.status + ' ' + res.statusText));
|
||||
});
|
||||
}
|
||||
if (res.status === 204) return null;
|
||||
@@ -359,25 +327,6 @@ function connectSSE() {
|
||||
eventSource.onopen = () => {
|
||||
document.getElementById('sse-dot').classList.remove('disconnected');
|
||||
document.getElementById('sse-status').textContent = I18n.t('status.connected');
|
||||
_reconnectAttempts = 0;
|
||||
|
||||
// Dismiss connection-lost banner and show reconnected flash
|
||||
if (_connectionLostTimer) {
|
||||
clearTimeout(_connectionLostTimer);
|
||||
_connectionLostTimer = null;
|
||||
}
|
||||
const lostBanner = document.getElementById('connection-banner');
|
||||
if (lostBanner) {
|
||||
const wasDisconnectedLong = _connectionLostAt && (Date.now() - _connectionLostAt > 10000);
|
||||
lostBanner.textContent = 'Reconnected';
|
||||
lostBanner.className = 'connection-banner connection-banner-success';
|
||||
setTimeout(() => { lostBanner.remove(); }, 2000);
|
||||
_connectionLostAt = null;
|
||||
// If disconnected >10s, reload chat history to catch missed messages
|
||||
if (wasDisconnectedLong && currentThreadId) {
|
||||
loadHistory();
|
||||
}
|
||||
}
|
||||
|
||||
// If we were restarting, close the modal and reset button now that server is back
|
||||
if (isRestarting) {
|
||||
@@ -398,28 +347,8 @@ function connectSSE() {
|
||||
};
|
||||
|
||||
eventSource.onerror = () => {
|
||||
_reconnectAttempts++;
|
||||
document.getElementById('sse-dot').classList.add('disconnected');
|
||||
document.getElementById('sse-status').textContent = I18n.t('status.reconnecting');
|
||||
|
||||
// Update existing banner with attempt count
|
||||
const existingBanner = document.getElementById('connection-banner');
|
||||
if (existingBanner && existingBanner.classList.contains('connection-banner-warning')) {
|
||||
existingBanner.textContent = 'Connection lost. Reconnecting... (attempt ' + _reconnectAttempts + ')';
|
||||
}
|
||||
|
||||
// Start connection-lost banner timer (3s delay)
|
||||
if (!_connectionLostTimer && !existingBanner) {
|
||||
_connectionLostAt = _connectionLostAt || Date.now();
|
||||
_connectionLostTimer = setTimeout(() => {
|
||||
_connectionLostTimer = null;
|
||||
// Only show if still disconnected
|
||||
const dot = document.getElementById('sse-dot');
|
||||
if (dot?.classList.contains('disconnected')) {
|
||||
showConnectionBanner('Connection lost. Reconnecting... (attempt ' + _reconnectAttempts + ')', 'warning');
|
||||
}
|
||||
}, 3000);
|
||||
}
|
||||
};
|
||||
|
||||
eventSource.addEventListener('response', (e) => {
|
||||
@@ -431,19 +360,6 @@ function connectSSE() {
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Flush any remaining streaming buffer
|
||||
if (_streamDebounceTimer) {
|
||||
clearInterval(_streamDebounceTimer);
|
||||
_streamDebounceTimer = null;
|
||||
}
|
||||
if (_streamBuffer) {
|
||||
appendToLastAssistant(_streamBuffer);
|
||||
_streamBuffer = '';
|
||||
}
|
||||
// Remove streaming attribute from active assistant message
|
||||
const streamingMsg = document.querySelector('.message.assistant[data-streaming="true"]');
|
||||
if (streamingMsg) streamingMsg.removeAttribute('data-streaming');
|
||||
|
||||
finalizeActivityGroup();
|
||||
addMessage('assistant', data.content);
|
||||
enableChatInput();
|
||||
@@ -501,31 +417,7 @@ function connectSSE() {
|
||||
const data = JSON.parse(e.data);
|
||||
if (!isCurrentThread(data.thread_id)) return;
|
||||
finalizeActivityGroup();
|
||||
|
||||
// Mark the active assistant message as streaming
|
||||
const container = document.getElementById('chat-messages');
|
||||
let lastAssistant = container.querySelector('.message.assistant:last-of-type');
|
||||
if (!lastAssistant) {
|
||||
addMessage('assistant', '');
|
||||
lastAssistant = container.querySelector('.message.assistant:last-of-type');
|
||||
}
|
||||
if (lastAssistant) lastAssistant.setAttribute('data-streaming', 'true');
|
||||
|
||||
// Accumulate chunks and debounce rendering at 50ms intervals
|
||||
_streamBuffer += data.content;
|
||||
// Force flush when buffer exceeds 10K chars to prevent memory buildup
|
||||
if (_streamBuffer.length > 10000) {
|
||||
appendToLastAssistant(_streamBuffer);
|
||||
_streamBuffer = '';
|
||||
}
|
||||
if (!_streamDebounceTimer) {
|
||||
_streamDebounceTimer = setInterval(() => {
|
||||
if (_streamBuffer) {
|
||||
appendToLastAssistant(_streamBuffer);
|
||||
_streamBuffer = '';
|
||||
}
|
||||
}, STREAM_DEBOUNCE_MS);
|
||||
}
|
||||
appendToLastAssistant(data.content);
|
||||
});
|
||||
|
||||
eventSource.addEventListener('status', (e) => {
|
||||
@@ -595,22 +487,6 @@ function connectSSE() {
|
||||
}
|
||||
});
|
||||
|
||||
eventSource.addEventListener('turn_cost', (e) => {
|
||||
const event = JSON.parse(e.data);
|
||||
if (!isCurrentThread(event.thread_id)) return;
|
||||
// Add cost badge below last assistant message
|
||||
const messages = document.querySelectorAll('.message.assistant');
|
||||
const lastMsg = messages[messages.length - 1];
|
||||
const tokens = (event.input_tokens || 0) + (event.output_tokens || 0);
|
||||
if (lastMsg && tokens > 0) {
|
||||
const badge = document.createElement('div');
|
||||
badge.className = 'turn-cost-badge';
|
||||
const cost = event.cost_usd ? ' \u00b7 ' + event.cost_usd : '';
|
||||
badge.textContent = tokens.toLocaleString() + ' tokens' + cost;
|
||||
lastMsg.appendChild(badge);
|
||||
}
|
||||
});
|
||||
|
||||
// Job event listeners (activity stream for all sandbox jobs)
|
||||
const jobEventTypes = [
|
||||
'job_message', 'job_tool_use', 'job_tool_result',
|
||||
@@ -702,7 +578,6 @@ function clearSuggestionChips() {
|
||||
|
||||
function sendMessage() {
|
||||
clearSuggestionChips();
|
||||
removeWelcomeCard();
|
||||
const input = document.getElementById('chat-input');
|
||||
if (authFlowPending) {
|
||||
showToast('Complete the auth step before sending chat messages.', 'info');
|
||||
@@ -714,11 +589,10 @@ function sendMessage() {
|
||||
console.warn('sendMessage: no thread selected, ignoring');
|
||||
return;
|
||||
}
|
||||
if (_sendCooldown) return;
|
||||
const content = input.value.trim();
|
||||
if (!content && stagedImages.length === 0) return;
|
||||
|
||||
const userMsg = addMessage('user', content || '(images attached)');
|
||||
addMessage('user', content || '(images attached)');
|
||||
input.value = '';
|
||||
autoResizeTextarea(input);
|
||||
input.focus();
|
||||
@@ -734,33 +608,7 @@ function sendMessage() {
|
||||
method: 'POST',
|
||||
body: body,
|
||||
}).catch((err) => {
|
||||
// Handle rate limiting (429)
|
||||
if (err.status === 429) {
|
||||
showToast('Rate limited. Please wait.', 'error');
|
||||
_sendCooldown = true;
|
||||
const sendBtn = document.getElementById('send-btn');
|
||||
if (sendBtn) sendBtn.disabled = true;
|
||||
setTimeout(() => {
|
||||
_sendCooldown = false;
|
||||
if (sendBtn) sendBtn.disabled = false;
|
||||
}, 2000);
|
||||
}
|
||||
// Keep the user message in DOM, add a retry link
|
||||
if (userMsg) {
|
||||
userMsg.classList.add('send-failed');
|
||||
userMsg.style.borderStyle = 'dashed';
|
||||
const retryLink = document.createElement('a');
|
||||
retryLink.className = 'retry-link';
|
||||
retryLink.href = '#';
|
||||
retryLink.textContent = 'Retry';
|
||||
retryLink.addEventListener('click', (e) => {
|
||||
e.preventDefault();
|
||||
if (userMsg.parentNode) userMsg.parentNode.removeChild(userMsg);
|
||||
input.value = content;
|
||||
sendMessage();
|
||||
});
|
||||
userMsg.appendChild(retryLink);
|
||||
}
|
||||
addMessage('system', 'Failed to send: ' + err.message);
|
||||
});
|
||||
}
|
||||
|
||||
@@ -1039,36 +887,11 @@ function copyMessage(btn) {
|
||||
});
|
||||
}
|
||||
|
||||
let _lastMessageDate = null;
|
||||
|
||||
function maybeInsertTimeSeparator(container, timestamp) {
|
||||
const date = timestamp ? new Date(timestamp) : new Date();
|
||||
const dateStr = date.toDateString();
|
||||
if (_lastMessageDate === dateStr) return;
|
||||
_lastMessageDate = dateStr;
|
||||
|
||||
const now = new Date();
|
||||
const today = now.toDateString();
|
||||
const yesterday = new Date(now.getTime() - 86400000).toDateString();
|
||||
|
||||
let label;
|
||||
if (dateStr === today) label = 'Today';
|
||||
else if (dateStr === yesterday) label = 'Yesterday';
|
||||
else label = date.toLocaleDateString(undefined, { month: 'short', day: 'numeric', year: 'numeric' });
|
||||
|
||||
const sep = document.createElement('div');
|
||||
sep.className = 'time-separator';
|
||||
sep.textContent = label;
|
||||
container.appendChild(sep);
|
||||
}
|
||||
|
||||
function addMessage(role, content) {
|
||||
const container = document.getElementById('chat-messages');
|
||||
maybeInsertTimeSeparator(container);
|
||||
const div = createMessageElement(role, content);
|
||||
container.appendChild(div);
|
||||
container.scrollTop = container.scrollHeight;
|
||||
return div;
|
||||
}
|
||||
|
||||
function appendToLastAssistant(chunk) {
|
||||
@@ -1082,14 +905,6 @@ function appendToLastAssistant(chunk) {
|
||||
const content = last.querySelector('.message-content');
|
||||
if (content) {
|
||||
content.innerHTML = renderMarkdown(raw);
|
||||
// Syntax highlighting for code blocks
|
||||
if (typeof hljs !== 'undefined') {
|
||||
requestAnimationFrame(() => {
|
||||
content.querySelectorAll('pre code').forEach(block => {
|
||||
hljs.highlightElement(block);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
container.scrollTop = container.scrollHeight;
|
||||
} else {
|
||||
@@ -1177,14 +992,16 @@ function addToolCard(name) {
|
||||
|
||||
const body = document.createElement('div');
|
||||
body.className = 'activity-tool-body';
|
||||
body.style.display = 'none';
|
||||
|
||||
const output = document.createElement('pre');
|
||||
output.className = 'activity-tool-output';
|
||||
body.appendChild(output);
|
||||
|
||||
header.addEventListener('click', () => {
|
||||
body.classList.toggle('expanded');
|
||||
chevron.classList.toggle('expanded', body.classList.contains('expanded'));
|
||||
const isOpen = body.style.display !== 'none';
|
||||
body.style.display = isOpen ? 'none' : 'block';
|
||||
chevron.classList.toggle('expanded', !isOpen);
|
||||
});
|
||||
|
||||
card.appendChild(header);
|
||||
@@ -1243,7 +1060,7 @@ function completeToolCard(name, success, error, parameters) {
|
||||
// Auto-expand so the error is immediately visible
|
||||
const body = entry.card.querySelector('.activity-tool-body');
|
||||
const chevron = entry.card.querySelector('.activity-tool-chevron');
|
||||
if (body) body.classList.add('expanded');
|
||||
if (body) body.style.display = 'block';
|
||||
if (chevron) chevron.classList.add('expanded');
|
||||
}
|
||||
}
|
||||
@@ -1730,13 +1547,6 @@ function loadHistory(before) {
|
||||
const isPaginating = !!before;
|
||||
if (isPaginating) loadingOlder = true;
|
||||
|
||||
// Show skeleton while loading (only for fresh loads)
|
||||
if (!isPaginating) {
|
||||
const chatContainer = document.getElementById('chat-messages');
|
||||
chatContainer.innerHTML = '';
|
||||
chatContainer.appendChild(renderSkeleton('message', 3));
|
||||
}
|
||||
|
||||
apiFetch(historyUrl).then((data) => {
|
||||
const container = document.getElementById('chat-messages');
|
||||
|
||||
@@ -1754,10 +1564,6 @@ function loadHistory(before) {
|
||||
addMessage('assistant', turn.response);
|
||||
}
|
||||
}
|
||||
// Show welcome card when history is empty
|
||||
if (data.turns.length === 0) {
|
||||
showWelcomeCard();
|
||||
}
|
||||
// Show processing indicator if the last turn is still in-progress
|
||||
var lastTurn = data.turns.length > 0 ? data.turns[data.turns.length - 1] : null;
|
||||
if (lastTurn && !lastTurn.response && lastTurn.state === 'Processing') {
|
||||
@@ -1804,30 +1610,6 @@ function createMessageElement(role, content) {
|
||||
const div = document.createElement('div');
|
||||
div.className = 'message ' + role;
|
||||
|
||||
const ts = document.createElement('span');
|
||||
ts.className = 'message-timestamp';
|
||||
ts.textContent = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
|
||||
div.appendChild(ts);
|
||||
|
||||
// Message content
|
||||
const contentEl = document.createElement('div');
|
||||
contentEl.className = 'message-content';
|
||||
if (role === 'user' || role === 'system') {
|
||||
contentEl.textContent = content;
|
||||
} else {
|
||||
div.setAttribute('data-raw', content);
|
||||
contentEl.innerHTML = renderMarkdown(content);
|
||||
// Syntax highlighting for code blocks
|
||||
if (typeof hljs !== 'undefined') {
|
||||
requestAnimationFrame(() => {
|
||||
contentEl.querySelectorAll('pre code').forEach(block => {
|
||||
hljs.highlightElement(block);
|
||||
});
|
||||
});
|
||||
}
|
||||
}
|
||||
div.appendChild(contentEl);
|
||||
|
||||
if (role === 'assistant' || role === 'user') {
|
||||
div.classList.add('has-copy');
|
||||
div.setAttribute('data-copy-text', content);
|
||||
@@ -1843,6 +1625,15 @@ function createMessageElement(role, content) {
|
||||
div.appendChild(copyBtn);
|
||||
}
|
||||
|
||||
const body = document.createElement('div');
|
||||
body.className = 'message-content';
|
||||
if (role === 'user' || role === 'system') {
|
||||
body.textContent = content;
|
||||
} else {
|
||||
div.setAttribute('data-raw', content);
|
||||
body.innerHTML = renderMarkdown(content);
|
||||
}
|
||||
div.appendChild(body);
|
||||
return div;
|
||||
}
|
||||
|
||||
@@ -1940,13 +1731,6 @@ function debouncedLoadThreads() {
|
||||
}
|
||||
|
||||
function loadThreads() {
|
||||
// Show skeleton while loading
|
||||
const threadListEl = document.getElementById('thread-list');
|
||||
if (threadListEl && threadListEl.children.length === 0) {
|
||||
threadListEl.innerHTML = '';
|
||||
threadListEl.appendChild(renderSkeleton('row', 4));
|
||||
}
|
||||
|
||||
apiFetch('/api/chat/threads').then((data) => {
|
||||
// Pinned assistant thread
|
||||
if (data.assistant_thread) {
|
||||
@@ -2044,11 +1828,6 @@ function switchToAssistant() {
|
||||
oldestTimestamp = null;
|
||||
loadHistory();
|
||||
loadThreads();
|
||||
if (window.innerWidth <= 768) {
|
||||
const sidebar = document.getElementById('thread-sidebar');
|
||||
sidebar.classList.remove('expanded-mobile');
|
||||
document.getElementById('thread-toggle-btn').innerHTML = '»';
|
||||
}
|
||||
}
|
||||
|
||||
function switchThread(threadId) {
|
||||
@@ -2060,18 +1839,12 @@ function switchThread(threadId) {
|
||||
oldestTimestamp = null;
|
||||
loadHistory();
|
||||
loadThreads();
|
||||
if (window.innerWidth <= 768) {
|
||||
const sidebar = document.getElementById('thread-sidebar');
|
||||
sidebar.classList.remove('expanded-mobile');
|
||||
document.getElementById('thread-toggle-btn').innerHTML = '»';
|
||||
}
|
||||
}
|
||||
|
||||
function createNewThread() {
|
||||
apiFetch('/api/chat/thread/new', { method: 'POST' }).then((data) => {
|
||||
currentThreadId = data.id || null;
|
||||
document.getElementById('chat-messages').innerHTML = '';
|
||||
showWelcomeCard();
|
||||
loadThreads();
|
||||
}).catch((err) => {
|
||||
showToast('Failed to create thread: ' + err.message, 'error');
|
||||
@@ -2080,17 +1853,9 @@ function createNewThread() {
|
||||
|
||||
function toggleThreadSidebar() {
|
||||
const sidebar = document.getElementById('thread-sidebar');
|
||||
const isMobile = window.innerWidth <= 768;
|
||||
if (isMobile) {
|
||||
sidebar.classList.toggle('expanded-mobile');
|
||||
} else {
|
||||
sidebar.classList.toggle('collapsed');
|
||||
}
|
||||
sidebar.classList.toggle('collapsed');
|
||||
const btn = document.getElementById('thread-toggle-btn');
|
||||
const isOpen = isMobile
|
||||
? sidebar.classList.contains('expanded-mobile')
|
||||
: !sidebar.classList.contains('collapsed');
|
||||
btn.innerHTML = isOpen ? '«' : '»';
|
||||
btn.innerHTML = sidebar.classList.contains('collapsed') ? '»' : '«';
|
||||
}
|
||||
|
||||
// Chat input auto-resize and keyboard handling
|
||||
@@ -2157,10 +1922,6 @@ chatInput.addEventListener('input', () => {
|
||||
ghost.style.display = 'block';
|
||||
wrapper.classList.add('has-ghost');
|
||||
}
|
||||
const sendBtn = document.getElementById('send-btn');
|
||||
if (sendBtn) {
|
||||
sendBtn.classList.toggle('active', chatInput.value.trim().length > 0);
|
||||
}
|
||||
});
|
||||
chatInput.addEventListener('blur', () => {
|
||||
// Small delay so mousedown on autocomplete item fires first
|
||||
@@ -2182,13 +1943,8 @@ document.getElementById('chat-messages').addEventListener('scroll', function ()
|
||||
});
|
||||
|
||||
function autoResizeTextarea(el) {
|
||||
const prev = el.offsetHeight;
|
||||
el.style.height = 'auto';
|
||||
const target = Math.min(el.scrollHeight, 120);
|
||||
el.style.height = prev + 'px';
|
||||
requestAnimationFrame(() => {
|
||||
el.style.height = target + 'px';
|
||||
});
|
||||
el.style.height = Math.min(el.scrollHeight, 120) + 'px';
|
||||
}
|
||||
|
||||
// --- Tabs ---
|
||||
@@ -2208,7 +1964,6 @@ function switchTab(tab) {
|
||||
document.querySelectorAll('.tab-panel').forEach((p) => {
|
||||
p.classList.toggle('active', p.id === 'tab-' + tab);
|
||||
});
|
||||
applyAriaAttributes();
|
||||
|
||||
if (tab === 'memory') loadMemoryTree();
|
||||
if (tab === 'jobs') loadJobs();
|
||||
@@ -2219,26 +1974,8 @@ function switchTab(tab) {
|
||||
} else {
|
||||
stopPairingPoll();
|
||||
}
|
||||
updateTabIndicator();
|
||||
}
|
||||
|
||||
function updateTabIndicator() {
|
||||
const indicator = document.getElementById('tab-indicator');
|
||||
if (!indicator) return;
|
||||
const activeBtn = document.querySelector('.tab-bar button[data-tab].active');
|
||||
if (!activeBtn) {
|
||||
indicator.style.width = '0';
|
||||
return;
|
||||
}
|
||||
const bar = activeBtn.closest('.tab-bar');
|
||||
const barRect = bar.getBoundingClientRect();
|
||||
const btnRect = activeBtn.getBoundingClientRect();
|
||||
indicator.style.left = (btnRect.left - barRect.left) + 'px';
|
||||
indicator.style.width = btnRect.width + 'px';
|
||||
}
|
||||
|
||||
window.addEventListener('resize', updateTabIndicator);
|
||||
|
||||
// --- Memory (filesystem tree) ---
|
||||
|
||||
let memorySearchTimeout = null;
|
||||
@@ -4957,27 +4694,13 @@ document.addEventListener('keydown', (e) => {
|
||||
return;
|
||||
}
|
||||
|
||||
// Mod+/: toggle shortcuts overlay
|
||||
if (mod && e.key === '/') {
|
||||
e.preventDefault();
|
||||
toggleShortcutsOverlay();
|
||||
return;
|
||||
}
|
||||
|
||||
// Escape: close modals, autocomplete, job detail, or blur input
|
||||
// Escape: close autocomplete, job detail, or blur input
|
||||
if (e.key === 'Escape') {
|
||||
const acEl = document.getElementById('slash-autocomplete');
|
||||
if (acEl && acEl.style.display !== 'none') {
|
||||
hideSlashAutocomplete();
|
||||
return;
|
||||
}
|
||||
// Close shortcuts overlay if open
|
||||
const shortcutsOverlay = document.getElementById('shortcuts-overlay');
|
||||
if (shortcutsOverlay?.style.display === 'flex') {
|
||||
shortcutsOverlay.style.display = 'none';
|
||||
return;
|
||||
}
|
||||
closeModals();
|
||||
if (currentJobId) {
|
||||
closeJobDetail();
|
||||
} else if (inInput) {
|
||||
@@ -5009,17 +4732,9 @@ function switchSettingsSubtab(subtab) {
|
||||
searchInput.value = '';
|
||||
searchInput.dispatchEvent(new Event('input'));
|
||||
}
|
||||
// On mobile, drill into detail view
|
||||
if (window.innerWidth <= 768) {
|
||||
document.querySelector('.settings-layout').classList.add('settings-detail-active');
|
||||
}
|
||||
loadSettingsSubtab(subtab);
|
||||
}
|
||||
|
||||
function settingsBack() {
|
||||
document.querySelector('.settings-layout').classList.remove('settings-detail-active');
|
||||
}
|
||||
|
||||
function loadSettingsSubtab(subtab) {
|
||||
if (subtab === 'inference') loadInferenceSettings();
|
||||
else if (subtab === 'agent') loadAgentSettings();
|
||||
@@ -5155,19 +4870,6 @@ function renderCardsSkeleton(count) {
|
||||
return html;
|
||||
}
|
||||
|
||||
function renderSkeleton(type, count) {
|
||||
count = count || 3;
|
||||
var container = document.createElement('div');
|
||||
container.className = 'skeleton-container';
|
||||
for (var i = 0; i < count; i++) {
|
||||
var el = document.createElement('div');
|
||||
el.className = 'skeleton-' + type;
|
||||
el.innerHTML = '<div class="skeleton-bar shimmer"></div>';
|
||||
container.appendChild(el);
|
||||
}
|
||||
return container;
|
||||
}
|
||||
|
||||
function loadInferenceSettings() {
|
||||
var container = document.getElementById('settings-inference-content');
|
||||
container.innerHTML = renderSettingsSkeleton(6);
|
||||
@@ -5186,13 +4888,11 @@ function loadInferenceSettings() {
|
||||
};
|
||||
// Inject available model IDs as suggestions for the selected_model field
|
||||
var modelIds = (modelsData.data || []).map(function(m) { return m.id; }).filter(Boolean);
|
||||
if (modelIds.length > 0) {
|
||||
var llmGroup = INFERENCE_SETTINGS[0];
|
||||
for (var i = 0; i < llmGroup.settings.length; i++) {
|
||||
if (llmGroup.settings[i].key === 'selected_model') {
|
||||
llmGroup.settings[i].suggestions = modelIds;
|
||||
break;
|
||||
}
|
||||
var llmGroup = INFERENCE_SETTINGS[0];
|
||||
for (var i = 0; i < llmGroup.settings.length; i++) {
|
||||
if (llmGroup.settings[i].key === 'selected_model') {
|
||||
llmGroup.settings[i].suggestions = modelIds;
|
||||
break;
|
||||
}
|
||||
}
|
||||
container.innerHTML = '';
|
||||
@@ -5320,30 +5020,34 @@ function renderStructuredSettingsRow(def, value, activeValue) {
|
||||
var placeholderText = activeValueText ? I18n.t('settings.envValue', { value: activeValueText }) : (def.placeholder || I18n.t('settings.envDefault'));
|
||||
|
||||
if (def.type === 'boolean') {
|
||||
var toggle = document.createElement('div');
|
||||
toggle.className = 'toggle-switch' + (value === 'true' || value === true ? ' on' : '');
|
||||
toggle.setAttribute('role', 'switch');
|
||||
toggle.setAttribute('aria-checked', value === 'true' || value === true ? 'true' : 'false');
|
||||
toggle.setAttribute('aria-label', ariaLabel);
|
||||
toggle.setAttribute('tabindex', '0');
|
||||
|
||||
var savedIndicator = document.createElement('span');
|
||||
savedIndicator.className = 'settings-saved-indicator';
|
||||
savedIndicator.textContent = I18n.t('settings.saved');
|
||||
|
||||
toggle.addEventListener('click', function() {
|
||||
var isOn = this.classList.toggle('on');
|
||||
this.setAttribute('aria-checked', isOn ? 'true' : 'false');
|
||||
saveSetting(def.key, isOn ? 'true' : 'false', savedIndicator);
|
||||
});
|
||||
toggle.addEventListener('keydown', function(e) {
|
||||
if (e.key === 'Enter' || e.key === ' ') {
|
||||
e.preventDefault();
|
||||
this.click();
|
||||
}
|
||||
});
|
||||
inputWrap.appendChild(toggle);
|
||||
inputWrap.appendChild(savedIndicator);
|
||||
var boolSel = document.createElement('select');
|
||||
boolSel.className = 'settings-select';
|
||||
boolSel.setAttribute('data-setting-key', def.key);
|
||||
boolSel.setAttribute('aria-label', ariaLabel);
|
||||
var boolDefault = document.createElement('option');
|
||||
boolDefault.value = '';
|
||||
boolDefault.textContent = activeValue !== undefined && activeValue !== null
|
||||
? '\u2014 ' + I18n.t('settings.envValue', { value: String(activeValue) }) + ' \u2014'
|
||||
: '\u2014 ' + I18n.t('settings.useEnvDefault') + ' \u2014';
|
||||
if (value === null || value === undefined) boolDefault.selected = true;
|
||||
boolSel.appendChild(boolDefault);
|
||||
var boolOn = document.createElement('option');
|
||||
boolOn.value = 'true';
|
||||
boolOn.textContent = I18n.t('settings.on');
|
||||
if (value === true) boolOn.selected = true;
|
||||
boolSel.appendChild(boolOn);
|
||||
var boolOff = document.createElement('option');
|
||||
boolOff.value = 'false';
|
||||
boolOff.textContent = I18n.t('settings.off');
|
||||
if (value === false) boolOff.selected = true;
|
||||
boolSel.appendChild(boolOff);
|
||||
boolSel.addEventListener('change', (function(k, el) {
|
||||
return function() {
|
||||
if (el.value === '') saveSetting(k, null);
|
||||
else saveSetting(k, el.value === 'true');
|
||||
};
|
||||
})(def.key, boolSel));
|
||||
inputWrap.appendChild(boolSel);
|
||||
} else if (def.type === 'select' && def.options) {
|
||||
var sel = document.createElement('select');
|
||||
sel.className = 'settings-select';
|
||||
@@ -5717,207 +5421,16 @@ function showToast(message, type) {
|
||||
const container = document.getElementById('toasts');
|
||||
const toast = document.createElement('div');
|
||||
toast.className = 'toast toast-' + (type || 'info');
|
||||
|
||||
// Icon prefix
|
||||
const icon = document.createElement('span');
|
||||
icon.className = 'toast-icon';
|
||||
if (type === 'success') icon.textContent = '\u2713';
|
||||
else if (type === 'error') icon.textContent = '\u2717';
|
||||
else icon.textContent = '\u2139';
|
||||
toast.appendChild(icon);
|
||||
|
||||
// Message text
|
||||
const text = document.createElement('span');
|
||||
text.textContent = message;
|
||||
toast.appendChild(text);
|
||||
|
||||
// Countdown bar
|
||||
const countdown = document.createElement('div');
|
||||
countdown.className = 'toast-countdown';
|
||||
toast.appendChild(countdown);
|
||||
|
||||
toast.textContent = message;
|
||||
container.appendChild(toast);
|
||||
// Trigger slide-in
|
||||
requestAnimationFrame(() => toast.classList.add('visible'));
|
||||
setTimeout(() => {
|
||||
toast.classList.add('dismissing');
|
||||
toast.addEventListener('transitionend', () => toast.remove(), { once: true });
|
||||
// Fallback removal if transitionend doesn't fire
|
||||
setTimeout(() => { if (toast.parentNode) toast.remove(); }, 500);
|
||||
toast.classList.remove('visible');
|
||||
toast.addEventListener('transitionend', () => toast.remove());
|
||||
}, 4000);
|
||||
}
|
||||
|
||||
// --- Welcome Card (Phase 4.2) ---
|
||||
|
||||
function showWelcomeCard() {
|
||||
const container = document.getElementById('chat-messages');
|
||||
if (!container || container.querySelector('.welcome-card')) return;
|
||||
const card = document.createElement('div');
|
||||
card.className = 'welcome-card';
|
||||
|
||||
const heading = document.createElement('h2');
|
||||
heading.className = 'welcome-heading';
|
||||
heading.textContent = I18n.t('welcome.heading');
|
||||
card.appendChild(heading);
|
||||
|
||||
const desc = document.createElement('p');
|
||||
desc.className = 'welcome-description';
|
||||
desc.textContent = I18n.t('welcome.description');
|
||||
card.appendChild(desc);
|
||||
|
||||
const chips = document.createElement('div');
|
||||
chips.className = 'welcome-chips';
|
||||
|
||||
const suggestions = [
|
||||
{ key: 'welcome.runTool', fallback: 'Run a tool' },
|
||||
{ key: 'welcome.checkJobs', fallback: 'Check job status' },
|
||||
{ key: 'welcome.searchMemory', fallback: 'Search memory' },
|
||||
{ key: 'welcome.manageRoutines', fallback: 'Manage routines' },
|
||||
{ key: 'welcome.systemStatus', fallback: 'System status' },
|
||||
{ key: 'welcome.writeCode', fallback: 'Write code' },
|
||||
];
|
||||
suggestions.forEach(({ key, fallback }) => {
|
||||
const chip = document.createElement('button');
|
||||
chip.className = 'welcome-chip';
|
||||
chip.textContent = I18n.t(key) || fallback;
|
||||
chip.addEventListener('click', () => sendSuggestion(chip));
|
||||
chips.appendChild(chip);
|
||||
});
|
||||
|
||||
card.appendChild(chips);
|
||||
container.appendChild(card);
|
||||
}
|
||||
|
||||
function renderEmptyState({ icon, title, hint, action }) {
|
||||
const wrapper = document.createElement('div');
|
||||
wrapper.className = 'empty-state-card';
|
||||
|
||||
if (icon) {
|
||||
const iconEl = document.createElement('div');
|
||||
iconEl.className = 'empty-state-icon';
|
||||
iconEl.textContent = icon;
|
||||
wrapper.appendChild(iconEl);
|
||||
}
|
||||
|
||||
if (title) {
|
||||
const titleEl = document.createElement('div');
|
||||
titleEl.className = 'empty-state-title';
|
||||
titleEl.textContent = title;
|
||||
wrapper.appendChild(titleEl);
|
||||
}
|
||||
|
||||
if (hint) {
|
||||
const hintEl = document.createElement('div');
|
||||
hintEl.className = 'empty-state-hint';
|
||||
hintEl.textContent = hint;
|
||||
wrapper.appendChild(hintEl);
|
||||
}
|
||||
|
||||
if (action) {
|
||||
const btn = document.createElement('button');
|
||||
btn.className = 'empty-state-action';
|
||||
btn.textContent = action.label || 'Go';
|
||||
if (action.onClick) btn.addEventListener('click', action.onClick);
|
||||
wrapper.appendChild(btn);
|
||||
}
|
||||
|
||||
return wrapper;
|
||||
}
|
||||
|
||||
function sendSuggestion(btn) {
|
||||
const textarea = document.getElementById('chat-input');
|
||||
if (textarea) {
|
||||
textarea.value = btn.textContent;
|
||||
sendMessage();
|
||||
}
|
||||
}
|
||||
|
||||
function removeWelcomeCard() {
|
||||
const card = document.querySelector('.welcome-card');
|
||||
if (card) card.remove();
|
||||
}
|
||||
|
||||
// --- Connection Status Banner (Phase 4.1) ---
|
||||
|
||||
function showConnectionBanner(message, type) {
|
||||
const existing = document.getElementById('connection-banner');
|
||||
if (existing) existing.remove();
|
||||
|
||||
const banner = document.createElement('div');
|
||||
banner.id = 'connection-banner';
|
||||
banner.className = 'connection-banner connection-banner-' + type;
|
||||
banner.textContent = message;
|
||||
document.body.appendChild(banner);
|
||||
}
|
||||
|
||||
// --- Keyboard Shortcut Helpers (Phase 7.4) ---
|
||||
|
||||
function focusMemorySearch() {
|
||||
const memSearch = document.getElementById('memory-search');
|
||||
if (memSearch) {
|
||||
if (currentTab !== 'memory') switchTab('memory');
|
||||
memSearch.focus();
|
||||
}
|
||||
}
|
||||
|
||||
function toggleShortcutsOverlay() {
|
||||
let overlay = document.getElementById('shortcuts-overlay');
|
||||
if (!overlay) {
|
||||
overlay = document.createElement('div');
|
||||
overlay.id = 'shortcuts-overlay';
|
||||
overlay.className = 'shortcuts-overlay';
|
||||
overlay.style.display = 'none';
|
||||
overlay.innerHTML =
|
||||
'<div class="shortcuts-content">'
|
||||
+ '<h3>Keyboard Shortcuts</h3>'
|
||||
+ '<div class="shortcut-row"><kbd>Ctrl/Cmd + 1-5</kbd> Switch tabs</div>'
|
||||
+ '<div class="shortcut-row"><kbd>Ctrl/Cmd + N</kbd> New thread</div>'
|
||||
+ '<div class="shortcut-row"><kbd>Ctrl/Cmd + K</kbd> Focus search/input</div>'
|
||||
+ '<div class="shortcut-row"><kbd>Ctrl/Cmd + /</kbd> Toggle this overlay</div>'
|
||||
+ '<div class="shortcut-row"><kbd>Escape</kbd> Close modals</div>'
|
||||
+ '<button class="shortcuts-close">Close</button>'
|
||||
+ '</div>';
|
||||
document.body.appendChild(overlay);
|
||||
overlay.querySelector('.shortcuts-close').addEventListener('click', () => {
|
||||
overlay.style.display = 'none';
|
||||
});
|
||||
overlay.addEventListener('click', (e) => {
|
||||
if (e.target === overlay) overlay.style.display = 'none';
|
||||
});
|
||||
}
|
||||
overlay.style.display = overlay.style.display === 'flex' ? 'none' : 'flex';
|
||||
}
|
||||
|
||||
function closeModals() {
|
||||
// Close shortcuts overlay
|
||||
const shortcutsOverlay = document.getElementById('shortcuts-overlay');
|
||||
if (shortcutsOverlay) shortcutsOverlay.style.display = 'none';
|
||||
|
||||
// Close restart confirmation modal
|
||||
const restartModal = document.getElementById('restart-confirm-modal');
|
||||
if (restartModal) restartModal.style.display = 'none';
|
||||
}
|
||||
|
||||
// --- ARIA Accessibility (Phase 5.2) ---
|
||||
|
||||
function applyAriaAttributes() {
|
||||
const tabBar = document.querySelector('.tab-bar');
|
||||
if (tabBar) tabBar.setAttribute('role', 'tablist');
|
||||
|
||||
document.querySelectorAll('.tab-bar button[data-tab]').forEach(btn => {
|
||||
btn.setAttribute('role', 'tab');
|
||||
btn.setAttribute('aria-selected', btn.classList.contains('active') ? 'true' : 'false');
|
||||
});
|
||||
|
||||
document.querySelectorAll('.tab-panel').forEach(panel => {
|
||||
panel.setAttribute('role', 'tabpanel');
|
||||
panel.setAttribute('aria-hidden', panel.classList.contains('active') ? 'false' : 'true');
|
||||
});
|
||||
}
|
||||
|
||||
// Apply ARIA attributes on initial load
|
||||
applyAriaAttributes();
|
||||
|
||||
// --- Utilities ---
|
||||
|
||||
function escapeHtml(str) {
|
||||
@@ -5956,17 +5469,6 @@ document.getElementById('skill-search-btn').addEventListener('click', () => sear
|
||||
document.getElementById('skill-install-btn').addEventListener('click', () => installSkillFromForm());
|
||||
document.getElementById('settings-export-btn').addEventListener('click', () => exportSettings());
|
||||
document.getElementById('settings-import-btn').addEventListener('click', () => importSettings());
|
||||
document.getElementById('settings-back-btn')?.addEventListener('click', () => settingsBack());
|
||||
|
||||
// --- Mobile: close thread sidebar on outside click ---
|
||||
document.addEventListener('click', function(e) {
|
||||
const sidebar = document.getElementById('thread-sidebar');
|
||||
if (sidebar && sidebar.classList.contains('expanded-mobile') &&
|
||||
!sidebar.contains(e.target)) {
|
||||
sidebar.classList.remove('expanded-mobile');
|
||||
document.getElementById('thread-toggle-btn').innerHTML = '»';
|
||||
}
|
||||
});
|
||||
|
||||
// --- Delegated Event Handlers (for dynamically generated HTML) ---
|
||||
|
||||
|
||||
@@ -521,29 +521,4 @@ I18n.register('en', {
|
||||
'channels.replDesc': 'Simple read-eval-print loop for testing',
|
||||
'channels.configureVia': 'Configure via {env}',
|
||||
'channels.runWith': 'Run with: {cmd}',
|
||||
|
||||
// Welcome Card
|
||||
'welcome.heading': 'What can I help you with?',
|
||||
'welcome.description': 'IronClaw is your secure AI assistant. Choose a suggestion below or type your own message.',
|
||||
'welcome.runTool': 'Run a tool',
|
||||
'welcome.checkJobs': 'Check job status',
|
||||
'welcome.searchMemory': 'Search memory',
|
||||
'welcome.manageRoutines': 'Manage routines',
|
||||
'welcome.systemStatus': 'System status',
|
||||
'welcome.writeCode': 'Write code',
|
||||
|
||||
// Connection
|
||||
'connection.disconnected': 'Disconnected — attempting to reconnect',
|
||||
'connection.reconnecting': 'Reconnecting (attempt {count})...',
|
||||
'connection.reconnected': 'Reconnected',
|
||||
|
||||
// Messages
|
||||
'message.you': 'You',
|
||||
'message.assistant': 'IronClaw',
|
||||
'message.system': 'System',
|
||||
'message.copy': 'Copy',
|
||||
'message.copied': 'Copied!',
|
||||
|
||||
// Approval
|
||||
'approval.pressY': 'Press Y to approve, N to deny',
|
||||
});
|
||||
|
||||
@@ -520,29 +520,4 @@ I18n.register('zh-CN', {
|
||||
'channels.replDesc': '用于测试的简单读取-求值-打印循环',
|
||||
'channels.configureVia': '通过 {env} 配置',
|
||||
'channels.runWith': '运行命令: {cmd}',
|
||||
|
||||
// Welcome Card
|
||||
'welcome.heading': '有什么可以帮助您的？',
|
||||
'welcome.description': 'IronClaw 是您的安全 AI 助手。选择下方的建议或输入您自己的消息。',
|
||||
'welcome.runTool': '运行工具',
|
||||
'welcome.checkJobs': '查看任务状态',
|
||||
'welcome.searchMemory': '搜索记忆',
|
||||
'welcome.manageRoutines': '管理例程',
|
||||
'welcome.systemStatus': '系统状态',
|
||||
'welcome.writeCode': '编写代码',
|
||||
|
||||
// Connection
|
||||
'connection.disconnected': '已断开连接 — 正在尝试重新连接',
|
||||
'connection.reconnecting': '正在重新连接（第 {count} 次尝试）...',
|
||||
'connection.reconnected': '已重新连接',
|
||||
|
||||
// Messages
|
||||
'message.you': '你',
|
||||
'message.assistant': 'IronClaw',
|
||||
'message.system': '系统',
|
||||
'message.copy': '复制',
|
||||
'message.copied': '已复制！',
|
||||
|
||||
// Approval
|
||||
'approval.pressY': '按 Y 批准，N 拒绝',
|
||||
});
|
||||
|
||||
@@ -92,7 +92,6 @@
|
||||
<div id="app">
|
||||
<!-- Tab Bar -->
|
||||
<div class="tab-bar">
|
||||
<div class="tab-indicator" id="tab-indicator"></div>
|
||||
<button class="active" data-tab="chat" data-i18n="tab.chat">Chat</button>
|
||||
<button data-tab="memory" data-i18n="tab.memory">Memory</button>
|
||||
<button data-tab="jobs" data-i18n="tab.jobs">Jobs</button>
|
||||
@@ -293,11 +292,9 @@
|
||||
<button class="settings-subtab" data-settings-subtab="extensions" data-i18n="tab.extensions">Extensions</button>
|
||||
<button class="settings-subtab" data-settings-subtab="mcp" data-i18n="settings.mcp">MCP</button>
|
||||
<button class="settings-subtab" data-settings-subtab="skills" data-i18n="tab.skills">Skills</button>
|
||||
<button class="settings-theme-toggle" id="settings-theme-toggle" data-i18n="theme.tooltipSystem" title="Toggle theme">Theme</button>
|
||||
</div>
|
||||
<div class="settings-content">
|
||||
<div class="settings-toolbar">
|
||||
<button id="settings-back-btn" class="settings-back-btn">← Back</button>
|
||||
<div class="settings-search">
|
||||
<input type="text" id="settings-search-input" data-i18n-placeholder="settings.searchPlaceholder" placeholder="Search settings..." data-i18n-attr="aria-label" data-i18n="settings.searchPlaceholder" aria-label="Search settings...">
|
||||
</div>
|
||||
|
||||
+240
-868
File diff suppressed because it is too large
Load Diff
@@ -254,16 +254,6 @@ pub enum SseEvent {
|
||||
thread_id: Option<String>,
|
||||
},
|
||||
|
||||
/// Per-turn token usage and cost summary.
|
||||
#[serde(rename = "turn_cost")]
|
||||
TurnCost {
|
||||
input_tokens: u64,
|
||||
output_tokens: u64,
|
||||
cost_usd: String,
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
thread_id: Option<String>,
|
||||
},
|
||||
|
||||
/// Extension activation status change (WASM channels).
|
||||
#[serde(rename = "extension_status")]
|
||||
ExtensionStatus {
|
||||
@@ -807,7 +797,6 @@ impl WsServerMessage {
|
||||
SseEvent::JobResult { .. } => "job_result",
|
||||
SseEvent::ImageGenerated { .. } => "image_generated",
|
||||
SseEvent::Suggestions { .. } => "suggestions",
|
||||
SseEvent::TurnCost { .. } => "turn_cost",
|
||||
SseEvent::ExtensionStatus { .. } => "extension_status",
|
||||
};
|
||||
let data = serde_json::to_value(event).unwrap_or(serde_json::Value::Null);
|
||||
|
||||
@@ -68,7 +68,7 @@ impl WebhookServer {
|
||||
reason: format!("Failed to bind to {}: {}", self.config.addr, e),
|
||||
})?;
|
||||
|
||||
tracing::debug!("Webhook server listening on {}", self.config.addr);
|
||||
tracing::info!("Webhook server listening on {}", self.config.addr);
|
||||
|
||||
let (shutdown_tx, shutdown_rx) = oneshot::channel();
|
||||
self.shutdown_tx = Some(shutdown_tx);
|
||||
@@ -129,7 +129,7 @@ impl WebhookServer {
|
||||
});
|
||||
self.handle = Some(handle);
|
||||
|
||||
tracing::debug!("Webhook server listening on {}", new_addr);
|
||||
tracing::info!("Webhook server listening on {}", new_addr);
|
||||
|
||||
(old_shutdown_tx, old_handle)
|
||||
}
|
||||
|
||||
+13
-48
@@ -7,13 +7,12 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use crate::bootstrap::ironclaw_base_dir;
|
||||
use crate::cli::fmt;
|
||||
use crate::settings::Settings;
|
||||
|
||||
/// Run all diagnostic checks and print results.
|
||||
pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
println!();
|
||||
println!(" {}IronClaw Doctor{}", fmt::bold(), fmt::reset());
|
||||
println!("IronClaw Doctor");
|
||||
println!("===============\n");
|
||||
|
||||
let mut passed = 0u32;
|
||||
let mut failed = 0u32;
|
||||
@@ -22,9 +21,7 @@ pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
// Load settings once for checks that need them.
|
||||
let settings = Settings::load();
|
||||
|
||||
// ── Core ─────────────────────────────────────────────────
|
||||
|
||||
section_header("Core");
|
||||
// ── Settings & core config ─────────────────────────────────
|
||||
|
||||
check(
|
||||
"Settings file",
|
||||
@@ -66,9 +63,7 @@ pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
&mut skipped,
|
||||
);
|
||||
|
||||
// ── Features ─────────────────────────────────────────────
|
||||
|
||||
section_header("Features");
|
||||
// ── Subsystem configuration checks ─────────────────────────
|
||||
|
||||
check(
|
||||
"Embeddings",
|
||||
@@ -126,9 +121,7 @@ pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
&mut skipped,
|
||||
);
|
||||
|
||||
// ── External ─────────────────────────────────────────────
|
||||
|
||||
section_header("External");
|
||||
// ── External binary checks ────────────────────────────────
|
||||
|
||||
check(
|
||||
"Docker daemon",
|
||||
@@ -165,18 +158,7 @@ pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
// ── Summary ───────────────────────────────────────────────
|
||||
|
||||
println!();
|
||||
println!(
|
||||
" {}{} passed{}, {}{} failed{}, {}{} skipped{}",
|
||||
fmt::success(),
|
||||
passed,
|
||||
fmt::reset(),
|
||||
if failed > 0 { fmt::error() } else { fmt::dim() },
|
||||
failed,
|
||||
fmt::reset(),
|
||||
fmt::dim(),
|
||||
skipped,
|
||||
fmt::reset(),
|
||||
);
|
||||
println!(" {passed} passed, {failed} failed, {skipped} skipped");
|
||||
|
||||
if failed > 0 {
|
||||
println!("\n Some checks failed. This is normal if you don't use those features.");
|
||||
@@ -185,38 +167,21 @@ pub async fn run_doctor_command() -> anyhow::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Print a section header with a separator and bold group name.
|
||||
fn section_header(name: &str) {
|
||||
println!();
|
||||
println!(" {}", fmt::separator(36));
|
||||
println!(" {}{}{}", fmt::bold(), name, fmt::reset());
|
||||
println!();
|
||||
}
|
||||
|
||||
// ── Individual checks ───────────────────────────────────────
|
||||
|
||||
fn check(name: &str, result: CheckResult, passed: &mut u32, failed: &mut u32, skipped: &mut u32) {
|
||||
match result {
|
||||
CheckResult::Pass(detail) => {
|
||||
*passed += 1;
|
||||
println!(
|
||||
"{}",
|
||||
fmt::check_line(fmt::StatusKind::Pass, name, &detail, 18)
|
||||
);
|
||||
println!(" [pass] {name}: {detail}");
|
||||
}
|
||||
CheckResult::Fail(detail) => {
|
||||
*failed += 1;
|
||||
println!(
|
||||
"{}",
|
||||
fmt::check_line(fmt::StatusKind::Fail, name, &detail, 18)
|
||||
);
|
||||
println!(" [FAIL] {name}: {detail}");
|
||||
}
|
||||
CheckResult::Skip(reason) => {
|
||||
*skipped += 1;
|
||||
println!(
|
||||
"{}",
|
||||
fmt::check_line(fmt::StatusKind::Skip, name, &reason, 18)
|
||||
);
|
||||
println!(" [skip] {name}: {reason}");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -692,7 +657,7 @@ mod tests {
|
||||
}
|
||||
}
|
||||
|
||||
let _mutex = crate::config::helpers::lock_env();
|
||||
let _mutex = crate::config::helpers::ENV_MUTEX.lock().expect("env mutex");
|
||||
let prev = std::env::var("LLM_BACKEND").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -812,7 +777,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn check_llm_config_shows_nearai_model_for_nearai_backend() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX.lock().expect("env mutex");
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_BACKEND");
|
||||
@@ -839,7 +804,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn check_embeddings_disabled_by_default_returns_skip() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX.lock().expect("env mutex");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("EMBEDDING_ENABLED");
|
||||
@@ -861,7 +826,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn check_routines_enabled_by_default() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX.lock().expect("env mutex");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("ROUTINES_ENABLED");
|
||||
|
||||
-296
@@ -1,296 +0,0 @@
|
||||
//! Shared terminal design system.
|
||||
//!
|
||||
//! Centralizes color tokens, rendering primitives, and width detection
|
||||
//! for consistent CLI output. Respects `NO_COLOR` env var and non-TTY
|
||||
//! output (piping to file, CI, etc.).
|
||||
|
||||
use std::io::IsTerminal;
|
||||
|
||||
// ── Color detection ─────────────────────────────────────────
|
||||
|
||||
/// Returns `true` when ANSI colors should be emitted.
|
||||
///
|
||||
/// Disabled when:
|
||||
/// - `NO_COLOR` env var is set (any value — per <https://no-color.org/>)
|
||||
/// - stdout is not a terminal (pipe, file redirect, CI)
|
||||
fn colors_enabled() -> bool {
|
||||
if std::env::var_os("NO_COLOR").is_some() {
|
||||
return false;
|
||||
}
|
||||
std::io::stdout().is_terminal()
|
||||
}
|
||||
|
||||
/// Returns `true` when the terminal supports 24-bit true-color.
|
||||
///
|
||||
/// Checks `$COLORTERM` for `truecolor` or `24bit`.
|
||||
fn truecolor_enabled() -> bool {
|
||||
std::env::var("COLORTERM")
|
||||
.map(|v| v.eq_ignore_ascii_case("truecolor") || v.eq_ignore_ascii_case("24bit"))
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
// ── Color tokens ────────────────────────────────────────────
|
||||
|
||||
/// Emerald green accent — primary brand color.
|
||||
///
|
||||
/// Uses true-color `#34d399` when supported, falls back to basic green.
|
||||
pub fn accent() -> &'static str {
|
||||
if !colors_enabled() {
|
||||
return "";
|
||||
}
|
||||
if truecolor_enabled() {
|
||||
"\x1b[38;2;52;211;153m"
|
||||
} else {
|
||||
"\x1b[32m"
|
||||
}
|
||||
}
|
||||
|
||||
/// Bold text.
|
||||
pub fn bold() -> &'static str {
|
||||
if colors_enabled() { "\x1b[1m" } else { "" }
|
||||
}
|
||||
|
||||
/// Green — success indicators.
|
||||
pub fn success() -> &'static str {
|
||||
if colors_enabled() { "\x1b[32m" } else { "" }
|
||||
}
|
||||
|
||||
/// Yellow — warning indicators.
|
||||
pub fn warning() -> &'static str {
|
||||
if colors_enabled() { "\x1b[33m" } else { "" }
|
||||
}
|
||||
|
||||
/// Red — error indicators.
|
||||
pub fn error() -> &'static str {
|
||||
if colors_enabled() { "\x1b[31m" } else { "" }
|
||||
}
|
||||
|
||||
/// Dim gray — labels, secondary text.
|
||||
pub fn dim() -> &'static str {
|
||||
if colors_enabled() { "\x1b[90m" } else { "" }
|
||||
}
|
||||
|
||||
/// Yellow underline — URLs and links.
|
||||
pub fn link() -> &'static str {
|
||||
if colors_enabled() { "\x1b[33;4m" } else { "" }
|
||||
}
|
||||
|
||||
/// Bold accent — commands and interactive elements.
|
||||
///
|
||||
/// Uses bold + true-color emerald when supported, falls back to bold green.
|
||||
pub fn bold_accent() -> &'static str {
|
||||
if !colors_enabled() {
|
||||
return "";
|
||||
}
|
||||
if truecolor_enabled() {
|
||||
"\x1b[1;38;2;52;211;153m"
|
||||
} else {
|
||||
"\x1b[1;32m"
|
||||
}
|
||||
}
|
||||
|
||||
/// Dim italic — contextual tips and hints.
|
||||
pub fn hint() -> &'static str {
|
||||
if colors_enabled() { "\x1b[2;3m" } else { "" }
|
||||
}
|
||||
|
||||
/// Reset all attributes.
|
||||
pub fn reset() -> &'static str {
|
||||
if colors_enabled() { "\x1b[0m" } else { "" }
|
||||
}
|
||||
|
||||
// ── Width detection ─────────────────────────────────────────
|
||||
|
||||
/// Detect terminal width, clamped to [40, 120].
|
||||
pub fn term_width() -> usize {
|
||||
crossterm::terminal::size()
|
||||
.map(|(w, _)| w as usize)
|
||||
.unwrap_or(80)
|
||||
.clamp(40, 120)
|
||||
}
|
||||
|
||||
// ── Rendering primitives ────────────────────────────────────
|
||||
|
||||
/// Horizontal separator line (dim `─` characters).
|
||||
pub fn separator(width: usize) -> String {
|
||||
format!("{}{}{}", dim(), "\u{2500}".repeat(width), reset())
|
||||
}
|
||||
|
||||
/// Key-value line with right-padded dim key and accent value.
|
||||
///
|
||||
/// ```text
|
||||
/// Database libsql (connected)
|
||||
/// ```
|
||||
pub fn kv_line(key: &str, value: &str, key_width: usize) -> String {
|
||||
format!(
|
||||
" {}{:<width$}{} {}{}{}",
|
||||
dim(),
|
||||
key,
|
||||
reset(),
|
||||
accent(),
|
||||
value,
|
||||
reset(),
|
||||
width = key_width,
|
||||
)
|
||||
}
|
||||
|
||||
/// Status icon for check results.
|
||||
///
|
||||
/// - `pass` → green `✓`
|
||||
/// - `fail` → red `✗`
|
||||
/// - `skip` → dim `○`
|
||||
pub fn status_icon(kind: StatusKind) -> String {
|
||||
match kind {
|
||||
StatusKind::Pass => format!("{}\u{2713}{}", success(), reset()),
|
||||
StatusKind::Fail => format!("{}\u{2717}{}", error(), reset()),
|
||||
StatusKind::Skip => format!("{}\u{25CB}{}", dim(), reset()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Kind of status check result.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum StatusKind {
|
||||
Pass,
|
||||
Fail,
|
||||
Skip,
|
||||
}
|
||||
|
||||
/// Top border of a box with an optional label.
|
||||
///
|
||||
/// ```text
|
||||
/// ┌─ label ──────────────────┐
|
||||
/// ```
|
||||
pub fn box_top(label: &str, width: usize) -> String {
|
||||
if label.is_empty() {
|
||||
let fill = width.saturating_sub(2);
|
||||
return format!("\u{250C}{}\u{2510}", "\u{2500}".repeat(fill));
|
||||
}
|
||||
let label_part = format!(" {} ", label);
|
||||
// ┌ (1) + ─ (1) + label_part + fill + ┐ (1) = width
|
||||
let fill = width.saturating_sub(label_part.len() + 3);
|
||||
format!(
|
||||
"\u{250C}\u{2500}{}{}{}\u{2510}",
|
||||
bold(),
|
||||
label_part,
|
||||
reset(),
|
||||
)
|
||||
.replace("\u{2510}", &format!("{}\u{2510}", "\u{2500}".repeat(fill)))
|
||||
}
|
||||
|
||||
/// Content line inside a box.
|
||||
///
|
||||
/// ```text
|
||||
/// │ content │
|
||||
/// ```
|
||||
pub fn box_line(content: &str, width: usize) -> String {
|
||||
let inner = width.saturating_sub(4); // │ + space + space + │
|
||||
let padded = if content.len() >= inner {
|
||||
content.to_string()
|
||||
} else {
|
||||
format!("{}{}", content, " ".repeat(inner - content.len()))
|
||||
};
|
||||
format!("\u{2502} {} \u{2502}", padded)
|
||||
}
|
||||
|
||||
/// Bottom border of a box.
|
||||
///
|
||||
/// ```text
|
||||
/// └──────────────────────────┘
|
||||
/// ```
|
||||
pub fn box_bottom(width: usize) -> String {
|
||||
let fill = width.saturating_sub(2);
|
||||
format!("\u{2514}{}\u{2518}", "\u{2500}".repeat(fill))
|
||||
}
|
||||
|
||||
/// Format a check result line for doctor/status commands.
|
||||
///
|
||||
/// ```text
|
||||
/// ✓ Database libsql (connected)
|
||||
/// ✗ Docker not running — start with: open -a Docker
|
||||
/// ○ Embeddings disabled
|
||||
/// ```
|
||||
pub fn check_line(kind: StatusKind, name: &str, detail: &str, name_width: usize) -> String {
|
||||
format!(
|
||||
" {} {:<width$} {}",
|
||||
status_icon(kind),
|
||||
name,
|
||||
detail,
|
||||
width = name_width,
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn separator_produces_correct_width() {
|
||||
// In test environment NO_COLOR or non-TTY may be active,
|
||||
// so strip ANSI to count visible characters.
|
||||
let s = separator(10);
|
||||
let visible: String = strip_ansi(&s);
|
||||
assert_eq!(visible.chars().count(), 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn kv_line_contains_key_and_value() {
|
||||
let line = kv_line("model", "gpt-4o", 12);
|
||||
let visible = strip_ansi(&line);
|
||||
assert!(visible.contains("model"));
|
||||
assert!(visible.contains("gpt-4o"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn status_icon_all_kinds() {
|
||||
// Just verify no panic for each variant
|
||||
let _ = status_icon(StatusKind::Pass);
|
||||
let _ = status_icon(StatusKind::Fail);
|
||||
let _ = status_icon(StatusKind::Skip);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn box_drawing() {
|
||||
let top = box_top("test", 30);
|
||||
let line = box_line("content", 30);
|
||||
let bottom = box_bottom(30);
|
||||
|
||||
assert!(top.contains('\u{250C}')); // ┌
|
||||
assert!(line.contains('\u{2502}')); // │
|
||||
assert!(bottom.contains('\u{2514}')); // └
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn check_line_formatting() {
|
||||
let line = check_line(StatusKind::Pass, "Database", "connected", 18);
|
||||
let visible = strip_ansi(&line);
|
||||
assert!(visible.contains("Database"));
|
||||
assert!(visible.contains("connected"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn term_width_in_range() {
|
||||
let w = term_width();
|
||||
assert!(w >= 40);
|
||||
assert!(w <= 120);
|
||||
}
|
||||
|
||||
/// Strip ANSI escape sequences for visible-character counting.
|
||||
fn strip_ansi(s: &str) -> String {
|
||||
let mut result = String::new();
|
||||
let mut in_escape = false;
|
||||
for c in s.chars() {
|
||||
if c == '\x1b' {
|
||||
in_escape = true;
|
||||
continue;
|
||||
}
|
||||
if in_escape {
|
||||
if c == 'm' {
|
||||
in_escape = false;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
result.push(c);
|
||||
}
|
||||
result
|
||||
}
|
||||
}
|
||||
+3
-8
@@ -18,7 +18,6 @@ mod channels;
|
||||
mod completion;
|
||||
mod config;
|
||||
mod doctor;
|
||||
pub mod fmt;
|
||||
mod hooks;
|
||||
#[cfg(feature = "import")]
|
||||
pub mod import;
|
||||
@@ -112,20 +111,16 @@ pub enum Command {
|
||||
skip_auth: bool,
|
||||
|
||||
/// Reconfigure channels only
|
||||
#[arg(long, conflicts_with_all = ["provider_only", "quick", "step"], help = "Deprecated: use --step channels")]
|
||||
#[arg(long, conflicts_with_all = ["provider_only", "quick"])]
|
||||
channels_only: bool,
|
||||
|
||||
/// Reconfigure LLM provider and model only
|
||||
#[arg(long, conflicts_with_all = ["channels_only", "quick", "step"], help = "Deprecated: use --step provider")]
|
||||
#[arg(long, conflicts_with_all = ["channels_only", "quick"])]
|
||||
provider_only: bool,
|
||||
|
||||
/// Quick setup: auto-defaults everything except LLM provider and model
|
||||
#[arg(long, conflicts_with_all = ["channels_only", "provider_only", "step"])]
|
||||
#[arg(long, conflicts_with_all = ["channels_only", "provider_only"])]
|
||||
quick: bool,
|
||||
|
||||
/// Run only specific setup steps (comma-separated: provider, channels, model, database, security)
|
||||
#[arg(long, value_delimiter = ',', conflicts_with_all = ["channels_only", "provider_only", "quick"])]
|
||||
step: Vec<String>,
|
||||
},
|
||||
|
||||
/// Manage configuration settings
|
||||
|
||||
+12
-12
@@ -758,7 +758,7 @@ mod tests {
|
||||
use crate::cli::oauth_defaults::{
|
||||
builtin_credentials, callback_host, callback_url, is_loopback_host, landing_html,
|
||||
};
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
|
||||
#[test]
|
||||
fn test_is_loopback_host() {
|
||||
@@ -775,7 +775,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_callback_host_default() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("OAUTH_CALLBACK_HOST").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -792,7 +792,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_callback_host_env_override() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original_host = std::env::var("OAUTH_CALLBACK_HOST").ok();
|
||||
let original_url = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
@@ -819,7 +819,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_callback_url_default() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// Clear both env vars to test default behavior
|
||||
let original_url = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
let original_host = std::env::var("OAUTH_CALLBACK_HOST").ok();
|
||||
@@ -843,7 +843,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_callback_url_env_override() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1008,7 +1008,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_use_gateway_callback_false_by_default() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1024,7 +1024,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_use_gateway_callback_true_for_hosted() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1045,7 +1045,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_use_gateway_callback_false_for_localhost() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1063,7 +1063,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_use_gateway_callback_false_for_empty() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1083,7 +1083,7 @@ mod tests {
|
||||
fn test_build_platform_state_with_instance() {
|
||||
use crate::cli::oauth_defaults::{build_platform_state, decode_hosted_oauth_state};
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_INSTANCE_NAME").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -1107,7 +1107,7 @@ mod tests {
|
||||
fn test_build_platform_state_without_instance() {
|
||||
use crate::cli::oauth_defaults::{build_platform_state, decode_hosted_oauth_state};
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_INSTANCE_NAME").ok();
|
||||
let original_oc = std::env::var("OPENCLAW_INSTANCE_NAME").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
@@ -1134,7 +1134,7 @@ mod tests {
|
||||
fn test_build_platform_state_with_openclaw_instance() {
|
||||
use crate::cli::oauth_defaults::{build_platform_state, decode_hosted_oauth_state};
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original_ic = std::env::var("IRONCLAW_INSTANCE_NAME").ok();
|
||||
let original_oc = std::env::var("OPENCLAW_INSTANCE_NAME").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
|
||||
+48
-57
@@ -6,7 +6,6 @@
|
||||
use std::path::PathBuf;
|
||||
|
||||
use crate::bootstrap::ironclaw_base_dir;
|
||||
use crate::cli::fmt;
|
||||
use crate::settings::Settings;
|
||||
|
||||
/// Load settings from JSON and TOML config files, matching the runtime
|
||||
@@ -39,25 +38,22 @@ fn load_settings_from(json_path: &std::path::Path, toml_path: &std::path::Path)
|
||||
pub async fn run_status_command() -> anyhow::Result<()> {
|
||||
let settings = load_settings();
|
||||
|
||||
println!();
|
||||
println!(" {}IronClaw Status{}", fmt::bold(), fmt::reset());
|
||||
println!();
|
||||
println!("IronClaw Status");
|
||||
println!("===============\n");
|
||||
|
||||
// Version
|
||||
println!(
|
||||
"{}",
|
||||
fmt::kv_line(
|
||||
"Version",
|
||||
&format!("{} v{}", env!("CARGO_PKG_NAME"), env!("CARGO_PKG_VERSION")),
|
||||
12,
|
||||
)
|
||||
" Version: {} v{}",
|
||||
env!("CARGO_PKG_NAME"),
|
||||
env!("CARGO_PKG_VERSION")
|
||||
);
|
||||
|
||||
// Database
|
||||
print!(" Database: ");
|
||||
let db_backend = std::env::var("DATABASE_BACKEND")
|
||||
.ok()
|
||||
.unwrap_or_else(|| "postgres".to_string());
|
||||
let db_value = match db_backend.as_str() {
|
||||
match db_backend.as_str() {
|
||||
"libsql" | "turso" | "sqlite" => {
|
||||
let path = std::env::var("LIBSQL_PATH")
|
||||
.map(std::path::PathBuf::from)
|
||||
@@ -68,77 +64,77 @@ pub async fn run_status_command() -> anyhow::Result<()> {
|
||||
} else {
|
||||
""
|
||||
};
|
||||
format!("libSQL ({}{})", path.display(), turso)
|
||||
println!("libSQL ({}{})", path.display(), turso);
|
||||
} else {
|
||||
format!("libSQL (file missing: {})", path.display())
|
||||
println!("libSQL (file missing: {})", path.display());
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
if std::env::var("DATABASE_URL").is_ok() {
|
||||
match check_database().await {
|
||||
Ok(()) => "connected (PostgreSQL)".to_string(),
|
||||
Err(e) => format!("error ({})", e),
|
||||
Ok(()) => println!("connected (PostgreSQL)"),
|
||||
Err(e) => println!("error ({})", e),
|
||||
}
|
||||
} else {
|
||||
"not configured".to_string()
|
||||
println!("not configured");
|
||||
}
|
||||
}
|
||||
};
|
||||
println!("{}", fmt::kv_line("Database", &db_value, 12));
|
||||
}
|
||||
|
||||
// Session / Auth
|
||||
print!(" Session: ");
|
||||
let session_path = crate::config::llm::default_session_path();
|
||||
let session_value = if session_path.exists() {
|
||||
format!("found ({})", session_path.display())
|
||||
if session_path.exists() {
|
||||
println!("found ({})", session_path.display());
|
||||
} else {
|
||||
"not found (run `ironclaw onboard`)".to_string()
|
||||
};
|
||||
println!("{}", fmt::kv_line("Session", &session_value, 12));
|
||||
println!("not found (run `ironclaw onboard`)");
|
||||
}
|
||||
|
||||
// Secrets (auto-detect from env only; skip keychain probe to avoid
|
||||
// triggering macOS system password dialogs on a simple status check)
|
||||
let secrets_value = if std::env::var("SECRETS_MASTER_KEY").is_ok() {
|
||||
"configured (env)".to_string()
|
||||
print!(" Secrets: ");
|
||||
if std::env::var("SECRETS_MASTER_KEY").is_ok() {
|
||||
println!("configured (env)");
|
||||
} else {
|
||||
// We don't probe the keychain here because get_generic_password()
|
||||
// triggers macOS unlock+authorization dialogs, which is bad UX for
|
||||
// a read-only status command. If onboarding completed with keychain
|
||||
// storage, the key is there; we just can't cheaply verify it.
|
||||
"env not set (keychain may be configured)".to_string()
|
||||
};
|
||||
println!("{}", fmt::kv_line("Secrets", &secrets_value, 12));
|
||||
println!("env not set (keychain may be configured)");
|
||||
}
|
||||
|
||||
// Embeddings
|
||||
print!(" Embeddings: ");
|
||||
let emb_enabled = settings.embeddings.enabled
|
||||
|| std::env::var("OPENAI_API_KEY").is_ok()
|
||||
|| std::env::var("EMBEDDING_ENABLED")
|
||||
.map(|v| v == "true")
|
||||
.unwrap_or(false);
|
||||
let emb_value = if emb_enabled {
|
||||
format!(
|
||||
if emb_enabled {
|
||||
println!(
|
||||
"enabled (provider: {}, model: {})",
|
||||
settings.embeddings.provider, settings.embeddings.model
|
||||
)
|
||||
);
|
||||
} else {
|
||||
"disabled".to_string()
|
||||
};
|
||||
println!("{}", fmt::kv_line("Embeddings", &emb_value, 12));
|
||||
println!("disabled");
|
||||
}
|
||||
|
||||
// WASM tools
|
||||
print!(" WASM Tools: ");
|
||||
let tools_dir = settings
|
||||
.wasm
|
||||
.tools_dir
|
||||
.clone()
|
||||
.unwrap_or_else(default_tools_dir);
|
||||
let tools_value = if tools_dir.exists() {
|
||||
if tools_dir.exists() {
|
||||
let count = count_wasm_files(&tools_dir);
|
||||
format!("{} installed ({})", count, tools_dir.display())
|
||||
println!("{} installed ({})", count, tools_dir.display());
|
||||
} else {
|
||||
format!("directory not found ({})", tools_dir.display())
|
||||
};
|
||||
println!("{}", fmt::kv_line("WASM Tools", &tools_value, 12));
|
||||
println!("directory not found ({})", tools_dir.display());
|
||||
}
|
||||
|
||||
// WASM channels
|
||||
print!(" Channels: ");
|
||||
let channels_dir = settings
|
||||
.channels
|
||||
.wasm_channels_dir
|
||||
@@ -157,40 +153,35 @@ pub async fn run_status_command() -> anyhow::Result<()> {
|
||||
channel_info.push(format!("{} wasm", wasm_count));
|
||||
}
|
||||
}
|
||||
println!("{}", fmt::kv_line("Channels", &channel_info.join(", "), 12));
|
||||
println!("{}", channel_info.join(", "));
|
||||
|
||||
// Heartbeat
|
||||
print!(" Heartbeat: ");
|
||||
let hb_enabled = settings.heartbeat.enabled
|
||||
|| std::env::var("HEARTBEAT_ENABLED")
|
||||
.map(|v| v == "true")
|
||||
.unwrap_or(false);
|
||||
let hb_value = if hb_enabled {
|
||||
format!("enabled (interval: {}s)", settings.heartbeat.interval_secs)
|
||||
if hb_enabled {
|
||||
println!("enabled (interval: {}s)", settings.heartbeat.interval_secs);
|
||||
} else {
|
||||
"disabled".to_string()
|
||||
};
|
||||
println!("{}", fmt::kv_line("Heartbeat", &hb_value, 12));
|
||||
println!("disabled");
|
||||
}
|
||||
|
||||
// MCP servers
|
||||
let mcp_value = match crate::tools::mcp::config::load_mcp_servers().await {
|
||||
print!(" MCP Servers: ");
|
||||
match crate::tools::mcp::config::load_mcp_servers().await {
|
||||
Ok(servers) => {
|
||||
let enabled = servers.servers.iter().filter(|s| s.enabled).count();
|
||||
let total = servers.servers.len();
|
||||
format!("{} enabled / {} configured", enabled, total)
|
||||
println!("{} enabled / {} configured", enabled, total);
|
||||
}
|
||||
Err(_) => "none configured".to_string(),
|
||||
};
|
||||
println!("{}", fmt::kv_line("MCP Servers", &mcp_value, 12));
|
||||
Err(_) => println!("none configured"),
|
||||
}
|
||||
|
||||
// Config path
|
||||
println!();
|
||||
println!(
|
||||
"{}",
|
||||
fmt::kv_line(
|
||||
"Config",
|
||||
&crate::bootstrap::ironclaw_env_path().display().to_string(),
|
||||
12,
|
||||
)
|
||||
"\n Config: {}",
|
||||
crate::bootstrap::ironclaw_env_path().display()
|
||||
);
|
||||
|
||||
Ok(())
|
||||
|
||||
@@ -63,12 +63,12 @@ impl BuilderModeConfig {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::Settings;
|
||||
|
||||
#[test]
|
||||
fn resolve_falls_back_to_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.builder.max_iterations = 99;
|
||||
settings.builder.auto_register = false;
|
||||
@@ -80,7 +80,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_overrides_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.builder.timeout_secs = 123;
|
||||
|
||||
|
||||
@@ -113,7 +113,7 @@ impl ChannelsConfig {
|
||||
let gateway = if gateway_enabled {
|
||||
let user_id = optional_env("GATEWAY_USER_ID")?
|
||||
.or_else(|| cs.gateway_user_id.clone())
|
||||
.unwrap_or_else(|| owner_id.to_string());
|
||||
.unwrap_or_else(|| "default".to_string());
|
||||
|
||||
Some(GatewayConfig {
|
||||
host: optional_env("GATEWAY_HOST")?
|
||||
@@ -236,7 +236,7 @@ fn default_channels_dir() -> PathBuf {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::config::channels::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::Settings;
|
||||
|
||||
#[test]
|
||||
@@ -395,7 +395,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn resolve_uses_settings_channel_values_with_owner_scope_user_ids() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let mut settings = Settings::default();
|
||||
settings.channels.http_enabled = true;
|
||||
settings.channels.http_host = Some("127.0.0.2".to_string());
|
||||
|
||||
@@ -196,7 +196,7 @@ impl EmbeddingsConfig {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::{EmbeddingsSettings, Settings};
|
||||
use crate::testing::credentials::*;
|
||||
|
||||
@@ -215,7 +215,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn embeddings_disabled_not_overridden_by_openai_key() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -245,7 +245,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn embeddings_enabled_from_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -265,7 +265,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn embeddings_env_override_takes_precedence() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -294,7 +294,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn embedding_base_url_parsed_from_env() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
@@ -313,7 +313,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn embedding_base_url_defaults_to_none() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
|
||||
let settings = Settings::default();
|
||||
@@ -326,7 +326,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn cache_size_zero_rejected() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_embedding_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
|
||||
+1
-31
@@ -14,16 +14,6 @@ use crate::config::INJECTED_VARS;
|
||||
#[cfg(test)]
|
||||
pub(crate) static ENV_MUTEX: std::sync::Mutex<()> = std::sync::Mutex::new(());
|
||||
|
||||
/// Acquire the env-var mutex, recovering from poison.
|
||||
///
|
||||
/// A poisoned mutex means a previous test panicked while holding the lock.
|
||||
/// The env state might be slightly stale, but cascading every subsequent
|
||||
/// test into a `PoisonError` panic is far worse. Recover and carry on.
|
||||
#[cfg(test)]
|
||||
pub(crate) fn lock_env() -> std::sync::MutexGuard<'static, ()> {
|
||||
ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner())
|
||||
}
|
||||
|
||||
/// Thread-safe mutable overlay for env vars set at runtime.
|
||||
///
|
||||
/// Unlike `INJECTED_VARS` (which is set once at startup from the secrets
|
||||
@@ -363,7 +353,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn real_env_var_takes_priority_over_runtime_override() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
let key = "IRONCLAW_TEST_ENV_PRIORITY_42";
|
||||
|
||||
// Set runtime override
|
||||
@@ -382,26 +372,6 @@ mod tests {
|
||||
assert_eq!(env_or_override(key), Some("override_value".to_string()));
|
||||
}
|
||||
|
||||
// --- lock_env poison recovery (regression for env mutex cascade) ---
|
||||
|
||||
#[test]
|
||||
fn lock_env_recovers_from_poisoned_mutex() {
|
||||
// Simulate a poisoned mutex: spawn a thread that panics while holding the lock.
|
||||
let _ = std::thread::spawn(|| {
|
||||
let _guard = ENV_MUTEX.lock().unwrap();
|
||||
panic!("intentional poison");
|
||||
})
|
||||
.join();
|
||||
|
||||
// The mutex is now poisoned. lock_env() should recover, not cascade.
|
||||
assert!(ENV_MUTEX.lock().is_err(), "mutex should be poisoned");
|
||||
let _guard = lock_env(); // must not panic
|
||||
drop(_guard);
|
||||
|
||||
// Clean up so this test doesn't leave ENV_MUTEX permanently poisoned.
|
||||
ENV_MUTEX.clear_poison();
|
||||
}
|
||||
|
||||
// --- validate_base_url tests (regression for #1103) ---
|
||||
|
||||
#[test]
|
||||
|
||||
+29
-52
@@ -9,7 +9,6 @@ use crate::llm::config::*;
|
||||
use crate::llm::registry::{ProviderProtocol, ProviderRegistry};
|
||||
use crate::llm::session::SessionConfig;
|
||||
use crate::settings::Settings;
|
||||
|
||||
impl LlmConfig {
|
||||
/// Create a test-friendly config without reading env vars.
|
||||
#[cfg(feature = "libsql")]
|
||||
@@ -38,7 +37,6 @@ impl LlmConfig {
|
||||
},
|
||||
provider: None,
|
||||
bedrock: None,
|
||||
gemini_oauth: None,
|
||||
openai_codex: None,
|
||||
request_timeout_secs: 120,
|
||||
cheap_model: None,
|
||||
@@ -75,16 +73,11 @@ impl LlmConfig {
|
||||
backend_lower == "nearai" || backend_lower == "near_ai" || backend_lower == "near";
|
||||
let is_bedrock =
|
||||
backend_lower == "bedrock" || backend_lower == "aws_bedrock" || backend_lower == "aws";
|
||||
let is_gemini_oauth = backend_lower == "gemini_oauth" || backend_lower == "gemini-oauth";
|
||||
let is_openai_codex = backend_lower == "openai_codex"
|
||||
|| backend_lower == "openai-codex"
|
||||
|| backend_lower == "codex";
|
||||
|
||||
if !is_nearai
|
||||
&& !is_bedrock
|
||||
&& !is_gemini_oauth
|
||||
&& !is_openai_codex
|
||||
&& registry.find(&backend_lower).is_none()
|
||||
if !is_nearai && !is_bedrock && !is_openai_codex && registry.find(&backend_lower).is_none()
|
||||
{
|
||||
tracing::warn!(
|
||||
"Unknown LLM backend '{}'. Will attempt as openai_compatible fallback.",
|
||||
@@ -138,8 +131,8 @@ impl LlmConfig {
|
||||
smart_routing_cascade: parse_optional_env("SMART_ROUTING_CASCADE", true)?,
|
||||
};
|
||||
|
||||
// Resolve registry provider config (for non-NearAI, non-Bedrock, non-Gemini, non-Codex backends)
|
||||
let provider = if is_nearai || is_bedrock || is_gemini_oauth || is_openai_codex {
|
||||
// Resolve registry provider config (for non-NearAI, non-Bedrock, non-Codex backends)
|
||||
let provider = if is_nearai || is_bedrock || is_openai_codex {
|
||||
None
|
||||
} else {
|
||||
Some(Self::resolve_registry_provider(
|
||||
@@ -220,19 +213,6 @@ impl LlmConfig {
|
||||
|
||||
let request_timeout_secs = parse_optional_env("LLM_REQUEST_TIMEOUT_SECS", 120)?;
|
||||
|
||||
let gemini_oauth = if backend_lower == "gemini_oauth" || backend_lower == "gemini-oauth" {
|
||||
let model = Self::resolve_model("GEMINI_MODEL", settings, "gemini-2.5-flash")?;
|
||||
let credentials_path = optional_env("GEMINI_CREDENTIALS_PATH")?
|
||||
.map(PathBuf::from)
|
||||
.unwrap_or_else(GeminiOauthConfig::default_credentials_path);
|
||||
Some(GeminiOauthConfig {
|
||||
model,
|
||||
credentials_path,
|
||||
})
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
// Generic cheap model (works with any backend).
|
||||
// Falls back to NearAI-specific cheap_model in provider chain logic.
|
||||
let cheap_model = optional_env("LLM_CHEAP_MODEL")?;
|
||||
@@ -246,8 +226,6 @@ impl LlmConfig {
|
||||
"nearai".to_string()
|
||||
} else if is_bedrock {
|
||||
"bedrock".to_string()
|
||||
} else if is_gemini_oauth {
|
||||
"gemini_oauth".to_string()
|
||||
} else if is_openai_codex {
|
||||
"openai_codex".to_string()
|
||||
} else if let Some(ref p) = provider {
|
||||
@@ -259,7 +237,6 @@ impl LlmConfig {
|
||||
nearai,
|
||||
provider,
|
||||
bedrock,
|
||||
gemini_oauth,
|
||||
openai_codex,
|
||||
request_timeout_secs,
|
||||
cheap_model,
|
||||
@@ -532,7 +509,7 @@ pub fn default_session_path() -> PathBuf {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::Settings;
|
||||
use crate::testing::credentials::*;
|
||||
|
||||
@@ -548,7 +525,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_compatible_uses_selected_model_when_llm_model_unset() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -566,7 +543,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_compatible_llm_model_env_overrides_selected_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -690,7 +667,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn ollama_uses_selected_model_when_ollama_model_unset() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_ollama_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -707,7 +684,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn ollama_model_env_overrides_selected_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_ollama_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -733,7 +710,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_compatible_preserves_dotted_model_name() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -754,7 +731,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn registry_provider_resolves_groq() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_BACKEND");
|
||||
@@ -779,7 +756,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn registry_provider_resolves_tinfoil() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_BACKEND");
|
||||
@@ -807,7 +784,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn registry_provider_alias_resolves_zai() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_BACKEND");
|
||||
@@ -832,7 +809,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn registry_provider_resolves_github_copilot_alias() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::set_var("LLM_BACKEND", "github-copilot");
|
||||
@@ -880,7 +857,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn nearai_backend_has_no_registry_provider() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_BACKEND");
|
||||
@@ -894,7 +871,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn backend_alias_normalized_to_canonical_id() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -920,7 +897,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn unknown_backend_falls_back_to_openai_compatible() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -944,7 +921,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn nearai_aliases_all_resolve_to_nearai() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
|
||||
for alias in &["nearai", "near_ai", "near"] {
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -971,7 +948,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn base_url_resolution_priority() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_compatible_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -1029,7 +1006,7 @@ mod tests {
|
||||
fn anthropic_oauth_token_sets_placeholder_api_key() {
|
||||
use secrecy::ExposeSecret;
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_anthropic_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1067,7 +1044,7 @@ mod tests {
|
||||
fn anthropic_api_key_takes_priority_over_oauth() {
|
||||
use secrecy::ExposeSecret;
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_anthropic_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1100,7 +1077,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn non_anthropic_provider_has_no_oauth_token() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_anthropic_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1208,7 +1185,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_request_timeout_defaults_to_120() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::remove_var("LLM_REQUEST_TIMEOUT_SECS");
|
||||
@@ -1219,7 +1196,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_request_timeout_configurable() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
std::env::set_var("LLM_REQUEST_TIMEOUT_SECS", "300");
|
||||
@@ -1246,7 +1223,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_codex_resolves_config() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -1266,7 +1243,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_codex_model_env_resolution() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1290,7 +1267,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_codex_falls_back_to_openai_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1314,7 +1291,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn openai_codex_falls_back_to_selected_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
|
||||
let settings = Settings {
|
||||
@@ -1331,7 +1308,7 @@ mod tests {
|
||||
/// Regression: SSRF validation on OPENAI_CODEX_API_URL (#1103).
|
||||
#[test]
|
||||
fn openai_codex_rejects_ssrf_api_url() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
@@ -1362,7 +1339,7 @@ mod tests {
|
||||
/// Regression: SSRF validation on OPENAI_CODEX_AUTH_URL (#1103).
|
||||
#[test]
|
||||
fn openai_codex_rejects_ssrf_auth_url() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_openai_codex_env();
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
unsafe {
|
||||
|
||||
+2
-2
@@ -56,8 +56,8 @@ pub use self::tunnel::TunnelConfig;
|
||||
pub use self::wasm::WasmConfig;
|
||||
pub use self::workspace::WorkspaceConfig;
|
||||
pub use crate::llm::config::{
|
||||
BedrockConfig, CacheRetention, GeminiOauthConfig, LlmConfig, NearAiConfig, OAUTH_PLACEHOLDER,
|
||||
OpenAiCodexConfig, RegistryProviderConfig,
|
||||
BedrockConfig, CacheRetention, LlmConfig, NearAiConfig, OAUTH_PLACEHOLDER, OpenAiCodexConfig,
|
||||
RegistryProviderConfig,
|
||||
};
|
||||
pub use crate::llm::session::SessionConfig;
|
||||
|
||||
|
||||
@@ -19,12 +19,12 @@ pub(crate) fn resolve_safety_config(
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::Settings;
|
||||
|
||||
#[test]
|
||||
fn resolve_falls_back_to_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.safety.max_output_length = 42;
|
||||
settings.safety.injection_check_enabled = false;
|
||||
@@ -36,7 +36,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_overrides_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.safety.max_output_length = 42;
|
||||
|
||||
|
||||
+15
-5
@@ -594,7 +594,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn sandbox_resolve_falls_back_to_settings() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let mut settings = crate::settings::Settings::default();
|
||||
settings.sandbox.cpu_shares = 99;
|
||||
settings.sandbox.auto_pull_image = false;
|
||||
@@ -608,7 +610,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn sandbox_env_overrides_settings() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let mut settings = crate::settings::Settings::default();
|
||||
settings.sandbox.timeout_secs = 999;
|
||||
|
||||
@@ -624,7 +628,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn claude_code_resolve_uses_settings_enabled() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let mut settings = crate::settings::Settings::default();
|
||||
settings.sandbox.claude_code_enabled = true;
|
||||
|
||||
@@ -634,7 +640,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn claude_code_resolve_defaults_disabled() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let settings = crate::settings::Settings::default();
|
||||
let cfg = ClaudeCodeConfig::resolve(&settings).expect("resolve");
|
||||
assert!(!cfg.enabled);
|
||||
@@ -642,7 +650,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn claude_code_env_overrides_settings() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let mut settings = crate::settings::Settings::default();
|
||||
settings.sandbox.claude_code_enabled = true;
|
||||
|
||||
|
||||
@@ -92,7 +92,7 @@ impl WorkspaceSearchConfig {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
|
||||
fn clear_search_env() {
|
||||
// SAFETY: Only called under ENV_MUTEX in tests.
|
||||
@@ -106,7 +106,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn defaults_when_no_env() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
let config = WorkspaceSearchConfig::resolve().expect("should resolve");
|
||||
@@ -118,7 +118,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_overrides() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -140,7 +140,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn invalid_strategy_rejected() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -156,7 +156,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn weighted_strategy_defaults() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -175,7 +175,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn weighted_both_zero_rejected() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
@@ -193,7 +193,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn rrf_both_zero_allowed() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
clear_search_env();
|
||||
|
||||
// SAFETY: Under ENV_MUTEX.
|
||||
|
||||
@@ -89,9 +89,7 @@ impl TranscriptionConfig {
|
||||
}
|
||||
|
||||
/// Create the transcription provider if enabled and configured.
|
||||
pub fn create_provider(
|
||||
&self,
|
||||
) -> Option<Box<dyn crate::llm::transcription::TranscriptionProvider>> {
|
||||
pub fn create_provider(&self) -> Option<Box<dyn crate::transcription::TranscriptionProvider>> {
|
||||
if !self.enabled {
|
||||
return None;
|
||||
}
|
||||
@@ -105,11 +103,10 @@ impl TranscriptionConfig {
|
||||
"Audio transcription enabled via Chat Completions API"
|
||||
);
|
||||
|
||||
let mut provider =
|
||||
crate::llm::transcription::ChatCompletionsTranscriptionProvider::new(
|
||||
api_key.clone(),
|
||||
)
|
||||
.with_model(&self.model);
|
||||
let mut provider = crate::transcription::ChatCompletionsTranscriptionProvider::new(
|
||||
api_key.clone(),
|
||||
)
|
||||
.with_model(&self.model);
|
||||
|
||||
if let Some(ref base_url) = self.base_url {
|
||||
provider = provider.with_base_url(base_url);
|
||||
@@ -124,7 +121,7 @@ impl TranscriptionConfig {
|
||||
);
|
||||
|
||||
let mut provider =
|
||||
crate::llm::transcription::OpenAiWhisperProvider::new(api_key.clone())
|
||||
crate::transcription::OpenAiWhisperProvider::new(api_key.clone())
|
||||
.with_model(&self.model);
|
||||
|
||||
if let Some(ref base_url) = self.base_url {
|
||||
|
||||
+3
-3
@@ -95,12 +95,12 @@ impl WasmConfig {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
use crate::settings::Settings;
|
||||
|
||||
#[test]
|
||||
fn resolve_falls_back_to_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.wasm.default_memory_limit = 42;
|
||||
settings.wasm.cache_compiled = false;
|
||||
@@ -112,7 +112,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn env_overrides_settings() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let mut settings = Settings::default();
|
||||
settings.wasm.default_fuel_limit = 42;
|
||||
|
||||
|
||||
@@ -79,10 +79,13 @@ impl WorkspaceConfig {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use std::sync::Mutex;
|
||||
|
||||
// Serialize env-var-dependent tests to avoid races.
|
||||
static ENV_LOCK: Mutex<()> = Mutex::new(());
|
||||
|
||||
fn with_env(key: &str, val: Option<&str>, f: impl FnOnce()) {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_LOCK.lock().unwrap();
|
||||
let prev = std::env::var(key).ok();
|
||||
match val {
|
||||
Some(v) => unsafe { std::env::set_var(key, v) },
|
||||
|
||||
@@ -36,7 +36,7 @@ pub(crate) fn resolve_embedding_dimension() -> Option<usize> {
|
||||
.unwrap_or(false);
|
||||
|
||||
if !enabled {
|
||||
tracing::debug!("Vector index setup skipped (EMBEDDING_ENABLED not set in env)");
|
||||
tracing::info!("Vector index setup skipped (EMBEDDING_ENABLED not set in env)");
|
||||
return None;
|
||||
}
|
||||
|
||||
@@ -1017,7 +1017,7 @@ mod tests {
|
||||
|
||||
mod resolve_dimension {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
|
||||
fn clear_embedding_env() {
|
||||
// SAFETY: called under ENV_MUTEX
|
||||
@@ -1030,14 +1030,14 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn returns_none_when_disabled() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex");
|
||||
clear_embedding_env();
|
||||
assert!(resolve_embedding_dimension().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn returns_explicit_dimension() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex");
|
||||
clear_embedding_env();
|
||||
// SAFETY: under ENV_MUTEX
|
||||
unsafe {
|
||||
@@ -1053,7 +1053,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn infers_from_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex");
|
||||
clear_embedding_env();
|
||||
// SAFETY: under ENV_MUTEX
|
||||
unsafe {
|
||||
@@ -1069,7 +1069,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn defaults_to_1536_for_unknown_model() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex");
|
||||
clear_embedding_env();
|
||||
// SAFETY: under ENV_MUTEX
|
||||
unsafe {
|
||||
|
||||
+1
-1
@@ -97,7 +97,7 @@ pub async fn connect_with_handles(
|
||||
.map_err(|e| DatabaseError::Pool(e.to_string()))?
|
||||
};
|
||||
backend.run_migrations().await?;
|
||||
tracing::debug!("libSQL database connected and migrations applied");
|
||||
tracing::info!("libSQL database connected and migrations applied");
|
||||
|
||||
handles.libsql_db = Some(backend.shared_db());
|
||||
|
||||
|
||||
@@ -7305,7 +7305,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn should_use_gateway_mode_true_for_tunnel_url() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -7327,7 +7329,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn should_use_gateway_mode_false_without_tunnel() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
unsafe {
|
||||
std::env::remove_var("IRONCLAW_OAUTH_CALLBACK_URL");
|
||||
@@ -7348,7 +7352,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn should_use_gateway_mode_false_for_loopback_tunnel() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
unsafe {
|
||||
std::env::remove_var("IRONCLAW_OAUTH_CALLBACK_URL");
|
||||
@@ -7376,7 +7382,9 @@ mod tests {
|
||||
|
||||
impl EnvGuard {
|
||||
fn new() -> Self {
|
||||
let guard = crate::config::helpers::lock_env();
|
||||
let guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe {
|
||||
@@ -7434,7 +7442,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn gateway_callback_redirect_uri_does_not_duplicate_callback_path_from_env() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
unsafe {
|
||||
std::env::set_var(
|
||||
@@ -7460,7 +7470,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn gateway_callback_redirect_uri_trims_trailing_slash_from_env_callback() {
|
||||
let _guard = crate::config::helpers::lock_env();
|
||||
let _guard = crate::config::helpers::ENV_MUTEX
|
||||
.lock()
|
||||
.expect("env mutex poisoned");
|
||||
let original = std::env::var("IRONCLAW_OAUTH_CALLBACK_URL").ok();
|
||||
unsafe {
|
||||
std::env::set_var(
|
||||
|
||||
@@ -72,6 +72,7 @@ pub mod skills;
|
||||
pub mod timezone;
|
||||
pub mod tools;
|
||||
pub mod tracing_fmt;
|
||||
pub mod transcription;
|
||||
pub mod tunnel;
|
||||
pub mod util;
|
||||
pub mod webhooks;
|
||||
|
||||
@@ -165,8 +165,6 @@ pub struct LlmConfig {
|
||||
pub provider: Option<RegistryProviderConfig>,
|
||||
/// AWS Bedrock config (populated when backend=bedrock, requires --features bedrock).
|
||||
pub bedrock: Option<BedrockConfig>,
|
||||
/// Gemini OAuth config (populated when backend=gemini_oauth).
|
||||
pub gemini_oauth: Option<GeminiOauthConfig>,
|
||||
/// OpenAI Codex config (populated when backend=openai_codex).
|
||||
pub openai_codex: Option<OpenAiCodexConfig>,
|
||||
/// HTTP request timeout in seconds for LLM API calls.
|
||||
@@ -269,34 +267,3 @@ impl NearAiConfig {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Configuration for Gemini OAuth integration.
|
||||
///
|
||||
/// Extended generation config parameters (topP, topK, seed, etc.) are read from
|
||||
/// environment variables at request time:
|
||||
/// - `GEMINI_TOP_P` — nucleus sampling (0.0–1.0)
|
||||
/// - `GEMINI_TOP_K` — top-k sampling (integer)
|
||||
/// - `GEMINI_SEED` — deterministic generation seed
|
||||
/// - `GEMINI_PRESENCE_PENALTY` — presence penalty (-2.0–2.0)
|
||||
/// - `GEMINI_FREQUENCY_PENALTY` — frequency penalty (-2.0–2.0)
|
||||
/// - `GEMINI_RESPONSE_MIME_TYPE` — e.g. "application/json"
|
||||
/// - `GEMINI_RESPONSE_JSON_SCHEMA` — JSON schema string for structured output
|
||||
/// - `GEMINI_CACHED_CONTENT` — cached content resource name
|
||||
/// - `GEMINI_CLI_CUSTOM_HEADERS` — custom headers (key:value,key:value)
|
||||
/// - `GOOGLE_GENAI_API_VERSION` — API version (default: v1beta)
|
||||
/// - `GEMINI_API_KEY` — optional API key for non-OAuth auth mode
|
||||
/// - `GEMINI_API_KEY_AUTH_MECHANISM` — "x-goog-api-key" (default) or "bearer"
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct GeminiOauthConfig {
|
||||
pub model: String,
|
||||
pub credentials_path: PathBuf,
|
||||
}
|
||||
|
||||
impl GeminiOauthConfig {
|
||||
pub fn default_credentials_path() -> PathBuf {
|
||||
dirs::home_dir()
|
||||
.unwrap_or_else(|| PathBuf::from("."))
|
||||
.join(".gemini")
|
||||
.join("oauth_creds.json")
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
+1
-57
@@ -18,7 +18,6 @@ pub mod config;
|
||||
pub mod costs;
|
||||
pub mod error;
|
||||
pub mod failover;
|
||||
pub mod gemini_oauth;
|
||||
mod github_copilot;
|
||||
pub(crate) mod github_copilot_auth;
|
||||
mod nearai_chat;
|
||||
@@ -35,7 +34,6 @@ mod rig_adapter;
|
||||
pub mod session;
|
||||
pub mod smart_routing;
|
||||
mod token_refreshing;
|
||||
pub mod transcription;
|
||||
|
||||
#[cfg(test)]
|
||||
mod codex_test_helpers;
|
||||
@@ -52,14 +50,13 @@ pub use config::{
|
||||
};
|
||||
pub use error::LlmError;
|
||||
pub use failover::{CooldownConfig, FailoverProvider};
|
||||
pub use gemini_oauth::GeminiOauthProvider;
|
||||
pub use nearai_chat::{DEFAULT_MODEL, ModelInfo, NearAiChatProvider, default_models};
|
||||
pub use openai_codex_provider::OpenAiCodexProvider;
|
||||
pub use openai_codex_session::{OpenAiCodexSession, OpenAiCodexSessionManager};
|
||||
pub use provider::{
|
||||
ChatMessage, CompletionRequest, CompletionResponse, ContentPart, FinishReason, ImageUrl,
|
||||
LlmProvider, ModelMetadata, Role, ToolCall, ToolCompletionRequest, ToolCompletionResponse,
|
||||
ToolDefinition, ToolResult, generate_tool_call_id,
|
||||
ToolDefinition, ToolResult,
|
||||
};
|
||||
pub use reasoning::{
|
||||
ActionPlan, Reasoning, ReasoningContext, RespondOutput, RespondResult, SILENT_REPLY_TOKEN,
|
||||
@@ -96,10 +93,6 @@ pub async fn create_llm_provider(
|
||||
return create_llm_provider_with_config(&config.nearai, session, timeout);
|
||||
}
|
||||
|
||||
if config.backend == "gemini_oauth" || config.backend == "gemini-oauth" {
|
||||
return create_gemini_oauth_provider(config);
|
||||
}
|
||||
|
||||
// Bedrock uses a native AWS SDK, not the rig-core registry
|
||||
if config.backend == "bedrock" {
|
||||
#[cfg(feature = "bedrock")]
|
||||
@@ -497,19 +490,6 @@ fn create_cheap_provider_for_backend(
|
||||
});
|
||||
}
|
||||
|
||||
if config.backend == "gemini_oauth" {
|
||||
let Some(ref gemini_config) = config.gemini_oauth else {
|
||||
return Err(LlmError::RequestFailed {
|
||||
provider: "gemini_oauth".to_string(),
|
||||
reason: "Gemini OAuth config not available for cheap model".to_string(),
|
||||
});
|
||||
};
|
||||
let mut cheap_gemini_config = gemini_config.clone();
|
||||
cheap_gemini_config.model = cheap_model.to_string();
|
||||
let provider = GeminiOauthProvider::new(cheap_gemini_config)?;
|
||||
return Ok(Some(Arc::new(provider)));
|
||||
}
|
||||
|
||||
// Registry-based provider: clone config and swap model
|
||||
let reg_config = config.provider.as_ref().ok_or_else(|| LlmError::RequestFailed {
|
||||
provider: config.backend.clone(),
|
||||
@@ -694,17 +674,6 @@ pub async fn build_provider_chain(
|
||||
Ok((llm, cheap_llm, recording_handle))
|
||||
}
|
||||
|
||||
pub fn create_gemini_oauth_provider(config: &LlmConfig) -> Result<Arc<dyn LlmProvider>, LlmError> {
|
||||
let gemini_config = config
|
||||
.gemini_oauth
|
||||
.clone()
|
||||
.ok_or_else(|| LlmError::AuthFailed {
|
||||
provider: "gemini_oauth".to_string(),
|
||||
})?;
|
||||
let provider = gemini_oauth::GeminiOauthProvider::new(gemini_config)?;
|
||||
Ok(Arc::new(provider))
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
@@ -736,7 +705,6 @@ mod tests {
|
||||
nearai: test_nearai_config(),
|
||||
provider: None,
|
||||
bedrock: None,
|
||||
gemini_oauth: None,
|
||||
request_timeout_secs: 120,
|
||||
cheap_model: None,
|
||||
smart_routing_cascade: true,
|
||||
@@ -818,30 +786,6 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_create_cheap_llm_provider_gemini_oauth_creates_provider() {
|
||||
let mut config = test_llm_config();
|
||||
config.backend = "gemini_oauth".to_string();
|
||||
config.cheap_model = Some("gemini-2.5-flash-lite".to_string());
|
||||
config.gemini_oauth = Some(crate::config::GeminiOauthConfig {
|
||||
model: "gemini-2.5-pro".to_string(),
|
||||
credentials_path: std::path::PathBuf::from("/tmp/nonexistent-creds.json"),
|
||||
});
|
||||
|
||||
let session = Arc::new(SessionManager::new(SessionConfig::default()));
|
||||
let result = create_cheap_llm_provider(&config, session);
|
||||
|
||||
// Should succeed and return a provider (credentials validation is deferred
|
||||
// until the first LLM call, not at construction time).
|
||||
let provider = result.expect("gemini_oauth cheap provider should succeed");
|
||||
assert!(provider.is_some(), "Should return Some(provider)");
|
||||
assert_eq!(
|
||||
provider.unwrap().model_name(),
|
||||
"gemini-2.5-flash-lite",
|
||||
"Cheap provider should use the overridden model name"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_cheap_model_name_resolution() {
|
||||
// Generic takes priority
|
||||
|
||||
@@ -344,7 +344,6 @@ pub(crate) fn build_nearai_model_fetch_config() -> crate::config::LlmConfig {
|
||||
nearai: crate::config::NearAiConfig::for_model_discovery(),
|
||||
provider: None,
|
||||
bedrock: None,
|
||||
gemini_oauth: None,
|
||||
request_timeout_secs: 120,
|
||||
cheap_model: None,
|
||||
smart_routing_cascade: false,
|
||||
|
||||
@@ -361,7 +361,7 @@ pub fn landing_html(provider_name: &str, success: bool) -> String {
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
|
||||
#[test]
|
||||
fn loopback_detection() {
|
||||
@@ -390,7 +390,7 @@ mod tests {
|
||||
#[allow(clippy::await_holding_lock)]
|
||||
#[tokio::test]
|
||||
async fn bind_rejects_wildcard_ipv4() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("OAUTH_CALLBACK_HOST").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe { std::env::set_var("OAUTH_CALLBACK_HOST", "0.0.0.0") };
|
||||
@@ -414,7 +414,7 @@ mod tests {
|
||||
#[allow(clippy::await_holding_lock)]
|
||||
#[tokio::test]
|
||||
async fn bind_rejects_wildcard_ipv6() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().expect("env mutex poisoned");
|
||||
let original = std::env::var("OAUTH_CALLBACK_HOST").ok();
|
||||
// SAFETY: Under ENV_MUTEX, no concurrent env access.
|
||||
unsafe { std::env::set_var("OAUTH_CALLBACK_HOST", "::") };
|
||||
|
||||
@@ -233,32 +233,6 @@ pub struct ToolCall {
|
||||
pub arguments: serde_json::Value,
|
||||
}
|
||||
|
||||
/// Generate a tool-call ID that satisfies all providers.
|
||||
///
|
||||
/// Mistral requires exactly 9 alphanumeric characters (`[a-zA-Z0-9]{9}`).
|
||||
/// Other providers accept any non-empty string. By default we produce a
|
||||
/// 9-char base-62 string derived from two seed values so the ID is both
|
||||
/// deterministic (for replayed history) and provider-compatible.
|
||||
pub fn generate_tool_call_id(seed_a: usize, seed_b: usize) -> String {
|
||||
// Mix the two seeds into a single u64 using a simple hash-like combine.
|
||||
let combined = (seed_a as u64)
|
||||
.wrapping_mul(6364136223846793005)
|
||||
.wrapping_add(seed_b as u64);
|
||||
// Format as 9-char zero-padded base-62 (0-9, a-z, A-Z).
|
||||
let mut buf = [b'0'; 9];
|
||||
let mut val = combined;
|
||||
for b in buf.iter_mut().rev() {
|
||||
let digit = (val % 62) as u8;
|
||||
*b = match digit {
|
||||
0..=9 => b'0' + digit,
|
||||
10..=35 => b'a' + (digit - 10),
|
||||
_ => b'A' + (digit - 36),
|
||||
};
|
||||
val /= 62;
|
||||
}
|
||||
buf.iter().map(|&b| b as char).collect::<String>()
|
||||
}
|
||||
|
||||
/// Result of a tool execution to send back to the LLM.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct ToolResult {
|
||||
@@ -559,77 +533,6 @@ pub fn strip_unsupported_tool_params(
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::collections::HashSet;
|
||||
|
||||
#[test]
|
||||
fn generate_tool_call_id_has_valid_format() {
|
||||
let samples = [
|
||||
(0usize, 0usize),
|
||||
(1usize, 2usize),
|
||||
(42usize, 999usize),
|
||||
(usize::MAX, usize::MAX),
|
||||
];
|
||||
|
||||
for (a, b) in samples {
|
||||
let id = generate_tool_call_id(a, b);
|
||||
assert_eq!(
|
||||
id.len(),
|
||||
9,
|
||||
"tool-call ID must be exactly 9 characters for seeds ({a}, {b})"
|
||||
);
|
||||
assert!(
|
||||
id.chars().all(|c| c.is_ascii_alphanumeric()),
|
||||
"tool-call ID must be ASCII alphanumeric for seeds ({a}, {b}), got: {id}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generate_tool_call_id_is_deterministic_for_same_seeds() {
|
||||
let pairs = [
|
||||
(0usize, 0usize),
|
||||
(1usize, 2usize),
|
||||
(123usize, 456usize),
|
||||
(usize::MAX, 0usize),
|
||||
];
|
||||
|
||||
for (a, b) in pairs {
|
||||
let id1 = generate_tool_call_id(a, b);
|
||||
let id2 = generate_tool_call_id(a, b);
|
||||
let id3 = generate_tool_call_id(a, b);
|
||||
assert_eq!(
|
||||
id1, id2,
|
||||
"tool-call ID must be deterministic for seeds ({a}, {b})"
|
||||
);
|
||||
assert_eq!(
|
||||
id2, id3,
|
||||
"tool-call ID must be deterministic across multiple calls for seeds ({a}, {b})"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn generate_tool_call_id_differs_for_different_seeds_in_small_sample() {
|
||||
let seed_pairs = [
|
||||
(0usize, 1usize),
|
||||
(1usize, 0usize),
|
||||
(1usize, 2usize),
|
||||
(2usize, 3usize),
|
||||
(10usize, 20usize),
|
||||
(100usize, 200usize),
|
||||
];
|
||||
|
||||
let mut ids = HashSet::new();
|
||||
for (a, b) in seed_pairs {
|
||||
let id = generate_tool_call_id(a, b);
|
||||
let inserted = ids.insert(id.clone());
|
||||
assert!(
|
||||
inserted,
|
||||
"expected distinct tool-call IDs for different seeds, \
|
||||
but duplicate ID '{id}' found for seeds ({a}, {b})"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_sanitize_preserves_valid_pairs() {
|
||||
|
||||
+4
-20
@@ -23,13 +23,6 @@ You said you would perform an action, but you did not include any tool calls.\n\
|
||||
Do NOT describe what you intend to do — actually call the tool now.\n\
|
||||
Use the tool_calls mechanism to invoke the appropriate tool.";
|
||||
|
||||
/// Seed value used as the second argument to `generate_tool_call_id` when
|
||||
/// recovering tool calls from malformed LLM text responses. This must differ
|
||||
/// from the `0` seed used in `rig_adapter::normalized_tool_call_id` to avoid
|
||||
/// ID collisions between provider-generated and text-recovered tool calls at
|
||||
/// the same positional index.
|
||||
const RECOVERED_TOOL_CALL_SEED: usize = 99;
|
||||
|
||||
/// Detect when an LLM response expresses intent to call a tool without
|
||||
/// actually issuing tool calls. Returns `true` if the text contains phrases
|
||||
/// like "Let me search …" or "I'll fetch …" outside of fenced/indented code blocks.
|
||||
@@ -1344,10 +1337,7 @@ fn recover_tool_calls_from_content(
|
||||
.cloned()
|
||||
.unwrap_or(serde_json::Value::Object(Default::default()));
|
||||
calls.push(ToolCall {
|
||||
id: super::provider::generate_tool_call_id(
|
||||
calls.len(),
|
||||
RECOVERED_TOOL_CALL_SEED,
|
||||
),
|
||||
id: format!("recovered_{}", calls.len()),
|
||||
name: name.to_string(),
|
||||
arguments,
|
||||
});
|
||||
@@ -1358,10 +1348,7 @@ fn recover_tool_calls_from_content(
|
||||
let name = inner.trim();
|
||||
if tool_names.contains(name) {
|
||||
calls.push(ToolCall {
|
||||
id: super::provider::generate_tool_call_id(
|
||||
calls.len(),
|
||||
RECOVERED_TOOL_CALL_SEED,
|
||||
),
|
||||
id: format!("recovered_{}", calls.len()),
|
||||
name: name.to_string(),
|
||||
arguments: serde_json::Value::Object(Default::default()),
|
||||
});
|
||||
@@ -1395,10 +1382,7 @@ fn recover_tool_calls_from_content(
|
||||
let arguments = serde_json::from_str::<serde_json::Value>(args_str)
|
||||
.unwrap_or(serde_json::Value::Object(Default::default()));
|
||||
calls.push(ToolCall {
|
||||
id: super::provider::generate_tool_call_id(
|
||||
calls.len(),
|
||||
RECOVERED_TOOL_CALL_SEED,
|
||||
),
|
||||
id: format!("recovered_{}", calls.len()),
|
||||
name: name.to_string(),
|
||||
arguments,
|
||||
});
|
||||
@@ -1409,7 +1393,7 @@ fn recover_tool_calls_from_content(
|
||||
|
||||
// No arguments or malformed — call with empty args
|
||||
calls.push(ToolCall {
|
||||
id: super::provider::generate_tool_call_id(calls.len(), RECOVERED_TOOL_CALL_SEED),
|
||||
id: format!("recovered_{}", calls.len()),
|
||||
name: name.to_string(),
|
||||
arguments: serde_json::Value::Object(Default::default()),
|
||||
});
|
||||
|
||||
+16
-131
@@ -20,7 +20,6 @@ use rust_decimal_macros::dec;
|
||||
use serde::Serialize;
|
||||
use serde::de::DeserializeOwned;
|
||||
use serde_json::Value as JsonValue;
|
||||
use sha2::{Digest, Sha256};
|
||||
|
||||
use std::collections::HashSet;
|
||||
|
||||
@@ -401,48 +400,11 @@ fn convert_messages(messages: &[ChatMessage]) -> (Option<String>, Vec<RigMessage
|
||||
}
|
||||
|
||||
/// Responses-style providers require a non-empty tool call ID.
|
||||
///
|
||||
/// IDs must be compatible with providers like Mistral, which constrain IDs
|
||||
/// to `[a-zA-Z0-9]{9}`. We therefore:
|
||||
/// - pass through any non-empty raw ID that already matches this constraint;
|
||||
/// - otherwise deterministically map the raw string into a provider-compliant ID;
|
||||
/// - and when `raw` is empty/None, delegate to `generate_tool_call_id`.
|
||||
fn normalized_tool_call_id(raw: Option<&str>, seed: usize) -> String {
|
||||
// Trim and treat empty as None.
|
||||
let trimmed = raw.and_then(|s| {
|
||||
let t = s.trim();
|
||||
if t.is_empty() { None } else { Some(t) }
|
||||
});
|
||||
|
||||
if let Some(id) = trimmed {
|
||||
// If the ID already satisfies `[a-zA-Z0-9]{9}`, pass it through unchanged.
|
||||
if id.len() == 9 && id.chars().all(|c| c.is_ascii_alphanumeric()) {
|
||||
return id.to_string();
|
||||
}
|
||||
|
||||
// Otherwise, deterministically hash the raw ID and feed the hash-derived
|
||||
// seed into the provider-level generator so that the encoding and any
|
||||
// provider-specific constraints remain centralized in one place.
|
||||
let digest = Sha256::digest(id.as_bytes());
|
||||
// Derive a 64-bit value from the first 8 bytes of the digest, then
|
||||
// split it into two usize seeds so we preserve all 64 bits of entropy
|
||||
// even on 32-bit targets.
|
||||
let hash64 = {
|
||||
// SHA-256 always produces 32 bytes, so indexing the first 8 is safe.
|
||||
let bytes: [u8; 8] = [
|
||||
digest[0], digest[1], digest[2], digest[3], digest[4], digest[5], digest[6],
|
||||
digest[7],
|
||||
];
|
||||
u64::from_be_bytes(bytes)
|
||||
};
|
||||
let hi_seed: usize = (hash64 >> 32) as usize;
|
||||
let lo_seed: usize = (hash64 & 0xFFFF_FFFF) as usize;
|
||||
return super::provider::generate_tool_call_id(hi_seed, lo_seed);
|
||||
match raw.map(str::trim).filter(|id| !id.is_empty()) {
|
||||
Some(id) => id.to_string(),
|
||||
None => format!("generated_tool_call_{seed}"),
|
||||
}
|
||||
|
||||
// Fallback for missing/empty raw IDs: use the provider-level generator,
|
||||
// which already produces compliant IDs.
|
||||
super::provider::generate_tool_call_id(seed, 0)
|
||||
}
|
||||
|
||||
/// Convert IronClaw tool definitions to rig-core format.
|
||||
@@ -851,9 +813,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_convert_messages_tool_result() {
|
||||
// Use a conforming 9-char alphanumeric ID so it passes through unchanged.
|
||||
let messages = vec![ChatMessage::tool_result(
|
||||
"abcDE1234",
|
||||
"call_123",
|
||||
"search",
|
||||
"result text",
|
||||
)];
|
||||
@@ -864,8 +825,8 @@ mod tests {
|
||||
match &history[0] {
|
||||
RigMessage::User { content } => match content.first() {
|
||||
UserContent::ToolResult(r) => {
|
||||
assert_eq!(r.id, "abcDE1234");
|
||||
assert_eq!(r.call_id.as_deref(), Some("abcDE1234"));
|
||||
assert_eq!(r.id, "call_123");
|
||||
assert_eq!(r.call_id.as_deref(), Some("call_123"));
|
||||
}
|
||||
other => panic!("Expected tool result content, got: {:?}", other),
|
||||
},
|
||||
@@ -875,9 +836,8 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_convert_messages_assistant_with_tool_calls() {
|
||||
// Use a conforming 9-char alphanumeric ID so it passes through unchanged.
|
||||
let tc = IronToolCall {
|
||||
id: "Xt7mK9pQ2".to_string(),
|
||||
id: "call_1".to_string(),
|
||||
name: "search".to_string(),
|
||||
arguments: serde_json::json!({"query": "test"}),
|
||||
};
|
||||
@@ -891,7 +851,7 @@ mod tests {
|
||||
assert!(content.iter().count() >= 2);
|
||||
for item in content.iter() {
|
||||
if let AssistantContent::ToolCall(tc) = item {
|
||||
assert_eq!(tc.call_id.as_deref(), Some("Xt7mK9pQ2"));
|
||||
assert_eq!(tc.call_id.as_deref(), Some("call_1"));
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -913,14 +873,7 @@ mod tests {
|
||||
match &history[0] {
|
||||
RigMessage::User { content } => match content.first() {
|
||||
UserContent::ToolResult(r) => {
|
||||
// Missing ID → normalized_tool_call_id generates a 9-char alphanumeric ID.
|
||||
assert_eq!(
|
||||
r.id.len(),
|
||||
9,
|
||||
"fallback ID should be 9 chars, got: {}",
|
||||
r.id
|
||||
);
|
||||
assert!(r.id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
assert!(r.id.starts_with("generated_tool_call_"));
|
||||
assert_eq!(r.call_id.as_deref(), Some(r.id.as_str()));
|
||||
}
|
||||
other => panic!("Expected tool result content, got: {:?}", other),
|
||||
@@ -1008,14 +961,12 @@ mod tests {
|
||||
_ => None,
|
||||
});
|
||||
let tc = tool_call.expect("should have a tool call");
|
||||
// Empty ID → normalized_tool_call_id generates a 9-char alphanumeric ID.
|
||||
assert_eq!(
|
||||
tc.id.len(),
|
||||
9,
|
||||
"generated id should be 9 chars, got: {}",
|
||||
assert!(!tc.id.is_empty(), "tool call id must not be empty");
|
||||
assert!(
|
||||
tc.id.starts_with("generated_tool_call_"),
|
||||
"empty id should be replaced with generated id, got: {}",
|
||||
tc.id
|
||||
);
|
||||
assert!(tc.id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
assert_eq!(tc.call_id.as_deref(), Some(tc.id.as_str()));
|
||||
}
|
||||
other => panic!("Expected Assistant message, got: {:?}", other),
|
||||
@@ -1039,14 +990,11 @@ mod tests {
|
||||
_ => None,
|
||||
});
|
||||
let tc = tool_call.expect("should have a tool call");
|
||||
// Whitespace-only ID → normalized_tool_call_id generates a 9-char alphanumeric ID.
|
||||
assert_eq!(
|
||||
tc.id.len(),
|
||||
9,
|
||||
"generated id should be 9 chars, got: {}",
|
||||
assert!(
|
||||
tc.id.starts_with("generated_tool_call_"),
|
||||
"whitespace-only id should be replaced, got: {:?}",
|
||||
tc.id
|
||||
);
|
||||
assert!(tc.id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
}
|
||||
other => panic!("Expected Assistant message, got: {:?}", other),
|
||||
}
|
||||
@@ -1433,67 +1381,4 @@ mod tests {
|
||||
// Should be 2 separate User messages (text user + tool result user)
|
||||
assert_eq!(history.len(), 2);
|
||||
}
|
||||
|
||||
// -- normalized_tool_call_id tests --
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_conforming_passthrough() {
|
||||
// A 9-char alphanumeric ID should pass through unchanged.
|
||||
let id = normalized_tool_call_id(Some("abcDE1234"), 42);
|
||||
assert_eq!(id, "abcDE1234");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_non_conforming_hashed() {
|
||||
// An ID that doesn't match [a-zA-Z0-9]{9} should be hashed into one.
|
||||
let id = normalized_tool_call_id(Some("call_abc_long_id"), 0);
|
||||
assert_eq!(id.len(), 9);
|
||||
assert!(id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
// Should NOT be the raw input.
|
||||
assert_ne!(id, "call_abc_l");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_empty_input() {
|
||||
let id = normalized_tool_call_id(Some(""), 5);
|
||||
assert_eq!(id.len(), 9);
|
||||
assert!(id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_whitespace_input() {
|
||||
let id = normalized_tool_call_id(Some(" "), 5);
|
||||
assert_eq!(id.len(), 9);
|
||||
assert!(id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
// Empty and whitespace-only with the same seed should produce identical results.
|
||||
let id_empty = normalized_tool_call_id(Some(""), 5);
|
||||
assert_eq!(id, id_empty);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_none_input() {
|
||||
let id = normalized_tool_call_id(None, 7);
|
||||
assert_eq!(id.len(), 9);
|
||||
assert!(id.chars().all(|c| c.is_ascii_alphanumeric()));
|
||||
// None and empty string with same seed should produce identical results.
|
||||
let id_empty = normalized_tool_call_id(Some(""), 7);
|
||||
assert_eq!(id, id_empty);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_deterministic() {
|
||||
let id1 = normalized_tool_call_id(Some("call_xyz_123"), 0);
|
||||
let id2 = normalized_tool_call_id(Some("call_xyz_123"), 0);
|
||||
assert_eq!(id1, id2, "same input must produce same output");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_normalized_tool_call_id_different_inputs_differ() {
|
||||
let id_a = normalized_tool_call_id(Some("call_aaa"), 0);
|
||||
let id_b = normalized_tool_call_id(Some("call_bbb"), 0);
|
||||
assert_ne!(
|
||||
id_a, id_b,
|
||||
"different raw IDs should produce different hashed IDs"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
+7
-52
@@ -38,49 +38,10 @@ fn main() -> anyhow::Result<()> {
|
||||
let _ = dotenvy::dotenv();
|
||||
ironclaw::bootstrap::load_ironclaw_env();
|
||||
|
||||
let result = tokio::runtime::Builder::new_multi_thread()
|
||||
tokio::runtime::Builder::new_multi_thread()
|
||||
.enable_all()
|
||||
.build()?
|
||||
.block_on(async_main());
|
||||
|
||||
if let Err(ref e) = result {
|
||||
format_top_level_error(e);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
/// Format a top-level error with color and recovery hints.
|
||||
fn format_top_level_error(err: &anyhow::Error) {
|
||||
use ironclaw::cli::fmt;
|
||||
let msg = format!("{err:#}");
|
||||
|
||||
eprintln!();
|
||||
eprintln!(" {}\u{2717}{} {}", fmt::error(), fmt::reset(), msg);
|
||||
|
||||
// Provide recovery hints for common errors
|
||||
let lower = msg.to_ascii_lowercase();
|
||||
let hint = if lower.contains("database_url")
|
||||
|| lower.contains("database") && lower.contains("not set")
|
||||
{
|
||||
Some("run `ironclaw onboard` or set DATABASE_URL in .env")
|
||||
} else if lower.contains("connection refused") || lower.contains("connect error") {
|
||||
Some("check that the database server is running")
|
||||
} else if lower.contains("session") && lower.contains("not found") {
|
||||
Some("run `ironclaw onboard` to set up authentication")
|
||||
} else if lower.contains("secrets_master_key") {
|
||||
Some("run `ironclaw onboard` or set SECRETS_MASTER_KEY in .env")
|
||||
} else if lower.contains("already running") {
|
||||
Some("stop the other instance or remove the stale PID file")
|
||||
} else if lower.contains("onboard") {
|
||||
Some("run `ironclaw onboard` to complete setup")
|
||||
} else {
|
||||
None
|
||||
};
|
||||
|
||||
if let Some(hint_text) = hint {
|
||||
eprintln!(" {}hint:{} {}", fmt::dim(), fmt::reset(), hint_text,);
|
||||
}
|
||||
eprintln!();
|
||||
.block_on(async_main())
|
||||
}
|
||||
|
||||
async fn async_main() -> anyhow::Result<()> {
|
||||
@@ -229,7 +190,6 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
channels_only,
|
||||
provider_only,
|
||||
quick,
|
||||
step,
|
||||
}) => {
|
||||
#[cfg(any(feature = "postgres", feature = "libsql"))]
|
||||
{
|
||||
@@ -238,7 +198,6 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
channels_only: *channels_only,
|
||||
provider_only: *provider_only,
|
||||
quick: *quick,
|
||||
steps: step.clone(),
|
||||
};
|
||||
let mut wizard =
|
||||
SetupWizard::try_with_config_and_toml(config, cli.config.as_deref())?;
|
||||
@@ -246,7 +205,7 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
}
|
||||
#[cfg(not(any(feature = "postgres", feature = "libsql")))]
|
||||
{
|
||||
let _ = (skip_auth, channels_only, provider_only, quick, step);
|
||||
let _ = (skip_auth, channels_only, provider_only, quick);
|
||||
eprintln!("Onboarding wizard requires the 'postgres' or 'libsql' feature.");
|
||||
}
|
||||
return Ok(());
|
||||
@@ -274,8 +233,6 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
}
|
||||
};
|
||||
|
||||
let startup_start = std::time::Instant::now();
|
||||
|
||||
// ── Agent startup ──────────────────────────────────────────────────
|
||||
|
||||
// Enhanced first-run detection
|
||||
@@ -734,7 +691,6 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
.and_then(|t| t.public_url())
|
||||
.or_else(|| config.tunnel.public_url.clone()),
|
||||
tunnel_provider: active_tunnel.as_ref().map(|t| t.name().to_string()),
|
||||
startup_elapsed: Some(startup_start.elapsed()),
|
||||
};
|
||||
ironclaw::boot_screen::print_boot_screen(&boot_info);
|
||||
}
|
||||
@@ -846,11 +802,10 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
cost_guard: components.cost_guard,
|
||||
sse_tx: sse_sender,
|
||||
http_interceptor,
|
||||
transcription: config.transcription.create_provider().map(|p| {
|
||||
Arc::new(ironclaw::llm::transcription::TranscriptionMiddleware::new(
|
||||
p,
|
||||
))
|
||||
}),
|
||||
transcription: config
|
||||
.transcription
|
||||
.create_provider()
|
||||
.map(|p| Arc::new(ironclaw::transcription::TranscriptionMiddleware::new(p))),
|
||||
document_extraction: Some(Arc::new(
|
||||
ironclaw::document_extraction::DocumentExtractionMiddleware::new(),
|
||||
)),
|
||||
|
||||
@@ -164,15 +164,19 @@ pub async fn setup_orchestrator(
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use std::sync::Mutex;
|
||||
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
|
||||
/// Serialize access to `ORCHESTRATOR_PORT` env var across test threads.
|
||||
static ENV_LOCK: Mutex<()> = Mutex::new(());
|
||||
|
||||
#[test]
|
||||
fn resolve_orchestrator_port_from_env() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_LOCK.lock().unwrap();
|
||||
|
||||
// Safety: env-var mutation requires unsafe in edition 2024;
|
||||
// lock_env() serializes concurrent access from other test threads.
|
||||
// ENV_LOCK serializes concurrent access from other test threads.
|
||||
|
||||
// Absent env var → default 50051
|
||||
unsafe { std::env::remove_var("ORCHESTRATOR_PORT") };
|
||||
|
||||
+23
-48
@@ -123,32 +123,15 @@ pub fn select_many(prompt: &str, options: &[(&str, bool)]) -> io::Result<Vec<usi
|
||||
writeln!(stdout, "\r")?;
|
||||
|
||||
for (i, (label, _)) in options.iter().enumerate() {
|
||||
let checkbox = if selected[i] { "[x]" } else { "[ ]" };
|
||||
let prefix = if i == cursor_pos { ">" } else { " " };
|
||||
|
||||
if i == cursor_pos {
|
||||
// Cursor line: cyan cursor, then colored checkbox
|
||||
execute!(stdout, SetForegroundColor(Color::Cyan))?;
|
||||
write!(stdout, " \u{25b8} ")?;
|
||||
if selected[i] {
|
||||
execute!(stdout, SetForegroundColor(Color::Green))?;
|
||||
write!(stdout, "[\u{2713}]")?;
|
||||
} else {
|
||||
execute!(stdout, SetForegroundColor(Color::DarkGrey))?;
|
||||
write!(stdout, "[\u{00b7}]")?;
|
||||
}
|
||||
execute!(stdout, SetForegroundColor(Color::Cyan))?;
|
||||
writeln!(stdout, " {}\r", label)?;
|
||||
writeln!(stdout, " {} {} {}\r", prefix, checkbox, label)?;
|
||||
execute!(stdout, ResetColor)?;
|
||||
} else {
|
||||
write!(stdout, " ")?;
|
||||
if selected[i] {
|
||||
execute!(stdout, SetForegroundColor(Color::Green))?;
|
||||
write!(stdout, "[\u{2713}]")?;
|
||||
execute!(stdout, ResetColor)?;
|
||||
} else {
|
||||
execute!(stdout, SetForegroundColor(Color::DarkGrey))?;
|
||||
write!(stdout, "[\u{00b7}]")?;
|
||||
execute!(stdout, ResetColor)?;
|
||||
}
|
||||
writeln!(stdout, " {}\r", label)?;
|
||||
writeln!(stdout, " {} {} {}\r", prefix, checkbox, label)?;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -301,12 +284,18 @@ pub fn confirm(prompt: &str, default: bool) -> io::Result<bool> {
|
||||
})
|
||||
}
|
||||
|
||||
/// Print a minimal wordmark banner.
|
||||
/// Print the IronClaw ASCII art banner in blue.
|
||||
pub fn print_banner() {
|
||||
use crate::cli::fmt;
|
||||
println!();
|
||||
println!(" {}ironclaw{}", fmt::bold_accent(), fmt::reset());
|
||||
let mut stdout = io::stdout();
|
||||
let _ = execute!(stdout, SetForegroundColor(Color::Cyan));
|
||||
println!();
|
||||
println!(r" ██╗██████╗ ██████╗ ███╗ ██╗ ██████╗██╗ █████╗ ██╗ ██╗");
|
||||
println!(r" ██║██╔══██╗██╔═══██╗████╗ ██║██╔════╝██║ ██╔══██╗██║ ██║");
|
||||
println!(r" ██║██████╔╝██║ ██║██╔██╗ ██║██║ ██║ ███████║██║ █╗ ██║");
|
||||
println!(r" ██║██╔══██╗██║ ██║██║╚██╗██║██║ ██║ ██╔══██║██║███╗██║");
|
||||
println!(r" ██║██║ ██║╚██████╔╝██║ ╚████║╚██████╗███████╗██║ ██║╚███╔███╔╝");
|
||||
println!(r" ╚═╝╚═╝ ╚═╝ ╚═════╝ ╚═╝ ╚═══╝ ╚═════╝╚══════╝╚═╝ ╚═╝ ╚══╝╚══╝ ");
|
||||
let _ = execute!(stdout, ResetColor);
|
||||
}
|
||||
|
||||
/// Print a styled header box.
|
||||
@@ -321,38 +310,24 @@ pub fn print_header(text: &str) {
|
||||
let border = "─".repeat(width);
|
||||
|
||||
println!();
|
||||
println!("┌{}┐", border);
|
||||
println!("╭{}╮", border);
|
||||
println!("│ {} │", text);
|
||||
println!("└{}┘", border);
|
||||
println!("╰{}╯", border);
|
||||
println!();
|
||||
}
|
||||
|
||||
/// Print a compact dot-based step indicator.
|
||||
///
|
||||
/// `●` = completed (green/success), `◉` = current (accent), `○` = remaining (dim).
|
||||
/// Print a step indicator.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```ignore
|
||||
/// print_step(3, 5, "Model Selection");
|
||||
/// // Output: ● ● ◉ ○ ○ Model Selection
|
||||
/// print_step(1, 3, "NEAR AI Authentication");
|
||||
/// // Output: Step 1/3: NEAR AI Authentication
|
||||
/// // ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
||||
/// ```
|
||||
pub fn print_step(current: usize, total: usize, name: &str) {
|
||||
use crate::cli::fmt;
|
||||
let mut dots = String::new();
|
||||
for i in 1..=total {
|
||||
if i > 1 {
|
||||
dots.push(' ');
|
||||
}
|
||||
if i < current {
|
||||
dots.push_str(&format!("{}\u{25CF}{}", fmt::success(), fmt::reset())); // ● green
|
||||
} else if i == current {
|
||||
dots.push_str(&format!("{}\u{25C9}{}", fmt::accent(), fmt::reset())); // ◉ accent
|
||||
} else {
|
||||
dots.push_str(&format!("{}\u{25CB}{}", fmt::dim(), fmt::reset())); // ○ dim
|
||||
}
|
||||
}
|
||||
println!(" {} {}", dots, name);
|
||||
println!("Step {}/{}: {}", current, total, name);
|
||||
println!("{}", "━".repeat(32));
|
||||
println!();
|
||||
}
|
||||
|
||||
|
||||
+234
-539
@@ -84,8 +84,6 @@ pub struct SetupConfig {
|
||||
pub provider_only: bool,
|
||||
/// Quick setup: auto-defaults everything except LLM provider and model.
|
||||
pub quick: bool,
|
||||
/// Run only specific setup steps (e.g. "provider", "channels", "model", "database", "security").
|
||||
pub steps: Vec<String>,
|
||||
}
|
||||
|
||||
/// Interactive setup wizard for IronClaw.
|
||||
@@ -190,55 +188,6 @@ impl SetupWizard {
|
||||
print_banner();
|
||||
print_header("IronClaw Setup Wizard");
|
||||
|
||||
if !self.config.steps.is_empty() {
|
||||
// Selective step mode: reconnect to existing DB and load settings,
|
||||
// then run only the requested steps.
|
||||
self.reconnect_existing_db().await?;
|
||||
|
||||
let valid_steps = ["provider", "channels", "model", "database", "security"];
|
||||
for s in &self.config.steps {
|
||||
if !valid_steps.contains(&s.as_str()) {
|
||||
return Err(SetupError::Config(format!(
|
||||
"Unknown step '{}'. Valid steps: {}",
|
||||
s,
|
||||
valid_steps.join(", ")
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
let total = self.config.steps.len();
|
||||
for (i, step_name) in self.config.steps.clone().iter().enumerate() {
|
||||
let step_num = i + 1;
|
||||
match step_name.as_str() {
|
||||
"database" => {
|
||||
print_step(step_num, total, "Database Connection");
|
||||
self.step_database().await?;
|
||||
}
|
||||
"security" => {
|
||||
print_step(step_num, total, "Security");
|
||||
self.step_security().await?;
|
||||
}
|
||||
"provider" => {
|
||||
print_step(step_num, total, "Inference Provider");
|
||||
self.step_inference_provider().await?;
|
||||
}
|
||||
"model" => {
|
||||
print_step(step_num, total, "Model Selection");
|
||||
self.step_model_selection().await?;
|
||||
}
|
||||
"channels" => {
|
||||
print_step(step_num, total, "Channel Configuration");
|
||||
self.step_channels().await?;
|
||||
}
|
||||
_ => {} // already validated above
|
||||
}
|
||||
self.persist_after_step().await;
|
||||
}
|
||||
|
||||
self.save_and_summarize().await?;
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
if self.config.channels_only {
|
||||
// Channels-only mode: reconnect to existing DB and load settings
|
||||
// before running the channel step, so secrets and save work.
|
||||
@@ -271,23 +220,23 @@ impl SetupWizard {
|
||||
// Pre-populate backend from env so step_inference_provider
|
||||
// can offer "Keep current provider?" instead of asking from scratch.
|
||||
if self.settings.llm_backend.is_none() {
|
||||
if let Ok(b) = std::env::var("LLM_BACKEND") {
|
||||
self.settings.llm_backend = Some(b);
|
||||
} else if std::env::var("NEARAI_API_KEY").is_ok() {
|
||||
use crate::config::helpers::env_or_override;
|
||||
if let Some(b) = env_or_override("LLM_BACKEND")
|
||||
&& !b.trim().is_empty()
|
||||
{
|
||||
self.settings.llm_backend = Some(b.trim().to_string());
|
||||
} else if env_or_override("NEARAI_API_KEY").is_some() {
|
||||
self.settings.llm_backend = Some("nearai".to_string());
|
||||
} else if std::env::var("ANTHROPIC_API_KEY").is_ok()
|
||||
|| std::env::var("ANTHROPIC_OAUTH_TOKEN").is_ok()
|
||||
} else if env_or_override("ANTHROPIC_API_KEY").is_some()
|
||||
|| env_or_override("ANTHROPIC_OAUTH_TOKEN").is_some()
|
||||
{
|
||||
self.settings.llm_backend = Some("anthropic".to_string());
|
||||
} else if std::env::var("OPENAI_API_KEY").is_ok() {
|
||||
} else if env_or_override("OPENAI_API_KEY").is_some() {
|
||||
self.settings.llm_backend = Some("openai".to_string());
|
||||
} else if std::env::var("OPENROUTER_API_KEY").is_ok() {
|
||||
self.settings.llm_backend = Some("openrouter".to_string());
|
||||
}
|
||||
}
|
||||
|
||||
if let Ok(api_key) = std::env::var("NEARAI_API_KEY")
|
||||
&& !api_key.is_empty()
|
||||
if let Some(api_key) = crate::config::helpers::env_or_override("NEARAI_API_KEY")
|
||||
&& self.settings.llm_backend.as_deref() == Some("nearai")
|
||||
{
|
||||
// NEARAI_API_KEY is set and backend auto-detected — skip interactive prompts
|
||||
@@ -305,79 +254,6 @@ impl SetupWizard {
|
||||
print_info(&format!("Using default model: {default}"));
|
||||
}
|
||||
self.persist_after_step().await;
|
||||
} else if self.settings.llm_backend.as_deref() == Some("anthropic")
|
||||
&& let Some(api_key) = Self::detect_anthropic_key()
|
||||
{
|
||||
// Anthropic key detected — skip interactive prompts
|
||||
print_info("Anthropic credentials found — using Anthropic provider");
|
||||
let secret_name = if api_key.starts_with("sk-ant-oat") {
|
||||
"llm_anthropic_oauth_token"
|
||||
} else {
|
||||
"llm_anthropic_api_key"
|
||||
};
|
||||
if let Ok(ctx) = self.init_secrets_context().await {
|
||||
let key = SecretString::from(api_key.clone());
|
||||
if let Err(e) = ctx.save_secret(secret_name, &key).await {
|
||||
tracing::warn!("Failed to persist Anthropic key to secrets: {}", e);
|
||||
}
|
||||
}
|
||||
self.llm_api_key = Some(SecretString::from(api_key));
|
||||
let registry = crate::llm::ProviderRegistry::load();
|
||||
if self.settings.selected_model.is_none() {
|
||||
let default = registry
|
||||
.find("anthropic")
|
||||
.map(|d| d.default_model.as_str())
|
||||
.unwrap_or("claude-sonnet-4-20250514");
|
||||
self.settings.selected_model = Some(default.to_string());
|
||||
print_info(&format!("Using default model: {default}"));
|
||||
}
|
||||
self.persist_after_step().await;
|
||||
} else if let Ok(api_key) = std::env::var("OPENAI_API_KEY")
|
||||
&& !api_key.is_empty()
|
||||
&& self.settings.llm_backend.as_deref() == Some("openai")
|
||||
{
|
||||
// OpenAI key detected — skip interactive prompts
|
||||
print_info("OPENAI_API_KEY found — using OpenAI provider");
|
||||
if let Ok(ctx) = self.init_secrets_context().await {
|
||||
let key = SecretString::from(api_key.clone());
|
||||
if let Err(e) = ctx.save_secret("llm_openai_api_key", &key).await {
|
||||
tracing::warn!("Failed to persist OPENAI_API_KEY to secrets: {}", e);
|
||||
}
|
||||
}
|
||||
self.llm_api_key = Some(SecretString::from(api_key));
|
||||
let registry = crate::llm::ProviderRegistry::load();
|
||||
if self.settings.selected_model.is_none() {
|
||||
let default = registry
|
||||
.find("openai")
|
||||
.map(|d| d.default_model.as_str())
|
||||
.unwrap_or("gpt-5-mini");
|
||||
self.settings.selected_model = Some(default.to_string());
|
||||
print_info(&format!("Using default model: {default}"));
|
||||
}
|
||||
self.persist_after_step().await;
|
||||
} else if let Ok(api_key) = std::env::var("OPENROUTER_API_KEY")
|
||||
&& !api_key.is_empty()
|
||||
&& self.settings.llm_backend.as_deref() == Some("openrouter")
|
||||
{
|
||||
// OpenRouter key detected — skip interactive prompts
|
||||
print_info("OPENROUTER_API_KEY found — using OpenRouter provider");
|
||||
if let Ok(ctx) = self.init_secrets_context().await {
|
||||
let key = SecretString::from(api_key.clone());
|
||||
if let Err(e) = ctx.save_secret("llm_openrouter_api_key", &key).await {
|
||||
tracing::warn!("Failed to persist OPENROUTER_API_KEY to secrets: {}", e);
|
||||
}
|
||||
}
|
||||
self.llm_api_key = Some(SecretString::from(api_key));
|
||||
let registry = crate::llm::ProviderRegistry::load();
|
||||
if self.settings.selected_model.is_none() {
|
||||
let default = registry
|
||||
.find("openrouter")
|
||||
.map(|d| d.default_model.as_str())
|
||||
.unwrap_or("openai/gpt-4o");
|
||||
self.settings.selected_model = Some(default.to_string());
|
||||
print_info(&format!("Using default model: {default}"));
|
||||
}
|
||||
self.persist_after_step().await;
|
||||
} else {
|
||||
print_step(1, 2, "Inference Provider");
|
||||
self.step_inference_provider().await?;
|
||||
@@ -1202,40 +1078,23 @@ impl SetupWizard {
|
||||
.map(|s| s.display_name().to_string())
|
||||
.unwrap_or_else(|| def.id.clone())
|
||||
} else {
|
||||
match current.as_str() {
|
||||
"nearai" => "NEAR AI".to_string(),
|
||||
"gemini_oauth" | "gemini-oauth" => "Gemini API (OAuth)".to_string(),
|
||||
_ => {
|
||||
if let Some(def) = registry.find(¤t) {
|
||||
def.setup
|
||||
.as_ref()
|
||||
.map(|s| s.display_name().to_string())
|
||||
.unwrap_or_else(|| def.id.clone())
|
||||
} else {
|
||||
current.clone()
|
||||
}
|
||||
}
|
||||
}
|
||||
current.clone()
|
||||
};
|
||||
print_info(&format!("Current provider: {}", display));
|
||||
println!();
|
||||
|
||||
let is_known = current == "nearai"
|
||||
|| current == "bedrock"
|
||||
|| current == "gemini_oauth"
|
||||
|| current == "gemini-oauth"
|
||||
|| current == "openai_codex"
|
||||
|| registry.is_known(¤t);
|
||||
|
||||
if is_known && confirm("Keep current provider?", true).map_err(SetupError::Io)? {
|
||||
if current == "bedrock" {
|
||||
// Keeping the existing Bedrock config — no need to re-run
|
||||
// the full setup flow (region, auth, cross-region).
|
||||
print_info("Keeping existing AWS Bedrock configuration.");
|
||||
return Ok(());
|
||||
}
|
||||
if current == "gemini_oauth" || current == "gemini-oauth" {
|
||||
print_info("Keeping existing Gemini CLI OAuth configuration.");
|
||||
return Ok(());
|
||||
}
|
||||
if current == "openai_codex" {
|
||||
print_info("Keeping existing OpenAI Codex configuration.");
|
||||
return Ok(());
|
||||
@@ -1254,100 +1113,33 @@ impl SetupWizard {
|
||||
print_info("Select your inference provider:");
|
||||
println!();
|
||||
|
||||
// Build menu: NearAI first, then Gemini OAuth, then OpenAI Codex, then registry providers, then Bedrock
|
||||
// Build menu: NearAI first, then OpenAI Codex, then registry providers, then Bedrock
|
||||
let selectable = registry.selectable();
|
||||
let mut options: Vec<String> = Vec::with_capacity(2 + selectable.len());
|
||||
let mut provider_ids: Vec<String> = Vec::with_capacity(2 + selectable.len());
|
||||
|
||||
// Detect which providers have API keys already set in the environment.
|
||||
let detected_env: HashMap<&str, bool> = [
|
||||
("nearai", std::env::var("NEARAI_API_KEY").is_ok()),
|
||||
(
|
||||
"anthropic",
|
||||
std::env::var("ANTHROPIC_API_KEY").is_ok()
|
||||
|| std::env::var("ANTHROPIC_OAUTH_TOKEN").is_ok(),
|
||||
),
|
||||
("openai", std::env::var("OPENAI_API_KEY").is_ok()),
|
||||
("openrouter", std::env::var("OPENROUTER_API_KEY").is_ok()),
|
||||
]
|
||||
.into_iter()
|
||||
.collect();
|
||||
options.push("NEAR AI - multi-model access via NEAR account".to_string());
|
||||
provider_ids.push("nearai".to_string());
|
||||
|
||||
// Helper: build a label for a provider entry, prepending a checkmark if detected.
|
||||
let make_label = |id: &str, name: &str, desc: &str| -> String {
|
||||
if detected_env.get(id).copied().unwrap_or(false) {
|
||||
format!("\u{2713} {:<15}- {}", name, desc)
|
||||
} else {
|
||||
format!(" {:<15}- {}", name, desc)
|
||||
}
|
||||
};
|
||||
|
||||
// Collect all entries as (provider_id, label, is_detected).
|
||||
struct ProviderEntry {
|
||||
id: String,
|
||||
label: String,
|
||||
detected: bool,
|
||||
}
|
||||
|
||||
let mut entries: Vec<ProviderEntry> = Vec::with_capacity(2 + selectable.len());
|
||||
|
||||
entries.push(ProviderEntry {
|
||||
id: "nearai".to_string(),
|
||||
label: make_label("nearai", "NEAR AI", "multi-model access via NEAR account"),
|
||||
detected: detected_env.get("nearai").copied().unwrap_or(false),
|
||||
});
|
||||
|
||||
entries.push(ProviderEntry {
|
||||
id: "gemini_oauth".to_string(),
|
||||
label: make_label(
|
||||
"gemini_oauth",
|
||||
"Gemini CLI",
|
||||
"Official Gemini API via Gemini CLI OAuth",
|
||||
),
|
||||
detected: false,
|
||||
});
|
||||
|
||||
entries.push(ProviderEntry {
|
||||
id: "openai_codex".to_string(),
|
||||
label: make_label(
|
||||
"openai_codex",
|
||||
"OpenAI Codex",
|
||||
"ChatGPT subscription (Plus/Pro/Max)",
|
||||
),
|
||||
detected: false,
|
||||
});
|
||||
options.push("OpenAI Codex - ChatGPT subscription (Plus/Pro/Max)".to_string());
|
||||
provider_ids.push("openai_codex".to_string());
|
||||
|
||||
for def in &selectable {
|
||||
let display_name = def
|
||||
.setup
|
||||
.as_ref()
|
||||
.map(|s| s.display_name())
|
||||
.unwrap_or(&def.id);
|
||||
entries.push(ProviderEntry {
|
||||
id: def.id.clone(),
|
||||
label: make_label(&def.id, display_name, &def.description),
|
||||
detected: detected_env.get(def.id.as_str()).copied().unwrap_or(false),
|
||||
});
|
||||
let label = format!(
|
||||
"{:<17}- {}",
|
||||
def.setup
|
||||
.as_ref()
|
||||
.map(|s| s.display_name())
|
||||
.unwrap_or(&def.id),
|
||||
def.description
|
||||
);
|
||||
options.push(label);
|
||||
provider_ids.push(def.id.clone());
|
||||
}
|
||||
|
||||
// Bedrock is a special case (native AWS SDK, not registry-based)
|
||||
entries.push(ProviderEntry {
|
||||
id: "bedrock".to_string(),
|
||||
label: make_label(
|
||||
"bedrock",
|
||||
"AWS Bedrock",
|
||||
"Claude & other models via AWS (IAM, SSO)",
|
||||
),
|
||||
detected: false,
|
||||
});
|
||||
|
||||
// Sort: detected providers first, preserving relative order within each group.
|
||||
entries.sort_by_key(|e| !e.detected);
|
||||
|
||||
let mut options: Vec<String> = Vec::with_capacity(entries.len());
|
||||
let mut provider_ids: Vec<String> = Vec::with_capacity(entries.len());
|
||||
for entry in &entries {
|
||||
options.push(entry.label.clone());
|
||||
provider_ids.push(entry.id.clone());
|
||||
}
|
||||
options.push("AWS Bedrock - Claude & other models via AWS (IAM, SSO)".to_string());
|
||||
provider_ids.push("bedrock".to_string());
|
||||
|
||||
let option_refs: Vec<&str> = options.iter().map(|s| s.as_str()).collect();
|
||||
let choice = select_one("Provider:", &option_refs).map_err(SetupError::Io)?;
|
||||
@@ -1355,8 +1147,6 @@ impl SetupWizard {
|
||||
|
||||
if selected_id == "bedrock" {
|
||||
self.setup_bedrock().await?;
|
||||
} else if selected_id == "gemini_oauth" {
|
||||
self.setup_gemini_oauth().await?;
|
||||
} else {
|
||||
self.run_provider_setup(selected_id, ®istry).await?;
|
||||
}
|
||||
@@ -1451,24 +1241,6 @@ impl SetupWizard {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Detect an Anthropic credential from the environment.
|
||||
///
|
||||
/// Checks `ANTHROPIC_API_KEY` first, then `ANTHROPIC_OAUTH_TOKEN`.
|
||||
/// Returns the key/token string if found, or `None`.
|
||||
fn detect_anthropic_key() -> Option<String> {
|
||||
if let Ok(key) = std::env::var("ANTHROPIC_API_KEY")
|
||||
&& !key.is_empty()
|
||||
{
|
||||
return Some(key);
|
||||
}
|
||||
if let Ok(token) = std::env::var("ANTHROPIC_OAUTH_TOKEN")
|
||||
&& !token.is_empty()
|
||||
{
|
||||
return Some(token);
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
/// Update the selected LLM backend while preserving the current model when
|
||||
/// the backend did not actually change.
|
||||
fn set_llm_backend_preserving_model(&mut self, backend: &str) {
|
||||
@@ -2023,40 +1795,6 @@ impl SetupWizard {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn setup_gemini_oauth(&mut self) -> Result<(), SetupError> {
|
||||
self.settings.llm_backend = Some("gemini_oauth".to_string());
|
||||
print_info("Starting Gemini CLI OAuth authentication...");
|
||||
println!();
|
||||
|
||||
let creds_path = crate::config::GeminiOauthConfig::default_credentials_path();
|
||||
let cred_manager =
|
||||
crate::llm::gemini_oauth::CredentialManager::new(&creds_path).map_err(|e| {
|
||||
SetupError::Config(format!(
|
||||
"Failed to initialize Gemini credential manager: {}",
|
||||
e
|
||||
))
|
||||
})?;
|
||||
|
||||
match cred_manager.get_valid_credential().await {
|
||||
Ok(cred) => {
|
||||
print_success("Gemini CLI authentication successful!");
|
||||
if let Some(ref pid) = cred.project_id {
|
||||
print_info(&format!("Cloud Code project: {}", pid));
|
||||
}
|
||||
}
|
||||
Err(e) => {
|
||||
return Err(SetupError::Config(format!(
|
||||
"Gemini CLI authentication failed: {}. Please try again.",
|
||||
e
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
println!();
|
||||
print_success("Gemini API configured via Gemini CLI");
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Step 4: Model selection.
|
||||
///
|
||||
/// Branches on the selected LLM backend and fetches models from the
|
||||
@@ -2080,157 +1818,109 @@ impl SetupWizard {
|
||||
let backend = self.settings.llm_backend.as_deref().unwrap_or("nearai");
|
||||
let registry = crate::llm::ProviderRegistry::load();
|
||||
|
||||
match backend {
|
||||
"nearai" => {
|
||||
// NEAR AI: use existing provider list_models()
|
||||
let fetched = self.fetch_nearai_models().await;
|
||||
let models = if fetched.is_empty() {
|
||||
crate::llm::default_models()
|
||||
} else {
|
||||
fetched.iter().map(|m| (m.clone(), m.clone())).collect()
|
||||
if backend == "nearai" {
|
||||
// NEAR AI: use existing provider list_models()
|
||||
let fetched = self.fetch_nearai_models().await;
|
||||
let models = if fetched.is_empty() {
|
||||
crate::llm::default_models()
|
||||
} else {
|
||||
fetched.iter().map(|m| (m.clone(), m.clone())).collect()
|
||||
};
|
||||
self.select_from_model_list(&models)?;
|
||||
} else if let Some(def) = registry.find(backend) {
|
||||
let can_list = def
|
||||
.setup
|
||||
.as_ref()
|
||||
.map(|s| s.can_list_models())
|
||||
.unwrap_or(false);
|
||||
|
||||
if can_list {
|
||||
// Try to fetch models from the provider's /v1/models endpoint
|
||||
let cached_key = self
|
||||
.llm_api_key
|
||||
.as_ref()
|
||||
.map(|k| k.expose_secret().to_string());
|
||||
|
||||
let models = match backend {
|
||||
"anthropic" => fetch_anthropic_models(cached_key.as_deref()).await,
|
||||
"openai" => fetch_openai_models(cached_key.as_deref()).await,
|
||||
"ollama" => {
|
||||
let base_url = self
|
||||
.settings
|
||||
.ollama_base_url
|
||||
.as_deref()
|
||||
.or(def.default_base_url.as_deref())
|
||||
.unwrap_or("http://localhost:11434");
|
||||
let models = fetch_ollama_models(base_url).await;
|
||||
if models.is_empty() {
|
||||
print_info("No models found. Pull one first: ollama pull llama3");
|
||||
}
|
||||
models
|
||||
}
|
||||
_ => {
|
||||
// Generic OpenAI-compatible model listing
|
||||
let base_url = def.default_base_url.as_deref().unwrap_or("");
|
||||
fetch_openai_compatible_models(base_url, cached_key.as_deref()).await
|
||||
}
|
||||
};
|
||||
self.select_from_model_list(&models)?;
|
||||
}
|
||||
"gemini_oauth" | "gemini-oauth" => {
|
||||
let default_models: Vec<(String, String)> = vec![
|
||||
(
|
||||
"gemini-3.1-pro-preview".into(),
|
||||
"Gemini 3.1 Pro (Latest, strongest reasoning)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-3.1-pro-preview-customtools".into(),
|
||||
"Gemini 3.1 Pro Custom Tools (Enhanced tool use)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-3-pro-preview".into(),
|
||||
"Gemini 3 Pro (Preview)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-3-flash-preview".into(),
|
||||
"Gemini 3 Flash (Fast preview with thinking)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-3.1-flash-lite-preview".into(),
|
||||
"Gemini 3.1 Flash Lite (Preview, lightweight)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-2.5-pro".into(),
|
||||
"Gemini 2.5 Pro (Stable, strong reasoning)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-2.5-flash".into(),
|
||||
"Gemini 2.5 Flash (Fast, good quality)".into(),
|
||||
),
|
||||
(
|
||||
"gemini-2.5-flash-lite".into(),
|
||||
"Gemini 2.5 Flash Lite (Fastest, lightweight)".into(),
|
||||
),
|
||||
];
|
||||
self.select_from_model_list(&default_models)?;
|
||||
}
|
||||
"bedrock" => {
|
||||
let model_id =
|
||||
input("Bedrock model ID (e.g., anthropic.claude-v3-sonnet-20240229-v1:0)")
|
||||
|
||||
// Apply models_filter from setup hint (e.g., Groq "chat" filters non-chat models)
|
||||
let models =
|
||||
if let Some(filter) = def.setup.as_ref().and_then(|s| s.models_filter()) {
|
||||
let filter_lower = filter.to_lowercase();
|
||||
models
|
||||
.into_iter()
|
||||
.filter(|(id, _)| id.to_lowercase().contains(&filter_lower))
|
||||
.collect()
|
||||
} else {
|
||||
models
|
||||
};
|
||||
|
||||
if models.is_empty() {
|
||||
// Fall back to manual entry
|
||||
let default = &def.default_model;
|
||||
let model_id = input(&format!("Model name (default: {default})"))
|
||||
.map_err(SetupError::Io)?;
|
||||
if model_id.is_empty() {
|
||||
return Err(SetupError::Config("Model ID is required".to_string()));
|
||||
let model_id = if model_id.is_empty() {
|
||||
default.clone()
|
||||
} else {
|
||||
model_id
|
||||
};
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
} else {
|
||||
self.select_from_model_list(&models)?;
|
||||
}
|
||||
} else {
|
||||
// Manual model entry
|
||||
let default = &def.default_model;
|
||||
let model_id =
|
||||
input(&format!("Model name (default: {default})")).map_err(SetupError::Io)?;
|
||||
let model_id = if model_id.is_empty() {
|
||||
default.clone()
|
||||
} else {
|
||||
model_id
|
||||
};
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
}
|
||||
_ => {
|
||||
if let Some(def) = registry.find(backend) {
|
||||
let can_list = def
|
||||
.setup
|
||||
.as_ref()
|
||||
.map(|s| s.can_list_models())
|
||||
.unwrap_or(false);
|
||||
|
||||
if can_list {
|
||||
// Try to fetch models from the provider's /v1/models endpoint
|
||||
let cached_key = self
|
||||
.llm_api_key
|
||||
.as_ref()
|
||||
.map(|k| k.expose_secret().to_string());
|
||||
|
||||
let models = match backend {
|
||||
"anthropic" => fetch_anthropic_models(cached_key.as_deref()).await,
|
||||
"openai" => fetch_openai_models(cached_key.as_deref()).await,
|
||||
"ollama" => {
|
||||
let base_url = self
|
||||
.settings
|
||||
.ollama_base_url
|
||||
.as_deref()
|
||||
.or(def.default_base_url.as_deref())
|
||||
.unwrap_or("http://localhost:11434");
|
||||
let models = fetch_ollama_models(base_url).await;
|
||||
if models.is_empty() {
|
||||
print_info(
|
||||
"No models found. Pull one first: ollama pull llama3",
|
||||
);
|
||||
}
|
||||
models
|
||||
}
|
||||
_ => {
|
||||
// Generic OpenAI-compatible model listing
|
||||
let base_url = def.default_base_url.as_deref().unwrap_or("");
|
||||
fetch_openai_compatible_models(base_url, cached_key.as_deref())
|
||||
.await
|
||||
}
|
||||
};
|
||||
|
||||
// Apply models_filter from setup hint
|
||||
let models = if let Some(filter) =
|
||||
def.setup.as_ref().and_then(|s| s.models_filter())
|
||||
{
|
||||
let filter_lower = filter.to_lowercase();
|
||||
models
|
||||
.into_iter()
|
||||
.filter(|(id, _)| id.to_lowercase().contains(&filter_lower))
|
||||
.collect()
|
||||
} else {
|
||||
models
|
||||
};
|
||||
|
||||
if models.is_empty() {
|
||||
// Fall back to manual entry
|
||||
let default = &def.default_model;
|
||||
let model_id = input(&format!("Model name (default: {default})"))
|
||||
.map_err(SetupError::Io)?;
|
||||
let model_id = if model_id.is_empty() {
|
||||
default.clone()
|
||||
} else {
|
||||
model_id
|
||||
};
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
} else {
|
||||
self.select_from_model_list(&models)?;
|
||||
}
|
||||
} else {
|
||||
// Manual model entry
|
||||
let default = &def.default_model;
|
||||
let model_id = input(&format!("Model name (default: {default})"))
|
||||
.map_err(SetupError::Io)?;
|
||||
let model_id = if model_id.is_empty() {
|
||||
default.clone()
|
||||
} else {
|
||||
model_id
|
||||
};
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
}
|
||||
} else {
|
||||
// Unknown provider, manual entry
|
||||
let model_id = input("Model name (e.g., meta-llama/Llama-3-8b-chat-hf)")
|
||||
.map_err(SetupError::Io)?;
|
||||
if model_id.is_empty() {
|
||||
return Err(SetupError::Config("Model name is required".to_string()));
|
||||
}
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
}
|
||||
} else if backend == "bedrock" {
|
||||
let model_id = input("Bedrock model ID (e.g., anthropic.claude-opus-4-6-v1)")
|
||||
.map_err(SetupError::Io)?;
|
||||
if model_id.is_empty() {
|
||||
return Err(SetupError::Config("Model ID is required".to_string()));
|
||||
}
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
} else {
|
||||
// Unknown provider, manual entry
|
||||
let model_id = input("Model name (e.g., meta-llama/Llama-3-8b-chat-hf)")
|
||||
.map_err(SetupError::Io)?;
|
||||
if model_id.is_empty() {
|
||||
return Err(SetupError::Config("Model name is required".to_string()));
|
||||
}
|
||||
self.settings.selected_model = Some(model_id.clone());
|
||||
print_success(&format!("Selected {}", model_id));
|
||||
}
|
||||
|
||||
Ok(())
|
||||
@@ -3286,11 +2976,8 @@ impl SetupWizard {
|
||||
let _ = loaded;
|
||||
}
|
||||
|
||||
/// Save settings to the database and `~/.ironclaw/.env`, then print
|
||||
/// a warm completion card with the 3 key facts.
|
||||
/// Save settings to the database and `~/.ironclaw/.env`, then print summary.
|
||||
async fn save_and_summarize(&mut self) -> Result<(), SetupError> {
|
||||
use crate::cli::fmt;
|
||||
|
||||
self.settings.onboard_completed = true;
|
||||
|
||||
// Final persist (idempotent — earlier incremental saves already wrote
|
||||
@@ -3306,108 +2993,117 @@ impl SetupWizard {
|
||||
// Write bootstrap env (also idempotent)
|
||||
self.write_bootstrap_env()?;
|
||||
|
||||
// ── Completion card ───────────────────────────────────
|
||||
let sep = fmt::separator(38);
|
||||
|
||||
println!();
|
||||
println!(" {}", sep);
|
||||
print_success("Configuration saved to database");
|
||||
println!();
|
||||
|
||||
// Title line: checkmark + "ironclaw is ready"
|
||||
println!(
|
||||
" {}\u{2713}{} {}ironclaw is ready{}",
|
||||
fmt::success(),
|
||||
fmt::reset(),
|
||||
fmt::bold_accent(),
|
||||
fmt::reset(),
|
||||
);
|
||||
println!();
|
||||
// Print summary
|
||||
println!("Configuration Summary:");
|
||||
println!("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
|
||||
|
||||
// Fact 1: Provider + model
|
||||
let provider_display = match self.settings.llm_backend.as_deref() {
|
||||
Some("nearai") => "NEAR AI".to_string(),
|
||||
Some("anthropic") => "Anthropic".to_string(),
|
||||
Some("openai") => "OpenAI".to_string(),
|
||||
Some("ollama") => "Ollama".to_string(),
|
||||
Some("openai_compatible") => "OpenAI-compatible".to_string(),
|
||||
Some("bedrock") => "AWS Bedrock".to_string(),
|
||||
Some("openai_codex") => "OpenAI Codex".to_string(),
|
||||
Some("gemini_oauth") => "Gemini CLI".to_string(),
|
||||
Some(other) => other.to_string(),
|
||||
None => "unknown".to_string(),
|
||||
};
|
||||
let model_suffix = if let Some(ref model) = self.settings.selected_model {
|
||||
let backend = self
|
||||
.settings
|
||||
.database_backend
|
||||
.as_deref()
|
||||
.unwrap_or("postgres");
|
||||
match backend {
|
||||
"libsql" => {
|
||||
if let Some(ref path) = self.settings.libsql_path {
|
||||
println!(" Database: libSQL ({})", path);
|
||||
} else {
|
||||
println!(" Database: libSQL (default path)");
|
||||
}
|
||||
if self.settings.libsql_url.is_some() {
|
||||
println!(" Turso sync: enabled");
|
||||
}
|
||||
}
|
||||
_ => {
|
||||
if self.settings.database_url.is_some() {
|
||||
println!(" Database: PostgreSQL (configured)");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match self.settings.secrets_master_key_source {
|
||||
KeySource::Keychain => println!(" Security: OS keychain"),
|
||||
KeySource::Env => println!(" Security: environment variable"),
|
||||
KeySource::None => println!(" Security: disabled"),
|
||||
}
|
||||
|
||||
if let Some(ref provider) = self.settings.llm_backend {
|
||||
let display = match provider.as_str() {
|
||||
"nearai" => "NEAR AI",
|
||||
"anthropic" => "Anthropic",
|
||||
"openai" => "OpenAI",
|
||||
"ollama" => "Ollama",
|
||||
"openai_compatible" => "OpenAI-compatible",
|
||||
"bedrock" => "AWS Bedrock",
|
||||
"openai_codex" => "OpenAI Codex",
|
||||
other => other,
|
||||
};
|
||||
println!(" Provider: {}", display);
|
||||
}
|
||||
|
||||
if let Some(ref model) = self.settings.selected_model {
|
||||
// Truncate long model names (char-based to avoid UTF-8 panic)
|
||||
let display = if model.chars().count() > 30 {
|
||||
let truncated: String = model.chars().take(27).collect();
|
||||
let display = if model.chars().count() > 40 {
|
||||
let truncated: String = model.chars().take(37).collect();
|
||||
format!("{}...", truncated)
|
||||
} else {
|
||||
model.clone()
|
||||
};
|
||||
format!(" ({})", display)
|
||||
println!(" Model: {}", display);
|
||||
}
|
||||
|
||||
if self.settings.embeddings.enabled {
|
||||
println!(
|
||||
" Embeddings: {} ({})",
|
||||
self.settings.embeddings.provider, self.settings.embeddings.model
|
||||
);
|
||||
} else {
|
||||
String::new()
|
||||
};
|
||||
let provider_value = format!("{}{}", provider_display, model_suffix);
|
||||
println!(
|
||||
" {}provider{} {}{}{}",
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::accent(),
|
||||
provider_value,
|
||||
fmt::reset(),
|
||||
);
|
||||
println!(" Embeddings: disabled");
|
||||
}
|
||||
|
||||
// Fact 2: Database
|
||||
let db_display = match self.settings.database_backend.as_deref() {
|
||||
Some("libsql") => "libSQL".to_string(),
|
||||
Some("postgres") | Some("postgresql") => "PostgreSQL".to_string(),
|
||||
Some(other) => other.to_string(),
|
||||
None => "unknown".to_string(),
|
||||
};
|
||||
println!(
|
||||
" {}database{} {}{}{}",
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::accent(),
|
||||
db_display,
|
||||
fmt::reset(),
|
||||
);
|
||||
if let Some(ref tunnel_url) = self.settings.tunnel.public_url {
|
||||
println!(" Tunnel: {} (static)", tunnel_url);
|
||||
} else if let Some(ref provider) = self.settings.tunnel.provider {
|
||||
println!(" Tunnel: {} (managed, starts at boot)", provider);
|
||||
}
|
||||
|
||||
// Fact 3: Security
|
||||
let security_display = match self.settings.secrets_master_key_source {
|
||||
KeySource::Keychain => "OS keychain",
|
||||
KeySource::Env => "environment variable",
|
||||
KeySource::None => "disabled",
|
||||
};
|
||||
println!(
|
||||
" {}security{} {}{}{}",
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::accent(),
|
||||
security_display,
|
||||
fmt::reset(),
|
||||
);
|
||||
let has_tunnel =
|
||||
self.settings.tunnel.public_url.is_some() || self.settings.tunnel.provider.is_some();
|
||||
|
||||
println!(" Channels:");
|
||||
println!(" - CLI/TUI: enabled");
|
||||
|
||||
if self.settings.channels.http_enabled {
|
||||
let port = self.settings.channels.http_port.unwrap_or(8080);
|
||||
println!(" - HTTP: enabled (port {})", port);
|
||||
}
|
||||
|
||||
for channel_name in &self.settings.channels.wasm_channels {
|
||||
let mode = if has_tunnel { "webhook" } else { "polling" };
|
||||
println!(
|
||||
" - {}: enabled ({})",
|
||||
capitalize_first(channel_name),
|
||||
mode
|
||||
);
|
||||
}
|
||||
|
||||
if self.settings.heartbeat.enabled {
|
||||
println!(
|
||||
" Heartbeat: every {} minutes",
|
||||
self.settings.heartbeat.interval_secs / 60
|
||||
);
|
||||
}
|
||||
|
||||
println!();
|
||||
println!(" {}", sep);
|
||||
println!("To start the agent, run:");
|
||||
println!(" ironclaw");
|
||||
println!();
|
||||
|
||||
// Action hints
|
||||
println!(
|
||||
" {}Start chatting:{} {}ironclaw{}",
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::bold_accent(),
|
||||
fmt::reset(),
|
||||
);
|
||||
println!(
|
||||
" {}Full setup:{} {}ironclaw onboard{}",
|
||||
fmt::dim(),
|
||||
fmt::reset(),
|
||||
fmt::bold_accent(),
|
||||
fmt::reset(),
|
||||
);
|
||||
println!("To change settings later:");
|
||||
println!(" ironclaw config set <setting> <value>");
|
||||
println!(" ironclaw onboard");
|
||||
println!();
|
||||
|
||||
if self.config.quick {
|
||||
@@ -3736,7 +3432,7 @@ mod tests {
|
||||
use tempfile::tempdir;
|
||||
|
||||
use super::*;
|
||||
use crate::config::helpers::lock_env;
|
||||
use crate::config::helpers::ENV_MUTEX;
|
||||
|
||||
#[test]
|
||||
fn test_wizard_creation() {
|
||||
@@ -3752,7 +3448,6 @@ mod tests {
|
||||
channels_only: false,
|
||||
provider_only: false,
|
||||
quick: false,
|
||||
steps: vec![],
|
||||
};
|
||||
let wizard = SetupWizard::with_config(config);
|
||||
assert!(wizard.config.skip_auth);
|
||||
@@ -3760,7 +3455,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_wizard_owner_id_uses_resolved_env_scope() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let _owner = EnvGuard::set("IRONCLAW_OWNER_ID", " wizard-owner ");
|
||||
|
||||
let wizard = SetupWizard::new();
|
||||
@@ -3769,7 +3464,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn test_wizard_owner_id_uses_toml_scope() {
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let _owner = EnvGuard::clear("IRONCLAW_OWNER_ID");
|
||||
let dir = tempdir().unwrap(); // safety: test-only tempdir setup
|
||||
let path = dir.path().join("config.toml");
|
||||
@@ -3785,7 +3480,7 @@ mod tests {
|
||||
fn test_try_with_config_and_toml_propagates_invalid_owner_env() {
|
||||
use std::os::unix::ffi::OsStringExt;
|
||||
|
||||
let _guard = lock_env();
|
||||
let _guard = ENV_MUTEX.lock().unwrap_or_else(|e| e.into_inner());
|
||||
let original = std::env::var_os("IRONCLAW_OWNER_ID");
|
||||
unsafe {
|
||||
std::env::set_var("IRONCLAW_OWNER_ID", OsString::from_vec(vec![0x66, 0x80]));
|
||||
@@ -4245,7 +3940,7 @@ mod tests {
|
||||
fn test_build_nearai_model_fetch_config_picks_up_api_key_env() {
|
||||
use secrecy::ExposeSecret;
|
||||
|
||||
let _lock = lock_env();
|
||||
let _lock = ENV_MUTEX.lock().unwrap();
|
||||
let _guard = EnvGuard::set("NEARAI_API_KEY", "test-cloud-api-key-12345");
|
||||
let _guard2 = EnvGuard::clear("NEARAI_BASE_URL");
|
||||
|
||||
@@ -4269,7 +3964,7 @@ mod tests {
|
||||
/// the config should have `api_key: None` (session token path).
|
||||
#[test]
|
||||
fn test_build_nearai_model_fetch_config_none_when_no_api_key() {
|
||||
let _lock = lock_env();
|
||||
let _lock = ENV_MUTEX.lock().unwrap();
|
||||
let _guard = EnvGuard::clear("NEARAI_API_KEY");
|
||||
let _guard2 = EnvGuard::clear("NEARAI_BASE_URL");
|
||||
|
||||
@@ -4288,7 +3983,7 @@ mod tests {
|
||||
/// Regression test for #799: empty NEARAI_API_KEY should be treated as absent.
|
||||
#[test]
|
||||
fn test_build_nearai_model_fetch_config_none_when_empty_api_key() {
|
||||
let _lock = lock_env();
|
||||
let _lock = ENV_MUTEX.lock().unwrap();
|
||||
let _guard = EnvGuard::set("NEARAI_API_KEY", "");
|
||||
|
||||
let config = build_nearai_model_fetch_config();
|
||||
@@ -4306,7 +4001,7 @@ mod tests {
|
||||
fn test_model_discovery_picks_up_injected_var() {
|
||||
use secrecy::ExposeSecret;
|
||||
|
||||
let _lock = lock_env();
|
||||
let _lock = ENV_MUTEX.lock().unwrap();
|
||||
let _guard = EnvGuard::clear("NEARAI_API_KEY");
|
||||
let _guard2 = EnvGuard::clear("NEARAI_BASE_URL");
|
||||
|
||||
@@ -4337,7 +4032,7 @@ mod tests {
|
||||
/// the NEAR AI authentication menu.
|
||||
#[test]
|
||||
fn test_build_nearai_model_fetch_config_picks_up_runtime_env() {
|
||||
let _lock = lock_env();
|
||||
let _lock = ENV_MUTEX.lock().unwrap();
|
||||
// Ensure the real env var is unset so the only source is the overlay.
|
||||
let _guard = EnvGuard::clear("NEARAI_API_KEY");
|
||||
|
||||
|
||||
+13
-10
@@ -19,7 +19,7 @@ pub async fn execute_tool_with_safety(
|
||||
tools: &ToolRegistry,
|
||||
safety: &SafetyLayer,
|
||||
tool_name: &str,
|
||||
params: serde_json::Value,
|
||||
params: &serde_json::Value,
|
||||
job_ctx: &JobContext,
|
||||
) -> Result<String, Error> {
|
||||
if tool_name.is_empty() {
|
||||
@@ -35,7 +35,7 @@ pub async fn execute_tool_with_safety(
|
||||
name: tool_name.to_string(),
|
||||
})?;
|
||||
|
||||
let normalized_params = prepare_tool_params(tool.as_ref(), ¶ms);
|
||||
let normalized_params = prepare_tool_params(tool.as_ref(), params);
|
||||
|
||||
// Validate tool parameters
|
||||
let validation = safety.validator().validate_tool_params(&normalized_params);
|
||||
@@ -63,7 +63,10 @@ pub async fn execute_tool_with_safety(
|
||||
// Execute with per-tool timeout
|
||||
let timeout = tool.execution_timeout();
|
||||
let start = std::time::Instant::now();
|
||||
let result = tokio::time::timeout(timeout, tool.execute(normalized_params, job_ctx)).await;
|
||||
let result = tokio::time::timeout(timeout, async {
|
||||
tool.execute(normalized_params.clone(), job_ctx).await
|
||||
})
|
||||
.await;
|
||||
let elapsed = start.elapsed();
|
||||
|
||||
match &result {
|
||||
@@ -146,7 +149,7 @@ pub async fn execute_tool_simple(
|
||||
tools: &ToolRegistry,
|
||||
safety: &SafetyLayer,
|
||||
tool_name: &str,
|
||||
params: serde_json::Value,
|
||||
params: &serde_json::Value,
|
||||
job_ctx: &JobContext,
|
||||
) -> Result<String, String> {
|
||||
execute_tool_with_safety(tools, safety, tool_name, params, job_ctx)
|
||||
@@ -305,7 +308,7 @@ mod tests {
|
||||
®istry,
|
||||
&safety,
|
||||
"",
|
||||
serde_json::json!({}),
|
||||
&serde_json::json!({}),
|
||||
&test_job_ctx(),
|
||||
)
|
||||
.await;
|
||||
@@ -328,7 +331,7 @@ mod tests {
|
||||
let params = serde_json::json!({"message": "hello"});
|
||||
|
||||
let result =
|
||||
execute_tool_with_safety(®istry, &safety, "echo", params, &test_job_ctx()).await;
|
||||
execute_tool_with_safety(®istry, &safety, "echo", ¶ms, &test_job_ctx()).await;
|
||||
|
||||
assert!(result.is_ok(), "Echo tool should succeed");
|
||||
let output = result.unwrap();
|
||||
@@ -347,7 +350,7 @@ mod tests {
|
||||
®istry,
|
||||
&safety,
|
||||
"nonexistent",
|
||||
serde_json::json!({}),
|
||||
&serde_json::json!({}),
|
||||
&test_job_ctx(),
|
||||
)
|
||||
.await;
|
||||
@@ -370,7 +373,7 @@ mod tests {
|
||||
®istry,
|
||||
&safety,
|
||||
"fail_tool",
|
||||
serde_json::json!({}),
|
||||
&serde_json::json!({}),
|
||||
&test_job_ctx(),
|
||||
)
|
||||
.await;
|
||||
@@ -394,7 +397,7 @@ mod tests {
|
||||
®istry,
|
||||
&safety,
|
||||
"slow_tool",
|
||||
serde_json::json!({}),
|
||||
&serde_json::json!({}),
|
||||
&test_job_ctx(),
|
||||
)
|
||||
.await;
|
||||
@@ -422,7 +425,7 @@ mod tests {
|
||||
®istry,
|
||||
&safety,
|
||||
"array_echo",
|
||||
serde_json::json!({"values": "[\"1\", \"2\", 3]"}),
|
||||
&serde_json::json!({"values": "[\"1\", \"2\", 3]"}),
|
||||
&test_job_ctx(),
|
||||
)
|
||||
.await
|
||||
|
||||
@@ -130,16 +130,6 @@ impl McpTransport for HttpMcpTransport {
|
||||
)));
|
||||
}
|
||||
|
||||
// MCP notifications commonly acknowledge with 202 Accepted and no body.
|
||||
if response.status() == reqwest::StatusCode::ACCEPTED {
|
||||
return Ok(McpResponse {
|
||||
jsonrpc: "2.0".to_string(),
|
||||
id: request.id,
|
||||
result: None,
|
||||
error: None,
|
||||
});
|
||||
}
|
||||
|
||||
// Determine response format from Content-Type.
|
||||
let content_type = response
|
||||
.headers()
|
||||
@@ -516,55 +506,4 @@ mod tests {
|
||||
let echoed = response.result.unwrap();
|
||||
assert_eq!(echoed["authorization"], "Bearer custom-token");
|
||||
}
|
||||
|
||||
async fn spawn_accepted_server() -> (String, tokio::task::JoinHandle<()>) {
|
||||
use axum::{Router, routing::post};
|
||||
use tokio::net::TcpListener;
|
||||
|
||||
async fn accepted() -> axum::http::StatusCode {
|
||||
axum::http::StatusCode::ACCEPTED
|
||||
}
|
||||
|
||||
let app = Router::new().route("/", post(accepted));
|
||||
let listener = TcpListener::bind("127.0.0.1:0")
|
||||
.await
|
||||
.expect("Failed to bind to an ephemeral port");
|
||||
let addr = listener
|
||||
.local_addr()
|
||||
.expect("Failed to get listener's local address");
|
||||
let url = format!("http://127.0.0.1:{}", addr.port());
|
||||
|
||||
let handle = tokio::spawn(async move {
|
||||
axum::serve(listener, app)
|
||||
.await
|
||||
.expect("Test server failed to run");
|
||||
});
|
||||
|
||||
(url, handle)
|
||||
}
|
||||
|
||||
fn notification_request(method: &str) -> McpRequest {
|
||||
McpRequest {
|
||||
jsonrpc: "2.0".to_string(),
|
||||
id: None,
|
||||
method: method.to_string(),
|
||||
params: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_accepted_notification_returns_empty_response() {
|
||||
let (url, _handle) = spawn_accepted_server().await;
|
||||
let transport = HttpMcpTransport::new(&url, "accepted-test");
|
||||
let request = notification_request("notifications/initialized");
|
||||
|
||||
let response = transport
|
||||
.send(&request, &HashMap::new())
|
||||
.await
|
||||
.expect("202 notification response");
|
||||
assert_eq!(response.jsonrpc, "2.0");
|
||||
assert_eq!(response.id, request.id);
|
||||
assert!(response.result.is_none());
|
||||
assert!(response.error.is_none());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -604,7 +604,7 @@ impl ToolRegistry {
|
||||
self.register(Arc::new(BuildSoftwareTool::new(Arc::clone(&builder))))
|
||||
.await;
|
||||
|
||||
tracing::debug!("Registered software builder tool");
|
||||
tracing::info!("Registered software builder tool");
|
||||
builder
|
||||
}
|
||||
|
||||
|
||||
@@ -206,7 +206,7 @@ impl WasmToolLoader {
|
||||
})
|
||||
.await?;
|
||||
|
||||
tracing::debug!(
|
||||
tracing::info!(
|
||||
name = name,
|
||||
wasm_path = %wasm_path.display(),
|
||||
"Loaded WASM tool from file"
|
||||
@@ -306,7 +306,7 @@ impl WasmToolLoader {
|
||||
}
|
||||
|
||||
if !results.loaded.is_empty() {
|
||||
tracing::debug!(
|
||||
tracing::info!(
|
||||
count = results.loaded.len(),
|
||||
tools = ?results.loaded,
|
||||
"Loaded WASM tools from directory"
|
||||
|
||||
@@ -312,7 +312,7 @@ impl WasmToolRuntime {
|
||||
.insert(prepared.name.clone(), Arc::clone(&prepared));
|
||||
}
|
||||
|
||||
tracing::debug!(
|
||||
tracing::info!(
|
||||
name = %prepared.name,
|
||||
"Prepared WASM tool for execution"
|
||||
);
|
||||
|
||||
+13
-23
@@ -1,6 +1,6 @@
|
||||
//! Custom tunnel via an arbitrary shell command.
|
||||
|
||||
use anyhow::{Context, Result, bail};
|
||||
use anyhow::{Result, bail};
|
||||
use tokio::io::AsyncBufReadExt;
|
||||
use tokio::process::Command;
|
||||
|
||||
@@ -27,7 +27,6 @@ pub struct CustomTunnel {
|
||||
url_pattern: Option<String>,
|
||||
proc: SharedProcess,
|
||||
url: SharedUrl,
|
||||
http_client: reqwest::Client,
|
||||
}
|
||||
|
||||
impl CustomTunnel {
|
||||
@@ -35,19 +34,14 @@ impl CustomTunnel {
|
||||
start_command: String,
|
||||
health_url: Option<String>,
|
||||
url_pattern: Option<String>,
|
||||
) -> Result<Self> {
|
||||
let http_client = reqwest::Client::builder()
|
||||
.timeout(std::time::Duration::from_secs(5))
|
||||
.build()
|
||||
.context("failed to create HTTP client for tunnel health checks")?;
|
||||
Ok(Self {
|
||||
) -> Self {
|
||||
Self {
|
||||
start_command,
|
||||
health_url,
|
||||
url_pattern,
|
||||
proc: new_shared_process(),
|
||||
url: new_shared_url(),
|
||||
http_client,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -146,9 +140,9 @@ impl Tunnel for CustomTunnel {
|
||||
|
||||
async fn health_check(&self) -> bool {
|
||||
if let Some(ref url) = self.health_url {
|
||||
return self
|
||||
.http_client
|
||||
return reqwest::Client::new()
|
||||
.get(url)
|
||||
.timeout(std::time::Duration::from_secs(5))
|
||||
.send()
|
||||
.await
|
||||
.is_ok();
|
||||
@@ -179,7 +173,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn empty_command_returns_error() {
|
||||
let tunnel = CustomTunnel::new(" ".into(), None, None).unwrap();
|
||||
let tunnel = CustomTunnel::new(" ".into(), None, None);
|
||||
let result = tunnel.start("127.0.0.1", 8080).await;
|
||||
assert!(result.is_err());
|
||||
assert!(
|
||||
@@ -192,7 +186,7 @@ mod tests {
|
||||
|
||||
#[tokio::test]
|
||||
async fn start_without_pattern_returns_local() {
|
||||
let tunnel = CustomTunnel::new("sleep 1".into(), None, None).unwrap();
|
||||
let tunnel = CustomTunnel::new("sleep 1".into(), None, None);
|
||||
let url = tunnel.start("127.0.0.1", 4455).await.unwrap();
|
||||
assert_eq!(url, "http://127.0.0.1:4455");
|
||||
tunnel.stop().await.unwrap();
|
||||
@@ -204,8 +198,7 @@ mod tests {
|
||||
"echo https://public.example".into(),
|
||||
None,
|
||||
Some("public.example".into()),
|
||||
)
|
||||
.unwrap();
|
||||
);
|
||||
let url = tunnel.start("localhost", 9999).await.unwrap();
|
||||
assert_eq!(url, "https://public.example");
|
||||
tunnel.stop().await.unwrap();
|
||||
@@ -220,8 +213,7 @@ mod tests {
|
||||
r"printf http://internal:1234\nhttps://real.tunnel.io/abc\n".into(),
|
||||
None,
|
||||
Some("tunnel.io".into()),
|
||||
)
|
||||
.unwrap();
|
||||
);
|
||||
let url = tunnel.start("localhost", 9999).await.unwrap();
|
||||
assert_eq!(url, "https://real.tunnel.io/abc");
|
||||
tunnel.stop().await.unwrap();
|
||||
@@ -233,8 +225,7 @@ mod tests {
|
||||
"echo http://{host}:{port}".into(),
|
||||
None,
|
||||
Some("http://".into()),
|
||||
)
|
||||
.unwrap();
|
||||
);
|
||||
let url = tunnel.start("10.1.2.3", 4321).await.unwrap();
|
||||
assert_eq!(url, "http://10.1.2.3:4321");
|
||||
tunnel.stop().await.unwrap();
|
||||
@@ -247,8 +238,7 @@ mod tests {
|
||||
"sleep 1".into(),
|
||||
Some("http://192.0.2.1:9999/healthz".into()),
|
||||
None,
|
||||
)
|
||||
.unwrap();
|
||||
);
|
||||
assert!(
|
||||
!tunnel.health_check().await,
|
||||
"Health check should fail for unreachable URL"
|
||||
@@ -281,7 +271,7 @@ mod tests {
|
||||
// `yes` floods stdout indefinitely; without the drain task the pipe
|
||||
// buffer fills (64 KB) and the child blocks on write(), becoming a
|
||||
// zombie. With draining the child stays alive and stop() can kill it.
|
||||
let tunnel = CustomTunnel::new("yes".into(), None, None).unwrap();
|
||||
let tunnel = CustomTunnel::new("yes".into(), None, None);
|
||||
let url = tunnel.start("127.0.0.1", 19999).await.unwrap();
|
||||
assert_eq!(url, "http://127.0.0.1:19999");
|
||||
|
||||
|
||||
+4
-4
@@ -171,7 +171,7 @@ pub fn create_tunnel(config: &TunnelProviderConfig) -> Result<Option<Box<dyn Tun
|
||||
cu.start_command.clone(),
|
||||
cu.health_url.clone(),
|
||||
cu.url_pattern.clone(),
|
||||
)?)))
|
||||
))))
|
||||
}
|
||||
|
||||
other => bail!(
|
||||
@@ -190,7 +190,7 @@ pub async fn start_managed_tunnel(
|
||||
mut config: crate::config::Config,
|
||||
) -> (crate::config::Config, Option<Box<dyn Tunnel>>) {
|
||||
if config.tunnel.public_url.is_some() {
|
||||
tracing::debug!(
|
||||
tracing::info!(
|
||||
"Static tunnel URL in use: {}",
|
||||
config.tunnel.public_url.as_deref().unwrap_or("?")
|
||||
);
|
||||
@@ -216,7 +216,7 @@ pub async fn start_managed_tunnel(
|
||||
|
||||
match create_tunnel(provider_config) {
|
||||
Ok(Some(tunnel)) => {
|
||||
tracing::debug!(
|
||||
tracing::info!(
|
||||
"Starting {} tunnel on {}:{}...",
|
||||
tunnel.name(),
|
||||
gateway_host,
|
||||
@@ -224,7 +224,7 @@ pub async fn start_managed_tunnel(
|
||||
);
|
||||
match tunnel.start(gateway_host, gateway_port).await {
|
||||
Ok(url) => {
|
||||
tracing::debug!("Tunnel started: {}", url);
|
||||
tracing::info!("Tunnel started: {}", url);
|
||||
config.tunnel.public_url = Some(url);
|
||||
(config, Some(tunnel))
|
||||
}
|
||||
|
||||
@@ -462,14 +462,9 @@ impl LoopDelegate for ContainerDelegate {
|
||||
..Default::default()
|
||||
};
|
||||
|
||||
let result = execute_tool_simple(
|
||||
&self.tools,
|
||||
&self.safety,
|
||||
&tc.name,
|
||||
tc.arguments.clone(),
|
||||
&job_ctx,
|
||||
)
|
||||
.await;
|
||||
let result =
|
||||
execute_tool_simple(&self.tools, &self.safety, &tc.name, &tc.arguments, &job_ctx)
|
||||
.await;
|
||||
|
||||
self.post_event(
|
||||
"tool_result",
|
||||
@@ -477,7 +472,7 @@ impl LoopDelegate for ContainerDelegate {
|
||||
"tool_name": tc.name,
|
||||
"output": match &result {
|
||||
Ok(output) => truncate_for_preview(output, 2000),
|
||||
Err(e) => format!("Error: {}", truncate_for_preview(e, 500)).into(),
|
||||
Err(e) => format!("Error: {}", truncate_for_preview(e, 500)),
|
||||
},
|
||||
"success": result.is_ok(),
|
||||
}),
|
||||
|
||||
+1
-5
@@ -800,16 +800,12 @@ Report when the job is complete or if you encounter issues you cannot resolve."#
|
||||
});
|
||||
}
|
||||
|
||||
let error_preview = {
|
||||
let msg = format!("Error: {}", e);
|
||||
truncate_for_preview(&msg, 500).into_owned()
|
||||
};
|
||||
self.log_event(
|
||||
"tool_result",
|
||||
serde_json::json!({
|
||||
"tool_name": selection.tool_name,
|
||||
"success": false,
|
||||
"output": error_preview,
|
||||
"output": truncate_for_preview(&format!("Error: {}", e), 500),
|
||||
}),
|
||||
);
|
||||
|
||||
|
||||
@@ -558,10 +558,6 @@ impl Workspace {
|
||||
/// which uses `\n\n`.
|
||||
pub async fn append(&self, path: &str, content: &str) -> Result<(), WorkspaceError> {
|
||||
let path = normalize_path(path);
|
||||
// Scan system-prompt-injected files for prompt injection.
|
||||
if is_system_prompt_file(&path) && !content.is_empty() {
|
||||
reject_if_injected(&path, content)?;
|
||||
}
|
||||
let doc = self
|
||||
.storage
|
||||
.get_or_create_document_by_path(&self.user_id, self.agent_id, &path)
|
||||
|
||||
@@ -134,7 +134,7 @@ mod tests {
|
||||
|
||||
match &routine.trigger {
|
||||
Trigger::Cron { schedule, timezone } => {
|
||||
assert_eq!(schedule, "0 0 9 * * * *");
|
||||
assert_eq!(schedule, "0 0 9 * * *");
|
||||
assert_eq!(timezone.as_deref(), Some("America/New_York"));
|
||||
}
|
||||
other => panic!("expected cron trigger, got {other:?}"),
|
||||
|
||||
@@ -1,99 +0,0 @@
|
||||
use ironclaw::llm::ChatMessage;
|
||||
use ironclaw::llm::gemini_oauth::GeminiOauthProvider;
|
||||
|
||||
/// Regression: Cloud Code API routing for Gemini 2.0+ models.
|
||||
/// Gemini 1.x → legacy generativelanguage.googleapis.com
|
||||
/// Gemini 2.0+ → Cloud Code API (cloudcode-pa.googleapis.com)
|
||||
#[test]
|
||||
fn test_regression_cloud_code_api_routing() {
|
||||
// Legacy models (1.x) → false
|
||||
assert!(!GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-1.5-pro"
|
||||
));
|
||||
assert!(!GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-1.5-flash"
|
||||
));
|
||||
|
||||
// 2.0+ models → true
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-2.0-flash"
|
||||
));
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-2.5-pro"
|
||||
));
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-2.5-flash"
|
||||
));
|
||||
|
||||
// Preview models with hyphen → true
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-3.1-pro-preview"
|
||||
));
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-3-flash-preview"
|
||||
));
|
||||
|
||||
// Gemini 3 family → true
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"gemini-3-pro"
|
||||
));
|
||||
}
|
||||
|
||||
/// Regression: "preview" false-positive fix.
|
||||
/// `model.contains("-preview")` (with hyphen) prevents models whose name
|
||||
/// happens to include "preview" without a hyphen prefix from being
|
||||
/// mis-routed to Cloud Code API.
|
||||
#[test]
|
||||
fn test_regression_preview_false_positive_fix() {
|
||||
// "my-preview-custom" still matches (contains "-preview")
|
||||
assert!(GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"my-preview-custom"
|
||||
));
|
||||
|
||||
// "mypreviewcustom" does NOT match (no hyphen before "preview")
|
||||
assert!(!GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"mypreviewcustom"
|
||||
));
|
||||
|
||||
// Non-Gemini models without "-preview" → false
|
||||
assert!(!GeminiOauthProvider::model_uses_cloud_code_api(
|
||||
"not-a-gemini-model"
|
||||
));
|
||||
}
|
||||
|
||||
/// Regression: model list consistency.
|
||||
/// Wizard, list_models(), and LLM_PROVIDERS.md all return the same 8 models.
|
||||
#[test]
|
||||
fn test_regression_standardized_model_list() {
|
||||
let expected_models = [
|
||||
"gemini-3.1-pro-preview",
|
||||
"gemini-3.1-pro-preview-customtools",
|
||||
"gemini-3-pro-preview",
|
||||
"gemini-3-flash-preview",
|
||||
"gemini-3.1-flash-lite-preview",
|
||||
"gemini-2.5-pro",
|
||||
"gemini-2.5-flash",
|
||||
"gemini-2.5-flash-lite",
|
||||
];
|
||||
|
||||
// All standardized models must route to Cloud Code API (all are >= 2.0)
|
||||
for model in &expected_models {
|
||||
assert!(
|
||||
GeminiOauthProvider::model_uses_cloud_code_api(model),
|
||||
"Standardized model '{}' should route to Cloud Code API",
|
||||
model
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
/// Regression: ChatMessage helper constructors.
|
||||
#[test]
|
||||
fn test_regression_chat_message_helpers() {
|
||||
let user_msg = ChatMessage::user("hello");
|
||||
assert_eq!(user_msg.role, ironclaw::llm::Role::User);
|
||||
assert_eq!(user_msg.content, "hello");
|
||||
|
||||
let system_msg = ChatMessage::system("you are helpful");
|
||||
assert_eq!(system_msg.role, ironclaw::llm::Role::System);
|
||||
assert_eq!(system_msg.content, "you are helpful");
|
||||
}
|
||||
@@ -773,7 +773,7 @@ impl TestRigBuilder {
|
||||
// 7. Create TestChannel and ChannelManager.
|
||||
// When testing bootstrap, the channel must be named "gateway" because
|
||||
// the bootstrap greeting targets only the gateway channel.
|
||||
let test_channel = if self.keep_bootstrap {
|
||||
let test_channel = if keep_bootstrap {
|
||||
Arc::new(TestChannel::new().with_name("gateway"))
|
||||
} else {
|
||||
Arc::new(TestChannel::new())
|
||||
|
||||
@@ -0,0 +1,23 @@
|
||||
[package]
|
||||
name = "composio-tool"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
description = "Composio integration tool for IronClaw (WASM component)"
|
||||
license = "MIT OR Apache-2.0"
|
||||
publish = false
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0", features = ["derive"] }
|
||||
serde_json = "1.0"
|
||||
wit-bindgen = "0.41.0"
|
||||
|
||||
[lib]
|
||||
crate-type = ["cdylib"]
|
||||
|
||||
[profile.release]
|
||||
opt-level = "s"
|
||||
lto = true
|
||||
strip = true
|
||||
codegen-units = 1
|
||||
|
||||
[workspace]
|
||||
@@ -0,0 +1,75 @@
|
||||
{
|
||||
"version": "0.1.0",
|
||||
"wit_version": "0.3.0",
|
||||
"description": "Connect to 250+ apps (Gmail, GitHub, Slack, Notion, etc.) via Composio. Actions: list (browse tools), execute (run a tool), connect (OAuth-link an app), connected_accounts (list linked accounts). Authentication is handled via the 'composio_api_key' secret injected by the host.",
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"action": {
|
||||
"type": "string",
|
||||
"enum": ["list", "execute", "connect", "connected_accounts"],
|
||||
"description": "Action to perform"
|
||||
},
|
||||
"app": {
|
||||
"type": "string",
|
||||
"description": "App/toolkit slug (e.g., \"gmail\", \"github\", \"notion\")"
|
||||
},
|
||||
"tool_slug": {
|
||||
"type": "string",
|
||||
"description": "Tool action slug for execute (e.g., \"GMAIL_SEND_EMAIL\")"
|
||||
},
|
||||
"params": {
|
||||
"description": "Parameters for the tool action (JSON object)"
|
||||
},
|
||||
"connected_account_id": {
|
||||
"type": "string",
|
||||
"description": "Specific connected account ID (auto-resolved if omitted)"
|
||||
}
|
||||
},
|
||||
"required": ["action"],
|
||||
"additionalProperties": false
|
||||
},
|
||||
"capabilities": {
|
||||
"http": {
|
||||
"allowlist": [
|
||||
{
|
||||
"host": "backend.composio.dev",
|
||||
"path_prefix": "/api/v3/",
|
||||
"methods": ["GET", "POST"]
|
||||
}
|
||||
],
|
||||
"credentials": {
|
||||
"composio_api_key": {
|
||||
"secret_name": "composio_api_key",
|
||||
"location": {
|
||||
"type": "header",
|
||||
"name": "x-api-key"
|
||||
},
|
||||
"host_patterns": ["backend.composio.dev"]
|
||||
}
|
||||
},
|
||||
"rate_limit": {
|
||||
"requests_per_minute": 30,
|
||||
"requests_per_hour": 500
|
||||
}
|
||||
},
|
||||
"secrets": {
|
||||
"allowed_names": ["composio_api_key"]
|
||||
}
|
||||
},
|
||||
"auth": {
|
||||
"secret_name": "composio_api_key",
|
||||
"display_name": "Composio",
|
||||
"instructions": "Get an API key at app.composio.dev — go to Settings > API Keys to generate one.",
|
||||
"setup_url": "https://app.composio.dev/",
|
||||
"env_var": "COMPOSIO_API_KEY"
|
||||
},
|
||||
"setup": {
|
||||
"required_secrets": [
|
||||
{
|
||||
"name": "composio_api_key",
|
||||
"prompt": "Composio API key (from app.composio.dev)"
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,425 @@
|
||||
//! Composio WASM Tool for IronClaw.
|
||||
//!
|
||||
//! Connects to 250+ third-party apps via Composio's REST API (v3).
|
||||
//! Provides a single multiplexed tool with actions: list, execute, connect,
|
||||
//! connected_accounts.
|
||||
//!
|
||||
//! # Authentication
|
||||
//!
|
||||
//! Store your Composio API key:
|
||||
//! `ironclaw secret set composio_api_key <key>`
|
||||
//!
|
||||
//! Get a key at: https://app.composio.dev/
|
||||
|
||||
wit_bindgen::generate!({
|
||||
world: "sandboxed-tool",
|
||||
path: "../../wit/tool.wit",
|
||||
});
|
||||
|
||||
use serde::Deserialize;
|
||||
|
||||
const API_BASE: &str = "https://backend.composio.dev/api/v3";
|
||||
const MAX_RETRIES: u32 = 3;
|
||||
|
||||
struct ComposioTool;
|
||||
|
||||
impl exports::near::agent::tool::Guest for ComposioTool {
|
||||
fn execute(req: exports::near::agent::tool::Request) -> exports::near::agent::tool::Response {
|
||||
match execute_inner(&req.params, req.context.as_deref()) {
|
||||
Ok(result) => exports::near::agent::tool::Response {
|
||||
output: Some(result),
|
||||
error: None,
|
||||
},
|
||||
Err(e) => exports::near::agent::tool::Response {
|
||||
output: None,
|
||||
error: Some(e),
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
fn schema() -> String {
|
||||
SCHEMA.to_string()
|
||||
}
|
||||
|
||||
fn description() -> String {
|
||||
"Connect to 250+ apps (Gmail, GitHub, Slack, Notion, etc.) via Composio. \
|
||||
Actions: \"list\" (browse tools), \"execute\" (run a tool), \
|
||||
\"connect\" (OAuth-link an app), \"connected_accounts\" (list linked accounts). \
|
||||
Authentication is handled via the 'composio_api_key' secret injected by the host."
|
||||
.to_string()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct Params {
|
||||
action: String,
|
||||
app: Option<String>,
|
||||
tool_slug: Option<String>,
|
||||
params: Option<serde_json::Value>,
|
||||
connected_account_id: Option<String>,
|
||||
}
|
||||
|
||||
fn execute_inner(params_str: &str, context: Option<&str>) -> Result<String, String> {
|
||||
let params: Params =
|
||||
serde_json::from_str(params_str).map_err(|e| format!("Invalid parameters: {e}"))?;
|
||||
|
||||
if params.action.is_empty() {
|
||||
return Err("'action' must not be empty".into());
|
||||
}
|
||||
|
||||
// Pre-flight: verify API key is available.
|
||||
if !near::agent::host::secret_exists("composio_api_key") {
|
||||
return Err(
|
||||
"Composio API key not found in secret store. Set it with: \
|
||||
ironclaw secret set composio_api_key <key>. \
|
||||
Get a key at: https://app.composio.dev/"
|
||||
.into(),
|
||||
);
|
||||
}
|
||||
|
||||
// Extract an entity identifier from context if provided; prefer `entity_id`,
|
||||
// then `user_id` (from JobContext), then `requester_id`, otherwise "default".
|
||||
let entity_id = context
|
||||
.and_then(|ctx| serde_json::from_str::<serde_json::Value>(ctx).ok())
|
||||
.and_then(|v| {
|
||||
v.get("entity_id")
|
||||
.or_else(|| v.get("user_id"))
|
||||
.or_else(|| v.get("requester_id"))
|
||||
.and_then(|e| e.as_str())
|
||||
.map(String::from)
|
||||
})
|
||||
.unwrap_or_else(|| "default".to_string());
|
||||
|
||||
match params.action.as_str() {
|
||||
"list" => list_tools(params.app.as_deref()),
|
||||
"execute" => {
|
||||
let tool_slug = params
|
||||
.tool_slug
|
||||
.as_deref()
|
||||
.ok_or("missing 'tool_slug' for execute action")?;
|
||||
let action_params = params.params.unwrap_or(serde_json::json!({}));
|
||||
execute_action(
|
||||
tool_slug,
|
||||
&action_params,
|
||||
&entity_id,
|
||||
params.connected_account_id.as_deref(),
|
||||
)
|
||||
}
|
||||
"connect" => {
|
||||
let app = params
|
||||
.app
|
||||
.as_deref()
|
||||
.ok_or("missing 'app' for connect action")?;
|
||||
connect_app(app, &entity_id)
|
||||
}
|
||||
"connected_accounts" => list_accounts(params.app.as_deref(), &entity_id),
|
||||
other => Err(format!(
|
||||
"unknown action \"{other}\", expected: list, execute, connect, connected_accounts"
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// API helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn api_get(path: &str, query: &[(&str, &str)]) -> Result<serde_json::Value, String> {
|
||||
let url = build_url(path, query);
|
||||
|
||||
let headers = serde_json::json!({
|
||||
"Accept": "application/json",
|
||||
"User-Agent": "IronClaw-Composio-Tool/0.1"
|
||||
});
|
||||
|
||||
let response = http_with_retry("GET", &url, &headers.to_string(), None)?;
|
||||
parse_json_response(&response.body, response.status)
|
||||
}
|
||||
|
||||
fn api_post(path: &str, body: &serde_json::Value) -> Result<serde_json::Value, String> {
|
||||
let url = build_url(path, &[]);
|
||||
|
||||
let headers = serde_json::json!({
|
||||
"Accept": "application/json",
|
||||
"Content-Type": "application/json",
|
||||
"User-Agent": "IronClaw-Composio-Tool/0.1"
|
||||
});
|
||||
|
||||
let body_bytes = serde_json::to_vec(body).map_err(|e| format!("JSON serialize error: {e}"))?;
|
||||
|
||||
let response = http_with_retry("POST", &url, &headers.to_string(), Some(&body_bytes))?;
|
||||
parse_json_response(&response.body, response.status)
|
||||
}
|
||||
|
||||
fn http_with_retry(
|
||||
method: &str,
|
||||
url: &str,
|
||||
headers: &str,
|
||||
body: Option<&[u8]>,
|
||||
) -> Result<near::agent::host::HttpResponse, String> {
|
||||
let mut attempt = 0;
|
||||
loop {
|
||||
attempt += 1;
|
||||
|
||||
let resp = near::agent::host::http_request(method, url, headers, body, None)
|
||||
.map_err(|e| format!("HTTP request failed: {e}"))?;
|
||||
|
||||
if resp.status >= 200 && resp.status < 300 {
|
||||
return Ok(resp);
|
||||
}
|
||||
|
||||
if attempt < MAX_RETRIES && (resp.status == 429 || resp.status >= 500) {
|
||||
near::agent::host::log(
|
||||
near::agent::host::LogLevel::Warn,
|
||||
&format!(
|
||||
"Composio API error {} (attempt {}/{}). Retrying...",
|
||||
resp.status, attempt, MAX_RETRIES
|
||||
),
|
||||
);
|
||||
continue;
|
||||
}
|
||||
|
||||
// Truncate at byte level before UTF-8 conversion to avoid
|
||||
// panicking on multibyte character boundaries.
|
||||
let truncated_bytes = if resp.body.len() > 512 {
|
||||
&resp.body[..512]
|
||||
} else {
|
||||
&resp.body
|
||||
};
|
||||
let truncated = String::from_utf8_lossy(truncated_bytes);
|
||||
return Err(format!("Composio API error (HTTP {}): {truncated}", resp.status));
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_json_response(body: &[u8], status: u16) -> Result<serde_json::Value, String> {
|
||||
if !(200..300).contains(&status) {
|
||||
// Truncate at byte level before UTF-8 conversion to avoid
|
||||
// panicking on multibyte character boundaries.
|
||||
let truncated_bytes = if body.len() > 512 { &body[..512] } else { body };
|
||||
let truncated = String::from_utf8_lossy(truncated_bytes);
|
||||
return Err(format!("Composio API {status}: {truncated}"));
|
||||
}
|
||||
|
||||
let text = String::from_utf8(body.to_vec())
|
||||
.map_err(|e| format!("non-UTF8 response: {e}"))?;
|
||||
serde_json::from_str(&text).map_err(|e| format!("invalid JSON: {e}"))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Actions
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn list_tools(app: Option<&str>) -> Result<String, String> {
|
||||
let query: Vec<(&str, &str)> = match app {
|
||||
Some(a) => vec![("toolkit_slug", a)],
|
||||
None => vec![],
|
||||
};
|
||||
let result = api_get("/tools", &query)?;
|
||||
serde_json::to_string(&result).map_err(|e| format!("Failed to serialize output: {e}"))
|
||||
}
|
||||
|
||||
fn execute_action(
|
||||
tool_slug: &str,
|
||||
params: &serde_json::Value,
|
||||
entity_id: &str,
|
||||
connected_account_id: Option<&str>,
|
||||
) -> Result<String, String> {
|
||||
// Auto-resolve connected account if not provided
|
||||
let account_id = match connected_account_id {
|
||||
Some(id) => id.to_string(),
|
||||
None => resolve_account(tool_slug, entity_id)?,
|
||||
};
|
||||
|
||||
let body = serde_json::json!({
|
||||
"connected_account_id": account_id,
|
||||
"entity_id": entity_id,
|
||||
"input": params,
|
||||
});
|
||||
let result = api_post(&format!("/tools/execute/{}", url_encode(tool_slug)), &body)?;
|
||||
serde_json::to_string(&result).map_err(|e| format!("Failed to serialize output: {e}"))
|
||||
}
|
||||
|
||||
fn connect_app(app: &str, entity_id: &str) -> Result<String, String> {
|
||||
// Resolve auth config for this app
|
||||
let configs = api_get("/auth_configs", &[("toolkit_slug", app)])?;
|
||||
let auth_config_id = configs
|
||||
.as_array()
|
||||
.and_then(|arr| arr.first())
|
||||
.and_then(|c| c.get("id"))
|
||||
.and_then(|id| id.as_str())
|
||||
.ok_or_else(|| {
|
||||
format!("no auth config found for {app} — configure it at app.composio.dev")
|
||||
})?;
|
||||
|
||||
let body = serde_json::json!({
|
||||
"auth_config_id": auth_config_id,
|
||||
"user_id": entity_id,
|
||||
});
|
||||
let result = api_post("/connected_accounts/link", &body)?;
|
||||
serde_json::to_string(&result).map_err(|e| format!("Failed to serialize output: {e}"))
|
||||
}
|
||||
|
||||
fn list_accounts(app: Option<&str>, entity_id: &str) -> Result<String, String> {
|
||||
let mut query = vec![("user_id", entity_id)];
|
||||
if let Some(a) = app {
|
||||
query.push(("toolkit_slug", a));
|
||||
}
|
||||
let result = api_get("/connected_accounts", &query)?;
|
||||
serde_json::to_string(&result).map_err(|e| format!("Failed to serialize output: {e}"))
|
||||
}
|
||||
|
||||
/// Look up the toolkit/app slug for a tool via the Composio API.
|
||||
///
|
||||
/// Querying the API is more reliable than parsing the tool slug string,
|
||||
/// which breaks for multi-word app names (e.g., `GOOGLE_DRIVE_UPLOAD`
|
||||
/// would incorrectly resolve to `"google"` instead of `"google_drive"`).
|
||||
fn lookup_app_for_tool(tool_slug: &str) -> Result<String, String> {
|
||||
let tools = api_get("/tools", &[("search", tool_slug)])?;
|
||||
tools
|
||||
.as_array()
|
||||
.and_then(|arr| {
|
||||
arr.iter().find(|t| {
|
||||
t.get("slug")
|
||||
.and_then(|s| s.as_str())
|
||||
.map(|s| s.eq_ignore_ascii_case(tool_slug))
|
||||
.unwrap_or(false)
|
||||
})
|
||||
})
|
||||
.and_then(|t| t.get("toolkit_slug").or_else(|| t.get("appName")))
|
||||
.and_then(|v| v.as_str())
|
||||
.map(|s| s.to_ascii_lowercase())
|
||||
.ok_or_else(|| {
|
||||
format!("could not determine app for tool \"{tool_slug}\" — verify the slug is correct")
|
||||
})
|
||||
}
|
||||
|
||||
/// Auto-resolve connected account for a tool slug.
|
||||
fn resolve_account(tool_slug: &str, entity_id: &str) -> Result<String, String> {
|
||||
let app = lookup_app_for_tool(tool_slug)?;
|
||||
|
||||
let accounts = api_get("/connected_accounts", &[("user_id", entity_id), ("toolkit_slug", &app)])?;
|
||||
|
||||
accounts
|
||||
.as_array()
|
||||
.and_then(|arr| {
|
||||
arr.iter()
|
||||
.filter(|a| a.get("status").and_then(|s| s.as_str()) == Some("ACTIVE"))
|
||||
.max_by_key(|a| {
|
||||
a.get("updatedAt")
|
||||
.and_then(|u| u.as_str())
|
||||
.unwrap_or("")
|
||||
.to_string()
|
||||
})
|
||||
})
|
||||
.and_then(|a| a.get("id"))
|
||||
.and_then(|id| id.as_str())
|
||||
.map(|s| s.to_string())
|
||||
.ok_or_else(|| {
|
||||
format!("no connected account for {app} — use composio with action=\"connect\" first")
|
||||
})
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// URL helpers
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
fn build_url(path: &str, query: &[(&str, &str)]) -> String {
|
||||
let mut url = format!("{API_BASE}{path}");
|
||||
if !query.is_empty() {
|
||||
url.push('?');
|
||||
for (i, (k, v)) in query.iter().enumerate() {
|
||||
if i > 0 {
|
||||
url.push('&');
|
||||
}
|
||||
url.push_str(&url_encode(k));
|
||||
url.push('=');
|
||||
url.push_str(&url_encode(v));
|
||||
}
|
||||
}
|
||||
url
|
||||
}
|
||||
|
||||
/// Percent-encode a string for safe use in URL query parameters.
|
||||
fn url_encode(s: &str) -> String {
|
||||
let mut out = String::with_capacity(s.len() * 2);
|
||||
for b in s.bytes() {
|
||||
match b {
|
||||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' => {
|
||||
out.push(b as char);
|
||||
}
|
||||
b' ' => out.push_str("%20"),
|
||||
_ => {
|
||||
out.push('%');
|
||||
out.push(char::from(b"0123456789ABCDEF"[(b >> 4) as usize]));
|
||||
out.push(char::from(b"0123456789ABCDEF"[(b & 0xf) as usize]));
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
const SCHEMA: &str = r#"{
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"action": {
|
||||
"type": "string",
|
||||
"enum": ["list", "execute", "connect", "connected_accounts"],
|
||||
"description": "Action to perform"
|
||||
},
|
||||
"app": {
|
||||
"type": "string",
|
||||
"description": "App/toolkit slug (e.g., \"gmail\", \"github\", \"notion\")"
|
||||
},
|
||||
"tool_slug": {
|
||||
"type": "string",
|
||||
"description": "Tool action slug for execute (e.g., \"GMAIL_SEND_EMAIL\")"
|
||||
},
|
||||
"params": {
|
||||
"description": "Parameters for the tool action (JSON object)"
|
||||
},
|
||||
"connected_account_id": {
|
||||
"type": "string",
|
||||
"description": "Specific connected account ID (auto-resolved if omitted)"
|
||||
}
|
||||
},
|
||||
"required": ["action"],
|
||||
"additionalProperties": false
|
||||
}"#;
|
||||
|
||||
export!(ComposioTool);
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_url_encode() {
|
||||
assert_eq!(url_encode("hello world"), "hello%20world");
|
||||
assert_eq!(url_encode("foo&bar=baz"), "foo%26bar%3Dbaz");
|
||||
assert_eq!(url_encode("simple"), "simple");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_url_encode_multibyte() {
|
||||
assert_eq!(url_encode("café"), "caf%C3%A9");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_url_no_query() {
|
||||
let url = build_url("/tools", &[]);
|
||||
assert_eq!(url, format!("{API_BASE}/tools"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_url_with_query() {
|
||||
let url = build_url("/tools", &[("toolkit_slug", "gmail"), ("search", "send")]);
|
||||
assert!(url.starts_with(&format!("{API_BASE}/tools?")));
|
||||
assert!(url.contains("toolkit_slug=gmail"));
|
||||
assert!(url.contains("search=send"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_build_url_encodes_special_chars() {
|
||||
let url = build_url("/tools", &[("q", "my app+1")]);
|
||||
assert!(url.contains("q=my%20app%2B1"));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user