firstpass_proxy/
launch.rs1use std::collections::HashMap;
19use std::process::Command;
20
21struct Agent {
23 name: &'static str,
25 bin: &'static str,
27 vars: &'static [&'static str],
30}
31
32const AGENTS: &[Agent] = &[
33 Agent {
34 name: "claude",
35 bin: "claude",
36 vars: &["ANTHROPIC_BASE_URL"],
37 },
38 Agent {
39 name: "codex",
40 bin: "codex",
41 vars: &["OPENAI_BASE_URL"],
42 },
43 Agent {
45 name: "openai",
46 bin: "",
47 vars: &["OPENAI_BASE_URL"],
48 },
49 Agent {
53 name: "gemini",
54 bin: "gemini",
55 vars: &["GOOGLE_GEMINI_BASE_URL"],
56 },
57];
58
59fn fail(msg: &str) -> ! {
65 eprintln!("firstpass launch: {msg}");
66 std::process::exit(2)
67}
68
69#[must_use]
72pub fn base_url() -> String {
73 url_for_bind(&std::env::var("FIRSTPASS_BIND").unwrap_or_else(|_| "127.0.0.1:8080".to_owned()))
74}
75
76fn url_for_bind(bind: &str) -> String {
79 let host = bind
81 .strip_prefix("0.0.0.0")
82 .map_or_else(|| bind.to_owned(), |port| format!("127.0.0.1{port}"));
83 format!("http://{host}")
84}
85
86fn split(args: &[String]) -> (Option<&str>, Vec<String>) {
90 let mut rest = args.iter();
91 let name = rest.next().map(String::as_str);
92 let passthrough: Vec<String> = rest
93 .skip_while(|a| a.as_str() == "--")
94 .map(Clone::clone)
95 .collect();
96 (name, passthrough)
97}
98
99fn env_for(agent: &Agent, url: &str) -> HashMap<String, String> {
101 agent
102 .vars
103 .iter()
104 .map(|v| {
105 let base = if v.starts_with("OPENAI") {
108 format!("{url}/v1")
109 } else {
110 url.to_owned()
111 };
112 ((*v).to_owned(), base)
113 })
114 .collect()
115}
116
117#[derive(Debug, PartialEq, Eq)]
119enum Listener {
120 Firstpass,
122 Foreign,
126 None,
128}
129
130fn classify(status_ok: bool, body: Option<&serde_json::Value>) -> Listener {
133 if !status_ok {
134 return Listener::None;
135 }
136 match body.and_then(|b| b.get("service")).and_then(|s| s.as_str()) {
137 Some("firstpass") => Listener::Firstpass,
138 _ => Listener::Foreign,
139 }
140}
141
142async fn probe(url: &str) -> Listener {
144 let Ok(client) = reqwest::Client::builder()
145 .timeout(std::time::Duration::from_secs(2))
146 .build()
147 else {
148 return Listener::None;
149 };
150 let Ok(resp) = client.get(format!("{url}/healthz")).send().await else {
151 return Listener::None;
152 };
153 let ok = resp.status().is_success();
154 let body = resp.json::<serde_json::Value>().await.ok();
155 classify(ok, body.as_ref())
156}
157
158pub async fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
164 let (name, passthrough) = split(args);
165 let Some(name) = name else {
166 let names: Vec<&str> = AGENTS.iter().map(|a| a.name).collect();
167 fail(&format!(
168 "firstpass launch <agent> [-- args…]\n agents: {}\n\n\
169 `openai` needs an explicit command: firstpass launch openai -- <cmd> [args…]",
170 names.join(", ")
171 ));
172 };
173 let Some(agent) = AGENTS.iter().find(|a| a.name == name) else {
174 let names: Vec<&str> = AGENTS.iter().map(|a| a.name).collect();
175 fail(&format!(
176 "unknown agent {name:?} (known: {})",
177 names.join(", ")
178 ));
179 };
180
181 let (bin, argv) = if agent.bin.is_empty() {
184 let Some((first, rest)) = passthrough.split_first() else {
185 fail(&format!(
186 "`firstpass launch {name}` needs a command:\n\n firstpass launch {name} -- <cmd> [args…]"
187 ));
188 };
189 (first.clone(), rest.to_vec())
190 } else {
191 (agent.bin.to_owned(), passthrough)
192 };
193
194 let url = base_url();
195 match probe(&url).await {
196 Listener::Firstpass => {}
197 Listener::None => {
198 fail(&format!(
199 "no proxy is listening at {url} — start one first:\n\n firstpass up\n\n\
200 (or `firstpass kiosk` to configure and start it in one press).\n\n\
201 Launching into a proxy that is not up produces a connection error from inside \
202 {bin}, which reads like {bin} is broken."
203 ));
204 }
205 Listener::Foreign => {
206 fail(&format!(
207 "something is listening at {url}, but it is not firstpass.\n\n\
208 Refusing to launch {bin} against it: every request would go to that service \
209 instead of through the gate, and it may well answer, so nothing would look \
210 wrong.\n\n\
211 Free the port, or point firstpass elsewhere and use the same address here:\n\n \
212 FIRSTPASS_BIND=127.0.0.1:8099 firstpass up\n \
213 FIRSTPASS_BIND=127.0.0.1:8099 firstpass launch {name}"
214 ));
215 }
216 }
217
218 let env = env_for(agent, &url);
219 for (k, v) in &env {
220 eprintln!("firstpass: {k}={v}");
221 }
222 eprintln!("firstpass: exec {bin}");
223
224 let mut cmd = Command::new(&bin);
225 cmd.args(&argv).envs(&env);
226
227 #[cfg(unix)]
228 {
229 use std::os::unix::process::CommandExt;
232 let err = cmd.exec();
233 Err(format!("could not exec {bin}: {err}. Is it installed and on PATH?").into())
234 }
235 #[cfg(not(unix))]
236 {
237 let status = cmd
238 .status()
239 .map_err(|e| format!("could not run {bin}: {e}. Is it installed and on PATH?"))?;
240 std::process::exit(status.code().unwrap_or(1));
241 }
242}
243
244#[cfg(test)]
245mod tests {
246 use super::*;
247
248 #[test]
249 fn a_wildcard_bind_becomes_a_connectable_loopback_address() {
250 assert_eq!(url_for_bind("0.0.0.0:9090"), "http://127.0.0.1:9090");
253 assert_eq!(url_for_bind("127.0.0.1:7777"), "http://127.0.0.1:7777");
254 }
255
256 #[test]
257 fn a_foreign_service_holding_the_port_is_not_mistaken_for_firstpass() {
258 let foreign = serde_json::json!({ "status": "ok", "llmMode": "api" });
262 assert_eq!(classify(true, Some(&foreign)), Listener::Foreign);
263
264 let ours =
265 serde_json::json!({ "status": "ok", "service": "firstpass", "version": "0.3.0" });
266 assert_eq!(classify(true, Some(&ours)), Listener::Firstpass);
267
268 assert_eq!(classify(false, Some(&ours)), Listener::None);
270 assert_eq!(classify(true, None), Listener::Foreign);
271 }
272
273 #[test]
274 fn a_bare_double_dash_separates_our_args_from_the_agents() {
275 let args: Vec<String> = ["claude", "--", "-p", "hi"]
276 .iter()
277 .map(|s| (*s).to_owned())
278 .collect();
279 let (name, rest) = split(&args);
280 assert_eq!(name, Some("claude"));
281 assert_eq!(rest, vec!["-p".to_owned(), "hi".to_owned()]);
282 }
283
284 #[test]
285 fn agent_args_survive_without_a_separator_too() {
286 let args: Vec<String> = ["claude", "-p", "hi"]
287 .iter()
288 .map(|s| (*s).to_owned())
289 .collect();
290 let (_, rest) = split(&args);
291 assert_eq!(rest, vec!["-p".to_owned(), "hi".to_owned()]);
292 }
293
294 #[test]
295 fn each_agent_routes_the_vendor_it_actually_speaks() {
296 let claude = AGENTS.iter().find(|a| a.name == "claude").expect("claude");
299 assert_eq!(
300 env_for(claude, "http://127.0.0.1:8080").get("ANTHROPIC_BASE_URL"),
301 Some(&"http://127.0.0.1:8080".to_owned())
302 );
303 let codex = AGENTS.iter().find(|a| a.name == "codex").expect("codex");
304 assert_eq!(
305 env_for(codex, "http://127.0.0.1:8080").get("OPENAI_BASE_URL"),
306 Some(&"http://127.0.0.1:8080/v1".to_owned())
307 );
308 let gemini = AGENTS.iter().find(|a| a.name == "gemini").expect("gemini");
311 assert_eq!(
312 env_for(gemini, "http://127.0.0.1:8080").get("GOOGLE_GEMINI_BASE_URL"),
313 Some(&"http://127.0.0.1:8080".to_owned()),
314 "GOOGLE_GEMINI_BASE_URL must point at the proxy root, not /v1"
315 );
316 }
318}