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];
50
51fn fail(msg: &str) -> ! {
57 eprintln!("firstpass launch: {msg}");
58 std::process::exit(2)
59}
60
61#[must_use]
64pub fn base_url() -> String {
65 url_for_bind(&std::env::var("FIRSTPASS_BIND").unwrap_or_else(|_| "127.0.0.1:8080".to_owned()))
66}
67
68fn url_for_bind(bind: &str) -> String {
71 let host = bind
73 .strip_prefix("0.0.0.0")
74 .map_or_else(|| bind.to_owned(), |port| format!("127.0.0.1{port}"));
75 format!("http://{host}")
76}
77
78fn split(args: &[String]) -> (Option<&str>, Vec<String>) {
82 let mut rest = args.iter();
83 let name = rest.next().map(String::as_str);
84 let passthrough: Vec<String> = rest
85 .skip_while(|a| a.as_str() == "--")
86 .map(Clone::clone)
87 .collect();
88 (name, passthrough)
89}
90
91fn env_for(agent: &Agent, url: &str) -> HashMap<String, String> {
93 agent
94 .vars
95 .iter()
96 .map(|v| ((*v).to_owned(), url.to_owned()))
97 .collect()
98}
99
100#[derive(Debug, PartialEq, Eq)]
102enum Listener {
103 Firstpass,
105 Foreign,
109 None,
111}
112
113fn classify(status_ok: bool, body: Option<&serde_json::Value>) -> Listener {
116 if !status_ok {
117 return Listener::None;
118 }
119 match body.and_then(|b| b.get("service")).and_then(|s| s.as_str()) {
120 Some("firstpass") => Listener::Firstpass,
121 _ => Listener::Foreign,
122 }
123}
124
125async fn probe(url: &str) -> Listener {
127 let Ok(client) = reqwest::Client::builder()
128 .timeout(std::time::Duration::from_secs(2))
129 .build()
130 else {
131 return Listener::None;
132 };
133 let Ok(resp) = client.get(format!("{url}/healthz")).send().await else {
134 return Listener::None;
135 };
136 let ok = resp.status().is_success();
137 let body = resp.json::<serde_json::Value>().await.ok();
138 classify(ok, body.as_ref())
139}
140
141pub async fn run(args: &[String]) -> Result<(), Box<dyn std::error::Error>> {
147 let (name, passthrough) = split(args);
148 let Some(name) = name else {
149 let names: Vec<&str> = AGENTS.iter().map(|a| a.name).collect();
150 fail(&format!(
151 "firstpass launch <agent> [-- args…]\n agents: {}\n\n\
152 `openai` needs an explicit command: firstpass launch openai -- <cmd> [args…]",
153 names.join(", ")
154 ));
155 };
156 let Some(agent) = AGENTS.iter().find(|a| a.name == name) else {
157 let names: Vec<&str> = AGENTS.iter().map(|a| a.name).collect();
158 fail(&format!(
159 "unknown agent {name:?} (known: {})",
160 names.join(", ")
161 ));
162 };
163
164 let (bin, argv) = if agent.bin.is_empty() {
167 let Some((first, rest)) = passthrough.split_first() else {
168 fail(&format!(
169 "`firstpass launch {name}` needs a command:\n\n firstpass launch {name} -- <cmd> [args…]"
170 ));
171 };
172 (first.clone(), rest.to_vec())
173 } else {
174 (agent.bin.to_owned(), passthrough)
175 };
176
177 let url = base_url();
178 match probe(&url).await {
179 Listener::Firstpass => {}
180 Listener::None => {
181 fail(&format!(
182 "no proxy is listening at {url} — start one first:\n\n firstpass up\n\n\
183 (or `firstpass kiosk` to configure and start it in one press).\n\n\
184 Launching into a proxy that is not up produces a connection error from inside \
185 {bin}, which reads like {bin} is broken."
186 ));
187 }
188 Listener::Foreign => {
189 fail(&format!(
190 "something is listening at {url}, but it is not firstpass.\n\n\
191 Refusing to launch {bin} against it: every request would go to that service \
192 instead of through the gate, and it may well answer, so nothing would look \
193 wrong.\n\n\
194 Free the port, or point firstpass elsewhere and use the same address here:\n\n \
195 FIRSTPASS_BIND=127.0.0.1:8099 firstpass up\n \
196 FIRSTPASS_BIND=127.0.0.1:8099 firstpass launch {name}"
197 ));
198 }
199 }
200
201 let env = env_for(agent, &url);
202 for (k, v) in &env {
203 eprintln!("firstpass: {k}={v}");
204 }
205 eprintln!("firstpass: exec {bin}");
206
207 let mut cmd = Command::new(&bin);
208 cmd.args(&argv).envs(&env);
209
210 #[cfg(unix)]
211 {
212 use std::os::unix::process::CommandExt;
215 let err = cmd.exec();
216 Err(format!("could not exec {bin}: {err}. Is it installed and on PATH?").into())
217 }
218 #[cfg(not(unix))]
219 {
220 let status = cmd
221 .status()
222 .map_err(|e| format!("could not run {bin}: {e}. Is it installed and on PATH?"))?;
223 std::process::exit(status.code().unwrap_or(1));
224 }
225}
226
227#[cfg(test)]
228mod tests {
229 use super::*;
230
231 #[test]
232 fn a_wildcard_bind_becomes_a_connectable_loopback_address() {
233 assert_eq!(url_for_bind("0.0.0.0:9090"), "http://127.0.0.1:9090");
236 assert_eq!(url_for_bind("127.0.0.1:7777"), "http://127.0.0.1:7777");
237 }
238
239 #[test]
240 fn a_foreign_service_holding_the_port_is_not_mistaken_for_firstpass() {
241 let foreign = serde_json::json!({ "status": "ok", "llmMode": "api" });
245 assert_eq!(classify(true, Some(&foreign)), Listener::Foreign);
246
247 let ours =
248 serde_json::json!({ "status": "ok", "service": "firstpass", "version": "0.3.0" });
249 assert_eq!(classify(true, Some(&ours)), Listener::Firstpass);
250
251 assert_eq!(classify(false, Some(&ours)), Listener::None);
253 assert_eq!(classify(true, None), Listener::Foreign);
254 }
255
256 #[test]
257 fn a_bare_double_dash_separates_our_args_from_the_agents() {
258 let args: Vec<String> = ["claude", "--", "-p", "hi"]
259 .iter()
260 .map(|s| (*s).to_owned())
261 .collect();
262 let (name, rest) = split(&args);
263 assert_eq!(name, Some("claude"));
264 assert_eq!(rest, vec!["-p".to_owned(), "hi".to_owned()]);
265 }
266
267 #[test]
268 fn agent_args_survive_without_a_separator_too() {
269 let args: Vec<String> = ["claude", "-p", "hi"]
270 .iter()
271 .map(|s| (*s).to_owned())
272 .collect();
273 let (_, rest) = split(&args);
274 assert_eq!(rest, vec!["-p".to_owned(), "hi".to_owned()]);
275 }
276
277 #[test]
278 fn each_agent_routes_the_vendor_it_actually_speaks() {
279 let claude = AGENTS.iter().find(|a| a.name == "claude").expect("claude");
282 assert_eq!(
283 env_for(claude, "http://127.0.0.1:8080").get("ANTHROPIC_BASE_URL"),
284 Some(&"http://127.0.0.1:8080".to_owned())
285 );
286 let codex = AGENTS.iter().find(|a| a.name == "codex").expect("codex");
287 assert_eq!(
288 env_for(codex, "http://127.0.0.1:8080").get("OPENAI_BASE_URL"),
289 Some(&"http://127.0.0.1:8080".to_owned())
290 );
291 }
292}