wisp/components/
elicitation_form.rs

1use acp_utils::notifications::{
2    CreateElicitationRequestParams, ElicitationAction, ElicitationParams, ElicitationResponse,
3};
4use acp_utils::{
5    ConstTitle, ElicitationSchema, EnumSchema, MultiSelectEnumSchema, PrimitiveSchema, SingleSelectEnumSchema,
6};
7use std::process::Command;
8use std::sync::Arc;
9use tokio::sync::oneshot;
10use tui::{
11    Checkbox, Component, Event, Form, FormField, FormFieldKind, FormMessage, Frame, MultiSelect, NumberField,
12    RadioSelect, SelectOption, TextField, ViewContext,
13};
14
15pub enum ElicitationMessage {
16    Responded,
17    /// Emitted when a URL modal successfully opens the browser.
18    UrlOpened {
19        elicitation_id: String,
20        server_name: String,
21    },
22}
23
24pub enum ElicitationUi {
25    Form(Form),
26    Url(UrlPrompt),
27}
28
29pub struct UrlPrompt {
30    pub server_name: String,
31    pub elicitation_id: String,
32    pub message: String,
33    pub url: String,
34    pub host: Option<String>,
35    pub warnings: Vec<String>,
36    pub launch_error: Option<String>,
37}
38
39type BrowserOpener = Arc<dyn Fn(&str) -> Result<(), String> + Send + Sync>;
40
41pub struct ElicitationForm {
42    pub ui: ElicitationUi,
43    browser_opener: BrowserOpener,
44    pub(crate) response_tx: Option<oneshot::Sender<ElicitationResponse>>,
45}
46
47impl UrlPrompt {
48    pub fn new(server_name: String, elicitation_id: String, message: String, url: String) -> Self {
49        let parsed_url = url::Url::parse(&url);
50        let host = parsed_url.as_ref().ok().and_then(|parsed| parsed.host_str().map(std::string::ToString::to_string));
51
52        let mut warnings = Vec::new();
53        match parsed_url {
54            Ok(parsed_url) => {
55                if let Some(ref h) = host
56                    && h.contains("xn--")
57                {
58                    warnings.push(
59                        "Warning: URL contains punycode (internationalized domain). Verify the domain before proceeding."
60                            .to_string(),
61                    );
62                }
63                if parsed_url.scheme() != "https" && !is_local_http_url(&parsed_url) {
64                    warnings.push("Warning: URL does not use HTTPS.".to_string());
65                }
66            }
67            Err(_) => {
68                warnings.push("Warning: URL could not be parsed. Verify it carefully before proceeding.".to_string());
69            }
70        }
71
72        Self { server_name, elicitation_id, message, url, host, warnings, launch_error: None }
73    }
74}
75
76impl Component for ElicitationForm {
77    type Message = ElicitationMessage;
78
79    async fn on_event(&mut self, event: &Event) -> Option<Vec<Self::Message>> {
80        match &mut self.ui {
81            ElicitationUi::Form(form) => {
82                let outcome = form.on_event(event).await?;
83                if let Some(msg) = outcome.into_iter().next() {
84                    match msg {
85                        FormMessage::Close => {
86                            let _ = self.response_tx.take().map(|tx| tx.send(Self::cancel()));
87                            return Some(vec![ElicitationMessage::Responded]);
88                        }
89                        FormMessage::Submit => {
90                            let response = self.confirm();
91                            let _ = self.response_tx.take().map(|tx| tx.send(response));
92                            return Some(vec![ElicitationMessage::Responded]);
93                        }
94                    }
95                }
96                Some(vec![])
97            }
98            ElicitationUi::Url(prompt) => {
99                let Event::Key(key) = event else {
100                    return Some(vec![]);
101                };
102                match key.code {
103                    tui::KeyCode::Enter => match (self.browser_opener)(&prompt.url) {
104                        Ok(()) => {
105                            let server_name = prompt.server_name.clone();
106                            let elicitation_id = prompt.elicitation_id.clone();
107                            let _ = self.response_tx.take().map(|tx| {
108                                tx.send(ElicitationResponse { action: ElicitationAction::Accept, content: None })
109                            });
110                            return Some(vec![
111                                ElicitationMessage::Responded,
112                                ElicitationMessage::UrlOpened { elicitation_id, server_name },
113                            ]);
114                        }
115                        Err(e) => {
116                            prompt.launch_error = Some(format!("Failed to open browser: {e}"));
117                        }
118                    },
119                    tui::KeyCode::Char('d' | 'D') => {
120                        let _ = self.response_tx.take().map(|tx| tx.send(Self::decline()));
121                        return Some(vec![ElicitationMessage::Responded]);
122                    }
123                    tui::KeyCode::Esc => {
124                        let _ = self.response_tx.take().map(|tx| tx.send(Self::cancel()));
125                        return Some(vec![ElicitationMessage::Responded]);
126                    }
127                    _ => {}
128                }
129                Some(vec![])
130            }
131        }
132    }
133
134    fn render(&mut self, ctx: &ViewContext) -> Frame {
135        match &mut self.ui {
136            ElicitationUi::Form(form) => form.render(ctx),
137            ElicitationUi::Url(prompt) => render_url_prompt(prompt, ctx),
138        }
139    }
140}
141
142impl ElicitationForm {
143    pub fn from_params(params: ElicitationParams, response_tx: oneshot::Sender<ElicitationResponse>) -> Self {
144        Self::with_browser_opener(params, response_tx, default_browser_opener)
145    }
146
147    pub fn with_browser_opener<F>(
148        params: ElicitationParams,
149        response_tx: oneshot::Sender<ElicitationResponse>,
150        browser_opener: F,
151    ) -> Self
152    where
153        F: Fn(&str) -> Result<(), String> + Send + Sync + 'static,
154    {
155        let ui = match params.request {
156            CreateElicitationRequestParams::FormElicitationParams { message, requested_schema, .. } => {
157                let fields = parse_schema(&requested_schema);
158                ElicitationUi::Form(Form::new(message, fields))
159            }
160            CreateElicitationRequestParams::UrlElicitationParams { message, url, elicitation_id, .. } => {
161                ElicitationUi::Url(UrlPrompt::new(params.server_name, elicitation_id, message, url))
162            }
163        };
164        Self { ui, browser_opener: Arc::new(browser_opener), response_tx: Some(response_tx) }
165    }
166
167    pub fn confirm(&self) -> ElicitationResponse {
168        match &self.ui {
169            ElicitationUi::Form(form) => {
170                ElicitationResponse { action: ElicitationAction::Accept, content: Some(form.to_json()) }
171            }
172            ElicitationUi::Url(_) => ElicitationResponse { action: ElicitationAction::Accept, content: None },
173        }
174    }
175
176    pub fn decline() -> ElicitationResponse {
177        ElicitationResponse { action: ElicitationAction::Decline, content: None }
178    }
179
180    pub fn cancel() -> ElicitationResponse {
181        ElicitationResponse { action: ElicitationAction::Cancel, content: None }
182    }
183}
184
185fn render_url_prompt(prompt: &UrlPrompt, ctx: &ViewContext) -> Frame {
186    use tui::{Line, Style};
187
188    let mut lines = Vec::new();
189    let primary = ctx.theme.primary();
190    let text_primary = ctx.theme.text_primary();
191    let text_secondary = ctx.theme.text_secondary();
192    let warning_color = ctx.theme.warning();
193    let muted = ctx.theme.muted();
194
195    lines.push(Line::with_style(
196        format!("{} requests you to open a URL", prompt.server_name),
197        Style::fg(primary).bold(),
198    ));
199    lines.push(Line::default());
200    lines.push(Line::with_style(&prompt.message, Style::fg(text_primary)));
201    lines.push(Line::default());
202    lines.push(Line::with_style("URL:", Style::fg(text_secondary)));
203    lines.push(Line::with_style(&prompt.url, Style::fg(primary)));
204
205    if let Some(ref host) = prompt.host {
206        lines.push(Line::with_style(format!("Host: {host}"), Style::fg(text_secondary)));
207    }
208
209    if !prompt.warnings.is_empty() {
210        lines.push(Line::default());
211        for warning in &prompt.warnings {
212            lines.push(Line::styled(warning, warning_color));
213        }
214    }
215
216    if let Some(ref error) = prompt.launch_error {
217        lines.push(Line::default());
218        lines.push(Line::styled(error, ctx.theme.error()));
219    }
220
221    lines.push(Line::default());
222    lines.push(Line::styled("Enter to open URL · D to decline · Esc to cancel", muted));
223
224    Frame::new(lines)
225}
226
227fn is_local_http_url(url: &url::Url) -> bool {
228    if url.scheme() != "http" {
229        return false;
230    }
231
232    matches!(url.host_str(), Some("localhost" | "127.0.0.1" | "::1"))
233}
234
235fn default_browser_opener(url: &str) -> Result<(), String> {
236    #[cfg(target_os = "macos")]
237    {
238        let status = Command::new("open").arg(url).status().map_err(|e| e.to_string())?;
239        return status.success().then_some(()).ok_or_else(|| format!("open exited with status {status}"));
240    }
241
242    #[cfg(target_os = "linux")]
243    {
244        let status = Command::new("xdg-open").arg(url).status().map_err(|e| e.to_string())?;
245        return status.success().then_some(()).ok_or_else(|| format!("xdg-open exited with status {status}"));
246    }
247
248    #[cfg(target_os = "windows")]
249    {
250        let status = Command::new("cmd").args(["/C", "start", url]).status().map_err(|e| e.to_string())?;
251        return status.success().then_some(()).ok_or_else(|| format!("start exited with status {status}"));
252    }
253
254    #[allow(unreachable_code)]
255    Err("Unsupported platform for opening URLs".to_string())
256}
257
258fn parse_schema(schema: &ElicitationSchema) -> Vec<FormField> {
259    let required = schema.required.as_deref().unwrap_or(&[]);
260    schema
261        .properties
262        .iter()
263        .map(|(name, prop)| {
264            let (title, description) = extract_metadata(prop);
265            FormField {
266                name: name.clone(),
267                label: title.unwrap_or_else(|| name.clone()),
268                description,
269                required: required.iter().any(|r| r == name),
270                kind: parse_field_kind(prop),
271            }
272        })
273        .collect()
274}
275
276fn parse_field_kind(prop: &PrimitiveSchema) -> FormFieldKind {
277    match prop {
278        PrimitiveSchema::Boolean(b) => FormFieldKind::Boolean(Checkbox::new(b.default.unwrap_or(false))),
279        PrimitiveSchema::Integer(_) => FormFieldKind::Number(NumberField::new(String::new(), true)),
280        PrimitiveSchema::Number(_) => FormFieldKind::Number(NumberField::new(String::new(), false)),
281        PrimitiveSchema::String(_) => FormFieldKind::Text(TextField::new(String::new())),
282        PrimitiveSchema::Enum(e) => parse_enum_field(e),
283    }
284}
285
286fn parse_enum_field(e: &EnumSchema) -> FormFieldKind {
287    match e {
288        EnumSchema::Single(s) => match s {
289            SingleSelectEnumSchema::Untitled(u) => {
290                let options = options_from_strings(&u.enum_);
291                let default_idx =
292                    u.default.as_ref().and_then(|d| options.iter().position(|o| o.value == *d)).unwrap_or(0);
293                FormFieldKind::SingleSelect(RadioSelect::new(options, default_idx))
294            }
295            SingleSelectEnumSchema::Titled(t) => {
296                let options = options_from_const_titles(&t.one_of);
297                let default_idx =
298                    t.default.as_ref().and_then(|d| options.iter().position(|o| o.value == *d)).unwrap_or(0);
299                FormFieldKind::SingleSelect(RadioSelect::new(options, default_idx))
300            }
301        },
302        EnumSchema::Multi(m) => match m {
303            MultiSelectEnumSchema::Untitled(u) => {
304                let options = options_from_strings(&u.items.enum_);
305                let defaults = u.default.as_deref().unwrap_or(&[]);
306                let selected: Vec<bool> = options.iter().map(|o| defaults.contains(&o.value)).collect();
307                FormFieldKind::MultiSelect(MultiSelect::new(options, selected))
308            }
309            MultiSelectEnumSchema::Titled(t) => {
310                let options = options_from_const_titles(&t.items.any_of);
311                let defaults = t.default.as_deref().unwrap_or(&[]);
312                let selected: Vec<bool> = options.iter().map(|o| defaults.contains(&o.value)).collect();
313                FormFieldKind::MultiSelect(MultiSelect::new(options, selected))
314            }
315        },
316        EnumSchema::Legacy(l) => {
317            let options = options_from_strings(&l.enum_);
318            FormFieldKind::SingleSelect(RadioSelect::new(options, 0))
319        }
320    }
321}
322
323fn extract_metadata(prop: &PrimitiveSchema) -> (Option<String>, Option<String>) {
324    match prop {
325        PrimitiveSchema::String(s) => {
326            (s.title.as_ref().map(ToString::to_string), s.description.as_ref().map(ToString::to_string))
327        }
328        PrimitiveSchema::Number(n) => {
329            (n.title.as_ref().map(ToString::to_string), n.description.as_ref().map(ToString::to_string))
330        }
331        PrimitiveSchema::Integer(i) => {
332            (i.title.as_ref().map(ToString::to_string), i.description.as_ref().map(ToString::to_string))
333        }
334        PrimitiveSchema::Boolean(b) => {
335            (b.title.as_ref().map(ToString::to_string), b.description.as_ref().map(ToString::to_string))
336        }
337        PrimitiveSchema::Enum(e) => extract_enum_metadata(e),
338    }
339}
340
341fn extract_enum_metadata(e: &EnumSchema) -> (Option<String>, Option<String>) {
342    match e {
343        EnumSchema::Single(s) => match s {
344            SingleSelectEnumSchema::Untitled(u) => {
345                (u.title.as_ref().map(ToString::to_string), u.description.as_ref().map(ToString::to_string))
346            }
347            SingleSelectEnumSchema::Titled(t) => {
348                (t.title.as_ref().map(ToString::to_string), t.description.as_ref().map(ToString::to_string))
349            }
350        },
351        EnumSchema::Multi(m) => match m {
352            MultiSelectEnumSchema::Untitled(u) => {
353                (u.title.as_ref().map(ToString::to_string), u.description.as_ref().map(ToString::to_string))
354            }
355            MultiSelectEnumSchema::Titled(t) => {
356                (t.title.as_ref().map(ToString::to_string), t.description.as_ref().map(ToString::to_string))
357            }
358        },
359        EnumSchema::Legacy(l) => {
360            (l.title.as_ref().map(ToString::to_string), l.description.as_ref().map(ToString::to_string))
361        }
362    }
363}
364
365fn options_from_strings(values: &[String]) -> Vec<SelectOption> {
366    values.iter().map(|s| SelectOption { value: s.clone(), title: s.clone(), description: None }).collect()
367}
368
369fn options_from_const_titles(items: &[ConstTitle]) -> Vec<SelectOption> {
370    items
371        .iter()
372        .map(|ct| SelectOption { value: ct.const_.clone(), title: ct.title.clone(), description: None })
373        .collect()
374}
375
376#[cfg(test)]
377mod tests {
378    use super::*;
379    use acp_utils::EnumSchema;
380    use std::collections::BTreeMap;
381    use std::sync::{Arc, Mutex};
382
383    fn test_schema() -> ElicitationSchema {
384        serde_json::from_value(serde_json::json!({
385            "type": "object",
386            "properties": {
387                "name": {
388                    "type": "string",
389                    "title": "Your Name",
390                    "description": "Enter your full name"
391                },
392                "age": {
393                    "type": "integer",
394                    "title": "Age",
395                    "minimum": 0,
396                    "maximum": 150
397                },
398                "rating": {
399                    "type": "number",
400                    "title": "Rating"
401                },
402                "approved": {
403                    "type": "boolean",
404                    "title": "Approved",
405                    "default": true
406                },
407                "color": {
408                    "type": "string",
409                    "title": "Favorite Color",
410                    "enum": ["red", "green", "blue"]
411                },
412                "tags": {
413                    "type": "array",
414                    "title": "Tags",
415                    "items": {
416                        "type": "string",
417                        "enum": ["fast", "reliable", "cheap"]
418                    }
419                }
420            },
421            "required": ["name", "color"]
422        }))
423        .unwrap()
424    }
425
426    #[test]
427    fn parse_schema_extracts_all_field_types() {
428        let schema = test_schema();
429        let fields = parse_schema(&schema);
430        assert_eq!(fields.len(), 6);
431
432        let name_field = fields.iter().find(|f| f.name == "name").unwrap();
433        assert_eq!(name_field.label, "Your Name");
434        assert!(name_field.required);
435        assert!(matches!(name_field.kind, FormFieldKind::Text(_)));
436
437        let age_field = fields.iter().find(|f| f.name == "age").unwrap();
438        match &age_field.kind {
439            FormFieldKind::Number(nf) => assert!(nf.integer_only),
440            _ => panic!("Expected Number (integer)"),
441        }
442
443        let bool_field = fields.iter().find(|f| f.name == "approved").unwrap();
444        match &bool_field.kind {
445            FormFieldKind::Boolean(cb) => assert!(cb.checked),
446            _ => panic!("Expected Boolean"),
447        }
448
449        let color_field = fields.iter().find(|f| f.name == "color").unwrap();
450        assert!(color_field.required);
451        match &color_field.kind {
452            FormFieldKind::SingleSelect(rs) => {
453                assert_eq!(rs.options.len(), 3);
454                assert_eq!(rs.options[0].value, "red");
455            }
456            _ => panic!("Expected SingleSelect"),
457        }
458
459        let tags_field = fields.iter().find(|f| f.name == "tags").unwrap();
460        match &tags_field.kind {
461            FormFieldKind::MultiSelect(ms) => {
462                assert_eq!(ms.options.len(), 3);
463                assert!(ms.selected.iter().all(|&s| !s));
464            }
465            _ => panic!("Expected MultiSelect"),
466        }
467    }
468
469    #[test]
470    fn confirm_produces_correct_json() {
471        let (tx, _rx) = oneshot::channel();
472        let params = ElicitationParams {
473            server_name: "test-server".to_string(),
474            request: CreateElicitationRequestParams::FormElicitationParams {
475                meta: None,
476                message: "Test".to_string(),
477                requested_schema: ElicitationSchema::builder()
478                    .optional_string("name")
479                    .optional_bool("approved", true)
480                    .optional_enum_schema(
481                        "color",
482                        EnumSchema::builder(vec!["red".into(), "green".into()])
483                            .untitled()
484                            .with_default("green")
485                            .unwrap()
486                            .build(),
487                    )
488                    .build()
489                    .unwrap(),
490            },
491        };
492
493        let form = ElicitationForm::from_params(params, tx);
494        let response = form.confirm();
495
496        assert_eq!(response.action, ElicitationAction::Accept);
497        let content = response.content.unwrap();
498        assert_eq!(content["name"], "");
499        assert_eq!(content["approved"], true);
500        assert_eq!(content["color"], "green");
501    }
502
503    #[test]
504    fn esc_returns_cancel() {
505        let response = ElicitationForm::cancel();
506        assert_eq!(response.action, ElicitationAction::Cancel);
507        assert!(response.content.is_none());
508    }
509
510    #[test]
511    fn decline_returns_decline() {
512        let response = ElicitationForm::decline();
513        assert_eq!(response.action, ElicitationAction::Decline);
514        assert!(response.content.is_none());
515    }
516
517    #[test]
518    fn url_prompt_parses_host() {
519        let prompt = UrlPrompt::new(
520            "github".to_string(),
521            "el-1".to_string(),
522            "Authorize".to_string(),
523            "https://github.com/login/oauth".to_string(),
524        );
525        assert_eq!(prompt.host.as_deref(), Some("github.com"));
526        assert!(prompt.warnings.is_empty());
527        assert!(prompt.launch_error.is_none());
528    }
529
530    #[test]
531    fn url_prompt_warns_on_non_https() {
532        let prompt = UrlPrompt::new(
533            "test".to_string(),
534            "el-1".to_string(),
535            "Open this".to_string(),
536            "http://example.com/form".to_string(),
537        );
538        assert_eq!(prompt.warnings.len(), 1);
539        assert!(prompt.warnings[0].contains("HTTPS"));
540    }
541
542    #[test]
543    fn url_prompt_does_not_warn_on_localhost() {
544        let prompt = UrlPrompt::new(
545            "test".to_string(),
546            "el-1".to_string(),
547            "Local".to_string(),
548            "http://localhost:3000/auth".to_string(),
549        );
550        assert!(prompt.warnings.is_empty());
551    }
552
553    #[test]
554    fn url_prompt_warns_on_invalid_url() {
555        let prompt = UrlPrompt::new(
556            "test".to_string(),
557            "el-invalid".to_string(),
558            "Check this".to_string(),
559            "not a valid url".to_string(),
560        );
561        assert!(prompt.host.is_none());
562        assert!(
563            prompt.warnings.iter().any(|warning| warning.contains("could not be parsed")),
564            "invalid URLs should show an explicit warning"
565        );
566    }
567
568    #[test]
569    fn url_prompt_warns_on_punycode() {
570        let prompt = UrlPrompt::new(
571            "test".to_string(),
572            "el-1".to_string(),
573            "Phishing".to_string(),
574            "https://xn--e1afmkfd.xn--p1ai/".to_string(),
575        );
576        assert_eq!(prompt.warnings.len(), 1);
577        assert!(prompt.warnings[0].contains("punycode"));
578    }
579
580    #[test]
581    fn url_prompt_warns_on_punycode_and_non_https() {
582        let prompt = UrlPrompt::new(
583            "test".to_string(),
584            "el-1".to_string(),
585            "Both".to_string(),
586            "http://xn--e1afmkfd.xn--p1ai/".to_string(),
587        );
588        assert_eq!(prompt.warnings.len(), 2, "both warnings should be present");
589        assert!(prompt.warnings.iter().any(|w| w.contains("punycode")));
590        assert!(prompt.warnings.iter().any(|w| w.contains("HTTPS")));
591    }
592
593    fn url_params(server: &str, id: &str, url: &str) -> ElicitationParams {
594        ElicitationParams {
595            server_name: server.to_string(),
596            request: CreateElicitationRequestParams::UrlElicitationParams {
597                meta: None,
598                message: "Auth".to_string(),
599                url: url.to_string(),
600                elicitation_id: id.to_string(),
601            },
602        }
603    }
604
605    #[tokio::test]
606    async fn url_modal_enter_returns_accept_with_carried_id() {
607        let opened_urls = Arc::new(Mutex::new(Vec::new()));
608        let opened_urls_for_opener = Arc::clone(&opened_urls);
609        let (tx, rx) = oneshot::channel();
610        let params = url_params("github", "el-123", "https://github.com/login/oauth");
611        let mut form = ElicitationForm::with_browser_opener(params, tx, move |url| {
612            opened_urls_for_opener.lock().unwrap().push(url.to_string());
613            Ok(())
614        });
615        let outcome =
616            form.on_event(&Event::Key(tui::KeyEvent::new(tui::KeyCode::Enter, tui::KeyModifiers::NONE))).await;
617        let messages = outcome.unwrap();
618
619        assert_eq!(opened_urls.lock().unwrap().as_slice(), ["https://github.com/login/oauth"]);
620        assert!(messages.iter().any(|m| matches!(m, ElicitationMessage::Responded)));
621        let opened = messages.iter().find_map(|m| match m {
622            ElicitationMessage::UrlOpened { elicitation_id, server_name } => {
623                Some((elicitation_id.clone(), server_name.clone()))
624            }
625            ElicitationMessage::Responded => None,
626        });
627        let (id, server) = opened.expect("UrlOpened message should be emitted");
628        assert_eq!(id, "el-123", "elicitation_id must come from request, not URL re-parsing");
629        assert_eq!(server, "github");
630
631        let response = rx.await.unwrap();
632        assert_eq!(response.action, ElicitationAction::Accept);
633        assert!(response.content.is_none());
634    }
635
636    #[tokio::test]
637    async fn url_modal_launch_failure_keeps_modal_open_and_shows_error() {
638        let (tx, mut rx) = oneshot::channel();
639        let params = url_params("github", "el-fail", "https://github.com/login/oauth");
640        let mut form = ElicitationForm::with_browser_opener(params, tx, |_| Err("boom".to_string()));
641
642        let outcome =
643            form.on_event(&Event::Key(tui::KeyEvent::new(tui::KeyCode::Enter, tui::KeyModifiers::NONE))).await;
644        let messages = outcome.expect("URL opener failure should still produce an event result");
645        assert!(messages.is_empty(), "modal should remain open on launch failure");
646        assert!(rx.try_recv().is_err(), "response should not be sent when browser launch fails");
647
648        let ElicitationUi::Url(prompt) = &form.ui else {
649            panic!("expected URL prompt");
650        };
651        assert_eq!(prompt.launch_error.as_deref(), Some("Failed to open browser: boom"));
652    }
653
654    #[tokio::test]
655    async fn url_modal_d_returns_decline() {
656        let (tx, rx) = oneshot::channel();
657        let params = url_params("github", "el-456", "https://github.com/login/oauth");
658        let mut form = ElicitationForm::from_params(params, tx);
659        let outcome =
660            form.on_event(&Event::Key(tui::KeyEvent::new(tui::KeyCode::Char('d'), tui::KeyModifiers::NONE))).await;
661        let messages = outcome.unwrap();
662
663        assert!(messages.iter().any(|m| matches!(m, ElicitationMessage::Responded)));
664
665        let response = rx.await.unwrap();
666        assert_eq!(response.action, ElicitationAction::Decline);
667    }
668
669    #[tokio::test]
670    async fn url_modal_esc_returns_cancel() {
671        let (tx, rx) = oneshot::channel();
672        let params = url_params("github", "el-789", "https://github.com/login/oauth");
673        let mut form = ElicitationForm::from_params(params, tx);
674        let outcome = form.on_event(&Event::Key(tui::KeyEvent::new(tui::KeyCode::Esc, tui::KeyModifiers::NONE))).await;
675        let messages = outcome.unwrap();
676
677        assert!(messages.iter().any(|m| matches!(m, ElicitationMessage::Responded)));
678
679        let response = rx.await.unwrap();
680        assert_eq!(response.action, ElicitationAction::Cancel);
681    }
682
683    #[tokio::test]
684    async fn form_modal_esc_returns_cancel() {
685        let (tx, rx) = oneshot::channel();
686        let params = ElicitationParams {
687            server_name: "test".to_string(),
688            request: CreateElicitationRequestParams::FormElicitationParams {
689                meta: None,
690                message: "Test".to_string(),
691                requested_schema: ElicitationSchema::builder().build().unwrap(),
692            },
693        };
694        let mut form = ElicitationForm::from_params(params, tx);
695        let outcome = form.on_event(&Event::Key(tui::KeyEvent::new(tui::KeyCode::Esc, tui::KeyModifiers::NONE))).await;
696        let messages = outcome.unwrap();
697
698        assert!(messages.iter().any(|m| matches!(m, ElicitationMessage::Responded)));
699
700        let response = rx.await.unwrap();
701        assert_eq!(response.action, ElicitationAction::Cancel);
702    }
703
704    #[test]
705    fn one_of_string_produces_single_select() {
706        let schema: ElicitationSchema = serde_json::from_value(serde_json::json!({
707            "type": "object",
708            "properties": {
709                "size": {
710                    "type": "string",
711                    "oneOf": [
712                        { "const": "s", "title": "Small" },
713                        { "const": "m", "title": "Medium" },
714                        { "const": "l", "title": "Large" }
715                    ]
716                }
717            }
718        }))
719        .unwrap();
720        let fields = parse_schema(&schema);
721        assert_eq!(fields.len(), 1);
722        match &fields[0].kind {
723            FormFieldKind::SingleSelect(rs) => {
724                assert_eq!(rs.options.len(), 3);
725                assert_eq!(rs.options[0].title, "Small");
726                assert_eq!(rs.options[0].value, "s");
727            }
728            _ => panic!("Expected SingleSelect"),
729        }
730    }
731
732    #[test]
733    fn empty_schema_produces_no_fields() {
734        let schema = ElicitationSchema::new(BTreeMap::new());
735        let fields = parse_schema(&schema);
736        assert!(fields.is_empty());
737    }
738
739    #[test]
740    fn url_modal_renders_server_name_and_url() {
741        use tui::testing::render_component;
742
743        let prompt = UrlPrompt::new(
744            "github".to_string(),
745            "el-1".to_string(),
746            "Authorize GitHub".to_string(),
747            "https://github.com/login/oauth".to_string(),
748        );
749        let ui = ElicitationUi::Url(prompt);
750        let mut form = ElicitationForm { ui, browser_opener: Arc::new(default_browser_opener), response_tx: None };
751
752        let lines = render_component(|ctx| form.render(ctx), 80, 20).get_lines();
753        let text: String = lines.join("\n");
754        assert!(text.contains("github"), "should show server name");
755        assert!(text.contains("https://github.com/login/oauth"), "should show full URL");
756        assert!(text.contains("github.com"), "should show host");
757        assert!(text.contains("Enter to open URL"), "should show footer hint");
758    }
759}
wisp/components/elicitation_form.rs

wisp/components/
elicitation_form.rs
