Hosted Claude Code / Codex sessions can run on the JuCode gateway

options.jucode_gateway runs that one process through the JuCode gateway on
the user's JuCode login (Claude: private --settings file; Codex: -c
overrides and a key env var), leaving their own config alone. The daemon
remembers it per session, so a reopen from another device keeps it.

Author: gaoyu06

crates/agent-core/src/lib.rs

@@ -39,6 +39,20 @@ pub use hunks::HunkView;
 pub use session::SessionSummary;
 pub use tools::{git_diff, terminate_tool_processes};
 
+/// The JuCode gateway URL and an access token good for at least two more
+/// minutes (refreshed first when needed), for tools spawned to call the
+/// gateway on the user's JuCode login.
+pub fn jucode_gateway_credentials() -> Result<(String, String), String> {
+    let config = config::Config::load_or_create().map_err(|error| error.to_string())?;
+    let auth = oauth::ensure_session(&config.jucode_api_url, config.encrypt_secrets)?;
+    let token = auth
+        .jucode_access_token()
+        .filter(|token| !token.is_empty())
+        .ok_or("not logged in to JuCode. Run /login.")?
+        .to_string();
+    Ok((config.jucode_api_url, token))
+}
+
 /// Sessions saved for `cwd`, most recently updated first (`updated_at` in
 /// seconds).
 pub fn saved_sessions(cwd: &std::path::Path) -> std::io::Result<Vec<SessionSummary>> {

crates/daemon/src/engines/claude.rs

@@ -35,6 +35,26 @@ pub const EFFORT_LEVELS: &[&str] = &["low", "medium", "high", "xhigh", "max"];
 const DEFAULT_EFFORT: &str = "medium";
 const SUMMARY_CAP: usize = 4000;
 
+/// This session talks to the JuCode gateway: a settings file (owner-only)
+/// that overrides the endpoint and token for this process alone. An empty
+/// ANTHROPIC_API_KEY masks one the user's own settings set.
+pub fn use_gateway(command: &mut Command, api: &str, token: &str) -> Result<(), String> {
+    let api = super::gateway_url(api)?;
+    let settings = json!({ "env": {
+        "ANTHROPIC_BASE_URL": api,
+        "ANTHROPIC_AUTH_TOKEN": token,
+        "ANTHROPIC_API_KEY": "",
+    } });
+    let path = home()
+        .join(".jucode")
+        .join("daemon")
+        .join("claude-gateway.json");
+    crate::store::write_private(&path, settings.to_string().as_bytes())
+        .map_err(|error| format!("cannot write {}: {error}", path.display()))?;
+    command.arg("--settings").arg(path);
+    Ok(())
+}
+
 pub fn command(id: &str, options: &Options) -> Command {
     let program = resolve(
         "claude",

crates/daemon/src/engines/codex.rs

@@ -29,6 +29,22 @@ pub fn command() -> Command {
     command
 }
 
+/// The env var a gateway session reads its key from.
+const GATEWAY_KEY_ENV: &str = "JUCODE_GATEWAY_TOKEN";
+
+/// This session talks to the JuCode gateway: config overrides for this
+/// process alone, with the key in its environment (never in argv).
+pub fn use_gateway(command: &mut Command, api: &str, token: &str) -> Result<(), String> {
+    let api = super::gateway_url(api)?;
+    command
+        .args(["-c", "model_provider=\"jucode_gateway\"", "-c"])
+        .arg(format!(
+            "model_providers.jucode_gateway={{name=\"JuCode\",base_url=\"{api}/v1\",env_key=\"{GATEWAY_KEY_ENV}\",wire_api=\"responses\"}}"
+        ))
+        .env(GATEWAY_KEY_ENV, token);
+    Ok(())
+}
+
 fn text(value: &Value) -> &str {
     value.as_str().unwrap_or_default()
 }
@@ -1287,6 +1303,34 @@ mod tests {
         c
     }
 
+    #[test]
+    fn the_gateway_goes_to_this_process_only() {
+        let mut command = std::process::Command::new("codex");
+        use_gateway(&mut command, "https://api.jucode.net/", "tok").unwrap();
+        let args: Vec<String> = command
+            .get_args()
+            .map(|a| a.to_string_lossy().to_string())
+            .collect();
+        assert_eq!(args[1], "model_provider=\"jucode_gateway\"");
+        assert!(args[3].contains("base_url=\"https://api.jucode.net/v1\""));
+        assert!(!args.concat().contains("tok\""));
+        let env: Vec<_> = command.get_envs().collect();
+        assert_eq!(
+            env,
+            [(
+                std::ffi::OsStr::new("JUCODE_GATEWAY_TOKEN"),
+                Some(std::ffi::OsStr::new("tok"))
+            )]
+        );
+        assert!(use_gateway(&mut command, "http://api.jucode.net", "tok").is_err());
+        assert!(use_gateway(&mut command, "https://a\"b", "tok").is_err());
+        assert_eq!(
+            Options::from_json(&json!({ "jucode_gateway": true })).gateway,
+            Some(true)
+        );
+        assert_eq!(Options::from_json(&json!({})).gateway, None);
+    }
+
     #[test]
     fn skills_list_as_commands_and_review_and_skills_run() {
         let mut c = opened();

crates/daemon/src/engines/mod.rs

@@ -70,6 +70,10 @@ pub struct Options {
     pub command: Option<String>,
     pub args: Vec<String>,
     pub env: Vec<(String, String)>,
+    /// Claude / Codex: talk to the JuCode gateway on the user's JuCode login
+    /// instead of the provider in their own config (which stays untouched).
+    /// None: as the session last ran.
+    pub gateway: Option<bool>,
 }
 
 impl Options {
@@ -99,6 +103,7 @@ impl Options {
                 .flatten()
                 .filter_map(|(name, value)| Some((name.clone(), value.as_str()?.to_string())))
                 .collect(),
+            gateway: value["jucode_gateway"].as_bool(),
         }
     }
 
@@ -163,12 +168,30 @@ fn adapter(kind: Kind, cwd: &Path, options: &Options) -> Box<dyn Adapter> {
     }
 }
 
-fn command(kind: Kind, id: &str, options: &Options) -> Command {
-    match kind {
+fn command(kind: Kind, id: &str, options: &Options) -> Result<Command, String> {
+    let mut command = match kind {
         Kind::Claude => claude::command(id, options),
         Kind::Codex => codex::command(),
         Kind::Acp => acp::command(options),
+    };
+    if options.gateway == Some(true) {
+        let (api, token) = jucode_agent_core::jucode_gateway_credentials()?;
+        match kind {
+            Kind::Claude => claude::use_gateway(&mut command, &api, &token)?,
+            Kind::Codex => codex::use_gateway(&mut command, &api, &token)?,
+            Kind::Acp => return Err("an ACP agent has no JuCode gateway mode".to_string()),
+        }
+    }
+    Ok(command)
+}
+
+/// The gateway URL as it may go into a spawned tool's config.
+fn gateway_url(api: &str) -> Result<&str, String> {
+    let api = api.trim().trim_end_matches('/');
+    if !api.starts_with("https://") || api.contains(['"', '\\', '\n']) {
+        return Err(format!("invalid JuCode API URL: {api}"));
     }
+    Ok(api)
 }
 
 /// A running engine process: its stdin writer and merged output.
@@ -402,7 +425,7 @@ pub fn spawn(
     transcript: Vec<Value>,
 ) -> Result<(String, Sender<Value>, u64), String> {
     let process = Process::spawn(
-        command(kind, id.as_deref().unwrap_or_default(), &options),
+        command(kind, id.as_deref().unwrap_or_default(), &options)?,
         &cwd,
     )?;
     let (ops_tx, ops) = mpsc::channel();
@@ -521,7 +544,9 @@ impl Session<'_> {
                     next.resume = adapter.conversation().or(next.resume);
                     process.stop();
                     let id = self.id.clone().unwrap_or_default();
-                    match Process::spawn(command(self.kind, &id, &next), &self.cwd) {
+                    match command(self.kind, &id, &next)
+                        .and_then(|command| Process::spawn(command, &self.cwd))
+                    {
                         Ok(started) => {
                             process = started;
                             adapter = self::adapter(self.kind, &self.cwd, &next);

crates/daemon/src/hub.rs

@@ -266,6 +266,7 @@ impl Hub {
             return Err(format!("not a directory: {}", cwd.display()));
         }
         let agent = agent.map(str::to_string);
+        let gateway = options.gateway == Some(true);
         let (id, ops, generation) = match engine {
             None => session::spawn(Arc::clone(self), cwd.clone(), None, agent.clone())?,
             Some(kind) => {
@@ -278,7 +279,13 @@ impl Hub {
             }
         };
         self.store
-            .record_engine_session(&id, &cwd, agent.as_deref(), engine.map(engines::Kind::name))
+            .record_engine_session(
+                &id,
+                &cwd,
+                agent.as_deref(),
+                engine.map(engines::Kind::name),
+                gateway,
+            )
             .map_err(|error| error.to_string())?;
         lock(&self.untitled).insert(id.clone());
         self.host(id.clone(), ops, cwd, generation);
@@ -342,11 +349,13 @@ impl Hub {
                     archived: false,
                     hidden: false,
                     engine: engine.map(|kind| kind.name().to_string()),
+                    gateway: false,
                 }
             }
             (None, None) => return Err(format!("unknown session {id}")),
         };
         let kind = engines::Kind::parse(record.engine.as_deref().unwrap_or_default())?;
+        let mut gateway = false;
         let (ops, generation) = match kind {
             None => {
                 let (_, ops, generation) = session::spawn(
@@ -373,10 +382,13 @@ impl Hub {
                     engines::Kind::Claude => engines::claude::transcript(&record.cwd, id),
                     engines::Kind::Codex | engines::Kind::Acp => Vec::new(),
                 };
+                // A client that does not say (a phone) keeps how it last ran.
                 let options = engines::Options {
                     resume: saved.then(|| id.to_string()),
+                    gateway: Some(options.gateway.unwrap_or(record.gateway)),
                     ..options
                 };
+                gateway = options.gateway == Some(true);
                 // A new start keeps the recorded id; a resume opens it.
                 let fresh = options.resume.is_none().then(|| id.to_string());
                 let (_, ops, generation) = engines::spawn(
@@ -397,6 +409,7 @@ impl Hub {
                     &record.cwd,
                     record.agent.as_deref(),
                     record.engine.as_deref(),
+                    gateway,
                 )
                 .map_err(|error| error.to_string())?;
         }

crates/daemon/src/store.rs

@@ -44,6 +44,8 @@ pub struct SessionRecord {
     pub hidden: bool,
     /// The engine running it; None: jucode.
     pub engine: Option<String>,
+    /// Claude / Codex: it last ran through the JuCode gateway.
+    pub gateway: bool,
 }
 
 /// A message for an agent: from the user, another agent or a timer.
@@ -170,7 +172,7 @@ impl Store {
         cwd: &std::path::Path,
         agent: Option<&str>,
     ) -> io::Result<()> {
-        self.record_engine_session(id, cwd, agent, None)
+        self.record_engine_session(id, cwd, agent, None, false)
     }
 
     /// Like `record_session`, for a session run by `engine` (None: jucode).
@@ -180,6 +182,7 @@ impl Store {
         cwd: &std::path::Path,
         agent: Option<&str>,
         engine: Option<&str>,
+        gateway: bool,
     ) -> io::Result<()> {
         let mut entry = json!({
             "kind": "open", "session": id, "cwd": cwd.display().to_string(),
@@ -188,6 +191,9 @@ impl Store {
         if let Some(engine) = engine {
             entry["engine"] = json!(engine);
         }
+        if gateway {
+            entry["gateway"] = json!(true);
+        }
         self.append(SESSIONS, entry)
     }
 
@@ -276,9 +282,11 @@ impl Store {
                             archived: false,
                             hidden: false,
                             engine: entry["engine"].as_str().map(str::to_string),
+                            gateway: false,
                         }
                     });
                     record.closed = false;
+                    record.gateway = entry["gateway"] == true;
                 }
                 Some("close") => {
                     if let Some(record) = records.get_mut(id) {
@@ -761,6 +769,21 @@ mod tests {
         assert!(!store.sessions()[0].closed);
     }
 
+    #[test]
+    fn a_session_remembers_whether_it_last_ran_through_the_gateway() {
+        let store = store("gateway");
+        let cwd = std::path::Path::new("/p");
+        store
+            .record_engine_session("c", cwd, None, Some("claude"), true)
+            .unwrap();
+        assert!(store.sessions()[0].gateway);
+        store.record_session_closed("c").unwrap();
+        store
+            .record_engine_session("c", cwd, None, Some("claude"), false)
+            .unwrap();
+        assert!(!store.sessions()[0].gateway);
+    }
+
     #[test]
     fn decided_actions_are_not_open() {
         let store = store("actions");

docs/daemon-protocol.md

@@ -200,6 +200,7 @@ clients need nothing engine-specific. `options`:
 | `approval_mode` | `manual`/`read-only` (Claude's `default`), `plan`, `auto`, `auto-edit`, `full-access`/`full-auto` |
 | `model` | Model to start with |
 | `resume_at` | Claude Code: resume the conversation as it was at this assistant message uuid |
+| `jucode_gateway` | Claude Code / Codex: `true` runs this session through the JuCode gateway on the user's JuCode login; `false` on the provider in the user's own Claude Code / Codex config. The endpoint and key go to this process only (Claude: `--settings` file; Codex: `-c` overrides and an env var), never to the user's config files. Omitted on `session_open`: as the session last ran |
 | `command`, `args`, `env` | ACP: the agent's command line and extra environment variables (plain names; no `DYLD_*`/`LD_*`) |
 
 `engine: "acp"` runs an Agent Client Protocol agent (`jucode acp`,