mirror of
https://github.com/openai/codex.git
synced 2026-11-20 15:07:25 +00:00
## Why Wrapped URLs in rich TUI output, especially URLs rendered inside Markdown tables, are split across terminal rows. In terminals that support OSC 8 hyperlinks, treating each visible fragment as part of the complete destination enables reliable open-link and copy-link actions even after table layout wraps the URL. This addresses the semantic-link portion of #12200 and the behavior described in https://github.com/openai/codex/issues/12200#issuecomment-4535452980. It does not change ordinary drag-selection across bordered table rows. ## What Changed - Added shared TUI OSC 8 support that validates `http://` and `https://` destinations, sanitizes terminal payloads, and applies metadata separately from visible line width/layout. - Added semantic web-link annotations to assistant and proposed-plan Markdown, including explicit web links and bare web URLs in prose and table cells while excluding code and non-web Markdown destinations. - Preserved complete URL targets through table wrapping, narrow pipe fallback, streaming, transcript overlay rendering, history insertion, and resize replay. - Routed intentional Codex-owned links in notices, status/setup/app-link, feedback, onboarding, MCP/plugin help, memories, and update surfaces through the shared hyperlink handling. ## How to Test 1. Run Codex in a terminal with OSC 8 link support, such as Ghostty, and request an assistant response containing a Markdown table whose last column contains a long `https://` URL. 2. Make the terminal narrow enough for the URL to wrap across multiple bordered table rows. 3. Use the terminal's open-link or copy-link action on more than one wrapped URL fragment and confirm each fragment resolves to the complete original URL. 4. Resize the terminal after the table is rendered and repeat the link action to confirm the destination survives scrollback replay. 5. Open the transcript overlay while rich output is present and confirm web links remain interactive there. 6. As a regression check, render inline/fenced code containing URL text and a Markdown link such as `[https://example.com](mailto:support@example.com)`; confirm these do not acquire a web OSC 8 destination. Targeted automated coverage exercised Markdown links and exclusions, wrapped and pipe-fallback tables, streaming/transcript overlay propagation, status-link truncation, and rendered word-wrapping cell alignment. `just test -p codex-tui` was also run; it passed the hyperlink coverage and reproduced two unrelated existing guardian feature-flag test failures.
934 lines
34 KiB
Rust
934 lines
34 KiB
Rust
use crate::history_cell::CompositeHistoryCell;
|
|
use crate::history_cell::HistoryCell;
|
|
use crate::history_cell::PlainHistoryCell;
|
|
use crate::history_cell::plain_lines;
|
|
use crate::history_cell::with_border_with_inner_width;
|
|
use crate::legacy_core::config::Config;
|
|
use crate::token_usage::TokenUsage;
|
|
use crate::token_usage::TokenUsageInfo;
|
|
use crate::version::CODEX_CLI_VERSION;
|
|
use chrono::DateTime;
|
|
use chrono::Local;
|
|
use codex_app_server_protocol::AskForApproval;
|
|
use codex_model_provider_info::WireApi;
|
|
use codex_protocol::ThreadId;
|
|
use codex_protocol::account::PlanType;
|
|
use codex_protocol::config_types::ApprovalsReviewer;
|
|
use codex_protocol::models::ActivePermissionProfile;
|
|
use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS;
|
|
use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_READ_ONLY;
|
|
use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_WORKSPACE;
|
|
use codex_protocol::models::PermissionProfile;
|
|
use codex_protocol::openai_models::ReasoningEffort;
|
|
use codex_utils_absolute_path::AbsolutePathBuf;
|
|
use codex_utils_sandbox_summary::summarize_permission_profile;
|
|
use ratatui::prelude::*;
|
|
use ratatui::style::Stylize;
|
|
use std::collections::BTreeSet;
|
|
use std::path::PathBuf;
|
|
use unicode_width::UnicodeWidthStr;
|
|
use url::Url;
|
|
|
|
use super::account::StatusAccountDisplay;
|
|
use super::format::FieldFormatter;
|
|
use super::format::line_display_width;
|
|
use super::format::push_label;
|
|
use super::format::truncate_line_to_width;
|
|
use super::helpers::compose_account_display;
|
|
use super::helpers::compose_model_display;
|
|
use super::helpers::format_directory_display;
|
|
use super::helpers::format_tokens_compact;
|
|
use super::rate_limits::RateLimitSnapshotDisplay;
|
|
use super::rate_limits::StatusRateLimitData;
|
|
use super::rate_limits::StatusRateLimitRow;
|
|
use super::rate_limits::StatusRateLimitValue;
|
|
use super::rate_limits::compose_rate_limit_data;
|
|
use super::rate_limits::compose_rate_limit_data_many;
|
|
use super::rate_limits::format_status_limit_summary;
|
|
use super::rate_limits::render_status_limit_progress_bar;
|
|
use super::remote_connection::RemoteConnectionStatus;
|
|
use crate::wrapping::RtOptions;
|
|
use crate::wrapping::adaptive_wrap_lines;
|
|
use crate::wrapping::word_wrap_lines;
|
|
use std::sync::Arc;
|
|
use std::sync::RwLock;
|
|
|
|
const CHATGPT_USAGE_URL: &str = "https://chatgpt.com/codex/settings/usage";
|
|
|
|
#[derive(Debug, Clone)]
|
|
struct StatusContextWindowData {
|
|
percent_remaining: i64,
|
|
tokens_in_context: i64,
|
|
window: i64,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct StatusTokenUsageData {
|
|
total: i64,
|
|
input: i64,
|
|
output: i64,
|
|
context_window: Option<StatusContextWindowData>,
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct StatusRateLimitState {
|
|
rate_limits: StatusRateLimitData,
|
|
refreshing_rate_limits: bool,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub(crate) struct StatusHistoryHandle {
|
|
rate_limit_state: Arc<RwLock<StatusRateLimitState>>,
|
|
}
|
|
|
|
impl StatusHistoryHandle {
|
|
pub(crate) fn finish_rate_limit_refresh(
|
|
&self,
|
|
rate_limits: &[RateLimitSnapshotDisplay],
|
|
now: DateTime<Local>,
|
|
) {
|
|
let rate_limits = if rate_limits.len() <= 1 {
|
|
compose_rate_limit_data(rate_limits.first(), now)
|
|
} else {
|
|
compose_rate_limit_data_many(rate_limits, now)
|
|
};
|
|
#[expect(clippy::expect_used)]
|
|
let mut state = self
|
|
.rate_limit_state
|
|
.write()
|
|
.expect("status history rate-limit state poisoned");
|
|
state.rate_limits = rate_limits;
|
|
state.refreshing_rate_limits = false;
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
struct StatusHistoryCell {
|
|
model_name: String,
|
|
model_details: Vec<String>,
|
|
directory: PathBuf,
|
|
permissions: String,
|
|
agents_summary: Arc<RwLock<String>>,
|
|
collaboration_mode: Option<String>,
|
|
model_provider: Option<String>,
|
|
remote_connection: Option<RemoteConnectionStatus>,
|
|
show_chatgpt_usage_link: bool,
|
|
account: Option<StatusAccountDisplay>,
|
|
thread_name: Option<String>,
|
|
session_id: Option<String>,
|
|
forked_from: Option<String>,
|
|
token_usage: StatusTokenUsageData,
|
|
rate_limit_state: Arc<RwLock<StatusRateLimitState>>,
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(crate) fn new_status_output(
|
|
config: &Config,
|
|
account_display: Option<&StatusAccountDisplay>,
|
|
token_info: Option<&TokenUsageInfo>,
|
|
total_usage: &TokenUsage,
|
|
session_id: &Option<ThreadId>,
|
|
thread_name: Option<String>,
|
|
forked_from: Option<ThreadId>,
|
|
rate_limits: Option<&RateLimitSnapshotDisplay>,
|
|
_plan_type: Option<PlanType>,
|
|
now: DateTime<Local>,
|
|
model_name: &str,
|
|
collaboration_mode: Option<&str>,
|
|
reasoning_effort_override: Option<Option<ReasoningEffort>>,
|
|
) -> CompositeHistoryCell {
|
|
let snapshots = rate_limits.map(std::slice::from_ref).unwrap_or_default();
|
|
new_status_output_with_rate_limits(
|
|
config,
|
|
account_display,
|
|
token_info,
|
|
total_usage,
|
|
session_id,
|
|
thread_name,
|
|
forked_from,
|
|
snapshots,
|
|
_plan_type,
|
|
now,
|
|
model_name,
|
|
collaboration_mode,
|
|
reasoning_effort_override,
|
|
/*refreshing_rate_limits*/ false,
|
|
)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(crate) fn new_status_output_with_rate_limits(
|
|
config: &Config,
|
|
account_display: Option<&StatusAccountDisplay>,
|
|
token_info: Option<&TokenUsageInfo>,
|
|
total_usage: &TokenUsage,
|
|
session_id: &Option<ThreadId>,
|
|
thread_name: Option<String>,
|
|
forked_from: Option<ThreadId>,
|
|
rate_limits: &[RateLimitSnapshotDisplay],
|
|
_plan_type: Option<PlanType>,
|
|
now: DateTime<Local>,
|
|
model_name: &str,
|
|
collaboration_mode: Option<&str>,
|
|
reasoning_effort_override: Option<Option<ReasoningEffort>>,
|
|
refreshing_rate_limits: bool,
|
|
) -> CompositeHistoryCell {
|
|
new_status_output_with_rate_limits_handle(
|
|
config,
|
|
/*runtime_model_provider_base_url*/ None,
|
|
/*remote_connection*/ None,
|
|
account_display,
|
|
token_info,
|
|
total_usage,
|
|
session_id,
|
|
thread_name,
|
|
forked_from,
|
|
rate_limits,
|
|
_plan_type,
|
|
now,
|
|
model_name,
|
|
collaboration_mode,
|
|
reasoning_effort_override,
|
|
"<none>".to_string(),
|
|
refreshing_rate_limits,
|
|
)
|
|
.0
|
|
}
|
|
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub(crate) fn new_status_output_with_rate_limits_handle(
|
|
config: &Config,
|
|
runtime_model_provider_base_url: Option<&str>,
|
|
remote_connection: Option<&RemoteConnectionStatus>,
|
|
account_display: Option<&StatusAccountDisplay>,
|
|
token_info: Option<&TokenUsageInfo>,
|
|
total_usage: &TokenUsage,
|
|
session_id: &Option<ThreadId>,
|
|
thread_name: Option<String>,
|
|
forked_from: Option<ThreadId>,
|
|
rate_limits: &[RateLimitSnapshotDisplay],
|
|
_plan_type: Option<PlanType>,
|
|
now: DateTime<Local>,
|
|
model_name: &str,
|
|
collaboration_mode: Option<&str>,
|
|
reasoning_effort_override: Option<Option<ReasoningEffort>>,
|
|
agents_summary: String,
|
|
refreshing_rate_limits: bool,
|
|
) -> (CompositeHistoryCell, StatusHistoryHandle) {
|
|
let command = PlainHistoryCell::new(vec!["/status".magenta().into()]);
|
|
let (card, handle) = StatusHistoryCell::new(
|
|
config,
|
|
runtime_model_provider_base_url,
|
|
remote_connection,
|
|
account_display,
|
|
token_info,
|
|
total_usage,
|
|
session_id,
|
|
thread_name,
|
|
forked_from,
|
|
rate_limits,
|
|
_plan_type,
|
|
now,
|
|
model_name,
|
|
collaboration_mode,
|
|
reasoning_effort_override,
|
|
agents_summary,
|
|
refreshing_rate_limits,
|
|
);
|
|
|
|
(
|
|
CompositeHistoryCell::new(vec![Box::new(command), Box::new(card)]),
|
|
handle,
|
|
)
|
|
}
|
|
|
|
impl StatusHistoryCell {
|
|
#[allow(clippy::too_many_arguments)]
|
|
fn new(
|
|
config: &Config,
|
|
runtime_model_provider_base_url: Option<&str>,
|
|
remote_connection: Option<&RemoteConnectionStatus>,
|
|
account_display: Option<&StatusAccountDisplay>,
|
|
token_info: Option<&TokenUsageInfo>,
|
|
total_usage: &TokenUsage,
|
|
session_id: &Option<ThreadId>,
|
|
thread_name: Option<String>,
|
|
forked_from: Option<ThreadId>,
|
|
rate_limits: &[RateLimitSnapshotDisplay],
|
|
_plan_type: Option<PlanType>,
|
|
now: DateTime<Local>,
|
|
model_name: &str,
|
|
collaboration_mode: Option<&str>,
|
|
reasoning_effort_override: Option<Option<ReasoningEffort>>,
|
|
agents_summary: String,
|
|
refreshing_rate_limits: bool,
|
|
) -> (Self, StatusHistoryHandle) {
|
|
let approval_policy = AskForApproval::from(config.permissions.approval_policy.value());
|
|
let permission_profile = config.permissions.effective_permission_profile();
|
|
let workspace_roots = config.effective_workspace_roots();
|
|
let mut config_entries = vec![
|
|
("workdir", config.cwd.display().to_string()),
|
|
("model", model_name.to_string()),
|
|
("provider", config.model_provider_id.clone()),
|
|
(
|
|
"approval",
|
|
config.permissions.approval_policy.value().to_string(),
|
|
),
|
|
(
|
|
"sandbox",
|
|
summarize_permission_profile(
|
|
&permission_profile,
|
|
&config.cwd,
|
|
workspace_roots.as_slice(),
|
|
),
|
|
),
|
|
];
|
|
if config.model_provider.wire_api == WireApi::Responses {
|
|
let effort_value = reasoning_effort_override
|
|
.unwrap_or(config.model_reasoning_effort)
|
|
.map(|effort| effort.to_string())
|
|
.unwrap_or_else(|| "none".to_string());
|
|
config_entries.push(("reasoning effort", effort_value));
|
|
config_entries.push((
|
|
"reasoning summaries",
|
|
config
|
|
.model_reasoning_summary
|
|
.map(|summary| summary.to_string())
|
|
.unwrap_or_else(|| "auto".to_string()),
|
|
));
|
|
}
|
|
let (model_name, model_details) = compose_model_display(model_name, &config_entries);
|
|
let approval = config_entries
|
|
.iter()
|
|
.find(|(k, _)| *k == "approval")
|
|
.map(|(_, v)| v.clone())
|
|
.unwrap_or_else(|| "<unknown>".to_string());
|
|
let active_permission_profile = config.permissions.active_permission_profile();
|
|
let sandbox =
|
|
status_permission_summary(&permission_profile, &config.cwd, workspace_roots.as_slice());
|
|
let workspace_root_suffix = workspace_root_suffix(workspace_roots.as_slice(), &config.cwd);
|
|
let approval = status_approval_label(approval_policy, config.approvals_reviewer, &approval);
|
|
let permissions = status_permissions_label(
|
|
active_permission_profile.as_ref(),
|
|
&permission_profile,
|
|
approval_policy,
|
|
&sandbox,
|
|
&approval,
|
|
workspace_root_suffix.as_deref(),
|
|
);
|
|
let model_provider = format_model_provider(config, runtime_model_provider_base_url);
|
|
let show_chatgpt_usage_link = config.model_provider.requires_openai_auth;
|
|
let account = compose_account_display(account_display);
|
|
let session_id = session_id.as_ref().map(std::string::ToString::to_string);
|
|
let forked_from = forked_from.map(|id| id.to_string());
|
|
let default_usage = TokenUsage::default();
|
|
let (context_usage, context_window) = match token_info {
|
|
Some(info) => (&info.last_token_usage, info.model_context_window),
|
|
None => (&default_usage, config.model_context_window),
|
|
};
|
|
let context_window = context_window.map(|window| StatusContextWindowData {
|
|
percent_remaining: context_usage.percent_of_context_window_remaining(window),
|
|
tokens_in_context: context_usage.tokens_in_context_window(),
|
|
window,
|
|
});
|
|
|
|
let token_usage = StatusTokenUsageData {
|
|
total: total_usage.blended_total(),
|
|
input: total_usage.non_cached_input(),
|
|
output: total_usage.output_tokens,
|
|
context_window,
|
|
};
|
|
let rate_limits = if rate_limits.len() <= 1 {
|
|
compose_rate_limit_data(rate_limits.first(), now)
|
|
} else {
|
|
compose_rate_limit_data_many(rate_limits, now)
|
|
};
|
|
let rate_limit_state = Arc::new(RwLock::new(StatusRateLimitState {
|
|
rate_limits,
|
|
refreshing_rate_limits,
|
|
}));
|
|
let agents_summary = Arc::new(RwLock::new(agents_summary));
|
|
|
|
(
|
|
Self {
|
|
model_name,
|
|
model_details,
|
|
directory: config.cwd.to_path_buf(),
|
|
permissions,
|
|
collaboration_mode: collaboration_mode.map(ToString::to_string),
|
|
model_provider,
|
|
remote_connection: remote_connection.cloned(),
|
|
show_chatgpt_usage_link,
|
|
account,
|
|
thread_name,
|
|
session_id,
|
|
forked_from,
|
|
token_usage,
|
|
agents_summary,
|
|
rate_limit_state: rate_limit_state.clone(),
|
|
},
|
|
StatusHistoryHandle { rate_limit_state },
|
|
)
|
|
}
|
|
|
|
fn token_usage_spans(&self) -> Vec<Span<'static>> {
|
|
let total_fmt = format_tokens_compact(self.token_usage.total);
|
|
let input_fmt = format_tokens_compact(self.token_usage.input);
|
|
let output_fmt = format_tokens_compact(self.token_usage.output);
|
|
|
|
vec![
|
|
Span::from(total_fmt),
|
|
Span::from(" total "),
|
|
Span::from(" (").dim(),
|
|
Span::from(input_fmt).dim(),
|
|
Span::from(" input").dim(),
|
|
Span::from(" + ").dim(),
|
|
Span::from(output_fmt).dim(),
|
|
Span::from(" output").dim(),
|
|
Span::from(")").dim(),
|
|
]
|
|
}
|
|
|
|
fn context_window_spans(&self) -> Option<Vec<Span<'static>>> {
|
|
let context = self.token_usage.context_window.as_ref()?;
|
|
let percent = context.percent_remaining;
|
|
let used_fmt = format_tokens_compact(context.tokens_in_context);
|
|
let window_fmt = format_tokens_compact(context.window);
|
|
|
|
Some(vec![
|
|
Span::from(format!("{percent}% left")),
|
|
Span::from(" (").dim(),
|
|
Span::from(used_fmt).dim(),
|
|
Span::from(" used / ").dim(),
|
|
Span::from(window_fmt).dim(),
|
|
Span::from(")").dim(),
|
|
])
|
|
}
|
|
|
|
fn rate_limit_lines(
|
|
&self,
|
|
state: &StatusRateLimitState,
|
|
available_inner_width: usize,
|
|
formatter: &FieldFormatter,
|
|
) -> Vec<Line<'static>> {
|
|
match &state.rate_limits {
|
|
StatusRateLimitData::Available(rows_data) => {
|
|
if rows_data.is_empty() {
|
|
return vec![formatter.line(
|
|
"Limits",
|
|
vec![Span::from("not available for this account").dim()],
|
|
)];
|
|
}
|
|
|
|
self.rate_limit_row_lines(rows_data, available_inner_width, formatter)
|
|
}
|
|
StatusRateLimitData::Stale(rows_data) => {
|
|
let mut lines =
|
|
self.rate_limit_row_lines(rows_data, available_inner_width, formatter);
|
|
lines.push(formatter.line(
|
|
"Warning",
|
|
vec![Span::from(if state.refreshing_rate_limits {
|
|
"limits may be stale - run /status again shortly."
|
|
} else {
|
|
"limits may be stale - start new turn to refresh."
|
|
})
|
|
.dim()],
|
|
));
|
|
lines
|
|
}
|
|
StatusRateLimitData::Unavailable => {
|
|
vec![formatter.line(
|
|
"Limits",
|
|
vec![Span::from("not available for this account").dim()],
|
|
)]
|
|
}
|
|
StatusRateLimitData::Missing => {
|
|
vec![formatter.line(
|
|
"Limits",
|
|
vec![Span::from(if state.refreshing_rate_limits {
|
|
"refresh requested; run /status again shortly."
|
|
} else {
|
|
"data not available yet"
|
|
})
|
|
.dim()],
|
|
)]
|
|
}
|
|
}
|
|
}
|
|
|
|
fn rate_limit_row_lines(
|
|
&self,
|
|
rows: &[StatusRateLimitRow],
|
|
available_inner_width: usize,
|
|
formatter: &FieldFormatter,
|
|
) -> Vec<Line<'static>> {
|
|
let mut lines = Vec::with_capacity(rows.len().saturating_mul(2));
|
|
|
|
for row in rows {
|
|
match &row.value {
|
|
StatusRateLimitValue::Window {
|
|
percent_used,
|
|
resets_at,
|
|
} => {
|
|
let percent_remaining = (100.0 - percent_used).clamp(0.0, 100.0);
|
|
let summary = format_status_limit_summary(percent_remaining);
|
|
let full_value_spans = vec![
|
|
Span::from(render_status_limit_progress_bar(percent_remaining)),
|
|
Span::from(" "),
|
|
Span::from(summary.clone()),
|
|
];
|
|
// On narrow terminals, keep the percentage visible rather than
|
|
// letting the fixed-width progress bar crowd out the reset time.
|
|
let value_spans = if line_display_width(&Line::from(full_value_spans.clone()))
|
|
<= formatter.value_width(available_inner_width)
|
|
{
|
|
full_value_spans
|
|
} else {
|
|
vec![Span::from(summary)]
|
|
};
|
|
let base_spans = formatter.full_spans(row.label.as_str(), value_spans);
|
|
let base_line = Line::from(base_spans.clone());
|
|
|
|
if let Some(resets_at) = resets_at.as_ref() {
|
|
let resets_span = Span::from(format!("(resets {resets_at})")).dim();
|
|
let mut inline_spans = base_spans.clone();
|
|
inline_spans.push(Span::from(" ").dim());
|
|
inline_spans.push(resets_span.clone());
|
|
|
|
if line_display_width(&Line::from(inline_spans.clone()))
|
|
<= available_inner_width
|
|
{
|
|
lines.push(Line::from(inline_spans));
|
|
} else {
|
|
lines.push(base_line);
|
|
let reset_text = format!("(resets {resets_at})");
|
|
let reset_width = formatter.value_width(available_inner_width).max(1);
|
|
let wrap_options =
|
|
textwrap::Options::new(reset_width).break_words(false);
|
|
// Reset timestamps are the actionable part of this row, so wrap them
|
|
// onto continuation lines instead of truncating partial times/dates.
|
|
lines.extend(
|
|
textwrap::wrap(reset_text.as_str(), wrap_options)
|
|
.into_iter()
|
|
.map(|wrapped| {
|
|
formatter.continuation(vec![
|
|
Span::from(wrapped.into_owned()).dim(),
|
|
])
|
|
}),
|
|
);
|
|
}
|
|
} else {
|
|
lines.push(base_line);
|
|
}
|
|
}
|
|
StatusRateLimitValue::Text(text) => {
|
|
let label = row.label.clone();
|
|
let spans =
|
|
formatter.full_spans(label.as_str(), vec![Span::from(text.clone())]);
|
|
lines.push(Line::from(spans));
|
|
}
|
|
}
|
|
}
|
|
|
|
lines
|
|
}
|
|
|
|
fn collect_rate_limit_labels(
|
|
&self,
|
|
state: &StatusRateLimitState,
|
|
seen: &mut BTreeSet<String>,
|
|
labels: &mut Vec<String>,
|
|
) {
|
|
match &state.rate_limits {
|
|
StatusRateLimitData::Available(rows) => {
|
|
if rows.is_empty() {
|
|
push_label(labels, seen, "Limits");
|
|
} else {
|
|
for row in rows {
|
|
push_label(labels, seen, row.label.as_str());
|
|
}
|
|
}
|
|
}
|
|
StatusRateLimitData::Stale(rows) => {
|
|
for row in rows {
|
|
push_label(labels, seen, row.label.as_str());
|
|
}
|
|
push_label(labels, seen, "Warning");
|
|
}
|
|
StatusRateLimitData::Unavailable => push_label(labels, seen, "Limits"),
|
|
StatusRateLimitData::Missing => push_label(labels, seen, "Limits"),
|
|
}
|
|
}
|
|
}
|
|
|
|
fn status_permission_summary(
|
|
permission_profile: &PermissionProfile,
|
|
cwd: &AbsolutePathBuf,
|
|
workspace_roots: &[AbsolutePathBuf],
|
|
) -> String {
|
|
let summary = summarize_permission_profile(permission_profile, cwd, workspace_roots);
|
|
if let Some(details) = summary.strip_prefix("read-only") {
|
|
if details.contains("(network access enabled)") {
|
|
return "read-only with network access".to_string();
|
|
}
|
|
return "read-only".to_string();
|
|
}
|
|
if let Some(details) = summary.strip_prefix("workspace-write") {
|
|
if details.contains("(network access enabled)") {
|
|
return "workspace with network access".to_string();
|
|
}
|
|
return "workspace".to_string();
|
|
}
|
|
if summary == "custom permissions (network access enabled)" {
|
|
return "custom permissions with network access".to_string();
|
|
}
|
|
summary
|
|
}
|
|
|
|
fn workspace_root_suffix(
|
|
workspace_roots: &[AbsolutePathBuf],
|
|
cwd: &AbsolutePathBuf,
|
|
) -> Option<String> {
|
|
let extra_roots = workspace_roots
|
|
.iter()
|
|
.filter(|root| *root != cwd)
|
|
.map(|root| root.to_string_lossy().to_string())
|
|
.collect::<Vec<_>>();
|
|
if extra_roots.is_empty() {
|
|
None
|
|
} else {
|
|
Some(format!(" [{}]", extra_roots.join(", ")))
|
|
}
|
|
}
|
|
|
|
fn status_permissions_label(
|
|
active_permission_profile: Option<&ActivePermissionProfile>,
|
|
permission_profile: &PermissionProfile,
|
|
approval_policy: AskForApproval,
|
|
sandbox: &str,
|
|
approval: &str,
|
|
workspace_root_suffix: Option<&str>,
|
|
) -> String {
|
|
let active_id = active_permission_profile.map(|active| active.id.as_str());
|
|
match active_id {
|
|
Some(BUILT_IN_PERMISSION_PROFILE_READ_ONLY) => {
|
|
let label = if sandbox == "read-only with network access" {
|
|
"Read Only with network access"
|
|
} else {
|
|
"Read Only"
|
|
};
|
|
return format!("{label} ({approval})");
|
|
}
|
|
Some(BUILT_IN_PERMISSION_PROFILE_WORKSPACE) => match sandbox {
|
|
"workspace" => {
|
|
return format!(
|
|
"Workspace{} ({approval})",
|
|
workspace_root_suffix.unwrap_or("")
|
|
);
|
|
}
|
|
"workspace with network access" => {
|
|
return format!(
|
|
"Workspace with network access{} ({approval})",
|
|
workspace_root_suffix.unwrap_or("")
|
|
);
|
|
}
|
|
_ => {}
|
|
},
|
|
Some(BUILT_IN_PERMISSION_PROFILE_DANGER_FULL_ACCESS)
|
|
if permission_profile == &PermissionProfile::Disabled =>
|
|
{
|
|
return if approval_policy == AskForApproval::Never {
|
|
"Full Access".to_string()
|
|
} else {
|
|
format!("No Sandbox ({approval})")
|
|
};
|
|
}
|
|
Some(id) => {
|
|
let sandbox = decorate_workspace_sandbox_label(sandbox, workspace_root_suffix);
|
|
return format!("Profile {id} ({sandbox}, {approval})");
|
|
}
|
|
None => {}
|
|
}
|
|
|
|
if sandbox == "read-only" {
|
|
return format!("Read Only ({approval})");
|
|
}
|
|
if approval_policy == AskForApproval::OnRequest && sandbox == "workspace" {
|
|
return format!(
|
|
"Workspace{} ({approval})",
|
|
workspace_root_suffix.unwrap_or("")
|
|
);
|
|
}
|
|
if approval_policy == AskForApproval::Never
|
|
&& permission_profile == &PermissionProfile::Disabled
|
|
{
|
|
return "Full Access".to_string();
|
|
}
|
|
let sandbox = decorate_workspace_sandbox_label(sandbox, workspace_root_suffix);
|
|
format!("Custom ({sandbox}, {approval})")
|
|
}
|
|
|
|
fn decorate_workspace_sandbox_label(sandbox: &str, workspace_root_suffix: Option<&str>) -> String {
|
|
match workspace_root_suffix {
|
|
Some(suffix) if sandbox.starts_with("workspace") => format!("{sandbox}{suffix}"),
|
|
_ => sandbox.to_string(),
|
|
}
|
|
}
|
|
|
|
fn status_approval_label(
|
|
approval_policy: AskForApproval,
|
|
approvals_reviewer: ApprovalsReviewer,
|
|
approval: &str,
|
|
) -> String {
|
|
if approval_policy == AskForApproval::OnRequest
|
|
&& approvals_reviewer == ApprovalsReviewer::AutoReview
|
|
{
|
|
"auto-review".to_string()
|
|
} else {
|
|
approval.to_string()
|
|
}
|
|
}
|
|
|
|
impl HistoryCell for StatusHistoryCell {
|
|
fn display_lines(&self, width: u16) -> Vec<Line<'static>> {
|
|
let mut lines: Vec<Line<'static>> = Vec::new();
|
|
lines.push(Line::from(vec![
|
|
Span::from(format!("{}>_ ", FieldFormatter::INDENT)).dim(),
|
|
Span::from("OpenAI Codex").bold(),
|
|
Span::from(" ").dim(),
|
|
Span::from(format!("(v{CODEX_CLI_VERSION})")).dim(),
|
|
]));
|
|
|
|
let available_inner_width = usize::from(width.saturating_sub(4));
|
|
if available_inner_width == 0 {
|
|
return Vec::new();
|
|
}
|
|
|
|
let account_value = self.account.as_ref().map(|account| match account {
|
|
StatusAccountDisplay::ChatGpt { email, plan } => match (email, plan) {
|
|
(Some(email), Some(plan)) => format!("{email} ({plan})"),
|
|
(Some(email), None) => email.clone(),
|
|
(None, Some(plan)) => plan.clone(),
|
|
(None, None) => "ChatGPT".to_string(),
|
|
},
|
|
StatusAccountDisplay::ApiKey => {
|
|
"API key configured (run codex login to use ChatGPT)".to_string()
|
|
}
|
|
});
|
|
|
|
let mut labels: Vec<String> = vec!["Model", "Directory", "Permissions", "Agents.md"]
|
|
.into_iter()
|
|
.map(str::to_string)
|
|
.collect();
|
|
let mut seen: BTreeSet<String> = labels.iter().cloned().collect();
|
|
let thread_name = self.thread_name.as_deref().filter(|name| !name.is_empty());
|
|
#[expect(clippy::expect_used)]
|
|
let rate_limit_state = self
|
|
.rate_limit_state
|
|
.read()
|
|
.expect("status history rate-limit state poisoned");
|
|
#[expect(clippy::expect_used)]
|
|
let agents_summary = self
|
|
.agents_summary
|
|
.read()
|
|
.expect("status history agents summary state poisoned")
|
|
.clone();
|
|
|
|
if self.model_provider.is_some() {
|
|
push_label(&mut labels, &mut seen, "Model provider");
|
|
}
|
|
if account_value.is_some() {
|
|
push_label(&mut labels, &mut seen, "Account");
|
|
}
|
|
if thread_name.is_some() {
|
|
push_label(&mut labels, &mut seen, "Thread name");
|
|
}
|
|
if self.session_id.is_some() {
|
|
push_label(&mut labels, &mut seen, "Session");
|
|
}
|
|
if self.session_id.is_some() && self.forked_from.is_some() {
|
|
push_label(&mut labels, &mut seen, "Forked from");
|
|
}
|
|
if self.collaboration_mode.is_some() {
|
|
push_label(&mut labels, &mut seen, "Collaboration mode");
|
|
}
|
|
push_label(&mut labels, &mut seen, "Token usage");
|
|
if self.token_usage.context_window.is_some() {
|
|
push_label(&mut labels, &mut seen, "Context window");
|
|
}
|
|
|
|
self.collect_rate_limit_labels(&rate_limit_state, &mut seen, &mut labels);
|
|
|
|
let formatter = FieldFormatter::from_labels(labels.iter().map(String::as_str));
|
|
let value_width = formatter.value_width(available_inner_width);
|
|
|
|
let note_first_line = Line::from(vec![
|
|
Span::from("Visit ").cyan(),
|
|
CHATGPT_USAGE_URL.cyan().underlined(),
|
|
Span::from(" for up-to-date").cyan(),
|
|
]);
|
|
let note_second_line = Line::from(vec![
|
|
Span::from("information on rate limits and credits").cyan(),
|
|
]);
|
|
let note_lines = adaptive_wrap_lines(
|
|
[note_first_line, note_second_line],
|
|
RtOptions::new(available_inner_width),
|
|
);
|
|
lines.push(Line::from(Vec::<Span<'static>>::new()));
|
|
// The ChatGPT usage page only applies to providers backed by OpenAI auth;
|
|
// providers like Bedrock manage limits and billing elsewhere.
|
|
if self.show_chatgpt_usage_link {
|
|
lines.extend(note_lines);
|
|
lines.push(Line::from(Vec::<Span<'static>>::new()));
|
|
}
|
|
if let Some(remote_connection) = self.remote_connection.as_ref() {
|
|
let wrapped_remote = word_wrap_lines(
|
|
[Line::from(vec![
|
|
Span::from(remote_connection.address.clone()),
|
|
Span::from(" (").dim(),
|
|
Span::from(remote_connection.version.clone()).dim(),
|
|
Span::from(")").dim(),
|
|
])],
|
|
RtOptions::new(value_width.max(1)),
|
|
);
|
|
let mut wrapped_remote = wrapped_remote.into_iter();
|
|
if let Some(first) = wrapped_remote.next() {
|
|
lines.push(formatter.line("Remote", first.spans));
|
|
lines.extend(wrapped_remote.map(|line| formatter.continuation(line.spans)));
|
|
}
|
|
lines.push(Line::from(Vec::<Span<'static>>::new()));
|
|
}
|
|
|
|
let mut model_spans = vec![Span::from(self.model_name.clone())];
|
|
if !self.model_details.is_empty() {
|
|
model_spans.push(Span::from(" (").dim());
|
|
model_spans.push(Span::from(self.model_details.join(", ")).dim());
|
|
model_spans.push(Span::from(")").dim());
|
|
}
|
|
|
|
let directory_value = format_directory_display(&self.directory, Some(value_width));
|
|
|
|
lines.push(formatter.line("Model", model_spans));
|
|
if let Some(model_provider) = self.model_provider.as_ref() {
|
|
lines.push(formatter.line("Model provider", vec![Span::from(model_provider.clone())]));
|
|
}
|
|
lines.push(formatter.line("Directory", vec![Span::from(directory_value)]));
|
|
lines.push(formatter.line("Permissions", vec![Span::from(self.permissions.clone())]));
|
|
lines.push(formatter.line("Agents.md", vec![Span::from(agents_summary)]));
|
|
|
|
if let Some(account_value) = account_value {
|
|
lines.push(formatter.line("Account", vec![Span::from(account_value)]));
|
|
}
|
|
|
|
if let Some(thread_name) = thread_name {
|
|
lines.push(formatter.line("Thread name", vec![Span::from(thread_name.to_string())]));
|
|
}
|
|
if let Some(collab_mode) = self.collaboration_mode.as_ref() {
|
|
lines.push(formatter.line("Collaboration mode", vec![Span::from(collab_mode.clone())]));
|
|
}
|
|
if let Some(session) = self.session_id.as_ref() {
|
|
lines.push(formatter.line("Session", vec![Span::from(session.clone())]));
|
|
}
|
|
if self.session_id.is_some()
|
|
&& let Some(forked_from) = self.forked_from.as_ref()
|
|
{
|
|
lines.push(formatter.line("Forked from", vec![Span::from(forked_from.clone())]));
|
|
}
|
|
|
|
lines.push(Line::from(Vec::<Span<'static>>::new()));
|
|
// Hide token usage only for ChatGPT subscribers
|
|
if !matches!(self.account, Some(StatusAccountDisplay::ChatGpt { .. })) {
|
|
lines.push(formatter.line("Token usage", self.token_usage_spans()));
|
|
}
|
|
|
|
if let Some(spans) = self.context_window_spans() {
|
|
lines.push(formatter.line("Context window", spans));
|
|
}
|
|
|
|
lines.extend(self.rate_limit_lines(&rate_limit_state, available_inner_width, &formatter));
|
|
|
|
let content_width = lines.iter().map(line_display_width).max().unwrap_or(0);
|
|
let inner_width = content_width.min(available_inner_width);
|
|
let truncated_lines: Vec<Line<'static>> = lines
|
|
.into_iter()
|
|
.map(|line| truncate_line_to_width(line, inner_width))
|
|
.collect();
|
|
|
|
with_border_with_inner_width(truncated_lines, inner_width)
|
|
}
|
|
|
|
fn raw_lines(&self) -> Vec<Line<'static>> {
|
|
plain_lines(self.display_lines(u16::MAX))
|
|
}
|
|
|
|
fn display_hyperlink_lines(
|
|
&self,
|
|
width: u16,
|
|
) -> Vec<crate::terminal_hyperlinks::HyperlinkLine> {
|
|
let mut lines =
|
|
crate::terminal_hyperlinks::plain_hyperlink_lines(self.display_lines(width));
|
|
for line in &mut lines {
|
|
let visible = line
|
|
.line
|
|
.spans
|
|
.iter()
|
|
.map(|span| span.content.as_ref())
|
|
.collect::<String>();
|
|
if let Some(start_byte) = visible.find(CHATGPT_USAGE_URL) {
|
|
let start = visible[..start_byte].width();
|
|
line.hyperlinks
|
|
.push(crate::terminal_hyperlinks::TerminalHyperlink {
|
|
columns: start..start + CHATGPT_USAGE_URL.width(),
|
|
destination: CHATGPT_USAGE_URL.to_string(),
|
|
});
|
|
}
|
|
}
|
|
lines
|
|
}
|
|
|
|
fn transcript_hyperlink_lines(
|
|
&self,
|
|
width: u16,
|
|
) -> Vec<crate::terminal_hyperlinks::HyperlinkLine> {
|
|
self.display_hyperlink_lines(width)
|
|
}
|
|
}
|
|
|
|
fn format_model_provider(config: &Config, runtime_base_url: Option<&str>) -> Option<String> {
|
|
let provider = &config.model_provider;
|
|
let name = provider.name.trim();
|
|
let provider_name = if name.is_empty() {
|
|
config.model_provider_id.as_str()
|
|
} else {
|
|
name
|
|
};
|
|
let base_url = runtime_base_url.and_then(sanitize_base_url);
|
|
let is_default_openai = provider.is_openai() && base_url.is_none();
|
|
if is_default_openai {
|
|
return None;
|
|
}
|
|
|
|
Some(match base_url {
|
|
Some(base_url) => format!("{provider_name} - {base_url}"),
|
|
None => provider_name.to_string(),
|
|
})
|
|
}
|
|
|
|
fn sanitize_base_url(raw: &str) -> Option<String> {
|
|
let trimmed = raw.trim();
|
|
if trimmed.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
let Ok(mut url) = Url::parse(trimmed) else {
|
|
return None;
|
|
};
|
|
let _ = url.set_username("");
|
|
let _ = url.set_password(None);
|
|
url.set_query(None);
|
|
url.set_fragment(None);
|
|
Some(url.to_string().trim_end_matches('/').to_string()).filter(|value| !value.is_empty())
|
|
}
|